Uma abordagem diferente com Nextion: 3 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

No meu primeiro projeto com Arduino Nano conectado ao display touch Nextion, escrevi uma longa série de comandos para serem comunicados ao Nextion via porta serial e isso é inevitável se precisarmos enviar comandos totalmente independentes, em momentos aleatórios.

Também tenho que admitir que passei mais tempo 'lutando' com as bibliotecas do que com qualquer outra coisa. Então, gradualmente, comecei a trabalhar totalmente sem as bibliotecas pesadas do ITEAD.

Logo percebi que não tinha urgência em comunicar ao Nextion as mudanças nos atributos dos objetos visuais, mas prefiro esperar até que os colete e envie para o Nextion como um todo, quando obtive um grupo completo.

Vou tentar me explicar melhor.

Quando no meu projeto composto por 16 indicações textuais quero ligar ou desligar algumas delas, faço isso aproveitando o atributo 'bco' que para ligar passa (por exemplo) de cinza escuro para branco (se em um retângulo preto) e vice-versa para desligar.

No meu aplicativo achei inútil enviar 16 comandos para a porta serial em 16 momentos diferentes, um para cada 'bco' dos 16 sinais.

Prefiro que o Arduino colete quais sinais devem estar 'ligados' (ALTO) e quais devem estar 'desligados' (BAIXOS) em um registro de 16 bits, onde cada bit corresponde a uma das 16 sinalizações de Nextion.

Após atualizar cada bit do registrador, transmito seu valor para Nextion, uma mensagem única que contém uma informação coletiva sobre 16 elementos.

Desta forma, a comunicação do Arduino e do Nextion é consideravelmente reduzida, pois naquela única mensagem transmitida no serial para o Nextion, são coletadas informações que de outra forma exigiriam a transmissão de 16 mensagens.

É verdade que nem sempre é necessário atualizar todos os relatórios, mas tenho certeza de que fazer o contrário seria uma perda de tempo.

Naturalmente, a cada bit contido no inteiro recebido pelo Arduino, o display do Nextion terá que associá-lo ao atributo desejado.

Isso significa que o código deve ser escrito no display Nextion, mas não é para se assustar: se eu consegui …

Então, há uma dupla vantagem: o Arduino terá um código mais leve e estará menos envolvido na comunicação serial com o Nextion.

O Nextion após receber os dados em uma única mensagem, os usará muito mais rapidamente do que se esperasse por 16 mensagens. O ligar ou desligar de 16 sinais será, portanto, quase contemporâneo em relação ao modo mais usual, no qual o tempo para um número desconhecido de mensagens decorre entre a execução do comando para a primeira sinalização e o comando para a última sinalização.

No display Nextion criei este sistema da maneira clássica, ou seja, girar um registro de 'máscara' a cada vez permite que você examine cada um dos 16 bits. Quando o bit examinado é HIGH, o sinal associado a esse bit acende no visor e desliga quando um bit está LOW.

O aspecto 'negativo' desse sistema é que o código escrito na tela do Nextion é menos conveniente de ser documentado do que o código do Arduino. Além disso, o código Nextion corre o risco de ser espalhado por vários objetos. Deve-se ter cuidado para documentar o que você faz imediatamente.

Eu uso o Notepad ++ para escrever o código que copio no objeto Nextion que está quase exclusivamente no tm0 da página 0.

A sintaxe da linguagem Nextion tem inúmeras limitações, mas consegue superá-las ou contorná-las com um mínimo de esforço e tentar enxergar os problemas de pontos de vista também inusitados.

Como exemplo, relato a maneira como o Arduino grava o registro a ser transmitido, escrito por mim da maneira mais elementar possível.

Etapa 1: Como o registro é transmitido

No arquivo ArduinoCode. PDF apresento todo o meu sketch. (Ler o código aqui embaixo não é tão claro)

Aqui embaixo, quero apenas mostrar de que forma o Arduino envia o Register de 16 bits para o Nextion, sem o auxílio das bibliotecas, mas apenas respeitando a sintaxe descrita pelo ITEAD.

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

void NexUpd ()

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

{

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

SRSerial.print (InpReg); // transmite os 16 bits coletados para o display Nextion

SRSerial.print (InpReg); // transmite os 16 bits coletados para o display Nextion

SRSerial.write (termin); // 255

SRSerial.write (termin); // 255

SRSerial.write (termin); // 255

}

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

Etapa 2:.. Mas antes…

É claro que o código começa com todas as declarações e o setup ().

As entradas são INPUT_PULLUP, portanto as chaves de entrada estão normalmente abertas e quando fechadas, aplicam o GND à entrada correspondente.

(Este é meu primeiro Instructable e sinto muito por mostrar meu código desta forma incorreta. Faça o download do arquivo ArduinoCode. PDF que está muito claro.

Deixe-me falar mais sobre isso

Eu desenvolvi minha própria maneira de 'dizer' ao monitor Nextion o que ele deve fazer. Normalmente o MCU (Arduino no meu caso) envia uma mensagem para cada variação para aplicar ao atributo de qualquer objeto único. Este método perde muito tempo para fazer coisas nem sempre tão urgentes para carregar continuamente a Linha Serial. Achei mais conveniente que o Arduino colete em registros de 16 bits as informações sobre os atributos para variar no Nextion. Aproximadamente a cada 500 ms, meu Arduino envia para a Nextion uma mensagem contendo os 16 bits contidos em cada registro de cada vez. Obviamente, no Nextion, precisamos do código que trata do que deve ser executado. Esta distribuição da tarefa (e do código) permite obter muitas outras vantagens. Por exemplo, pense em como fazer piscar uma luz! Com a minha abordagem é fácil: defina um bit no registro do Arduino e envie para o Nextion. Os registradores gêmeos Nextion podem ser atualizados a partir do Arduino muito raramente, porque a frequência de intermitência é independente da comunicação; a frequência de intermitência depende de um objeto Timer em Nextion e pode funcionar com a base de tempo mínima próxima a 50 ms. Então, com meu método, podemos piscar uma luz em Nextion em uma frequência relativamente alta (suponha que 2 Hz), mesmo se meu Arduino enviar mensagens a cada 10 segundos, apenas para um exemplo extremo. Isso pode sugerir o problema oposto: como fazer se a comunicação falhar? Este não é o objeto desta discussão, mas já resolvi esse problema com uma espécie de Watch Dog: um dentro do código do Arduino, outro no código Nextion.

O piscar é regulado pelo código Nextion, onde cada luz segue suas próprias regras: ON / OFF ou VERDE / VERMELHO ou também alterando a escrita interna (ou outra mais). Poderia contar outras coisas sobre o meu projeto, mas prefiro aguardar suas perguntas, antes de acrescentar muitas palavras que não são tão fáceis de traduzir tão bem quanto eu faria.

Etapa 3: Editando os Objetos Nextion

Aqui está uma parte do código que escrevi com o Nextion Editor no objeto tm0.

Não passa despercebido que, com os 16 bits recebidos do Arduino, a tela do Nextion não liga e desliga apenas os sinais. Por enquanto, omito as explicações para não complicar a compreensão.

Sou um iniciante e por isso é melhor baixar a página Nextion code. PDF em vez de ler o código confuso aqui embaixo. (Lamento, este é o meu primeiro instrutível)

Se desejar, você pode baixar o código completo "HMI" deste meu aplicativo. O nome do arquivo deste código é POW1225. HMI. Ele pode ser executado em seu display Nextion NX4024T032, mas para entendê-lo você tem que nadar em muitos objetos e olhar o código dentro da pequena janela do editor. Então acho que ficará mais fácil olhar o código principal, escrito no arquivo Nextion code. PDF

// Projeto POW1225. HMI 15 de maio de 2019

// Acumulador vACC (va0)

// vINP (va1) Registro de entrada xxxx xxxx xxxx xxxx

tm0.en = 1 // tm0 Start

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

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

vACC.val = vINP.val & 0x0001 // Máscara

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

{

tRDY.pco = AZUL // VERMELHO

}outro

{

tRDY.pco = GREY // dark GREY

}

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

vACC.val = vINP.val & 0x0002

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

{

tPWR.pco = VERDE // VERDE claro

tPON.txt = "ON" // ON

tPON.pco = VERDE // VERDE claro

}outro

{

tPWR.pco = GREY // dark GREY 33.808

tPON.txt = "OFF" // OFF

tPON.pco = GREY // dark GREY 33.808

}

// SECO ***************

vACC.val = vINP.val & 0x0004

if (vACC.val! = 0) // Teste SECO

{

tDRV.pco = AZUL // AZUL

tDRY.pco = AZUL // AZUL

}outro

{

tDRV.pco = GREY // dark GREY 33.808

tDRY.pco = GREY // dark GREY 33.808

}

// CORRE ***************

vACC.val = vINP.val & 0x0018

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

{

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

tRUN.pco = PRETO // em PRETO

tDIR.bco = RED // DIR RED

tDIR.pco = PRETO // em PRETO

}outro

{

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

tRUN.pco = CINZA // em CINZA

tDIR.bco = 32768 // DIR VERDE escuro 1024

tDIR.pco = CINZA // CINZA SUJO

tDIR.txt = "---" // PARE

}

// DEIXOU **************

vACC.val = vINP.val & 0x0008

if (vACC.val! = 0) // Teste RUN certo

{

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

}

// DIREITO *************

vACC.val = vINP.val & 0x0010

if (vACC.val! = 0) // Teste RUN à esquerda

{

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

}

// AMBAS **************

vACC.val = vINP.val & 0x0018

if (vACC.val == 24) // Teste RUN ambos

{

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

}

// TESTE **************

vACC.val = vINP.val & 0x0020

if (vACC.val! = 0) // Teste TESTE

{

tTEST.pco = BRANCO // BRANCO

tsw tTEST, 1 // Habilita eventos de toque

}outro

{

tTEST.pco = GREY // dark GREY 33.808

tsw tTEST, 0 // Desativar eventos de toque

}

// CULPA *************

vACC.val = vINP.val & 0x0040

if (vACC.val == 0) // Teste de FALHA

{

tFLT.pco = CINZA // FALHA ausente

}

if (vACC.val! = 0)

{

tFLT.pco = AMARELO // FALHA presente

}

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

vACC.val = vINP.val & 0x0080

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

{

tEME.pco = GREY // EME ausente

}

if (vACC.val! = 0)

{

tEME.pco = RED // EME presente

}

}

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

vACC.val = vINP.val & 0x0100

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

{

tFER.pco = PRETO // PRETO

tFER.bco = VERDE // VERDE

}outro

{

tFER.pco = CINZA // CINZA

tFER.bco = 672 // VERDE escuro

}

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

Reconhecimento

Quero deixar meus agradecimentos a Gideon Rossouwv porque lendo seus Instructables ganhei rapidamente parte de meus objetivos. Obrigado MR. Gideon Rossouwv