Ein anderer Ansatz mit Nextion - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:18

In meinem ersten Projekt mit Arduino Nano, das mit dem Nextion-Touchdisplay verbunden war, hatte ich eine lange Reihe von Befehlen geschrieben, die über den seriellen Port an Nextion übermittelt wurden, und dies ist unvermeidlich, wenn wir in zufälligen Momenten völlig unabhängige Befehle senden müssen.

Ich muss auch zugeben, dass ich mehr Zeit damit verbracht habe, mit Bibliotheken zu „kämpfen“als mit allem anderen. So kam ich nach und nach dazu, ganz ohne die schweren ITEAD-Bibliotheken zu arbeiten.

Ich erkannte bald, dass ich keine Dringlichkeit hatte, Nextion die Änderungen an den Attributen von visuellen Objekten mitzuteilen, aber ich warte lieber, bis ich sie gesammelt und als Ganzes an Nextion gesendet habe, wenn ich eine vollständige Gruppe habe.

Ich werde versuchen, mich besser zu erklären.

Wenn ich in meinem Projekt, das aus 16 Textanzeigen besteht, einige von ihnen ein- oder ausschalten möchte, mache ich dies, indem ich das 'bco'-Attribut ausnutze, das beim Einschalten (zum Beispiel) von dunkelgrau zu weiß übergeht (wenn in ein schwarzes Rechteck) und umgekehrt zum Ausschalten.

In meiner Anwendung fand ich es nutzlos, 16 Befehle in 16 verschiedenen Momenten an den seriellen Port zu senden, einen für jedes 'bco' der 16 Signale.

Ich bevorzuge stattdessen, dass Arduino in einem 16-Bit-Register sammelt, welche Signale "an" (HIGH) und welche "aus" (LOW) sein müssen, in einem 16-Bit-Register, wobei jedes Bit einer der 16 Signalisierungen von Nextion entspricht.

Nachdem ich jedes Bit des Registers aktualisiert habe, übertrage ich seinen Wert an Nextion, eine einzelne Nachricht, die eine Sammelinformation über 16 Elemente enthält.

Auf diese Weise wird die Kommunikation von Arduino und Nextion erheblich reduziert, da in dieser einzigen Nachricht, die seriell an Nextion übertragen wird, Informationen gesammelt werden, die sonst die Übertragung von 16 Nachrichten erfordert hätten.

Es ist zwar nicht immer notwendig, alle Berichte zu aktualisieren, aber ich bin sicher, dass sonst mehr Zeit verschwendet würde.

Natürlich muss das Nextion-Display jedes Bit, das in der von Arduino empfangenen Ganzzahl enthalten ist, dem gewünschten Attribut zuordnen.

Dies bedeutet, dass Code in das Nextion-Display geschrieben werden muss, aber es ist nicht zu erschrecken: wenn es mir gelungen ist …

Dann gibt es einen doppelten Vorteil: Arduino wird einen leichteren Code haben und weniger an der seriellen Kommunikation mit Nextion beteiligt sein.

Nextion wird die Daten nach dem Empfang in einer einzigen Nachricht viel schneller verwenden, als wenn es auf 16 Nachrichten warten würde. Das Ein- oder Ausschalten von 16 Signalen erfolgt daher nahezu zeitgleich mit dem üblichsten Modus, bei dem die Zeit für eine unbekannte Anzahl von Nachrichten zwischen der Ausführung des Befehls für die erste Signalisierung und dem Befehl für die letzte Signalisierung verstreicht.

In der Nextion-Anzeige habe ich dieses System auf klassische Weise erstellt, dh jedes Mal, wenn Sie ein 'Masken'-Register drehen, können Sie jedes der 16 Bits untersuchen. Wenn das untersuchte Bit HIGH ist, leuchtet das diesem Bit zugeordnete Signal auf der Anzeige auf und erlischt, wenn ein Bit LOW ist.

Der "negative" Aspekt dieses Systems ist, dass der im Nextion-Display geschriebene Code weniger bequem zu dokumentieren ist als der Arduino-Code. Darüber hinaus besteht die Gefahr, dass der Nextion-Code über verschiedene Objekte verstreut wird. Es muss darauf geachtet werden, dass Sie sofort dokumentieren, was Sie tun.

Ich benutze Notepad ++, um den Code zu schreiben, den ich dann in das Nextion-Objekt kopiere, das sich fast ausschließlich in tm0 von Seite 0 befindet.

Die Syntax der Nextion-Sprache weist zahlreiche Einschränkungen auf, aber sie schafft es, diese mit minimalem Aufwand zu überwinden bzw. zu umgehen und zu versuchen, die Probleme auch aus ungewöhnlichen Blickwinkeln zu betrachten.

Als Beispiel berichte ich, wie Arduino das zu übertragende Register schreibt, von mir so elementar wie möglich geschrieben.

Schritt 1: Wie das Register übertragen wird

In der Datei ArduinoCode. PDF zeige ich alle meine Skizzen. (Wenn man den Code hier unten liest, ist es nicht so klar)

Hier unten möchte ich nur zeigen, auf welche Weise Arduino das 16-Bit-Register an Nextion sendet, ohne die Hilfe der Bibliotheken, sondern nur unter Beachtung der von ITEAD beschriebenen Syntax.

//***************************************************************************************

void NexUpd()

//***************************************************************************************

{

SRSerial.print("vINP.val=");

SRSerial.print (InpReg); // die 16 gesammelten Bits an das Nextion Display übertragen

SRSerial.print (InpReg); // die 16 gesammelten Bits an das Nextion Display übertragen

SRSerial.write(termin); // 255

SRSerial.write(termin); // 255

SRSerial.write(termin); // 255

}

//***************************************************************************************

Schritt 2:.. Aber vorher …

Natürlich beginnt der Code mit allen Deklarationen und dem setup().

Die Eingänge sind INPUT_PULLUP, also sind die Eingangsschalter normalerweise offen und wenn sie geschlossen sind, legen sie GND an den entsprechenden Eingang an.

(Dies ist mein erstes Instructable und es tut mir leid, Ihnen meinen Code auf diese schlechte Weise zu zeigen. Bitte laden Sie die Datei ArduinoCode. PDF herunter, die sehr klar ist.

Lass mich mehr darüber reden

Ich habe meine eigene Methode entwickelt, um dem Nextion-Display zu „sagen“, was es tun muss. Normalerweise sendet die MCU (in meinem Fall Arduino) eine Nachricht für jede einzelne Variation, die auf das Attribut eines einzelnen Objekts angewendet wird. Diese Methode verschwendet viel Zeit, um Dinge zu tun, die nicht immer so dringend sind, um die serielle Leitung kontinuierlich zu laden. Ich fand es bequemer, dass Arduino die Informationen über die Attribute, die auf Nextion variieren sollen, in 16-Bit-Registern sammelt. Ungefähr alle 500 ms sendet mein Arduino eine Nachricht an Nextion, die jeweils die 16 Bit enthält, die in jedem Register enthalten sind. Offensichtlich brauchen wir in Nextion den Code, der handhabt, was ausgeführt werden muss. Diese Verteilung der Aufgabe (und des Codes) bringt viele weitere Vorteile mit sich. Denken Sie zum Beispiel daran, wie man Blinken zu einem Licht macht! Bei meinem Ansatz ist es einfach: ein bisschen in das Arduino-Register setzen und an Nextion senden. Die Nextion-Zwillingsregister können sehr selten von Arduino aktualisiert werden, da die Blinkfrequenz unabhängig von der Kommunikation ist; die Blinkfrequenz hängt von einem Timer-Objekt in Nextion ab und kann mit der minimalen Zeitbasis nahe 50 mS laufen. Mit meiner Methode können wir also in Nextion ein Licht mit relativ hoher Frequenz blinken lassen (angenommen 2 Hz), auch wenn mein Arduino alle 10 Sekunden Nachrichten sendet, nur für ein extremes Beispiel. Dies kann auf das gegenteilige Problem hinweisen: Wie ist vorzugehen, wenn die Kommunikation fehlschlägt? Dies ist nicht Gegenstand dieser Diskussion, aber ich habe dieses Problem bereits mit einer Art Watch Dog gelöst: einen im Arduino-Code, einen anderen im Nextion-Code.

Das Blinken wird durch den Nextion-Code geregelt, bei dem jedes Licht seinen eigenen Regeln folgt: EIN/AUS oder GRÜN/ROT oder auch das Wechseln der geschriebenen Innenseite (oder andere mehr). Ich könnte noch einige andere Dinge über mein Projekt erzählen, aber ich warte lieber auf Ihre Fragen, bevor ich zu viele Wörter hinzufüge, die für mich nicht so leicht zu übersetzen sind, wie ich es tun würde.

Schritt 3: Bearbeiten der Nextion-Objekte

Hier ist ein Teil des Codes, den ich mit Nextion Editor für das tm0-Objekt geschrieben habe.

Es entgeht uns nicht, dass das Nextion-Display mit den von Arduino empfangenen 16 Bits nicht nur die Signale ein- und ausschaltet. Die Erläuterungen lasse ich vorerst weg, um das Verständnis nicht zu erschweren.

Ich bin ein Anfänger und daher ist es besser, die Nextion code. PDF-Seite herunterzuladen, anstatt den verwirrten Code hier unten zu lesen. (Es tut mir leid, dies ist mein erstes instructable)

Wenn Sie möchten, können Sie den vollständigen Code "HMI" für diese meine Anwendung herunterladen. Der Dateiname dieses Codes ist POW1225. HMI. Es kann in Ihr Nextion-Display NX4024T032 laufen, aber um es zu verstehen, müssen Sie in viele Objekte schwimmen und den Code in dem kleinen Fenster des Editors betrachten. Ich denke also, dass der Hauptcode einfacher aussehen wird, der in der Datei Nextion code. PDF geschrieben ist

// Projekt POW1225. HMI 15. Mai 2019

// vACC (va0) Akkumulator

// vINP (va1) Eingangsregister xxxx xxxx xxxx xxxx

tm0.en=1 // tm0 Start

tm0.tim=50 // tm0 Zeitbasis 50 mS

// RDY **************

vACC.val=vINP.val&0x0001 // Maske

if(vACC.val!=0) // Test RDY

{

tRDY.pco=BLAU // ROT

}anders

{

tRDY.pco=GRAY // dunkelGRAU

}

// DWR ****************

vACC.val=vINP.val&0x0002

if(vACC.val!=0) // Test PWR

{

tPWR.pco=GRÜN // hell GRÜN

tPON.txt="EIN" // EIN

tPON.pco=GRÜN // hell GRÜN

}anders

{

tPWR.pco=GRAY // dunkelGRAU 33808

tPON.txt="OFF" // OFF

tPON.pco=GRAY // dunkelGRAU 33808

}

// TROCKEN ***************

vACC.val=vINP.val&0x0004

if(vACC.val!=0) // Test DRY

{

tDRV.pco=BLAU // BLAU

tDRY.pco=BLAU // BLAU

}anders

{

tDRV.pco=GRAY // dunkelGRAU 33808

tDRY.pco=GRAY // dunkelGRAU 33808

}

// LAUF ***************

vACC.val=vINP.val&0x0018

if(vACC.val!=0) // Testlauf

{

tRUN.bco=RED // MARCIA ROT (an)

tRUN.pco=SCHWARZ // auf SCHWARZ

tDIR.bco=RED // DIR ROT

tDIR.pco=BLACK // auf SCHWARZ

}anders

{

tRUN.bco=32768 // MARCIA GRAU (aus)

tRUN.pco=GRAY // auf GRAU

tDIR.bco=32768 // DIR dunkelgrün 1024

tDIR.pco=GRAY // DIR GRAU

tDIR.txt="---" // STOP

}

// LINKS **************

vACC.val=vINP.val&0x0008

if(vACC.val!=0) // Testlauf rechts

{

tDIR.txt="<<< " // DIR LINKS

}

// RECHTS *************

vACC.val=vINP.val&0x0010

if(vACC.val!=0) // Testlauf links

{

tDIR.txt=" >>>" // DIR RECHTS

}

// BEIDE **************

vACC.val=vINP.val&0x0018

if(vACC.val==24) // Test RUN beide

{

tDIR.txt=">>!<<" // DIR BOTH

}

// PRÜFUNG **************

vACC.val=vINP.val&0x0020

if(vACC.val!=0) // Test TEST

{

tTEST.pco=WEISS // WEISS

tsw tTEST, 1 // Touch-Ereignisse aktivieren

}anders

{

tTEST.pco=GRAY // dunkelGRAU 33808

tsw tTEST, 0 // Touch-Ereignisse deaktivieren

}

// FEHLER *************

vACC.val=vINP.val&0x0040

if(vACC.val==0) // Test FEHLER

{

tFLT.pco=GRAY // FEHLER fehlt

}

if(vACC.val!=0)

{

tFLT.pco=YELLOW // FEHLER vorhanden

}

// EME **************

vACC.val=vINP.val&0x0080

if(vACC.val==0) // EME testen

{

tEME.pco=GRAY // EME fehlt

}

if(vACC.val!=0)

{

tEME.pco=RED // EME vorhanden

}

}

// FERMO *************

vACC.val=vINP.val&0x0100

if(vACC.val!=0) // Test FERMO

{

tFER.pco=SCHWARZ // SCHWARZ

tFER.bco=GRÜN // GRÜN

}anders

{

tFER.pco=GRAU // GRAU

tFER.bco=672 // dunkelGRÜN

}

// *******************

Wissen

Ich möchte Gideon Rossouwv meine Anerkennung aussprechen, weil ich beim Lesen seiner Instructables schnell einen Teil meiner Ziele erreicht habe. Danke Herr. Gideon Rossouwv