Belangrijke punten of waar dit artikel over gaat
Het onderwerp van het artikel is visueel programmeren van PLC's ShIoTiny voor het slimme huis, dat hier wordt beschreven: .
Kort samengevat worden concepten zoals knooppunten, verbindingen, evenementen, evenals de kenmerken van het laden en uitvoeren van een visueel programma op ESP8266, dat de basis vormt voor de PLC ShIoTiny.
Inleiding of enkele organisatorische vragen
In het vorige artikel over mijn ontwikkeling heb ik een kort overzicht gegeven van de mogelijkheden van de controller ShIoTiny.
Verrassend genoeg toonde het publiek een vrij sterke belangstelling en stelde het me veel vragen. Sommige mensen boden zelfs meteen aan om de controller van me te kopen. Nee, ik ben niet tegen een beetje extra geld verdienen, maar mijn geweten staat me niet toe om een nog zeer ongepolijst product te verkopen.
Daarom heb ik de binaire firmware en het apparaat schema op GitHub geplaatst: .
Nu kan iedereen de ESP-07 flitsen en zelf met de firmware experimenteren. Als iemand precies zo'n bordje wilt als op de foto — ik heb er een paar. Stuur een e-mail shiotiny@yandex.ru. Maar zoals de onvergetelijke Ogurtsov zei: "Ik ben nergens voor verantwoordelijk!".
Laten we dan tot de kern komen: wat is een "knooppunt" (node) en "evenement"? Hoe wordt het programma uitgevoerd?
Zoals gebruikelijk beginnen we met het begin: het laden van het programma.
Hoe het programma wordt geladen
Laten we beginnen met wat er gebeurt wanneer we op de knop Uploaden in de editor ElDraw drukken en ons schema-programma, bestaande uit mooie vierkantjes, naar het apparaat wordt verzonden.
Ten eerste wordt er op basis van ons getekende schema een tekstuele beschrijving gemaakt.
Ten tweede wordt gecontroleerd of alle ingangen van de knooppunten zijn verbonden met uitgangen. Er mogen geen "hangende" ingangen zijn. Als zo'n ingang wordt gevonden, wordt het schema niet in ShIoTiny geladen en geeft de editor een passende waarschuwing.
Als alles succesvol is verlopen, stuurt de editor de tekstuele beschrijving van het schema knooppunt voor knooppunt naar ShIoTiny. Uiteraard wordt het bestaande schema in ShIoTiny eerst verwijderd. De verkregen tekstuele beschrijving wordt opgeslagen in het FLASH-geheugen.
Overigens, als je het schema uit het apparaat wilt verwijderen, laad dan gewoon een leeg schema (zonder knoop-elementen) in.
Zodra het schema-programma is geladen in de PLC ShIoTiny, begint het met 'uitvoeren'. Wat betekent dat?
Opmerking: de processen voor het laden van het schema uit het FLASH-geheugen bij het inschakelen van de voeding en het ontvangen van het schema vanuit de editor zijn identiek.
Eerst worden de objecten-knooppunten aangemaakt op basis van hun beschrijving.
Vervolgens worden de verbindingen tussen de knooppunten vastgesteld. Dat wil zeggen, de uitgangslinks worden gegenereerd naar ingangen en ingangen naar uitgangen.
Pas na dit alles wordt de hoofdcyclus van de uitvoering van het programma gestart.
Ik heb er lang over geschreven, maar het hele proces van 'laden' van het schema uit FLASH-geheugen tot het starten van de hoofdcyclus duurt enkele seconden voor een schema met 60-80 knooppunten.
Hoe werkt de hoofdcyclus? Heel eenvoudig. Eerst wacht hij op een gebeurtenis evenementen in een van de knooppunten, waarna deze gebeurtenis wordt verwerkt. En zo gaat het maar door. Of totdat er een nieuw schema in ShIoTiny wordt geladen.
Ik heb al verschillende keren dingen genoemd zoals evenementen, knooppunten en verbindingen. Maar wat betekent dit eigenlijk vanuit programmatisch perspectief? Daar zullen we het vandaag over hebben.
Knooppunten, verbindingen en gebeurtenissen
Het is voldoende om naar voorbeelden van schema-programma's voor ShIoTinyte kijken om te begrijpen dat een schema slechts uit twee entiteiten bestaat - knooppunten (of elementen) en de verbindingen tussen hen.
Knoop, knooppunt of schema-element - dit is een virtuele representatie van een bepaald acties boven de gegevens. Dit kan een wiskundige bewerking, logische bewerking of elke andere bewerking zijn die in ons opkomt. Het belangrijkste is dat elk knooppunt een ingang en uitgang heeft.
Ingang - dit is de plek waar het knooppunt gegevens ontvangt. De afbeeldingen van ingangen zijn de punten die altijd aan de linkerkant van het knooppunt bevinden.
Uitgang - dit is de plek waar het resultaat van de werking van het knooppunt wordt verkregen. De afbeeldingen van uitgangen zijn de punten die altijd aan de rechterkant van het knooppunt bevinden.
Sommige knooppunten hebben geen ingangen. Dergelijke knooppunten genereren het resultaat binnenin zichzelf. Bijvoorbeeld een constante knooppunt of een sensor knooppunt: ze hebben geen gegevens van andere knooppunten nodig om een resultaat te melden.
Andere knooppunten hebben daarentegen geen uitgangen. Dit zijn knooppunten die bijvoorbeeld uitvoerende apparaten (relais of andere dergelijke) weergeven. Ze ontvangen gegevens, maar genereren geen resultaten van berekeningen die beschikbaar zijn voor andere knooppunten.
Bovendien is er ook een uniek opmerking-knooppunt. Het doet niets, heeft geen ingangen of uitgangen. Het doel ervan is om een toelichting op het schema te zijn.
Wat isevenement»? Evenement — dit is het ontstaan van nieuwe gegevens in een knooppunt. Bijvoorbeeld, gebeurtenissen omvatten: de statusverandering van een ingang (knooppunt Invoer), het ontvangen van gegevens van een ander apparaat (knooppunten MQTT en UDP), het verstrijken van een bepaalde tijdsperiode (knooppunten Timer en Vertraging) en ga zo maar door.
Waarom zijn gebeurtenissen nodig? Om te bepalen in welk knooppunt nieuwe gegevens zijn ontstaan en welke knooppunten hun status moeten wijzigen in verband met het ontvangen van nieuwe gegevens. Een gebeurtenis 'gaat' als het ware door een keten van knooppunten totdat alle knooppunten zijn bereikt waarvan de status moet worden gecontroleerd en gewijzigd.
Alle knooppunten kunnen in twee categorieën worden onderverdeeld.
Knooppunten die gebeurtenissen kunnen genereren, noemen we 'actieve knooppunten».
Knooppunten die geen gebeurtenissen kunnen genereren, noemen we 'passieve knooppunten».
Wanneer een knooppunt een gebeurtenis genereert (dat wil zeggen, er verschijnen nieuwe gegevens aan de uitgang), verandert in het algemeen de status van de hele keten van knooppunten die zijn aangesloten op de uitgang van het knooppunt dat de gebeurtenis genereert.
Om het duidelijk te maken, laten we een voorbeeld bekijken in de afbeelding.
De actieve knooppunten hier zijn Input1, Input2 en Input3. De andere knooppunten zijn passief. Laten we kijken wat er gebeurt wanneer een van de ingangen wordt gesloten. De resultaten zijn voor de overzichtelijkheid in een tabel samengevoegd.
Zoals we zien, wordt bij het ontstaan van een gebeurtenis een keten opgebouwd van het knooppunt waar de gebeurtenis vandaan komt tot het uiteindelijke knooppunt. De status van de knooppunten die niet in de keten worden opgenomen, verandert niet.
Er rijst een legitieme vraag: wat gebeurt er als er tegelijkertijd twee of meer gebeurtenissen optreden?
Als liefhebber van de creativiteit van Gleb Anfilov, voel ik de neiging om de nieuwsgierige vrager naar zijn boek 'De vlucht van verbazing' te verwijzen. Dit is een soort 'relativiteitstheorie voor de allerkleinsten', waarin goed wordt uitgelegd wat 'tegelijkertijd' is en hoe je daarmee omgaat.
Maar praktisch gezien is alles veel eenvoudiger: wanneer er twee of meer gebeurtenissen optreden, worden alle ketens van elk gebeurtenisbron achtereenvolgens opgebouwd en verwerkt, zonder dat er wonderen plaatsvinden.
Een volkomen legitieme vraag van een nieuwsgierige lezer is: wat gebeurt er als we knooppunten in een ring verbinden? Of, zoals ze het vaak onder deze slimme mensen zeggen — een feedbackloop invoeren. Dat wil zeggen, de uitgang van een knooppunt verbinden met de ingang van het vorige knooppunt, zodat de toestand van de uitgang van dit knooppunt invloed heeft op de toestand van zijn eigen ingang. Je kunt de uitgang van een knooppunt niet rechtstreeks met zijn eigen ingang verbinden, dat staat de editor niet toe. ElDraw. Maar indirect, zoals in de onderstaande afbeelding — dat is mogelijk.
Dus, wat zal er in dit geval gebeuren? Het antwoord zal zeer "bepaald" zijn: afhankelijk van welke knooppunten. Laten we een voorbeeld bekijken in de afbeelding.
Wanneer de contacten van de ingang Input1 open zijn aan de bovenkant van knooppunt A — 0. Aan de uitgang van knooppunt A, ook 0. Aan de uitgang van knooppunt B — 1. En tot slot, aan de onderkant van knooppunt A — 1. Alles is duidelijk. Voor wie het niet duidelijk is — kijk hieronder naar de uitleg van hoe de knooppunten "EN" en "NIET" werken.
Laten we nu de contacten van ingang Input1 sluiten, dat wil zeggen, we geven een eenheid aan de bovenste ingang van knooppunt A. Degenen die bekend zijn met elektronica weten dat we feitelijk een klassieke generatorconfiguratie op logische elementen krijgen. En in theorie zou zo'n schakeling eindeloos de reeksen 1-0-1-0-1-0... en 0-1-0-1-0-1... moeten produceren. Het evenement zou constant de toestand van knooppunten A en B moeten veranderen, steeds in de cirkel 2-3-2-3...!
Maar in werkelijkheid gebeurt dit niet. De schakeling zal in een willekeurige toestand vallen — of het relais blijft ingeschakeld of uitgeschakeld, of het kan een beetje zoemen terwijl het meerdere keren achtereenvolgens in- en uitschakelt. Alles hangt af van het weer op de zuidpool van Mars. En dit is waarom dit gebeurt.
Het evenement met knooppunt Input1 verandert de toestand van knooppunt A, vervolgens knooppunt B, en zo verder in een cirkel meerdere keren. Het programma detecteert de "lus" van het evenement en stopt deze carnaval gedwongen. Na dit wordt de verandering van de toestand van knooppunten A en B geblokkeerd totdat er een nieuw evenement optreedt. Het moment waarop het programma besluit — "genoeg met draaien in cirkels!" — hangt in het algemeen af van veel factoren en kan als willekeurig worden beschouwd.
Wees voorzichtig bij het verbinden van knooppunten in een ring — de effecten zullen niet altijd voor de hand liggend zijn! Zorg ervoor dat je goed weet wat en waarom je het doet!
Is it still possible to build a generator using the nodes available to us? Yes, it is! However, a node that can generate events on its own is required. Such a node exists — it's the 'delay line.' Let's see how a generator works with a period of 6 seconds in the illustration below.
The key element of the generator is node A — the delay line. If the state of the input to the delay line changes from 0 to 1, then a 1 will not appear at the output immediately, but only after a specified time. In our case, this is 3 seconds. Similarly, if the state of the input to the delay line changes from 1 to 0, then a 0 will appear at the output after the same 3 seconds. The delay time is set in tenths of a second. So a value of 30 means — 3 seconds.
The feature of the delay line is that it generates an event after the delay time has elapsed.
Suppose that initially the output of the delay line was 0. After passing through node B — the inverter — this 0 turns into 1 and goes to the input of the delay line. Immediately, nothing happens. The output of the delay line remains 0, but the countdown of the delay time begins. Three seconds pass. And then the delay line generates an event. It outputs a 1. This unit, after passing through node B — the inverter — turns into 0 and goes to the input of the delay line. Another 3 seconds pass... and the process repeats. That is, every 3 seconds, the output state of the delay line changes from 0 to 1 and then from 1 to 0. The relay clicks. The generator works. The pulse period is 6 seconds (3 seconds at output zero and 3 seconds — one).
However, in real circuits, it is often unnecessary to use even this example. There are special timer nodes that wonderfully and without outside help generate a sequence of pulses with a given period. The duration of 'zero' and 'one' in these pulses is equal to half the period.
To set periodic actions, use timer nodes.
I would like to note that such digital signals, where the duration of 'zero' and 'one' are equal, are called 'meander.'
I hope I clarified the question about how the distribution of events between nodes occurs and what should not be done?
Conclusion and links
The article turned out to be short, but this is a response article to the questions that arose about nodes and events.
Naarmate firmware zich ontwikkelt en er nieuwe voorbeelden verschijnen, zal ik schrijven over hoe te programmeren ShIoTiny korte artikelen, zolang het interessant is voor mensen.
Zoals eerder, schema's, firmware, voorbeelden, beschrijvingen van knooppunten en alles .
Vragen, suggesties, kritiek — hierheen: shiotiny@yandex.ru
Bron: habr.com
