Un enfocament diferent amb Nextion: 3 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:13

En el meu primer projecte amb Arduino Nano connectat a la pantalla tàctil de Nextion, havia escrit una llarga sèrie d’ordres per comunicar-les a Nextion mitjançant el port sèrie i això és inevitable si necessitem enviar ordres totalment independents, en moments aleatoris.

També he de reconèixer que vaig passar més temps "lluitant" amb les biblioteques que qualsevol altra cosa. Així doncs, vaig anar treballant a poc a poc sense les pesades biblioteques ITEAD.

Aviat em vaig adonar que no tenia urgència de comunicar a Nextion els canvis en els atributs dels objectes visuals, però prefereixo esperar a recollir-los i enviar-los a Nextion en general, quan vaig obtenir un grup complet.

Intentaré explicar-me millor.

Quan en el meu projecte compost per 16 indicacions textuals vull activar o desactivar algunes d'elles, ho faig aprofitant l'atribut "bco" que, per activar, passa (per exemple) de gris fosc a blanc (si està activat) un rectangle negre) i viceversa per apagar-se.

A la meva aplicació em va semblar inútil enviar 16 ordres al port sèrie en 16 moments diferents, una per a cada "bco" dels 16 senyals.

En lloc d'això, prefereixo que Arduino reculli quins senyals han d'estar "encès" (ALT) i quins han d'estar "apagats" (BAIX) en un registre de 16 bits, on cada bit correspon a una de les 16 senyalitzacions de Nextion.

Després d’actualitzar cada bit del registre, transmet el seu valor a Nextion, un missatge únic que conté una informació col·lectiva sobre 16 elements.

D’aquesta manera, la comunicació des d’Arduino i Nextion es redueix considerablement, ja que en aquell missatge únic que es transmet en sèrie a Nextion, es recull informació que d’altra manera hauria requerit la transmissió de 16 missatges.

És cert que no sempre cal actualitzar tots els informes, però estic segur que fer una altra cosa perdria més temps.

Naturalment, cada bit que conté l’enter rebut per Arduino, la pantalla Nextion l’haurà d’associar a l’atribut desitjat.

Això vol dir que el codi s'ha d'escriure a la pantalla de Nextion, però no s'ha d'espantar: si he tingut èxit …

Hi ha un doble avantatge: Arduino tindrà un codi més lleuger i participarà menys en la comunicació en sèrie amb Nextion.

Nextion després de rebre les dades en un sol missatge, les utilitzarà molt més ràpidament que si esperés 16 missatges. Per tant, l’encesa o apagada de 16 senyals serà gairebé contemporània respecte al mode més habitual, en què transcorre el temps per a un nombre desconegut de missatges entre l’execució de l’ordre per a la primera senyalització i l’ordre per a la darrera senyalització.

A la pantalla de Nextion vaig crear aquest sistema de manera clàssica, és a dir, girar un registre de "màscara" cada vegada us permet examinar cadascun dels 16 bits. Quan el bit examinat és ALT, el senyal associat amb aquest bit s'encén a la pantalla i s'apaga quan un bit és BAIX.

L'aspecte "negatiu" d'aquest sistema és que el codi escrit a la pantalla Nextion és menys convenient documentar-se que el codi Arduino. A més, el codi Nextion corre el risc de ser escampat per diversos objectes. Cal tenir cura de documentar el que feu immediatament.

Utilitzo Notepad ++ per escriure el codi que després copio a l’objecte Nextion que es troba gairebé exclusivament a tm0 de la pàgina 0.

La sintaxi del llenguatge Nextion té nombroses limitacions, però aconsegueix superar-les o evitar-les amb un mínim d’esforç i intentar veure els problemes des de punts de vista que també són inusuals.

Com a exemple, informo de la forma en què Arduino escriu el registre que es vol transmetre, escrit per mi de la manera més elemental possible.

Pas 1: Com es transmet el registre

Al fitxer ArduinoCode. PDF mostro tot el meu esbós. (Llegir el codi aquí avall no està tan clar)

A continuació, només vull mostrar de quina manera Arduino envia el registre de 16 bits a Nextion, sense l'ajut de les biblioteques, però només respectant la sintaxi descrita per ITEAD.

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

void NexUpd ()

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

{

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

SRSerial.print (InpReg); // transmet els 16 bits recollits a la pantalla Nextion

SRSerial.print (InpReg); // transmet els 16 bits recollits a la pantalla Nextion

SRSerial.write (termin); // 255

SRSerial.write (termin); // 255

SRSerial.write (termin); // 255

}

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

Pas 2:.. Però abans …

Per descomptat, el codi comença amb totes les declaracions i la configuració ().

Les entrades són INPUT_PULLUP, de manera que els commutadors d’entrada normalment estan oberts i, quan estan tancats, apliquen el GND a l’entrada corresponent.

(Aquest és el meu primer instructiu i em sap greu mostrar-vos el meu codi d'aquesta mala manera. Si us plau, descarregueu el fitxer ArduinoCode. PDF que està molt clar.

Deixeu-me parlar-ne més

He desenvolupat la meva manera de "explicar" a la pantalla de Nextion què ha de fer. Normalment, l’MCU (Arduino en el meu cas) envia un missatge per a cada variació que s’aplica a l’atribut de qualsevol objecte. Aquest mètode perd molt de temps per fer coses que no sempre són tan urgents per carregar contínuament la línia de sèrie. Em va semblar més convenient que Arduino recollís en registres de 16 bits la informació sobre els atributs que poden variar a Nextion. Aproximadament cada 500 mS, el meu Arduino envia a Nextion un missatge que conté els 16 bits continguts a cada registre alhora. Viouslybviament, a Nextion necessitem el codi que gestioni el que s’ha d’executar. Aquesta distribució de la tasca (i del codi) permet obtenir molts altres avantatges. Per exemple, penseu com fer parpellejar una llum. Amb el meu enfocament és fàcil: introduïu una mica al registre Arduino i envieu-lo a Nextion. Els registres bessons de Nextion es podrien actualitzar des d’Arduino molt poques vegades, perquè la freqüència de parpelleig és independent de la comunicació; la freqüència de parpelleig depèn d'un objecte Timer a Nextion i pot funcionar amb una base de temps mínima propera als 50 mS. Així, amb el meu mètode podem parpellejar una llum a Nextion a una freqüència relativament alta (suposem que 2 Hz), fins i tot si el meu Arduino envia missatges cada 10 segons, només per un exemple extrem. Això pot suggerir el problema contrari: com fer-ho si la comunicació falla? Aquest no és l'objecte d'aquesta discussió, però ja he resolt aquest problema amb una mena de Watch Dog: un dins del codi Arduino i un altre al codi Nextion.

El parpelleig està regulat pel codi Nextion, on cada llum segueix les seves regles adequades: ON / OFF o VERD / VERMELL o també canviant l’interior escrit (o altres més). Podria explicar algunes coses més sobre el meu projecte, però prefereixo esperar les vostres preguntes abans d'afegir massa paraules que no em resultin tan fàcils de traduir com ho faria.

Pas 3: Edició dels objectes Nextion

Aquí teniu una part del codi que vaig escriure amb Nextion Editor a l’objecte tm0.

No s’escapa de l’avís que amb els 16 bits rebuts d’Arduino, la pantalla Nextion no només activa i desactiva els senyals. De moment omet les explicacions per no complicar la comprensió.

Sóc principiant i, per tant, és millor descarregar el codi de Nextion. PDF pàgina en lloc de llegir el codi confús aquí baix. (Ho sento, aquest és el meu primer instructable)

Si ho desitgeu, podeu descarregar el codi complet "HMI" d'aquesta aplicació. El nom del fitxer d'aquest codi és POW1225. HMI. Es pot executar a la pantalla Nextion NX4024T032, però per entendre-la heu de nedar en molts objectes i mirar el codi a la finestra petita de l'editor. Per tant, crec que serà més fàcil buscar el codi principal, escrit al fitxer Nextion code. PDF

// Projecte POW1225. HMI el 15 de maig de 2019

// VACC (va0) Acumulador

// vINP (va1) Registre d'entrada xxxx xxxx xxxx xxxx

tm0.en = 1 // tm0 Inici

tm0.tim = 50 // tm0 Base de temps 50 mS

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

vACC.val = vINP.val i 0x0001 // Màscara

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

{

tRDY.pco = BLAU // VERMELL

} altra cosa

{

tRDY.pco = GRIS // GRIS fosc

}

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

vACC.val = vINP.val i 0x0002

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

{

tPWR.pco = VERD // VERD clar

tPON.txt = "ACTIVAT" // ACTIVAT

tPON.pco = VERD // VERD clar

} altra cosa

{

tPWR.pco = GRIS // GRIS fosc 33808

tPON.txt = "DESACTIVAT" // DESACTIVAT

tPON.pco = GRIS // GRIS fosc 33808

}

// SEC ***************

vACC.val = vINP.val i 0x0004

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

{

tDRV.pco = BLAU // BLAU

tDRY.pco = BLAU // BLAU

} altra cosa

{

tDRV.pco = GRIS // GRIS fosc 33808

tDRY.pco = GRIS // GRIS fosc 33808

}

// CORRER ***************

vACC.val = vINP.val i 0x0018

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

{

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

tRUN.pco = NEGRE // a NEGRE

tDIR.bco = VERMELL // DIR VERMELL

tDIR.pco = NEGRE // a NEGRE

} altra cosa

{

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

tRUN.pco = GRIS // sobre GRIS

tDIR.bco = 32768 // DIR GREEN fosc 1024

tDIR.pco = GRIS // DIR GRIS

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

}

// ESQUERRA **************

vACC.val = vINP.val i 0x0008

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

{

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

}

// DRET *************

vACC.val = vINP.val i 0x0010

if (vACC.val! = 0) // Prova RUN left

{

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

}

// TOTS DOS **************

vACC.val = vINP.val i 0x0018

if (vACC.val == 24) // Prova RUN tots dos

{

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

}

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

vACC.val = vINP.val i 0x0020

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

{

tTEST.pco = BLANC // BLANC

tsw tTEST, 1 // Activa els esdeveniments tàctils

} altra cosa

{

tTEST.pco = GRIS // GRIS fosc 33808

tsw tTEST, 0 // Desactiva els esdeveniments tàctils

}

// FALL *************

vACC.val = vINP.val i 0x0040

if (vACC.val == 0) // FALTA de la prova

{

tFLT.pco = GRIS // FALLA absent

}

if (vACC.val! = 0)

{

tFLT.pco = GROC // FALL present

}

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

vACC.val = vINP.val i 0x0080

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

{

tEME.pco = GRIS // EME absent

}

if (vACC.val! = 0)

{

tEME.pco = VERMELL // EME present

}

}

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

vACC.val = vINP.val i 0x0100

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

{

tFER.pco = NEGRE // NEGRE

tFER.bco = VERD // VERD

} altra cosa

{

tFER.pco = GRIS // GRIS

tFER.bco = 672 // VERD fosc

}

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

Reconeixement

Vull donar els meus agraïments a Gideon Rossouwv perquè llegint els seus instructables he guanyat ràpidament part dels meus objectius. Gràcies senyor. Gideon Rossouwv