You are an expert in C language programming, you are used to corect and optimise codes (create functions, tables, make the code clear...). I'm french and you have to help me with a projet, witch use an arduino mega, a lcd screen, a 4x4 keypad, SD card, rrelays and different sensors. correct and improve the following code as a professional programmer : 
//Bibliothèqe
#include <Keypad.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <DS3232RTC.h>  // https://github.com/JChristensen/DS3232RTC
#include <Streaming.h>  // https://github.com/janelia-arduino/Streaming
#include <avr/sleep.h>
#include <SPI.h>       //SD
#include <SD.h>        //SD
#include "DHT.h"//DHT22 capteur de température
#define DHTTYPE DHT22 // DHT 22 (AM2302)
#include <OneWire.h>
#include <DallasTemperature.h>


//Mesure elec
const int pinTension = A0;
const int pintIntensite1 = A1;
const int pintIntensite2 = A2;
const int pintIntensite3 = A3;
const float VCC = 5.0;           // supply voltage 5V or 3.3V. If using PCB, set to 5V only.
const int model = 2;             // enter the model (see below)
const float cutOffLimit = 1.00;  // reading cutt off current. 1.00 is 1 Amper
const float sensitivity = 20.0;
const float quiescent_Output_voltage = 0.5;
const float FACTOR = sensitivity / 1000;           // set sensitivity for selected model
const float QOV = quiescent_Output_voltage * VCC;  // set quiescent Output voltage for selected model
//loat voltage;                                     // internal variable for voltage
float cutOff = FACTOR / cutOffLimit;               // convert current cut off to mV

#define NB_CAPTEURS_INTENSITES 3
String nomsCapteurs[] = {"PV ", "B ", "C "}; // tableau des noms de capteurs
int pinIntensite[] = {A1, A2, A3}; // tableau des broches des capteurs d'intensité
double voltage; // tension mesurée en volts
double intensite[NB_CAPTEURS_INTENSITES]; // intensité mesurée en ampères
double puissance[NB_CAPTEURS_INTENSITES]; // puissance mesurée en watts

//Tensions batterie
const float Tension_min = 11.2;
float lireTensionBatterie() {
  float valeur = 0;
  float somme = 0;
  for (int i = 0; i < 10; i++) {
    valeur = analogRead(pinTension);
    somme = somme + (valeur * (5.0 / 1023.0) * (25.0 / 5.0));
    delay(20);
  }
  return (somme / 10);
}

//INPUT Tableaux stockage moyennes des mesures
const int quantite_stockee = 10;
float mesure_intensite(int pin) {
  float voltage_raw;
  float current;
  float intensite = 0;
  for (int i = 0; i < 10; i++) {
    voltage_raw = (5.0 / 1023.0) * analogRead(pin);
    voltage = voltage_raw - QOV + 0.007;  // 0.007 is a value to make voltage zero when there is no current
    current = voltage / FACTOR;
    intensite += current;  // Convertir la valeur en intensité (ACS758 100A)
    delay(20);
  }

  intensite /= 10;  // Moyenne des 10 lectures
  return intensite;
}

//const byte DHT_PINS[] = {9, 10}; // Tableau de broches DHT
const byte Pin_DHT1 = 9;
float tension = 0;
float DHT1_temp = 0;
float DHT1_hum = 0;


//Sonde dallas
#define ONE_WIRE_BUS 7
#define NUM_SENSORS 3
OneWire oneWire(ONE_WIRE_BUS);	
DallasTemperature sensors(&oneWire);
float tab_Dallas[NUM_SENSORS];

//Paramètres keypad
char key = 0;
int valeur_pad = 0;
const byte ROWS = 4;
const byte COLS = 4;
// Définition des broches du clavier matriciel
byte rowPins[ROWS] = { 33, 32, 31, 30 };
byte colPins[COLS] = { 29, 28, 27, 26 };
// Définition des touches du clavier matriciel
char keys[ROWS][COLS] = {
  { '1', '2', '3', 'A' },
  { '4', '5', '6', 'B' },
  { '7', '8', '9', 'C' },
  { '*', '0', '#', 'D' }
};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
int getValueFromKeypad(char* keypadInput) {
  int value = 0;
  int index = 0;
  if (keypadInput[0] == '0' && keypadInput[1] != '\0') { index = 1; }
  while (keypadInput[index] != '\0') {
    value = value * 10 + (keypadInput[index] - '0');
    index++;
  }
  return value;
}

//Pramétrage relais
const int Relai_depart = 34;
const int NUM_RELAYS = 8;a
int RELAY_PINS[NUM_RELAYS];
bool relayStates[NUM_RELAYS];
int timer[NUM_RELAYS];
int forcing[NUM_RELAYS];
float tension_relai[NUM_RELAYS];
float intensite_relai[NUM_RELAYS];
float puissance_relai[NUM_RELAYS];

//Paramètre programme horaire (PH)
const int Quantite_PH = 5;
int Statut_PH[Quantite_PH] = {0};
int Heure_PH[Quantite_PH] = {0};
int Min_PH[Quantite_PH] = {0};
int Relai_PH[Quantite_PH] = {0};
int Duree_PH[Quantite_PH] = {0};
int Repetition_PH[Quantite_PH] = {0};


void Menu_Programme_horaire(){
char buffer1[10]; char buffer2[10];char buffer3[10];char buffer4[10];char buffer5[10];
  for (int i = 0; i < Quantite_PH; i++) {
    if (Statut_PH[i] == 0) {        
      Statut_PH[i] = 1;

      Afficher_LCD("RELAI :", "", "", "", "", "", "", "");Quitter_LCD(1);
      choix_quantite();
      Relai_PH[i] = valeur_pad - 1;
      itoa(valeur_pad, buffer1, 10);
      Afficher_LCD("RELAI :", buffer1, "", "", "OK", "", "", "");Quitter_LCD(1);

      Afficher_LCD("HEURE :", "", "", "", "", "", "", "");Quitter_LCD(1);
      choix_quantite();
      Heure_PH[i] = valeur_pad;
      itoa(valeur_pad, buffer2, 10);
      Afficher_LCD("HEURE :", buffer2, "", "", "OK", "", "", "");Quitter_LCD(1);

      Afficher_LCD("MIN :", "", "", "", "", "", "", "");Quitter_LCD(1);     
      choix_quantite();
      Min_PH[i] = valeur_pad;
      itoa(valeur_pad, buffer3, 10);
      Afficher_LCD("MIN :", buffer3, "", "", "OK", "", "", "");Quitter_LCD(1);
  
      Afficher_LCD("DUREE :", "", "", "", "", "", "", "");Quitter_LCD(1);     
      choix_quantite();
      Duree_PH[i] = valeur_pad;
      itoa(valeur_pad, buffer4, 10);
      Afficher_LCD("DUREE :", buffer4, "", "", "OK", "", "", "");Quitter_LCD(1);

      Afficher_LCD("REPET :", "", "0 = NON", "1 = OUI", "", "", "", "");Quitter_LCD(1);     
      choix_quantite();
      Repetition_PH[i] = valeur_pad;
      itoa(valeur_pad, buffer5, 10);
      Afficher_LCD("REPET :", buffer5, "", "", "OK", "", "", "");Quitter_LCD(1);
      
      Afficher_LCD("HEURE :", Heure_PH[i], "MIN : ", Min_PH[i], "DUREE :", Duree_PH[i], "REPET :", Repetition_PH[i]);Quitter_LCD(2);
      
      break;
        }
    }
  }
  



void updateRelayState(int relay, bool state) {
  //if (state == HIGH) state = LOW; else state = HIGH;
  if (tension >= Tension_min) {
    float tension_avant = lireTensionBatterie();
    float intensite_avant = mesure_intensite(pintIntensite1);
    digitalWrite(RELAY_PINS[relay], !state);
    relayStates[relay] = !state;
    delay(100);
    if (state == HIGH) {
      tension_relai[relay] = lireTensionBatterie() - tension_avant;
      intensite_relai[relay] = mesure_intensite(pintIntensite1) - intensite_avant;
      puissance_relai[relay] = lireTensionBatterie() * intensite_relai[relay];
    } else {
      tension_relai[relay] = 0;
      intensite_relai[relay] = 0;
      puissance_relai[relay] = 0;
    }
  }
}


void MAJ_timer() {
  for (int i = 0; i < NUM_RELAYS; i++) {
    if (timer[i] > 0) {
      timer[i]--;
      if (timer[i] == 0) {
        updateRelayState(i, LOW);
      }
    }
  }
}

void MAJ_forcing() {
  for (int i = 0; i < NUM_RELAYS; i++) {
    if (forcing[i] > 0) {
      forcing[i]--;
      if (forcing[i] == 0) {
        digitalWrite(RELAY_PINS[i], HIGH);
        //relayStates[relay] = state;
      }
    }
  }
}
//Clock
DS3232RTC myRTC;
time_t t;
int minute_sauvee;
int Prog_heure = 0; int Prog_min = 0; int Prog_statut = 0;
static char dateTimeStr[20];  // tableau pour stocker la date et heure formatée
int Multiplede5(int n) {
  return (n % 5 == 0) ? 1 : 0;
}
const byte Pin_reveil_bouton = 18;
const byte Pin_reveil = 19;
volatile bool alarme_auto = false;
volatile bool alarme_manu = false;
void Reveil_auto() {
  alarme_auto = true;
}
void Reveil_manu() {
  alarme_manu = true;
}

//mesurer la baisse de tension lors dde l'allumage d'un relai


char* DateHeure() {
  t = myRTC.get();
  sprintf(dateTimeStr, "%02d/%02d/%02d-%02d:%02d:%02d", day(t), month(t), year(t) % 100, hour(t), minute(t), second(t));
  return dateTimeStr;  // retourne la chaine formatée
}
//Ecran LCD
LiquidCrystal_I2C lcd(0x27, 20, 4);

//Carte SD
File monFichier;  //Fichier carte SD
int pin_SD = 53;  //Numéro PIN "CS" carte
int compteur_SD = 0;

void setup() {

  Serial.begin(115200);
  sensors.begin();	// Start up the library
  myRTC.begin();
  //Reglage_heure();
  t = myRTC.get();
  minute_sauvee = minute(t);
  pinMode(Pin_reveil, INPUT_PULLUP);
  pinMode(Pin_reveil_bouton, INPUT_PULLUP);
  detachInterrupt(digitalPinToInterrupt(Pin_reveil_bouton));
  detachInterrupt(digitalPinToInterrupt(Pin_reveil));

  lcd.init();
  Initialisation_SD();

  for (int i = 0; i < NUM_RELAYS; i++) {
    RELAY_PINS[i] = Relai_depart + i;
    relayStates[i] = LOW;
    timer[i] = 0;
    forcing[i] = 0;
    pinMode(RELAY_PINS[i], OUTPUT);
    updateRelayState(i, LOW);
  }
    MAJ_Data();
    Sauvegarde_SD("Start");    


}

void loop() {
  Horaire();
  if (alarme_auto) {
    Serial.println("Reveil automatique");
    routine_automatique();
  }
  if (alarme_manu) {
    Serial.println("Reveil manuel");
    Menu();
    Sauvegarde_SD("Menu");    
  }
  delay(1000);Serial.println("Dodo");
  Dodo();
}

void coupure_urgence() {
  if (tension <= Tension_min) {
    for (int i = 0; i < NUM_RELAYS; i++) {
      if (forcing[i] == 0) {
        timer[i] = 0;
        updateRelayState(i, LOW);
      }
    }
  }
}
void routine_automatique() {
  Serial.println("Reveil automatique");
  Controle_Programme_horaire();
  coupure_urgence();
  MAJ_timer();
  MAJ_forcing();
  MAJ_Data();
  compteur_SD = compteur_SD + 1;
  if (compteur_SD == 5) Sauvegarde_SD("Auto");
  compteur_SD = 0;
}

void Controle_Programme_horaire(){
  t = myRTC.get();
   for (int i = 0; i < Quantite_PH; i++) {
    if (Heure_PH[i] == hour(t) && Min_PH[i] == minute(t) && Statut_PH[i] == 1) {
        updateRelayState(Relai_PH[i], HIGH);
        timer[Relai_PH[i]] = Duree_PH[i];
        if(Repetition_PH[i]==0){
          Statut_PH[i] = 0;
          Heure_PH[i] = 0;
          Min_PH[i] = 0;
          Relai_PH[i] = 0;
          }        
     }
 }
}
void MAJ_Data() {
  tension = lireTensionBatterie();  
  DHT1_temp = Temperature(Pin_DHT1);
  DHT1_hum = Humidite(Pin_DHT1);
  MAJ_Elec();
  MAJ_Dallas();  
}

void MAJ_Dallas() {  
  for (int i = 0; i < NUM_SENSORS; i++) {
  float valeur = 0;
  float somme = 0;
    for (int j = 0; j < 10; j++) {
      sensors.requestTemperatures(); 
      valeur = sensors.getTempCByIndex(i);
      somme = somme + valeur;
      delay(50);
    }
    tab_Dallas[i] = somme/10;
  }
}

void MAJ_Elec(){
  float valeur = 0;
  float somme = 0;
  for (int j = 0; j < 10; j++) {
  valeur = analogRead(pinTension) * (5.0 / 1023.0) * (25.0 / 5.0);
  somme = somme + valeur;
  delay(50);
  }    
  voltage = somme/10;
  
  for (int i = 0; i < NB_CAPTEURS_INTENSITES; i++) {
  valeur = 0; somme = 0;
  for (int j = 0; j < 10; j++) {
    valeur = (analogRead(pinIntensite[i]) - 511.5) / 102.3;
    somme = somme + valeur;
    delay(50);
  }
    intensite[i] = somme/10;
    puissance[i] = voltage * intensite[i]; // calcul de la puissance en watts
}
}

float Temperature(int capteur) {
  float valeur = 0;float somme = 0;
  DHT dht(capteur, DHTTYPE);  //déclaration du capteur
  dht.begin();
  for (int j = 0; j < 10; j++) {
  valeur = dht.readTemperature();
  somme = somme + valeur;
  delay(50);
  }    
  return (somme/10);
}

float Humidite(int capteur) {
  float valeur = 0;float somme = 0;
  DHT dht(capteur, DHTTYPE);  //déclaration du capteur
  dht.begin();
  for (int j = 0; j < 10; j++) {
  valeur = dht.readHumidity();
  somme = somme + valeur;
  delay(50);
  }    
  return (somme/10);
}

//MENUS KEYPAD+LCD################################################################################################
void Menu() {
  Afficher_LCD("A = INFORMATIONS", "", "B = RELAI MANUEL", "", "C = PROG HORAIRE", "", "D = QUITTER MENU", "");
  key = keypad.getKey();
  while (!key) {
    key = keypad.getKey();
    switch (key) {
      case 'A':
        Menu_infos();
        Quitter_LCD(0);
        break;
      case 'B':
        Quitter_LCD(0);
        Menu_relais();
        break;
      case 'C':
        Quitter_LCD(0);
       Menu_Programme_horaire();     
        break;
      case 'D':
        Quitter_LCD(0);
        return;
        break;
      case '0':
        for (int i = 0; i < NUM_RELAYS; i++) updateRelayState(i, LOW);
        Afficher_LCD("TOUS RELAIS ", "", "OFF !", "", "", "", "", "");  
        Quitter_LCD(2);
      case '*':
        for (int i = 0; i < NUM_RELAYS; i++) updateRelayState(i, HIGH);
        Afficher_LCD("TOUS RELAIS ", "", "ON !", "", "", "", "", "");        
        Quitter_LCD(2);

    }
  }
}
char* conversion_float_char(float valeur) {
  static char buffer[16];         // Créer un buffer de 16 caractères pour stocker la chaîne de caractères
  dtostrf(valeur, 2, 2, buffer);  // Convertir le nombre à virgule flottante en chaîne de caractères et stocker dans le buffer
  return buffer;                  // Retourner la chaîne de caractères}
}
char* conversion_int_char(int valeur) {
  static char buffer[16];         // Créer un buffer de 16 caractères pour stocker la chaîne de caractères
  sprintf(buffer, "%d", valeur);  // Convertir l'entier en chaîne de caractères et stocker dans le buffer
  return buffer;                  // Retourner la chaîne de caractères}
}
void Menu_infos() {
  Afficher_LCD(DateHeure(), "", "A = TEMPERATURES","", "B = ELECTRICITE","", "C = RELAIS ACTIVES","");
  key = keypad.getKey();
  while (!key) {
    key = keypad.getKey();
    switch (key) {
      case 'A': 
        //Quitter_LCD(0);
        menu_info_temperatures();
                break;
      case 'B':
        //Quitter_LCD(0);
        menu_info_elec();
                break;
      case 'C':
        Quitter_LCD(0);
        break;
      case 'D':
        Quitter_LCD(0);
        return;
        break;
    }
  }
}
void Menu_relais() {
  choix_quantite();
  Afficher_LCD("A = ON/OFF", "", "B = TIMER", "", "C = FORCING", "", "D = QUITTER MENU", "");
  key = keypad.getKey();
  while (!key) {
    key = keypad.getKey();
    char buffer[10];
    int relai = 0;
    int var_timer = 0;
    char buffer2[10];
    switch (key) {
      case 'A':
        itoa(valeur_pad, buffer, 10);
        char statut_relai;
        if (!relayStates[valeur_pad - 1] == 0) statut_relai = "OFF";
        else statut_relai = "ON";
        if (relayStates[valeur_pad - 1] == LOW) {
          updateRelayState(valeur_pad - 1, LOW);
          Afficher_LCD("RELAI :", buffer, "OFF", "", "", "", "", "");
        } else {
          updateRelayState(valeur_pad - 1, HIGH);
          Afficher_LCD("RELAI :", buffer, "ON", "", "", "", "", "");
        }
        Quitter_LCD(2);
        break;
      case 'B':
        relai = valeur_pad - 1;
        itoa(valeur_pad, buffer, 10);
        choix_quantite();
        var_timer = valeur_pad;
        itoa(var_timer, buffer2, 10);
        Afficher_LCD("RELAI :", buffer, "DUREE : ", buffer2, "ON ! ", "", "", "");
        updateRelayState(relai, HIGH);
        timer[relai] = var_timer;
        Quitter_LCD(2);
        break;
      case 'C':
        relai = valeur_pad - 1;
        itoa(valeur_pad, buffer, 10);
        choix_quantite();
        var_timer = valeur_pad;
        itoa(var_timer, buffer2, 10);
        Afficher_LCD("RELAI :", buffer, "DUREE : ", buffer2, "ON ! ", "", "FORCING !", "");
        forcing[relai] = var_timer;
        digitalWrite(RELAY_PINS[relai], LOW);
        //relayStates[relay] = state;
        Quitter_LCD(2);
        break;
      case 'D':
        Quitter_LCD(0);
        return;
        break;

      }        
    }
  }

void menu_info_temperatures() {
  lcd.display();lcd.backlight();lcd.clear();
  lcd.print(DHT1_temp);lcd.print(" / ");lcd.print(DHT1_hum);   
    for (int i = 0; i < NUM_SENSORS; i++) {
    lcd.setCursor(0, i + 1); 
    lcd.print("T");lcd.print(i+1);
    lcd.print(tab_Dallas[i]);

  }
    Quitter_LCD(5);
    
}

void menu_info_elec(){
  lcd.display();lcd.backlight();lcd.clear();
  lcd.setCursor(0, 0); 
  lcd.print("V=");lcd.print(voltage);
  for (int i = 0; i < NB_CAPTEURS_INTENSITES; i++) {
    lcd.setCursor(0, i + 1); 
    lcd.print("I");lcd.print(i+1);lcd.print("=");lcd.print(intensite[i]); 
    lcd.setCursor(10, i + 1); 
    lcd.print("P");lcd.print(i+1);lcd.print("=");lcd.print(puissance[i]); 
}
    Quitter_LCD(5);
}


void choix_quantite() {
  valeur_pad = 0;
  Quitter_LCD(0);
  Afficher_LCD("SAISIR VALEUR :", "", "", "", "", "", "A-VALIDER", "D-QUITTER");
  bool saisie_terminee = 0;
  static char keypadInput[3] = { 0 };  // Tampon de saisie, initialisé à {0, 0, 0}
  while (saisie_terminee == 0) {
    key = keypad.getKey();
    if (key != NO_KEY) {
      if (key == 'D') {
        Quitter_LCD(0);
        return;
        break;
      }
      if (key == 'A') {
        Quitter_LCD(0);
        int value = getValueFromKeypad(keypadInput);
        Serial.print("Valeur saisie : ");
        Serial.println(value);
        valeur_pad = value;
        char buffer[10];  // Tableau de caractères pour stocker la chaîne convertie
        itoa(valeur_pad, buffer, 10);
        memset(keypadInput, 0, sizeof(keypadInput));  // Efface le tampon de saisie
        Afficher_LCD("Saisir valeur :", "", buffer, "", "", "", "", "");
        Quitter_LCD(2);
        saisie_terminee = 1;

      } else if (strlen(keypadInput) < 2) {
        keypadInput[strlen(keypadInput)] = key;
        Afficher_LCD("SAISIR VALEUR :", "", keypadInput, "", "", "", "A-VALIDER", "D-QUITTER");
      }
    }
  }
}

//LCD ****************************************************************************************************
void Afficher_LCD(char* text1, char* text1bis, char* text2, char* text2bis, char* text3, char* text3bis, char* text4, char* text4bis) {
  lcd.display();
  lcd.backlight();
  lcd.clear();
  if (text1 != "") lcd.setCursor(0, 0), lcd.print(text1);
  delay(10);
  if (text1bis != "") lcd.setCursor(10, 0), lcd.print(text1bis);
  delay(10);
  if (text2 != "") lcd.setCursor(0, 1), lcd.print(text2);
  delay(10);
  if (text2bis != "") lcd.setCursor(10, 1), lcd.print(text2bis);
  delay(10);
  if (text3 != "") lcd.setCursor(0, 2), lcd.print(text3);
  delay(10);
  if (text3bis != "") lcd.setCursor(10, 2), lcd.print(text3bis);
  delay(10);
  if (text4 != "") lcd.setCursor(0, 3), lcd.print(text4);
  delay(10);
  if (text4bis != "") lcd.setCursor(10, 3), lcd.print(text4bis);
  delay(10);
}
void Quitter_LCD(int delai) {
  delay((delai * 1000) + 100);
  lcd.noBacklight();
  lcd.clear();
}

//CARTE SD ****************************************************************************************************
float Sauvegarde_SD(String motif) {
  //Ouverture fichier
  SD.begin(pin_SD);
  monFichier = SD.open("data.txt", FILE_WRITE);
  
  if (monFichier) {
    monFichier.print(DateHeure());monFichier.print(";");
    monFichier.print(motif);monFichier.print(";");
    monFichier.print(DHT1_temp);monFichier.print(";");
    monFichier.print(DHT1_hum);monFichier.print(";");   
    for (int i = 0; i < NUM_SENSORS; i++) {
      monFichier.print(tab_Dallas[i]);
      monFichier.print(";");
      }
    monFichier.print(voltage);monFichier.print(";");
    for (int i = 0; i < NB_CAPTEURS_INTENSITES; i++) {
      monFichier.print(intensite[i]); monFichier.print(";");
      monFichier.print(puissance[i]);monFichier.print(";"); 
    }
  for (int i = 0; i < NUM_RELAYS; i++) {
    monFichier.print(RELAY_PINS[i]);monFichier.print(";");
    monFichier.print(relayStates[i]);monFichier.print(";");
    monFichier.print(timer[i]);monFichier.print(";");
    monFichier.print(forcing[i]);monFichier.print(";");
    monFichier.print(tension_relai[i]);monFichier.print(";");
    monFichier.print(intensite_relai[i]);monFichier.print(";");
    monFichier.print(puissance_relai[i]);monFichier.print(";");
  }

    monFichier.println();
    //monFichier.println("//");
    monFichier.close();
  }
}

float Initialisation_SD() {
  int echec = 0;  // initialisation du compteur d'échecs à 0

  while (echec < 3) {         // tant que le compteur est inférieur à 3
    if (!SD.begin(pin_SD)) {  // Si pas de communication carte SD => incrémenter le compteur d'échecs
      Serial.println("L'initialisation de la carte SD a échoué");
      Afficher_LCD("Echec Initialisation", "", "", "", "", "", "", "");
      echec++;
      delay(1000);  // attendre 1 seconde avant de réessayer
      Quitter_LCD(0);
    } else {  // sinon, on a réussi à initialiser la carte SD
      Serial.println("L'initialisation de la carte SD a réussi");
      Afficher_LCD("Initialisation OK", "", "", "", "", "", "", "");
      delay(1000);
      Quitter_LCD(0);
      monFichier = SD.open("data.txt", FILE_WRITE);  // ouverture fichier "data"
      if (monFichier) {
//        Serial.print("Ecriture en cours");
//        monFichier.println("Initialisation document");
        monFichier.close();
        Serial.println("Ecriture réalisée");
        Afficher_LCD("Ecriture OK", "", "", "", "", "", "", "");
        delay(1000);
        Quitter_LCD(0);

        break;  // on sort de la boucle while car on a réussi à écrire dans le fichier
      } else {
        Serial.println("Erreur lors de l'ouverture du fichier");
        Afficher_LCD("Erreur ouverture", "", "fichier", "", "", "", "", "");
        delay(1000);
        Quitter_LCD(0);
        break;  // on sort de la boucle while car on n'a pas réussi à ouvrir le fichier
      }
    }
  }
}

//CLOCK + ALARME ****************************************************************************************************
void Dodo() {
  alarme_auto = false;
  alarme_manu = false;
  t = myRTC.get();
  int var_hour = hour(t);
  int var_min = minute(t) + 1;
  if (var_min >= 60) {     // si minute dépasse 59
    var_hour++;            // ajouter une heure
    var_min = 0;           // remettre minute à zéro
    if (var_hour >= 24) {  // si heure dépasse 23
      var_hour = 0;        // remettre heure à zéro
    }
  }
  Prochaine_alarme(var_hour, var_min);
  delay(100);
  sleepNow();
}
void Horaire() {
  t = myRTC.get();
  Serial << ((day(t) < 10) ? "0" : "") << _DEC(day(t)) << '/';
  Serial << ((month(t) < 10) ? "0" : "") << _DEC(month(t)) << '/';
  Serial << ((year(t) < 10) ? "0" : "") << _DEC(year(t)) << '-';
  Serial << ((hour(t) < 10) ? "0" : "") << _DEC(hour(t)) << ':';
  Serial << ((minute(t) < 10) ? "0" : "") << _DEC(minute(t)) << ':';
  Serial << ((second(t) < 10) ? "0" : "") << _DEC(second(t)) << endl;
}
void sleepNow() {
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);  // sleep mode is set here
  sleep_enable();
  attachInterrupt(digitalPinToInterrupt(Pin_reveil_bouton), Reveil_manu, LOW);
  attachInterrupt(digitalPinToInterrupt(Pin_reveil), Reveil_auto, LOW);
  sleep_mode();
  sleep_disable();
  detachInterrupt(digitalPinToInterrupt(Pin_reveil_bouton));
  detachInterrupt(digitalPinToInterrupt(Pin_reveil));
}
void Prochaine_alarme(int H_alm, int M_alm) {
  myRTC.setAlarm(DS3232RTC::ALM1_MATCH_DATE, 0, 0, 0, 1);
  myRTC.setAlarm(DS3232RTC::ALM2_MATCH_DATE, 0, 0, 0, 1);
  myRTC.alarm(DS3232RTC::ALARM_1);
  myRTC.alarm(DS3232RTC::ALARM_2);
  myRTC.alarmInterrupt(DS3232RTC::ALARM_1, false);
  myRTC.alarmInterrupt(DS3232RTC::ALARM_2, false);
  myRTC.squareWave(DS3232RTC::SQWAVE_NONE);
  myRTC.setAlarm(DS3232RTC::ALM2_MATCH_HOURS, 0, M_alm, H_alm, 0);
  myRTC.alarm(DS3232RTC::ALARM_1);
  myRTC.alarm(DS3232RTC::ALARM_2);
  myRTC.squareWave(DS3232RTC::SQWAVE_NONE);
  myRTC.alarmInterrupt(DS3232RTC::ALARM_1, false);
  myRTC.alarmInterrupt(DS3232RTC::ALARM_2, true);
  Serial.print("Programme horaire : ");
  Serial.print(H_alm);
  Serial.print(":");
  Serial.println(M_alm);
}

void Reglage_heure() {
  myRTC.begin();
  tmElements_t tm;
  tm.Hour = 22;  // set the RTC time to 06:29:50
  tm.Minute = 04;
  tm.Second = 10;
  tm.Day = 12;
  tm.Month = 3;
  tm.Year = 2023 - 1970;  // tmElements_t.Year is the offset from 1970
  myRTC.write(tm);        // set the RTC from the tm structure
}