Arduino Mega con dos pantallas Nextion

International Español Software
1

Buenas noches a todos
Estoy inmerso en un proyecto para controlar elementos de un vehículo con dos pantallas Nextion, he usado un Arduino mega, en un principio iba a usar dos, pero después de darle bastantes vueltas y aprender un poco sobre como controlar las pantallas, me decidí por utilizar solo un Arduino mega ya que tiene varios puertos series

La comunicación con las pantallas es a través de los puertos seriales, para la pantalla trasera he utilizado las librerías oficiales de Nextion, y para la la delantera, como prácticamente tiene que tener las mismas funciones, doy las ordenes al puerto serie3 sin librerías, y capturo las ordenes de la Nextion con un String, lo tengo mas o menos, pero me parece que va un poco lento, no se si son errores míos, porque hace mucho que utilizaba el Arduino o es que no da mas de si

el Arduino lleva conectados 3 sensores de temperatura (Termistores NTC), dos divisores de tensión para hacer lectura de dos baterías y luego unas cuantas entradas que condicionan algún elemento.

Si alguien me puede decir que puedo hacer para que vaya todo mas fluido, porque cuando le doy a encender algo, responde mas o menos, pero por ejemplo, cuando quito el contacto, tarda como 3 o 4 segundos y hacer lo que tiene que hacer (mandar un orden a la pantalla delantera).

adjunto el código, gracias por adelantado.

#include "Nextion.h"                                                                            // Incluir la libreria

#define       CONTACTO            2                                                             // Definir Pines a Utilizar (Entrada)
#define       SENAL_ATRAS         3                                                             // Definir Pines a Utilizar (Entrada)
#define       PRIORITARIAS        4                                                             // Definir Pines a Utilizar (Entrada)

#define       TEMPERATURA_CAB     A1                                                             // Definir Pines a Utilizar (Entrada)
#define       TEMPERATURA_ASIST   A2                                                             // Definir Pines a Utilizar (Entrada)
#define       TEMPERATURA_EXT     A3                                                             // Definir Pines a Utilizar (Entrada)
#define       VOLTIMETRO_CAR      A4                                                             // Definir Pines a Utilizar (Entrada)
#define       VOLTIMETRO_AUX      A5                                                             // Definir Pines a Utilizar (Entrada)


#define       PENUMBRA            31                                                            // Definir Pines a Utilizar (Salida)
#define       PLAFONES            32                                                            // Definir Pines a Utilizar (Salida)
#define       HALOGENOS           33                                                            // Definir Pines a Utilizar (Salida)
#define       CONVERTIDOR         34                                                            // Definir Pines a Utilizar (Salida)
#define       CALEFACCION         35                                                            // Definir Pines a Utilizar (Salida)
#define       AIRE                36                                                            // Definir Pines a Utilizar (Salida)
#define       VELOCIDAD1          37                                                            // Definir Pines a Utilizar (Salida)
#define       VELOCIDAD2          38                                                            // Definir Pines a Utilizar (Salida)
#define       VELOCIDAD3          39                                                            // Definir Pines a Utilizar (Salida)
#define       VENTILADOR          40                                                            // Definir Pines a Utilizar (Salida)
#define       EXTRACTOR           41                                                            // Definir Pines a Utilizar (Salida)
#define       MAPAS               42                                                            // Definir Pines a Utilizar (Salida)
#define       MARCHA_ATRAS        43                                                            // Definir Pines a Utilizar (Salida)

int EstadoCalefaccion;                                                                          // Declaracion de Variables Globales
int EstadoAire;                                                                                 // Declaracion de Variables Globales
int EstadoVelocidad1;                                                                           // Declaracion de Variables Globales
int EstadoVelocidad2;                                                                           // Declaracion de Variables Globales
int EstadoVelocidad3;                                                                           // Declaracion de Variables Globales
int EstadoVehiculo;                                                                             // Declaracion de Variables Globales

int EstadoMarchaAtras = 0;                                                                      // Declaracion de Variables Globales
int PulsacionMarchaAtras = 0;                                                                   // Declaracion de Variables Globales

int Faros = 0;                                                                   // Declaracion de Variables Globales

float VOutCar = 0;                                                                              // Declaracion de Variables Globales
float VInCar = 0;                                                                               // Declaracion de Variables Globales
float R1Car = 99500.0;
float R2Car = 9900.0;
float ValorCar = 0;
float VOutAux = 0;                                                                              // Declaracion de Variables Globales
float VInAux = 0;                                                                               // Declaracion de Variables Globales
float R1Aux = 99500.0;
float R2Aux = 9900.0;
float ValorAux = 0;
unsigned long ContadorVolt = 0;

float R1 = 15500.0;                                                                             // resistencia fija del divisor de tension
float Asist0 = 1.133582007e-03, Asist1 = 2.331668630e-04, Asist2 = 0.9328901740e-07;
float Ext0 = 1.133582007e-03, Ext1 = 2.331668630e-04, Ext2 = 0.9328901740e-07;
float Cab0 = 1.133582007e-03, Cab1 = 2.331668630e-04, Cab2 = 0.9328901740e-07;
unsigned long Contadortemp = 0;

int V3; 
float logR2Ext, R2Ext, TEMPERATURAExt;

int V2;                                                                                         // resistencia fija del divisor de tension 
float logR2Asist, R2Asist, TEMPERATURAAsist;

int V1;                                                                                         // resistencia fija del divisor de tension 
float logR2Cab, R2Cab, TEMPERATURACab;

NexButton NPenum = NexButton(0,3,"NPenum");                                                     // Declarar el Objeto del Tipo de Componente
NexButton NPlafon = NexButton(0,4,"NPlafon");                                                   // Declarar el Objeto del Tipo de Componente
NexButton NHalog = NexButton(0,5,"NHalog");                                                     // Declarar el Objeto del Tipo de Componente
NexCrop NPenumTest = NexCrop(0,3,"NPenum");                                                     // Declarar el Objeto del Tipo de Componente
NexCrop NPlafonTest = NexCrop(0,4,"NPlafon");                                                   // Declarar el Objeto del Tipo de Componente
NexCrop NHalogTest = NexCrop(0,5,"NHalog");                                                     // Declarar el Objeto del Tipo de Componente
NexButton NVolverClima = NexButton(1,8,"NVolverClima");                                       // Declarar el Objeto del Tipo de Componente
NexButton NVolverAjustes = NexButton(2,1,"NVolverAjustes");                                   // Declarar el Objeto del Tipo de Componente
NexButton NVolverBrillo = NexButton(3,2,"NVolverBrillo");                                     // Declarar el Objeto del Tipo de Componente
NexButton N230V = NexButton(0,6,"N230V");                                                       // Declarar el Objeto del Tipo de Componente
NexCrop N230VTest = NexCrop(0,6,"N230V");                                                       // Declarar el Objeto del Tipo de Componente

NexButton NCalor = NexButton(0,2,"NCalor");                                                     // Declarar el Objeto del Tipo de Componente
NexCrop NCalorTest = NexCrop(0,2,"NCalor");                                                     // Declarar el Objeto del Tipo de Componente
NexButton NCalor1 = NexButton(1,2,"NCalor1");                                                   // Declarar el Objeto del Tipo de Componente
NexCrop NCalor1Test = NexCrop(1,2,"NCalor1");                                                   // Declarar el Objeto del Tipo de Componente

NexButton NAire = NexButton(0,1,"NAire");                                                       // Declarar el Objeto del Tipo de Componente
NexCrop NAireTest = NexCrop(0,1,"NAire");                                                       // Declarar el Objeto del Tipo de Componente
NexButton NAire1 = NexButton(1,1,"NAire1");                                                     // Declarar el Objeto del Tipo de Componente
NexCrop NAire1Test = NexCrop(1,1,"NAire1");                                                     // Declarar el Objeto del Tipo de Componente

NexButton NVelo1 = NexButton(1,3,"NVelo1");                                                     // Declarar el Objeto del Tipo de Componente
NexCrop NVelo1Test = NexCrop(1,3,"NVelo1");                                                     // Declarar el Objeto del Tipo de Componente

NexButton NVelo2 = NexButton(1,4,"NVelo2");                                                     // Declarar el Objeto del Tipo de Componente
NexCrop NVelo2Test = NexCrop(1,4,"NVelo2");                                                     // Declarar el Objeto del Tipo de Componente

NexButton NVelo3 = NexButton(1,5,"NVelo3");                                                     // Declarar el Objeto del Tipo de Componente
NexCrop NVelo3Test = NexCrop(1,5,"NVelo3");                                                     // Declarar el Objeto del Tipo de Componente

NexButton NClima = NexButton(0,35,"NClima");                                                  // Declarar el Objeto del Tipo de Componente

NexButton NVentila = NexButton(1,6,"NVentila");                                                 // Declarar el Objeto del Tipo de Componente
NexCrop NVentilaTest = NexCrop(1,6,"NVentila");                                                 // Declarar el Objeto del Tipo de Componente

NexButton NExtractor = NexButton(1,7,"NExtractor");                                             // Declarar el Objeto del Tipo de Componente
NexCrop NExtractorTest = NexCrop(1,7,"NExtractor");                                             // Declarar el Objeto del Tipo de Componente

NexCrop NCarTest = NexCrop(0,8,"NCarTest");                                                     // Declarar el Objeto del Tipo de Componente
NexCrop NAuxTest = NexCrop(0,7,"NAuxTest");                                                     // Declarar el Objeto del Tipo de Componente


NexTouch *nex_listen_list[]=                                                                    // Registrar los Objetos en una lista de Eventos Tactiles
{
  &NPenum,
  &NPlafon,
  &NHalog,
  &NVolverClima,
  &NVolverAjustes,
  &NVolverBrillo,
  &N230V,
  &NCalor,
  &NCalor1,
  &NAire,
  &NAire1,
  &NVelo1,
  &NVelo2,
  &NVelo3,
  &NClima,
  &NVentila,
  &NExtractor,
  NULL
};
    
void setup() 
{
  int EstadoCalefaccion=LOW;
  int EstadoAire=LOW;
  int EstadoVelocidad1=LOW;
  int EstadoVelocidad2=LOW;
  int EstadoVelocidad3=LOW;
  
  nexInit();                                                         // Inicializar la conexion Serie

  Serial3.begin(9600);                                               // inicializa comunicacion serie a 9600 bps

  pinMode(CONTACTO, INPUT);                                          // Definir los Pines como salida o entrada
  pinMode(SENAL_ATRAS, INPUT);                                       // Definir los Pines como salida o entrada
  pinMode(PRIORITARIAS, INPUT);                                      // Definir los Pines como salida o entrada

  pinMode(PENUMBRA, OUTPUT);                                         // Definir los Pines como salida o entrada
  pinMode(PLAFONES, OUTPUT);                                         // Definir los Pines como salida o entrada
  pinMode(HALOGENOS, OUTPUT);                                        // Definir los Pines como salida o entrada
  pinMode(CONVERTIDOR, OUTPUT);                                      // Definir los Pines como salida o entrada
  pinMode(CALEFACCION, OUTPUT);                                      // Definir los Pines como salida o entrada
  pinMode(AIRE, OUTPUT);                                             // Definir los Pines como salida o entrada
  pinMode(VELOCIDAD1, OUTPUT);                                       // Definir los Pines como salida o entrada
  pinMode(VELOCIDAD2, OUTPUT);                                       // Definir los Pines como salida o entrada
  pinMode(VELOCIDAD3, OUTPUT);                                       // Definir los Pines como salida o entrada
  pinMode(VENTILADOR, OUTPUT);                                       // Definir los Pines como salida o entrada
  pinMode(EXTRACTOR, OUTPUT);                                        // Definir los Pines como salida o entrada
  pinMode(MAPAS, OUTPUT);                                            // Definir los Pines como salida o entrada
  pinMode(MARCHA_ATRAS, OUTPUT);                                     // Definir los Pines como salida o entrada
  
  digitalWrite(PENUMBRA,LOW);                                        // Inicializamos Salidas a 0
  digitalWrite(PLAFONES,LOW);                                        // Inicializamos Salidas a 0
  digitalWrite(HALOGENOS,LOW);                                       // Inicializamos Salidas a 0
  digitalWrite(CONVERTIDOR,LOW);                                     // Inicializamos Salidas a 0
  digitalWrite(CALEFACCION,LOW);                                     // Inicializamos Salidas a 0
  digitalWrite(AIRE,LOW);                                            // Inicializamos Salidas a 0
  digitalWrite(VELOCIDAD1,LOW);                                      // Inicializamos Salidas a 0
  digitalWrite(VELOCIDAD2,LOW);                                      // Inicializamos Salidas a 0
  digitalWrite(VELOCIDAD3,LOW);                                      // Inicializamos Salidas a 0
  digitalWrite(VENTILADOR,LOW);                                      // Inicializamos Salidas a 0
  digitalWrite(EXTRACTOR,LOW);                                       // Inicializamos Salidas a 0
  digitalWrite(MAPAS,LOW);                                           // Inicializamos Salidas a 0
  digitalWrite(MARCHA_ATRAS,LOW);                                    // Inicializamos Salidas a 0
  
  Voltimetro_Aux();
  Voltimetro_Car();
  Temperatura_Cabina();
  Temperatura_Asistencial();
  Temperatura_Exterior();
  Actualiza_Iconos();
  Actualiza_Iconos_Clima();
//  Actualiza_Iconos_Principal();

  NPenum.attachPush(Control_Penumbra);
  NPlafon.attachPush(Control_Plafones);
  NHalog.attachPush(Control_Halogenos);
  N230V.attachPush(Control_Convertidor);
  NCalor.attachPush(Control_Calefaccion);
  NCalor1.attachPush(Control_Calefaccion_Clima);
  NAire.attachPush(Control_Aire);
  NAire1.attachPush(Control_Aire_Clima);
  NVelo1.attachPush(Control_Velocidad1); 
  NVelo2.attachPush(Control_Velocidad2); 
  NVelo3.attachPush(Control_Velocidad3); 
  NVolverBrillo.attachPush(Actualiza_Iconos);  
  NVolverAjustes.attachPush(Actualiza_Iconos);
  NVolverClima.attachPush(Actualiza_Iconos);
  NClima.attachPush(Actualiza_Iconos_Clima);
  NVentila.attachPush(Control_Ventilador);
  NExtractor.attachPush(Control_Extractor);
}

void loop() 
{  
  EstadoVehiculo=digitalRead(CONTACTO);
  if ((EstadoVehiculo == HIGH)&&(Faros==0))
  {
    Serial3.print("NContactoTest.picc=");
    Serial3.print(1);
    Serial3.write(0xff); 
    Serial3.write(0xff); 
    Serial3.write(0xff);
    Faros=1;
  }

  if ((EstadoVehiculo == LOW)&&(Faros==1))
  {
    Serial3.print("NContactoTest.picc=");
    Serial3.print(0);
    Serial3.write(0xff); 
    Serial3.write(0xff); 
    Serial3.write(0xff);
    Faros=0;
  }
  if ((EstadoVehiculo == LOW) && ((EstadoAire == HIGH) || (EstadoCalefaccion == HIGH)))
  {
    
    Control_Clima_Contacto();
  }
  nexLoop(nex_listen_list);
  Pantalla_Delantera ();

  if ((PulsacionMarchaAtras == 1)||(PulsacionMarchaAtras == 2))
    {
       Actualiza_Marcha_Atras();
    }
  
  Contadortemp = Contadortemp + 1;
  ContadorVolt = ContadorVolt + 1;
  if (Contadortemp>1000000)
    {
    Temperatura_Exterior();
    Temperatura_Asistencial();
    Temperatura_Cabina();
    Contadortemp=0;
    }
   if (ContadorVolt>500000)
    {
    Voltimetro_Car();
    Voltimetro_Aux();
    ContadorVolt = 0;
    }  
}

void Pantalla_Delantera()
{     
   if (Serial3.available()>0)
   {
      String Cadena = Serial3.readStringUntil('ZZZ');
      if (Cadena == "NMapasP")
      {
        Control_Mapas();
      }
      if (Cadena == "NAtrasP")
      {
        Control_Marcha_Atras();
      }
      if (Cadena == "NTodasP")
      {
        Cadena="";
      }
      if (Cadena == "N230VP")
      {
        Control_Convertidor();
      }
      if (Cadena == "NCalorP")
      {
        Control_Calefaccion();
      }
      if (Cadena == "NAireP")
      {
        Control_Aire();
      }
//       if (Cadena == "NVolverP")
//      {
//        Actualiza_Iconos_Principal();
//      }
   }
}

void Control_Penumbra()                                               //Realizar Una Funcion que se realice al presionar el boton
{
  int EstadoPenumbra;
  EstadoPenumbra = digitalRead(PENUMBRA);
  if (EstadoPenumbra == LOW)
  {
    digitalWrite (PENUMBRA,HIGH);
    NPenumTest.setPic(1);
  }
  else
  {
    digitalWrite (PENUMBRA,LOW);
    NPenumTest.setPic(0);
  } 
}
void Control_Plafones()                                               //Realizar Una Funcion que se realice al presionar el boton
{
  int EstadoPlafones;
  EstadoPlafones = digitalRead(PLAFONES);
  if (EstadoPlafones == LOW)
  {
    digitalWrite (PLAFONES,HIGH);
    NPlafonTest.setPic(1);
  }
  else
  {
    digitalWrite (PLAFONES,LOW);
    NPlafonTest.setPic(0);
  } 
}
void Control_Halogenos()                                              //Realizar Una Funcion que se realice al presionar el boton
{
  int EstadoHalogenos;
  EstadoHalogenos = digitalRead(HALOGENOS);
  if (EstadoHalogenos == LOW)
  {
    digitalWrite (HALOGENOS,HIGH);
    NHalogTest.setPic(1);
  }
  else
  {
    digitalWrite (HALOGENOS,LOW);
    NHalogTest.setPic(0);
  } 
}

void Control_Convertidor()                                               //Realizar Una Funcion que se realice al presionar el boton
{
  int Estado230V;
  Estado230V = digitalRead(CONVERTIDOR);
  if (Estado230V == LOW)
  {
    digitalWrite (CONVERTIDOR,HIGH);
    N230VTest.setPic(1);
    Serial3.print("N230VP.picc=");
    Serial3.print(1);
    Serial3.write(0xff); 
    Serial3.write(0xff); 
    Serial3.write(0xff);
  }
  else
  {
    digitalWrite (CONVERTIDOR,LOW);
    N230VTest.setPic(0);
    Serial3.print("N230VP.picc=");
    Serial3.print(0);
    Serial3.write(0xff); 
    Serial3.write(0xff); 
    Serial3.write(0xff);
  } 
}

void Control_Calefaccion()                                               //Realizar Una Funcion que se realice al presionar el boton
{
    EstadoCalefaccion = digitalRead(CALEFACCION);
    if ((EstadoCalefaccion == LOW)&&(EstadoVehiculo == HIGH))
    {
      NAireTest.setPic(0);
      NCalorTest.setPic(1);
      Serial3.print("NAireP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      Serial3.print("NCalorP.picc=");
      Serial3.print(1);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      digitalWrite (AIRE,LOW);
      digitalWrite (CALEFACCION,HIGH);
      digitalWrite (VELOCIDAD1,HIGH);
      digitalWrite (VELOCIDAD2,LOW);
      digitalWrite (VELOCIDAD3,LOW);
      EstadoCalefaccion = digitalRead(CALEFACCION);
    }
    else
    {
      NAireTest.setPic(0);
      NCalorTest.setPic(0);
      Serial3.print("NAireP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      Serial3.print("NCalorP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      digitalWrite (CALEFACCION,LOW);
      digitalWrite (VELOCIDAD1,LOW);
      digitalWrite (VELOCIDAD2,LOW);
      digitalWrite (VELOCIDAD3,LOW);
      EstadoCalefaccion = digitalRead(CALEFACCION);
    } 
}

void Control_Aire()                                                        //Realizar Una Funcion que se realice al presionar el boton
{
    EstadoAire = digitalRead(AIRE);
    if ((EstadoAire == LOW)&&(EstadoVehiculo == HIGH))
    {
      NCalorTest.setPic(0);
      NAireTest.setPic(1);
      Serial3.print("NCalorP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.print("NAireP.picc=");
      Serial3.print(1);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);      
      digitalWrite (CALEFACCION,LOW);
      digitalWrite (AIRE,HIGH);
      digitalWrite (VELOCIDAD1,HIGH);
      digitalWrite (VELOCIDAD2,LOW);
      digitalWrite (VELOCIDAD3,LOW);
      EstadoAire = digitalRead(AIRE);
    }
    else
    {     
      NAireTest.setPic(0);
      NCalorTest.setPic(0);
      Serial3.print("NAireP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);    
      Serial3.print("NCalorP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      digitalWrite (AIRE,LOW);
      digitalWrite (VELOCIDAD1,LOW);
      digitalWrite (VELOCIDAD2,LOW);
      digitalWrite (VELOCIDAD3,LOW);
      EstadoAire = digitalRead(AIRE);
    } 
}

void Control_Calefaccion_Clima()                                               //Realizar Una Funcion que se realice al presionar el boton
{
    EstadoCalefaccion = digitalRead(CALEFACCION);
    if ((EstadoCalefaccion == LOW)&&(EstadoVehiculo == HIGH))
    {
      NCalor1Test.setPic(4);
      Serial3.print("NCalorP.picc=");
      Serial3.print(1);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      NAire1Test.setPic(3);
      Serial3.print("NAireP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      NVelo1Test.setPic(4);
      NVelo2Test.setPic(3);
      NVelo3Test.setPic(3);
      digitalWrite (AIRE,LOW);
      digitalWrite (CALEFACCION,HIGH);
      digitalWrite (VELOCIDAD1,HIGH);
      digitalWrite (VELOCIDAD2,LOW);
      digitalWrite (VELOCIDAD3,LOW);
      EstadoCalefaccion = digitalRead(CALEFACCION);
    }
    else
    {
      NAire1Test.setPic(3);
      Serial3.print("NAireP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      NCalor1Test.setPic(3);
      Serial3.print("NCalorP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      NVelo1Test.setPic(3);
      NVelo2Test.setPic(3);
      NVelo3Test.setPic(3);
      digitalWrite (CALEFACCION,LOW);
      digitalWrite (VELOCIDAD1,LOW);
      digitalWrite (VELOCIDAD2,LOW);
      digitalWrite (VELOCIDAD3,LOW); 
      EstadoCalefaccion = digitalRead(CALEFACCION);
    } 
}

void Control_Aire_Clima()                                                        //Realizar Una Funcion que se realice al presionar el boton
{
    EstadoAire = digitalRead(AIRE);
    if ((EstadoAire == LOW)&&(EstadoVehiculo == HIGH))
    {
      NCalor1Test.setPic(3);
      Serial3.print("NCalorP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      NAire1Test.setPic(4);
      Serial3.print("NAireP.picc=");
      Serial3.print(1);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      NVelo1Test.setPic(4);
      NVelo2Test.setPic(3);
      NVelo3Test.setPic(3);
      digitalWrite (CALEFACCION,LOW);
      digitalWrite (AIRE,HIGH);
      digitalWrite (VELOCIDAD1,HIGH);
      digitalWrite (VELOCIDAD2,LOW);
      digitalWrite (VELOCIDAD3,LOW);
      EstadoAire = digitalRead(AIRE);
    }
    else
    {
      NAire1Test.setPic(3);
      Serial3.print("NAireP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      NCalor1Test.setPic(3);
      Serial3.print("NCalorP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      NVelo1Test.setPic(3);
      NVelo2Test.setPic(3);
      NVelo3Test.setPic(3);
      digitalWrite (AIRE,LOW);
      digitalWrite (VELOCIDAD1,LOW);
      digitalWrite (VELOCIDAD2,LOW);
      digitalWrite (VELOCIDAD3,LOW);
      EstadoAire = digitalRead(AIRE);
    } 
}

void Control_Clima_Contacto()                                                        //Realizar Una Funcion que se realice al presionar el boton
{
    EstadoAire = digitalRead(AIRE);
    EstadoCalefaccion = digitalRead (CALEFACCION);
    if ((EstadoAire == HIGH)||(EstadoCalefaccion == HIGH))
    {
      NAireTest.setPic(0);
      NCalorTest.setPic(0);
      Serial3.print("NAireP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      Serial3.print("NCalorP.picc=");
      Serial3.print(0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      NAire1Test.setPic(3);
      NCalor1Test.setPic(3);
      NVelo1Test.setPic(3);
      NVelo2Test.setPic(3);
      NVelo3Test.setPic(3);
      digitalWrite (AIRE,LOW);
      digitalWrite (CALEFACCION,LOW);
      digitalWrite (VELOCIDAD1,LOW);
      digitalWrite (VELOCIDAD2,LOW);
      digitalWrite (VELOCIDAD3,LOW);
      EstadoAire = digitalRead(AIRE);
      EstadoCalefaccion = digitalRead(CALEFACCION);
    } 
}

void Control_Velocidad1()                                               //Realizar Una Funcion que se realice al presionar el boton
{
    EstadoVelocidad1 = digitalRead(VELOCIDAD1);
    EstadoAire = digitalRead(AIRE);
    EstadoCalefaccion = digitalRead(CALEFACCION);
    if ((EstadoVelocidad1 == LOW) && ((EstadoAire == HIGH) || (EstadoCalefaccion == HIGH)))
    {
      NVelo1Test.setPic(4);
      NVelo2Test.setPic(3);
      NVelo3Test.setPic(3);
      digitalWrite (VELOCIDAD1,HIGH);
      digitalWrite (VELOCIDAD2,LOW);
      digitalWrite (VELOCIDAD3,LOW);
    }
}

void Control_Velocidad2()                                               //Realizar Una Funcion que se realice al presionar el boton
{
    EstadoVelocidad2 = digitalRead(VELOCIDAD2);
    EstadoAire = digitalRead(AIRE);
    EstadoCalefaccion = digitalRead(CALEFACCION);
    if ((EstadoVelocidad2 == LOW) && ((EstadoAire == HIGH) || (EstadoCalefaccion == HIGH)))
    {
      NVelo1Test.setPic(3);
      NVelo2Test.setPic(4);
      NVelo3Test.setPic(3);
      digitalWrite (VELOCIDAD1,LOW);
      digitalWrite (VELOCIDAD2,HIGH);
      digitalWrite (VELOCIDAD3,LOW);
    }
}

void Control_Velocidad3()                                               //Realizar Una Funcion que se realice al presionar el boton
{
    EstadoVelocidad3 = digitalRead(VELOCIDAD3);
    EstadoAire = digitalRead(AIRE);
    EstadoCalefaccion = digitalRead(CALEFACCION);
    if ((EstadoVelocidad3 == LOW) && ((EstadoAire == HIGH) || (EstadoCalefaccion == HIGH)))
    {
      NVelo1Test.setPic(3);
      NVelo2Test.setPic(3);
      NVelo3Test.setPic(4);
      digitalWrite (VELOCIDAD1,LOW);
      digitalWrite (VELOCIDAD2,LOW);
      digitalWrite (VELOCIDAD3,HIGH);
    }
}

void Control_Ventilador()                                                        //Realizar Una Funcion que se realice al presionar el boton
{   
    int EstadoVentilador;
    EstadoVentilador = digitalRead(VENTILADOR);
    if (EstadoVentilador == LOW)
    {
      NExtractorTest.setPic(3);
      NVentilaTest.setPic(4);
      digitalWrite (EXTRACTOR,LOW);
      delay(400);
      digitalWrite (VENTILADOR,HIGH);
    }
    else
    {
      NExtractorTest.setPic(3);
      NVentilaTest.setPic(3);
      digitalWrite (VENTILADOR,LOW);
    } 
}

void Control_Extractor()                                                        //Realizar Una Funcion que se realice al presionar el boton
{   
    int EstadoExtractor;
    EstadoExtractor = digitalRead(EXTRACTOR);
    if (EstadoExtractor == LOW)
    {
      NVentilaTest.setPic(3);
      NExtractorTest.setPic(4);
      digitalWrite (VENTILADOR,LOW);
      delay(400);
      digitalWrite (EXTRACTOR,HIGH);
    }
    else
    {
      NExtractorTest.setPic(3);
      NVentilaTest.setPic(3);
      digitalWrite (EXTRACTOR,LOW);
    } 
}

void Actualiza_Iconos()                                                      //Realizar Una Funcion que se realice al presionar el boton
{
//  int ActualizaHalogenos;
//    ActualizaHalogenos = digitalRead(HALOGENOS);
//      if (ActualizaHalogenos == HIGH)
//      {
//        NHalogTest.setPic(1);
//      }
//  
//  int ActualizaPenumbra;
//    ActualizaPenumbra = digitalRead(PENUMBRA);
//      if (ActualizaPenumbra == HIGH)
//      {
//        NPenumTest.setPic(1);
//      }
//
//  int ActualizaPlafon;
//    ActualizaPlafon = digitalRead(PLAFONES);
//      if (ActualizaPlafon == HIGH)
//      {
//        NPlafonTest.setPic(1);
//      } 
//  
//  int Actualiza230V;
//    Actualiza230V = digitalRead(CONVERTIDOR);
//      if (Actualiza230V == HIGH)
//      {
//        N230VTest.setPic(1);
//      }

  int ActualizaCalor;
    ActualizaCalor = digitalRead(CALEFACCION);
      if (ActualizaCalor == HIGH)
      {
        NCalorTest.setPic(1);
      }

   int ActualizaAire;
    ActualizaAire = digitalRead(AIRE);
      if (ActualizaAire == HIGH)
      {
        NAireTest.setPic(1);
      }

}

void Actualiza_Iconos_Clima()
{
  int ActualizaCalor;
    ActualizaCalor = digitalRead(CALEFACCION);
      if (ActualizaCalor == HIGH)
      {
        NCalor1Test.setPic(4);
      }

   int ActualizaAire;
    ActualizaAire = digitalRead(AIRE);
      if (ActualizaAire == HIGH)
      {
        NAire1Test.setPic(4);
      }

   int ActualizaVelo1;
    ActualizaVelo1 = digitalRead(VELOCIDAD1);
      if (ActualizaVelo1 == HIGH)
      {
        NVelo1Test.setPic(4);
      }
      
   int ActualizaVelo2;
    ActualizaVelo2 = digitalRead(VELOCIDAD2);
      if (ActualizaVelo2 == HIGH)
      {
        NVelo2Test.setPic(4);
      }

   int ActualizaVelo3;
    ActualizaVelo3 = digitalRead(VELOCIDAD3);
      if (ActualizaVelo3 == HIGH)
      {
        NVelo3Test.setPic(4);
      }

//   int ActualizaVentilador;
//    ActualizaVentilador = digitalRead(VENTILADOR);
//      if (ActualizaVentilador == HIGH)
//      {
//        NVentilaTest.setPic(4);
//      }
//      else
//      {
//        NVentilaTest.setPic(3);
//      }
//  
//    int ActualizaExtractor;
//     ActualizaExtractor = digitalRead(EXTRACTOR);
//      if (ActualizaExtractor == HIGH)
//      {
//        NExtractorTest.setPic(4);
//      }
//      else
//      {
//        NExtractorTest.setPic(3);
//      }
}

//void Actualiza_Iconos_Principal()                                                      //Realizar Una Funcion que se realice al presionar el boton
//{
//  int Actualiza230VP;
//    Actualiza230VP = digitalRead(CONVERTIDOR);
//      if (Actualiza230VP == HIGH)
//      {
//        Serial3.print("N230VP.picc=");
//        Serial3.print(1);
//        Serial3.write(0xff); 
//        Serial3.write(0xff); 
//        Serial3.write(0xff);
//      }
//
//  int ActualizaCalorP;
//    ActualizaCalorP = digitalRead(CALEFACCION);
//      if (ActualizaCalorP == HIGH)
//      {
//        Serial3.print("NCalorP.picc=");
//        Serial3.print(1);
//        Serial3.write(0xff); 
//        Serial3.write(0xff); 
//        Serial3.write(0xff);
//      }
//
//   int ActualizaAireP;
//    ActualizaAireP = digitalRead(AIRE);
//      if (ActualizaAireP == HIGH)
//      {
//        Serial3.print("NAireP.picc=");
//        Serial3.print(1);
//        Serial3.write(0xff); 
//        Serial3.write(0xff); 
//        Serial3.write(0xff);
//      }
//}

void Control_Mapas()                                               //Realizar Una Funcion que se realice al presionar el boton
{
  int EstadoMapas;
  EstadoMapas = digitalRead(MAPAS);
  if (EstadoMapas == LOW)
  {
    digitalWrite (MAPAS,HIGH);
    Serial3.print("NMapasP.picc=");
    Serial3.print(1);
    Serial3.write(0xff); 
    Serial3.write(0xff); 
    Serial3.write(0xff);
  }
  else
  {
    digitalWrite (MAPAS,LOW);
    Serial3.print("NMapasP.picc=");
    Serial3.print(0);
    Serial3.write(0xff); 
    Serial3.write(0xff); 
    Serial3.write(0xff);
  } 
}

void Control_Marcha_Atras()                                                                             //Realizar Una Funcion que se realice al presionar el boton
{
   digitalWrite (MARCHA_ATRAS,HIGH);
   Serial3.print("NAtrasP.picc=");
   Serial3.print(1);
   Serial3.write(0xff); 
   Serial3.write(0xff); 
   Serial3.write(0xff);
   PulsacionMarchaAtras=1;
   delay(250);
   digitalWrite (MARCHA_ATRAS,LOW);
}

void Actualiza_Marcha_Atras()                                                                                 //Realizar Una Funcion que se realice al presionar el boton
{
  EstadoMarchaAtras = digitalRead(SENAL_ATRAS);
    if ((EstadoMarchaAtras == HIGH)&&(PulsacionMarchaAtras == 1))
        {
         Serial3.print("NAtrasP.picc=");
         Serial3.print(1);
         Serial3.write(0xff); 
         Serial3.write(0xff); 
         Serial3.write(0xff);
         PulsacionMarchaAtras=2;
        }
    if ((EstadoMarchaAtras == LOW)&&((PulsacionMarchaAtras == 2)||(PulsacionMarchaAtras == 1)))
        {
         Serial3.print("NAtrasP.picc=");
         Serial3.print(0);
         Serial3.write(0xff); 
         Serial3.write(0xff); 
         Serial3.write(0xff);
        PulsacionMarchaAtras=0;
        }
} 

void Temperatura_Cabina()
{
  V1 = analogRead(TEMPERATURA_CAB);                                                                           // lectura de A1
  R2Cab = R1 * (1023.0 / (float)V1 - 1.0);                                                                    // conversion de tension a resistencia
  logR2Cab = log(R2Cab);                                                                                      // logaritmo de R2 necesario para ecuacion
  TEMPERATURACab = (1.0 / (Cab0 + Cab1*logR2Cab + Cab2*logR2Cab*logR2Cab*logR2Cab));                          // ecuacion S-H
  TEMPERATURACab = ((TEMPERATURACab - 273.15)*10);                                                            // Kelvin a Centigrados (Celsius) * 10 para enviar valor a Nextion

  Serial2.print("NTempCab.val=");
  Serial2.print((int)TEMPERATURACab);
  Serial2.write(0xff); 
  Serial2.write(0xff); 
  Serial2.write(0xff); 

  Serial3.print("NTempCabP.val=");
  Serial3.print((int)TEMPERATURACab);
  Serial3.write(0xff); 
  Serial3.write(0xff); 
  Serial3.write(0xff);
}

void Temperatura_Asistencial()
{
  V2 = analogRead(TEMPERATURA_ASIST);                                                                            // lectura de A2
  R2Asist = R1 * (1023.0 / (float)V2 - 1.0);                                                           // conversion de tension a resistencia
  logR2Asist = log(R2Asist);                                                                                // logaritmo de R2 necesario para ecuacion
  TEMPERATURAAsist = (1.0 / (Asist0 + Asist1*logR2Asist + Asist2*logR2Asist*logR2Asist*logR2Asist));                                   // ecuacion S-H
  TEMPERATURAAsist = ((TEMPERATURAAsist - 273.15)*10);                                                    // Kelvin a Centigrados (Celsius) * 10 para enviar valor a Nextion

  Serial2.print("NTempAsist.val=");
  Serial2.print((int)TEMPERATURAAsist);
  Serial2.write(0xff); 
  Serial2.write(0xff); 
  Serial2.write(0xff); 

  Serial3.print("NTempAsistP.val=");
  Serial3.print((int)TEMPERATURAAsist);
  Serial3.write(0xff); 
  Serial3.write(0xff); 
  Serial3.write(0xff);  
}

void Temperatura_Exterior()
{
  V3 = analogRead(TEMPERATURA_EXT);                                                                            // lectura de A3
  R2Ext = R1 * (1023.0 / (float)V3 - 1.0);                                                           // conversion de tension a resistencia
  logR2Ext = log(R2Ext);                                                                                // logaritmo de R2 necesario para ecuacion
  TEMPERATURAExt = (1.0 / (Ext0 + Ext1*logR2Ext + Ext2*logR2Ext*logR2Ext*logR2Ext));                                   // ecuacion S-H
  TEMPERATURAExt = ((TEMPERATURAExt - 273.15)*10);                                                    // Kelvin a Centigrados (Celsius) * 10 para enviar valor a Nextion                                                            // imprime valor en monitor serie 
                                                                                                        // imprime valor en monitor serie
  Serial2.print("NTempExt.val=");
  Serial2.print((int)TEMPERATURAExt);
  Serial2.write(0xff); 
  Serial2.write(0xff); 
  Serial2.write(0xff); 
  
  Serial3.print("NTempExtP.val=");
  Serial3.print((int)TEMPERATURAExt);
  Serial3.write(0xff); 
  Serial3.write(0xff); 
  Serial3.write(0xff);   
}

void Voltimetro_Car()
{
  ValorCar = analogRead (VOLTIMETRO_CAR);
  VOutCar = (ValorCar * 4.2)/1023;
  VInCar = VOutCar/(R2Car / (R1Car + R2Car));
  if (VInCar<0.9)
   {
     VInCar = 0;
   }
    Serial2.print("NVoltCar.val=");
    Serial2.print(VInCar*10, 0);
    Serial2.write(0xff); 
    Serial2.write(0xff); 
    Serial2.write(0xff); 

    Serial3.print("NVoltCarP.val=");
    Serial3.print(VInCar*10, 0);
    Serial3.write(0xff); 
    Serial3.write(0xff); 
    Serial3.write(0xff); 

     if (VInCar<11.8)
      {
      NCarTest.setPic(2);
      Serial3.print("NCarTestP.picc=");
      Serial3.print(2);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      }
     if (VInCar>=12)
      {
      NCarTest.setPic(1);
      Serial3.print("NCarTestP.picc=");
      Serial3.print(1);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
      }   
}

void Voltimetro_Aux()
{
  ValorAux = analogRead (VOLTIMETRO_AUX);
  VOutAux = (ValorAux * 4.2)/1023;
  VInAux = VOutAux/(R2Aux / (R1Aux + R2Aux));
    if (VInAux<0.9)
     {
       VInAux = 0;
     }
      Serial2.print("NVoltAux.val=");
      Serial2.print(VInAux*10, 0);
      Serial2.write(0xff); 
      Serial2.write(0xff); 
      Serial2.write(0xff); 
  
      Serial3.print("NVoltAuxP.val=");
      Serial3.print(VInAux*10, 0);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff); 

    if (VInAux<11.8)
    {
      NAuxTest.setPic(2);
      Serial3.print("NAuxTestP.picc=");
      Serial3.print(2);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
    }
     if (VInAux>=12)
    {
      NAuxTest.setPic(1);
      Serial3.print("NAuxTestP.picc=");
      Serial3.print(1);
      Serial3.write(0xff); 
      Serial3.write(0xff); 
      Serial3.write(0xff);
    }   
}
2

La libreria oficial es bastante mala usa mucha memoria y es lenta te recomiendo que hagas tu propio codigo.
Yo empece con la libreria oficial y me iba bien hasta que empiezas a meter mas elementos y notas que hay botones de los que no se entera que has pulsado, desde que hice mi codigo no he vuelto a tener ese problema.

3

Pues vaya…
Y como solucionaste la lectura del puerto serial cada vez que aprietas un botón en la pantalla ?

Yo le he puesto este if, y le he puesto unos serial.print para ver cuando ejecuta ese if, y después de pulsar el botón entra tres veces, una capta la cadena que envío, dos veces más sin captar nada.

4

He hecho un codigo completo para manejar la pantalla, la lectura le hice un timeout de 200ms ya que me vaciaba el buffer antes de que la pantalla enviara toda la trama.
Desde Nextion Editor en el simulador puedes ver la trama que daría la pantalla, la unica parte mas complicada sería pedirle valores de un campo pero puedes ver en la libreria oficial como lo hace.

Cada comando que envias la pantalla te devuelve un codigo de confirmación o error.

5

Ok, pero el timeout está dentro de serial.available? Entiendo que si no?

Es posible que lo que lo que reciba sea el mensaje de confirmación pero como no tiene la terminación del if… pues Jose, probaré a quitar las librerías a ver qué tal

También quiero probar el arduino Due, que parece que sea mucho más rápido, crees que se notará?

6

Lo tengo antes por que se vaciaba todo el buffer antes de acabar la trama.
Probé el Due con la librería oficial y iba exactamente igual de mal.

7

Y probaste el arduino Due sin librerías? Alguna diferencia? Bueno, he ido avanzando, ya me va todo bastante fluido, pero he detectado que si le doy algún botón de la pantalla en el mismo instante que está calculando los valores de temperatura y voltaje ( hay 3 sensores de temperatura y dos de voltaje) no actualiza el evento, como podría eliminar ese problema? Había pensando en poner otro arduino (nano o uno) para hacer los cálculos y enviarlos por serial o por i2c, pero no me veo capaz… que puedo hacer?

8

No lo he probado porque con Due no puedo actualizarlo por bluetooth como hago con Mega.
Comenta los calculos para probar si es el causante pero lo dudo bastante, el mio calcula tambien muchas cosas y no tengo problema, mi programa es de 187kb

9

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.