Ajouter la date et heure fichiers carte SD

Bonjour,
J'aurais besoin de votre aide pour mon projet arduino qui a pour but de relevé ma consommation d'eau dans mon logement et stocker tous les jours sur une carte sd les différentes données de consommation, pression, température.
Je n'ai pas de problème pour le stockage sur la carte sd, par contre j'aimerais savoir comment mettre à jour la date et heure du fichier sd car j'ai toujours "01/01/2000 00:00:".
Je souhaiterais que mon fichier prenne la date et l'heure de mon dernier enregistrement grâce à mon module RTC.

Je pensais avoir trouvé la solution sur le forum : https://forum.arduino.cc/t/fichier-sur-carte-sd-non-horodate/464362/2
Malheureusement je n'arrives pas à le mettre en place, souvent une date différente de celle actuelle ou alors une date erronée.
Auriez-vous des pistes pour que je puisse enfin résoudre mon problème?

Pour information j'utilise un arduino Mega et un module rtc
Voici mon code arduino si cela peut aider

/*
Objectif : Afficher la Consommation d'eau, la pression et la temperature sur un Ecran LCD
 Date de Modification : 17/11/2020 à 12h00
              --> Nombre Impulsions : 12447227 impulsions totals / Nombre de Litres : 42820 litres / Compteur Eau 185771
              --> Sauvegarde du Nombre d'impulsions dans la NVRAM du module DS1307
 */
//#define RX 18 // Pin Bluetooth
//#define TX 19 // Pin Bluetooth
#include "DHT.h"
#include <OneWire.h>
#include <DallasTemperature.h> // Bibliotheque pour la sonde de T°

#include <Wire.h>
#include <LiquidCrystal_I2C.h> // Bibliotheque pour l'ecran LCD
#include "RTClib.h"  // Bibliothèque pour le module RTC
#include <SPI.h>    // Bibliotheque pour Slot Carde SD
#include <SD.h>     // Bibliotheque pour Slot Carde SD
#define ONE_WIRE_BUS 6  //Capteur Temperature
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
LiquidCrystal_I2C lcd(0x27, 20, 4);  //Declarer l'adresse I2C de l'ecran
RTC_DS1307 RTC;      // Instance du module RTC de type DS1307
File fichierSD;
#if defined(ARDUINO_ARCH_SAMD)
// for Zero, output on USB Serial console, remove line below if using programming port to program the Zero!
   #define Serial SerialUSB
#endif

//#include <SoftwareSerial.h>                  
//SoftwareSerial bluetooth(RX,TX); //Bluetooth

//Debut Declaration Detecteur de Debit
byte sensorInterrupt = 0;  // 0 = digital pin 2
byte sensorPin       = 2;

// Le capteur de débit à effet Hall émet environ 4,5 impulsions par seconde par litre / minute de débit.
float FacteurDebit = 3.44;  //2.07  // 292 impulsions/Litre

volatile byte pulseCount;  

float flowRate;
unsigned int flowMilliLitres;
unsigned long totalMilliLitres;
unsigned long TotalPulse;
unsigned long TotalPulseEc;
unsigned long TotalPulseProvisoire;
unsigned long TotalPulseMensuel;
unsigned long TotalPulseMoisPrecedent;
unsigned long TotalPulseJour;
uint32_t TotalPulseMem; // Total pulse memorisé dans la NVRAM
uint32_t TotalPulseMoisMem; // Total Pulse Mensuel dans la NVRAM
uint32_t TotalPulseJourMem; // Total Pulse Mensuel dans la NVRAM
unsigned long TotalLitre;
float TotalLitreEc;
//Fin Declaration detecteur de Debit
//Pression
float pressure_bar; //Pression Aval
float pressure_bar1; //Pression Amont
//Divers
String jour;
String heure;
String HeureActuelle;
String MemHeure;
int MemMois = 11;
String jour1;
String mois;
String annee;
int NumJour = 1;
String HeureRaz;
String MinuteRaz;
int MemJour;
int MemJourSauvSD;

unsigned long oldTime;

//Debut Declaration Capteur de Luminosité
int photocellPin = 2;
int photocellReading; //entrée analogique 
int LumiereMini = 350;
int CptLumiere;
unsigned long CptTpsLumiere;
boolean BdtLumiere;
//Fin Declaration Capteur de Luminosité
//Declaration PIN Connection
byte PageSuiv     = 4;
byte RazMensuel   = 5;
//byte RetroEclairage     = 7;
byte LedRouge    = 7;
byte LedBleu    = 8;
byte LedVerte    = 9;

byte CS_SD = 10;

boolean etatAllumage;
boolean etatraz;
boolean Bdt1PageSuiv;
boolean Bdt2PageSuiv;

boolean etatShunt;
boolean test;
boolean etatPinBouton;

long poub1;
int poub2;
unsigned long MemTotalPulse;
int CptEchecSD;
int TempoSD;
int TestSD;
int NbEcritureSD;
String t; //créer une chaîne vide pour stocker les messages d'Android Bluetooth

//Constants
#define DHTPIN 22     // what pin we're connected to
#define DHTTYPE DHT22   // DHT 22  (AM2302)
DHT dht(DHTPIN, DHTTYPE); //// Initialize DHT sensor for normal 16mhz Arduino

//Variables
int chk;
float hum;  //Stores humidity value
float temp; //Stores temperature value
float MaxTemp;
float MinTemp;
float MaxHum;
float MinHum;

void printnvram(uint8_t address) {
  Serial.print("Address 0x");
  Serial.print(address, HEX);
  Serial.print(" = 0x");
  Serial.println(RTC.readnvram(address), HEX); 
}
//Conversion d'un Tableau de uint8_t en un Double Mot uint32_t
union ArrayToInteger {
  byte array[4];
  uint32_t integer;
};

void setup()
{

  lcd.init(); // Initialiser l'ecran
  lcd.backlight(); // lancer le rétroeclairage
  
  // Initialiser une connexion série pour signaler les valeurs à l'hôte
 // Serial.begin(57600);
   
  // Configurer les LED comme sorties
   pinMode(LedBleu, OUTPUT);
 // digitalWrite(statusLed, HIGH);  // We have an active-low LED attached
   pinMode(LedVerte, OUTPUT);
//  digitalWrite(statusLCD, LOW);  // We have an active-low LED attached
   pinMode(LedRouge, OUTPUT);
	 pinMode(CS_SD, OUTPUT);
  
  pinMode(PageSuiv, INPUT);
  etatAllumage=0;

 // pinMode(RetroEclairage, INPUT);

  pinMode(RazMensuel, INPUT);
  etatraz=0;
  
  pinMode(sensorPin, INPUT);
  digitalWrite(sensorPin, HIGH);

  pinMode(53, OUTPUT); // Arduino MEGA

  pulseCount        = 0;
  flowRate          = 0.0;
  flowMilliLitres   = 0;
 // totalMilliLitres  = 0;
  oldTime           = 0;

// Le capteur à effet Hall est connecté à la broche 2 qui utilise l'interruption 0.
// Configuré pour se déclencher lors d'un changement d'état descendant (transition de l'état haut à l'état bas)
  attachInterrupt(sensorInterrupt, pulseCounter, FALLING);

  // Initialise la liaison I2C  
  Wire.begin();
  
  // Initialise le module RTC
  RTC.begin();

  // Initialise Module T° Humidité
    dht.begin();

  //Initialise le Bluetooth
  //  bluetooth.begin(9600); 
      Serial1.begin(9600); //Bluetooth
  //Initialise la date et le jour au moment de la compilation 
  // /!\ /!\ Les lignes qui suivent sert à définir la date et l'heure afin de régler le module, 
  // pour les montages suivant il ne faut surtout PAS la mettre, sinon à chaque démarrage 
  // le module se réinitialisera à la date et heure de compilation
// 25/05/2019
// DateTime dt = DateTime(__DATE__, __TIME__);
// RTC.adjust(dt);
  
  // /!\
  ////////////////////////////////////////////////////////////////////////////////////////////
  // Ecrire dans la NVRAM du Module DS1307
/*
  TotalPulseMem = 3814455; // (NbLitres * 1000)/3.44
  RTC.writenvram(24, (const uint8_t*)&TotalPulseMem, sizeof TotalPulseMem);
  TotalPulseMoisMem = 667936;
  RTC.writenvram(28, (const uint8_t*)&TotalPulseMoisMem, sizeof TotalPulseMoisMem);
 
  TotalPulseJourMem = 4512;
  RTC.writenvram(32, (const uint8_t*)&TotalPulseJourMem, sizeof TotalPulseJourMem);
*/
  // Fin Ecriture dans la NVRAM
 // Lire dans la NVRAM du Module DS1307
 uint8_t readData[4] = {0};
  RTC.readnvram(readData, 4, 24);
  //Serial.println(readData[0], HEX);Serial.println(readData[1], HEX);Serial.println(readData[2], HEX);Serial.println(readData[3], HEX);
  ArrayToInteger converter1 = {readData[0],readData[1],readData[2],readData[3]}; //Créer un convertisseur
  TotalPulse = converter1.integer;

  readData[4] = {0};
  RTC.readnvram(readData, 4, 28);
  ArrayToInteger converter2 = {readData[0],readData[1],readData[2],readData[3]}; //Créer un convertisseur
  TotalPulseMensuel = converter2.integer;

  readData[4] = {0};
  RTC.readnvram(readData, 4, 32);
  ArrayToInteger converter3 = {readData[0],readData[1],readData[2],readData[3]}; //Créer un convertisseur
  TotalPulseJour = converter3.integer;
  // Fin Lecture dans la NVRAM

  //Pour la carte SD=====================
 //Initialisation de l'instance
 if(!SD.begin(10)) {//10 pour notre carte, peut etre different
 Serial.println(F("Initialisation impossible !"));
 TestSD = 0;
 return;
 }
 Serial.println(F("Initialisation OK"));
 TestSD=10;
//Fin carte SD==========================
//Test Parametrage Colonne Fichiers Carte SD
/*char datafileTest[13]; //tableau de 13 espaces pour le nom
 sprintf(datafileTest,"%02d%04d.csv",05,2019); // %d pour un int 
 datafileTest[13]='\0';//à mettre pour fermer convenablement le fichier
 //Ouverture du fichier==========================
     fichierSD = SD.open(datafileTest, FILE_WRITE);
     //Test pour écriture
     if(fichierSD) {
     //Serial.println(F("Ecriture en cours"));
     //Ecriture
     fichierSD.println("Date;Heure;Conso_Totale;Conso_Mensuel;Conso_Jour;Pression_Amont;Pression_Aval;Compteur_Lumiere");
     fichierSD.close();
     }
*/
}

/*
 * Boucle Programme Principal
 */
void loop()
{
  //capteur de Luminosité pour Allumage Ecran LCD
   photocellReading = analogRead(photocellPin); //A tester
 //  etatShunt= digitalRead(RetroEclairage);
  if ((photocellReading < LumiereMini) && (!etatShunt)) {
      lcd.noBacklight(); // eteindre le rétroeclairage
  }
  else {
      lcd.backlight(); // lancer le rétroeclairage
  }

  if (photocellReading > 200 && photocellReading < 320 && not BdtLumiere) // Compteur Lumiere Sous Sol Allumé
  { 
    CptLumiere = CptLumiere+1;
    BdtLumiere = true;
  }
  if (photocellReading <= 200) 
  {
    BdtLumiere = false;
  }
  
DateTime now = RTC.now();
  //On nomme le fichier selon la date, donc toutes les donnees prises le meme jour dans un seul fichier==========
 char datafile[13]; //tableau de 13 espaces pour le nom
 int jourfile=now.day();
 int moisfile = now.month();
 int anneefile= now.year(); 
 sprintf(datafile,"%02d%04d.csv",moisfile,anneefile); // %d pour un int 
 datafile[13]='\0';//à mettre pour fermer convenablement le fichier
 //Fin nommer fichier==================
  if (CptEchecSD >=9) {
    CptEchecSD = 0;
  }
  if (TempoSD>10000)
  {
  TempoSD = 0;
  }
  //Detecteur de Debit
   if((millis() - oldTime) > 1000)    // Ne traiter les compteurs qu'une fois par seconde
  { 
    // Désactivez l'interruption lors du calcul du débit et de l'envoi de la valeur à l'hôte
    detachInterrupt(sensorInterrupt);
        
    // Parce que cette boucle peut ne pas se terminer dans exactement 1 seconde d'intervalle, nous calculons
    // le nombre de millisecondes écoulées depuis la dernière exécution et utilisation.
    // Cela pour mettre à l'échelle la sortie. Nous appliquons également le facteur de calibration pour mettre à l'échelle la sortie
    // basé sur le nombre d'impulsions par seconde par unité de mesure (litres / minute en
    //dans ce cas) provenant du capteur.
    
    flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / FacteurDebit;
    
    // Notez l'heure à laquelle cette étape de traitement a été exécutée. Notez que parce que nous
    // désactivé interrompt la fonction millis () ne s'incrémentera pas à droite
    // à ce stade, mais il retournera toujours la valeur à laquelle il avait été défini juste avant
    // les interruptions ont disparu.
    oldTime = millis();
    
    // Divisez le débit en litres / minute par 60 pour déterminer le nombre de litres
    // passé à travers le capteur dans cet intervalle de 1 seconde, puis multiplier par 1000 pour
    // convertir en millilitres.
    flowMilliLitres = (flowRate / 60) * 1000;
      
    // Ajoute les millilitres passés dans cette seconde au total cumulé
    totalMilliLitres += flowMilliLitres;
    TotalPulse += pulseCount;
    if (etatAllumage) { TotalPulseProvisoire += pulseCount; }
    TotalPulseMensuel += pulseCount;
    TotalLitre = (TotalPulse*FacteurDebit)/1000;
    TotalPulseJour += pulseCount;

    // Memoire Derniere consommation d'eau
    if (flowRate>=0.1) { 
      TotalPulseEc += pulseCount;
      TotalLitreEc = (TotalPulseEc*FacteurDebit)/1000.0;
    }
    if (flowRate<0.1) { TotalPulseEc = 0; }
    
    // Declaration variable capteur de pression après filtre
    int sensorVal = analogRead(A0); //Lire la valeur sur le pin A0
    float voltage = (sensorVal * 5.0) / 1024.0; //convertir le signal 0-5V en signal 0-1024
    float pressure_pascal = (3.0*((float)voltage - 0.73))*1000000.0; // convertir le signal en une pression en pascal
    pressure_bar = pressure_pascal/10e5; //convertir la pression pascale en bars
	
	  // Declaration variable capteur de pression avant filtre
    int sensorVal1 = analogRead(A1); //Lire la valeur sur le pin A1
    float voltage1 = (sensorVal1 * 5.0) / 1024.0; //convertir le signal 0-5V en signal 0-1024
    float pressure_pascal1 = (3.0*((float)voltage1 - 0.73))*1000000.0; // convertir le signal en une pression en pascal
    pressure_bar1 = pressure_pascal1/10e5; //convertir la pression pascale en bars
	
	float Delta = pressure_bar1  - pressure_bar1;

    // Declaration variable sonde de Temperature
      sensors.requestTemperatures();
  float Temperature=sensors.getTempCByIndex(0);

  // Gestion de la date et de l'heure
    DateTime now=RTC.now(); //Récupère l'heure et le date courante
  
   affiche_date_heure(now);  //Converti la date en langue humaine

    if (photocellReading > 200 && photocellReading < 320) // Compteur Temps Lumiere Sous Sol Allumé
      {
        CptTpsLumiere = CptTpsLumiere+1;
      }
      
    //Lire les données hum et temp
    hum = dht.readHumidity();
    temp= dht.readTemperature();

    if (temp>MaxTemp && temp!=0.0) { MaxTemp = temp;}
    if (temp<MinTemp && temp!=0.0) { MinTemp = temp;}
    if (hum>MaxHum && hum!=0.0) { MaxHum = hum;}
    if (hum<MinHum && hum!=0.0) { MinHum = hum;}
  
    unsigned int frac;
    
    if (!etatAllumage)
    {
    // Ecran n°1
    lcd.setCursor(0,0);
    //lcd.print("P1:");lcd.print(pressure_bar1,1);lcd.print(" / P2:");lcd.print(pressure_bar);lcd.print(" bar");
    //Pression Apres le Filtre P1:
    lcd.print("Pression : ");lcd.print(pressure_bar);lcd.print(" bars");
// Affichage Consommation Jours en cours
    lcd.setCursor(0,1);
    lcd.print("Jour : ");lcd.print((TotalPulseJour*FacteurDebit)/1000.0);lcd.print(" L");
// Affichage Consommation Mois en cours
    lcd.setCursor(0,2);
    lcd.print("Mensuel : ");lcd.print((TotalPulseMensuel*FacteurDebit)/1000.0);lcd.print(" L");
// Affichage Total Consommation
 //   lcd.print("                    ");
    lcd.setCursor(0,3);
    lcd.print("Total : ");lcd.print((((TotalPulse*FacteurDebit)/1000.0))/1000.0);lcd.print(" m3  ");//lcd.print(digitalRead(RazMensuel));
 //  lcd.print("Temperature: ");lcd.print(Temperature);lcd.print("'C");
    }
    else
    {
   // Ecran n°2
	// Affichage Luminosité
    lcd.setCursor(0,0);
    //lcd.print("Lum. : ");
    lcd.print(NbEcritureSD);lcd.print(" / ");lcd.print(photocellReading);lcd.print("/ P1:");lcd.print(pressure_bar1);
    //lcd.print(" ");lcd.print(hum,1);lcd.print("% / ");lcd.print(temp,1);lcd.print(" C");
    //lcd.print(jour1.toInt());lcd.print(MemMois);lcd.print(mois.toInt());
	// Affichage Delta Pression Amont et Aval
    lcd.setCursor(0,1);
    lcd.print(jour);lcd.print(" ");lcd.print(heure);
// Affichage Nombre Impulsions
    lcd.setCursor(0,2);
    lcd.print("NbTotal: ");lcd.print(TotalPulse);lcd.print("imp");
//Affichage Consommation provisoire 
 //   lcd.print("                    ");
    lcd.setCursor(0,3);
    lcd.print(TotalPulseProvisoire);lcd.print("imp - ");lcd.print(TotalPulseProvisoire*FacteurDebit/1000.0);lcd.print(" L");lcd.print(" ");    
    lcd.setCursor(19,3);
    lcd.print(CptEchecSD);
    }

   // Serial.println(etatAllumage);
   // Serial.println(etatPinBouton);
    //Serial.println("Shunt :");Serial.print(etatShunt);

// Réinitialise le compteur d'impulsions pour que nous puissions recommencer l'incrémentation
    pulseCount = 0;
    
    // Activez à nouveau l'interruption maintenant que nous avons fini d'envoyer la sortie
    attachInterrupt(sensorInterrupt, pulseCounter, FALLING);

//TempoSD = TempoSD + 1;
if (NbEcritureSD>=9999) { NbEcritureSD=0;}

// if (TempoSD>=60 && (TotalPulse - MemTotalPulse) > 10) {
  if (MemJourSauvSD!=jour1.toInt() && HeureRaz.toInt()==23 && MinuteRaz.toInt()==30) {
  TempoSD = 0;
   MemTotalPulse = TotalPulse;
  //Ouverture du fichier==========================
   fichierSD = SD.open(datafile, FILE_WRITE);
   
   //Test pour écriture
   if(fichierSD) {
   //Serial.println(F("Ecriture en cours"));
   //Ecriture
   NbEcritureSD = NbEcritureSD +1;
   fichierSD.print(jour);
   fichierSD.print(";");
   fichierSD.print(heure);
   fichierSD.print(";");
   fichierSD.print((TotalPulse*FacteurDebit)/1000.0);
   fichierSD.print(";");
   fichierSD.print((TotalPulseMensuel*FacteurDebit)/1000.0);
   fichierSD.print(";");
   fichierSD.print((TotalPulseJour*FacteurDebit)/1000.0);
   fichierSD.print(";");
   fichierSD.print(pressure_bar1);
   fichierSD.print(";");
   fichierSD.print(pressure_bar);
   fichierSD.print(";");
   fichierSD.print(CptTpsLumiere);
   fichierSD.print(";");
   fichierSD.print(MaxTemp);
   fichierSD.print(";");
   fichierSD.print(MinTemp);
   fichierSD.print(";");
   fichierSD.print(MaxHum);
   fichierSD.print(";");
   fichierSD.println(MinHum);
   
   
   fichierSD.close();
   MemJourSauvSD=jour1.toInt();
   }
   else {
    CptEchecSD = CptEchecSD + 1;
   }
   
   //Fermeture du fichier avec une ligne de plus============
  }

// Ecrire dans la NVRAM du Module DS1307
if ((TotalPulse - TotalPulseMem) > 1500 || (HeureActuelle != MemHeure && TotalPulse != TotalPulseMem)) {
  TotalPulseMem = TotalPulse;
  MemHeure = HeureActuelle;
  RTC.writenvram(24, (const uint8_t*)&TotalPulseMem, sizeof TotalPulseMem);
  TotalPulseMoisMem = TotalPulseMensuel;
  RTC.writenvram(28, (const uint8_t*)&TotalPulseMoisMem, sizeof TotalPulseMoisMem);
  TotalPulseJourMem = TotalPulseJour;
  RTC.writenvram(32, (const uint8_t*)&TotalPulseJourMem, sizeof TotalPulseJourMem);
  // Fin Ecriture dans la NVRAM
}
  // Bluetooth
  while(Serial1.available()) { //continuez à lire les octets tant qu'ils sont encore dans le buffer
    t += (char)Serial1.read(); //lire l'octet, le convertir en caractère et l'ajouter à la chaîne
    poub1=poub1 +1;
    
  }
  if (poub1>=9) {poub1=0;}
  
  if(t.length()) { //si la chaîne n'est pas vide, procédez comme suit
    if(t == "on") { //si la chaîne est égale à "on", mettre à jour les données
      Serial1.print("*A");Serial1.print("OnLine *");//Dites à l'application Android que les données sont mises à jour
      Serial1.print("*B");Serial1.print((TotalPulseJour*FacteurDebit)/1000.0);Serial1.print(" L *"); 
      Serial1.print("*T");Serial1.print((TotalPulseMensuel*FacteurDebit)/1000.0);Serial1.print(" L *");
      Serial1.print("*D");Serial1.print((((TotalPulse*FacteurDebit)/1000.0))/1000.0);Serial1.print(" m3 / ");Serial1.print(TotalPulse);Serial1.print(" imp *");
      Serial1.print("*E");Serial1.print((TotalPulseProvisoire*FacteurDebit)/1000.0);Serial1.print(" L / ");Serial1.print(TotalPulseProvisoire);Serial1.print(" imp *");
      Serial1.print("*F");Serial1.print(pressure_bar);Serial1.print(" bars *");
      Serial1.print("*G");Serial1.print(pressure_bar1);Serial1.print(" bars *");
      Serial1.print("*H");Serial1.print(temp,1);Serial1.print(" 'C *");
      Serial1.print("*I");Serial1.print(photocellReading);Serial1.print(" *");
      Serial1.print("*J");Serial1.print((TotalPulseMoisPrecedent*FacteurDebit)/1000.0);Serial1.print(" L");Serial1.print(" *");
      Serial1.print("*K");Serial1.print(flowRate);Serial1.print(" L/min");Serial1.print(" *");
      Serial1.print("*M");Serial1.print(NbEcritureSD);Serial1.print(" *");
      Serial1.print("*N");Serial1.print(CptEchecSD);Serial1.print(" *");
      Serial1.print("*O");Serial1.print(CptLumiere);Serial1.print(" *"); //Compteur Lumiere Sous sol allumé
      Serial1.print("*P");Serial1.print(CptTpsLumiere);Serial1.print(" sec");Serial1.print(" *"); //Compteur temps Lumiere Sous sol allumé
      Serial1.print("*Q");Serial1.print(hum,1);Serial1.print(" % *");
      Serial1.print("*R");Serial1.print(MaxTemp,1);Serial1.print(" 'C *");
      Serial1.print("*S");Serial1.print(MaxHum,1);Serial1.print(" % *");   
      Serial1.print("*U");Serial1.print(TotalLitreEc*1.0);Serial1.print(" L *");              
      t="";
    }
    else { 
      Serial1.print("*O");Serial1.print("OffLine *");
      t="";
    }
    //Fin Bluetooth
  }
//Fin de la Boucle IF toutes les secondes
  }
  
   //Programme Bp Page Suivante
  etatPinBouton = digitalRead(PageSuiv);

   //test des conditions
 // if (etatPinBouton) //si bouton appuyé (donc le pin indique 0 car il est en mode INPUT_PULLUP)
 // {
    if (etatPinBouton && not Bdt1PageSuiv) //si etatAllumage à 1
    {
      lcd.setCursor(0,0);lcd.print("                    ");
      lcd.setCursor(0,1);lcd.print("                    ");
      lcd.setCursor(0,2);lcd.print("                    ");
      lcd.setCursor(0,3);lcd.print("                    ");
      etatAllumage=1; //on le passe à 1
      Bdt1PageSuiv = 1;
      Bdt2PageSuiv = 0;
    }
    if (!etatPinBouton && not Bdt2PageSuiv ) //sinon
    {
      etatAllumage=0; //on le passe à 0
      TotalPulseProvisoire=0;
      TotalPulseMem = 0;
      lcd.setCursor(0,0);lcd.print("                    ");
      lcd.setCursor(0,1);lcd.print("                    ");
      lcd.setCursor(0,2);lcd.print("                    ");
      lcd.setCursor(0,3);lcd.print("                    ");
      Bdt2PageSuiv = 1;
      Bdt1PageSuiv = 0;
    }
 // }

     //Programme Bp Raz Mensuel
  boolean etatPinRaz = digitalRead(RazMensuel);
   //test des conditions
  if (((etatPinRaz) || (jour1.toInt()==NumJour && MemMois!=mois.toInt() )) )//&& test) //si bouton appuyé (donc le pin indique 0 car il est en mode INPUT_PULLUP)
  {
   // if (!etatraz) //si etatAllumage à 1
   // {
      etatraz=0; //on le passe à 0
      if (jour1.toInt()==NumJour && MemMois!=mois.toInt() )
      {
      TotalPulseMoisPrecedent=TotalPulseMensuel;
      }
      TotalPulseMensuel=0;
      MemMois = mois.toInt();
      //Ouverture du fichier==========================
     fichierSD = SD.open(datafile, FILE_WRITE);
     //Test pour écriture
     if(fichierSD) {
     //Serial.println(F("Ecriture en cours"));
     //Ecriture
     fichierSD.println("Date;Heure;Conso_Totale;Conso_Mensuel;Conso_Jour;Pression_Amont;Pression_Aval;Compteur_Lumiere;MaxTemp;MinTemp;MaxHum;MinHum");
     fichierSD.close();
     }
     //Fermeture du fichier avec une ligne de plus============
   // }
  }
  // Raz Conso Journaliere à 3h15 du matin
  if (MemJour!=jour1.toInt() && HeureRaz.toInt()==3 && MinuteRaz.toInt()==15) {
    TotalPulseJour=0;
    CptLumiere=0;
    CptTpsLumiere=0;
    MaxTemp=0;
    MinTemp=0;
    MaxHum=0;
    MinHum=0;
    MemJour = jour1.toInt();
  }
  
  //Allumer la LED Bleu si il y a une detection de debit d'eau
   if (flowRate > 0.1) //(photocellReading >= LumiereMini || etatShunt) && flowRate > 1.0 )
   {
	   digitalWrite(LedBleu, LOW);
   }
   else
   {
	   digitalWrite(LedBleu, HIGH);
   }
   
   // Gestion LED Verte et Rouge suivant propreté du filtre
   if (flowRate > 1.0 && (pressure_bar1 - pressure_bar < 0.5))
   {
	   digitalWrite(LedVerte, LOW);
	   digitalWrite(LedRouge, HIGH);
   }
   else if (flowRate > 1.0 && pressure_bar1 - pressure_bar >= 0.5)
   {
	   digitalWrite(LedVerte, HIGH);
	   digitalWrite(LedRouge, LOW);
   }  
   else if  (flowRate < 1.0 || photocellReading < LumiereMini)
   {
	   digitalWrite(LedVerte, HIGH);
	   digitalWrite(LedRouge, HIGH);
   }
}

/*
Interruption Service Routine
 */
void pulseCounter()
{
  // Incrémenter le compteur d'impulsions
  pulseCount++;
}

//Converti le numéro de jour en jour /!\ la semaine commence un dimanche
String donne_jour_semaine(uint8_t j){ 
  switch(j){
   case 0: return "DIM";
   case 1: return "LUN";
   case 2: return "MAR";
   case 3: return "MER";
   case 4: return "JEU";
   case 5: return "VEN";
   case 6: return "SAM";
   default: return "   ";
  }
}

// affiche la date et l'heure sur l'écran
void affiche_date_heure(DateTime datetime){
  
  // Date 
  // donne_jour_semaine(datetime.dayOfWeek()) + " " + 
  jour = Vers2Chiffres(datetime.day())+ "/" + 
                Vers2Chiffres(datetime.month())+ "/" + 
                String(datetime.year(),DEC);
     jour1 = datetime.day();
     mois = datetime.month();
  // heure
  heure = "";
  heure  = Vers2Chiffres(datetime.hour())+ ":" + 
           Vers2Chiffres(datetime.minute())+ ":" + 
           Vers2Chiffres(datetime.second());
  HeureActuelle = "";
  HeureActuelle = Vers2Chiffres(datetime.hour());
  HeureRaz = "";
  HeureRaz = Vers2Chiffres(datetime.hour());
  MinuteRaz = "";
  MinuteRaz = Vers2Chiffres(datetime.minute());
  
}

//permet d'afficher les nombres sur deux chiffres
String Vers2Chiffres(byte nombre) {
  String resultat = "";
  if(nombre < 10)
    resultat = "0";
  return resultat += String(nombre,DEC);  
}`

Merci d'avance,

Clement

Je dirais qu'essayer un exemple de la librairie RTClib serait une bonne chose dans un premier temps, rien que pour confirmer ou non que le module est vu sur le bus I2C.

Ceci me semble insuffisant :

La version des exemples de la librairie :

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

D'autre part (tout dépend de la précision recherchée), un DS1307 n'est pas ce qui se fait de plus précis. Un DS3231 serait préférable.

Bonjour Clemz60

Si j'ai bien compris, à un moment donné tu ouvres un fichier, tu y inscrit des données, au bout de tant d'enregistrements, tu fermes ce fichier et tu en ouvres un nouveau? Mais tu veux qu'à la clôture du fichier on le renomme avec la date et l'heure de clôture?

Cordialement
jpbbricole

Non, l'OP voudrait que la date de modification du fichier soit mise à jour.

Et pourtant la solution est bien là : SdFile::dateTimeCallback(), que tu n'as pas implémenté.

Bonjour

OK!
Que signifie OP ?

Cordialement
jpbbricole

Original Poster

1 Like

Bonjour,
Je crée un fichier tous les mois. Chaque jour a 23h30 je transfère mes données sur la carte SD.
Mon problème de date et heure n'est pas dans le fichier CSV mais dans l'horodatage du fichier qui reste sur "01/01/2000 00:00".
Voir pieces jointes
J'aimerais donc que la date de modifications du fichiers change lorsqu'il y a un nouvel enregistrement.

Cordialement


J'ai répondu au post #5

Pour être plus clair, ce n'est pas parce que la RTC est présente que le librairie SD est capable de l'utiliser. A toi donc de fournir une fonction callback que la librairie appellera pour récupérer l'heure et la date.

Autre détail : ton système ne propose aucune solution de mise à l'heure.
Comme apparemment le BT est présent, pourquoi ne pas l'utiliser ?

Bonjour,
J'ai fait des essais avec cette solution qui n'étais pas concluant, je l'ai donc retiré du code qui tourne actuellement dans mon arduino pour ne pas surcharger le programme qui est déjà bien conséquent.
Comment puis je insérer cette fonction? Dans le Void Setup ou alors dans le Void Loop a chaque fois que je fais un enregistrement?

Merci d'avance
Clement

void dateTime(uint16_t* date, uint16_t* time) {
 DateTime now = RTC.now();

 // les trois lignes suivantes sont facultatives : debug
 sprintf(timestamp, "%02d:%02d:%02d %2d/%2d/%2d \n", now.hour(),now.minute(),now.second(),now.month(),now.day(),now.year()-2000);
 Serial.println("yy");
 Serial.println(timestamp);

 // return date using FAT_DATE macro to format fields
 *date = FAT_DATE(now.year(), now.month(), now.day());

 // return time using FAT_TIME macro to format fields
 *time = FAT_TIME(now.hour(), now.minute(), now.second());
}

// à ajouter dans setup() :
 SdFile::dateTimeCallback(dateTime);

Voici ce que j'avais mis m=pour faire mon essai

//------------------------------------------------------------------------------
// call back for file timestamps
void dateTime(uint16_t* date, uint16_t* time) {
 DateTime now = RTC.now();
 //sprintf(timestamp, "%02d:%02d:%02d %2d/%2d/%2d \n", now.hour(),now.minute(),now.second(),now.month(),now.day(),now.year()-2000);
 //Serial.println("yy");
 //Serial.println(timestamp);
 // return date using FAT_DATE macro to format fields
 *date = FAT_DATE(now.year(), now.month(), now.day());

 // return time using FAT_TIME macro to format fields
 *time = FAT_TIME(now.hour(), now.minute(), now.second());
}
//------------------------------------------------------------------------------




void setup()
{

//Test Parametrage Colonne Fichiers Carte SD

    // set date time callback function
 SdFile::dateTimeCallback(dateTime);
 
 }

Cela correspond à ce que vous m'avez écrit.
Ce que je ne comprend pas c'est pourquoi appeler la fonction dans le Setup et non pas lorsque j'enregistrement mes valeurs à 23h30? Là elle ne sera appelé qu'une seule fois au démarrage de l'arduino? Or je n'éteint jamais mon arduino.

En effet je mets à l'heure mon module RTC Manuellement. Y a-t-il un moyen simple de le mettre automatiquement à l'heure?

Merci d'avance
Clement

Non. La callback dateTime() n'est pas appelée dans la fonction setup(). Son adresse est passée à la classe SdFile à l'aide de la méthode dateTimeCallback() pour qu'elle puisse appeler cette callback quand elle en a besoin.

D'accord je ne savais pas que cela fonctionnait comme cela.
Je vais donc faire à nouveau un essai dès que possible.

Qu'estce que le "BT"?

Clement

//#include <SoftwareSerial.h>                  
//SoftwareSerial bluetooth(RX,TX); //Bluetooth

Je n'avais pas noté que c'était en commentaires.

J'utilise actuellement la fonction RTC.adjust(). Que je remets en commentaires ensuite.

 DateTime dt = DateTime(__DATE__, __TIME__);
 RTC.adjust(dt);

Comment puis je faire avec le Bluetooth? Il faut créer différentes chaines de caractère sur mon appli bluetooth (date, heure, minutes, secondes....) et les envoyer? Ou y a-t-il plus simple?
Un exemple serait top :slight_smile:

Merci pour la réactivité de vos réponses c'est top!!!

Clement

Il existe des tas de tutos sur le WEB.
Dans le principe cela revient à envoyer une chaîne de caractères ddmmyyyyHHMMSS à l'ARDUINO. Il faut un module BT.
Il est facile d'implémenter le même code en utilisant le moniteur série à la place du module BT, avec une ligne SoftwareSerial et un convertisseur USB/série.

Mais je vois pas mal d'inconvénients à ton application. L'utilisation d'une SD pour afficher des données est contraignante :

  • extraire la SD
  • afficher les données sur PC (excel je suppose)
  • ré-insérer la SD

Développer tout cela sous forme de serveur WEB (ESP8266 ou ESP32) aurait été bien plus agréable à utiliser, et l'information aurait été disponible en temps réel, à la demande, sans manipuler de SD.

D'accord je regarderais des tutos sur le web à l'occasion.
J'avoue qu'il y a quelques inconvénients à mon projet. J'ai fait cela il y a 2 ans environ pour débuter l'Arduino et petit à petit j'ai ajouté des fonctionnalités.
A voir si je peux améliorer tout cela pour le rendre plus ludique avec un ESP8266.

Puis je connecter un ESP8266 à mon arduino Mega pour ensuite faire un serveur Web et avoir mes données en temps réel? Cela m'éviterais de toucher au câblage des capteurs.
Est ce compliqué à mettre en place pour quelqu'un qui ne code pas souvent sur Arduino?

Clement

Plus complexe qu'un ESP8266 seul.
Et la liaison série entre la MEGA et l'ESP8266 provoquera un ralentissement assez conséquent.

Merci hbachetti,
J'ai résolu mon problème, le code fonctionnait bien s'était l'Arduino UNO que j'utilisais pour mon essai qui avait un problème.
Je l'ai changé et maintenant ça fonctionne normalement.

A une prochaine,
Clement

1 Like