Programmateur à la seconde DS3231

Bonjour à tous :slight_smile:

projet aquarium ( fontaine ,arrosage, led…)

Tous fonctionne plus au moins sauf les timers et je pense que le code pourrai nettement être plus “propre” mais j’arrive au max de mes capacité pour le moment ::slight_smile:

J’essaye de faire fonctionner le DS3231 pour faire des programmateur sur 4 relay différents et bien sur indépendant les uns des autres.

voici le code mais il n’a pas l’air très optimisé avez-vous des conseils? ( je suis débutant )

J’aimerais pouvoir programmer indépendamment et à la seconde pour certains timer, et d’autre comme juste l’éclairage a l’heure sachant que plus tard j’aimerai installé le module ou si c’est bien éclairé ça coupe les LED ( si j arrive à me faire comprendre :o )

Le relai de brumisation lui devrai pouvoir être activé seulement quelque seconde et plusieurs fois dans la journée.

un peu d’aide serai la bien venu :confused:

merci à ceux ou celui qui viendra a ma rescousse :grinning:

// UTFT ///////////////////////////////////////////////////////////////////////////////////// UTFT //
  #include <UTFT.h>
  #include <memorysaver.h>  //Ajouté pour optimiser la mémoire Uno
  extern uint8_t SmallFont[];
  extern uint8_t BigFont[];
  extern uint8_t SevenSegNumFont[];
  extern uint8_t DotMatrix_M[];
  extern uint8_t Grotesk16x32[];
  extern uint8_t Grotesk24x48[];
  extern uint8_t Grotesk32x64[];
  extern uint8_t GroteskBold16x32[];
  extern uint8_t GroteskBold24x48[];
  extern uint8_t GroteskBold32x64[];
  extern uint8_t SixteenSegment48x72Num[];
  extern uint8_t SixteenSegment64x96Num[];
  UTFT myGLCD(ILI9486,38,39,40,41);
// UTFT ///////////////////////////////////////////////////////////////////////////////////// UTFT //

//DHT 22///////////////////////////////////////////////////
  #include "DHT.h"
  #define DHTPIN 7
  #define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
  DHT dht(DHTPIN, DHTTYPE);
//DHT 22///////////////////////////////////////////////////

// DS18B20 ///////////////////////////////////////////////////////////////////////////////////// DS18B20 //
#include <DS18B20.h>
DS18B20 ds(8);
uint8_t address[] = {0x28,  0x26,  0xBA,  0x7,  0xD6,  0x1,  0x3C,  0x7F};
uint8_t selected;
// DS18B20 ///////////////////////////////////////////////////////////////////////////////////// DS18B20 //

// DS3231 ///////////////////////////////////////////////////////////////////////////////////// DS3231 //
  #include <RTClib.h>
  #include <Wire.h>
  RTC_DS3231 rtc;
  char t[32];
// DS3231 ///////////////////////////////////////////////////////////////////////////////////// DS3231 //

// TIMER ///////////////////////////////////////////////////////////////////////////////////// TIMER //
int Brumisateur = 2; //Pin D2
int PompeEau = 3; //Pin D3
int BarLed = 4; //Pin D4
int LedAqua = 5; //Pin D5

boolean ActionBrumisateur = 0;  //O= OFF 1 = ON
boolean ActionPompeEau = 0;  //O= OFF 1 = ON
boolean ActionBarLed = 0;  //O= OFF 1 = ON
boolean ActionLedAqua = 0;  //O= OFF 1 = ON
// TIMER ///////////////////////////////////////////////////////////////////////////////////// TIMER //

void setup() {

// TIMER ///////////////////////////////////////////////////////////////////////////////////// TIMER //
  pinMode ( Brumisateur , OUTPUT );
  //pinMode ( PompeEau , OUTPUT );
  //pinMode ( BarLed , OUTPUT );
  //pinMode ( LedAqua , OUTPUT );
// TIMER ///////////////////////////////////////////////////////////////////////////////////// TIMER //

  Serial.begin(9600);
  selected = ds.select(address);  //sonde DS18B20 temp
  dht.begin();                    //sonde DHT22 hygro
  
//DS3231/////////////////////////////////////////////////////////////////////////////////////DS3231//
  Wire.begin();
  rtc.begin();
  rtc.adjust(DateTime(F(__DATE__),F(__TIME__)));
  //rtc.adjust(DateTime(2021, 1, 5, 15, 55, 0));

  dht.begin();
 
//DS3231/////////////////////////////////////////////////////////////////////////////////////DS3231//


// UTFT ///////////////////////////////////////////////////////////////////////////////////// UTFT //
  myGLCD.InitLCD();  //Initialisation
  myGLCD.clrScr();   //Clear

  myGLCD.setColor(255, 255, 0);       //Couleur Rectangle du bas
  myGLCD.fillRect(0, 300, 479, 320);    //Rectangle du Bas

  myGLCD.setFont(BigFont);              // Taille du texte
  myGLCD.setBackColor(255, 255, 0);   // Couleur du fond
  myGLCD.setColor(255, 0, 0);           // Couleur du texte
  myGLCD.print("Paludarium", CENTER, 302);

  myGLCD.setFont(BigFont);                // Taille du texte
  myGLCD.setBackColor(0, 0, 0);           // Couleur du fond
  myGLCD.setColor(255, 255, 255);         // Couleur du texte
  myGLCD.print("Temp : ", 10, 20); 
  myGLCD.print("%", 145, 20); 
  myGLCD.print("Hygro: ", 10, 60); 
  myGLCD.print("o", 145, 50); 
  
  //myGLCD.print("PH: ", 290, 20); 
  //myGLCD.print("EC: ", 290, 60); 

  myGLCD.setFont(GroteskBold32x64);       // Taille du texte
  myGLCD.setBackColor(0, 0, 0);           // Couleur du fond
  myGLCD.setColor(255, 255, 255);         // Couleur du texte
  myGLCD.print(":", CENTER, 150); 

  myGLCD.setFont(Grotesk16x32);           // Taille du texte
  myGLCD.setBackColor(0, 0, 0);           // Couleur du fond
  myGLCD.setColor(255, 255, 255);         // Couleur du texte
  myGLCD.print("/", 390, 260); 
  myGLCD.print("/", 330, 260); 
  
 
// UTFT ///////////////////////////////////////////////////////////////////////////////////// UTFT //

}

void loop() {

  
 //DS3231/////////////////////////////////////////////////////////////////////////////////////DS3231//
  DateTime now = rtc.now();
  int heure = 00;
  int minut = 00;
  int seconde = 00;
  int jour = 00;
  int mois = 00;
  int annee = 00;
  heure = now.hour();
  minut = now.minute();
  seconde = now.second();
  jour = now.day();
  mois = now.month();
  annee = now.year();

  Serial.print(heure);
  Serial.print(":");
  Serial.print(minut);
  Serial.print(":");
  Serial.println(seconde);
//DS3231/////////////////////////////////////////////////////////////////////////////////////DS3231//
  Serial.print(ds.getTempC());
  Serial.println(" C");
//DHT 22///////////////////////////////////////////////////
  int h = dht.readHumidity();
  int t = dht.readTemperature();
  int f = dht.readTemperature(true);
  
  if (isnan(h) || isnan(t) || isnan(f)) {
    return;
  }

  Serial.print(F("Humidité: "));
  Serial.print(h);
  Serial.print(F("%     Temperature: "));
  Serial.println(t);
//DHT 22///////////////////////////////////////////////////


// TIMER ///////////////////////////////////////////////////////////////////////////////////// TIMER //

//Timer1///////////
  float onheure1 = 17;                           // heure allumage
  float onminute1 = 18;
  float offheure1 = 17;
  float offminute1 = 19;
  if(minut == onminute1 & heure == onheure1 ){
    ActionBrumisateur = 1; 
  }
  if(minut == offminute1 & heure == offheure1 ){
    ActionBrumisateur = 1; 
  }
  if(ActionBrumisateur == 0){
    Serial.println("Brumisateur OFF");
    digitalWrite(Brumisateur, HIGH);  
  }
  else{
   Serial.println("Brumisateur ON"); 
  }







// TIMER ///////////////////////////////////////////////////////////////////////////////////// TIMER //

// UTFT ///////////////////////////////////////////////////////////////////////////////////// UTFT //  
  myGLCD.setFont(SixteenSegment64x96Num);
  
  myGLCD.setColor(255,255,255); // Couleur du Texte
  myGLCD.setBackColor(0, 0, 0); // Couleur du fond

  myGLCD.printNumI(heure,80,130);
  myGLCD.printNumI(minut,270,130);

  myGLCD.setFont(Grotesk16x32);
  myGLCD.printNumI(jour ,290,260);
  myGLCD.printNumI(mois,370,260);
  myGLCD.printNumI(annee,410,260);

  myGLCD.setFont(BigFont);
  myGLCD.printNumI(h, 110, 20); 
  myGLCD.printNumI(t, 110, 60);   

   myGLCD.printNumI("timer", 360, 20); 
   myGLCD.printNumI("timer", 360, 60); 
  
  int buf[478];
  int x, x2;
  int y, y2;
  int r;
// UTFT ///////////////////////////////////////////////////////////////////////////////////// UTFT //
  
  delay(1000);
}

Comme vous utilisez la RTClib vous pourriez profiter des classes DateTime et TimeSpan qui sont proposées pour représenter le temps.

Vous allez avoir plusieurs appareils à gérer mais qui ont le même comportement: on définit un moment de début et de fin (ou une durée) et on lui demande de réagir à l’heure.
==> faire une petite classe semble donc approprié

je verrais donc bien un truc du genre (tapé ici, donc pas sûr que ça fonctionne, à tester)

#include <RTClib.h>
RTC_DS3231 rtc;

class Appareil
{
  private:
    uint8_t broche;
    uint8_t etatOff;
    uint32_t debut, fin;
    bool actif;

    inline uint32_t enSeconde(DateTime& e)
    {
      return 3600ul * e.hour() + 60ul * e.minute() + e.second();
    }

    void activation() {
      digitalWrite(broche, !etatOff);
      actif = true;
    }

    void desactivation() {
      digitalWrite(broche, etatOff);
      actif = false;
    }

  public:
    // constructeur avec 2 dates. seules H/M/S sont prises en compte
    Appareil(const uint8_t pin, DateTime& s, DateTime& e) : broche(pin) {
      debut = enSeconde(s);
      fin = enSeconde(e);
    }

    // constructeur avec 1 date et une durée. seules H/M/S sont prises en compte
    Appareil(const uint8_t pin, DateTime& s, TimeSpan& d) : broche(pin) {
      DateTime e = s + d;
      debut = enSeconde(s);
      fin = enSeconde(e);
    }

    void begin(uint8_t inactiveState = LOW) {
      etatOff = inactiveState;
      pinMode(broche, OUTPUT);
      desactivation();
    }

    void verification(DateTime & maintenant) {
      uint32_t t0 = enSeconde(maintenant);
      if (actif) {
        if (t0 >= fin) desactivation();
      }
      else {
        if (t0 >= debut) activation();
      }
    }
};

DateTime debutBrumisateur = DateTime(0, 0, 0, 17, 18, 0);
DateTime finBrumisateur = DateTime(0, 0, 0, 18, 29, 30);
Appareil brumisateur(2, debutBrumisateur, finBrumisateur); // entre 17:18:00 et 18:29:30

DateTime debutPompe = DateTime(0, 0, 0, 14, 20, 0);
TimeSpan dureePompe = TimeSpan(0, 1, 20, 30);
Appareil pompe(3, debutPompe, dureePompe ); // entre 14:20:00 et 15:40:30 (durée 1h20 et 30s)

void setup() {
  Serial.begin(9600);
  rtc.begin();
  brumisateur.begin();
  pompe.begin();
}

void loop() {
  DateTime maintenant = rtc.now();
  brumisateur.verification(maintenant);
  pompe.verification(maintenant);
}

On définit un Appareil par le N° de pin qui contrôle le relais et le début et fin (ou durée pour l’autre constructeur) du programme.
Il suffit ensuite d’appeler verification() dans la boucle pour que l’appareil vérifie si c’est le moment de faire une action.

bien sûr on pourrait étendre la classe pour forcer la désactivation pour aujourd’hui ou forcer l’activation pour un certain temps etc…

je vous laisse tester le concept