Principali tesi o di cosa tratta questo articolo
Il tema dell'articolo è la programmazione visiva PLC ShIoTiny per la casa intelligente, descritta qui: .
Molto brevemente sono stati considerati i concetti di nodi, connessioni, eventi, così come le caratteristiche di caricamento e esecuzione di un programma visivo su ESP8266, che è la base del PLC ShIoTiny.
Introduzione o un paio di domande organizzative
Nell'articolo precedente riguardo al mio sviluppo, ho fatto una breve panoramica delle capacità del controller ShIoTiny.
Stranamente, il pubblico ha mostrato un notevole interesse e mi ha posto molte domande. Alcuni amici hanno persino subito offerto di acquistare il controller. No, non ho nulla in contrario a guadagnare un po', ma la coscienza non mi permette di vendere qualcosa che è ancora molto grezzo dal punto di vista software.
Quindi ho caricato su GitHub i binari del firmware e lo schema del dispositivo: .
Ora chiunque può programmare l'ESP-07 e divertirsi con il firmware. Se qualcuno desidera davvero un tale modulo come in foto, ne ho alcuni. Scrivimi via email shiotiny@yandex.ru. Ma, come diceva l'indimenticabile Ogurcov: «Non mi prendo la responsabilità per niente!».
Quindi, andiamo al nocciolo della questione: che cos'è «nodo» (nodo) e «evento«? Come viene eseguito il programma?
Come al solito, iniziamo in ordine: con il caricamento del programma.
Come si carica il programma
Iniziamo con ciò che accade quando premiamo il pulsante Upload nell'editor ElDraw e il nostro schema-programma, composto da bellissimi quadrati, viene inviato al dispositivo.
Innanzitutto, sulla base dello schema che abbiamo disegnato, viene costruita una sua descrizione in forma testuale.
In secondo luogo, viene verificato che tutti gli ingressi dei nodi siano collegati alle uscite. Non devono esserci ingressi «sospesi». Se viene trovato un ingresso di questo tipo, lo schema non verrà caricato su 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 viene prima eliminato. La descrizione testuale ottenuta viene memorizzata nella memoria FLASH.
A proposito, se desideri eliminare lo schema dal dispositivo, carica semplicemente uno schema vuoto (che non contiene alcun elemento-nodo).
Non appena l'intero schema-programma viene caricato nel PLC ShIoTiny, inizia a «eseguire». Cosa significa questo?
È importante notare che i processi di caricamento dello schema dalla memoria FLASH all'accensione e di ricezione dello schema dall'editor sono identici.
Inizialmente si crea oggetti-nodi sulla base della loro descrizione.
Successivamente, vengono stabiliti i collegamenti tra i nodi. In altre parole, vengono generate le connessioni tra le uscite e le entrate e viceversa.
E solo dopo tutto questo, si avvia il ciclo principale di esecuzione del programma.
Ho scritto a lungo, ma l'intero processo - da «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 semplicemente. Innanzitutto, aspetta l'insorgere di eventi in un nodo qualsiasi, quindi elabora questo evento. E così senza fine. O fino a quando non viene caricato un nuovo schema nel ShIoTiny.
Ho già menzionato più volte cose come eventi, nodi e connessioni. Ma cosa significa questo dal punto di vista programmatico? Di questo parleremo oggi.
Nodi, collegamenti ed eventi
Basta dare un'occhiata agli esempi di schemi-programma per ShIoTiny, per capire che uno schema è composto da sole due entità: nodi (o elementi) e collegamenti tra di essi.
Nodo, nodo o elemento dello schema è una rappresentazione virtuale di qualche azioni sopra i dati. Può trattarsi di un'operazione aritmetica, di un'operazione logica o di qualsiasi altra operazione ci venga in mente. La cosa principale è che un nodo ha un ingresso e un'uscita.
Ingresso è il posto dove il nodo riceve i dati. Le immagini delle entrate sono punti che si trovano sempre sul lato sinistro del nodo.
Uscita è il posto da cui viene estratto il risultato dell'attività del nodo. Le immagini delle uscite sono punti che si trovano sempre sul lato destro del nodo.
Alcuni nodi non hanno ingressi. Questi nodi generano un risultato al loro interno. Ad esempio, un nodo-costante o un nodo-sensore: non necessitano di dati da altri nodi per comunicare un risultato.
Al contrario, altri nodi non hanno uscite. Sono nodi che rappresentano, ad esempio, dispositivi attuatori (relè o simili). Ricevono dati, ma non generano risultati di calcolo accessibili ad 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.
Cosa è "evento»? Evento — è l'emergere di nuovi dati in un nodo. Ad esempio, gli eventi includono: la modifica dello stato di un ingresso (nodo Input), ricezione di dati da un altro dispositivo (nodi MQTT e UDP), scadenza di un intervallo di tempo specificato (nodi Timer e Delay) e così via.
A cosa servono gli eventi? Sì, per determinare in quale nodo sono emersi nuovi dati e quali stati dei nodi devono essere modificati in relazione alla ricezione di nuovi dati. Un evento, così dire, «passa» attraverso la catena di nodi, finché non attraversa tutti i nodi di cui è necessario controllare e modificare lo stato.
Tutti i nodi possono essere suddivisi in due categorie.
I nodi che possono generare eventi li chiameremo «nodi attivi».
I nodi che non possono generare eventi li chiameremo «nodi passivi».
Quando un nodo genera un evento (cioè quando appaiono nuovi dati in output), in generale cambia lo stato dell'intera catena di nodi collegati all'uscita 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. Vediamo cosa succede quando si chiude un ingresso o l'altro. I risultati sono stati riassunti in una tabella per comodità.
Come possiamo vedere, al verificarsi di 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 la domanda legittima: cosa succede quando ci sono due o più eventi contemporaneamente?
Come amante delle opere di Gleb Anfilov, sento il bisogno di rimandare il curioso interrogante al suo libro «Fuga dalle meraviglie». È una sorta di «teoria della relatività per i più piccoli», in cui viene spiegato cosa significhi «contemporaneamente» e come vivere con questo.
Ma, in termini pratici, è molto più semplice: al verificarsi di due o più eventi, tutte le catene da ciascuna sorgente dell'evento vengono costruite e elaborate in sequenza, senza alcun miracolo.
La seguente domanda del lettore curioso è del tutto legittima: cosa succede se colleghiamo i nodi in un anello? Oppure, come si suole dire tra questi esperti, stabiliamo un feedback. Ossia, collegare l'uscita di un nodo all'ingresso del nodo precedente in modo che lo stato dell'uscita di quel nodo influenzi lo stato del suo stesso ingresso. Non puoi collegare direttamente l'uscita di un nodo al suo ingresso ElDraw. Ma indirettamente, come illustrato nell'immagine qui sotto, è possibile farlo.
E così, cosa succede in questo caso? La risposta sarà molto "definita": dipende dai nodi. Consideriamo l'esempio nell'immagine.
Quando i contatti dell'ingresso Input1 sono aperti sul nodo A — 0. Sull'uscita del nodo A, anch'essa 0. Sull'uscita del nodo B — 1. E, infine, sull'ingresso inferiore del nodo A — 1. È tutto chiaro. E chi non lo capisce, può consultare qui sotto la descrizione di come funzionano i nodi "E" e "NON".
Ora chiudiamo i contatti dell'ingresso Input1, cioè applichiamo 1 all'ingresso superiore del nodo A. Coloro che sono familiari con l'elettronica sanno che ciò che otterremo in realtà è uno schema classico di un generatore basato su elementi logici. E per principio, tale schema dovrebbe produrre infinite sequenze in uscita dai nodi A e B: 1-0-1-0-1-0... e 0-1-0-1-0-1-.... Infatti, l'evento dovrebbe costantemente cambiare lo stato dei nodi A e B, avanzando in cerchio 2-3-2-3-...!
Ma in realtà non è così. Lo schema entra in uno stato casuale: o il relè rimarrà acceso o spento, oppure può emettere un leggero ronzio accendendosi e spegnendosi più volte di seguito. Tutto dipende dalle condizioni meteorologiche al polo sud di Marte. Ecco perché accade questo.
L'evento nel nodo Input1 altera lo stato del nodo A, poi del nodo B e così via in cerchio varie volte. Il programma riconosce il "ciclo" dell'evento e interrompe forzatamente questo carnevale. Dopo ciò, la modifica dello stato dei nodi A e B viene bloccata fino a un nuovo evento. Il momento in cui il programma decide che "è ora di smettere di girare in tondo!" dipende in generale da molti fattori e può essere considerato casuale.
Fai attenzione quando colleghi i nodi in un anello: gli effetti potrebbero non essere sempre evidenti! Assicurati di comprendere cosa e perché stai facendo!
È possibile costruire un generatore sui nodi a nostra disposizione? Sì, è possibile! Ma per farlo è necessario un nodo in grado di generare eventi. E quel nodo esiste: è la 'linea di ritardo'. Vediamo come funziona un generatore con un periodo di 6 secondi nell'immagine sottostante.
L'elemento chiave del generatore è il nodo A - la linea di ritardo. Se si modifica lo stato dell'input della linea di ritardo da 0 a 1, il 1 non apparirà subito in uscita, ma solo dopo un certo intervallo di tempo. Nel nostro caso, sono 3 secondi. Allo stesso modo, se si cambia lo stato dell'input della linea di ritardo da 1 a 0, lo 0 in uscita apparirà dopo gli stessi 3 secondi. Il tempo di ritardo è impostato in decimi di secondo. Quindi, il valore 30 significa 3 secondi.
Una caratteristica della linea di ritardo è che genera un evento dopo la scadenza del tempo di ritardo.
Supponiamo che inizialmente in uscita dalla linea di ritardo ci fosse 0. Dopo aver attraversato il nodo B - l'inverter - questo 0 si trasforma in 1 e va all'ingresso della linea di ritardo. All'inizio non succede nulla. In uscita dalla linea di ritardo rimane 0, ma inizia il conteggio del tempo di ritardo. Passano 3 secondi. E subito la linea di ritardo genera un evento. In uscita ottiene 1. Questo 1, dopo aver attraversato il nodo B - l'inverter - si trasforma in 0 e va all'ingresso della linea di ritardo. Passano altri 3 secondi... e il processo si ripete. Quindi, ogni 3 secondi lo stato dell'uscita dalla 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 in uscita a 0 e 3 secondi a 1).
Tuttavia, negli schemi reali, non è solitamente necessario utilizzare neanche questo esempio. Esistono nodi timer speciali che generano magnificamente e senza assistenza esterna una sequenza di impulsi con un periodo stabilito. La durata degli '0' e '1' in questi impulsi è pari alla metà del periodo.
Per programmare azioni periodiche, utilizzare i nodi timer.
Vale la pena notare che tali segnali digitali, in cui la durata di '0' e '1' è uguale, sono chiamati 'meandro'.
Spero di aver chiarito un po' la questione su come avviene la propagazione degli eventi tra i nodi e su cosa non bisognerebbe fare.
Conclusione e riferimenti
L'articolo è risultato breve, ma è una risposta alle domande sorte riguardo ai nodi e agli eventi.
Con lo sviluppo di nuovi firmware e l'emergere di nuovi esempi, scriverò su come programmare ShIoTiny articoli brevi, finché sarà interessante per le persone.
Come in precedenza, schema, firmware, esempi, descrizione dei nodi e tutto .
Domande, suggerimenti, critiche — qui: shiotiny@yandex.ru
Fonte: habr.com
