# Esercizio

> Le unità in uso: un nodo per unità con i pannelli e le dashboard attraverso cui si esegue, che cos'è una prova, il ciclo di vita dall'Avvio a Completata, e che cosa è rifiutato mentre il runtime è fermo.

**Esercizio** è l'ultimo dei quattro gruppi di un modello nella colonna Spazio di lavoro
della pagina Process (Process > Modelli > un modello > Esercizio), dopo
[Definizione](process-definition),
[Visualizzazione](process-visualization) e [Allestimento](process-setup). Gli altri tre
dichiarano il processo; questo contiene le unità in uso, un nodo per unità, e sotto ogni
unità le superfici attraverso cui si comanda. Qui non si configura nulla: un'unità si
dichiara e si conclude sulla pagina propria del modello ([Unità](process-units)), i suoi
pannelli e le sue dashboard si dispongono sotto Visualizzazione, e ciò che esegue si compone
sotto Allestimento.

Il ramo è disegnato per ogni ruolo che può consultare i modelli (Consultare i modelli,
Eseguire le procedure, Gestire Process). Un ruolo che possiede soltanto Modificare ricette e
valutazioni vede ogni modello ridotto al suo gruppo Allestimento, quindi Esercizio non gli è
disegnato. Sorvegliare è gratuito con l'albero; preparare, avviare e condurre una prova
richiedono **Eseguire le procedure**, e un pannello lo dice sulla propria faccia quando il
ruolo non lo ha.

## La pagina Esercizio {#the-operate-page}

Selezionare il gruppo apre un muro di riquadri, uno per unità, intitolato "Le stazioni su cui
gira questo modello. Aprirne una per preparare una procedura, avviarla e seguire una prova
registrata e valutata." Premere un riquadro apre quell'unità. Ogni riquadro porta lo stato dal
vivo dell'unità, risolto in quest'ordine di precedenza:

| Stato | Significato |
| --- | --- |
| Arresto scattato, In attesa di riarmo, Segnale di arresto non disponibile | L'[interblocco](process-automation) dell'unità non è Normale. Mostrato soltanto quando il modello osserva un fermo esterno; ha la precedenza su tutto ciò che sta sotto. |
| In attesa che i setpoint arrivino al dispositivo | Una prova possiede l'unità e la sua ricetta ha consegnato i setpoint di un segmento e aspetta che l'apparecchiatura li accolga. Il tempo proprio del segmento non ha ancora cominciato a scorrere, quindi questo ha la precedenza sugli stati qui sotto; il datalog continua a registrare sotto, esattamente come prima. Lo mostra soltanto un segmento impostato per attendere. Vedere [Ricette](process-recipes#what-a-run-does-with-it). |
| In registrazione, Sospesa, Salvataggio, In preparazione, Finalizzazione | Una prova possiede l'unità: sta campionando, è sospesa a un setpoint, sta scrivendo la propria istantanea, è riservata prima che la prova esista, oppure sta chiudendo il proprio file dopo lo stato finale. |
| Inattiva · procedura | Niente possiede l'unità e quella procedura è preparata per il prossimo Avvio. |
| Inattiva · nessuna procedura preparata | Niente possiede l'unità e niente è preparato. |

Un modello senza unità dice "Ancora nessuna unità. Aggiungerne una nella pagina del modello, nella tabella Unità." La riga
del gruppo nell'albero conta le proprie unità.

La barra di dettaglio porta i due attivatori di blocco, disegnati soltanto per un ruolo con
Eseguire le procedure. Su questa barra non sta nient'altro, perché qui non si crea e non si
elimina nulla.

| Comando | Che cosa fa | In grigio quando (situazione) | Non disegnato quando (ruolo) |
| --- | --- | --- | --- |
| Avvia tutte | Avvia ogni unità che ha una procedura preparata e che può partire adesso; le altre sono saltate in silenzio. Ogni prova avviata registra come responsabile l'operatore connesso su questa schermata. | Nessuna unità accetta adesso l'Avvio, oppure un blocco è già in distribuzione. | Senza Eseguire le procedure. |
| Arresta tutte | Arresta ogni unità che sta eseguendo adesso; le unità già ferme restano ferme. | Nessuna unità accetta adesso l'Arresto, oppure un blocco è già in distribuzione. | Senza Eseguire le procedure. |

Un blocco è un attivatore, non un'operazione coordinata: ogni unità va per conto proprio, un
rifiuto su un'unità finisce a diario e non fa mai tornare indietro un'altra, e il registro
delle azioni riporta il conteggio ("3 unità avviate", "Nessuna unità ha potuto essere
arrestata.").

## L'unità {#the-unit}

La pagina propria di un'unità la nomina, dice se una prova la possiede e apre su ciascuna
delle sue superfici. L'intestazione porta una pastiglia con lo stato della prova mentre una
prova possiede l'unità (In registrazione, Sospesa, Salvataggio, In preparazione, Finalizzazione,
oppure "In attesa che i setpoint arrivino al dispositivo" mentre un segmento di ricetta impostato
per attendere aspetta ancora i suoi setpoint; nulla mentre l'unità è libera). Mentre la prova
attende, la riga dell'intestazione lascia il posto a "Ancora in attesa di: Furnace, Pump 1", i
canali la cui apparecchiatura non ha ancora accolto il proprio setpoint, così la pagina stessa dice
perché l'orologio del segmento non è partito. Un solo riquadro, **Superfici**, elenca come tessere
i pannelli e le dashboard che il modello definisce, disegnati per questa unità. La pagina non ha
verbi di barra né menu del tasto destro: è una via d'ingresso, non un posto in cui modificare.

Sotto l'unità, l'albero contiene un nodo per pannello del modello, poi un nodo per dashboard.
I due si aprono sotto la stessa barra della scena che usa la pagina View, di nome "Modello ·
Unità · Superficie", con la pastiglia dello stato della prova accanto al nome e i due verbi
della finestra sul lato di coda: **Espandi** dà alla superficie tutta la finestra, **Schermo
intero** (F11) prende tutto lo schermo, ed Esc lascia l'uno o l'altro.

- Un nodo **pannello** disegna, per questa unità, i riquadri che il pannello dispone: il
  riquadro Prova, il riquadro Metadati, lo Stato della prova, i Commenti, le Occorrenze, il
  Grafico dei canali, il Registro di produttività, i Comandi singoli e una qualsiasi dashboard
  che il pannello incorpora come riquadro. Quella superficie, riquadro per riquadro, è
  [Prove e commenti](process-runs).
- Un nodo **dashboard** esegue l'unica definizione del modello con ogni canale astratto
  risposto dalla sorgente collegata di questa unità. Mostra la dashboard e non la modifica mai:
  modificare è un verbo della riga propria del modello sotto Visualizzazione ([Dashboard di un
  modello](process-dashboards)). Una dashboard su cui non è posato nulla lo dice invece di
  disegnare una scena vuota. I suoi componenti di comando qui hanno bisogno soltanto di
  Eseguire le procedure, perché questa è la superficie ufficiale di Process e non una dashboard
  propria della stazione.

Un pannello o una dashboard segnato **Mostra in View** compare anche sulla pagina View, una
voce per unità del modello, sotto lo stesso nome; ciò che disegna è lo stesso nei due casi.

## Che cos'è una prova {#what-a-run-is}

Una prova è un'esecuzione di una procedura su un'unità. Si chiama "Procedura · Unità", si
registra nel proprio file SQLite sotto la cartella `acquisitions` della radice dei dati
dell'applicazione, ed è indicata da una riga dell'indice degli storici, che è ciò che permette
di ritrovare e riprendere dopo un riavvio una prova non terminata. Il modo della procedura è
l'involucro della prova: **Immediato** applica, registra una riga e giudica una volta, poi
termina da sé; **Temporale** esegue la finestra della procedura, eventualmente ripetuta in
cicli, e termina quando l'ultima finestra si chiude; **Controllato** applica all'Avvio e
registra finché qualcuno non la arresta.

Una prova per unità alla volta. L'Avvio riserva l'unità prima di risolvere qualsiasi cosa,
così un'unità in preparazione è Occupata senza fingere di registrare; la riserva dura
attraverso In marcia, Sospesa, In salvataggio e la chiusura finale del file. Mentre una
qualsiasi unità è occupata, ogni superficie di configurazione della stazione è in sola lettura
("La configurazione è bloccata mentre un'unità è in esecuzione."); Esercizio stesso resta
vivo, perché esercire non è configurare.

## Il ciclo di vita {#the-lifecycle}

| Stato | Significato | Vi si entra con | Se ne esce con |
| --- | --- | --- | --- |
| In preparazione | L'unità è riservata e la prova viene convalidata e materializzata. Non è uno stato memorizzato: il punto `Procedure.Status` lo legge mentre `Busy` è già vero. | Avvio | La prova che si materializza (In marcia), oppure un rifiuto (di nuovo inattiva). |
| In marcia | Il campionamento e, per una prova Temporale, l'orologio della finestra si muovono. | Avvio, Riprendi | Sospendi, Arresta, Interrompi, la fine della finestra, un guasto, l'interblocco. |
| Sospesa | L'orologio della finestra è congelato all'ultimo setpoint; il datalog continua a registrare. Soltanto prove Temporali. | Sospendi | Riprendi, Arresta, Interrompi, l'interblocco. |
| In salvataggio | Il campionamento si è fermato; il blocco di finalizzazione è stato eseguito e l'istantanea congelata è in scrittura. | Arresta, Interrompi, la fine della finestra, l'interblocco, una prova Istantanea che si completa | La scrittura dell'istantanea. |
| Completata | Terminata pulitamente; l'esito è quello della valutazione. | In salvataggio dopo un Arresta, la fine di una finestra o una prova immediata | Finale. |
| Interrotta | Terminata in anticipo; l'esito è Non conforme qualunque cosa avesse giudicato la valutazione. | In salvataggio dopo un Interrompi, una politica di errore della ricetta impostata su Interrompi, l'interblocco, oppure l'arresto del runtime | Finale. |
| Non riuscita | Terminata da un errore irrecuperabile; l'esito è Nessuno. | Un guasto mentre eseguiva o mentre terminava; un puntatore In salvataggio lasciato indietro da un arresto anomalo torna Non riuscita al lancio successivo | Finale. |

Una prova che era In marcia o Sospesa quando l'applicazione si è chiusa non è terminata:
riprende al lancio successivo, con un profilo temporale sospeso al proprio segmento e ciclo
resi persistenti.

Ogni prova registra chi l'ha avviata (l'operatore connesso sulla schermata che ha premuto
Avvio, la stazione quando non c'era nessuno, l'automazione dell'unità, oppure un agente) e chi
l'ha terminata (gli stessi generi, per un Arresta o un Interrompi). Una finestra che si è
esaurita, uno scatto di interblocco e un guasto terminano senza nominare nessuno. Sospendi e
Riprendi non lasciano dietro alcun attore.

## Che cosa è rifiutato, e perché {#what-is-refused-and-why}

- **Runtime fermo**: mentre il runtime della stazione è fermo, Avvia, Sospendi, Riprendi,
  Arresta, Interrompi, i comandi singoli, la preparazione e i commenti sono tutti rifiutati con
  quel motivo, e il riquadro Prova lo scrive sotto i propri pulsanti. Le prove ancora aperte
  quando il runtime si ferma terminano come Interrotte.
- **L'interblocco**: mentre l'interblocco di un'unità è Scattato, In attesa di riarmo o Non
  disponibile, su quell'unità non è ammesso alcun nuovo Avvio, Riprendi, snapshot, valutazione
  o applicazione di ricetta ("L'unità 'X' è bloccata dal suo interblocco: motivo"). Arresta e
  Interrompi restano disponibili.
- **Niente preparato**: l'Avvio ha bisogno di una procedura preparata ("Nessuna procedura è
  preparata. Sceglierne una prima.").
- **Una sorgente tenuta da un'altra prova**: due unità che scrivono la stessa sorgente non
  possono eseguire insieme; il secondo Avvio è rifiutato nominando il canale e l'unità che lo
  tiene.

Le pagine di questo gruppo:

| Pagina | Copre |
| --- | --- |
| [Prove e commenti](process-runs) | Il pannello di un'unità: la preparazione, l'Avvio e che cosa convalida, i comandi del ciclo di vita, i riquadri dal vivo, i commenti, i comandi singoli, il file della prova, e le vie dell'automazione e dell'agente allo stesso ciclo di vita. |
| [Lo spazio degli indirizzi di un'unità](process-addresses) | Ogni punto che un'unità pubblica sotto `Process.<Model>.<Unit>`, il suo tipo e il suo significato, e quali punti sono comandi scrivibili. |