FLProg + Nextion HMI. Lektion 2



In der letzten Lektion habe ich über das Nextion HMI-Panel und über das Erstellen von Projekten für dieses Panel im Nextion Editor gesprochen.
In diesem Tutorial zeige ich Ihnen, wie Sie dieses Panel mit dem FLProg-Programm von einem Arduino-Board aus steuern. Nehmen wir zum Beispiel die einfachste Wetterstation, die Daten vom Temperatur- und Feuchtigkeitssensor DHT-22 liest und auf dem Bedienfeld anzeigt. Ein Diagramm der Änderungen dieser Parameter wird ebenfalls gezeichnet. Die Helligkeit der Hintergrundbeleuchtung des Bedienfeldbildschirms wird mithilfe eines variablen Widerstands geändert.

Prüfstandslayout.


Zuerst müssen Sie das Projekt in das Panel hochladen (die Projektdatei im Archiv ist ein Link, zu dem am Ende des Artikels Lesson2.hmi steht).
Dieses Projekt besteht aus drei Bildschirmen.
Der erste Bildschirm dient zur Anzeige der Temperatur (Seite “Seite0” Index - 0).



Es besteht aus folgenden Elementen:
1 - Bild mit dem Bild eines Alkoholthermometers.
2 - Das Element "Fortschrittsbalken". Mit seiner Hilfe wird das Thermometer simuliert.

Elementeinstellungen.


Ich empfehle die Elemente, mit denen geplant ist, immer global über UART zu machen (das Attribut "vccope" ist auf "global" gesetzt) ​​und ihnen im gesamten Projekt dementsprechend eindeutige Namen zuzuweisen (das Attribut "objname"). Dies beschleunigt die Arbeit des Arduino-Controllers und reduziert den Code dafür. Ich werde erklären warum.
Wenn Sie versuchen, das Attribut eines lokalen Elements zu schreiben, müssen Sie zuerst die aktuelle Seite vom Bedienfeld anfordern (dies ist eine separate Anforderung, die mindestens 20 ms dauert). Wenn die Seite diejenige ist, zu der das Element gehört, wird der Wert an das Panel gesendet. Wenn nicht, wird der zum Senden bestimmte Wert in die Variable geschrieben (für die derselbe Speicherplatz benötigt wird). Wenn Sie zu einer Seite mit einem Element wechseln, müssen Sie deren Attribute sofort mit den neuesten Istwerten aktualisieren, da beim Rendern einer Seite lokale Variablen mit den Werten initialisiert werden, die beim Erstellen des Projekts angegeben wurden. Wenn auf der Seite viele vom Controller verwaltete Elemente vorhanden sind, ist dieser Controller beim Umschalten lange Zeit mit der Aktualisierung aller Elemente beschäftigt.
Für ein globales Element ist alles viel einfacher. Sie können jederzeit Attributwerte dafür aufzeichnen, und die letzten Werte werden beim Rendern der Seite verwendet. Dies bedeutet, dass Sie vor dem Senden keine Seitenzahl anfordern und keine Änderungen vornehmen müssen, um den Wert zu speichern.
Aber natürlich hängt alles vom Projekt ab. Wenn das Projekt für das Panel sehr groß ist und nicht genügend Platz für globale Elemente vorhanden ist, können Sie dem Controller sozusagen Speicher entnehmen und lokalisieren.
3. Textfeld zur Anzeige der Temperatur.

Elementparameter.


Das ausgeschnittene Bild wird als Hintergrund ausgewählt (Attribut „sta“ -Wert „Bild zuschneiden“). Und als Bild, das zum Schneiden verwendet wird, wird dasselbe verwendet, das für den Hintergrund der gesamten Seite verwendet wird (das Attribut „picc“ ist der Index des Bildes aus der Bildbibliothek). Dank dessen wird der Tex mit einem transparenten Hintergrund erhalten.
Wie ich bereits in der letzten Lektion geschrieben habe, weiß das Panel nicht, wie man mit gebrochenen und negativen Zahlen arbeitet, und für die Temperatur ist beides möglich. Zur Anzeige des Temperaturwertes wird daher ein Textfeld verwendet, in das die fertige Zeile sofort von der Steuerung gesendet wird.
4. Das geschnittene Bild.

Elementparameter.


Mit Hilfe dieses Elements wird die Sonne angezeigt, wenn die Temperatur einen vorgegebenen Grenzwert überschreitet. Eigentlich war es möglich, ein gewöhnliches Bild zu verwenden und seine Sichtbarkeit zu ändern, aber seit dem Trainingsbeispiel habe ich mich für dieses spezielle Element entschieden. Ich selbst habe die Ideologie dieses Elements schon lange verstanden und werde versuchen zu zeigen, wie es funktioniert. Für seine Arbeit habe ich zwei Bilder gemacht, eines mit der Sonne, das andere ohne die Sonne.





Das Element zeigt den Teil des angehängten Bildes an (das Attribut „picc“ ist der Index des Bildes in der Bildbibliothek). Die obere linke Ecke dieses Abschnitts befindet sich in den Einfügungskoordinaten des Elements (Attribute „x“ und „y“) und hat die Breite und Höhe des Elements (Attribute „w“ und „h“). Während des Betriebs des Steuerungsprogramms ändert sich bei Bedarf die Bindung des Elements an das Bild.

5. Taste.

Elementparameter.


Wenn Sie auf die Schaltfläche klicken, wird die nächste Seite aufgerufen. Ich habe ein Bild als Hintergrund für die Schaltfläche verwendet. Ich habe für beide Zustände dasselbe Bild verwendet (die Attribute „pic“ und „pic2“ sind die Indizes der Bilder in der Bildbibliothek), da der gedrückte Zustand niemals sichtbar ist. Wenn Sie auf die Schaltfläche klicken, wird direkt zur nächsten Seite gewechselt. Da wir an dieser Schaltfläche nichts ändern werden, habe ich sie lokal und den Standardnamen belassen.

Code im Ereignis „Touch Press Event“.


Der zweite Bildschirm dient zur Anzeige der Luftfeuchtigkeit (Seite “Seite1” Index - 1).


Für den Hintergrund der Seite habe ich ein Bild mit einem vorbereiteten Bild der Hygrometerskala verwendet.


Betrachten Sie die auf der Seite enthaltenen Elemente.

1. Das Element „Gaude“, das den Betrieb eines Hygrometers simuliert.

Elementparameter.


Da wir es vom Controller aus steuern, wird es globalisiert. Das ausgeschnittene Bild (das Attribut „sta“) wird als Hintergrund ausgewählt, und das Hintergrundbild der Seite (das Attribut „picc“) wird als Hintergrund ausgewählt.

2. Numerisches Feld.

Elementparameter.


In diesem Feld wird der Feuchtigkeitswert angezeigt. Da das Panel das Arbeiten mit Bruchzahlen nicht unterstützt, wird der Feuchtigkeitswert ohne Bruchteil angezeigt. Das ausgeschnittene Bild wird als Hintergrund ausgewählt (Attribut „sta“ -Wert „Bild zuschneiden“). Und als Bild, das zum Schneiden verwendet wird, wird dasselbe verwendet, das für den Hintergrund der gesamten Seite verwendet wird (das Attribut „picc“ ist der Index des Bildes aus der Bildbibliothek). Um die Schönheit der Anzeige zu gewährleisten, setze ich die Ausrichtung nach rechts (Attribut „xcen“ -Wert - 2) und füge daneben ein Textfeld (3) mit dem Wert „%“ ein. Die Hintergrundeinstellungen dafür ähneln den Einstellungen für das Nummernfeld.

Textfeldoptionen (3).


4 und 5. Schaltflächen vorherige Seite und nächste Seite. Wenn Sie die Taste 4 drücken, gelangen Sie zur ersten Seite, und wenn Sie auf die Taste 5 klicken, gelangen Sie zur nächsten. Die Einstellungen für die Tastenanzeige ähneln denen auf der ersten Seite.

Einstellungen für Schaltfläche 4 („Vorherige Seite“)


Code im „Touch Press Event“ für Schaltfläche 4 („Vorherige Seite“).


Einstellungen für Schaltfläche 5 („Nächste Seite“)


Code im „Touch Press Event“ für Schaltfläche 5 („Nächste Seite“).


Dritte Seite - Diagramm der Änderungen von Temperatur und Luftfeuchtigkeit (Index „Seite 2“ - 2).


Auf dieser Seite wird eine grafische Darstellung der Änderungen von Temperatur und Luftfeuchtigkeit angezeigt. Betrachten Sie die auf der Seite enthaltenen Elemente.

1. Das Wellenformelement.

Elementparameter.


In der letzten Lektion habe ich bereits geschrieben, dass dieses Element nicht (ich hoffe bisher) global werden kann, dh der Attributwert kann umgeschaltet werden, aber dies führt zu nichts. Also habe ich es lokal gelassen (wer weiß, aber plötzlich frisst er immer noch die Erinnerung an globale Variablen). In diesem Element befinden sich zwei Anzeigekanäle (Attribut „ch“ -Wert - 2).

2 und 3 sind einfach Textfelder, die die Achse der Diagramme zeigen.

4 - Knopf zurück. Es ähnelt der gleichen Schaltfläche auf dem vorherigen Bildschirm, mit Ausnahme des Codes in der Ereignisbehandlungsroutine.

Der Code im „Touch Press Event“ für Schaltfläche 4 („Vorherige Seite“).


Wir haben das Panel herausgefunden, jetzt kümmern wir uns um den Controller. Ich werde nicht sagen, wie man das FLProg-Programm öffnet, ein Projekt erstellt und ein Diagramm zeichnet. All dies habe ich in früheren Lektionen erzählt (Lektion 1 , Lektion 2 ) und viele Informationen dazu finden Sie im Schulungszentrum auf der Projektwebsite. Deshalb werde ich sofort die vorgefertigten Leiterplatten zeigen und erzählen, was auf ihnen passiert.

Karte 1. Daten vom Sensor lesen.


Um mit dem DHT-22-Sensor Temperatur- und Feuchtigkeitswerte zu erhalten, wird der B1-Block verwendet - „DHT11, DHT21, DHT22“ (Elementbibliothek, Ordner „Sensoren“).

Blockeinstellungen (durch Doppelklick aufgerufen).


In den Einstellungen wird der Pin zugewiesen, an den der „Daten“ -Ausgang des Sensors angeschlossen ist, der Sensortyp und das Vorhandensein von Temperatur- und Feuchtigkeitsausgängen. Der Sensorabfragemodus ist ebenfalls ausgewählt. Ich habe die Abfrage des Sensors alle 5 Sekunden eingerichtet.

Da Arduino-Controller mit Gleitkommazahlen nicht sehr gut funktionieren und die Arbeit mit ihnen viel Speicherplatz beansprucht, übersetze ich sofort alle Werte in das Integer-Format. Verwenden Sie dazu die Blöcke B3 und B4 - „Float in Integer konvertieren“ (Elementbibliothek, Ordner „Type Conversion“), die den Bruchteil der Zahl abschneiden. Um keine Zehntelgrad zu verlieren, wird der vom Sensor erhaltene Temperaturwert zunächst mit Block B2 - „MUL (*)“ (Elementbibliothek, Ordner „Mathematik“) mit 10 multipliziert.
Dann werden die erhaltenen Werte im Integer-Format in die entsprechenden Variablen eingegeben.

Karte 2. Zeigt den Temperaturwert auf dem Bedienfeld an.


In diesem Projekt verwende ich benannte Verbindungen. Mehr darüber erfahren Sie in der entsprechenden Lektion .
Um die Belastung der Steuerung zu begrenzen, ist es sinnvoll, Daten nur dann an das Panel zu senden, wenn sich die Daten geändert haben. Daher stellen wir zunächst fest, dass sich die Daten geändert haben. Verwenden Sie dazu Block B5 - „Nummernänderungsdetektor“ (Elementbibliothek, Ordner - „Basisblöcke“). Dieses Gerät steuert die Zahl „Wert“ an seinem Eingang und erzeugt bei Änderung einen Ausgangsimpuls von einem Zyklus der Programmausführung am Ausgang.
Danach bereiten wir eine Zeichenfolge für das Senden an das Bedienfeldtextfeld vor. Teilen Sie zunächst den mit 10 multiplizierten Temperaturwert durch eine Konstante vom Typ Float mit einem Wert von 10. Somit erhalten wir den Temperaturwert mit einem Bruchteil. Wir tun dies mit Block B6 - "DIV (/)" (Bibliothek von Elementen, Ordner "Mathematik"). Dann wandeln wir den erhaltenen Wert im Float-Format mit Block B7 - „String-Konvertierung“ (Elementbibliothek, Ordner „Typkonvertierung“) in einen String um. Dann verbinden wir den resultierenden String mit der String-Konstante "C" über Block B8 - "Addition von Zeilen" (Elementbibliothek, Ordner "Lines"). Die resultierende Zeile wird dem Eingang des Geräts zugeführt, um den Attributwert in das Nextion HMI B9-Bedienfeld zu schreiben - „Set Parameter“ (Elementbibliothek -> Ordner „Nextion HMI Panel“ -> „Elements“ -Ordner).
Dieser Block schreibt den Wert in das angegebene Attribut.

Blockparametrierung.

Durch Doppelklick auf den Block wird das Blockeditorfenster geöffnet.


Wenn im Projekt noch keine Panels erstellt wurden, müssen Sie ein Panel erstellen. Wenn das erforderliche Bedienfeld bereits erstellt wurde, kann es durch Drücken der Taste 3 aus der Dropdown-Liste ausgewählt werden. Das ausgewählte Bedienfeld kann mit der Schaltfläche „Bedienfeld ändern“ (2) geändert werden. Um ein Panel zu erstellen, klicken Sie auf die Schaltfläche "Panel hinzufügen" (1). Das Fenster zur Panel-Erstellung wird geöffnet.


Wählen Sie in diesem Dialogfeld den Anschluss für den Anschluss des Panels aus (in unserer Lektion - SoftwareSerial). Wenn Sie SoftwareSerial auswählen, müssen Sie auch die Pins auswählen, die als RX- und TX-Signale des UART-Ports zugewiesen sind (in unserem Fall 2 und 3). Es ist auch erforderlich, einen Panel-Namen zuzuweisen. Es muss einzigartig sein. In einem Projekt können mehrere Panels verbunden werden, sofern genügend freie UART-Ports vorhanden sind. Der Name jedes Panels muss innerhalb des Projekts eindeutig sein. Im selben Dialogfeld können Sie die im Bedienfeld enthaltenen Seiten hinzufügen. Was werden wir tun? Klicken Sie auf die Schaltfläche Seite hinzufügen. Das Fenster zur Seitenerstellung wird geöffnet.


In diesem Fenster müssen wir den Namen der Seite und ihre ID eingeben. Diese Informationen können aus dem Projekt im Nextin Editor abgerufen werden.


Standardmäßig ist die Startseite (die beim Start des Controllers geöffnet wird) eine Seite mit der ID 0, Sie können jedoch das Kontrollkästchen "Startseite" in den Eigenschaften jeder Seite aktivieren und sie wird zur Startseite.
In diesem Fenster können Sie die Elemente hinzufügen, die uns auf dieser Seite interessieren. Klicken Sie auf die Schaltfläche "Element hinzufügen".
Das Fenster zum Erstellen von Elementen wird geöffnet.


Hier müssen wir den Typ und den Typ des Elements auswählen, seinen Namen und Index eingeben und, wenn das Element global ist, das entsprechende Kontrollkästchen aktivieren. Alle diese Daten können im Projekt im Nextin Editor angezeigt werden.


Nachdem Sie alle Daten eingegeben haben, klicken Sie auf "Fertig stellen" und fügen Sie dann im Fenster zur Seitenerstellung auf die gleiche Weise alle für uns interessanten Elemente auf dieser Seite hinzu.


Nachdem Sie alle Elemente auf der Seite erstellt haben, klicken Sie im Fenster zum Erstellen der Seite auf die Schaltfläche „Fertig stellen“. Erstellen Sie im Fenster zum Erstellen eines Bedienfelds mit demselben Szenario den Rest der Seite.






Wir beenden die Erstellung des Panels mit der bekannten Schaltfläche "Fertig stellen".
Wählen Sie im Blockeditor das Seitenelement „Seite0“ „Text“ mit dem Namen „tnt“ und dem Attribut „Text (txt)“. Wählen Sie als Wert den Eingang.


Der Block ist konfiguriert.
Wir betrachten das Schema weiter.
Empirisch wurde definitiv festgestellt, dass ein Wert von -40 Grad eines gezeichneten Thermometers einem Wert von 10 im darauf befindlichen Element "Fortschrittsbalken" entspricht, und ein Wert von 50 Grad eines Thermometers einem Wert von 91 bar Fortschritt entspricht. Dementsprechend skalieren wir den Wert mit der Variablen „Temperature x10“ unter Verwendung des Blocks B10 - „Scale“ (Elementbibliothek, Ordner „Scaling“), ohne zu vergessen, dass der Temperaturwert mit 10 multipliziert wird. Parameter dieses Blocks.


Der skalierte Temperaturwert wird mit Block B11 - "Set Parameter" (Elementbibliothek -> Ordner "Panel Nextion HMI" -> Ordner "Elements") an das Panel gesendet. Einstellungen für diesen Block.


Der nächste Block B12 - „Komparator“ (Elementbibliothek, Ordner „Vergleich“) bestimmt, ob die aktuelle Temperatur die eingestellte Temperatur um den Standardwert der Variablen „Set - Hot“ überschreitet. Es ist 290 (vergessen Sie nicht, dass wir überall Temperaturen multipliziert mit 10 haben).


Block B12 ist so konfiguriert, dass eine logische Einheit an ihrem Ausgang ausgegeben wird, wenn der Wert am Eingang "I1" den Wert am Eingang "I2" überschreitet.


Die Blöcke B13, B14 und B15 bilden diskrete Signaländerungserfassungsschaltungen. Die Blöcke B13 und B14 - Rtrig (Elementbibliothek, Ordner „Trigger“) geben bei Auftreten einer Vorderflanke eines diskreten Signals einen Ausgangsimpuls mit einer Dauer von 1 Programmzyklus aus. Block B14 erkennt aufgrund der Inversion an seinem Eingang die Hinterflanke des Signals "Überschreiten der Schwelle". Block B15 –OR (Elementbibliothek, Ordner „Basic Elements“) gibt, wenn sich an einem der Eingänge eine logische Einheit befindet, eine logische Einheit an ihren Ausgang aus. Somit wird ein Signal gebildet, "Daten zu senden, wenn der Schwellenwert überschritten wird". An der Vorderflanke dieses Signals wird ein Befehl zum Ändern der Schriftfarbe des Textfelds gesendet, in dem die aktuelle Temperatur angezeigt wird. Das Senden erfolgt über Block B17 - „Parameter einstellen“ (Elementbibliothek -> Ordner „Nextion HMI Panel“ ->Elementordner). Einstellungen für diesen Block.


Der im Befehl übertragene Wert wird mit Block B16 - „Switch“ (Elementbibliothek, Ordner „Switch“) ausgewählt. Dieser Block mit einem niedrigen Logikpegel am Eingang überträgt den Wert vom Eingang „0“ zum Ausgang und mit einem hohen Wert vom Eingang „1“. Der den Schaltereingängen zugeführte Farbwert wird mit den Blöcken B44 und B45 - „Farbkonstante Hight Color“ (Elementbibliothek -> Ordner „Nextion HMI Panel“ -> Ordner „Color“) eingestellt. Die Farbe wird im Blockeditor ausgewählt (Doppelklick auf den Block).


Um eine Farbe auszuwählen, klicken Sie auf die Schaltfläche "Ändern". Der Farbwähler wird geöffnet.


Darin wird durch Einstellen des Wertes der Komponenten R (rot), G (grün) und B (blau) die gewünschte Farbe ausgewählt.
Außerdem wird an der Vorderflanke des Signals "Senden von Daten, wenn der Schwellenwert überschritten wird" ein Befehl gesendet, um die Bindung des ausgeschnittenen Bildes zu ändern. Dies geschieht mit Block B19 - „Set Parameter“ (Elementbibliothek -> Ordner „Nextion HMI Panel“ -> Ordner „Elements“).
Einstellungen für diesen Block.


Der Bildindex wird mit Block B18 - „Switch“ (Elementbibliothek, Ordner „Switch“) ausgewählt. Seine Arbeit wurde oben beschrieben. Der Indexwert des erforderlichen Bildes kann im Nextion Editor-Projekt in der Bildbibliothek angezeigt werden.

Mit der Übertragung der Temperaturdaten beendet. Gehen wir weiter zur Luftfeuchtigkeit.

Board 3. Schlussfolgerung der Luftfeuchtigkeit.


Wie bei der Temperatur erzeugen wir zunächst ein Signal „Daten senden, wenn sich die Luftfeuchtigkeit ändert“. Wir tun dies mit Block B20 - „Nummernänderungsdetektor“ (Elementbibliothek, Ordner - „Basisblöcke“). Der Betrieb dieses Geräts wurde bereits beschrieben. Dieses Signal sendet den Wert an ein numerisches Feld, das die Luftfeuchtigkeit anzeigt. Dies geschieht mit Block B21 - „Set Parameter“ (Elementbibliothek -> Ordner „Nextion HMI Panel“ -> Ordner „Elements“).
Einstellungen für diesen Block.


Empirisch wurde definitiv festgestellt, dass für den 0% Luftfeuchtigkeitswert der gezeichneten Hygrometerskala im Paneldesign das „Gayge“ -Element, das den Pfeil zeichnet, 314 und für 100% Luftfeuchtigkeit 226 beträgt. Gleichzeitig geht der Pfeil über den Wert 0. Bei der Umrechnung in lineare Werte erhalten wir stetig reichen von -46 (0%) bis 226 (100%). In Übereinstimmung mit diesen Daten konfigurieren wir den Block B22 - „Scale“.
Blockparameter.


Da die Werte für das Element „Messgerät“ nicht negativ sein dürfen, wird bei einem negativen Wert zur Berechnung des Pfeilwinkels bei diesen Werten der Wert 360 hinzugefügt. Dazu verwenden wir den B23-Block „SUMM (+)“ (Elementbibliothek, Mathe-Ordner). Mit Block B26 - „Komparator“ (Elementbibliothek, Ordner „Vergleich“) stellen wir fest, dass die Zahl kleiner als 0 ist. Sein Ausgang steuert den Schalter B24 - „Schalter“ (Elementbibliothek, Ordner „Schalter“) und der ausgewählte Wert wird über Block B25 - „Parameter einstellen“ (Elementbibliothek -> Ordner „Nextion HMI Panel“ -> Ordner „Elemente“ an das Panel gesendet. )
Einstellungen für diesen Block.


Die nächste Tafel zeigt eine grafische Darstellung der Änderungen von Temperatur und Luftfeuchtigkeit.


Wie ich zu Beginn der Lektion geschrieben habe, weiß das Waveform-Element nicht, wie man ein globales Element ist, und wird jedes Mal neu gezeichnet, wenn Sie die Seite öffnen, auf der es sich befindet. Wir müssen diese Einschränkung umgehen. Bestimmen Sie zunächst die Nummer der Seite, die derzeit in das Bedienfeld geladen wird. Verwenden Sie dazu Block B27 - „ID der aktuellen Seite abrufen“ (Elementbibliothek -> Ordner „Nextion HMI Panel“ -> Ordner „Seite“). In den Einstellungen dieses Blocks müssen Sie nur das Panel auswählen, auf das wir mit dieser Anfrage zugreifen.


Die aus diesem Block erhaltene Seitenzahl wird mit dem Index der benötigten Seite (2) unter Verwendung von Block B28 - „Komparator“ (Elementbibliothek, Ordner „Vergleich“) verglichen. Wenn die gewünschte Seite geöffnet ist, wird die logische Einheit in die Variable "Seite des Diagramms öffnen" geschrieben. Wenn nicht, dann eine logische Null.
Mit Block B29 - „Generator“ (Elementbibliothek, Ordner „Timer“) wird ein Signal generiert, um den nächsten Punkt im Diagramm aufzuzeichnen. Dieser Block erzeugt Impulse mit einer bestimmten Impulsdauer und Pause.
Einstellungen blockieren.


Der ausgewählte Generatortyp ist "Symmetrischer Multivibrator", was bedeutet, dass die Impulsdauer gleich der Dauer der Pause ist. Wenn Sie die Pulsdauer auf 5 Sekunden einstellen, beträgt die Pause 5 Sekunden. Die Vorderflanke des Impulses kommt alle 10 Sekunden. Diese Front wird durch Block B30 - "Rtrig" (Elementbibliothek, Ordner "Trigger") hervorgehoben und in die Variable "Befehl zum Aufzeichnen des nächsten Punktes" geschrieben.
An der Vorderkante des Signals „Grafikseite öffnen“, das mit Block B31 - „Rtrig“ (Elementbibliothek, Ordner „Trigger“) ausgewählt wird, wird das Signal „Grafikverlauf senden“ generiert. Durch dieses Signal wird der Inhalt von Arrays an das Bedienfeld im Diagramm gesendet, in dem die Werte der Punkte gespeichert sind, die das Änderungsdiagramm anzeigen. Für die Temperatur wird dies mit Block B32 - „Senden des Arrays an das Diagramm“ (Elementbibliothek -> Ordner „Nextion HMI Panel“ -> Ordner „Diagramm“) durchgeführt. Der Block wird mit dem Blockeditor konfiguriert.


Zuerst müssen Sie ein Array erstellen, in dem der Verlauf des Temperaturdiagramms gespeichert wird. Klicken Sie dazu auf die Schaltfläche "Erstellen". Das Array-Erstellungsfenster wird geöffnet.


In diesem Ozean müssen Sie den Namen des Arrays und den Typ eingeben (verwenden Sie Byte, da das Waveform-Element einen Maximalwert von 255 annimmt). Die Größe entspricht der Breite des Diagramms (330).
Wählen Sie nach dem Erstellen das Bedienfeld, die Seite, das Element und den Kanal aus, auf dem das Diagramm gezeichnet werden soll.


Auf die gleiche Weise konfigurieren wir den Block zum Senden eines Arrays mit Feuchtigkeitsdaten an das B33-Bedienfeld - „Senden des Arrays an das Diagramm“ (Elementbibliothek -> Ordner „Nextion HMI-Bedienfeld“ -> Ordner „Diagramm“). In den Einstellungen erstellen wir ein weiteres Array zum Speichern dieser Daten.


Jetzt müssen Sie die Daten für das Temperaturdiagramm vorbereiten. Dieses Diagramm hat eine Linie entlang seiner Achse in einer Höhe von 160 Punkten vom unteren Rand des Diagramms. Um die Temperaturänderungen besser sichtbar zu machen, teilen wir den Wert der Variablen „Temperatur x10“ mit Block B35 durch 5 (dh als würde der reale Temperaturwert mit 2 multipliziert) und addieren den Offset mit Block B36. Das Ergebnis wird in die Variable "Temperatur mit einer Verschiebung für das Diagramm" eingegeben.
Mit Block B37 - „Stapel“ (Elementbibliothek, Ordner „Arrays“) wird der Impuls aus der Variablen „Befehl zum Aufzeichnen des nächsten Punktes“ durch die Temperatur mit einer Verschiebung für den Graphen nach dem Stapelprinzip in das Array geschrieben (das erste Element des Arrays wird gelöscht). der Rest wird um eins verschoben und der letzte Wert wird geschrieben). Der Block wird mit dem Blockeditor parametriert.


Wählen Sie im Editor das gewünschte Array aus, indem Sie auf die Schaltfläche "Auswählen" klicken.
Auf die gleiche Weise konfigurieren wir den B34-Block "Stack" (Elementbibliothek, Ordner "Arrays") zum Schreiben von Feuchtigkeitswerten in das Array, indem wir im entsprechenden Array auswählen.
Wenn die Diagrammseite geöffnet ist, die Übertragung von Arrays in das Diagramm abgeschlossen ist und der Befehl zum Aufzeichnen des nächsten Punkts empfangen wird, werden die Werte der neuen Punkte an die entsprechenden Diagramme gesendet. Dies ist erforderlich, damit die Grafiken während der Anzeige der Seite weiter erstellt werden können. Die Einhaltung dieser Bedingungen wird mit Block B38 - „UND“ (Elementbibliothek, Ordner „Grundelemente“) überwacht. Dieser Block gibt eine Einheit an seinem Ausgang aus, wenn an allen Eingängen eine logische Einheit vorhanden ist. Der nächste Temperaturwert mit einer Verschiebung wird mit Block B40 - „Punkt zum Diagramm hinzufügen“ (Elementbibliothek -> Ordner „Nextion HMI Panel“ -> Ordner „Diagramm“) an das Diagramm gesendet.
Einstellungen blockieren.


Der Block zum Senden des nächsten Feuchtigkeitswerts an das B39-Diagramm ist ebenfalls eingerichtet: "Hinzufügen eines Punkts zum Diagramm" (Elementbibliothek -> Ordner "Nextion HMI Panel" -> Ordner "Diagramm").


Fertig mit dem Abschluss des Zeitplans.

Board 5. Passen Sie die Helligkeit der Hintergrundbeleuchtung an.


Der Wert der Hintergrundbeleuchtung, die mit einem variablen Widerstand eingestellt wurde, wird mit dem Analogeingangsblock „Helligkeit“ gelesen. Da der Helligkeitswert der Hintergrundbeleuchtung des Panels im Bereich von 0 bis 100 liegt, skalieren wir den Lesewert vom Bereich 0-1023 bis zum Bereich 0-100 mit dem Block B41 - „Scale“.
Einstellungen blockieren.


Dann bestimmen wir die Tatsache einer Änderung dieses Wertes mit Block B42 - „Detektor zum Ändern der Nummer“. Dieser Block hat einige nicht standardmäßige Einstellungen.


Um die Helligkeit nicht für jede Bewegung des variablen Widerstands zu ändern, wird das Totband in der Einheit auf einen Wert von 5 eingestellt. Das heißt, die Einheit arbeitet, wenn sich der Eingangswert in beide Richtungen um mehr als 5 ändert. Wenn das Gerät ausgelöst wird, wird ein Befehl an das Bedienfeld gesendet, um mithilfe von Block B43 - „Hintergrundbeleuchtungsstufe einstellen“ (Elementbibliothek -> Ordner „Nextion HMI Panel“ -> Ordner „System“) eine neue Helligkeit für die Hintergrundbeleuchtung einzustellen.
Blockeinstellungen Die


Arbeit am Programm für die Steuerung ist abgeschlossen.

Für diejenigen, die sich für den Code für den resultierenden Sketch Skoller interessieren.
#include <SoftwareSerial.h>
#include "DHT.h"
DHT _dht1(4, DHT22);

SoftwareSerial Serial100(2, 3);

byte _FLPArray142003126[330] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
byte _FLPArray239384258[330] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int _SUETFLPATemp = 0;
byte _nextionSaveDataVAL_P0_E2;
long _nextionSaveDataPCO_P0_E3;
String _nextionSaveDataTXT_P0_E3;
byte _nextionSaveDataPICC_P0_E4;
int _nextionSaveDataVAL_P1_E2;
long _nextionSaveDataVAL_P1_E4;
String _nextionCommandTempString;
struct _nextionLissenStruct {
  char code;
  String result;
  long number;
};
_nextionLissenStruct _nextionTempLissen;
int nextionGetPageIdTempVar = 0;
int NextionPanel_47525121_PageIdOut = 0;
int _hasNumberChangeInTemp = 0;
int _gtv1;
int _gtv2;
int _gtv3 = 290;
bool _gtv4 = 0;
bool _gtv5 = 0;
int _gtv6;
unsigned long _dht1Tti = 0UL;
float _dht1t = 0.00;
float _dht1h = 0.00;
bool _changeNumber1_Out = 0;
int _changeNumber1_OLV;
bool _nextionSetAttr1_isNU = 0;
bool _nextionSetAttr1_oldState = 0;
bool _nextionSetAttr2_isNU = 0;
bool _nextionSetAttr2_oldState = 0;
bool _trgrt1 = 0;
bool _trgrt1I = 0;
bool _trgrt2 = 0;
bool _trgrt2I = 0;
bool _nextionSetAttr3_isNU = 0;
bool _nextionSetAttr3_oldState = 0;
long _swi1;
bool _nextionSetAttr4_isNU = 0;
bool _nextionSetAttr4_oldState = 0;
byte _swi2;
bool _nextionSetAttr5_isNU = 0;
bool _nextionSetAttr5_oldState = 0;
bool _changeNumber2_Out = 0;
int _changeNumber2_OLV;
int _swi3;
bool _nextionSetAttr6_isNU = 0;
bool _nextionSetAttr6_oldState = 0;
bool _trgrt3 = 0;
bool _trgrt3I = 0;
bool _gen1I = 0;
bool _gen1O = 0;
unsigned long _gen1P = 0UL;
bool _trgrt5 = 0;
bool _trgrt5I = 0;
bool _nextionAddPointToWave1_OldState = 0;
bool _nextionAddPointToWave2_OldState = 0;
bool _SFLPAS1;
bool _SFLPAS2;
bool _nextionSendArraytToWave1_OldState = 0;
bool _nextionSendArraytToWave2_OldState = 0;
bool _nextionSetLighting1_OldStae = 0;
bool _changeNumber3_Out = 0;
int _changeNumber3_OLV;
void setup()
{
  Serial100.begin(9600);
  _dht1.begin();
  nextionSendCommand("", 100);
  nextionAck(100);
  nextionSendCommand("page 0", 100);
  delay(100);
  nextionAck(100);
}
void loop()
{ nextionGetPageIdTempVar = nextionAskPageNamper(100);
  if ( ! (nextionGetPageIdTempVar < 0) ) {
    NextionPanel_47525121_PageIdOut = nextionGetPageIdTempVar;
  };
  if (_isTimer(_dht1Tti, 5000)) {
    _dht1Tti = millis();
    float tempDht4;
    tempDht4 = _dht1.readTemperature();
    if (!(isnan(tempDht4))) {
      _dht1t = tempDht4;
    }
    tempDht4 = _dht1.readHumidity();
    if (!(isnan(tempDht4))) {
      _dht1h = tempDht4;
    }
  }



  _gtv1 = (int((_dht1t) * (10)));
  _gtv2 = (int(_dht1h));
  if ((_gtv1) > (_gtv3)) {
    if (_trgrt1I) {
      _trgrt1 = 0;
    } else {
      _trgrt1 = 1;
      _trgrt1I = 1;
    }
  } else {
    _trgrt1 = 0;
    _trgrt1I = 0;
  };
  if ((_gtv1) > (_gtv3))
  {
    _swi1 = 63488;
  }
  else
  {
    _swi1 = 2016;
  }
  if (!((_gtv1) > (_gtv3))) {
    if (_trgrt2I) {
      _trgrt2 = 0;
    } else {
      _trgrt2 = 1;
      _trgrt2I = 1;
    }
  } else {
    _trgrt2 = 0;
    _trgrt2I = 0;
  };
  if ((_gtv1) > (_gtv3))
  {
    _swi2 = 2;
  }
  else
  {
    _swi2 = 0;
  }
  if (_changeNumber1_Out) {
    _changeNumber1_Out = 0;
  } else {
    _hasNumberChangeInTemp = _gtv1;
    if (_hasNumberChangeInTemp != _changeNumber1_OLV) {
      _changeNumber1_OLV = _hasNumberChangeInTemp;
      _changeNumber1_Out = 1;
    }
  }
  if (_changeNumber1_Out) {
    if (! _nextionSetAttr1_oldState ) {
      _nextionSetAttr1_oldState = 1;
      _nextionSetAttr1_isNU = 1;
      _nextionSaveDataTXT_P0_E3 =  ((( _floatToStringWitRaz((_gtv1) / (10.00), 1))) + (String(" C"))) ;
    }
  } else {
    _nextionSetAttr1_oldState = 0;
  } if (_nextionSetAttr1_isNU) {
    _nextionCommandTempString = String("page0.tnt.txt=\"") + _nextionSaveDataTXT_P0_E3 + String("\"");
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr1_isNU = 0;
  } if (_changeNumber1_Out) {
    if (! _nextionSetAttr2_oldState ) {
      _nextionSetAttr2_oldState = 1;
      _nextionSetAttr2_isNU = 1;
      _nextionSaveDataVAL_P0_E2 =  (map((_gtv1), (-400), (500), (10), (91))) ;
    }
  } else {
    _nextionSetAttr2_oldState = 0;
  } if (_nextionSetAttr2_isNU) {
    _nextionCommandTempString = String("page0.tpb.val=") + String(_nextionSaveDataVAL_P0_E2);
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr2_isNU = 0;
  } if (( (_trgrt1) || (_trgrt2) )) {
    if (! _nextionSetAttr3_oldState ) {
      _nextionSetAttr3_oldState = 1;
      _nextionSetAttr3_isNU = 1;
      _nextionSaveDataPCO_P0_E3 =  _swi1 ;
    }
  } else {
    _nextionSetAttr3_oldState = 0;
  }
  if (nextionAskPageNamper(100) == 0) {
    if (_nextionSetAttr3_isNU) {
      _nextionCommandTempString = String("page0.tnt.pco=") + String(_nextionSaveDataPCO_P0_E3);
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionCommandTempString = "ref tnt";
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionSetAttr3_isNU = 0;
    }
  } else {
    _nextionSetAttr3_isNU = 1;
  }
  if (( (_trgrt1) || (_trgrt2) )) {
    if (! _nextionSetAttr4_oldState ) {
      _nextionSetAttr4_oldState = 1;
      _nextionSetAttr4_isNU = 1;
      _nextionSaveDataPICC_P0_E4 =  _swi2 ;
    }
  } else {
    _nextionSetAttr4_oldState = 0;
  }
  if (nextionAskPageNamper(100) == 0) {
    if (_nextionSetAttr4_isNU) {
      _nextionCommandTempString = String("page0.tci.picc=") + String(_nextionSaveDataPICC_P0_E4);
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionCommandTempString = "ref tci";
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionSetAttr4_isNU = 0;
    }
  } else {
    _nextionSetAttr4_isNU = 1;
  }
  if (((map((_gtv2), (0), (100), (-46), (226)))) < (0))
  {
    _swi3 = ((map((_gtv2), (0), (100), (-46), (226)))) + (360);
  }
  else
  {
    _swi3 = (map((_gtv2), (0), (100), (-46), (226)));
  }
  if (_changeNumber2_Out) {
    _changeNumber2_Out = 0;
  } else {
    _hasNumberChangeInTemp = _gtv2;
    if (_hasNumberChangeInTemp != _changeNumber2_OLV) {
      _changeNumber2_OLV = _hasNumberChangeInTemp;
      _changeNumber2_Out = 1;
    }
  }
  if (_changeNumber2_Out) {
    if (! _nextionSetAttr5_oldState ) {
      _nextionSetAttr5_oldState = 1;
      _nextionSetAttr5_isNU = 1;
      _nextionSaveDataVAL_P1_E4 =  _gtv2 ;
    }
  } else {
    _nextionSetAttr5_oldState = 0;
  } if (_nextionSetAttr5_isNU) {
    _nextionCommandTempString = String("page1.humN.val=") + String(_nextionSaveDataVAL_P1_E4);
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr5_isNU = 0;
  } if (_changeNumber2_Out) {
    if (! _nextionSetAttr6_oldState ) {
      _nextionSetAttr6_oldState = 1;
      _nextionSetAttr6_isNU = 1;
      _nextionSaveDataVAL_P1_E2 =  _swi3 ;
    }
  } else {
    _nextionSetAttr6_oldState = 0;
  } if (_nextionSetAttr6_isNU) {
    _nextionCommandTempString = String("page1.humG.val=") + String(_nextionSaveDataVAL_P1_E2);
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr6_isNU = 0;
  } if (1) {
    if (! _gen1I) {
      _gen1I = 1;
      _gen1O = 1;
      _gen1P = millis();
    }
  } else {
    _gen1I = 0 ;
    _gen1O = 0;
  }
  if (_gen1I) {
    if ( _isTimer ( _gen1P , 5000 )) {
      _gen1P = millis();
      _gen1O = ! _gen1O;
    }
  }
  if (_gen1O) {
    if (_trgrt5I) {
      _trgrt5 = 0;
    } else {
      _trgrt5 = 1;
      _trgrt5I = 1;
    }
  } else {
    _trgrt5 = 0;
    _trgrt5I = 0;
  };
  if (_gtv4) {
    if (_trgrt3I) {
      _trgrt3 = 0;
    } else {
      _trgrt3 = 1;
      _trgrt3I = 1;
    }
  } else {
    _trgrt3 = 0;
    _trgrt3I = 0;
  };
  _gtv4 = (NextionPanel_47525121_PageIdOut) == (2);
  _gtv5 = _trgrt5;
  if (_trgrt3) {
    if ( ! _nextionAddPointToWave1_OldState) {
      _nextionAddPointToWave1_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        for (int nextionSATWTemp = 0;  nextionSATWTemp < 330;  nextionSATWTemp ++) {
          _nextionCommandTempString = String ("add 1,1,") + String (_FLPArray142003126[nextionSATWTemp]);
          nextionSendCommand(_nextionCommandTempString.c_str(), 100);
        } delay (50);
      }
    }
  } else {
    _nextionAddPointToWave1_OldState = 0;
  }

  if (_trgrt3) {
    if ( ! _nextionAddPointToWave2_OldState) {
      _nextionAddPointToWave2_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        for (int nextionSATWTemp = 0;  nextionSATWTemp < 330;  nextionSATWTemp ++) {
          _nextionCommandTempString = String ("add 1,0,") + String (_FLPArray239384258[nextionSATWTemp]);
          nextionSendCommand(_nextionCommandTempString.c_str(), 100);
        } delay (50);
      }
    }
  } else {
    _nextionAddPointToWave2_OldState = 0;
  }

  if (_gtv5) {
    if (!_SFLPAS1) {
      _SFLPAS1 =  1;
      for (_SUETFLPATemp = 0; _SUETFLPATemp < 329; _SUETFLPATemp = _SUETFLPATemp + 1 ) {
        _FLPArray239384258[_SUETFLPATemp ] = _FLPArray239384258[_SUETFLPATemp + 1];
      }  _FLPArray239384258[329] = _gtv2;
    }
  }  else {
    _SFLPAS1 = 0;
  }
  _gtv6 = ((_gtv1) / (5)) + (160);
  if (_gtv5) {
    if (!_SFLPAS2) {
      _SFLPAS2 =  1;
      for (_SUETFLPATemp = 0; _SUETFLPATemp < 329; _SUETFLPATemp = _SUETFLPATemp + 1 ) {
        _FLPArray142003126[_SUETFLPATemp ] = _FLPArray142003126[_SUETFLPATemp + 1];
      }  _FLPArray142003126[329] = _gtv6;
    }
  }  else {
    _SFLPAS2 = 0;
  }
  if (( (_gtv5) && (!(_trgrt3)) && (_gtv4) )) {
    if ( ! _nextionSendArraytToWave1_OldState) {
      _nextionSendArraytToWave1_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        _nextionCommandTempString = String ("add 1,0,") + String (_gtv2);
        nextionSendCommand(_nextionCommandTempString.c_str(), 100); delay (50);
      }
    }
  } else {
    _nextionSendArraytToWave1_OldState = 0;
  }

  if (( (_gtv5) && (!(_trgrt3)) && (_gtv4) )) {
    if ( ! _nextionSendArraytToWave2_OldState) {
      _nextionSendArraytToWave2_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        _nextionCommandTempString = String ("add 1,1,") + String (_gtv6);
        nextionSendCommand(_nextionCommandTempString.c_str(), 100); delay (50);
      }
    }
  } else {
    _nextionSendArraytToWave2_OldState = 0;
  }

  if (_changeNumber3_Out) {
    _changeNumber3_Out = 0;
  } else {
    _hasNumberChangeInTemp = (map(( (analogRead (0))), (0), (1023), (0), (100)));
    if (((_hasNumberChangeInTemp > _changeNumber3_OLV) && ((_hasNumberChangeInTemp - _changeNumber3_OLV ) > 5)) || ((_hasNumberChangeInTemp < _changeNumber3_OLV) && ((_changeNumber3_OLV - _hasNumberChangeInTemp ) > 5) ))
    {
      _changeNumber3_OLV = _hasNumberChangeInTemp;
      _changeNumber3_Out = 1;
    }
  }
  if (_changeNumber3_Out) {
    if (!(_nextionSetLighting1_OldStae)) {
      _nextionSetLighting1_OldStae = 1;
      _nextionCommandTempString = String("dim=") + String((map(( (analogRead (0))), (0), (1023), (0), (100))));
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);
    }
  } else {
    _nextionSetLighting1_OldStae = 0;
  }




}
bool _isTimer(unsigned long startTime, unsigned long period )
{
  unsigned long currentTime;
  currentTime = millis();
  if (currentTime >= startTime) {
    return (currentTime >= (startTime + period));
  } else {
    return (currentTime >= (4294967295 - startTime + period));
  }
}
String  _floatToStringWitRaz(float value, int raz)
{
  float tv;
  int ti = int(value);
  String ts = String(ti);
  if (raz == 0) {
    return ts;
  }
  ts += ".";
  float tf = abs(value - ti);
  for (int i = 1; i <= raz; i++ )
  {
    tv = tf * 10;
    ti = int(tv);
    ts += String(ti);
    tf = (tv - ti);
  }
  return ts;
}
void nextionSendCommand(const char* cmd, byte port )
{
  while (Serial100.available()) {
    Serial100.read();
  }
  Serial100.print(cmd);
  Serial100.write(0xFF);
  Serial100.write(0xFF);
  Serial100.write(0xFF);
}
boolean nextionAck( byte port )
{
  uint8_t bytes[4] = {0};
  Serial100.setTimeout(20); if (sizeof(bytes) != Serial100.readBytes((char *)bytes, sizeof(bytes))) {
    return 0;
  }

  if ((bytes[1] == 0xFF) && (bytes[2] == 0xFF) && (bytes[3] == 0xFF)) {
    switch (bytes[0]) {
      case 0x00:
        return false; break;
      case 0x01:
        return true; break;
      default:
        return false;
    }
  }
}
struct _nextionLissenStruct nextionListen( byte port )
{
  char _bite;
  char _end = 0xff;
  String cmd;
  _nextionLissenStruct temp;
  int countEnd = 0;
  delay(10);
  while (Serial100.available() > 0) {
    if (Serial100.available() > 0) {
      _bite = Serial100.read();
      cmd += _bite;
      if (_bite == _end) {
        countEnd++;
      }
      if (countEnd == 3) {
        break;
      }
    }
  }
  temp.result = "";
  temp.code = 'z';
  temp.number = 0;
  switch (cmd[0]) {
    case 'e':
      temp.code = 'e';
      countEnd = 0;
      for (uint8_t i = 0; i < cmd.length(); i++) {
        if (cmd[i] == _end) {
          countEnd++;
        }
        temp.result += String(cmd[i], HEX);
        if (countEnd == 3) {
          return temp;
        }
        temp.result += " ";
      }
      break;
    case 'f':
      temp.code = 'f';
      temp.result = String(cmd[1], DEC);
      return temp;
      break;
    case 'g':
      temp.code = 'g';
      temp.result = String(cmd[2], DEC) + "," + String(cmd[4], DEC) + "," + String(cmd[5], DEC);
      return temp;
      break;
    case 'h':
      temp.code = 'h';
      temp.result = String(cmd[2], DEC) + "," + String(cmd[4], DEC) + "," + String(cmd[5], DEC);
      temp.result = "68 " + temp.result;
      return temp;
      break;
    case 'p':
      temp.code = 'p';
      temp.result = cmd.substring(1, cmd.length() - 3);
      return temp;
      break;
    case 'q':
      temp.code = 'q';
      temp.number = (cmd[4] << 24) | (cmd[3] << 16) | (cmd[2] << 8) | (cmd[1]);
      return temp;
      break;
    default:
      return temp;
      break;
  }
  return temp;
}
int nextionAskPageNamper(byte port)
{
  int result;
  _nextionLissenStruct temp;
  nextionSendCommand("sendme", port);
  temp = nextionListen(port);
  if ((temp.code == 'f') && (temp.result != "")) {
    result = temp.result.toInt();
  } else {
    result = -1;
  }
  return result;
}


Ein kurzes Video mit einer Demonstration.


Archivieren Sie mit dem Projekt für das Panel und dem Projekt für die Steuerung.
In der nächsten Lektion lernen wir, wie Sie den Arduino-Controller über das Bedienfeld steuern.

Source: https://habr.com/ru/post/de392685/


All Articles