Punti principali o di cosa parla questo articolo
Il tema dell'articolo è la programmazione visuale PLC ShIoTiny per la casa intelligente descritta qui: .
Molto brevemente sono stati trattati concetti come nodi, connessioni, eventi, così come le caratteristiche di caricamento ed esecuzione del programma visuale su ESP8266, che è la base del PLC ShIoTiny.
Introduzione o un paio di domande generali
Nel precedente articolo riguardo il mio sviluppo, ho fornito una breve panoramica delle capacità del controllore ShIoTiny.
Stranamente, il pubblico ha mostrato un interessante interesse e mi ha posto molte domande. Alcuni hanno persino subito proposto di acquistare il controllore da me. No, non sono contrario a guadagnare qualcosa, ma la mia coscienza non mi permette di vendere una cosa ancora molto grezza dal punto di vista software.
Quindi ho caricato su GitHub i binari del firmware e lo schema del dispositivo: .
Ora chiunque può caricare l’ESP-07 e sperimentare personalmente con il firmware. Se a qualcuno interessa davvero una scheda come quella in foto — ne ho un paio. Scrivetemi via email shiotiny@yandex.ru. Ma, come diceva il memorabile Ogurtsov: «Non mi prendo alcuna responsabilità!»
Quindi, andiamo al sodo: cos'è un «nodo» (node) e «evento«? Come viene eseguito il programma?
Come al solito, iniziamo in ordine: dal caricamento del programma.
Come viene caricato il programma
Iniziamo da cosa succede quando premiamo il bottone Carica nell'editor ElDraw e il nostro schema-programma, composto da bellissimi quadrati, viene inviato al dispositivo.
In primo luogo, sulla base dello schema disegnato, viene costruita una sua descrizione in formato testuale.
In secondo luogo, si verifica se tutti gli ingressi dei nodi sono collegati alle uscite. Non devono esserci ingressi "sospesi". Se viene trovato un ingresso del genere, lo schema non verrà caricato in ShIoTiny e l'editor mostrerà un avviso corrispondente.
Se tutto è andato a buon fine, l'editor invia a ShIoTiny la descrizione testuale dello schema nodo per nodo. Naturalmente, lo schema esistente in ShIoTiny verrà precedentemente eliminato. La descrizione testuale ottenuta viene salvata nella memoria FLASH.
A proposito, se desideri eliminare lo schema dal dispositivo, basta caricare uno schema vuoto (che non contenga alcun elemento-nodo).
Non appena l'intero schema-programma è caricato nel PLC ShIoTiny, inizia a "eseguire". Cosa significa?
Va notato che i processi di caricamento dello schema dalla memoria FLASH all'accensione e di ricezione dello schema dall'editor sono identici.
In primo luogo, si procede alla creazione di oggetti-nodo basati sulla loro descrizione.
Successivamente, si stabiliscono le connessioni tra i nodi. In altre parole, vengono generate le relazioni tra uscite e ingressi.
E solo dopo tutto ciò inizia il ciclo principale di esecuzione del programma.
Ho scritto a lungo, ma l'intero processo, dal "caricamento" dello schema dalla memoria FLASH all'avvio del ciclo principale, richiede frazioni di secondo per uno schema di 60-80 nodi.
Come funziona il ciclo principale? Molto semplice. Prima attende l'insorgere eventi in un nodo qualsiasi, poi elabora questo evento. E così via all'infinito. O fino a quando non viene caricato un nuovo schema in ShIoTiny.
Ho già menzionato diverse volte cose come eventi, nodi e connessioni. Ma cosa sono esattamente da un punto di vista programmatico? Di questo parleremo oggi.
Nodi, connessioni ed eventi
Basta dare un'occhiata agli esempi di schemi-programma per ShIoTiny, per capire che uno schema è composto solo da due entità: nodi (o elementi) e connessioni tra di loro.
Nodo, nodo o elemento dello schema — è una rappresentazione virtuale di qualche azione sui dati. Può essere un'operazione aritmetica, un'operazione logica o qualsiasi tipo di operazione che ci venga in mente. L'importante è che il nodo abbia un ingresso e un'uscita.
Accesso — è il luogo dove il nodo riceve i dati. Le immagini delle entrate sono i punti che si trovano sempre sul lato sinistro del nodo.
Uscita — è il luogo da cui viene estratto il risultato del lavoro del nodo. Le immagini delle uscite sono i punti che si trovano sempre sul lato destro del nodo.
Alcuni nodi non hanno ingressi. Tali nodi generano un risultato al loro interno. Ad esempio, un nodo costante o un nodo sensore: non hanno bisogno di dati da altri nodi per fornire un risultato.
Altri nodi, al contrario, non hanno uscite. Questi nodi rappresentano, ad esempio, dispositivi esecutivi (relè o simili). Ricevono dati, ma non generano risultati delle elaborazioni disponibili per altri nodi.
Inoltre, c'è un nodo commento unico. Non fa nulla, non ha né ingressi né uscite. Il suo scopo è essere un chiarimento nello schema.
Che cos'è «evento»? Evento — è la generazione di nuovi dati in un nodo. Ad esempio, gli eventi includono: la modifica dello stato dell'ingresso (nodo Ingresso), la ricezione di dati da un altro dispositivo (nodi MQTT e UDP), il trascorrere di un intervallo di tempo specificato (nodi Timer e Delay) e così via.
A cosa servono gli eventi? Servono a determinare in quale nodo siano emersi nuovi dati e quali stati dei nodi debbano essere modificati in base alla ricezione di nuovi dati. L'evento, in un certo senso, ‘passa’ attraverso la catena di nodi finché non esplora tutti i nodi il cui stato deve essere verificato e modificato.
Tutti i nodi possono essere suddivisi in due categorie.
I nodi che possono generare eventi saranno chiamati «nodi attivi».
. I nodi che non possono generare eventi saranno chiamati «nodi passivi».
. Quando un nodo genera un evento (ovvero, quando emergono nuovi dati dal suo output), di norma cambia lo stato dell'intera catena di nodi connessi all'output del nodo generatore dell'evento.
Per chiarire, consideriamo un esempio nell'immagine.
I nodi attivi qui sono – Input1, Input2 e Input3. Gli altri nodi sono passivi. Analizziamo cosa succede quando viene chiuso uno di questi ingressi. I risultati sono riassunti in una tabella per comodità.
Come possiamo vedere, quando si verifica un evento, si costruisce una catena dal nodo sorgente dell'evento fino al nodo finale. Lo stato dei nodi che non rientrano nella catena non cambia.
Sorge una legittima domanda: cosa succede se si verificano due eventi o addirittura più eventi contemporaneamente?
Essendo un amante delle creazioni di Gleb Anfilov, mi viene voglia di indirizzare il curioso interrogante al suo libro «Fuga dalle meraviglie». È una sorta di «teoria della relatività per i più piccoli», dove viene spiegato bene cosa significa «contemporaneamente» e come viverci.
Ma in pratica è tutto molto più semplice: quando si verificano due o più eventi, si costruiscono e si elaborano in sequenza tutte le catene da ogni sorgente dell'evento a turno, senza alcun miracolo.
La domanda successiva, assolutamente legittima, di un lettore curioso è: cosa succede se si collegano i nodi in un anello? O, come si dice tra questi intelligenti, introdurre un feedback. Cioè, collegare l'uscita di un nodo all'ingresso del nodo precedente, in modo che lo stato dell'uscita influisca sullo stato del suo stesso ingresso. Non potrete collegare direttamente l'uscita di un nodo al suo ingresso. ElDrawMa in modo indiretto, come mostrato nell'immagine qui sotto, è possibile farlo.
Allora, cosa succede in questo caso? La risposta sarà molto "definita": dipende da quali nodi. Consideriamo un esempio nell'immagine.
Quando i contatti dell'ingresso Input1 sono aperti sul terminale superiore del nodo A, l'uscita del nodo A è 0. L'uscita del nodo B è 1. Infine, sull'ingresso inferiore del nodo A, è 1. Tutto chiaro. E per chi non è chiaro, date un'occhiata alla descrizione di come funzionano i nodi "E" e "NON" qui sotto.
Ora colleghiamo i contatti dell'ingresso Input1, ossia forniremo un'unità all'ingresso superiore del nodo A. Chi è familiare con l'elettronica sa che otterremo effettivamente un classico schema di generatore su elementi logici. E in teoria, questo schema dovrebbe produrre all'infinito sequenze 1-0-1-0-1-0… e 0-1-0-1-0-1-… in uscita dai nodi A e B. Infatti, l'evento dovrebbe continuamente cambiare lo stato dei nodi A e B, seguendo il ciclo 2-3-2-3…!
Ma in realtà ciò non accade. Lo schema entrerà in uno stato casuale — o il relè rimarrà attivato o disattivato, oppure potrebbe pulsare leggermente accendendosi e spegnendosi diverse volte di fila. Tutto dipende dal tempo al polo sud di Marte. Ed ecco perché succede ciò.
L'evento dal nodo Input1 cambia lo stato del nodo A, poi quello del nodo B e così via per diverse volte in cerchio. Il programma riconosce il 'ciclo' dell'evento e termina forzatamente questo carnevale. Dopo di che, la modifica dello stato dei nodi A e B viene bloccata fino a quando non si verifica un nuovo evento. Il momento in cui il programma deciderà — 'basta girare in tondo!' — dipende in genere da molti fattori e può essere considerato casuale.
Fai attenzione a collegare i nodi in un anello: gli effetti non saranno sempre evidenti! Assicurati di avere ben chiaro cosa e perché stai facendo!
È possibile costruire un generatore con i nodi a nostra disposizione? Sì, è possibile! Ma per questo è necessario un nodo che possa generare eventi. E quel nodo esiste: è la «linea di ritardo». Vediamo come funziona il generatore con un periodo di 6 secondi nell'immagine sottostante.
L'elemento chiave del generatore è il nodo A — la linea di ritardo. Se si cambia lo stato dell'ingresso della linea di ritardo da 0 a 1, il valore 1 in uscita non apparirà immediatamente, ma solo dopo un tempo prestabilito. Nel nostro caso, sono 3 secondi. Allo stesso modo, se si cambia lo stato dell'ingresso della linea di ritardo da 1 a 0, il valore 0 in uscita apparirà dopo gli stessi 3 secondi. Il tempo di ritardo è definito in decimi di secondo, quindi un valore di 30 significa 3 secondi.
La caratteristica della linea di ritardo è che genera un evento dopo il decorso del tempo di ritardo.
Supponiamo che inizialmente l'uscita della linea di ritardo fosse 0. Dopo il passaggio attraverso il nodo B — l'invertitore — questo 0 si trasforma in 1 e arriva all'ingresso della linea di ritardo. Inizialmente, non succede nulla. All'uscita della linea di ritardo rimane 0, ma inizia il conteggio del tempo di ritardo. Passano 3 secondi. In quel momento la linea di ritardo genera un evento. Sull'uscita appare 1. Questa unità, dopo il passaggio attraverso il nodo B — l'invertitore — si trasforma in 0 e arriva all'ingresso della linea di ritardo. Passano altri 3 secondi… e il processo si ripete. Cioè, ogni 3 secondi lo stato dell'uscita della linea di ritardo cambia da 0 a 1 e poi da 1 a 0. Il relè scatta. Il generatore funziona. Il periodo degli impulsi è di 6 secondi (3 secondi di uscita zero e 3 secondi di uno).
Tuttavia, negli schemi reali, di solito non è necessario utilizzare nemmeno questo esempio. Esistono nodi timer speciali che generano magnificamente e senza aiuto esterno sequenze di impulsi con un periodo prestabilito. La durata di 'zero' e 'uno' in questi impulsi è pari alla metà del periodo.
Per impostare azioni periodiche, utilizzare nodi timer.
Voglio sottolineare che i segnali digitali in cui la durata di 'zero' e 'uno' sono uguali sono chiamati 'meandro'.
Spero di aver chiarito un po' la questione su come avviene la diffusione degli eventi tra i nodi e cosa non bisogna fare.
Conclusione e link
L'articolo è breve, ma è una risposta alle domande emerse sui nodi e sugli eventi.
Man mano che le versioni del firmware evolvono e nuovi esempi appaiono, scriverò su come programmare ShIoTiny piccoli articoli, fintanto che ciò interesserà le persone.
Come in precedenza, schema, firmware, esempi, descrizione dei nodi e tutto .
Domande, suggerimenti, critiche — questo è il posto: shiotiny@yandex.ru
Fonte: habr.com
