Pantallas Nextion.

Nextion es probablemente una de las mejores opciones para crear proyectos con electrónica. No solamente son compatibles con Arduino, Raspberry PI, Atmel, Microchip, ARM, etc, sino que además podemos utilizarlos de forma independiente contando la propia placa con una serie de pines de uso general incluso un RTC para sistemas de adquisición de datos. Para crear una interfaz en una pantalla Nextion usaremos el editor Nextion, un software provisto por el propio fabricante que hace la tarea del diseño realmente simple.
Una vez que tenemos todo los elementos de la interfaz desplegados en la pantalla se envía la programación a la propia pantalla usando una simple conexión serial.
Este editor de Nextion es la mejor solución, en realidad casi la única para crear proyectos con estas pantallas inteligentes.
Lamentablemente solo existe en versión para Windows que se descarga a través del enlace oficial de Nextion.

Conexión de la pantalla.

La pantalla dispone solamente de 4 pines. Dos de ellos son de alimentación (cable rojo y negro) y los otros dos son de recepción (RX ) y transmisión (TX) de datos a través de su puerto serie.
La pantalla se programa por medio de una conexión serial desde el propio editor Nextion, y también se conecta con Arduino por una conexión serial.
Cuando queremos mostrar un dato en la pantalla solo “apuntamos”al componente de la pantalla donde queremos enviar los datos y enviamos la información que se me mostrará donde se indicó, por ejemplo imaginemos que tenemos un termómetro dibujado en la pantalla y queremos enviar los datos para que cambie su aspecto según la temperatura, la sintaxis seria algo como esto:
Serial.print("j0.val=") donde j0 es la variable y val es el valor a mostrar.

Editor Nextion.

Vamos a realizar un ejemplo rápido para ver nuestro entorno de edición y cargar un primer proyecto a nuestra pantalla.
En el momento de crear un proyecto nuevo, deberemos seleccionar el modelo de pantalla con el que vamos a trabajar.
Observe la siguiente imagen el aspecto del editor al crear la pantalla.

El código Arduino que se usa en este ejemplo es el siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/**********************************************************************
** Descripción  : Ejemplo simple para una pantalla NEXTION NX4024K032        
**                400 x 240 pixeles
**                
**  Target       : Arduino Nano
**  ToolChain    : Arduino IDE 1.8.10 bajo Linux Debian
**  www.firtec.com.ar 
**********************************************************************/
int val =0; //variable para mandar por el puerto serial
#define led 2
bool bandera = false;  // Bandera para saber si hay que apagar o encender el LED
   
void setup() {
 Serial.begin(9600); 
  pinMode(led, OUTPUT);
}
void loop() {
 
byte array[16];                             // Arreglo para recibir datos desde la UART
     while (Serial.available() > 0) {       
     for (int i = 1 ; i < 16; i++) {        // Solo son necesarios en este ejemplo los datos del 1 al 7
          array[i] =  Serial.read();        // La pantalla enviará 7 bytes donde los bytes 2,3 y 4 son los que interesan
        delay(20);                            
    }
/*-----------------------------------------------------------------------------------------------
Estructura del mensaje enviado por NEXTION:
	65 00 05 01 FF FF FF
	 |  |  |  |  |__|__| > Fin de TX
	 |  |  |  Evento
	 |  |  Componente
	 | Página
Todo OK
	 
-------------------------------------------------------------------------------------------------*/
    array[16] = '\0';       
    byte error = array[1];     
    byte pagina = array[2];    	// Página desde donde llega la información desde la pantalla
    byte componente = array[3];	// Identificación del componente que ha enviado la información desde la pantalla
    byte eventopres = array[4];	// Evento del componente que se ha enviado
    byte dato1 = array[5];     	// Comando de fin de envío
    byte dato2 = array[6];     	// Comando de fin de envío
    byte dato3 = array[7];     	// Comando de fin de envío
    delay(5);
    if (pagina == 0 && componente == 5 && bandera == false ) {   // Evento de la pagina 0 y el componente 5(el unico boton de esa pagina)
      digitalWrite(led, HIGH);                    // LED encendido
      bandera = true;                             // Bandera pasa a true para saber si en proximo evento enciede o apaga
      componente = 0;                             // Componente es puesto a cero 
      delay(5);                                       
    }
    if (pagina == 0 && componente == 5 && bandera == true) {   // Nuevo evento del boton y relación con bandera.
      digitalWrite(led, LOW);                    // LED apagado
      bandera = false;                          
      delay(5);                                 
    }
  }
  
 Valor = analogRead(0); // Lee el canal 0
  val= (Valor/4)/2.55;  // Escala los valores analogicos para ajustarlos de 0 a255
 
 Serial.print("j0.val="); // Se apunta a la variable que se modifica
 Serial.print(val);       // Se envía el valor del potenciometro para modificar la variable en la pantalla
 Serial.write(0xff);
 Serial.write(0xff);
 Serial.write(0xff);
 
 Serial.print("n0.val="); // Variable de pantalla que se va a modificar
 Serial.print(val);       // Envía el dato
 Serial.write(0xff);
 Serial.write(0xff);
 Serial.write(0xff);
}

En el siguiente vídeo puede ver el ejemplo en la pantalla trabajando con un Arduino Nano.

 

 El manejo de estas pantallas es muy sencillo y resuelve un problema no menor ya que el desarrollo de interfaces gráficas es una tarea ardua y por lo general las pantallas TFT consumen recursos tanto de hardware como software, en este caso solo dos cables de datos son suficientes y cualquier microcontrolador o sistema con un puerto UART puede manejar estas pantallas.
El código Nextion de este ejemplo lo puede descargar del portal Github de Firtec.
Con un sensor BME280 y un Arduino Nano podemos construir una simple estación meteorológica, la predicción del clima la informa cambiando los iconos (sol, nublado, lluvia, tormenta, etc) de forma automática dependiendo de las condiciones atmosféricas. 

(Todo el manejo de estas pantallas esta incluido en varios de nuestros libros para Arduino y MicroPython).