Een andere aanpak met Nextion: 3 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

In mijn eerste project met Arduino Nano aangesloten op het aanraakscherm van Nextion, had ik een lange reeks opdrachten geschreven die via de seriële poort naar Nextion moesten worden gecommuniceerd en dit is onvermijdelijk als we op willekeurige momenten totaal onafhankelijke opdrachten moeten verzenden.

Ik moet ook toegeven dat ik meer tijd heb besteed aan 'vechten' met bibliotheken dan aan iets anders. Dus kwam ik geleidelijk aan volledig zonder de zware ITEAD-bibliotheken aan het werk.

Ik realiseerde me al snel dat ik geen urgentie had om de veranderingen in de attributen van visuele objecten aan Nextion te communiceren, maar ik wacht liever tot ik ze heb verzameld en stuur ze naar Nextion als geheel, wanneer ik een complete groep heb.

Ik zal proberen mezelf beter uit te leggen.

Wanneer ik in mijn project, bestaande uit 16 tekstuele aanduidingen, enkele daarvan wil in- of uitschakelen, doe ik dat door gebruik te maken van het 'bco'-attribuut dat voor inschakelen (bijvoorbeeld) van donkergrijs naar wit (indien in een zwarte rechthoek), en vice versa om uit te schakelen.

In mijn applicatie vond ik het nutteloos om op 16 verschillende momenten 16 commando's naar de seriële poort te sturen, één voor elke 'bco' van de 16 signalen.

In plaats daarvan geef ik er de voorkeur aan dat Arduino verzamelt welke signalen 'aan' (HOOG) moeten zijn en welke 'uit' (LAAG) moeten zijn in een 16-bits register, waarbij elk bit overeenkomt met een van de 16 signaleringen van Nextion.

Nadat ik elk bit van het register heb bijgewerkt, stuur ik de waarde ervan naar Nextion, een enkel bericht dat een collectieve informatie bevat over 16 elementen.

Op deze manier wordt de communicatie van Arduino en Nextion aanzienlijk verminderd, omdat in dat ene bericht dat via de seriële naar Nextion wordt verzonden, informatie wordt verzameld die anders 16 berichten zou hebben verzonden.

Toegegeven, het is niet altijd nodig om alle rapporten bij te werken, maar ik ben er zeker van dat anders meer tijd zou verspillen.

Natuurlijk moet elke bit in het gehele getal dat door Arduino wordt ontvangen, door het Nextion-display worden gekoppeld aan het gewenste attribuut.

Dit betekent dat er code moet worden geschreven in het Nextion-display, maar het is niet om bang te zijn: als het me gelukt is …

Dan is er een dubbel voordeel: Arduino zal een lichtere code hebben en minder bezig zijn met seriële communicatie met Nextion.

Nextion zal na ontvangst van de gegevens in een enkel bericht ze veel sneller gebruiken dan wanneer het zou wachten op 16 berichten. Het aan- of uitzetten van 16 seinen zal dus bijna gelijktijdig zijn ten opzichte van de meest gebruikelijke modus, waarin de tijd voor een onbekend aantal berichten verstrijkt tussen het uitvoeren van het commando voor de eerste signalering en het commando voor de laatste signalering.

In het Nextion-display heb ik dit systeem op de klassieke manier gemaakt, dat wil zeggen, door elke keer aan een 'masker'-register te draaien, kun je elk van de 16 bits onderzoeken. Wanneer het onderzochte bit HOOG is, licht het signaal dat bij dat bit hoort op het scherm op en gaat uit wanneer een bit LAAG is.

Het 'negatieve' aspect van dit systeem is dat de code die in het Nextion-display is geschreven, minder gemakkelijk te documenteren is dan de Arduino-code. Bovendien dreigt de Nextion-code over verschillende objecten te worden verspreid. Zorg ervoor dat u meteen documenteert wat u doet.

Ik gebruik Notepad ++ om de code te schrijven die ik vervolgens kopieer naar het Nextion-object dat zich bijna uitsluitend in tm0 van pagina 0 bevindt.

De syntaxis van de Nextion-taal heeft tal van beperkingen, maar het slaagt erin deze met een minimum aan inspanning te overwinnen of te omzeilen en te proberen de problemen te zien vanuit oogpunten die ook ongebruikelijk zijn.

Als voorbeeld rapporteer ik de manier waarop Arduino het te verzenden register schrijft, door mij op de meest elementaire manier mogelijk geschreven.

Stap 1: Hoe het register wordt verzonden

In het bestand ArduinoCode. PDF laat ik al mijn schetsen zien. (Als ik de code hier beneden lees, is het niet zo duidelijk)

Hieronder wil ik alleen laten zien op welke manier Arduino het 16 bit Register naar Nextion stuurt, zonder de hulp van de bibliotheken, maar met respect voor de syntaxis beschreven door ITEAD.

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

ongeldig NexUpd()

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

{

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

SRSerial.print(InpReg); // verzend de 16 verzamelde bits naar de Nextion Display

SRSerial.print(InpReg); // verzend de 16 verzamelde bits naar de Nextion Display

SRSerial.write(termin); // 255

SRSerial.write(termin); // 255

SRSerial.write(termin); // 255

}

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

Stap 2:.. Maar voordat …

Natuurlijk begint de code met alle declaraties en de setup().

De ingangen zijn INPUT_PULLUP, dus de ingangsschakelaars zijn normaal open en wanneer ze gesloten zijn, passen ze de GND toe op de corresponderende ingang.

(Dit is mijn eerste Instructable en het spijt me je mijn code op deze slechte manier te laten zien. Download het bestand ArduinoCode. PDF dat het heel duidelijk is.

Laat me er meer over praten

Ik heb mijn eigen manier ontwikkeld om de Nextion-display te 'vertellen' wat hij moet doen. Gewoonlijk stuurt de MCU (Arduino in mijn geval) een bericht voor elke variatie om toe te passen op het attribuut van een enkel object. Deze methode verspilt veel tijd om dingen te doen die niet altijd zo dringend zijn om de seriële lijn continu te laden. Ik vond het handiger dat Arduino de informatie over de attributen verzamelt in 16-bits registers om op Nextion te variëren. Ongeveer elke 500 mS stuurt mijn Arduino één bericht naar Nextion met daarin de 16 bits die in elk register tegelijk zitten. Het is duidelijk dat we in Nextion de code nodig hebben die afhandelt wat moet worden uitgevoerd. Deze verdeling van de taak (en de code) heeft vele andere voordelen opgeleverd. Bedenk bijvoorbeeld hoe je een lampje kunt laten knipperen! Met mijn aanpak is het eenvoudig: zet een bit in het Arduino-register en stuur het naar Nextion. De Nextion dubbele registers kunnen zeer zelden worden bijgewerkt vanuit Arduino, omdat de knipperfrequentie onafhankelijk is van de communicatie; de knipperfrequentie is afhankelijk van een Timer-object naar Nextion en kan worden uitgevoerd met een minimale tijdbasis in de buurt van 50 mS. Dus met mijn methode kunnen we een lampje in Nextion laten knipperen met een relatief hoge frequentie (stel 2 Hz), zelfs als mijn Arduino elke 10 seconden berichten verzendt, alleen voor een extreem voorbeeld. Dit kan wijzen op het tegenovergestelde probleem: hoe te handelen als de communicatie faalt? Dit is niet het onderwerp van deze discussie, maar ik heb dit probleem al opgelost met een soort Watch Dog: een in de Arduino-code, een andere in de Nextion-code.

Het knipperen wordt geregeld door Nextion-code, waarbij elk lampje zijn eigen regels volgt: AAN/UIT of GROEN/ROOD of ook het veranderen van de geschreven binnenkant (of andere meer). Ik zou nog wat andere dingen over mijn project kunnen vertellen, maar ik wacht liever op uw vragen voordat ik te veel woorden toevoeg die niet zo gemakkelijk voor mij zijn om goed te vertalen als ik zou doen.

Stap 3: De Nextion-objecten bewerken

Hier is een deel van de code die ik met Nextion Editor op het tm0-object heb geschreven.

Het ontgaat ons niet dat met de 16 bits die van Arduino worden ontvangen, het Nextion-display niet alleen de signalen in- en uitschakelt. Voorlopig laat ik de uitleg achterwege om het begrip niet te bemoeilijken.

Ik ben een beginner en daarom is het beter om in plaats daarvan de Nextion code. PDF-pagina te downloaden om de verwarde code hier beneden te lezen. (Het spijt me dat dit mijn eerste instructable is)

Indien u wenst kunt u de volledige code "HMI" voor deze mijn applicatie downloaden. De bestandsnaam van deze code is POW1225. HMI. Het kan je Nextion-display NX4024T032 tegenkomen, maar om het te begrijpen, moet je in veel objecten zwemmen en de code in het kleine venster van de editor bekijken. Dus ik denk dat het gemakkelijker zal zijn om de hoofdcode te bekijken, geschreven in het bestand Nextion code. PDF

// Project POW1225. HMI 15 mei 2019

// vACC (va0) Accumulator

// vINP (va1) Invoerregister xxxx xxxx xxxx xxxx

tm0.en=1 // tm0 Start

tm0.tim=50 // tm0 Tijdbasis 50 mS

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

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

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

{

tRDY.pco=BLAUW // ROOD

}anders

{

tRDY.pco=GRIJS // donkerGRIJS

}

// PWR ***************

vACC.val=vINP.val&0x0002

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

{

tPWR.pco=GROEN // lichtGROEN

tPON.txt="AAN" // AAN

tPON.pco=GROEN // lichtGROEN

}anders

{

tPWR.pco=GRIJS // donkerGRIJS 33808

tPON.txt="UIT" // UIT

tPON.pco=GRIJS // donkerGRIJS 33808

}

// DROOG ***************

vACC.val=vINP.val&0x0004

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

{

tDRV.pco=BLAUW // BLAUW

tDRY.pco=BLAUW // BLAUW

}anders

{

tDRV.pco=GRIJS // donkerGRIJS 33808

tDRY.pco=GRIJS // donkerGRIJS 33808

}

// LOOP ***************

vACC.val=vINP.val&0x0018

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

{

tRUN.bco=RED // MARCIA RED (aan)

tRUN.pco=ZWART // op ZWART

tDIR.bco=ROOD // DIR ROOD

tDIR.pco=ZWART // op ZWART

}anders

{

tRUN.bco=32768 // MARCIA GRIJS (uit)

tRUN.pco=GRIJS // op GRIJS

tDIR.bco=32768 // DIR donker GROEN 1024

tDIR.pco=GRIJS // DIR GRIJS

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

}

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

vACC.val=vINP.val&0x0008

if(vACC.val!=0) // Test RUN Rechts

{

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

}

// RECHTSAF *************

vACC.val=vINP.val&0x0010

if(vACC.val!=0) // Test UITVOEREN Links

{

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

}

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

vACC.val=vINP.val&0x0018

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

{

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

}

// TOETS **************

vACC.val=vINP.val&0x0020

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

{

tTEST.pco=WIT // WIT

tsw tTEST, 1 // Touch-gebeurtenissen inschakelen

}anders

{

tTEST.pco=GRIJS // donkerGRIJS 33808

tsw tTEST, 0 // Touch-gebeurtenissen uitschakelen

}

// SCHULD *************

vACC.val=vINP.val&0x0040

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

{

tFLT.pco=GRIJS // FOUT afwezig

}

if(vACC.val!=0)

{

tFLT.pco=GEEL // STORING aanwezig

}

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

vACC.val=vINP.val&0x0080

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

{

tEME.pco=GRIJS // EME afwezig

}

if(vACC.val!=0)

{

tEME.pco=ROOD // EME aanwezig

}

}

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

vACC.val=vINP.val&0x0100

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

{

tFER.pco=ZWART // ZWART

tFER.bco=GROEN // GROEN

}anders

{

tFER.pco=GRIJS // GRIJS

tFER.bco=672 // donkerGROEN

}

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

Erkenning

Ik wil mijn dank aan Gideon Rossouwv geven omdat ik door het lezen van zijn Instructables snel een deel van mijn doelstellingen heb bereikt. Dank u meneer. Gideon Rossouwv