Codice DS3231RTC

Ciao a tutti, son tornato con i miei problemi :stuck_out_tongue: Ho spulciato tutto il giorno in cerca di una libreria adatta per far funzionare il mio sensore DS3231RTC, credo di aver trovato quello che cercavo, riesco ad installarlo senza problemi, da progetto originale ho cambiato solo il tempo di refresh che aggiornava il tempo ogni 10sec l’ho portato ad un secondo, dallo schermo seriale funziona benissimo, allora ho cominciato a modificare il codice aggiungendo lo schermo lcd_I2C dove riesco a mostrare l’ora, la data e la temperatura ma l’unica cosa che si aggiorna ad ogni secondo è la temperatura, l’orario rimane fisso finchè nn resetto la scheda o lo ricompilo, metto di seguito i codici prima e dopo la mia modifica perché vorrei capire anche se c’è una lista di comandi che fanno parte di quella scheda per poter gestire ad orari prestabiliti dei relè

codice originale:

// CONNECTIONS:
// DS3231 SDA --> SDA
// DS3231 SCL --> SCL
// DS3231 VCC --> 3.3v or 5v
// DS3231 GND --> GND

#if defined(ESP8266)
#include <pgmspace.h>
#else
#include <avr/pgmspace.h>
#endif
#include <Wire.h>  // must be incuded here so that Arduino library object file references work
#include <RtcDS3231.h>

RtcDS3231 Rtc;

void setup () 
{
    Serial.begin(57600);

    Serial.print("compiled: ");
    Serial.print(__DATE__);
    Serial.println(__TIME__);

    //--------RTC SETUP ------------
    Rtc.Begin();

    // if you are using ESP-01 then uncomment the line below to reset the pins to
    // the available pins for SDA, SCL
    // Wire.begin(0, 2); // due to limited pins, use pin 0 and 2 for SDA, SCL

    RtcDateTime compiled = RtcDateTime(__DATE__, __TIME__);
    printDateTime(compiled);
    Serial.println();

    if (!Rtc.IsDateTimeValid()) 
    {
        // Common Cuases:
        //    1) first time you ran and the device wasn't running yet
        //    2) the battery on the device is low or even missing

        Serial.println("RTC lost confidence in the DateTime!");

        // following line sets the RTC to the date & time this sketch was compiled
        // it will also reset the valid flag internally unless the Rtc device is
        // having an issue

        Rtc.SetDateTime(compiled);
    }

    if (!Rtc.GetIsRunning())
    {
        Serial.println("RTC was not actively running, starting now");
        Rtc.SetIsRunning(true);
    }

    RtcDateTime now = Rtc.GetDateTime();
    if (now < compiled) 
    {
        Serial.println("RTC is older than compile time!  (Updating DateTime)");
        Rtc.SetDateTime(compiled);
    }
    else if (now > compiled) 
    {
        Serial.println("RTC is newer than compile time. (this is expected)");
    }
    else if (now == compiled) 
    {
        Serial.println("RTC is the same as compile time! (not expected but all is fine)");
    }

    // never assume the Rtc was last configured by you, so
    // just clear them to your needed state
    Rtc.Enable32kHzPin(false);
    Rtc.SetSquareWavePin(DS3231SquareWavePin_ModeNone); 
}

void loop () 
{
    if (!Rtc.IsDateTimeValid()) 
    {
        // Common Cuases:
        //    1) the battery on the device is low or even missing and the power line was disconnected
        Serial.println("RTC lost confidence in the DateTime!");
    }

    RtcDateTime now = Rtc.GetDateTime();
    printDateTime(now);
    Serial.println();

    RtcTemperature temp = Rtc.GetTemperature();
    Serial.print(temp.AsFloat());
    Serial.println("C");

    delay(1000); // one seconds
}

#define countof(a) (sizeof(a) / sizeof(a[0]))

void printDateTime(const RtcDateTime& dt)
{
    char datestring[20];

    snprintf_P(datestring, 
            countof(datestring),
            PSTR("%02u/%02u/%04u %02u:%02u:%02u"),
            dt.Day(),
            dt.Month(),
            dt.Year(),
            dt.Hour(),
            dt.Minute(),
            dt.Second() );
    Serial.print(datestring);
}

Ho dovuto scrivere in 2 volte, è normale che viene fuori un errore di 9000 caratteri?

In mezzo c’è anche parte di codice che sto ancora sistemando per un sensore di temperatura da mettere dentro il terrario con la sua visualizzazione con simboli di byte, codice mod. con aggiunta lcd_I2C:

// CONNECTIONS:
// DS3231 SDA --> SDA
// DS3231 SCL --> SCL
// DS3231 VCC --> 3.3v or 5v
// DS3231 GND --> GND

#if defined(ESP8266)
#include <pgmspace.h>
#else
#include <avr/pgmspace.h>
#endif
#include <Wire.h>  // must be incuded here so that Arduino library object file references work
#include <RtcDS3231.h>
#include "DHT.h"
#include <LiquidCrystal_I2C.h>

//Librerie define
#define DHTPIN 8
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);

LiquidCrystal_I2C lcd(0x27,16,2); //set indirizzo lcd su rete I2C

//Mostra simboli in byte 
byte termometro[8] = //icona per termometro sotto i 15¬į
{
     B00100,
     B01010,
     B01010,
     B01010,
     B01010,
     B11111,
     B11111,
     B01110
};

byte termometro1[8] = //icona per termometro sopra i 15¬į
 {
     B00100,
     B01010,
     B01010,
     B01110,
     B01110,
     B11111,
     B11111,
     B01110
 };
 
byte termometro2[8] = //icona per termometro sopra i 25¬į
 {
     B00100,
     B01010,
     B01110,
     B01110,
     B01110,
     B11111,
     B11111,
     B01110
 };
 
 byte termometro3[8] = //icona per termometro sopra i 30¬į
 {
     B00100,
     B01110,
     B01110,
     B01110,
     B01110,
     B11111,
     B11111,
     B01110
 };

byte umidita[8] = //icona per umidità
 {
     B00100,
     B00100,
     B01010,
     B01010,
     B10001,
     B10001,
     B10001,
     B01110,
 };

RtcDS3231 Rtc;

void setup () 
{
    Serial.begin(57600);

    Serial.print("compiled: ");
    Serial.print(__DATE__);
    Serial.println(__TIME__);
 
 lcd.init();
    lcd.backlight();
    lcd.print(__TIME__);
   lcd.setCursor(0, 1); 
    lcd.print(__DATE__);
    
 
 dht.begin();
   lcd.createChar(1, termometro);
   lcd.createChar(2, termometro1);
   lcd.createChar(3, termometro2);
   lcd.createChar(4, termometro3);
   lcd.createChar(5, umidita); 
        
    //--------RTC SETUP ------------
    Rtc.Begin();

    // if you are using ESP-01 then uncomment the line below to reset the pins to
    // the available pins for SDA, SCL
    // Wire.begin(0, 2); // due to limited pins, use pin 0 and 2 for SDA, SCL

    RtcDateTime compiled = RtcDateTime(__DATE__, __TIME__);
    printDateTime(compiled);
    Serial.println();
       
    if (!Rtc.IsDateTimeValid()) 
    {
        // Common Cuases:
        //    1) first time you ran and the device wasn't running yet
        //    2) the battery on the device is low or even missing

        Serial.println("RTC lost confidence in the DateTime!");

        // following line sets the RTC to the date & time this sketch was compiled
        // it will also reset the valid flag internally unless the Rtc device is
        // having an issue

        Rtc.SetDateTime(compiled);
    }

    if (!Rtc.GetIsRunning())
    {
        Serial.println("RTC was not actively running, starting now");
        Rtc.SetIsRunning(true);
    }

    RtcDateTime now = Rtc.GetDateTime();
    if (now < compiled) 
    {
        Serial.println("RTC is older than compile time!  (Updating DateTime)");
        Rtc.SetDateTime(compiled);
    }
    else if (now > compiled) 
    {
        Serial.println("RTC is newer than compile time. (this is expected)");
    }
    else if (now == compiled) 
    {
        Serial.println("RTC is the same as compile time! (not expected but all is fine)");
    }

    // never assume the Rtc was last configured by you, so
    // just clear them to your needed state
    Rtc.Enable32kHzPin(false);
    Rtc.SetSquareWavePin(DS3231SquareWavePin_ModeNone); 
}

void loop () 
{
    if (!Rtc.IsDateTimeValid()) 
    {
        // Common Cuases:
        //    1) the battery on the device is low or even missing and the power line was disconnected
        Serial.println("RTC lost confidence in the DateTime!");
    }

    RtcDateTime now = Rtc.GetDateTime();
    printDateTime(now);
    Serial.println();
    //lcd.print();
  
 //vista da seriale della temperatura con aggiornamento di 1 sec  
  RtcTemperature temp = Rtc.GetTemperature();
    Serial.print(temp.AsFloat());
    Serial.println("C");
    
 //vista LCD della temperatura con aggiornamento di 1 sec   
  lcd.setCursor(9, 0);
    //lcd.print((char) 2);
     lcd.print(temp.AsFloat());
      lcd.print((char)223);
    delay(1000); // one seconds
}

#define countof(a) (sizeof(a) / sizeof(a[0]))

void printDateTime(const RtcDateTime& dt)
{
    char datestring[20];

    snprintf_P(datestring, 
            countof(datestring),
            PSTR("%02u/%02u/%04u %02u:%02u:%02u"),
            dt.Day(),
            dt.Month(),
            dt.Year(),
            dt.Hour(),
            dt.Minute(),
            dt.Second() );
    Serial.print(datestring);
    lcd.print(datestring);  
}

spero di essere stato il pi√Ļ chiaro possibile, nel caso provo di spiegarmi meglio

Scusa ma nel loop io non vedo nessuna riga che fa scrivere l'ora sul display ogni secondo... Poi non so se quella libreria dell'RTC ha bisogno di tutta quella roba per fare funzionare il "modulo", però basta gestire la sincronizzazione nel setup (una volta che hai impostato l'ora giusta) e poi usare la libreria time e chiamare hour() minute() etc quando le vuoi scrivere, o per altro.

P.S. riguardo all'errore, se non lo posti non possiamo sapere cosa possa essere.

Ciao, veramente nn lo so neanch’io se ci vuole tutta quella roba, ho trovato lo sketch così compilato e l’ho avviato l’unico che nn mi ha dato problemi, ho provato a cercare anche i soli comandi per capire come avviarlo ma nn ho trovato niente :confused:

nel loop c’è questa parte di codice:

RtcDateTime now = Rtc.GetDateTime();
printDateTime(now);
Serial.println();
//lcd.print();

è questo che fa aggiornare l’orario? avevo messo lcd.print senza le due // ma mi genera errore,

molte ricerche su google mi rimandano quasi sempre a questa libreria, GitHub - JChristensen/DS3232RTC: Arduino Library for Maxim Integrated DS3232 and DS3231 Real-Time Clocks

/*
 * TimeRTC.pde
 * Example code illustrating Time library with Real Time Clock.
 * This example is identical to the example provided with the Time Library,
 * only the #include statement has been changed to include the DS3232RTC library.
 */

#include <DS3232RTC.h>    //http://github.com/JChristensen/DS3232RTC
#include <Time.h>         //http://www.arduino.cc/playground/Code/Time  
#include <Wire.h>         //http://arduino.cc/en/Reference/Wire (included with Arduino IDE)

void setup(void)
{
    Serial.begin(9600);
    setSyncProvider(RTC.get);   // the function to get the time from the RTC
    if(timeStatus() != timeSet) 
        Serial.println("Unable to sync with the RTC");
    else
        Serial.println("RTC has set the system time");      
}

void loop(void)
{
    digitalClockDisplay();  
    delay(1000);
}

void digitalClockDisplay(void)
{
    // digital clock display of the time
    Serial.print(hour());
    printDigits(minute());
    printDigits(second());
    Serial.print(' ');
    Serial.print(day());
    Serial.print(' ');
    Serial.print(month());
    Serial.print(' ');
    Serial.print(year()); 
    Serial.println(); 
}

void printDigits(int digits)
{
    // utility function for digital clock display: prints preceding colon and leading 0
    Serial.print(':');
    if(digits < 10)
        Serial.print('0');
    Serial.print(digits);
}

questo codice qui che fa parte del codice del link sopra mi genera questo errore sul Time.h

Non ci vuole tutta quella roba :slight_smile:

Quella parte che citi non fa aggiornare l‚Äôorario, semplicemente ‚Äúrileva‚ÄĚ l‚Äôorario, ma non lo scrivi da nessuna parte sul display, ecco perch√© non lo visualizzi, lo scrivi solo nel setup, ecco perch√© lo visualizzi solo una volta. Quell‚Äôerrore che ti genera, almeno per me √® strano, va in conflitto con qualcosa nel ‚Äėcore‚Äô di Arduino, puoi leggerlo tu stesso il percorso scritto nell‚Äôerrore da te postato.

Quella libreria che hai trovato per il DS3231 è quella che uso io e puoi notare che non serve molto per farlo funzionare. L’errore te lo genera perché ti manca la libreria Time.h
Installala e vedrai che quel codice, ovvero questo:

/*
 * TimeRTC.pde
 * Example code illustrating Time library with Real Time Clock.
 * This example is identical to the example provided with the Time Library,
 * only the #include statement has been changed to include the DS3232RTC library.
 */

#include <DS3232RTC.h>    //http://github.com/JChristensen/DS3232RTC
#include <Time.h>         //http://www.arduino.cc/playground/Code/Time  
#include <Wire.h>         //http://arduino.cc/en/Reference/Wire (included with Arduino IDE)

void setup(void)
{
    Serial.begin(9600);
    setSyncProvider(RTC.get);   // the function to get the time from the RTC
    if(timeStatus() != timeSet) 
        Serial.println("Unable to sync with the RTC");
    else
        Serial.println("RTC has set the system time");      
}

void loop(void)
{
    digitalClockDisplay();  
    delay(1000);
}

void digitalClockDisplay(void)
{
    // digital clock display of the time
    Serial.print(hour());
    printDigits(minute());
    printDigits(second());
    Serial.print(' ');
    Serial.print(day());
    Serial.print(' ');
    Serial.print(month());
    Serial.print(' ');
    Serial.print(year()); 
    Serial.println(); 
}

void printDigits(int digits)
{
    // utility function for digital clock display: prints preceding colon and leading 0
    Serial.print(':');
    if(digits < 10)
        Serial.print('0');
    Serial.print(digits);
}

non ti dar√† pi√Ļ errore. :wink:
Una volta fatto questo ti do una mano su come fare semplicemente a scrivere l’ora sul display senza tante parole.
Ciao!

P.S. Ho notato che in realt√† quell‚Äôerrore non √® per colpa di una libreria mancante (anche se ti consiglio di installarla comunque la time aggiornata), ma √® stato anche aperto un ‚Äėissue‚Äô a riguardo.
Praticamente vai nella cartella della libreria del DS3231 e apri il file DS3232RTC.h
Una volta aperto cambia questo

#include <Time.h>

con questo

#include <TimeLib.h>

Ora veramente non dovrebbe darti nessun errore.

finalmente :D ma una libreria completa in giro per la rete nn la si poteva rilasciare >:( grazie per il tuo aiuto, sto gi√† provando ad apportare qualche modifica se mi vuoi rendere la vita pi√Ļ semplice sono ben contento di sapere come fare :P oltre a quello il mio progetto dovrebbe abilitare a determinati orari e temperature delle uscite, ma intanto inizio con gli orari

EDIT: ho visualizzato nella prima riga l'orario, nella seconda la data ma dopo la data gli ultimi caratteri mostrano cmq una parte dell'orario, devo capire come eliminarli

Tu prova fino allo sfinimento, poi fammi domande :) Comunque, dici sul display? Se hai problemi di visualizzazione sul display, forse ti manca di mettere nel tuo codice lcd.clear() Ciao!

ho aggiunto lcd.clear() alla parte di codice sotto il serial.print perch√© usava in comune il comando printdigits() per i minuti e i secondi, fatto quello la parte in pi√Ļ che nn centrava niente si √® cancellata mostrando la data e l‚Äôora, per fare un po‚Äô di pulizia ho eliminato tutto quello che riguarda i comandi serial‚Ķ

Ma ora sono in alto mare, ho provato a seguire qualche progetto trovato qua e là ma alcuni comandi nn sono compatibili con la mia libreria, nn so come fare per abilitare delle uscite ad un determinato orario, ho dichiarato delle int per l’ora e i minuti, nel loop ho messo questo:

  if ((!active_luce_uvb) && (RTC_HOURS == h_avvio_inv) && (RTC_MINUTES >= m_avvio_inv)) {
      digitalWrite(luce_uvb, HIGH );
      lcd.noBacklight();
    }
  if ((active_luce_uvb) && (RTC_HOURS == h_fine_inv) && (RTC_MINUTES >= m_fine_inv)) {
      digitalWrite(luce_uvb, LOW);
      lcd.backlight();
      active_luce_uvb = false;
 }

ho ricavato RTC_HOURS e MINUTES dalla libreria, pensavo che con quei comandi (perché mettendo solo hour o minute mi da errore) di riuscire a ricavare l’orario dell’rtc e in base al numero impostato negli int (h_avvio_inv, m_avvio_inv, h_fine_inv e m_fine_inv) di poter avviare la lampadina in un determinato orario.

L’errore che mi genera mettendo solo hour o minute è:
invalid operands of types ‚Äė‚Äô and ‚Äėint‚Äô to binary ‚Äėoperator==‚Äô

Prova hour() e minute(), con le parentesi. Le chiamate di funzione ne hanno sempre bisogno.

Esatto, devi usare le parentesi, se no è normale che ti dà errore. Un po' come usare millis senza le parentesi.

avevo scopiazzato quella parte da altri progetti ma nessuno li usava così io da nubbio nn ci avevo neanche pensato :P cmq ho risolto anche altri piccoli problemi dopo il vostro suggerimento, a grandi linee dovrei aver capito come scrivere le altre righe di codice, nel caso mi faccio risentire ;) grazie per l'aiuto

Sì, posta il codice dopo, almeno ci diamo un'occhiata ;)

Sono gi√† in fase di modifica, necessito di aiuto per far lampeggiare un led e pensavo di usare i millis piuttosto che il delay cos√¨ il programma continua a ciclare e uguale per lo schermo che adesso si accende in determinante condizioni e si spegne solo se raggiunge una temperatura, vorrei che stesse acceso per tot secondi poi si spegne. Metto il codice cos√¨ se c‚Äô√® qualche cosa da cambiare per renderlo pi√Ļ fluido me lo dite :wink: (alcune parti sono sotto commento perch√© sto facendo delle prove)

#include <DS3232RTC.h>         // libreria controllo RTC http://github.com/JChristensen/DS3232RTC
#include <Time.h>              //http://www.arduino.cc/playground/Code/Time  
#include <Wire.h>              // libreria controllo I2C http://arduino.cc/en/Reference/Wire (included with Arduino IDE)
#include <LiquidCrystal_I2C.h> // vista dati su LCD 
#include "DHT.h"               // libreria controllo sensore 
                               // temperatura - umidità nel 
                               // terrario*/ 

/***********************************************************/
//Librerie define

#define DHTPIN 7                  // pin ingresso sensore
                                  // temperatura 
#define DHTTYPE DHT11             // definizione del tipo      
                                  // di sensore

/***********************************************************/
DHT dht(DHTPIN, DHTTYPE);         // inizializza il sensore per
                                  // funzionare a 16Mhz

LiquidCrystal_I2C lcd(0x27,16,2); //set indirizzo lcd su rete I2C

//Mostra simboli in byte
//Icona per termometro a 20¬į
byte termometro[8] = 
{
     B00100,
     B01010,
     B01010,
     B01010,
     B01010,
     B11011,
     B10001,
     B01110,
};

//Icona per termometro tra i 22¬į e 25¬į
byte termometro1[8] = 
 {
     B00100,
     B01010,
     B01010,
     B01110,
     B01110,
     B11111,
     B11111,
     B01110,
 };

//Icona per termometro tra i 25¬į e 30¬į
byte termometro2[8] = 
 {
     B00100,
     B01010,
     B01110,
     B01110,
     B01110,
     B11111,
     B11111,
     B01110,
 };
 
 //Icona per termometro sopra i 30¬į
 byte termometro3[8] = 
 {
     B00100,
     B01110,
     B01110,
     B01110,
     B01110,
     B11111,
     B11111,
     B01110,
 };

//Icona per umidità luogo secco
byte umidita[8] = 
 {
     B00100,
     B00100,
     B01010,
     B01010,
     B10001,
     B10001,
     B10001,
     B01110,
 };

//Icona per umidità luogo umido
byte umidita1[8] = 
 {
     B00100,
     B00100,
     B01110,
     B01110,
     B11111,
     B11111,
     B11111,
     B01110,
 };

//rebecca 
byte rebecca[8] = 
 {
     B00100,
     B01110,
     B00110,
     B00101,
     B01110,
     B11111,
     B01010,
     B01010,
 }; 
//pc accesso rebecca 
 byte pc[8] = 
 {
     B00000,
     B00011,
     B00011,
     B01111,
     B11111,
     B00111,
     B00111,
     B00111,
 };
 
//Imposta pin int
int cavo = 2;                        //cavo resistenza
int luce_rossa = 3;                  //luce spot rossa
int luce_uvb = 4;                    //luce uvb per calcio
int lampeggio = 5;                   //led avviso umidità bassa

//Imposta ore e minuti inverno
int h_avvio_inv = 9;        //ora accensione luce inverno
int m_avvio_inv = 00;        //minuti accensione luce inverno 
int h_fine_inv = 20;         //ora spegnimento luce inverno 
int m_fine_inv = 00;         //minuti spegnimento luce inverno

//Imposta ore e minuti estate
int h_avvio_est = 9;        //ora accensione luce estate
int m_avvio_est = 00;        //minuti accensione luce estate 
int h_fine_est = 21;         //ora spegnimento luce estate 
int m_fine_est = 00;         //minuti spegnimento luce estate

//Imposta variabili booleane
boolean active_cavo = false;
boolean active_luce_rossa = false;
boolean active_luce_uvb = false;
boolean cavo_int = false;
boolean luce_rossa_int = false;
boolean luce_uvb_int = false;

//Imposta variabili tempo
unsigned long time;
int led_um = 250;
int light_sch = 0;

/**********************************************************/
void setup(void)
{
  Serial.begin(9600);
  setSyncProvider(RTC.get);   // the function to get the time from the RTC
/**********************************************************/
   pinMode (cavo, OUTPUT);
   pinMode (luce_rossa, OUTPUT);
   pinMode (luce_uvb, OUTPUT);
   pinMode (lampeggio, OUTPUT);
   
   digitalWrite(cavo, LOW);
   digitalWrite(luce_rossa, LOW);
   digitalWrite(luce_uvb, LOW);
   digitalWrite(lampeggio, LOW);
   
  Wire.begin();

   lcd.init();
    lcd.noBacklight();
     
  dht.begin();
   lcd.createChar(1, termometro);
   lcd.createChar(2, termometro1);
   lcd.createChar(3, termometro2);
   lcd.createChar(4, termometro3);
   lcd.createChar(5, umidita);
   lcd.createChar(6, umidita1);   
  
/**********************************************************/

  lcd.createChar(7, rebecca);
  lcd.createChar(8, pc);
  
  lcd.setCursor(12, 1);
     lcd.print((char) 7);    
  lcd.setCursor(13, 1);
     lcd.print((char) 8);
   
}
     
/**********************************************************/
void loop(void)
{     
  digitalClockDisplay();
  delay(1000);
  
//avvio e lettura temperatura
  int h = dht.readHumidity();
  int t = dht.readTemperature();
  float f = dht.readTemperature(true);

if (isnan(h) || isnan(t) || isnan(f)) {
  // lcd.clear();
    lcd.setCursor(0, 0);
      lcd.print("Lettura fallita");
    lcd.setCursor(0, 1);
      lcd.print("del sensore DHT");  
    return;
  }
  
  float hi = dht.computeHeatIndex(f, h);

// visualizza temperatura tramite sensore
if (t <= 20) {
    lcd.setCursor(0, 1);
     lcd.print((char) 1);
        lcd.print(t); 
         lcd.print((char)223); 
          lcd.print("C ");
  }
  
  if (t >= 22) {
   lcd.setCursor(0, 1);
     lcd.print((char) 2);
        lcd.print(t); 
         lcd.print((char)223); 
          lcd.print("C ");
    }
   
   if (t >= 25) {
     lcd.setCursor(0, 1);
     lcd.print((char) 3);
        lcd.print(t); 
         lcd.print((char)223); 
          lcd.print("C ");
    }
    
    if (t >= 35) {
      lcd.setCursor(0, 1);
     lcd.print((char) 4);
        lcd.print(t); 
         lcd.print((char)223); 
          lcd.print("C ");
    }
          
// visualizza umidità tramite sensore          
 time=millis();  
   if (h <= 40){ 
    lcd.setCursor(6, 1);      
      lcd.print((char) 5);
         lcd.print(h);
           lcd.print("%");
   /* digitalWrite(5, HIGH);   
       delay(250);
     digitalWrite(5, LOW);
   delay(250);*/               
} 
if ((h <= 40) && (time > led_um)){ 
    digitalWrite(lampeggio, HIGH);
 }   
if ((h <= 40) && (time < led_um)){      
     digitalWrite(lampeggio, LOW);
  } 
   
   if (h >= 42){ 
    lcd.setCursor(6, 1);      
      lcd.print((char) 6);
         lcd.print(h);
           lcd.print("%");     
     digitalWrite(lampeggio, LOW);         
   }
//accensione e spegnimento lampada uvb giornaliera
  if ((!active_luce_uvb) && (hour() == h_avvio_inv) && (minute() == m_avvio_inv)) {
      digitalWrite(luce_uvb, HIGH);
      lcd.backlight();
      active_luce_uvb = true;
    }
  if ((active_luce_uvb) && (hour() == h_fine_inv) && (minute() == m_fine_inv)) {
      digitalWrite(luce_uvb, LOW);
      lcd.noBacklight();
      active_luce_uvb = false;
 }
 
//avvio riscaldamento cavo 
 if ((!active_cavo) && (t <= 22) ) {
      digitalWrite(cavo, HIGH);
      lcd.backlight();    
      active_cavo = true;
    }
  if ((active_cavo) && (t > 25)) {
      digitalWrite(cavo, LOW);
      lcd.noBacklight();
      active_cavo = false;
 }
 
//avvio riscaldamento luce rossa 
 if ((!active_luce_rossa) && (active_luce_uvb = true) && (t <= 20)) {
      digitalWrite(luce_rossa, HIGH);
      lcd.backlight();
     active_luce_rossa = true;
    }
  if ((active_luce_rossa) && (active_luce_uvb = true) && (t > 25)) {
      digitalWrite(luce_rossa, LOW);
      lcd.noBacklight();
     active_luce_rossa = false;
 }
}

/*********************************************************/
void digitalClockDisplay(void)    //mostra data e ora
{  
  lcd.setCursor(0, 0);
    lcd.print(day());
    lcd.print('/');
    lcd.print(month());
    lcd.print('/');
    lcd.print(year());  
  
  lcd.setCursor(11, 0);
    lcd.print(hour());
    printDigits(minute());
   // printDigits(second());      //nascondo i secondi nel display
  
}

/*********************************************************/
void printDigits(int digits)      //aggiorna l'ora       
{
 lcd.print(':');
  if (digits < 10)
    lcd.print('0');
  lcd.print(digits);
}

EDIT:
stavo facendo delle prove, e ho trovato un altro problema, l‚Äôaccensione della lampada rossa nn avviene come immaginavo, cio√® si dovrebbe accendere se la temperatura arriva 20¬į e quando la lampada uvb √® gi√† accesa se no deve rimanere spenta, allora ho fatto queste modifiche:

//avvio riscaldamento luce rossa 
 if ((!active_luce_rossa) && (hour() == h_avvio_inv) && (minute() == m_avvio_inv) && (t <= 20)) {
      digitalWrite(luce_rossa, HIGH);
      lcd.backlight();
     active_luce_rossa = true;
    }
  if ((active_luce_rossa) && (t > 25) || (hour() == h_fine_inv) && (minute() == m_fine_inv)) {
      digitalWrite(luce_rossa, LOW);
      lcd.noBacklight();
     active_luce_rossa = false;
 }

ora si accende solo se l‚Äôorario corrisponde e la temperatura raggiunge i 20¬į ma una volta che si spegne poi in una delle 2 condizioni poi nn si riaccende, ho riscontrato lo stesso problema anche per l‚Äôaccensione della lampada uvb se l‚Äôorario nn corrisponde allora si spegne, mettiamo per ipotesi che vada via la luce un volta che ritorna se √® nell‚Äôorario prestabilito se deve riavviare‚Ķ Nn so come fare :stuck_out_tongue:

Allora per prima una cosa da modificare perch√© diciamo ‚Äúinsensata‚ÄĚ, √® l‚Äôuso di ‚Äėint‚Äô per definire un pin. Come sai int serve per dichiarare una variabile, ma un pin √® una costante, perci√≤ o usi ‚Äėconst int‚Äô oppure la #define come hai fatto per il pin del DHT! Per definire un pin sinceramente un #define va pi√Ļ che bene. Magari ti chiederai perch√©: beh semplicemente non ha senso sprecare 2 byte di memoria con int e comprendere numeri che vanno da -32768 a +32768‚Ķ un pin user√† mai quei numeri? :slight_smile: Ma SOPRATUTTO, un pin varier√† mai in quel range nel codice? Assolutamente impossibile. Perci√≤ questa parte:

//Imposta pin int
int cavo = 2;                        //cavo resistenza
int luce_rossa = 3;                  //luce spot rossa
int luce_uvb = 4;                    //luce uvb per calcio
int lampeggio = 5;                   //led avviso umidità bassa

Deve diventare così:

//Imposta pin int
#define cavo  2                        //cavo resistenza
#define luce_rossa 3                  //luce spot rossa
#define luce_uvb 4                   //luce uvb per calcio
#define lampeggio 5                  //led avviso umidità bassa

Comunque non te la prendere, è un errore praticamente comune nel playground di Arduino e non so perché :slight_smile:


In questa parte invece:

//Imposta ore e minuti inverno
int h_avvio_inv = 9;        //ora accensione luce inverno
int m_avvio_inv = 00;        //minuti accensione luce inverno 
int h_fine_inv = 20;         //ora spegnimento luce inverno 
int m_fine_inv = 00;         //minuti spegnimento luce inverno

//Imposta ore e minuti estate
int h_avvio_est = 9;        //ora accensione luce estate
int m_avvio_est = 00;        //minuti accensione luce estate 
int h_fine_est = 21;         //ora spegnimento luce estate 
int m_fine_est = 00;         //minuti spegnimento luce estate

Dove usi 00, puoi mettere direttamente 0, intanto lui legge così ad esempio lo 0 di mezzanotte :wink:


Per il lampeggio del led intendi quello su questa parte di codice?

  time = millis();
  if (h <= 40) {
    lcd.setCursor(6, 1);
    lcd.print((char) 5);
    lcd.print(h);
    lcd.print("%");
    /* digitalWrite(5, HIGH);
        delay(250);
      digitalWrite(5, LOW);
      delay(250);*/
  }
  if ((h <= 40) && (time > led_um)) {
    digitalWrite(lampeggio, HIGH);
  }
  if ((h <= 40) && (time < led_um)) {
    digitalWrite(lampeggio, LOW);
  }

Per questa parte di codice è sbagliato proprio tutto l’approccio a millis()
Hai provato a guardare l‚Äôesempio ‚Äėblink without delay‚Äô?
Se si, cosa non ti è chiaro?


Poi per ultimo, non ho capito bene questo problema :

ora si accende solo se l‚Äôorario corrisponde e la temperatura raggiunge i 20¬į ma una volta che si spegne poi in una delle 2 condizioni poi nn si riaccende, ho riscontrato lo stesso problema anche per l‚Äôaccensione della lampada uvb se l‚Äôorario nn corrisponde allora si spegne, mettiamo per ipotesi che vada via la luce un volta che ritorna se √® nell‚Äôorario prestabilito se deve riavviare‚Ķ Nn so come fare :stuck_out_tongue:

Spero di esserti stato di aiuto!
Ciao!

ok ho sistemato i primi 2 punti, no nn me la prendo anche perché se sapessi il modo in cui faccio programmazione ti metteresti le mani nei capelli :stuck_out_tongue:

per il lampeggio avevo usato un esempio simile ma nn ci avevo capito molto di come funziona il millis() in generale e ho estrapolato quello che mi sembrava facesse al caso mio, adesso provo a guardare quell’esempio e vedo che cosa combino

per l’ultima parte mi son spiegato parecchio male scrivendoti frettolosamente, dopo provo a esprimermi meglio, magari guardo meglio anche come si comporta

EDIT:
la situazione si complica :frowning: ora nn vedo pi√Ļ sul display l‚Äôumidit√† dopo aver provato a inserire la parte per far lampeggiare il led

#define lampeggio 5 

unsigned long time = 0;
int led_um = LOW;


const long interval = 500;

void setup()

pinMode (lampeggio, OUTPUT);
digitalWrite(lampeggio, LOW);

void loop()

unsigned timeCurrent = millis();
if ((timeCurrent - time >= interval) && (h <= 40) ){
   time = timeCurrent;
  if (led_um == LOW)
    led_um = HIGH;
   else
    led_um = LOW;
 digitalWrite(lampeggio, led_um);
 }

questo è quello che ho aggiunto allo sketch per far lameggiare il led ma ora mi ritrovo che sul display vedo solo la temperatura, ho provato a tornare indietro rimettendo com’era prima ma nn è servito, addirittura delle volte quando ricompilo il progetto nn si vede nemmeno la temperatura… qualcosa è andato a culo

Sinceramente mi pare giusta quella parte di codice, fa lampeggiare il led ogni 500ms se l'umidit√† √® sotto o uguale a 40 Non dovrebbe aver causato danni... hai provato a vedere se magari ci sono falsi contatti da qualche parte? Oltre a sembrarmi strano che quel codice blocchi qualcosa (anche se preferirei vedere dove lo hai inserito nel TUO codice) mi pare ancora pi√Ļ impossibile che abbia danneggiato qualcosa!

√ą come se nn venisse inizializzato il testo, perch√© se ci soffio sopra la temperatura sale e fa scattare il rel√®, ho provato ad estrarre e reinserire il sensore allora si vede la sola temperatura, ne avevo un altro di quei sensori e fa la stessa cosa quindi immagino che il sensore sia a posto, il sensore lo avevo volante con della cavetteria quando ha iniziato a fare cos√¨ l‚Äôho preso e fissato sulla basetta di prova‚Ķ Stamattina ho provato a caricare lo sketch precedente con gli errori che mi hai fatto correggere e funziona a dovere :stuck_out_tongue:

metto il codice a pezzi per farti capire dove ho sistemato le parti che riguardano la modifica al lampeggio (mi sembrava inutile postare il tutto un’altra volta)

//Librerie define

#define DHTPIN 6                  // pin ingresso sensore
                                            // temperatura 
#define DHTTYPE DHT11        // definizione del tipo      
                                            // di sensore
#define cavo 2                      // cavo resistenza
#define luce_rossa 3             // luce spot rossa
#define luce_uvb 4               // luce uvb per calcio
#define lampeggio 5             // led avviso umidità bassa

//Imposta variabili booleane
boolean active_cavo = false;
boolean active_luce_rossa = false;
boolean active_luce_uvb = false;

//Imposta variabili tempo
unsigned long time = 0;
int led_um = LOW;
//int light_sch = 0;

//Imposta costanti
const long interval = 500;

/**********************************************************/
void loop(void)
{   
unsigned timeCurrent = millis(); 

  digitalClockDisplay();
  delay(1000);
  
//avvio e lettura temperatura
  int h = dht.readHumidity();
  int t = dht.readTemperature();
  float f = dht.readTemperature(true);

if (isnan(h) || isnan(t) || isnan(f)) {
  // lcd.clear();
    lcd.setCursor(0, 0);
      lcd.print("Lettura fallita");
    lcd.setCursor(0, 1);
      lcd.print("del sensore DHT");  
    return;
  }
  
  float hi = dht.computeHeatIndex(f, h);
  

// visualizza temperatura tramite sensore
if (t <= 20) {
    lcd.setCursor(0, 1);
     lcd.print((char) 1);
        lcd.print(t); 
         lcd.print((char)223); 
          lcd.print("C ");
  }
  
  if (t >= 22) {
   lcd.setCursor(0, 1);
     lcd.print((char) 2);
        lcd.print(t); 
         lcd.print((char)223); 
          lcd.print("C ");
    }
   
   if (t >= 25) {
     lcd.setCursor(0, 1);
     lcd.print((char) 3);
        lcd.print(t); 
         lcd.print((char)223); 
          lcd.print("C ");
    }
    
    if (t >= 35) {
      lcd.setCursor(0, 1);
     lcd.print((char) 4);
        lcd.print(t); 
         lcd.print((char)223); 
          lcd.print("C ");
    }
          
// visualizza umidità tramite sensore          
  if (h <= 40){ 
    lcd.setCursor(6, 1);      
      lcd.print((char) 5);
         lcd.print(h);
           lcd.print("%");               
} 

if ((timeCurrent - time >= interval) && (h <= 40) ){
   time = timeCurrent;
  if (led_um == LOW)
    led_um = HIGH;
   else
    led_um = LOW;
 digitalWrite(lampeggio, led_um);
 }   

   if (h >= 60){ 
    lcd.setCursor(6, 1);      
      lcd.print((char) 6);
         lcd.print(h);
           lcd.print("%");              
   }

pensavo anche al fatto che ad ogni condizione if richiamo anche la visualizzazione della temperatura o umidità, è possibile visualizzarla e cambiare solo il char da mostrare? mi sembra una ripetizione ogni volta mostrare il valore

Manca una parentesi alla fine per chiudere il loop, ma probabilmente l'hai dimenticata solo qui sul forum ;) Comunque meglio che funzioni! Come ti ho detto forse erano falsi contatti. Comunque riguardo alla visualizzazione, credo che basti semplicemente scrivere l'umidità e temperatura fuori dagli if IN UN POSTO BEN DEFINITO E USANDO lcd.clear ogni volta che vai a riscrivere e poi negli if scrivi solo il char con lcd.setCursor nel punto che vuoi che siano. In pratica ci lasci solo questo nell'if (esempio)

lcd.setCursor(6, 1); lcd.print((char) 6);

Poi la temperatura e l'umidità li scrivi in un altro posto fuori dagli if e quando si verificano gli if, andrai a scrivere un carattere in un posto da te scelto, facendo come sopra. Ciao! E grazie per i karma (penso me li abbia messi tu :P )

P.S. Comunque da Arduino, vai su Strumenti e usa 'formattazione automatica' che √® meglio, √® tutto pi√Ļ ordinato. ;)

No nn te li ho dati io perché nn so neanche che roba sia, ma vado a vedere e visto l'aiuto te li lascio volentieri, mi manca ancora una cosa però voglio provare a fare ulteriori verifiche, magari monto anche il tutto in una scatola così da nn avere tutto smollato, cosa fa la formattazione automatica?