Nextion problem with arduino

Fbaptista · July 4, 2019, 6:21pm

Hello, i´m starting a project with arduino mega and nextion and i have problems when i use the function
popcallback. i´m sending some variables to nextion, clock, temperature, ph, two progressive bars etc.
On this project i have 4 pages and i checked when i change to one page without theses variables the nextion return the code 1A FF FF FF . On arduino i´m sending the values to page 1 only.

I think popcallback don´t work because bus is busy with return data and don´t read popcallback operations.
I need some help. Thanks in advance.

#include <EEPROM.h>
#include <Nextion.h>
#include <SoftwareSerial.h>   // Library for Software Serial Port
#define espacoEEPROM 4000   //4Kb para arduino mega, 1k para arduino uno



// parametros RTC
#include <virtuabotixRTC.h>   
#define   clk   6
#define   dat   7
#define   rst   8
#define   segL       19
#define   minL       45
#define   horL       19
#define   d_semL      6
#define   d_mesL     24
#define   mesL        6
#define   anoL     2019


char data_temperatura;
char datas_serial;
char buffer[10];
float temperature;

//valores a memorizar na eeprom ////////////////////////
//endereço de memória para guardar o valor do set tempetatura
int address1 = 0; //inicializa o valor de temperatura no endereço 0 da eeprom

////// endereços de memoria para as funções automáticas##############################################################
////feed
int address2 = 10; //inicializa o valor da hora ligar feed
int address3 = 20; //inicializa o valor do minuto ligar feed



/////bomba filtro

int address6 = 50; //inicializa o valor da hora ligar bomba
int address7 = 60; // inicializa o valor do minuto ligar bomba
int address8 = 70; // inicializa o valor da hora desligar bomba
int address9 = 80; // inicializa o valor do minuto desligar bomba

///// iluminação


int address10 = 90; //inicializa o valor da hora ligar iluminacao
int address11 = 100; //inicializa o valor do minuto ligar iluminacao
int address12 = 110; //inicializa o valor da hora desligar iluminacao
int address13 = 120; //inicializa o valor do minuto desligar iluminacao



int settemp; // inicializa a valiável temperatura do set temperatura


// valores variáveis função automática
//feed
int horafeedligar;
int minutofeedligar;


//bomba
int horabombaligar;
int minutobombaligar;
int horabombadesligar;
int minutobombadesligar;


//iluminação
int horailuminacaoligar;
int minutoiluminacaoligar;
int horailuminacaodesligar;
int minutoiluminacaodesligar;


void EEPROMWriteInt(int address, int value); //2 Bytes
int  EEPROMReadInt(int address);




//===========================================================================
// MANUAL BUTTONS



int variable1 = 0;  // Create a variable to have a counter going up by one on each cycle
int counter = 0;  // Create a variable to have a counter for the + and - buttons
int CurrentPage = 0;



//envio dos valores temp,horas,etc para  nextion

NexNumber d_val = NexNumber(3, 8, "settemp");
NexText vel_val  = NexText(0, 11, "t3");
NexNumber temp_digit  = NexNumber(0, 23, "n0");    
NexProgressBar j0 = NexProgressBar(0, 2, "j0");
NexProgressBar j1 = NexProgressBar(0, 3, "j1");
NexText ph_val  = NexText(0, 4, "t1");

//envio de valores para programador
//feed
NexNumber horafeedligar_val = NexNumber(1, 51, "n10");
NexNumber minutofeedligar_val = NexNumber(1, 52, "n12");
//bomba filtro
NexNumber horabombaligar_val = NexNumber(1, 35, "n14");
NexNumber minutobombaligar_val = NexNumber(1, 36, "n16");
NexNumber horabombadesligar_val = NexNumber(1, 37, "n15");
NexNumber minutobombadesligar_val = NexNumber(1, 38, "n17");
//iluminação
NexNumber horailuminacaoligar_val = NexNumber(1, 19, "n18");
NexNumber minutoiluminacaoligar_val = NexNumber(1, 20, "n20");
NexNumber horailuminacaodesligar_val = NexNumber(1, 21, "n19");
NexNumber minutoiluminacaodesligar_val = NexNumber(1, 22, "n21");

//declaração de botões set temp
NexButton b1 = NexButton(3, 6, "b1"); //botão de set temperature +
NexButton b2 = NexButton(3, 7, "b2"); //botão de -

// decalaração de botões para programação automática
// feed
NexButton b100 = NexButton(1, 41, "b100"); //botão de hora + feed on
NexButton b101 = NexButton(1, 43, "b101"); //botão de hora - feed on
NexButton b104 = NexButton(1, 42, "b104"); //botão de minuto + feed on
NexButton b105 = NexButton(1, 46, "b105"); //botão de minuto - feed on
//bomba filtro
NexButton b108 = NexButton(1, 31, "b108"); //botão de hora + bomba on
NexButton b109 = NexButton(1, 33, "b109"); //botão de hora - bomba on
NexButton b110 = NexButton(1, 23, "b110"); //botão de hora + bomba off
NexButton b111 = NexButton(1, 25, "b111"); //botão de hora - bomba off
NexButton b112 = NexButton(1, 32, "b112"); //botão de minuto + bomba on
NexButton b113 = NexButton(1, 34, "b113"); //botão de minuto - bomba on
NexButton b114 = NexButton(1, 24, "b113"); //botão de minuto + bomba off
NexButton b115 = NexButton(1, 26, "b114"); //botão de minuto - bomba off
//iluminação
NexButton b116 = NexButton(1, 48, "b116"); //botão de hora luz on
NexButton b117 = NexButton(1, 17, "b117"); //botão de hora luz on
NexButton b118 = NexButton(1, 3, "b118"); //botão de hora luz off
NexButton b119 = NexButton(1, 47, "b119"); //botão de hora luz off
NexButton b120 = NexButton(1, 49, "b120"); //botão de minuto  luz on
NexButton b121 = NexButton(1, 18, "b121"); //botão de minuto  luz on
NexButton b122 = NexButton(1, 4, "b122"); //botão de minuto luz off
NexButton b123 = NexButton(1, 5, "b123"); //botão de minuto luz off



NexDSButton bt0 = NexDSButton(2, 5, "bt0");  // Dual state bomba filtro
NexDSButton bt1 = NexDSButton(2, 6, "bt1");  // Dual state alimentador
NexDSButton bt2 = NexDSButton(2, 7, "bt2");  // Dual state iluminação



NexTouch *nex_listen_list[] = 
{

&b1, // botão + do set temp
&b2, // botão - do set temp

//botoes do temporizador
&b100,
&b101,
&b104,
&b105,
&b108,
&b109,
&b110,
&b111,
&b112,
&b113,
&b114,
&b115,
&b116,
&b117,
&b118,
&b119,
&b120,
&b121,
&b122,
&b123,

 
&bt0,  // bt0 bt1 bt2 botões dual state para controlos manuais
&bt1,  
&bt2,  
  
  
 
  
    NULL  // String terminated
};  // End of touch event list

Fbaptista · July 4, 2019, 6:33pm

//botoes para incremento-decremento do set temperature do nextion


  void b1PopCallback(void *ptr)  // Release event for button b1
{
 
  settemp= settemp + 1;

  if(settemp >40)  // proteção temperatura máxima
  {settemp = 40;
  }
  
  EEPROM.write(0, settemp);
}  // End of release event
  
  void b2PopCallback(void *ptr)  // Release event for button b2
{
  
  settemp= settemp - 1;
  if(settemp < 0)  // proteção temperatura mínima 
  {settemp = 0;
  EEPROM.write(0, settemp);
  }
  
 
}  // End of release event

/////botoes programacao automatica /////////////////////////////////////////////////////////////////////////////7

void b100PopCallback(void *ptr)  // Release event for button 
{
  horafeedligar = horafeedligar + 1;
   
   if(horafeedligar > 23)
   {horafeedligar = 0;
   EEPROM.write(10, horafeedligar);
   }
     
 
}  // End of release event

void b101PopCallback(void *ptr)  // Release event for button 
{
  horafeedligar = horafeedligar - 1;
  
   if(horafeedligar < 0)
   {horafeedligar = 23;
   EEPROM.write(10, horafeedligar);
   }
    
   
}  // End of release event



void b104PopCallback(void *ptr)  // Release event for button 
{
  
  minutofeedligar = minutofeedligar + 1;
  
  if(minutofeedligar > 59)
  {minutofeedligar = 0;
  
  EEPROM.write(20, minutofeedligar);
  }
  
}  // End of release event


void b105PopCallback(void *ptr)  // Release event for button 
{
    minutofeedligar = minutofeedligar - 1;
    
  if(minutofeedligar < 0)
  {minutofeedligar = 59 ;
    EEPROM.write(20, minutofeedligar);
  }
  

}  // End of release event




void b108PopCallback(void *ptr)  // Release event for button 
{

  horabombaligar= horabombaligar + 1;
  
  if(horabombaligar > 23)
   {horabombaligar = 0;
   EEPROM.write(50, horabombaligar);
   }
   
  
}  // End of release event


void b109PopCallback(void *ptr)  // Release event for button 
{
 
  horabombaligar = horabombaligar - 1;
  
    if(horabombaligar < 0)
    {horabombaligar = 23;
      EEPROM.write(50, horabombaligar);
     }
   

}  // End of release event


void b110PopCallback(void *ptr)  // Release event for button 
{

  horabombadesligar = horabombadesligar + 1;
  if(horabombadesligar > 23)
   {horabombadesligar = 0;
    EEPROM.write(70, horabombadesligar);
   }
 
}  // End of release event


void b111PopCallback(void *ptr)  // Release event for button 
{
  
  horabombadesligar = horabombadesligar - 1;
  
  if(horabombadesligar < 0)
   {horabombadesligar = 23;
     EEPROM.write(70, horabombadesligar);
   }
   

}  // End of release event


void b112PopCallback(void *ptr)  // Release event for button 
{
 
  minutobombaligar= minutobombaligar + 1;
   if(minutobombaligar > 59)
  {minutobombaligar = 0;
  
  EEPROM.write(60, minutobombaligar);
  }
  
}  // End of release event


void b113PopCallback(void *ptr)  // Release event for button 
{
  minutobombaligar= minutobombaligar - 1;
  if(minutobombaligar < 0)
  {minutobombaligar = 59;
    EEPROM.write(60, minutobombaligar);
  }

}  // End of release event



void b114PopCallback(void *ptr)  // Release event for button 
{
 
  minutobombadesligar = minutobombadesligar + 1;
   if(minutobombadesligar > 59)
  {minutobombadesligar = 0;
  EEPROM.write(80, minutobombadesligar);
  }
  
}  // End of release event


void b115PopCallback(void *ptr)  // Release event for button
{
   minutobombadesligar = minutobombadesligar - 1;
   if(minutobombadesligar < 0)
  {minutobombadesligar = 59;
  EEPROM.write(80, minutobombadesligar);
  }
  
}  // End of release event


void b116PopCallback(void *ptr)  // Release event for button 
{
  
  horailuminacaoligar = horailuminacaoligar + 1;
  
  if(horailuminacaoligar > 23)
   {horailuminacaoligar = 0;
    EEPROM.write(90, horailuminacaoligar);
   }
   
 
}  // End of release event


void b117PopCallback(void *ptr)  // Release event for button 
{
 
  horailuminacaoligar = horailuminacaoligar - 1;
  
  if(horailuminacaoligar < 0)
   {horailuminacaoligar = 23 ;
    EEPROM.write(90, horailuminacaoligar);
   }
   
    
}  // End of release event


void b118PopCallback(void *ptr)  // Release event for button 
{
 
  horailuminacaodesligar = horailuminacaodesligar + 1;
  
  if(horailuminacaodesligar > 23)
   {horailuminacaodesligar = 0;
   
  EEPROM.write(110, horailuminacaodesligar);
   }
   
}  // End of release event


void b119PopCallback(void *ptr)  // Release event for button 
{

  horailuminacaodesligar = horailuminacaodesligar - 1;
  
  if(horailuminacaodesligar < 0)
   {horailuminacaodesligar = 23;
   EEPROM.write(110, horailuminacaodesligar);
   }
   
  
}  // End of release event



void b120PopCallback(void *ptr)  // Release event for button 
{
  
  minutoiluminacaoligar = minutoiluminacaoligar + 1;
   if(minutoiluminacaoligar > 59)
  {minutoiluminacaoligar = 0;
  EEPROM.write(100, minutoiluminacaoligar);
  }
  
}  // End of release event


void b121PopCallback(void *ptr)  // Release event for button 
{
   minutoiluminacaoligar = minutoiluminacaoligar - 1;
   if(minutoiluminacaoligar < 0)
  {minutoiluminacaoligar = 59;
   EEPROM.write(100, minutoiluminacaoligar);
  }
 
}  // End of release event


void b122PopCallback(void *ptr)  // Release event for button 
{
  
  minutoiluminacaodesligar = minutoiluminacaodesligar + 1;
   if(minutoiluminacaodesligar > 59)
  {minutoiluminacaodesligar = 0;
   EEPROM.write(120, minutoiluminacaodesligar);
  }

}  // End of release event


void b123PopCallback(void *ptr)  // Release event for button
{
    minutoiluminacaodesligar = minutoiluminacaodesligar - 1;
    if(minutoiluminacaodesligar < 0)
  {minutoiluminacaodesligar = 59;
   EEPROM.write(120, minutoiluminacaodesligar);
  }
 
}  // End of release event




// botão dual state iluminação 
void bt0PopCallback(void *ptr)  // Release event for dual state button             
{
  uint32_t number5 = 0;  // Create variable to store value we are going to get
  bt0.getValue(&number5);  // Read value of dual state button to know the state (0 or 1)

  if(number5 == 1){  // If dual state button is equal to 1 (meaning is ON)...
    digitalWrite(4, HIGH);  // Turn ON internal LED
  }else{  // Since the dual state button is OFF...
    digitalWrite(4, LOW);  // Turn OFF internal LED
  }
}  // End of release event


// botão dual state bomba circulação 
void bt1PopCallback(void *ptr)  // Release event for dual state button bt      
{
  uint32_t number5 = 0;  // Create variable to store value we are going to get
  bt1.getValue(&number5);  // Read value of dual state button to know the state (0 or 1)

  if(number5 == 1){  // If dual state button is equal to 1 (meaning is ON)...
    digitalWrite(5, HIGH);  // Turn ON internal LED
  }else{  // Since the dual state button is OFF...
    digitalWrite(5, LOW);  // Turn OFF internal LED
  }
}  // End of release event

// botão dual state alimentador
void bt2PopCallback(void *ptr)  // Release event for dual state button bt2     
{
  uint32_t number5 = 0;  // Create variable to store value we are going to get
  bt2.getValue(&number5);  // Read value of dual state button to know the state (0 or 1)

  if(number5 == 1){  // If dual state button is equal to 1 (meaning is ON)...
    digitalWrite(3, HIGH); 
    delay (100);
     digitalWrite(3, LOW);  // Turn OFF internal LED// Turn ON internal LED
  }else{  // Since the dual state button is OFF...
    digitalWrite(3, HIGH); 
    delay (100);
    digitalWrite(3, LOW);  // Turn OFF internal LED
  }
}  // End of release event

Fbaptista · July 4, 2019, 6:42pm

virtuabotixRTC   myRTC(clk, dat, rst);         //declara objeto para o RTC


int     temperatura = 0x00,    //valor da variavel de temperatura 
        ph = 0x00,            //valor da variavel de ph 
        bar_ph = 0x00,        // valor da barra de ph
        bar_value = 0x00;    //valor da barra de temperatura

char    txt1[10],
        txt2[10],
        txt3[10],
        txt5[10],
        txt4[10];//texto para conversão e exibição
        
boolean    flag1 = 0x00, 
           flag2 = 0x00;        //armazena o estado do botão
        
// ========================================================================================================

void DS1302();
//void week(int dayW);

// parametros sensor temperatura

const double VCC = 5;             
const double R2 = 10000;            // 10k ohm series resistor
const double adc_resolution = 1023; // 10-bit adc

const double A = 0.001129148;   // thermistor equation parameters
const double B = 0.000234125;
const double C = 0.0000000876741; 

//const double D = 28; //valor de temperatura para disparar o termostato

#define SensorPin A2          //pH meter Analog output to Arduino Analog Input 
unsigned long int avgValue;  //Store the average value of the sensor feedback
float b;
int buf[100],temp;

// parametros sensor de nível
//sensor de nível pino 9

const int buttonPin = 9;    //define pino 9 como input para sensor de nível
int buttonState = 0;


void setup()




{   nexInit(); 


 
   // declaração de ouputs
  pinMode(2,OUTPUT); //saida para ativar termostato
  pinMode(3,OUTPUT);  //saida para ativar alimentador
  pinMode(4,OUTPUT);  //saida para ativar iluminação
  pinMode(5,OUTPUT);  //saida para ativar bomba circulação

 pinMode(10,OUTPUT);  //led teste

  Serial.begin(9600);  


////codigo eeprom////////////////////////////////
  //Limpeza da EEPROM (Executado apenas para limpar a memoria. IMPORTANTE: Apos a primeira carga, comentar este trecho e efetuar a segunda carga em seguida.)
//for (int nL = 0; nL < espacoEEPROM; nL++) { 
 // EEPROM.write(nL, 0);
//}  //Comentar até aqui.




   //  set temp
   b1.attachPop(b1PopCallback);
   b2.attachPop(b2PopCallback);

   // set programador
   b100.attachPop(b100PopCallback);
   b101.attachPop(b101PopCallback);
   b104.attachPop(b104PopCallback);
   b105.attachPop(b105PopCallback);
   b108.attachPop(b108PopCallback);
   b109.attachPop(b109PopCallback);
   b110.attachPop(b110PopCallback);
   b111.attachPop(b111PopCallback);
   b112.attachPop(b112PopCallback);
   b113.attachPop(b113PopCallback);
   b114.attachPop(b114PopCallback);
   b115.attachPop(b115PopCallback);
   b116.attachPop(b116PopCallback);
   b117.attachPop(b117PopCallback);
   b118.attachPop(b118PopCallback);
   b119.attachPop(b119PopCallback);
   b120.attachPop(b120PopCallback);
   b121.attachPop(b121PopCallback);
   b122.attachPop(b122PopCallback);
   b123.attachPop(b123PopCallback);


   
   bt0.attachPop(bt0PopCallback);  // Dual state button bt0 release
   bt1.attachPop(bt1PopCallback);  // Dual state button bt1 release
   bt2.attachPop(bt2PopCallback);  // Dual state button bt2 release

   



    
   // initialize the pushbutton pin as an input: Sensor de nível
   //sensor de nível pino 9
   pinMode(buttonPin, INPUT);
  
   //Faz upload do código para o Arduino uma vez para carregar os
  //dados iniciais no RTC. Após carregar os dados a linha abaixo deve ficar comentada.

 //myRTC.setDS1302Time(segL, minL, horL, d_semL, d_mesL, mesL, anoL);
 // leitura da memoria antes de atualizar para o novo valor obtido pelo botão do nextion  
settemp = EEPROM.read(address1);

//memoria feed
horafeedligar = EEPROM.read(address2);
minutofeedligar = EEPROM.read(address3);

//memoria bomba
horabombaligar = EEPROM.read(address6);
minutobombaligar = EEPROM.read(address7);
horabombadesligar = EEPROM.read(address8);
minutobombadesligar = EEPROM.read(address9);
//memoria iluminação
horailuminacaoligar = EEPROM.read(address10);
minutoiluminacaoligar = EEPROM.read(address11);
horailuminacaodesligar = EEPROM.read(address12);
minutoiluminacaodesligar = EEPROM.read(address13);
   
}//end setup

Fbaptista · July 4, 2019, 6:49pm

void loop()
{


 
  
   nexLoop(nex_listen_list);  // Check for any touch event //para botões manuais



  DS1302();  //função de comparação  de timer abaixo

     


   double Vout, Rth, temperature, adc_value; 

  adc_value = analogRead(A0);
  Vout = (adc_value * VCC) / adc_resolution;
  Rth = (VCC * R2 / Vout) - R2;

/*  Steinhart-Hart Thermistor Equation:
 *  Temperature in Kelvin = 1 / (A + B[ln(R)] + C[ln(R)]^3)
 *  where A = 0.001129148, B = 0.000234125 and C = 8.76741*10^-8  */
  temperature = (1 / (A + (B * log(Rth)) + (C * pow((log(Rth)),3))));   // Temperature in kelvin

  temperature = temperature - 273.15;  // Temperature in degree celsius
int temp1 = temperature;
temp_digit.setValue(temp1);
temperatura = temperature; // para a barra
  
ph_val.setText(txt2);
memset(txt2, 0, sizeof(txt2));
itoa(ph, txt2, 10);

//atribuições de variáveis     
//temperatura
d_val.setValue(settemp);


//programador
//feed
horafeedligar_val.setValue(horafeedligar);
minutofeedligar_val.setValue(minutofeedligar);

//bomba
horabombaligar_val.setValue(horabombaligar);
minutobombaligar_val.setValue(minutobombaligar);
horabombadesligar_val.setValue(horabombadesligar);
minutobombadesligar_val.setValue(minutobombadesligar);
//iluminação
horailuminacaoligar_val.setValue(horailuminacaoligar);
minutoiluminacaoligar_val.setValue(minutoiluminacaoligar);
horailuminacaodesligar_val.setValue(horailuminacaodesligar);
minutoiluminacaodesligar_val.setValue(minutoiluminacaodesligar);
  
j0.setValue(bar_value); // informação para barra animada da temperatura
j1.setValue(bar_ph);   // informação para barra animada do ph
bar_value = map(temperatura, 0, 40, 0, 100);
bar_ph = map(ph, 0, 14, 0, 100);
 
  // função de termostato

  
 { if (temperatura <=settemp)
digitalWrite(2, HIGH);
else 
digitalWrite(2, LOW);
   }



//  Envia o texto para o objeto do Nextion

 buttonState = digitalRead(buttonPin);
 if (buttonState == HIGH) {
   
Serial.print("t6.txt=");  // This is sent to the nextion display to set what object name (before the dot) and what atribute (after the dot) are you going to change.
Serial.print("\"");  // Since we are sending text, and not a number, we need to send double quote before and after the actual text.
Serial.print("nivel de agua ok");  // This is the text you want to send to that object and atribute mentioned before.
Serial.print("\"");  // Since we are sending text, and not a number, we need to send double quote before and after the actual text.
Serial.write(0xff);  // We always have to send this three lines after each command sent to the nextion display.
Serial.write(0xff);
Serial.write(0xff);
} 
else 
 {
Serial.print("t6.txt="); 
Serial.print("\""); 
Serial.print("nivel de agua baixo");  
Serial.print("\"");  
Serial.write(0xff); 
Serial.write(0xff);
Serial.write(0xff);}
    
Serial.print("dia.val=");
Serial.print(myRTC.dayofmonth);
Serial.write(0xff);  
Serial.write(0xff);
Serial.write(0xff);

Serial.print("mes.val=");
Serial.print(myRTC.month);
Serial.write(0xff);  
Serial.write(0xff);
Serial.write(0xff);

Serial.print("ano.val=");
Serial.print(myRTC.year);
Serial.write(0xff);  
Serial.write(0xff);
Serial.write(0xff);
    

Serial.print("hour.val=");
Serial.print(myRTC.hours);
Serial.write(0xff);
Serial.write(0xff);
Serial.write(0xff);
    
Serial.print("minute.val=");
Serial.print(myRTC.minutes);
Serial.write(0xff);  
Serial.write(0xff);
Serial.write(0xff);

Serial.print("second.val=");
Serial.print(myRTC.seconds);
Serial.write(0xff);
Serial.write(0xff);
Serial.write(0xff);


 //========================================================================================================================================================================================
 //   Sensor de Ph
    
  for(int i=0;i<10;i++)       //Get 10 sample value from the sensor for smooth the value
  { 
    buf[i]=analogRead(SensorPin);
    delay(10);
  }
  for(int i=0;i<9;i++)        //sort the analog from small to large
  {
    for(int j=i+1;j<10;j++)
    {
      if(buf[i]>buf[j])
      {
        temp=buf[i];
        buf[i]=buf[j];
        buf[j]=temp;
      }
    }
  }
  avgValue=0;
  for(int i=2;i<8;i++)                      //take the average value of 6 center sample
    avgValue+=buf[i];
  float phValue=(float)avgValue*5.0/1024/6; //convert the analog into millivolt
  phValue=3.5*phValue;                      //convert the millivolt into pH value
  delay(50);
  ph = phValue;
}

//=================================================================================================================================
// funções automáticas- comparação dos valores de set com o rtc

void DS1302()
{
  myRTC.updateTime();         //faz leitura do DS1302

int horas = myRTC.hours;
int minutos = myRTC.minutes;
int segundos = myRTC.seconds;
//auto feed 
if (horas==horafeedligar && minutos==minutofeedligar && segundos ==1){
digitalWrite(3, HIGH);}
delay (1000);
digitalWrite(3, LOW);
//auto bomba
if (horas==horabombaligar && minutos==minutobombaligar && segundos ==1){
digitalWrite(5, HIGH);}
if (horas==horabombadesligar && minutos==minutobombadesligar && segundos ==1){
digitalWrite(5, LOW);}
//auto iluminação
if (horas==horailuminacaoligar && minutos==minutoiluminacaoligar && segundos ==1){
digitalWrite(4, HIGH);}
if (horas==horailuminacaodesligar && minutos==minutoiluminacaodesligar && segundos ==1){
digitalWrite(4, LOW);}



} //end DS1302

PerryBebbington · July 4, 2019, 8:46pm

Hello Fbaptista,
I am replying because you sent me a PM. Unfortunately, as I state in my tutorial, I do not know or use the Nextion libraries, my methods and the sample code I present in the tutorial don't use the libraries and I cannot help you with them, sorry.

++Karma for using code tags properly from your first post.

Topic		Replies	Views
nextion lcd problem Programming	5	767	May 5, 2021
Problems using Nextion display General Guidance	25	3214	April 15, 2022
Need help with code for mega board and nextion Programming	27	2753	May 5, 2021
Nextion get value (Arduino Mega) Programming	3	4827	May 6, 2021
Nextion Display Problem with attachPop Programming	2	1282	May 5, 2021

Nextion problem with arduino

Related topics