Generic serial and TCP

Apparecchiature che parlano un protocollo proprio fatto di testo o di byte, come bilance e lettori di codici a barre, su una linea seriale, in TCP o in UDP: come finiscono e si verificano i loro messaggi, e come ogni tag ne ricava il valore.

Il driver Generic serial and TCP legge e scrive apparecchiature che parlano un protocollo proprio, fatto di testo o di byte semplici, dove nessun protocollo standard si applica: una bilancia, un lettore di codici a barre o RFID, uno strumento datato, una stampante di etichette. A un'apparecchiatura così non si può chiedere che cosa sia, quindi non si rileva nulla. Spetta all'operatore dire al dispositivo come finisce un messaggio che invia e come si verifica il suo checksum, e a dire a ogni tag come ottiene il valore, quali messaggi sono suoi e quali caratteri del messaggio sono il valore.

Un dispositivo raggiunge la sua apparecchiatura in uno di tre modi, scelto quando viene creato:

Un dispositivo su una linea seriale sta sotto la sua linea, così quella parte dell'albero si legge Driver → Linea → Dispositivo → Tag, come sotto Modbus RTU. Un dispositivo di rete sta sotto il driver e può essere archiviato in cartelle come il dispositivo di qualsiasi altro driver, Driver → Cartella → Dispositivo → Tag. Un dispositivo resta dalla parte in cui è stato creato: TCP e UDP si scambiano, ma un dispositivo non passa mai da una linea alla rete né dalla rete a una linea.

La pagina del driver

La frase sotto l'intestazione dice « Le linee seriali portano gli strumenti che condividono un bus, e i dispositivi di rete stanno sotto il driver. Aggiungere una linea o un dispositivo, poi aprirlo per descriverne i messaggi. » e la pagina porta due tabelle, una sotto l'altra:

L'intestazione conta i dispositivi tra parentesi, e la riga del driver nell'albero conta i due livelli appena esiste una linea (« 1 linea · 2 dispositivi »). La barra del driver non ha Rileva. Il clic destro sulla riga del driver offre Aggiungi dispositivo, Aggiungi linea, Nuova cartella e Aggiorna, poi, dopo un separatore, Rimuovi driver; nel menu Nuovo… della colonna la voce del driver offre Nuovo dispositivo, Nuova linea seriale e Nuova cartella, poi le sue linee, cartelle e dispositivi. Una volta aggiunto, il driver sta sotto la cartella Driver dell'albero, con o senza linea o dispositivo.

Linea seriale

Una linea di questo driver è la linea descritta in Linee seriali, con meno campi. La sua pagina dice « Un solo bus seriale fisico: le impostazioni della porta condivise dai suoi strumenti, una richiesta alla volta. » e la sua scheda Linea fisica porta:

Una linea creata qui parte disabilitata, così le impostazioni della porta si digitano prima che la porta si apra. La porta, la velocità e il formato cambiano solo con la linea disabilitata; il nome cambia in qualsiasi momento. Una linea di questo driver non ha modalità di trasmissione, timeout di risposta, intervallo minimo tra le transazioni né silenzio automatico: ogni dispositivo che porta indica nel proprio pannello come finiscono i suoi messaggi e quanto attende una risposta, come dice la scheda Dispositivi sotto la linea: « Tutti i dispositivi di questa linea ne condividono le impostazioni della porta. Ciascuno indica nel proprio pannello come finiscono i suoi messaggi e quanto attende una risposta. » Non ha la scheda Rileva unità e la sua tabella Dispositivi non ha la colonna ID unità, perché uno strumento si riconosce da ciò che dicono le sue richieste, non da un indirizzo.

Aggiungi dispositivo sulla linea, o nel suo menu del clic destro, crea un dispositivo di questo driver su quella linea. Una linea appartiene per sempre al driver sotto cui è stata creata: un dispositivo Modbus RTU e un dispositivo di questo driver non condividono mai una linea, e un agente che collega un dispositivo a una linea dell'altro driver viene rifiutato. Gli stati della linea (Spenta, Inattiva, Connessione…, Connessa, Guasto della porta) sono quelli di ogni linea seriale, in Abilitazione e stato di salute.

Sulla linea, il driver apre la porta una volta per tutti i dispositivi che porta e invia una richiesta alla volta, aspettando la risposta prima della successiva. Tra una richiesta e l'altra, ciò che arriva viene offerto a ogni dispositivo della linea, e ciascuno lo divide in messaggi secondo le proprie regole. Una porta che si guasta viene riaperta dalla linea per tutti i suoi dispositivi, con un'attesa che si allunga tra un tentativo e l'altro finché continua a guastarsi.

Dispositivo

Connessione

Un nuovo dispositivo TCP dice « Indirizzo host non ancora inserito » e non viene collegato finché non ha un host e una porta. Un dispositivo con un host e senza porta, e un dispositivo UDP senza la sua porta locale, non si possono salvare: « Indicare la porta: quella del dispositivo via TCP, la porta locale di ascolto via UDP. » Un dispositivo su una linea non ha host, porta, cartella né ID unità.

La Base URI che l'intestazione mostra è l'indirizzo di esecuzione: generic://tcp/<host>:<port>, generic://udp/<local port> (con from=<sender> quando Accetta da è compilato) o generic://serial/<line id>/<port>/<baud>/<format>, seguita da come i messaggi finiscono e si verificano (end, start, terminator, length, gap, timeout, checksum e il resto). I byte che porta sono byte, mai la notazione in cui il dispositivo viene scritto. La copia di un dispositivo su una linea resta su quella linea; la copia di un dispositivo di rete va al livello del driver.

La scheda Messaggi

Sotto la scheda Connessione, la scheda Messaggi dice come si scrivono i byte e come finisce un messaggio.

Un campo che la fine scelta non legge non viene mostrato e conserva il suo valore per quando quella fine ritorna. Un valore con cui il dispositivo non può lavorare non viene salvato, e il registro delle azioni dice perché, ad esempio « Indicare il terminatore con cui finiscono i messaggi, ad esempio \r\n. » o « La lunghezza del messaggio deve essere compresa tra 1 e 1024 byte. »

La scheda Somma di controllo

Tutti i campi tranne l'algoritmo compaiono solo dopo che si è scelto un checksum. Il checksum copre il messaggio dal primo byte al byte che precede il checksum, tranne i byte esclusi. Un messaggio il cui checksum non corrisponde non viene mai letto come valore: viene scartato, e il diario tecnico lo segnala sotto il dispositivo al massimo una volta al minuto. Il checksum viene solo verificato: le richieste e le scritture partono esattamente come sono state digitate, quindi una richiesta che ha bisogno di un checksum lo porta nei propri byte.

Indirizzamento del tag

Un tag di questo driver non ha un indirizzo da digitare: la sua scheda Sorgente chiede come ottiene il valore, nei campi qui sotto. I byte si digitano nella notazione del dispositivo.

I caratteri si contano dall'inizio del messaggio, marcatore di inizio compreso; il terminatore, il checksum e i byte che il checksum esclude subito prima non fanno parte di ciò che un tag legge. Un pattern è un'espressione regolare .NET, e un messaggio che richiede più di 250 ms per essere letto non viene letto. Un tag di sola scrittura non ha campi di richiesta, filtro o valore; un tag senza messaggio di scrittura è di sola lettura.

I tipi di dati sono Boolean, Int32, Int64, Float, Double e String. Il testo ritagliato viene letto nel tipo del tag prima che le fasi del tag stesso lo convertano, come per ogni driver (vedi La catena di conversione): un Boolean legge 1, true, on o yes e 0, false, off o no; un intero legge un numero intero (12.0 si legge 12, 12.5 viene rifiutato); un Float o un Double legge un numero decimale; uno String prende i caratteri così come sono. Gli spazi attorno a un numero, e tra il segno e le cifre, vengono ignorati, perché gli indicatori riempiono i loro numeri di spazi. Un tag i cui campi non possono funzionare non viene salvato, e la pagina del tag dice che cosa gli manca, ad esempio « Indicare la richiesta che questo tag invia. » o « Il pattern deve avere esattamente un gruppo di cattura, attorno al valore. »

L'anteprima in sola lettura dell'indirizzo di bus mostra ask o listen seguito da ciò che si applica, ad esempio listen?extract=position&start=5&length=6, o ask?send=01RD%0D&extract=field&separator=,&field=3 per un tag che invia 01RD e un CR e legge il terzo campo separato da virgole della risposta.

Lettura

I messaggi che non rispondono a nessuna richiesta passano ai tag in ascolto dello stesso dispositivo, quindi un dispositivo può avere entrambi i tipi di tag. I tag in ascolto con lo stesso filtro condividono ciò che è stato sentito, e possono prendere campi diversi dallo stesso messaggio.

Scrittura

Una scrittura passa per lo stesso imbuto di quella di qualsiasi altro driver: la casella di scrittura riceve il valore ingegneristico, e le fasi di conversione vengono invertite prima di inviare il valore grezzo (vedi Connector).

Le scritture aspettano il loro turno nella coda del dispositivo come quelle di ogni driver: su una linea condividono la richiesta alla volta della linea, in TCP la connessione propria del dispositivo. Un dispositivo UDP non invia nulla, quindi i suoi tag non si possono scrivere.

Esempio: una bilancia su RS-232

Un indicatore nello stile dell'uscita continua Toledo invia, molte volte al secondo, uno STX, tre byte di stato, sei cifre di peso, sei di tara, un CR e un byte di checksum. Sulla stazione:

1. Aggiungi linea sulla pagina del driver; chiamarla Scale line, scegliere COM3, lasciare Velocità (baud) a 9600 e scegliere 7E1 come Formato seriale, poi Abilita la linea.
2. Aggiungi dispositivo sulla linea; chiamarlo Scale. Nella scheda Messaggi lasciare Testo con sequenze di escape e Terminatore, impostare il Terminatore a \r, il Marcatore di inizio a \x02 e il Tempo massimo senza messaggi (s) a 10, così un cavo staccato si vede come comunicazione persa.
3. Nella scheda Somma di controllo scegliere Complemento a due della somma a 7 bit (Toledo), Byte grezzi e Dopo il terminatore, con entrambi i conteggi di byte esclusi a 0.
4. Aggiungi tag; chiamarlo Weight, Double, di sola lettura. Nella scheda Sorgente scegliere Ascolto, Ogni messaggio e Posizione fissa, con Primo carattere 5 e Lunghezza 6: lo STX è il carattere 1, i tre byte di stato vanno dal 2 al 4, il peso dal 5 al 10.
5. Le cifre non hanno il punto decimale, quindi la fase Scalatura del tag lo mette al suo posto, ad esempio un fattore di 0,01 per un indicatore impostato su due decimali.

Un agente fa lo stesso con tre chiamate di strumento:

serial_line_upsert driver=GenericSerialTcp name="Scale line" serialPort=COM3 baudRate=9600 serialFormat=7E1
device_upsert driver=GenericSerialTcp name=Scale transport=SerialLine serialLineId=<id> messageEnd=Terminator terminator=\r startMarker=\x02 checksum=SumTwosComplement7Bit checksumFormat=Raw checksumPlacement=AfterEnd silenceTimeoutSeconds=10
tag_upsert device=Scale name=Weight opcUaType=Double tagMode=Listen valueExtraction=FixedPosition valueStart=5 valueLength=6

Esempio: un lettore di codici a barre su TCP

Un lettore di codici a barre con porta Ethernet invia un codice per riga, e solo quando ne legge uno:

1. Aggiungi dispositivo sulla pagina del driver; chiamarlo Reader, lasciare Client TCP, e inserire Indirizzo host 192.168.0.40 e Porta 2001.
2. Nella scheda Messaggi lasciare Testo con sequenze di escape, Terminatore \r\n e Tempo massimo senza messaggi (s) a 0: un lettore che non invia nulla per un'ora non è guasto. Lasciare Nessuno nella scheda Somma di controllo.
3. Aggiungi tag; chiamarlo Code, String, di sola lettura. Nella scheda Sorgente scegliere Ascolto, Ogni messaggio e L'intero messaggio.

Lo stesso con gli strumenti dell'agente:

device_upsert driver=GenericSerialTcp name=Reader transport=TcpClient host=192.168.0.40 port=2001 messageEnd=Terminator terminator=\r\n
tag_upsert device=Reader name=Code opcUaType=String tagMode=Listen valueExtraction=WholeMessage

driver_capabilities descrive questo driver sotto genericSerialTcp, con questi due esempi, e serial_line_upsert crea una linea di questo driver con driver=GenericSerialTcp; gli altri strumenti sono in Gli strumenti, area per area.

Limiti da conoscere

• Non si rileva nulla: non c'è un protocollo per chiedere a un'apparecchiatura così che cosa sia o che cosa contenga.
• Una trama binaria che annuncia la propria lunghezza in un'intestazione non viene letta; un messaggio finisce con un terminatore, una lunghezza fissa, un silenzio o un datagramma.
• Il checksum viene solo verificato: nessun checksum viene aggiunto a ciò che la stazione invia.
• Un tag ricava un valore da un messaggio, come testo letto nel suo tipo; i numeri impacchettati come interi o virgola mobile binari dentro il messaggio non vengono decodificati.
• Un dispositivo UDP si limita ad ascoltare: non invia richieste e non accetta scritture.
• Un dispositivo non si può spostare tra una linea seriale e la rete, né su un'altra linea: lo si crea dove deve stare e si elimina quello vecchio.