IF non funziona..ci risiamo..Nextion funziona tutto tranne l'if..

Bè scusa la risp ma pure io è un po' che faccio arduino anche più di un anno.. l'ho letto e riletto parecchie volte e ricopiato ma se scrivo qui cmq una verifica prima l'ho fatta.. non scrivo tanto per stressare la gente, anche se magari un errore mi possa essere capitato ma non lo trovo.Sinceramente e scusa se lo dico ma se hai già abbastanza dei tuoi errori cosa scrivi a fare?(senza offesa).

Scusa non volevo essere offensivo

ti consigliavo solo di provare a riscriverlo(magari con Variabili Nominate in Italiano)...e verificarle una alla volta....io molti errori li ho risolti cosi facendo.

per favore mi dici esattamente come hai collegato il nexion e l'arduino

a parte il dht che è sul pin 2?
e l'alimentazione?

Certo,
schermo tx -> rx arduino
schermo rx -> tx arduino
poi 5v e gnd

per funzionare funziona la temperatura ora, però mi manda il tilt il valore dello schermo non mi fa piu i passaggi progerssivi quando premo più o meno

lo sospettavo :slight_smile:

allora, se è collegato così non puoi fare i vari serial.print.... perchè appunto la seriale (pin 0 e 1) sono occupati. è che stai cercando di fare le cose seguendo 2 vie che da quello che ho capito non sono compatibili tra loro. Tu attualmente stai cercando di usare il nexion come un comune lcd attaccato ad arduino, vorresti usare il loop per eseguire delle funzioni ma col nexion non puoi, le funzioni devono stare nelle varie callback e tutti i risultati li devi avere esclusivamente a video quindi se segui esattamente il progetto che ti avevo lincato per lo slide vedi come viene usato anche il dht per avere la temperatura... altrimenti non ho idea di come fare.

Non ci sono incompatibilità note tra la libreria DHT e i dispaly Nextion, i problemi qui credo siano altri ovvero:

  1. Non puoi usare la seriale sia a scopo di debug sia per il collegamento con il display (come già detto da Patrick_M)
  2. Il fatto che ti "salta" i passi intermedi deriva dal delay inserito tra le letture, il ritardo tra le letture del DHT è indispensabile
    Propondo possibili soluzione ai punti indicati come "problematici":
  3. Se usi Arduino Uno o similare collega il display utilizzando la libreria SoftwareSerial, per come usarla ti rimando agli esempi nell'IDE, al sito e ai mille mila tutorial su internet. Se invece usi una mega usa la seriale hardware 1 (o la due o quella che ti torna meglio delle 3 disponibili oltre la zero che è collegata a TX e RX che usi per il debug)
  4. Tra le letture DEVONO intercorrere almeno i millisecondi riportati nel datasheet del componente che nel caso del DHT22 credo siano non meno di 360 ms ma credo che anche leggendo la temperatura ogni dieci secondi si possa considerare sufficiente, quindi elimina il delay e lavora tramite la millis per leggere la temperatura ogni N secondi.
    Visto che millis ti costringe a rivedere l'approccio per capire le basi con cui si usa millis() consiglio prima la lettura di QUESTO post esplicativo, dopo di che lo studio di come si usa la funzione millis(), prima QUI, poi QUI e QUI e QUI e tutti gli articoli che sono in QUESTA pagina ... alla fine il tutto dovrebbe essere più chiaro :slight_smile:
    Lascia che ad ogni ciclo di loop venga eseguito il polling del nextion (nexLoop) e il test se attivare/disattivare il relé, tutto il resto dentro l'if del millis().
    Ti dico già che il test di attivazione/disattivazione del relé così com'é è problematico, cerca isteresi sul forum e trovi la soluzione anche a quello.
    Ti indico anche perché ho proposto 10 secondi tra una lettura e la successiva, credo tu stia realizzando un termostato o un cronotermostato per il riscaldamento di ambienti o similare (terrario,acquario,cella lievitazione), considera che quando attivi o disattivi un elemento riscaldante hai una certa latenza ovvero da quando l'attivi a che effettivamente inizia a scaldare passa del tempo così come quando lo disattivi prima che la temperatura inizi a scendere inizialmente continuerà a salire poi si stabilizza e poi inizia a scendere. Detto questo leggere ogni secondo la temperatura (con un DHT poi che ha una latenza enorme) è innutile a fini pratici e normalmente si consiglia sempre di effettuare una media tra N letture per scongiurare rimbalzi e/o errori di lettura quindi se leggi ogni 10 secondi e fai la media su 6 letture aggiornerai il display e il valore con cui decidere se attivare/disattivare il relé ogni minuto che credo sia più che sufficiente.
    Io stesso sono alla fase finale della realizzazione di un cronotermostato con display Nextion e leggo la temperatura ogni minuto o faccio la media su 12 letture scartando prima della media il valore più alto e il valore più basso letto aggiornando quindi la temperatura di controllo ogni dodici minuti che ritendo più che soddisfacente per il mio scopo. Contrariamente a te uso un'altra sonda di temperatura e non suo la libreria per comunicare con il display quindi per la parte di libreria Nextion non posso esserti d'aiuto granché

Eccomi dopo ore e studi fino a notte tarda ecco il risultato :

[code]
#include "Nextion.h"
#include "DHT.h"

#define DHTPIN 2

#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);

const int led =8;
const int led2 =5;


int temp;
int umid;




byte imptemp;
//aggiuntivo
byte impumid;
byte impore;
unsigned long ora;



void n0PopCallback(void *ptr);
void b0PopCallback(void *ptr);
void b1PopCallback(void *ptr);
void b2PopCallback(void *ptr);
void b3PopCallback(void *ptr);
//aggiuntivo
void b4PopCallback(void *ptr);
void b5PopCallback(void *ptr);
void b6PopCallback(void *ptr);
void b7PopCallback(void *ptr);
void b8PopCallback(void *ptr);
void b9PopCallback(void *ptr);
void n1PopCallback(void *ptr);
void n2PopCallback(void *ptr);









NexNumber n0 = NexNumber(0, 3, "n0");
NexButton b0 = NexButton(0, 1, "b0");
NexButton b1 = NexButton(0, 2, "b1");
NexButton b2 = NexButton(0, 6, "b2");
NexButton b3 = NexButton(0, 7, "b3");
//aggiuntivo
NexNumber n1 = NexNumber(0, 8, "n1");
NexNumber n2 = NexNumber(0, 14, "n2");
NexButton b4 = NexButton(0, 10, "b4");
NexButton b5 = NexButton(0, 11, "b5");
NexButton b6 = NexButton(0, 12, "b6");
NexButton b7 = NexButton(0, 13, "b7");
NexButton b8 = NexButton(0, 16, "b8");
NexButton b9 = NexButton(0, 17, "b9");
NexText txt_gradi = NexText(1, 11, "t5");
NexText txt_umid  = NexText(1, 12, "t6");


char buffer[100] = {0};

/*
 * Register object n0, b0, b1, to the touch event list.  
 */
NexTouch *nex_listen_list[] = 
{
    &n0,
    &b0,
    &b1,
    &b2,
    &b3,
    //aggiuntivi
    &n1,
    &n2,
    &b4,
    &b5,
    &b6,
    &b7,
    &b8,
    &b9,
    NULL
};

/*
 * number component pop callback function. 
 */
void n0PopCallback(void *ptr)
{
    n0.setValue(0);
}
void n1PopCallback(void *ptr)
{
    n1.setValue(0);
}
void n2PopCallback(void *ptr)
{
    n2.setValue(0);
}

/*
 * Button0 component pop callback function.
 * In this example,the value of the number component will plus one every time when button0 is released.
 */
void b0PopCallback(void *ptr)
{
    n0.getValue(imptemp);
    
    imptemp ++;
    
    n0.setValue(imptemp);
 }

void b1PopCallback(void *ptr)
{    
    n0.getValue(imptemp);
    
    imptemp --;
    
    n0.setValue(imptemp);
   }

void b2PopCallback(void *ptr)
{    
    n0.getValue(imptemp);
    
    imptemp++;
    imptemp++;
    imptemp++;
    imptemp++;
    imptemp++;
    imptemp++;
    imptemp++;
    imptemp++;
    imptemp++;
    imptemp++;
    
    n0.setValue(imptemp);
   }

void b3PopCallback(void *ptr)
{    
    n0.getValue(imptemp);
    
    imptemp --;
    imptemp --;
    imptemp --;
    imptemp --;
    imptemp --;
    imptemp --;
    imptemp --;
    imptemp --;
    imptemp --;
    imptemp --;
    
    n0.setValue(imptemp);
   }

void b4PopCallback(void *ptr)
{    
    n1.getValue(impumid);
    
    impumid ++;
    
    n1.setValue(impumid);
   }

void b6PopCallback(void *ptr)
{    
    n1.getValue(impumid);
    
    impumid++;
    impumid++;
    impumid++;
    impumid++;
    impumid++;
    impumid++;
    impumid++;
    impumid++;
    impumid++;
    impumid++;
    
    n1.setValue(impumid);
   }

void b5PopCallback(void *ptr)
{    
    n1.getValue(impumid);
    
    impumid --;
    
    n1.setValue(impumid);
   }

void b7PopCallback(void *ptr)
{    
    n1.getValue(impumid);
    
    impumid --;
    impumid --;
    impumid --;
    impumid --;
    impumid --;
    impumid --;
    impumid --;
    impumid --;
    impumid --;
    impumid --;
    
    n1.setValue(impumid);
   }

void b8PopCallback(void *ptr)
    {    
    n2.getValue(impore);
    
    impore ++;
    
    n2.setValue(impore);
   }

void b9PopCallback(void *ptr)
    {    
    n2.getValue(impore);
    
    impore --;
    
    n2.setValue(impore);
   }




   

void setup(void)
{
    /* Set the baudrate which is for debug and communicate with Nextion screen. */
    nexInit();
    dht.begin();
    Serial.begin(9600);
    pinMode(led,OUTPUT);
    pinMode(led2,OUTPUT);
    pinMode(trig,OUTPUT);
    pinMode(echo,INPUT);
    
    
    n0.attachPop(n0PopCallback);
    n1.attachPop(n1PopCallback);
    n2.attachPop(n2PopCallback);
    b0.attachPop(b0PopCallback);
    b1.attachPop(b1PopCallback);
    b2.attachPop(b2PopCallback);
    b3.attachPop(b3PopCallback);
    b4.attachPop(b4PopCallback);
    b5.attachPop(b5PopCallback);
    b6.attachPop(b6PopCallback);
    b7.attachPop(b7PopCallback);
    b8.attachPop(b8PopCallback);
    b9.attachPop(b9PopCallback);
    
}

void loop()
{
    nexLoop(nex_listen_list);
    Serial.println(dht.readTemperature());
    Serial.println(dht.readHumidity());


    if(dht.readTemperature() >= imptemp)
    {
      digitalWrite(led,HIGH);
    }
    else
    {
      digitalWrite(led,LOW);
    }

    if(dht.readHumidity() >= impumid)
    {
      digitalWrite(led2,HIGH);
    }
    else
    {
      digitalWrite(led2,LOW);
    }   
}

[/code]

Ora funzionare funziona imposto la temperatura e a tal valore accendo il led(poi futuro relè), il problema ora è un altro ! ! quando nel loop cerco di aggiungere un sensore ad ultrasuoni o altri sensori mi blocca l'inserimento dei dati nello schermo e non capisco perché.

Grazie mille per tutti i consigli