# Ricette

> I setpoint che una prova scrive: un insieme immediato applicato all'Avvio, oppure un profilo temporale di Gradino, Rampa e Mantenimento, ciascuno con il blocco di finalizzazione che ogni prova scrive quando finisce.

Una **ricetta** scrive i canali scrivibili del modello. Una ricetta **immediata** è un insieme di
setpoint applicati una volta sola quando una prova parte; una ricetta **temporale** è un profilo
ordinato di segmenti Gradino, Rampa e Mantenimento condotti sull'orologio proprio della prova. Tutte
e due possono terminare su un blocco di **finalizzazione**, lo stato sicuro scritto ogni volta che la
prova finisce. Ogni scrittura passa per l'[unico punto di scrittura](logic#writing-values) registrato
a diario ed è annotata nel file della prova così come è stata eseguita. Le ricette stanno sotto
Process > Modelli > modello > Allestimento > **Ricette** e richiedono il permesso **Modificare
ricette e valutazioni**.

## La cartella Ricette {#the-recipes-folder}

Selezionare la riga **Ricette** apre la pagina della cartella ("Valori di setpoint che una procedura
applica all'avvio di una prova, scritti attraverso l'unico punto di scrittura e registrati come
eseguiti.") con un riquadro per ricetta, per nome; premere un riquadro la apre e la X la
rimuove. Senza nessuna, la pagina dice "Ancora nessuna ricetta. Aggiungerne una."

| Comando | Che cosa fa | In grigio quando (situazione) | Non disegnato quando (ruolo) |
| --- | --- | --- | --- |
| **Nuova ricetta** (barra di dettaglio, cartella selezionata; tasto destro **Aggiungi una ricetta**) | Aggiunge `Ricetta <n>`: Immediata, In caso di fallimento Sospendi, nessun setpoint. La riga si aggiunge al suo gruppo, evidenziata e portata in vista lì; il suo riquadro la apre. | Una qualsiasi unità tiene una prova, oppure il runtime è fermo. | Senza Modificare ricette e valutazioni. |

## La pagina della ricetta {#the-recipes-page}

L'intestazione porta il nome, la riga "Valori di setpoint che una procedura applica all'avvio di una
prova, scritti attraverso l'unico punto di scrittura e registrati come eseguiti." e una
pastiglia con la natura. Ogni campo si salva da solo, e ogni modifica ridisegna l'anteprima del
profilo.

### Definizione {#definition}

| Campo | Che cos'è | Valori / predefinito | Effetto |
| --- | --- | --- | --- |
| **Nome** | Come si chiama la ricetta nell'albero, nel selettore Ricetta di una procedura e nel selettore Applica una ricetta di un pannello. | Testo libero; `Ricetta <n>` alla creazione. | Rinomina la riga. |
| **Natura** | La forma della ricetta. | **Immediata** (predefinita): un insieme di setpoint applicati una volta all'Avvio. **Temporale**: un profilo ordinato di Gradino / Rampa / Mantenimento sul proprio orologio. | Commuta la pagina fra le due forme qui sotto. I setpoint e i segmenti già inseriti si conservano; è disegnata soltanto la forma che la natura legge. Il blocco conservato non è né applicato né riservato: una prova scrive e blocca soltanto ciò che scrive la natura in vigore. Una procedura ammette soltanto una ricetta la cui natura si accorda con il suo modo. |
| **In caso di fallimento** (solo temporale) | Che cosa fa il profilo quando una scrittura fallisce o un valore che gli serve non è leggibile. | **Sospendi** (predefinito), **Continua**, **Interrompi**; vedi la tabella sotto la forma temporale. | La regola della ricetta; ogni segmento può scavalcarla. |
| **Note** | Testo libero per chi legge la ricetta. | Su più righe; vuoto per impostazione predefinita. | Nient'altro. |

### Valori {#values}

I setpoint e i bersagli si scrivono come testo e si interpretano nel tipo del canale quando vengono
applicati, nella cultura invariante:

| Tipo del canale | Valori letterali accettati |
| --- | --- |
| Booleano | `true`, `false`, `1`, `0` |
| Intero | Un numero intero, mai con `.` come separatore |
| Decimale | Un numero con `.` come separatore decimale (`12.5`, `1e-3`); su una stazione che scrive i decimali con la virgola il campo accetta anche `12,5` e lo conserva come `12.5` |
| Testo | Qualsiasi testo, così come è scritto |
| Data e ora | Una data e un'ora complete (`2026-09-02T14:30:00+00:00`) |

Un valore letterale che non si accorda con il tipo del canale non viene mai scritto: la scrittura è
annotata come fallita nel file della prova ed è gestita dalla regola di fallimento. Ogni tabella di
righe di canale di questa pagina offre a una riga soltanto i canali scrivibili che le altre righe
della stessa tabella non hanno preso, così un canale è scritto una volta per insieme e una volta per
segmento; quando ogni canale scrivibile è preso, il pulsante che aggiunge una riga passa in grigio
con "Ogni canale scrivibile ha già un setpoint qui." (oppure "… un bersaglio in questo segmento."), e
senza alcun canale scrivibile con "Questo modello non ha ancora canali scrivibili."

## Una ricetta immediata {#an-instant-recipe}

Due riquadri indipendenti, ciascuno intestato da un pulsante **Setpoint** che aggiunge
una riga sul primo canale scrivibile libero con il valore `0`:

| Riquadro | Che cosa scrive |
| --- | --- |
| **Setpoint (applicati all'avvio)** | Scritti una volta, all'Avvio, prima che la prova registri qualsiasi cosa. |
| **Finalizzazione (stato sicuro)** | "Scritta ogni volta che la prova finisce: completamento, arresto o interruzione." |

Le due tabelle condividono le stesse colonne:

| Colonna | Che cos'è | Valori |
| --- | --- | --- |
| **Canale** | Il canale scrivibile che viene scritto, come `Ch<number> · <name>`. | I canali di Sola scrittura e di Lettura e scrittura non ancora presi in questa tabella. |
| **Valore** | Il valore letterale scritto. | Vedi Valori. |
| Comando di riga | **Rimuovi** chiede "Elimina il setpoint": il nome del canale, "Questo rimuove il setpoint dalla ricetta." | |

## Una ricetta temporale {#a-temporal-recipe}

La forma temporale disegna prima il profilo, poi i segmenti accanto a quello scelto fra essi, poi il
blocco di finalizzazione.

### Profilo temporale {#temporal-profile}

Il grafico è la ricetta stessa: una serie per canale numerico verso cui i segmenti portano,
etichettata `<name> [<unit>]`, disegnata come la curva a tratti che i segmenti costruiscono (un
Gradino salta e poi tiene, una Rampa sale dal valore che le arriva, un Mantenimento o un segmento
senza bersagli tiene), sul tempo cumulato in secondi. Un bersaglio su un canale non numerico non
viene disegnato. Il grafico porta la barra degli strumenti che ogni grafico ha e si può aprire in una
finestra tutta sua (vedi [Grafici](view-charts)); la pagina della procedura disegna lo stesso profilo
sotto il proprio passo Applica.

### Segmenti {#segments}

L'elenco è intitolato **Segmenti** e il suo pulsante **Segmento** aggiunge un Gradino di 60000 ms
senza bersagli e lo sceglie. Premere una riga la apre nella colonna **Bersagli del segmento**; senza
niente di scelto la colonna dice "Selezionare un segmento per modificarlo tutto in un unico posto,
con i bersagli verso cui porta."

| Colonna | Che cos'è | Valori / predefinito |
| --- | --- | --- |
| **Natura** | La forma che il segmento mette sul profilo; ogni opzione porta quella forma accanto al proprio nome. | **Gradino** (predefinito), **Rampa**, **Mantenimento**. |
| **Durata (ms)** | Quanto la ricetta resta nel segmento prima di passare al successivo. | Un numero di millisecondi; 60000 alla creazione. Il campo non accetta un numero negativo: l'inserimento viene rifiutato, la nota sotto il campo lo dice, e il valore precedente torna. |
| **Conteggio del tempo** | Quando questo segmento comincia a contare il proprio tempo: una volta che l'apparecchiatura ha accolto i setpoint, oppure nel momento in cui vengono consegnati. | **Attendere che arrivino al dispositivo** · **Inviare e proseguire**. Un Gradino nasce in attesa, una Rampa nasce inviando; cambiare la **Natura** del segmento rimette il valore di nascita della nuova natura, e ciò che si sceglie dopo resta. Un Mantenimento non scrive nulla, quindi la sua cella è vuota e non c'è nulla da scegliere. |
| **In caso di fallimento** | Se un fallimento qui segue la regola della ricetta oppure una propria di questo segmento. | **(ricetta)** (predefinito: eredita), **Sospendi**, **Continua**, **Interrompi**. |
| **Bersagli** | Verso che cosa porta il segmento, su una riga sola: `<canale> = <valore>, …`. Un Mantenimento non porta verso nulla, quindi si legge vuoto. | In sola lettura; si modificano nella colonna. |
| Comando di riga | **Rimuovi** chiede "Elimina il segmento": `Segmento <n> · <Natura>`, "Questo rimuove il segmento e i suoi bersagli dalla ricetta." | |

| Natura del segmento | Che cosa fa |
| --- | --- |
| **Gradino** | Scrive i propri bersagli all'inizio del segmento, poi rimane per la durata (un Gradino può rimanere 0 ms). |
| **Rampa** | Porta ogni canale con bersaglio linearmente dall'ultimo valore comandato (o dal suo valore attuale quando non è ancora stato comandato nulla) fino al bersaglio, lungo la durata. Una rampa porta il suo canale tra due letture, quindi il suo selettore di bersaglio offre solo i canali che contengono un numero: un canale di testo o di data e ora resta nell'elenco senza poter essere scelto, dicendo che un gradino lo scrive una sola volta. |
| **Mantenimento** | Tiene per la durata gli ultimi valori comandati; non scrive nulla e non porta alcun bersaglio. |

La colonna, intestata `Segmento <n> · <Natura>`, ripete gli stessi campi con una didascalia e l'effetto
del valore in vigore sotto ciascuno:

| Campo | Didascalia | Effetto |
| --- | --- | --- |
| **Natura** | La forma accanto a ogni opzione. | |
| **Durata (ms)** | "Quanto la ricetta resta in questo segmento prima di passare al successivo." | "Dura 1 min e 30 s." ("nessun tempo" per 0). |
| **Conteggio del tempo** | "Quando questo segmento inizia a contare il proprio tempo." | "Il tempo scorre solo dopo che i setpoint sono arrivati al dispositivo; un rifiuto o un tempo scaduto attiva la regola di guasto." oppure "Invia e conta il tempo; ciò che il dispositivo risponde viene soltanto registrato." |
| **In caso di fallimento** | "Se un fallimento qui viene gestito come dice la ricetta, oppure in un altro modo che questo singolo segmento chiede." | "Segue la ricetta: Sospendi." oppure "Questo segmento prevale sulla ricetta: Interrompi." |

Il conteggio del tempo è una proprietà del segmento e di nient'altro sopra di esso: non esiste un
campo valido per tutta la ricetta, perché un profilo i cui segmenti contano in modi diversi è un
profilo legittimo e un solo interruttore sopra il tutto sarebbe solo un secondo posto in cui dire la
stessa cosa. Non è nemmeno un'impostazione di fallimento. Ciò che decide è l'orologio; ciò che fa un
fallimento lo decide la regola **In caso di fallimento**, qui sotto. Su un Mantenimento il campo non
viene disegnato affatto.

Sotto di essi, **BERSAGLI** contiene i bersagli del segmento, con un pulsante **Bersaglio** nella
testata della colonna che aggiunge una riga sul primo canale scrivibile verso cui il segmento non
porta ancora, a `0`. Su un Mantenimento la tabella è sostituita dalla riga "Un mantenimento tiene i
valori che il profilo ha già raggiunto, quindi non porta alcun bersaglio proprio." e il pulsante è in
grigio, con "Un mantenimento tiene i valori già raggiunti. Cambiare la natura per portare qui un
bersaglio."; i bersagli che un Mantenimento si porta dietro da una natura precedente restano
conservati e sono ignorati dalla prova, dall'anteprima del profilo e dal foglio di viaggio allo
stesso modo:

| Colonna | Che cos'è |
| --- | --- |
| **Canale** | Il canale scrivibile verso cui si porta, offerto soltanto fra i canali che gli altri bersagli di questo segmento non hanno preso. |
| **Bersaglio** | Il valore letterale scritto (Gradino) oppure raggiunto (Rampa). |
| Comando di riga | **Rimuovi** chiede "Elimina il bersaglio": il nome del canale, "Questo rimuove il bersaglio dal segmento." |

### In caso di fallimento {#on-failure}

La regola di fallimento vale per una ricetta temporale quando una scrittura è rifiutata oppure un
valore che le serve non è leggibile:

| Regola | Che cosa fa la prova |
| --- | --- |
| **Sospendi** | Congela il profilo all'ultimo setpoint e aspetta che l'operatore Riprenda o Interrompa. Il datalog continua a registrare. |
| **Continua** | Annota il fallimento così come è avvenuto e prosegue; il canale fallito è saltato per il resto del segmento. |
| **Interrompi** | Scrive il blocco di finalizzazione e termina la prova come interrotta. |

La regola risponde per un fallimento di cui la ricetta **viene a sapere**, e ciò che la ricetta sa
dipende dal fatto che sia rimasta ad ascoltare la risposta. Un problema che vede prima di inviare
qualcosa è sapere in entrambi i modi; un rifiuto o un silenzio dell'apparecchiatura è sapere soltanto
dove il segmento lo ha aspettato:

| Che cosa la ricetta viene a sapere, e quando | Attendere che arrivino al dispositivo | Inviare e proseguire |
| --- | --- | --- |
| Prima dell'invio: il canale non è collegato, il valore non va bene per il tipo del canale, il tag non è nel runtime, un'altra prova tiene il tag, il dispositivo è già noto come disconnesso | La regola vale. | La regola vale lo stesso: la ricetta lo sapeva prima di lasciar andare. |
| L'apparecchiatura rifiuta il valore sul filo | La regola vale. | Qui non è un fallimento: annotato come eseguito con il motivo, e messo a diario. |
| L'apparecchiatura non risponde in tempo | La regola vale. | Qui non è un fallimento: annotato. |
| Un setpoint che una scrittura più recente sullo stesso bersaglio ha superato prima dell'invio | Non è un fallimento. | Non è un fallimento. |

Un setpoint superato non è mai un fallimento in nessuno dei due modi: il valore più recente per quel
bersaglio è quello che l'apparecchiatura riceve, ed è quello che conta. Una rampa funziona così di
proposito, e ogni battito sostituisce quello precedente che non ha ancora lasciato la coda del
dispositivo.

### Finalizzazione (stato sicuro) {#finalization-safe-state}

Lo stesso riquadro di una ricetta immediata, "Scritta ogni volta che la prova finisce: completamento,
arresto o interruzione.", con il proprio pulsante **Setpoint** e la propria tabella.

## Dove si usa una ricetta {#where-a-recipe-is-used}

| Superficie | Che cosa fa con la ricetta |
| --- | --- |
| Il passo **Applica** di una procedura | Il selettore offre ogni ricetta del modello; una ricetta la cui natura non si accorda con il modo della procedura è elencata come "`<nome>` (incompatibile)", disabilitata, con il motivo come suggerimento. Una procedura Immediata o Controllata prende una ricetta immediata oppure nessuna; una Temporale prende una ricetta temporale oppure nessuna, e il suo profilo deve stare dentro la finestra. La riga del passo dice che cosa scrive la scelta: "Scrive 4 setpoint all'avvio.", "Scrive 4 setpoint all'avvio e 2 setpoint in uscita.", "Percorre 3 segmenti in 2 min e 30 s e scrive 2 setpoint in uscita." oppure "Non viene scritto alcun setpoint." Vedi [Procedure](process-procedures). |
| Il riquadro **Comandi singoli** di un pannello | **Applica una ricetta** scrive una volta i setpoint di una ricetta immediata, fuori da ogni prova, attraverso l'unico punto di scrittura registrato a diario e sotto un blocco di breve durata; non si crea alcun file di prova, il diario è l'annotazione. Sono offerte soltanto ricette immediate. Vedi [Pannelli](process-panels#the-card-catalogue). |

## Che cosa ne fa una prova {#what-a-run-does-with-it}

All'Avvio la prova prende possesso di ogni sorgente che la ricetta scrive per tutta la propria
durata, quindi un Avvio la cui ricetta scrive una sorgente tenuta da un'altra prova è rifiutato per
nome, e ogni scrittura che venga da altrove (un campo di dashboard, uno script, un client OPC UA)
verso quelle sorgenti è rifiutata mentre la prova le possiede. Un insieme immediato è scritto una
volta all'Avvio; un profilo temporale è percorso segmento per segmento sull'orologio della prova, e
una procedura Temporale senza ricetta riceve comunque quell'orologio, così ogni membro della finestra
parte, si ripete e finisce insieme agli altri. Sospendi congela l'orologio e Riprendi lo libera; il
datalog continua a registrare attraverso una sospensione. Ogni scrittura va a diario con la prova
come sorgente ed è annotata nel file della prova così come è stata eseguita, così chi legge dopo vede
che cosa è stato scritto davvero, e quando.

Un segmento, l'insieme immediato e il blocco di finalizzazione consegnano **tutti i propri setpoint
in una volta sola**, e da lì ciascuno va alla coda del proprio dispositivo. Una stazione i cui quattro
canali stanno su quattro dispositivi paga quindi il dispositivo più lento una volta, non la somma dei
quattro, e la logica stessa non aspetta nessuno di loro.

Che cosa faccia il segmento dopo lo decide il **Conteggio del tempo**. Con **Attendere che arrivino al
dispositivo** l'orologio proprio del segmento non parte finché ogni setpoint non è stato accolto dalla
propria apparecchiatura: mentre questo avviene l'unità legge "In attesa che i setpoint arrivino al
dispositivo" sulla parete di [Esercizio](process-operate#the-operate-page), la durata del segmento non
ha cominciato a scorrere, e il datalog registra per tutto il tempo. Con **Inviare e proseguire**
l'orologio parte nel momento in cui i setpoint vengono consegnati, e le risposte che arrivano dopo
vengono annotate e nient'altro.

La ricetta immediata all'Avvio e il blocco di finalizzazione aspettano sempre, senza campo e senza
scelta: una prova non deve cominciare prima che il suo stato iniziale sia reale, e non deve essere
dichiarata chiusa prima che lo sia il suo stato sicuro. I loro rifiuti sono annotati come eseguiti e,
come sempre, non interrompono mai la prova.

Il blocco di finalizzazione è scritto ogni volta che la prova **finisce**: completamento, Arresta o
Interrompi. Non è scritto quando è l'applicazione stessa a chiudersi a metà prova: la prova non sta
finendo, e riprende sospesa al proprio segmento e ciclo resi persistenti al lancio successivo.

## Rimuovi la ricetta {#remove-recipe}

**Rimuovi la ricetta** sta nel gruppo di pericolo della barra di dettaglio con la ricetta
selezionata, nel suo menu del tasto destro e come X sul riquadro della pagina della cartella. Chiede
prima ("Elimina la ricetta", "Questo rimuove la ricetta dal modello."). Ogni procedura che la
applicava svuota il proprio riferimento Ricetta e diventa una prova senza ricetta. Richiede
Modificare ricette e valutazioni ed è in grigio sotto il blocco di progettazione e con il runtime
fermo.

## Che cosa non fa una ricetta {#what-a-recipe-does-not-do}

- Non legge nulla e non giudica nulla: i limiti sono una [valutazione](process-evaluations).
- Non scrive valori per unità. Ogni unità riceve gli stessi valori letterali sulle sorgenti a cui è
  collegata.
- Non ritenta mai una scrittura rifiutata; la regola di fallimento è tutta la risposta.
- Una ricetta temporale non si può lanciare come comando singolo; soltanto una procedura percorre un
  profilo.
- L'anteprima del profilo disegna soltanto i canali numerici; un bersaglio Booleano o Testo è scritto ma
  non è mai disegnato.