Problème de lecture de temps unix sur DS3231

Bonjour à vous,

Je suis entrain de travailler sur un projet de décomptage du temps de veille de ma carte arduino. Comme les compteurs internes à l’Arduino s’arrêtent quand on passe l’arduino en mode veille “STANDBY”, je ne peux donc pas me baser dessus pour savoir, au réveille, combien de temps la veille a duré.

J’ai donc décidé d’utiliser un DS3231 avec la librairie DS3231.h (https://github.com/rodan/ds3231).

J’ai écrit le code suivant :

#include <SoftwareSerial.h>                                 // Inclusion de la librairie de communication sur le port série
#include <Wire.h>                                           // Inclusion de la librairie de communication I2C
#include <ds3231.h>                                         // Inclusion de la librairie de controle du RTC
#include <LowPower.h>                                       // Inclusion de la librairie de mise en veille


struct ts t;                                                // On définie t commme étant une variable de type "struct ts"

// Constantes

#define wakeUpPin 2



//Variables
float freqValue =0;
unsigned long Delta_T = 0;                                  // Toutes les marqueurs et delta de temps sont de type "unsigned long", qui est équvalent à "uint32_t"
unsigned long pause = 0;                                    // u = unsigned = non signé
unsigned long T_total = 0;                                  // long = int32 = entier de 32 bits
unsigned long T1 = 0;
unsigned long T2 = 0;
unsigned long T_start = 0;
unsigned long T_start_pause = 0;
unsigned long T_end_pause = 0;


void setup() {
  
  Serial.begin(9600);                                       // Initialisation de la liaison série à 9600 bauds
  Wire.begin();                                             // L'Arduino se déclare maitre sur le bus i2c
  pinMode(wakeUpPin, INPUT);
  DS3231_init(DS3231_CONTROL_INTCN);
  
#ifdef CONFIG_UNIXTIME
  DS3231_get(&t);                                           // Lecture de t sur la RTC (t étant un vecteur des donées sec, min, hours,...)

  T_start = t.unixtime;                                     // Initialisation de l'heure de départ du système    unixtime étant le temps en seconde qui c'est écoulé depuis le 01.01.1970 00:00:00 UTC
#endif
  T2= T_start;                                              // Marquage du début du premier tour de la boucle
  
}



void loop() {
  
  T1 = T2;                                                  // Marqueur de début de tour de traitement
  T_start_pause = 0;                                        // Mise à 0 du marqueur de début de veille à chaque tours
  T_end_pause = 0;                                          // Mise à 0 du marqueur de fin de veille à chaque tours


// Début de la mise en veille
  
#ifdef CONFIG_UNIXTIME   
    DS3231_get(&t);                                         // Lecture de t sur la RTC pour le début de veille
                
    T_start_pause = t.unixtime;                             // Marqueur de début de pause (veille)
#endif

    attachInterrupt(digitalPinToInterrupt(wakeUpPin), wakeUp, RISING);
    
    delay (200);                                            // Attente pour la mise en veille pour laisser le temps à l'Arduino de finir les taches en cours
    
    LowPower.powerStandby(SLEEP_4S,ADC_OFF,BOD_OFF);   // Mise en veille jusqu'à interruption sur ..
    
    detachInterrupt (wakeUpPin);

    DS3231_get(&t);                                         // Lecture de t sur la RTC pour la fin de veille
    
#ifdef CONFIG_UNIXTIME
    T_end_pause = t.unixtime;                                 // Marqueur de fin de pause (veille)
#endif

    Delta_T =(T_end_pause - T_start_pause); 
    pause += Delta_T;                                       // Calcul du total de temps d'arret (pause) du robot à la sortie de veille
    T_total += Delta_T;                                     // Calcul du temps total de surveillance
    
 


  DS3231_get(&t);                                           // Lecture de t sur la RTC pour la fin du tour
  
#ifdef CONFIG_UNIXTIME
  T2 =t.unixtime;                                            // Marqueur de fin du tour
#endif

  Delta_T = T2 - T1 - (T_end_pause - T_start_pause);        // Calcul du temps de traitement hors période de veille
  T_total += Delta_T;                                       // Ajout du nouveau temps de traitement au total
  
  freqValue = FreqValue ( pause, T_total);                  // Calcul de la fréquence
  envoie();
}




//fonction

//fonction pour calculer la valeur de la fréquence

float FreqValue ( float pause, float T_total) {
  float resultat = (( T_total - pause )/T_total) * 100;     // Calcul de la fréquence d'usinage
  if (resultat <= 0){
    resultat = 0;
  }
  return resultat ;                                      // Retourne le résultat
}

//fonction pour envoyer les deux valeurs demandées

void envoie () {
  Serial.print("x");                                          // Envoie d'un x pour séparer les deux valeurs renvoyées
  Serial.println(freqValue);                                  // Envoie la fréquence d'usinage calculée
  Serial.print("T_total : ");
  Serial.println(T_total);
  Serial.print("pause : ");
  Serial.println(pause);
  Serial.print("T1 : ");
  Serial.println(T1);
  Serial.print("T2 : ");
  Serial.println(T2);
  Serial.print("T_start_pause : ");
  Serial.println(T_start_pause);
  Serial.print("T_end_pause : ");
  Serial.println(T_end_pause);
  Serial.println(millis());
  Serial.println(" ");
}

void wakeUp(){
  
}

Mon idée, pour éviter d’avoir des erreurs de comptage, c’est de lire directement sur mon horloge l’unixtime, avec t.unixtime. Le problème, c’est que mon programme me renvoie 0. Pour débugger mon système, j’ai tenté de juste lire les secondes et ça a marché. Donc le problème vient surement de mon programme.

Etant peu expérimenté en programmation, j’ai beau avoir cherché, je ne trouve pas. Quelqu’un aurait il une idée ?

Merci d’avance

Voila peut être un code plus simple pour faire d’abord marcher la lecture du temps UNIX, qui bien sûr, s’inspire du précédent et qui ne marche pas.

#include <SoftwareSerial.h>                                 // Inclusion de la librairie de communication sur le port série
#include <Wire.h>                                           // Inclusion de la librairie de communication I2C
#include <ds3231.h>                                         // Inclusion de la librairie de controle du RTC

struct ts t;                                                // On définie t commme étant une variable de type "struct ts"

//Variables
unsigned long T = 1;
unsigned long T2 = 0;


void setup() {
  
  Serial.begin(9600);
  Wire.begin();
  DS3231_init(DS3231_CONTROL_INTCN);
  
}



void loop() {
  
#ifdef CONFIG UNIXTIME
    DS3231_get(&t);
    T=t.unixtime;
#endif
  
    Serial.print("UNIX : ");
    Serial.println(T);
    Serial.print("millis : ");
    Serial.println(millis());
    delay(1000);


}

Quelqu’un aurait une idée de ce que j’ai mal fait ?

CONFIG_UNIXTIME : cette macro est-elle définie quelque part ?

Ensuite pourquoi remplacer _ par espace ?

#ifdef CONFIG UNIXTIME

Bonjour,

Cette macro me semble être définie dans la librairie "DS3231.h", dans la définition de la structure du message envoyé par la RTC. Après, je n'est peut être pas compris son fonctionnement.

Bout de la librairie DS3231.h concerné :

struct ts {
    uint8_t sec;         /* seconds */
    uint8_t min;         /* minutes */
    uint8_t hour;        /* hours */
    uint8_t mday;        /* day of the month */
    uint8_t mon;         /* month */
    int16_t year;        /* year */
    uint8_t wday;        /* day of the week */
    uint8_t yday;        /* day in the year */
    uint8_t isdst;       /* daylight saving time */
    uint8_t year_s;      /* year in short notation*/
#ifdef CONFIG_UNIXTIME
    uint32_t unixtime;   /* seconds since 01.01.1970 00:00:00 UTC*/
#endif
};

L'oublie du _ est une erreur de frappe de ma part. ^^'

Bonjour,

Justement la macro CONFIG_UNIXTIME n'est pas définie dans ds3231.h. Elle n'est définie que pour les processeur ESP32 et SAMD.
Il faudrait la définir manuellement dans ds3231.h, mais j'ai essayé ça ne fonctionne pas.

Laisses tomber cette librairie et utilises la librairie RTCLib d'adafruit qui fonctionne très bien et gère le temps unix

+1 pour RTCLib.

Finalement, j'ai bien finit par utiliser la bibliothèque RTCLib et, surprise, ça marche :smiley:

Merci à vous