RTC n'est pas a l'heure au demarrage

bonjour
tout est dans le titre je n'arrive pas a trouver pourquoi
pour l'installation j'ai un ecran lcd i2c ou il ya un message , un deuxieme ecran lcd i2c ou sur la premiere ligne la date , sur la deuxieme ligne la temperature et l humidité avec capteut DHT22 i2c et pour finir un afficheur 7 segment 4dgit i2c ou il ya l'heure le tout avec RTC DS3231 i2c

quand je les scann ils sont tous la :
" Scanning...
I2C device found at address 0x27 ! ecran lcd
I2C device found at address 0x3F ! ecran lcd2
I2C device found at address 0x57 !
I2C device found at address 0x5F !
I2C device found at address 0x68 !
done"

donc quand j allume tout ca rien n'est a jour il faut que je televerse pour mettre a jour , je ne trouve pas le probleme voici mon code je suis tres novice sur arduino alors hesitez pas a corriger si il ya des lignes de code inutile , mal placé etc....
merci d'avance pour votre aide je ne sais plus quoi faire avec cette heure qui ne ce met pas a jour

// LIBRAIRIES
 
   #include <DHT.h> // inclure les librairies
   #include <Wire.h>
   #include <LiquidCrystal_I2C.h>
   #include <RTClib.h> //librairie à télécharger en ZIP sur https://github.com/jcw/rtclib
   #include "TM1637.h"
   #include "RTClib.h"
   
// Digital

//{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
//0~9,A,b,C,d,E,F,"-"," ",degree,r,h

   #define CLK 4//Pins for TM1637       
   #define DIO 5
   TM1637 tm1637(CLK,DIO);

// Date and time functions using a DS3231 RTC connected via I2C and Wire lib
   
 
   RTC_DS3231 rtc;
   int hh, mm; 

// Fin


// ECRAN

   LiquidCrystal_I2C lcd(0x27, 16,2); // Initialise le module 1602 I2C
   LiquidCrystal_I2C lcd2 (0x3f,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display

// FIN

// FIN

// DHT 22

   const int relayPin = 13; // PIN 13 pour test sur une LED de la carte
   const int DHTPIN = 13;

// Type de capteur utiliser
   #define DHTTYPE DHT22   // DHT 11
   DHT dht(DHTPIN, DHTTYPE);// Initialise le capteur DHT11

// FIN

//RTC

    DateTime now;
    char daysOfTheWeek[7][12] = {"Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"};

    void showDate(void);
    void showTime(void);
    void showDay(void); 
  
//FIN


void setup() {

    
// RTC


  lcd.init();  // initialisation du LCD1
  lcd2.init();  // initialisation du LCD2
  lcd.backlight();
  lcd2.backlight();
  lcd.print("Initialisation....");  //afficher un message sur l'afficheur LCD
  lcd2.print("Initialisation...."); //afficher un message sur l'afficheur LCD
  delay (2500) ;
  delay (2500);
  Wire.begin();
  Wire.begin();
  lcd.begin(16,2);
  lcd2.begin(16,2);
  Serial.begin(9600);
  
  
//delay(2000);
    if (! rtc.begin()) 
    {
    Serial.println("Couldn't find RTC Module");
    while (1);
    }

    if (rtc.lostPower()) 
    {
    Serial.println("RTC lost power, lets set the time!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    }
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

// Fin


// Digital

   tm1637.init();
   tm1637.set(5); 
   
//BRIGHT_TYPICAL = 2,BRIGHT_DARKEST = 0,BRIGHTEST = 7;

   rtc.begin();
     
// manual adjust
// December , 2018 at 19pm you would call:

    rtc.adjust(DateTime(2018, 12, 23, 04, 01, 0));
    
 //  automatic adjust

    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

// Fin
    

// DATE

 
 

  // Print a message to the LCD.
   
   lcd2.backlight();
   lcd2.setCursor(5,0);
   lcd2.print("Salut");
   lcd2.setCursor(2,1);
   lcd2.print("Mugen Zaraki");
   
// FIN


// RTC


   }
   
void loop()

   {

   now = rtc.now();
   showDate();
   showDay();
   showTime();
  }


  void showDate()
  {
  lcd.setCursor(5,0);
  lcd.print(now.day());
  lcd.print('/');
  lcd.print(now.month());
  lcd.print('/');
  lcd.print(now.year());
  }
   void showDay()
  {
  lcd.setCursor(0,0);
  lcd.print(daysOfTheWeek[now.dayOfTheWeek()]);
  }
  void showTime()
  {

// Fin


//Digital

     DateTime now = rtc.now();
     hh = now.hour(), DEC;
     mm = now.minute(), DEC;
     tm1637.point(POINT_OFF);
    tm1637.display(0,hh/10);     // hour
    tm1637.display(1,hh%10);
    tm1637.display(2,mm/10);    // minutes
    tm1637.display(3,mm%10);    // 
    delay(100);
    tm1637.point(POINT_ON);
    tm1637.display(0,hh/10);     // hour
    tm1637.display(1,hh%10);
    tm1637.display(2,mm/10);    // minutes
    tm1637.display(3,mm%10);    // 
    delay(100);

// Fin


// BOUCLE TEMPERATURE
  
   // Lecture de température et de l'humiditer environ 250 millisecondes
   // La durer des capteurs peuvent etre regler jusqu'a 2 secondes (capteur tres lent)
   float h = dht.readHumidity();
   // Lit la temperature en degres Celsius (valeur par defaut
   float t = dht.readTemperature();
   float c = dht.readTemperature(true);

   // Vérifie si toutes les lectures ont échoué et quitte le début (pour réessayer).
   if (isnan(h) || isnan(t) || isnan(c)) {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }

// FIN


// Temperature et humidité LCD

  lcd.setCursor(0, 1);
  lcd.print("");
  lcd.print(t);
  lcd.print(" C");
  lcd.setCursor(9, 1);
  lcd.print("");
  lcd.print(h);
  lcd.print(" % ");

  Serial.print("Temperature = ");
  Serial.print(t);
  Serial.print(" *C ");
 
  Serial.print("Humidity = ");
  Serial.print(h);
  Serial.print(" %\t ");
  Serial.println();


  if (h >= 75 && h <= 80) // si hum. est = ou sup. a 75 ET hum infer. ou = a 80 relais ouvert
  {
    digitalWrite(relayPin, HIGH);
  }
  else
  {
    digitalWrite(relayPin, LOW); // Sinon relais fermé
  }
  delay(1000);// Delai d'une seconde entre les mesures

  
  }

// FIN
if (rtc.lostPower())
    {
    Serial.println("RTC lost power, lets set the time!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    }
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

Si la RTC s'est trouvé non alimentée tu l'as remet à l'heure
Sinon dans tous les cas tu remets à l'heure.
Puis un peu plus loin tu refais encore des remises à l'heure
Faudrait peut-être faire un peu le ménage dans les rtc.adjust()

Bonjour,

va voir la : https://www.instructables.com/id/Simple-Guide-to-Setting-Time-on-a-DS3231DS3107DS13/

tu vas trouver toutes les explications.

Tu mets ton DS3231 a l'heure une fois pour toute. Tant que tu ne retireras pas la batterie, tu auras toujours l'heure exacte.

Jacques

Utilise ce code:

#include <Wire.h>
#include "RTClib.h"

RTC_DS3231 rtc;

char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

void setup () {

#ifndef ESP8266
#endif

  Serial.begin(9600);

  delay(3000); // wait for console opening

  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (rtc.lostPower()) {
    Serial.println("RTC lost power, lets set the time!");
    // following line sets the RTC to the date & time this sketch was compiled
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    // anee, mois, jour, heure, minute, seconde
    rtc.adjust(DateTime(2018, 12, 30, 17, 51, 0));
  }
}

void loop () {
    DateTime now = rtc.now();
Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();
  delay(1000);
  
}

Indique la bonne date et heure dans le code dans "rtc.adjust(DateTime(2018, 12, 30, 17, 51, 0));" en remplaçant , téléverser, débrancher la carte, enlever la pile pour 3sec, la remettre, puis re-téléverser. C'est bon ! Heure réglée !

Bonjour;

Il te faut initialiser ton module dans le setup().

Voici une façon de le faire.

//----- Configuration de l'échange RTC -----//
RTC.begin(); // Ouverture de la transmission RTC
if (! RTC.isrunning()) { // Contrôle la présence du modul RTC.
//Serial.println("!! RTC NO OK !!"); // Affichage message complémentaire./
RTC.adjust(DateTime(DATE, TIME)); // Mise à la date et a l'heure par le RTC lors de la compilation.
}//if.
else {
//Serial.println("- RTC OK -"); // Affichage message complémentaire.
/
//delay(tempConf); //Temporisation.
}//else

A savoir les donnée RTC sont transmise par le PC.
La configuration de la date et heure du pc peux crée des problème de mise à l'heure.

A plus.

Il faut bien comprendre comment fonctionne une RTC.
Le module complet comprend une pile de sauvegarde : donc l'heure n'est jamais perdue.

La conséquence est qu'une RTC n'a besoin d'être mise à l'heure qu'à la première mise en route et éventuellement au changement de pile ce qui laisse plusieurs années tranquilles.
Surtout avec une DS3231 qui est compensée en température donc extrêmement précise et stable à long terme.
NB : Quand la RTC est alimentée par le Vcc on peut retirer la pile et la changer, pas besoin de tout éteindre.

La conséquence de cette conséquence est qu'AMHA c'est donner des bâtons pour se faire battre que d'ajouter les fonctions de mise à l'heure dans le programme qui utilise.

La sagesse me dit d'écrire un programme qui ne fait que la mettre à l'heure à la première utilisation.

Une fois l'opération réalisée, dans le programme utilisateur il suffit juste d'utiliser les fonctions de lecture de la DS3231.

J'ajoute que toujours, à mon humble avis, Bricoleau a écrit une bibliothèque bien plus simple et plus aisée d'usage que ces bibliothèques que l'on trouve sur internet.
Ceux qui sont intéressés peuvent la trouver dans le sous-forum "Tuto et cours".

68tjs:
La sagesse me dit d'écrire un programme qui ne fait que la mettre à l'heure à la première utilisation.

Nul besoin d'écrire ce programme qui se trouve déjà dans les exemples, si je ne m'abuse. Pour le reste, je suis tout à fait d'accord.

Nul besoin d'écrire ce programme qui se trouve déjà dans les exemples,

Ben pour moi si.
Recopier mot à mot n'est pas apprendre.

Bonjour

A la limite, initialiser le rtc avec la date/heure de compil, en exécutant une fois un programme directement fourni dans les exemples, pourquoi pas.

Mais dans ce cas, les instructions qui décodent la chaîne de caractères en valeurs numériques, n'ont rien à faire dans la bibliothèque associée, qu'elles polluent inutilement.
Le principe d'une bibliothèque est d'encapsuler des séquences de codes communes, alors que là on est sur une fonction à usage unique dans un cadre bien précis.

Je pense ajouter un exemple à cet effet dans ma petite lib.
Et le fait que le décodage de la chaîne soit dans le source de l'exemple et non de la lib, évitera un usage non conforme de cette dernière.

J'utilise "RTClib.h" je n'ai pas rencontré de problème avec son utilisation.
Je la trouve simple d’accès et optimale.
Je ne comprends pas pourquoi en crée d'autre !! y a t'il des problèmes ou des fonctionnalités supplémentaires à ajouter?

Je rejoint 68tjs sur ce point

Recopier mot à mot n'est pas apprendre.

Mais quant un exemple est donnée il serai dommage de ne pas l'exploiter pour une première approche.

A plus.

Oui RTCLib est très bien

Si on veut pinailler sur des détails mineurs :

Son principal manque est la gestion des changements d'heure été/hiver (donc la gestion des heures UTC/locales). Les montages permanents qui ont besoin de cette gestion, nécessitent une surcouche pour gérer cela.

En terme d'ergonomie d'utilisation, y a juste un truc que je ne trouve pas top : la lecture physique du circuit externe est déclenchée à chaque fois que l'on appelle RTC.now().
Cela n'a rien d'intuitif, et ouvre la voie à de mauvais usages que l'on trouve à foison : des programmes qui appellent RTC.now() des centaines ou milliers de fois par seconde, pour lire exactement la même valeur. Ca prend du temps pour rien (la lecture via l'I2C est loin d'être instantanée) et ralentit le programme.

Et autre petit bémol : elle met en oeuvre les classes DateTime et TimeSpan, au demeurant très bien quand on maîtrise la programmation en cpp, mais peut-être un peu moins faciles d'accès pour les débutants.
Il faut expérimenter les exemples pour comprendre un minimum comment elle fonctionne.

Alors que la lecture du header ci-dessous se suffit à elle-même pour se lancer directement dans l'utilisation

class simpleRTC
{
  public :
    //Principales méthodes d'accès au circuit externe
    //Retournent true si accès ok, false sinon

    bool actualiser();
         //Actualisation des variables privées par lecture du circuit externe.
         //Idéalement : à exécuter une fois par seconde

    bool regler(uint8_t annee, uint8_t mois, uint8_t jour, uint8_t heure, uint8_t minute, uint8_t seconde);
         //Mise à jour à partir de valeurs date heure locales

    //Méthodes constantes pour consultation de l'horloge
    uint8_t annee() const       {return this->_annee;}
    uint8_t mois() const        {return this->_mois;}
    uint8_t jour() const        {return this->_jour;}
    uint8_t jourSemaine() const {return this->_joursem;} //0 dimanche, 1 lundi, 2 mardi, ...
    uint8_t heure() const       {return this->_heure;}
    uint8_t minute() const      {return this->_minute;}
    uint8_t seconde() const     {return this->_seconde;}

    bool heureEte() const       {return this->_ete;} //Permet de savoir si on est en heures d'été ou d'hiver


    //Méthodes secondaires
    //Retournent true si accès ok, false sinon

    bool reglerUTC(uint8_t annee, uint8_t mois, uint8_t jour, uint8_t heure, uint8_t minute, uint8_t seconde);
         //Mise à jour à partir de valeurs date heure UTC

    bool reglerNTP(uint32_t temps_unix);
         //Mise à jour dans le cadre d'une synchro NTP (secondes écoulées depuis le 01/01/1970 00:00:00 UTC)

    bool reglerDCF77(uint8_t annee, uint8_t mois, uint8_t jour, uint8_t heure, uint8_t minute, bool ete);
         //Mise à jour dans le cadre d'une synchro DCF77 (signal radio heure locale + indic heure d'été)

    uint8_t anneeUTC() const {return this->_anneeUTC;}
    uint8_t moisUTC() const  {return this->_moisUTC;}
    uint8_t jourUTC() const  {return this->_jourUTC;}
    uint8_t heureUTC() const {return this->_heureUTC;}

  private :
    void    _memoriser(uint8_t annee, uint8_t mois, uint8_t jour, uint8_t heure);
    uint8_t _annee, _mois, _jour, _joursem, _heure, _minute, _seconde;
    uint8_t _anneeUTC, _moisUTC, _jourUTC, _heureUTC;
    bool    _ete;
};

Mais bien sûr, l'exemple est réduit aux fonctionnalités essentielles.
Si on veut accéder aux autres fonctionnalités des circuits externes (mise à jour nvram du ds1307, alarmes, etc.) il faut utiliser une lib plus complète.

C'est du beau travail !! bricoleau.

Cela est justifier donc. je te remercie pour ton complet retour.
A l'occasion je l'exploiterais dans mon projet. (enregistreur)

Salutations.

je vous remercie pour toutes ces réponses je vais voir ce qui l'en ai et je reviens ici pour vous dire merci

oui le rtc lib marche tres bien mais ce que je n'arrive pas a faire c'est de mettre seulement la date sur la premiere ligne de l ecran lcd et l'heure sur le 7 segment 4 digit j'ai beau chercher essayer par moi même je n'y arrive pas

Bonjour;

Ton programme c'est le tien ou tu l'a copier ? Si je peux me permettre... La plus grande partie des problèmes viennent de la non compréhension de ce que l'on copie.

Je ne comprends pas pourquoi tu crée des fonctions pour lire la date actuelle.
showDate();
showDay();
showTime();
L'outil "DateTime now = RTC.now();" le fait pour toi en une fois.
De plus l'actualisation de al date n'est utile qu'une fois par jour au passage à 23h59.
Contrairement à l'heure.

Une fonction est utiles lorsqu'une action définie est reconduite plusieurs fois dans un programme.
Ce n'est pas le cas ici tu l'es exécute a chaque tour de boucle. Tu peux donc la laisser ton traitement tel que dans la boucle.

Je trouve l'utilisation du "tm1637" très complexe est pas approprié a ce que tu souhaite faire de l'afficheur 7 segment. (juste bon pour des instructions définis)
Je te recommanderais l'utilisation du' MAX 7219 un pilote d'afficheur 7 segment très simple d'utilisation.

Je pense que ton problème d'affichage au LCD viens de la façon de le mettre en œuvre.
Reprends le modèle de l'exemple RTC inclus dans l'IDE manipule le comprends le et applique le au LCD pour la date.

Salutation.