# Simulated

> Segnali sintetici interni all'applicazione, per provare, addestrare e costruire dashboard senza hardware.

Il driver Simulated produce segnali sintetici dentro l'applicazione, senza alcuna
apparecchiatura e senza alcuna rete di mezzo. È un driver di prima classe, non una
scorciatoia: i suoi dispositivi vengono messi in servizio, interrogati e conservati
in cache lungo esattamente lo stesso percorso di runtime dell'hardware vero, quindi
i grafici, i tipi di dato, gli indicatori di qualità e il comportamento delle
scritture funzionano tutti come funzionerebbero sul campo. Usalo per provare il
modello del [Connector](connector), per costruire dashboard prima che
l'apparecchiatura arrivi, oppure per preparare una dimostrazione.

## Dispositivo {#device}

Un dispositivo simulato non ha campi di connessione: solo il suo nome e
l'**Intervallo di interrogazione (ms)** predefinito (1000 all'inizio). Il suo URI di
base è `simulated://<device>`; il segmento del dispositivo è solo informativo,
perché ogni comportamento vive nei tag.

## Rilevamento {#discovery}

**Rileva** non ha bisogno di alcun bersaglio ed elenca il catalogo incorporato: una
istanza pronta da aggiungere per ogni archetipo, tag compresi. Si toglie la spunta ai
canali che non servono prima di aggiungere.

| Modello | Istanza | Canali |
| --- | --- | --- |
| Universal Controller | UC-01 | ProcessValue (sinusoide), SetPoint (setpoint scrivibile, predefinito 50), Output (rampa), RunStatus (Run/Stop/Pause/Fault) |
| Electrical Power Meter | PM-01 | Voltage, Current, ActivePower e Frequency (cammini casuali intorno a 230, 10, 2300 e 60, interrogati ogni 250 ms), PowerFactor (sinusoide) |
| Production Counter | CNT-01 | Count (contatore Int32), Rate (cammino casuale intorno a 100), Running (booleano che commuta) |
| Status Panel | STS-01 | State (Run/Stop/Pause/Fault), Alarm (booleano che commuta), Uptime (contatore Int64) |
| Type Showcase | SHOW-01 | Un canale per ogni tipo incorporato OPC UA, quindici in tutto: utile per esercitare ogni forma di visualizzazione del valore |

Un dispositivo aggiunto dal catalogo recupera dalla sua stessa pagina un canale che è stato tolto: **Rileva tag**, nell'intestazione della sua scheda **Tag**, elenca i canali del suo modello per cui non ha ancora un tag. Un dispositivo creato a mano non nomina alcun modello e non mostra Rileva tag (vedere [Rilevare i tag di un dispositivo](connector-discovery#discovering-a-devices-tags)).

## Tag {#tags}

Un tag simulato non ha alcun indirizzo da scrivere: il nome del tag è il punto. Sono
disponibili tutti i tipi di dato incorporati OPC UA e tutte e tre le modalità di
accesso. Quello che il tag produce si sceglie con **Tipo di segnale** sulla scheda
Sorgente; il selettore offre solo le forme compatibili con il tipo di dato del tag, e
cambiare il tipo di dato riporta una forma incompatibile su un valore predefinito
ragionevole. A un tag il cui accesso consente la scrittura vengono offerte solo le
forme che accettano una scrittura, Setpoint mantenuto e Impulso, e cambiare l'accesso
riporta la forma allo stesso modo.

| Tipo di segnale | Che cosa produce | Tipi compatibili | Scrivibile |
| --- | --- | --- | --- |
| **Sinusoide** | Un'onda regolare con una leggera increspatura, generata a partire dal nome del tag, così tag con nomi diversi si muovono in modo diverso e un riavvio riproduce la stessa curva | numerici | no |
| **Rampa** | Un'onda triangolare (in salita, poi in discesa), con periodo da 10 a 59 s generato dal nome del tag | numerici | no |
| **Cammino casuale** | Il rumore realistico di uno strumento: passi a partire dall'ultimo valore con ritorno verso il valore predefinito (50 quando non è impostato), con passo pari all'1% del centro (almeno 0,5) | numerici | no |
| **Contatore** | Un intero che cresce in modo monotono: parte dal valore predefinito (0 quando non è impostato) e aggiunge 1 a ogni lettura, quindi la velocità segue l'intervallo di interrogazione | numerici | no |
| **Commutazione booleana** | Un booleano che si alterna ogni secondo | Boolean | no |
| **Testo enumerato** | Una stringa che percorre un elenco fisso di stati, un passo ogni 3 s | String | no |
| **Orologio** | L'ora corrente, campionata a ogni lettura | DateTime | no |
| **GUID casuale** | Un nuovo Guid casuale a ogni lettura | Guid | no |
| **Byte casuali** | Un payload casuale di 8 byte a ogni lettura | ByteString | no |
| **Setpoint mantenuto** | Mantiene un valore predefinito finché non viene scritto; una scrittura sostituisce quello che ogni lettura successiva risponde | qualunque | sì |
| **Impulso** | Un punto momentaneo: riposa su una linea di base, e una scrittura tiene il valore scritto per un numero dichiarato di secondi prima di ricadere da sé | qualunque | sì |

Un tag creato senza un tipo esplicito riceve un valore predefinito vivace: i tag
scrivibili diventano **Setpoint mantenuto** (così le scritture restano), e i tag in
sola lettura ricevono un generatore adatto al tipo (numerico → Sinusoide, Boolean →
Commutazione booleana, String → Testo enumerato, DateTime → Orologio, Guid →
GUID casuale, ByteString → Byte casuali). **Impulso** non è mai un valore
predefinito: un punto che restituisce un valore scritto e poi lo abbandona è una
scelta deliberata.
Fa eccezione un tag in sola lettura il cui indirizzo dichiara un valore `default` (per esempio `?default=true`): diventa anch'esso **Setpoint mantenuto** e risponde quel valore, perché un generatore lo ignorerebbe.

### I parametri nel pannello {#parameters-in-the-panel}

Due parametri si modificano direttamente sulla scheda Sorgente:

| Campo | Mostrato per | Significato |
| --- | --- | --- |
| **Valore predefinito** | Cammino casuale, Contatore, Setpoint mantenuto | Il centro del cammino, il valore di partenza del contatore, oppure la risposta del setpoint finché non viene scritto qualcosa. Il campo si adatta al tipo del tag (casella di spunta per Boolean, campo di data per DateTime, testo altrimenti). |
| **Stati** | Testo enumerato | L'elenco separato da punto e virgola da percorrere, per esempio `Run;Stop;Pause`. Un elenco vuoto o senza voci ricade su `Run;Stop;Pause`. |

### I parametri avanzati del segnale {#advanced-signal-parameters}

Gli altri parametri di forma viaggiano come argomenti di query nell'indirizzo
memorizzato del tag (per esempio `ProcessValue?min=20&max=80&period=30`). Il pannello
non li modifica ma li conserva a ogni modifica; gli esempi seminati li usano, e un
agente li può impostare con gli strumenti dei tag sulla superficie [agente](agent).

| Argomento | Si applica a | Significato | Quando manca |
| --- | --- | --- | --- |
| `min`, `max` | Sinusoide | La banda in cui l'onda scorre; l'uscita viene riportata dentro di essa | Una banda generata dal nome del tag (ampiezza da 10 a 49 attorno a uno scostamento da 20 a 49), senza limitazione |
| `period` | Sinusoide | Il periodo dell'onda in secondi | Una frequenza generata dal nome del tag (da 0,05 a 0,24 Hz) |
| `phase` | Sinusoide | Lo scostamento di fase in gradi | Generato dal nome del tag |
| `default` | Cammino casuale, Contatore, Setpoint mantenuto | Lo stesso valore che il campo Valore predefinito del pannello modifica | 50 / 0 / predefinito del tipo |
| `values` | Testo enumerato | Lo stesso elenco che il campo Stati del pannello modifica | `Run;Stop;Pause` |
| `baseline` | Impulso | Il valore su cui il punto riposa tra un episodio e l'altro, letto secondo il tipo del tag | Il valore zero del tipo (l'ora corrente per DateTime, vuoto per String) |
| `hold` | Impulso | Quanti secondi dura un episodio scritto | 10 s |
| `warmup` | qualunque | I secondi dopo la connessione prima che la prima lettura risponda, come uno strumento che deve stabilizzarsi; il ciclo di interrogazione assorbe l'attesa | nessuno |
| `outage` | qualunque | I secondi alla fine di ogni ciclo in cui il punto fallisce le sue letture, come un dispositivo che smette di rispondere; gli altri tag del dispositivo continuano a rispondere e le scritture arrivano comunque | nessuno |
| `outageEvery` | qualunque | Quanti secondi dura un ciclo di interruzione, contati dalla connessione: il punto risponde all'inizio di ogni ciclo e fallisce negli ultimi `outage` secondi, e un'interruzione lunga quanto il suo ciclo lo lascia in errore | 60 s |

Un `outage` mostra cosa fa un tag quando il suo dispositivo non risponde, senza alcuna apparecchiatura: `?outage=5&outageEvery=30` risponde per 25 s, fallisce le letture per 5 s e ricomincia. Il tag applica la politica che ha scelto, come descrive [Il dispositivo non ha risposto](connector-value-pipeline#the-device-did-not-answer), e la lettura fallita indica come causa l'interruzione dichiarata.

## Scritture {#writes}

- **Setpoint mantenuto** accetta le scritture e da quel momento risponde con il
  valore scritto. Il valore mantenuto vive in memoria per tutto il tempo in cui il
  dispositivo resta connesso; non viene salvato nella configurazione, quindi
  disabilitare il dispositivo o riavviare l'applicazione riporta il punto al suo
  valore predefinito.
- **Impulso** prende una scrittura come un episodio: risponde con il valore scritto
  finché il mantenimento non finisce, poi ricade sulla sua linea di base. Una seconda
  scrittura durante un episodio lo sostituisce per intero, quindi tenere premuto un
  pulsante fa ripartire il mantenimento invece di sommarne due.
- Ogni altro tipo rifiuta le scritture; un tentativo di scrittura viene registrato nel
  diario una volta per tag, invece di inondare il diario a ogni interrogazione.

Come per qualunque driver, il campo di scrittura prende il valore ingegneristico e la
[catena di conversione](connector-value-pipeline) viene percorsa all'indietro prima che il valore grezzo raggiunga il segnale.

## Limiti da conoscere {#limits-worth-knowing}

- I valori vengono sintetizzati per ogni esecuzione. Le forme deterministiche
  (Sinusoide, Rampa, Orologio) riproducono la stessa curva dopo un riavvio; quelle con
  stato (Contatore, Cammino casuale, Setpoint mantenuto, Impulso) ricominciano da capo.
- Accoppiare un tipo di segnale con un tipo di dato incompatibile (possibile solo
  attraverso una configurazione programmatica; il pannello vincola il selettore) fa
  fallire al tag ogni lettura, con un avviso registrato una volta nel diario.