Comandos para controle do display Nextion

Já vamos para o quarto artigo sobre esse display e ainda assim outros virão devido à quantidade enorme de possibilidades que esse display oferece. É muito simples fazer a interface, assim como enviar comandos TTL para o display, mas ele oferece muito, muito mais do que isso. Conhecer os comandos para controle do display permitirá um projeto muito mais profissional e facilitará a distribuição do processamento.

Se não viu ainda, sugiro que dê uma olhada nos artigos anteriores relacionados:

Display Nextion com Arduino

Gif animado no display Nextion

Comunicação serial com Nextion sem biblioteca

Conceito da programação para o display

A primeira coisa que devemos ter em mente é que a programação para o display deve ser focada no controle da interface. Isto é, o que sai do display para o dispositivo que fará a interação (seja um linux embedded ou uma MCU) deve ser apenas o informativo. Não cabe ao display a decisão do que a MCU deve fazer, então, quando for programar o display, o foco deve ser a interface com o usuário. Claro que podemos fazer o cruzamento de informações para mandar à MCU apenas um resultado, cuja tomada de decisão do que fazer com esse resultado caberá à MCU. Podemos concatenar os valores de seleção de um LED RGB e enviá-los em uma única string, como 255,0,0,1 para o LED RGB 1 conectado à MCU. Após a seleção, o usuário clica em Enviar e o display coleta a informação e envia tudo. Mas podemos também ter condicionais a validar e então decidir "o quê" deve ir na mensagem para a MCU. Vamos começar então.

Comandos para controle de componentes e sistema

Refresh

Para fazer atualização de página, simplesmente chamamos o comando page seguido pelo ID da página a atualizar:

page 0 // atualiza a página 0
page main // atualiza a página principal

A página 0 é atualizada automaticamente quando o display é energizado.

Refresh de um widget

Quando queremos atualizar um widget específico apenas, chamamos o comando ref seguido pelo nome do componente:

ref t0 //refresh do widget de texto 0

Esse comando deve ser utilizado quando estiver carregando uma configuração manualmente. Se estiver acionando a interface pelo touch, o refresh será feito automaticamente. Os atributos que aparecem em verde no Nextion Editor são atualizados automaticamente. Os demais necessitam da interação através do comando ref.

Quando um componente é criado através do Nextion Editor, a atualização é feita automaticamente, mas se o carregamento for feito de modo manual, requererá o uso desse comando também. Se o componente estiver protegido, a mesma coisa.

Evento de "click" de um widget

Podemos também enviar o comando atuador de um botão, por exemplo. Para isso, utilizamos o comando click.

click b0, 1 //envia o sinal de "pressionado" para o botão 0
click b0, 0 // Envia o evento de "liberado" para o botão 0

Congelar a atualização de tela

Não consigo imaginar quando isso pode ser realmente útil (talvez digitando uma senha), mas podemos interromper a atualização de tela até que um ciclo de eventos seja concluído. Para tal, utillizamos o comando ref_stop.

ref_stop //adeus, atualização de tela

O toque no display continua responsivo, apenas não haverá exibição dos eventos. Do mesmo modo, o comando ref continua sendo funcional, pois a funcionalidade exclusiva de ref_stop é para a atualização de tela.

Retomar a atualização de tela

Então, tendo concluído o que desejou fazer de forma oculta, utiliza-se o comando ref_star para retomar a atualização de tela.

ref_star //tudo volta ao padrão

Esse comando só deve ser utilizado se previamente foi chamado o comando ref_stop.

Pegar o valor de um widget

Se quiser obter o valor contido em um widget da interface, utilize o comando get. Por exemplo:

get t0.txt //pega o valor do label t0 na interface
get j0.val //pega o valor do slider j0
get "17"   //retorna a string do número do Presidente Bolsonaro
get 17     //retorna o número literal

O retorno para string é 0x70+ASCII+0xFF 0xFF 0xFF. Quando o valor for numérico, o retorno é 0x71+4 Bytes de dado binário + 0xFF 0xFF 0xFF. Como citei em um ou dois artigos anteriores, a finalização de mensagem é sempre 0xFF 0xFF 0xFF.

Pegar o ID da página corrente pela UART

Se precisar saber em qual página o display está, utilizamos o comando sendme.

sendme //envia o número da página pela UART

Para enviar automaticamente o valor de página em seu carregamento, esse comando pode ser incluído no evento da página pelo Nextion Editor, assim, toda a vez que a página for trocada, o primeiro comando enviado é a página e a controladora terá sempre ciência do conteúdo do display.

Converter um valor numérico para texto a ser inserido em um label

Esse comando é bem legal. É normal que atualizemos um label enquanto deslizamos um slider. O slider usa variável int para guardar o valor, por isso é necessário converter esse valor para seu correspondente char. Podemos fazer uma subtração ou simplesmente utilizar o comando cov para converter e atribuir automaticamente:

cov h0.val,t0.txt,0 //converte o valor do slider h0
em string e o atribui ao label t0, com comprimento automático

Do mesmo modo, é possível atribuir o valor de um label ao slider, apenas invertendo a ordem. Se origem e destino forem do mesmo tipo, a conversão falhará.

Calibração do display

Caso seja necessário, basta chamar o comando touch_j. Duvido que seja necessário porque o display já vem calibrado.

Substring

É o mesmo comando que utilizamos em C, mas no formato próprio para o display:

substr t0.txt,t1.txt,0,2 // label t0 é a origem
                         // label t1 é o destino
                         // byte inicial
                         // byte tamanho

Exibir ou esconder um widget na página

Quando desenho interfaces, gosto de ocultar componentes que não fazem parte de um contexto, até que seja necessário dispô-lo. Isso deixa a interface mais intuitiva e reduz a chance de tomada de decisão errada por parte do usuário. Para fazer esse controle no display, utilizamos o comando vis:

vis b0,0 //esconde o botão b0
vis b0,1 //exibe o botão b0

Se utilizarmos como primeiro parâmetro o valor 255, todos os widgets da página atual serão afetados pelo comando.

Desabilitar ou habilitar o touchscreen

Podemos querer aguardar que a MCU retorne um status para a tela e às vezes isso pode levar um tempo, seja lá qual for a razão. O usuário, como sempre, é a parte mais problemática de um projeto. Para evitar que ele pratique piano no display e fique enviando comandos para todos os lados, podemos desabilitar o touch até que a MCU retorne a resposta de uma solicitação. Para isso, utilizamos o comando tsw:

tsw b0,0 //desabilita o toque para o botão 0
tsw b0,1 //habilita novamente o toque para o botão 0

Do mesmo modo, para desabilitar a interação com todos os widgets da página atual, podemos utilizar o valor 255 como primeiro parâmetro.

Desabilitar a execução de instruções advindas da UART

Não sei se consigo enumerar as razões para essa necessidade, mas é outro recurso que acho incrível nesse display. Para interromper a interação remota, utilizamos o comando com_stop.

O dispositivo continuará recebendo e armazenando no buffer, até que receba o comando com_star. Então o display executará os comandos enfileirados no buffer.

Gerar um valor randômico

Para gerar um valor randômico, utilizamos o comando randset seguido pela faixa de valor desejada. Por exemplo:

randset 1,1000 // retorna um valor entre 1 e 1000

Essa range permanece até que o dispositivo seja reiniciado.

Limpar os comandos armazenados no buffer

Mais acima vimos um comando que interrompe a execução de comandos advindos da UART. Se desejarmos limpar o buffer invés de retomar a execução após a retomada do fluxo normal, utilizamos o comando code_c.

Pegar um valor de um widget em seu tipo natural

Se for uma string, retornará o valor em ASCII, se for numérico, retornará o valor ASCII em hexa. O comando é o print. A diferença do print e get é que o comando get retorna um identificador como supracitado e o comando printnão.

Enviar dados em hexa

Para tal, utilizamos o comando printh:

printh d0 a0 //o dispositivo envia 0xd0 e 0xa0

Não será mostrado no emulador do Nextion Editor, é executado apenas no display. Os caracteres devem ser separados apenas por 1 espaço, não utilize vírgula.

Adicionar dados ao widget Waveform

O formato é simples e o componente não requer explicação:

add 1, 0, 30 // Adiciona 30 ao canal 0 do widget cujo ID é 1
add 1, 1, 50 // Adiciona 50 ao canal 1 do widget cujo ID é 1

O widget Waveform tem apenas 8 bits, portanto sua faixa vai de 0 à 255.

Cada página suporta até 4 widgets Waveform e cada um deles suporta até 4 canais. Ele também suporta pass through de dados. O widget fará o auto-fluxo e exibirá os valores no display. Também é permitido modificar atributos de background e cores de frente e fundo para cada canal durante o fluxo.

Passar um volume de dados ao widget Waveform

O formato é addt objid, ch, qty. O primeiro parâmetro objid é o ID do componente. O parâmetro ch é o número do canal e qty é a quantidade de pontos de dados.

addt 1, 0, 100

O máximo de dados que pode ser passado é 1024 bits. O dispositivo se tornará irresponsivo até que seja concluída a transferência dos valores. Após 5ms é enviado o dado 0xFE 0xFF 0xFF 0xFF ao usuário e iniciará o envio dos pontos, em hexa. Não haverá atualização de tela até o fim da transferência de dados.

Limpar os dados do widget Waveform

Dispensa explicações.

cle 1, 0   // limpa os dados do componente cujo ID é 1 e canal 0.
cle 1, 255 // limpa todos os dados do componente cujo ID é 1.

Reset do Nextion

rest

Forçar atualização imediata da tela

doevents

while(n0.val<1024)
{
n0.val++
doevents    //a tela ficará atualizando durante o loop
}

Esse loop pode ser útil para fazer atualização de tela durante um evento de longa duração, colocando, por exemplo, um contador na tela ou um progressbar.

Comprimento de uma string

Como em C, strlen.

strlen t0.txt, n0.val // atribui o comprimento de t0.txt a n0.val

A origem deve ser do tipo string e o destino deve ser do tipo numérico.

if

A condicional tem o seguinte formato:

if (t0.txt=="textoOu1234")
{
Page 1 //troca de página
}
//Ou
if (b0.txt=="Start")
{
    b0.txt=="Stop"
} else
{
    b0.txt="Start"
}

Também podemos usar  else if.

Os operadores válidos para valores numéricos são <,>,==,!=,<=,>=.

Caracteres e strings suportam ==,!=.

Comparação de operações não são permitidos. Por exemplo:

if (j0.val + 1 > 2)
...

Parênteses não devem conter espaços.

while

Qualquer operação que requeira tempo tornará o display irresponsivo, incluindo os eventos de tela. Usando doevents forçará a atualização de tela.

//loop comum
while(n0.val<100)
{
n0.val++
}

//loop atualizando a tela a cada interação
while(n0.val<100)
{
n0.val++
doevents
}

Durante um evento desses, o dispositivo se torna irresponsível ao toque, os comandos seriais serão armazenados no buffer e executados apenas após a finalização do loop. Deve-se tomar todo o cuidado do mundo para não haver a possibilidade de um loop infinito, senão...

for

As condições são as mesmas.

for(n0.val=0; n0.val<100; n0.val++)
{
}

for(n0.val=0; n0.val<100; n0.val++)
{
doevents   
}

Vou deixar a parte de desenho da GUI para o próximo artigo. Espero que essa repassada da documentação lhe seja útil como está sendo para mim.

Onde adquirir

Esse era um produto de nosso parceiro MASUGUX, que há algum tempo não encontro referências, por isso estou encaminhando a sugestão de aquisição com nossos parceiros do carrossel.

Não perca o próximo tutorial, já teremos video e brincadeiras!

Inscreva-se no nosso canal Manual do Maker no YouTube.

Também estamos no Instagram.