Un enfoque diferente con Nextion: 3 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

En mi primer proyecto con Arduino Nano conectado a la pantalla táctil Nextion, había escrito una larga serie de comandos para comunicarlos a Nextion a través del puerto serie y esto es inevitable si necesitamos enviar comandos totalmente independientes, en momentos aleatorios.

También tengo que admitir que pasé más tiempo "peleando" con las Bibliotecas que con cualquier otra cosa. Así que gradualmente comencé a trabajar sin las pesadas bibliotecas ITEAD.

Pronto me di cuenta de que no tenía ninguna urgencia por comunicar a Nextion los cambios en los atributos de los objetos visuales, pero prefiero esperar hasta que los recoja y los envíe a Nextion en su conjunto, cuando tengo un grupo completo.

Intentaré explicarme mejor.

Cuando en mi proyecto compuesto por 16 indicaciones textuales quiero encender o apagar alguna de ellas, lo hago aprovechando el atributo 'bco' que para encender pasa (por ejemplo) de gris oscuro a blanco (si está en un rectángulo negro) y viceversa para apagar.

En mi aplicación me pareció inútil enviar 16 comandos al puerto serie en 16 momentos diferentes, uno por cada 'bco' de las 16 señales.

En cambio, prefiero que Arduino recopile qué señales deben estar 'encendidas' (ALTA) y cuáles deben estar 'apagadas' (BAJA) en un registro de 16 bits, donde cada bit corresponde a una de las 16 señales de Nextion.

Después de actualizar cada bit del registro, transmito su valor a Nextion, un mensaje único que contiene una información colectiva sobre 16 elementos.

De esta manera la comunicación desde Arduino y Nextion se reduce considerablemente porque en ese único mensaje transmitido en el serial a Nextion, se recolecta información que de otra manera hubiera requerido la transmisión de 16 mensajes.

Es cierto que no siempre es necesario actualizar todos los informes, pero estoy seguro de que hacerlo de otra manera sería una pérdida de tiempo.

Naturalmente, cada bit contenido en el entero recibido por Arduino, la pantalla Nextion tendrá que asociarlo al atributo deseado.

Esto significa que el código debe escribirse en la pantalla de Nextion, pero no debe asustarse: si lo logré …

Entonces hay una doble ventaja: Arduino tendrá un código más ligero y estará menos involucrado en la comunicación en serie con Nextion.

Nextion después de recibir los datos en un solo mensaje, los usará mucho más rápido que si tuviera que esperar 16 mensajes. El encendido o apagado de 16 señales será, por tanto, casi contemporáneo con respecto al modo más habitual, en el que transcurre el tiempo para un número desconocido de mensajes entre la ejecución del comando para la primera señalización y el comando para la última señalización.

En la pantalla de Nextion creé este sistema de la manera clásica, es decir, girar un registro de 'máscara' cada vez te permite examinar cada uno de los 16 bits. Cuando el bit examinado es ALTO, la señal asociada con ese bit se enciende en la pantalla y se apaga cuando un bit está BAJO.

El aspecto 'negativo' de este sistema es que el código escrito en la pantalla Nextion es menos conveniente de documentar que el código Arduino. Además, el código de Nextion corre el riesgo de estar disperso en varios objetos. Se debe tener cuidado de documentar lo que hace de inmediato.

Utilizo Notepad ++ para escribir el código que luego copio en el objeto Nextion que está casi exclusivamente en tm0 de la página 0.

La sintaxis del lenguaje Nextion tiene numerosas limitaciones, pero consigue superarlas o sortearlas con un mínimo de esfuerzo y tratar de ver los problemas desde puntos de vista también inusuales.

A modo de ejemplo, informo la forma en que Arduino escribe el registro a transmitir, escrito por mí de la forma más elemental posible.

Paso 1: Cómo se transmite el registro

En el archivo ArduinoCode. PDF muestro todo mi boceto. (Leer el código aquí abajo no está tan claro)

Aquí abajo, solo quiero mostrar de qué manera Arduino envía el Registro de 16 bits a Nextion, sin la ayuda de las bibliotecas, pero respetando la sintaxis descrita por ITEAD.

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

anular NexUpd ()

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

{

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

SRSerial.print (InpReg); // transmite los 16 bits recopilados a la pantalla Nextion

SRSerial.print (InpReg); // transmite los 16 bits recopilados a la pantalla Nextion

SRSerial.write (termin); // 255

SRSerial.write (termin); // 255

SRSerial.write (termin); // 255

}

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

Paso 2:.. Pero antes…

Por supuesto, el código comienza con todas las declaraciones y la configuración ().

Las Entradas son INPUT_PULLUP, por lo que los interruptores de entrada están normalmente abiertos y cuando están cerrados, aplican GND a la entrada correspondiente.

(Este es mi primer Instructable y lamento mostrarles mi código de esta mala manera. Por favor descargue el archivo ArduinoCode. PDF que es muy claro.

Déjame hablar más de eso

He desarrollado mi propia forma de "decirle" a la pantalla Nextion lo que debe hacer. Por lo general, el MCU (Arduino en mi caso) envía un mensaje para que cada variación se aplique al atributo de cualquier objeto. Este método pierde mucho tiempo para hacer cosas que no siempre son tan urgentes como para cargar continuamente la Línea Serie. Encontré más conveniente que Arduino recopilara en registros de 16 bits la información sobre los atributos para variar en Nextion. Aproximadamente cada 500 mS, mi Arduino envía a Nextion un mensaje que contiene los 16 bits contenidos en cada registro a la vez. Obviamente, en Nextion necesitamos el código que maneja lo que se debe ejecutar. Esta distribución de la tarea (y del código) permite obtener muchas otras ventajas. Por ejemplo, ¡piensa en cómo hacer parpadear una luz! Con mi enfoque, es fácil: ingrese un poco en el registro de Arduino y envíelo a Nextion. Los registros gemelos de Nextion podrían actualizarse desde Arduino muy raramente, porque la frecuencia de parpadeo es independiente de la comunicación; la frecuencia de parpadeo depende de un objeto Timer en Nextion y puede funcionar con una base de tiempo mínima cercana a 50 mS. Entonces, con mi método, podemos hacer parpadear una luz en Nextion a una frecuencia relativamente alta (supongamos que 2 Hz), incluso si mi Arduino envía mensajes cada 10 segundos, solo por un ejemplo extremo. Esto puede sugerir el problema opuesto: ¿cómo hacer si falla la comunicación? Este no es el objeto de esta discusión, pero ya resolví este problema con una especie de Watch Dog: uno dentro del Código Arduino, otro dentro del código Nextion.

El parpadeo está regulado por el código Nextion, donde cada luz sigue sus propias reglas: ENCENDIDO / APAGADO o VERDE / ROJO o también cambiando el interior escrito (u otro más). Podría contar algunas otras cosas sobre mi proyecto pero prefiero esperar tus preguntas, antes de añadir demasiadas palabras que no me resultan tan fáciles de traducir como lo haría.

Paso 3: editar los objetos Nextion

Aquí hay una parte del código que escribí con Nextion Editor en el objeto tm0.

No escapa a nuestro conocimiento que con los 16 bits recibidos de Arduino, la pantalla Nextion no solo enciende y apaga las señales. Por el momento omito las explicaciones para no complicar la comprensión.

Soy un principiante, por lo que es mejor descargar la página Nextion code. PDF en lugar de leer el código confuso aquí abajo. (Lo siento, este es mi primer instructivo)

Si lo desea puede descargar el código completo "HMI" para esta mi aplicación. El nombre de archivo de este código es POW1225. HMI. Puede ejecutarse en su pantalla Nextion NX4024T032, pero para comprenderlo, debe nadar en muchos objetos y mirar el código dentro de la pequeña ventana del editor. Entonces creo que será más fácil mirar el código principal, escrito en el archivo Nextion code. PDF

// Proyecto POW1225. HMI 15 de mayo de 2019

// vACC (va0) Acumulador

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

tm0.en = 1 // tm0 Inicio

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

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

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

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

{

tRDY.pco = AZUL // ROJO

}demás

{

tRDY.pco = GRIS // GRIS oscuro

}

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

vACC.val = vINP.val y 0x0002

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

{

tPWR.pco = VERDE // VERDE claro

tPON.txt = "ON" // ON

tPON.pco = VERDE // VERDE claro

}demás

{

tPWR.pco = GRIS // GRIS oscuro 33808

tPON.txt = "APAGADO" // APAGADO

tPON.pco = GRIS // GRIS oscuro 33808

}

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

vACC.val = vINP.val y 0x0004

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

{

tDRV.pco = AZUL // AZUL

tDRY.pco = AZUL // AZUL

}demás

{

tDRV.pco = GRIS // GRIS oscuro 33808

tDRY.pco = GRIS // GRIS oscuro 33808

}

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

vACC.val = vINP.val y 0x0018

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

{

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

tRUN.pco = NEGRO // en NEGRO

tDIR.bco = RED // DIR RED

tDIR.pco = NEGRO // en NEGRO

}demás

{

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

tRUN.pco = GRIS // sobre GRIS

tDIR.bco = 32768 // DIR VERDE oscuro 1024

tDIR.pco = GRIS // DIR GRIS

tDIR.txt = "---" // DETENER

}

// IZQUIERDA **************

vACC.val = vINP.val y 0x0008

if (vACC.val! = 0) // Prueba RUN Derecha

{

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

}

// DERECHA *************

vACC.val = vINP.val y 0x0010

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

{

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

}

// AMBOS **************

vACC.val = vINP.val y 0x0018

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

{

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

}

// PRUEBA **************

vACC.val = vINP.val y 0x0020

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

{

tTEST.pco = BLANCO // BLANCO

tsw tTEST, 1 // Habilitar eventos táctiles

}demás

{

tTEST.pco = GRIS // GRIS oscuro 33808

tsw tTEST, 0 // Desactivar eventos táctiles

}

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

vACC.val = vINP.val y 0x0040

if (vACC.val == 0) // Prueba FALLA

{

tFLT.pco = GRIS // FALLO ausente

}

si (vACC.val! = 0)

{

tFLT.pco = AMARILLO // FALLO presente

}

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

vACC.val = vINP.val y 0x0080

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

{

tEME.pco = GRIS // EME ausente

}

si (vACC.val! = 0)

{

tEME.pco = RED // EME presente

}

}

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

vACC.val = vINP.val y 0x0100

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

{

tFER.pco = NEGRO // NEGRO

tFER.bco = VERDE // VERDE

}demás

{

tFER.pco = GRIS // GRIS

tFER.bco = 672 // VERDE oscuro

}

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

Reconocimiento

Quiero dar mis agradecimientos a Gideon Rossouwv porque leyendo sus Instructables he ganado rápidamente parte de mis objetivos. Gracias Señor. Gideon Rossouwv