MVC Nextion – Arduino Communication variables

Si hemos estado atentos al tutorial anterior para poder capturar eventos táctiles desde nuestras pantallas Nextion, habremos comprobado que ahora las cosas se complican un poco más, pero tampoco son para tanto.

Para algunos desarrolladores que ya están acostumbrados a realizar ingeniería inversa a raiz de todos los posibles errores que podemos encontrar hasta dar con la solución mágica; en este post vamos a abordar la manera de enviar y recibir datos de manera bidireccional, ya sean numéricos o de texto.

Para ello, vamos a proponer dos ejemplos que son los modelos que más utilidad podemos aplicar.

Formato numérico

En un tutorial anterior abordamos la manera de manipular un indicador Gauge de una manera bastante primitiva. Ahora vamos a realizar este mismo apartado, pero accediendo a nuestro modelo Gauge registrado en el editor Nextion leyendo desde un potenciómetro y modificando su valor usando las librerías Nextion.

#include "Nextion.h"

NexGauge z0 = NexGauge(2 , 3 , "z0");

void setup() {
  nexInit();

  dbSerial.println("Debug OK");
  
}

void loop() {

  int n = analogRead(A0);
  n = map(n,0,1023,0,180);
    z0.setValue( n ) ;
}

Si recordamos, este valor se actualizaba en cada iteración del bucle y su comportamiento podía verse como el color aparecía y desaparecía intermitentemente. Así que para evitar este caso, vamos a desarrollar un programa un poco menos sensible a cambios.

#include "Nextion.h"

NexGauge z0 = NexGauge(2 , 3 , "z0");

int old_value ;
int threshold = 5;

void setup() {
  nexInit();

  dbSerial.println("Debug OK");
  
}

void loop() {

  int n = analogRead(A0);
  n = map(n,0,1023,0,180);
  
  if ( abs(old_value - n) > threshold){
    old_value = n;
    z0.setValue( old_value ) ;
  }
}

Este modo de programar los datos que serán leidos por un componente externo a nuestra placa Arduino hacia la pantalla es la apropiada para realizar la modificación del valor donde apunta nuestra aguja Gauge.

Enviar valor numérico de la pantalla Nextion a Arduino

En primer lugar, imaginemos que tenemos un motor, que queremos mover a una velocidad determinada y este valor lo queremos definir a través de nuestra pantalla Nextion. En este caso necesitaremos crear una variable numerica que podamos modificar desde nuestra pantalla y enviarla a nuestra placa para que se ejecute esta acción.

Ahora deberemos programar los botones para aumentar y disminuir el valor numérico. Evitaremos además que nuestros valores sean negativos programando la parte de la pantalla.

n0.val=n0.val+1

 

if(n0.val<=0)
{
	n0.val=n0.val-1
}

Solamente nos queda programar nuestra placa convenientemente. Hay que prestar atención a esta forma de relacionar los valores numéricos.
Por un lado, el tipo de dato de la variable para formato numérico tiene que ser int32_t. Si ponemos solo int no nos funcionará.
Por otra parte, a la hora de leer la variable con el método getValue, hay que pasarle el puntero sobre el que va a escribir. Por lo que siempre deberá ir acompañado del símbolo &.

#include "Nextion.h"

NexButton b2 = NexButton(4 , 7 , "b2");
NexNumber n0 = NexNumber(4 , 4 , "n0");

NexTouch *components[] = {
  &b2,
  NULL
};

int32_t  velocity;

void setup() {
  nexInit();

  dbSerial.println("Debug OK");
  b2.attachPush( pushValue, &b2 );
}

void loop() {

  nexLoop( components );
  
}

void pushValue(void *ptr) 
{  
  n0.getValue( &velocity );
  dbSerial.print("Velocity:  ");
  dbSerial.println ( velocity );
}  

Formato String

Dejamos los números para pasar al formato de texto. El formato de texto es quizás un poco más complicado, ya que dependerá de la longitud definida por el apartado de texto.

Leer cadena de texto desde el monitor serie a la pantalla

En este caso, vamos a crear un campo de texto que modificaremos cuando introduzcamos un texto a través del monitor serie. Para ello, utilizaremos el Serial de arduino para mandar mensajes.
IMPORTANTE: Este ejercicio tiene utilidad solamente si utilizamos un Arduino MEGA o un puerto serie diferente para conectar la pantalla. Para conectar nuestra placa a un puerto serie diferente, hay que modificar la configuración desde nuestra librería.

Lo más importante de esta parte de código es que tenemos que tratar la cadena de texto leida como un buffer de datos que hay que introducir en le método setText como argumento.

 

#include "Nextion.h"
#define size 20
NexText t0 = NexText(4 , 3 , "t0");

char buff[size] = {0};

void setup() {
  Serial.begin(9600);
  nexInit();
}

void loop() {
  if ( Serial.available() ){
    String data = Serial.readString();
    dbSerial.println(data);
    //Clean buffer
    memset(buff, 0, sizeof(buff));
    data.toCharArray(buff, data.length()+1 );
    
    t0.setText( buff ); 
  }
}

Finalmente, nos tocaría enviar un texto desde nuestra pantalla a nuestra placa Arduino.
Realmente este proceso no tiene tanta utilidad como lo visto anteriormente, pero podemos realizar este paso de la misma manera que hemos hecho con el resto.

Para realizar este paso, supongamos que queremos reconocer si una variable de texto guardada en el programa de nuestra pantalla coincide con el valor que le proporcionamos por el monitor serie de Arduino. De esta forma lo compararemos.

El valor de la variable de texto será la palabra Nextion.

#include "Nextion.h"
#define size 7

NexVariable va0 = NexVariable(4 , 8 , "va0");

char buff[size] = {0};

void setup() {
  Serial.begin(9600);
  nexInit();
}

void loop() {
  if ( Serial.available() ){
    String data = Serial.readString();

    //Clean buffer
    memset(buff, 0, sizeof(buff));

    va0.getText( buff, size ); 
    
    dbSerial.println( buff );
    dbSerial.println( data );
    if(  String(buff) == data ){
      dbSerial.println("Get Text OK");
    }else{
      dbSerial.println("Text no OK");
    }
  }
}

 

---

Podéis acceder a nuestro repositorio Github, con cada una de los programas que mostramos en estos tutoriales