Un approccio diverso con Nextion: 3 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

Nel mio primo progetto con Arduino Nano collegato al display touch Nextion, avevo scritto una lunga serie di comandi da comunicare a Nextion tramite la porta seriale e questo è inevitabile se dobbiamo inviare comandi totalmente indipendenti, in momenti casuali.

Devo anche ammettere che ho passato più tempo a "combattere" con le biblioteche che con qualsiasi altra cosa. Quindi gradualmente sono arrivato a lavorare totalmente senza le pesanti librerie ITEAD.

Mi sono subito reso conto che non avevo urgenza di comunicare a Nextion le modifiche agli attributi degli oggetti visivi, ma preferisco aspettare di raccoglierli e inviarli a Nextion nel loro insieme, quando ho ottenuto un gruppo completo.

Cercherò di spiegarmi meglio.

Quando nel mio progetto composto da 16 indicazioni testuali voglio attivarne o disattivarne alcune, lo faccio sfruttando l'attributo 'bco' che per l'accensione passa (ad esempio) dal grigio scuro al bianco (se in un rettangolo nero) e viceversa per spegnere.

Nella mia applicazione ho trovato inutile inviare 16 comandi alla porta seriale in 16 momenti diversi, uno per ogni 'bco' dei 16 segnali.

Preferisco invece che Arduino raccolga quali segnali devono essere 'on' (HIGH) e quali devono essere 'off' (LOW) in un registro a 16 bit, dove ogni bit corrisponde ad una delle 16 segnalazioni di Nextion.

Dopo aver aggiornato ogni bit del registro, trasmetto il suo valore a Nextion, un unico messaggio che contiene un'informazione collettiva relativa a 16 elementi.

In questo modo si riduce notevolmente la comunicazione tra Arduino e Nextion perché in quel singolo messaggio trasmesso sulla seriale a Nextion vengono raccolte informazioni che altrimenti avrebbero richiesto la trasmissione di 16 messaggi.

È vero, non è sempre necessario aggiornare tutti i rapporti, ma sono sicuro che fare diversamente farebbe perdere più tempo.

Naturalmente ogni bit contenuto nell'intero ricevuto da Arduino, il display Nextion dovrà associarlo all'attributo desiderato.

Questo significa che il codice va scritto nel display Nextion, ma non c'è da spaventarsi: se ci riuscissi…

C'è poi un doppio vantaggio: Arduino avrà un codice più leggero e sarà meno impegnato nella comunicazione seriale con Nextion.

Nextion dopo aver ricevuto i dati in un unico messaggio, li utilizzerà molto più rapidamente che se dovesse attendere 16 messaggi. L'accensione o lo spegnimento di 16 segnalazioni sarà quindi pressoché contemporanea rispetto alla modalità più usuale, in cui intercorre il tempo per un numero imprecisato di messaggi tra l'esecuzione del comando per la prima segnalazione e il comando per l'ultima segnalazione.

Nel display Nextion ho creato questo sistema nel modo classico, cioè girare ogni volta un registro 'maschera' permette di esaminare ciascuno dei 16 bit. Quando il bit esaminato è ALTO, il segnale associato a quel bit si accende sul display e si spegne quando un bit è BASSO.

L'aspetto "negativo" di questo sistema è che il codice scritto nel display Nextion è meno conveniente da documentare rispetto al codice Arduino. Inoltre, il codice Nextion rischia di essere disperso su vari oggetti. Bisogna fare attenzione a documentare ciò che si fa subito.

Uso Notepad ++ per scrivere il codice che poi copio nell'oggetto Nextion che è quasi esclusivamente in tm0 di pagina 0.

La sintassi del linguaggio Nextion ha numerosi limiti, ma riesce a superarli o ad aggirarli con il minimo sforzo e a cercare di vedere i problemi da punti di vista anche insoliti.

A titolo di esempio riporto il modo in cui Arduino scrive il registro da trasmettere, scritto da me nel modo più elementare possibile.

Passaggio 1: come viene trasmesso il registro

Nel file ArduinoCode. PDF mostro tutti i miei sketch. (leggendo il codice qui sotto non è così chiaro)

Qui sotto, voglio solo mostrare in che modo Arduino invia il registro a 16 bit a Nextion, senza l'aiuto delle librerie, ma rispettando la sintassi descritta da ITEAD.

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

void NexUpd()

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

{

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

SRSerial.print(InpReg); // trasmette i 16 bit raccolti al display Nextion

SRSerial.print(InpReg); // trasmette i 16 bit raccolti al display Nextion

SRSerial.write(termin); // 255

SRSerial.write(termin); // 255

SRSerial.write(termin); // 255

}

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

Passaggio 2:.. Ma prima …

Ovviamente il codice inizia con tutte le dichiarazioni e il setup().

Gli ingressi sono INPUT_PULLUP, quindi gli interruttori di ingresso sono normalmente aperti e quando chiusi applicano il GND all'ingresso corrispondente.

(Questo è il mio primo Instructable e mi dispiace mostrarti il mio codice in questo modo sbagliato. Scarica il file ArduinoCode. PDF che è molto chiaro.

Lascia che ne parli di più

Ho sviluppato un mio modo per "raccontare" al display Nextion cosa deve fare. Solitamente l'MCU (Arduino nel mio caso) invia un messaggio per ogni singola variazione da applicare all'attributo di ogni singolo oggetto. Questo metodo fa perdere molto tempo a fare cose non sempre così urgenti da caricare continuamente la Linea Seriale. Ho trovato più conveniente che Arduino raccolga in registri a 16 bit le informazioni sugli attributi da variare su Nextion. Circa ogni 500 mS, il mio Arduino invia a Nextion un messaggio contenente i 16 bit contenuti in ogni registro alla volta. Ovviamente in Nextion abbiamo bisogno del codice che gestisce ciò che deve essere eseguito. Questa distribuzione del compito (e del codice) permette di ottenere molti altri vantaggi. Ad esempio, pensa a come far lampeggiare una luce! Con il mio approccio è facile: imposta un bit nel registro Arduino e invialo a Nextion. I registri gemelli Nextion potrebbero essere aggiornati da Arduino molto raramente, perché la frequenza di lampeggio è indipendente dalla comunicazione; la frequenza di lampeggio dipende da un oggetto Timer in Nextion e può funzionare con la base dei tempi minima vicina a 50 mS. Quindi con il mio metodo possiamo lampeggiare una luce in Nextion a frequenza relativamente alta (supponiamo 2 Hz), anche se il mio Arduino invia messaggi ogni 10 secondi, solo per un esempio estremo. Questo può suggerire il problema opposto: come fare se la Comunicazione fallisce? Non è questo l'oggetto di questa discussione, ma ho già risolto questo problema con una specie di Watch Dog: uno all'interno del codice Arduino, un altro nel codice Nextion.

Il lampeggio è regolato dal codice Nextion, dove ogni spia segue le sue regole: ON/OFF o VERDE/ROSSO o anche cambiando la scritta all'interno (o altro). Potrei dire qualcos'altro sul mio progetto ma preferisco aspettare le vostre domande, prima di aggiungere troppe parole per me non così facili da tradurre come vorrei.

Passaggio 3: modifica degli oggetti Nextion

Ecco una parte del codice che ho scritto con Nextion Editor sull'oggetto tm0.

Non ci sfugge che con i 16 bit ricevuti da Arduino, il display Nextion non si limita ad accendere e spegnere i segnali. Per il momento tralascio le spiegazioni per non complicare la comprensione.

Sono un principiante e quindi è meglio scaricare la pagina Nextion code. PDF invece di leggere il codice confuso qui in basso. (Mi dispiace questo è il mio primo istruibile)

Se lo desideri puoi scaricare il codice completo "HMI" per questa mia applicazione. Il nome del file di questo codice è POW1225. HMI. Può entrare nel tuo display Nextion NX4024T032 ma per capirlo devi nuotare in molti oggetti e guardare il codice all'interno della piccola finestra dell'editor. Quindi penso che sarà più facile guardare il codice principale, scritto nel file Nextion code. PDF

// Progetto POW1225. HMI 15 maggio 2019

// vACC (va0) Accumulatore

// vINP (va1) Input Register xxxx xxxx xxxx xxxx

tm0.en=1 // tm0 Inizio

tm0.tim=50 // tm0 Base tempi 50 mS

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

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

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

{

tRDY.pco=BLU // ROSSO

}altro

{

tRDY.pco=GRIGIO // GRIGIO scuro

}

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

vACC.val=vINP.val&0x0002

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

{

tPWR.pco=VERDE // VERDE chiaro

tPON.txt="ON" // ON

tPON.pco=VERDE // VERDE chiaro

}altro

{

tPWR.pco=GRIGIO // GRIGIO scuro 33808

tPON.txt="OFF" // OFF

tPON.pco=GRIGIO // GRIGIO scuro 33808

}

// ASCIUTTO ***************

vACC.val=vINP.val&0x0004

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

{

tDRV.pco=BLU // BLU

tDRY.pco=BLUE // BLU

}altro

{

tDRV.pco=GRIGIO // GRIGIO scuro 33808

tDRY.pco=GRIGIO // GRIGIO scuro 33808

}

// CORRERE ***************

vACC.val=vINP.val&0x0018

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

{

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

tRUN.pco=BLACK // su BLACK

tDIR.bco=RED // DIR RED

tDIR.pco=NERO // su NERO

}altro

{

tRUN.bco=32768 // MARCIA GRIGIA (spento)

tRUN.pco=GRIGIO // su GRIGIO

tDIR.bco=32768 // DIR VERDE scuro 1024

tDIR.pco=GRIGIO // DIR GRIGIO

tDIR.txt="---" // ARRESTO

}

// SINISTRA **************

vACC.val=vINP.val&0x0008

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

{

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

}

// GIUSTO *************

vACC.val=vINP.val&0x0010

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

{

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

}

// ENTRAMBI **************

vACC.val=vINP.val&0x0018

if(vACC.val==24) // Prova ESEGUI entrambi

{

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

}

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

vACC.val=vINP.val&0x0020

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

{

tTEST.pco=BIANCO // BIANCO

tsw tTEST, 1 // Abilita eventi Touch

}altro

{

tTEST.pco=GRIGIO // GRIGIO scuro 33808

tsw tTEST, 0 // Disabilita gli eventi Touch

}

// COLPA *************

vACC.val=vINP.val&0x0040

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

{

tFLT.pco=GRIGIO // GUASTO assente

}

if(vACC.val!=0)

{

tFLT.pco=GIALLO // GUASTO presente

}

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

vACC.val=vINP.val&0x0080

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

{

tEME.pco=GRIGIO // EME assente

}

if(vACC.val!=0)

{

tEME.pco=RED // EME presente

}

}

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

vACC.val=vINP.val&0x0100

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

{

tFER.pco=NERO // NERO

tFER.bco=VERDE // VERDE

}altro

{

tFER.pco=GRIGIO // GRIGIO

tFER.bco=672 // VERDE scuro

}

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

Riconoscimento

Voglio fare i miei ringraziamenti a Gideon Rossouwv perché leggendo i suoi Instructables ho raggiunto rapidamente parte dei miei obiettivi. Grazie Signore. Gideon Rossouwv