O abordare diferită cu Nextion: 3 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

În primul meu proiect cu Arduino Nano conectat la ecranul tactil Nextion, scrisesem o serie lungă de comenzi care să fie comunicate către Nextion prin portul serial și acest lucru este inevitabil dacă trebuie să trimitem comenzi total independente, în momente aleatorii.

De asemenea, trebuie să recunosc că am petrecut mai mult timp în „luptă” cu bibliotecile decât orice altceva. Așa că am ajuns treptat să lucrez total fără bibliotecile grele ITEAD.

Curând mi-am dat seama că nu aveam nicio urgență să comunic lui Nextion modificările atributelor obiectelor vizuale, dar prefer să aștept până le-am colectat și le trimit la Nextion în ansamblu, când am obținut un grup complet.

Voi încerca să mă explic mai bine.

Când în proiectul meu compus din 16 indicații textuale vreau să activez sau să dezactivez unele dintre ele, o fac profitând de atributul „bco” care, pentru pornire, trece (de exemplu) de la gri închis la alb (dacă este în un dreptunghi negru) și invers pentru a opri.

În aplicația mea am găsit inutil să trimit 16 comenzi către portul serial în 16 momente diferite, câte una pentru fiecare „bco” din cele 16 semnale.

Prefer, în schimb, ca Arduino să colecteze semnalele care trebuie să fie „pornite” (HIGH) și care trebuie să fie „oprite” (LOW) într-un registru pe 16 biți, unde fiecare bit corespunde unuia dintre cele 16 semnalizări ale Nextion.

După actualizarea fiecărui bit al registrului, îi transmit valoarea lui Nextion, un singur mesaj care conține informații colective referitoare la 16 elemente.

În acest fel, comunicarea de la Arduino și Nextion este redusă considerabil, deoarece în acel mesaj unic transmis pe serial către Nextion, sunt colectate informații care altfel ar fi necesitat transmiterea a 16 mesaje.

Este adevărat, nu este întotdeauna necesar să se actualizeze toate rapoartele, dar sunt sigur că a face altfel ar pierde mai mult timp.

Bineînțeles, fiecare bit conținut în întregul primit de Arduino, afișajul Nextion va trebui să-l asocieze cu atributul dorit.

Aceasta înseamnă că codul trebuie să fie scris în afișajul Nextion, dar nu trebuie să mă sperii: dacă am reușit …

Apoi, există un avantaj dublu: Arduino va avea un cod mai ușor și va fi mai puțin implicat în comunicarea în serie cu Nextion.

Nextion după primirea datelor într-un singur mesaj, le va folosi mult mai repede decât dacă ar fi să aștepte 16 mesaje. Prin urmare, pornirea sau oprirea a 16 semnale va fi aproape contemporană în ceea ce privește modul cel mai obișnuit, în care timpul pentru un număr necunoscut de mesaje scade între executarea comenzii pentru prima semnalizare și comanda pentru ultima semnalizare.

În afișajul Nextion am creat acest sistem în mod clasic, adică rotirea unui registru „mască” de fiecare dată vă permite să examinați fiecare dintre cei 16 biți. Când bitul examinat este HIGH, semnalul asociat cu acel bit se aprinde pe afișaj și se oprește atunci când un bit este LOW.

Aspectul „negativ” al acestui sistem este că codul scris în afișajul Nextion este mai puțin convenabil să fie documentat decât codul Arduino. Mai mult, codul Nextion riscă să fie împrăștiat pe diferite obiecte. Trebuie să aveți grijă să documentați ceea ce faceți imediat.

Folosesc Notepad ++ pentru a scrie codul pe care îl copiez apoi în obiectul Nextion care este aproape exclusiv în tm0 din pagina 0.

Sintaxa limbajului Nextion are numeroase limitări, dar reușește să le depășească sau să le ocolească cu un efort minim și să încerce să vadă problemele din puncte de vedere care sunt, de asemenea, neobișnuite.

De exemplu, raportez modul în care Arduino scrie registrul de transmis, scris de mine în cel mai elementar mod posibil.

Pasul 1: Cum se transmite registrul

În fișierul ArduinoCode. PDF îmi arăt schița. (Citind codul aici jos nu este atât de clar)

Aici jos, vreau doar să arăt în ce mod Arduino trimite Registrul pe 16 biți către Nextion, fără ajutorul bibliotecilor, ci doar respectând sintaxa descrisă de ITEAD.

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

nul NexUpd ()

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

{

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

SRSerial.print (InpReg); // transmiteți cei 16 biți colectați pe afișajul Nextion

SRSerial.print (InpReg); // transmiteți cei 16 biți colectați pe afișajul Nextion

SRSerial.write (termin); // 255

SRSerial.write (termin); // 255

SRSerial.write (termin); // 255

}

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

Pasul 2:.. Dar înainte …

Desigur, codul începe cu toate declarațiile și setarea ().

Intrările sunt INPUT_PULLUP, deci comutatoarele de intrare sunt în mod normal deschise și când sunt închise, aplică GND la intrarea corespondentă.

(Acesta este primul meu instructabil și îmi pare rău să vă arăt codul meu în acest mod prost. Vă rugăm să descărcați fișierul ArduinoCode. PDF că este foarte clar.

Lasă-mă să vorbesc despre asta mai mult

Mi-am dezvoltat propriul mod de a „spune” afișajului Nextion ce trebuie să facă. De obicei, MCU (Arduino în cazul meu) trimite un mesaj pentru fiecare variantă care se aplică atributului oricărui obiect. Acest metod pierde mult timp pentru a face lucruri care nu sunt întotdeauna atât de urgente pentru a încărca în mod continuu Linia Serială. Mi s-a părut mai convenabil ca Arduino să colecteze în 16 biți registre informațiile despre atributele care trebuie să varieze pe Nextion. Aproximativ la fiecare 500 mS, Arduino-ul meu trimite către Nextion un mesaj care conține 16 biți din fiecare registru la un moment dat. Evident, în Nextion avem nevoie de codul care să gestioneze ceea ce trebuie executat. Această distribuție a sarcinii (și a codului) permite să obțină multe alte avantaje. De exemplu, gândiți-vă cum să faceți să clipească o lumină! Cu abordarea mea este ușor: setați un pic în registrul Arduino și trimiteți-l la Nextion. Registrele gemene Nextion ar putea fi actualizate foarte rar de la Arduino, deoarece frecvența clipirii este independentă de comunicare; frecvența clipirii depinde de un obiect Timer în Nextion și poate rula cu baza minimă de timp aproape de 50 mS. Deci, cu metoda mea putem clipi o lumină în Nextion la o frecvență relativ mare (să presupunem 2 Hz), chiar dacă Arduino-ul meu trimite mesaje la fiecare 10 secunde, doar pentru un exemplu extrem. Acest lucru poate sugera problema opusă: cum se face dacă comunicarea eșuează? Acesta nu este obiectul acestei discuții, dar am rezolvat deja această problemă cu un fel de Watch Dog: unul în Codul Arduino, altul în codul Nextion.

Clipirea este reglementată de codul Nextion, unde fiecare lumină respectă regulile sale adecvate: PORNIT / OPRIT sau VERZ / ROȘU sau schimbând, de asemenea, interiorul scris (sau altele mai multe). Aș putea spune câteva alte lucruri despre proiectul meu, dar prefer să vă aștept întrebările, înainte de a adăuga prea multe cuvinte care nu sunt atât de ușor pentru mine să traduc bine aș vrea.

Pasul 3: Editarea obiectelor Nextion

Iată o parte din codul pe care l-am scris cu Nextion Editor pe obiectul tm0.

Nu scapă de observația noastră că, cu cei 16 biți primiți de la Arduino, afișajul Nextion nu doar pornește și oprește semnalele. Pentru moment omit explicațiile pentru a nu complica înțelegerea.

Sunt începător și, prin urmare, este mai bine să descărcați codul Nextion. PDF pagina în loc să citiți codul confuz aici. (Îmi pare rău că acesta este primul meu instructable)

Dacă doriți, puteți descărca codul complet „HMI” pentru această aplicație. Numele fișierului acestui cod este POW1225. HMI. Poate rula în afișajul Nextion NX4024T032, dar pentru a-l înțelege trebuie să înotați în multe obiecte și să priviți codul în fereastra mică a editorului. Deci, cred că va fi mai ușor să căutați codul principal, scris în fișierul Nextion code. PDF

// Proiect POW1225. HMI 15 mai 2019

// vACC (va0) Acumulator

// vINP (va1) Registr de intrare xxxx xxxx xxxx xxxx

tm0.ro = 1 // tm0 Start

tm0.tim = 50 // tm0 Baza de timp 50 mS

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

vACC.val = vINP.val & 0x0001 // Mască

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

{

tRDY.pco = ALBASTRU // ROȘU

} altfel

{

tRDY.pco = GREY // dark GREY

}

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

vACC.val = vINP.val & 0x0002

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

{

tPWR.pco = VERDE // lumină VERDE

tPON.txt = "ON" // ON

tPON.pco = VERDE // VERDE deschis

} altfel

{

tPWR.pco = GREY // dark GREY 33808

tPON.txt = "OFF" // OFF

tPON.pco = GREY // dark GREY 33808

}

// DRY ***************

vACC.val = vINP.val & 0x0004

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

{

tDRV.pco = ALBASTRU // ALBASTRU

tDRY.pco = ALBASTRU // ALBASTRU

} altfel

{

tDRV.pco = GREY // dark GREY 33808

tDRY.pco = GREY // dark GREY 33808

}

// ALERGA ***************

vACC.val = vINP.val & 0x0018

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

{

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

tRUN.pco = BLACK // pe BLACK

tDIR.bco = RED // DIR RED

tDIR.pco = BLACK // pe BLACK

} altfel

{

tRUN.bco = 32768 // MARCIA GREY (oprit)

tRUN.pco = GREY // pe GREY

tDIR.bco = 32768 // DIR GREEN închis 1024

tDIR.pco = GREY // DIR GREY

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

}

// STÂNGA **************

vACC.val = vINP.val & 0x0008

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

{

tDIR.txt = "<<<" // DIR STÂNGA

}

// DREAPTA *************

vACC.val = vINP.val & 0x0010

if (vACC.val! = 0) // Test RUN la stânga

{

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

}

// AMBII **************

vACC.val = vINP.val & 0x0018

if (vACC.val == 24) // Testează RUN ambele

{

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

}

// TEST **************

vACC.val = vINP.val & 0x0020

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

{

tTEST.pco = ALB // ALB

tsw tTEST, 1 // Activați evenimentele tactile

} altfel

{

tTEST.pco = GREY // dark GREY 33808

tsw tTEST, 0 // Dezactivează evenimentele tactile

}

// FAULT *************

vACC.val = vINP.val & 0x0040

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

{

tFLT.pco = GREY // FAULT absent

}

if (vACC.val! = 0)

{

tFLT.pco = GALBEN // FAULT prezent

}

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

vACC.val = vINP.val & 0x0080

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

{

tEME.pco = GREY // EME absent

}

if (vACC.val! = 0)

{

tEME.pco = RED // EME prezent

}

}

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

vACC.val = vINP.val & 0x0100

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

{

tFER.pco = BLACK // BLACK

tFER.bco = VERDE // VERDE

} altfel

{

tFER.pco = GREY // GREY

tFER.bco = 672 // VERDE închis

}

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

Confirmare

Vreau să-i mulțumesc lui Gideon Rossouwv pentru că citind instructabilele sale am câștigat rapid o parte din obiectivele mele. Mulțumesc d-le. Gideon Rossouwv