#include <LiquidCrystal_I2C.h>

#define TIME_STAMP 60000 // normalement = 60'000 ms
#define TIMER_TS 10 // Timer time-stamp, normalement = 1'000'000 us
#define BUZZER_STAMP 100 // ms

const int buzzer = 13; // Déclaration du pin du buzzer dans le pin 13

int ldr = A2;
int luminosite = 0;
uint16_t b_frequency = 1000; // Buzzer tone frequency

#define BP_MODE 3      // Le bouton pousoir jaune
#define BP_PARAM 4     // Le bouton pousoir bleu
#define BP_UP 5        // Le bouton pousoir rouge
#define BP_DOWN 6      // Le bouton pousoir noir
#define TMP A3

//Pour avoir le symbole de degré sur le LCD
byte DEGREE_SYMBOL = 0;
byte degree[8] = {
  0b00111,
  0b00101,
  0b00111,
  0b00000,
  0b00000,
  0b00000,
  0b00000,
  0b00000
};

// Date
uint8_t days = 01;
uint8_t months = 2;
uint16_t years = 2023;

// Time
uint8_t hours = 23;
uint8_t minutes = 59;

/* Variables du timer */
byte t_hours = 0;
byte t_minutes = 0;
byte t_seconds = 0;
bool t_is_active = false; // Etat du timer
bool t_is_triggered = false; // Change to false if timer reach zero
bool t_is_started = false;

/* Variables de l'alarme*/
byte a_hours = 0;
byte a_minutes = 0;

// Variables utiliser pour calculer le nom du jours
uint8_t c; //Sciècle
uint8_t yy; //2 derniers chiffres de l'année
uint8_t mTable; //Valeur mensuelle basée sur la table de calcul cité dans le rapport
uint8_t cTable; // Valeur centenaire basée sur la table de calcul cité dans le rapport
uint8_t DoW; // Valeur du jour de la semaine (0-6)
uint8_t SummedDate; /* Ajouter des valeurs combinées dans la préparation
                     pour le calcul de reste de la division sur 7*/


/*Déclaration des variables de référence du temps, et les variables utilisés pour assurer
  le switch des paramètres au niveau des boutons dans les trois modes. */
char ascii_0 = '0';  // Nous servira plus tard à faire des convertions 
byte index = 0; // Utilisée par les fonctions d'affichage
char temp[11]; // Utilisée par les fonctions d'affichage comme buffer

bool is_sep_on = false; // Indique si le séparateur ':' de time est affiché ou pas.
unsigned long sep_time_ref; // Référence de temps pour le clignotement de ':'

bool is_param_on = true;
unsigned long param_time_ref; // Référence de temps pour le clignotement du paramètre sélectionné

unsigned long clock_ref;
unsigned long timer_ref;
unsigned long buzzer_ref; // Référence de temps pour le buzzer
bool is_buzzer_triggered = false;

#define M_CLOCK 0         // Horloge
#define M_TIMER 1         // Minuteur
#define M_ALARM 2         // Réveil

byte mode = M_CLOCK;

byte displayed_mode = M_CLOCK; /* Permet de mémoriser le mode d'affichage en cours,
                                  pour éviter les effacements inutiles*/

#define C_DAYS 0
#define C_MONTHS 1
#define C_YEARS 2
#define C_HOURS 3
#define C_MINUTES 4
#define C_NONE 5
byte param_c = C_NONE; // Parametre d'horloge

#define T_HOURS 0
#define T_MINUTES 1
#define T_SECONDS 2
#define T_ON_OFF 3     // Activation/désactivation du minuteur
#define T_NONE 4      // Valide l'activation/désactivation
byte param_t = T_NONE; // Parametre timer

#define A_HOURS 0
#define A_MINUTES 1
#define A_ON_OFF 2
#define A_NONE 3
byte param_a = A_NONE; // Parametre alarme

bool a_is_active = false;
bool a_is_started = false;
bool is_changed = false;


// initialize the library with the numbers of the interface pins
LiquidCrystal_I2C lcd(0x27, 20, 4);  //LCD équipé d'un module I2C


void setup() {
  // put your setup code here, to run once:
  // Serial .begin (9600) ;
  // Serial.println("Device started!");

  // set up the LCD's number of columns and rows:
  lcd.init();
  //lcd.begin(16, 2);
  lcd.createChar(DEGREE_SYMBOL, degree); // Création de l'indice degré

  display();
  //La carte Arduino Uno dispose de 2 entrées d’interruption 
  //Les interruptions INT0 et INT1 sont les plus faciles à utiliser
  // et sont les plus rapides. Comme nous disposons de 04 boutons poussoirs
  // et que nous ne voulons pas mélanger les deux types d’interruptions 
  // afin de garder une uniformité dans la gestion et le même niveau de réactivité, 
  // nous avons choisi de câbler les 04 boutons sur la même entrée 
  // d’interruption à l’aide d’une fonction OU câblée.
  attachInterrupt (digitalPinToInterrupt (2), isr_function, FALLING);

  pinMode (BP_MODE, INPUT);
  pinMode (BP_PARAM, INPUT) ;
  pinMode (BP_UP, INPUT);
  pinMode (BP_DOWN, INPUT) ;
  pinMode (buzzer, OUTPUT) ;
  //pinMode (transistor, OUTPUT) ;
  pinMode (ldr, INPUT) ;

  param_time_ref, sep_time_ref, clock_ref, buzzer_ref = millis(); // Initialisation
  timer_ref = micros();
}

void loop() {
  // put your main code here, to run repeatedly:
  if (millis() - sep_time_ref > 500) {
    blink_time_sep();
    sep_time_ref = millis();
  }

  if (millis() - param_time_ref > 500) {
    blink_param() ;
    param_time_ref = millis();
  }

  if (millis() - clock_ref > TIME_STAMP) {
    /* A chaque time stamp (normalement 60s),
       l'heure augmente de 1min*/
    update_clock();
    is_changed = true;
    clock_ref = millis();
  }

  if (micros() - timer_ref > TIMER_TS and t_is_started) {
    update_timer();
    is_changed = true;
    timer_ref = micros();
  }

  if (t_is_triggered) {
    // Faire sonner le buzzer
    // Serial.println("Timer expiré");
    is_buzzer_triggered = true; // Trigger the buzzer
    t_is_triggered = false;
  }

  if (a_is_started and a_is_time()) {
    // Faire sonner le buzzer
    // Serial.printin("Réveille-toi")
    is_buzzer_triggered = true;
    a_is_started = false;
    a_is_active = false;
  }
  if (is_buzzer_triggered) {
    ring_buzzer();
  }

  if (is_changed) {
    display();
    is_changed = false;
  }
  retroeclairage();
}


/* 	Création de la fonction rectoeclairage() qui permet d’atténué le recto-éclairage du LCD
  lorsque le capteur de luminosité capte une valeur inférieure. */
void retroeclairage()
{
  //luminosite = analogRead(ldr);
  // Serial.begin(9600);
  //Serial.println(luminosite) ;
  if (digitalRead(ldr) == LOW)
    lcd.backlight();
  else
    lcd.noBacklight();
}


/* 	Création de la fonction isr_func() qui permet
    le choix du bouton à utiliser. */
void isr_function()
{
  if (digitalRead(BP_MODE) == HIGH) {
    //Serial.println("BP_MODE");
    update_mode();
    return;
  }

  if (digitalRead(BP_PARAM) == HIGH) {
    //Serial.printin("BP_PARAM");
    update_param();
    return;
  }

  if (digitalRead(BP_UP) == HIGH) {
    //Serial.println("BP_UP") ;
    up_handler() ;
    return;
  }

  if (digitalRead(BP_DOWN) == HIGH) {
    //Serial.println("BP_DOWN") ;
    down_handler();
    return;
  }
}

/* 	Création de la fonction display_date() qui permet l’affichage de la date
  et si le jours et le mois sont inférieure à 10 on ajoute un zéro à gauche.*/
void display_date()
{
  index = 0;
  memset(temp, '\O', 11);

  /* Plage des jours */
  if (days < 10) { // Ajout du 0 décimal
    temp[index] = ascii_0;
    index++;
    temp[index] = ascii_0 + days;
    index++;
  }
  else {
    temp[index] = days / 10 + ascii_0;
    index++;
    temp[index] = days % 10 + ascii_0;
    index++;
  }

  /* Un slash délimiteur*/
  temp[index] = '/';
  index++;

  /* Plage des mois */
  if (months < 10) { // Ajout du 0 décimal
    temp[index] = ascii_0;
    index++;
    temp[index] = ascii_0 + months;
    index++;
  }
  else {

    temp[index] = months / 10 + ascii_0;
    index++;
    temp[index] = months % 10 + ascii_0;
    index++;
  }

  /* Un slash délimiteur*/
  temp[index] = '/';
  index++;

  /* Plage des années */
  byte rest = 0;
  temp[index] = years / 1000 + ascii_0;
  rest = years % 1000;
  index++;
  temp[index] = rest / 100 + ascii_0;
  rest = rest % 100;
  index++;
  temp[index] = rest / 10 + ascii_0;
  index++;
  temp[index] = years % 10 + ascii_0;

  // Afficher la date
  lcd.setCursor(6, 0); // Déplacement curseur
  lcd.print(temp) ;
}

/* 	Création de la fonction display_time() qui permet l’affichage
    du temps et si l’heure et les minutes sont inférieure à 10
    on ajoute un zéro à gauche. */
void display_time()
{
  byte index = 0;
  memset(temp,'\O', 5);

  /* Plage des heures */
  if (hours < 10) { // Ajout du 0 décimal
    temp[index] = ascii_0;
    index++;
    temp[index] = ascii_0 + hours;
    index++;
  }
  else {
    temp[index] = hours / 10 + ascii_0;
    index++;
    temp[index] = hours % 10 + ascii_0;
    index++;
  }

  /* Un ' ' pour la place du délimiteur*/
  temp[index] = ' ';
  index++;

  /* Plage des minutes */
  if (minutes < 10) { // Ajout du 0 décimal
    temp[index] = ascii_0;
    index++;
    temp[index] = ascii_0 + minutes;
    index++;
  }
  else {
    temp[index] = minutes / 10 + ascii_0;
    index++;
    temp[index] = minutes % 10 + ascii_0;
    index++;
  }

  // Afficher l'heure
  lcd.setCursor(0, 1); // Déplacement curseur
  lcd.print(temp) ;
  lcd.setCursor(5, 1);
  lcd.print("   ");
}

void update_mode()
{
  mode++;
  if (mode > 2)
    mode = 0;
}

/* Création de la fonction update_param() qui permet
  de switcher dans les différentes paramètres soit
  dans le mode horloge(M_CLOCK), ou minuteur( M_TIMER),
  ou bien alarme( M_ALARM) . */
void update_param()
{
  if (is_buzzer_triggered) { // La touche param sert à arrêter la sonnerie du buzzer si elle est active
    is_buzzer_triggered = false;
    noTone(buzzer); // Deactivate the tone on the buzzer
    return;
  }

  if (mode == M_CLOCK) {
    param_c++;
    if (param_c > 5)
      param_c = 0;
    switch (param_c) {
      /* Faire l'action appropriée en fonction du paramètre actuel,
                                comme donner un background différent*/
      case C_DAYS: /**/ break;
      case C_MONTHS: /**/ break;
      case C_YEARS: /**/ break;
      case C_HOURS: /**/ break;
      case C_MINUTES: /**/ break;
      case C_NONE: display(); break; // Affichage normal
      default: break;
    }
    return;
  }

  if (mode == M_TIMER) {
    param_t++;
    if (param_t > T_NONE)
      param_t = 0;

    if (param_t == T_NONE) {
      if (t_hours != 0 or t_minutes != 0 or t_seconds != 0) {
        if (t_is_active)
          t_is_started = true;
        else
          t_is_started = false;
      }
    }
    return;
  }

  if (mode == M_ALARM) {
    param_a++;
    if (param_a > A_NONE)
      param_a = 0;

    if (param_a == A_NONE) {
      if (a_is_active)
        a_is_started = true;
      else
        a_is_started = false;
      display_alarm();
    }
    return;
  }
}

/* 	Création de la fonction up_handler () qui permet d’augmenter
   la valeur des différents paramètres quel que soit le mode choisit. */
void up_handler()
{
  if (mode == M_CLOCK)
  {
    switch (param_c) {
      case C_DAYS: inc_days(); break;
      case C_MONTHS: inc_months(); break;
      case C_YEARS: inc_years(); break;
      case C_HOURS: inc_hours(); break;
      case C_MINUTES: inc_minutes(); break;
      default: break; // We should not reach here
    }
    is_changed = true;
    return;
  }

  if (mode == M_TIMER) {
    switch (param_t) {
      case T_HOURS:
        if (!t_is_started)
          inc_t_hours();
        break;
      case T_MINUTES:
        if (!t_is_started)
          inc_t_minutes();
        break;
      case T_SECONDS:
        if (!t_is_started)
          inc_t_seconds();
        break;
      case T_ON_OFF: change_t_state(); break;
      default: break; // We Should reach here
    }
    is_changed = true;
    return;
  }

  if (mode == M_ALARM) {
    switch (param_a) {
      case A_HOURS: inc_a_hours(); break;
      case A_MINUTES: inc_a_minutes(); break;
      case A_ON_OFF: change_a_state(); break;
      case A_NONE: display_alarm();
    }
    is_changed = true;
    return;
  }
}

/* Création de la fonction down_handler () qui permet
  de diminue la valeur des différents paramètres
  quel que soit le mode choisit. */
void down_handler()
{
  if (mode == M_CLOCK)
  {
    switch (param_c) {
      case C_DAYS: dec_days(); break;
      case C_MONTHS: dec_months(); break;
      case C_YEARS: dec_years(); break;
      case C_HOURS: dec_hours(); break;
      case C_MINUTES: dec_minutes(); break;
      default: break; // We should not reach there
    }
    is_changed = true;
    return;
  }

  if (mode == M_TIMER) {
    switch (param_t) {
      case T_HOURS:
        if (!t_is_started)
          dec_t_hours();
        break;
      case T_MINUTES:
        if (!t_is_started)
          dec_t_minutes();
        break;
      case T_SECONDS:
        if (!t_is_started)
          dec_t_seconds();
        break;
      case T_ON_OFF: change_t_state(); break;
      default: break; // We should reach here
    }
    is_changed = true;
    return;
  }

  if (mode == M_ALARM) {
    switch (param_a) {
      case A_HOURS: dec_a_hours(); break;
      case A_MINUTES: dec_a_minutes(); break;
      case A_ON_OFF: change_a_state(); break;
      case A_NONE: display_alarm();
    }
    is_changed = true;
    return;
  }
}

/* 	Création des fonction inc_...()  et dec_...() qui permettent
  d’incrémenter et décrémenter les différents valeurs des paramètres
  pour chaque mode. */
void inc_days()
{
  days++;
  if (days > number_of_days()) // chaque mois à son dernier jour.
    days = 1;
}

void inc_months()
{
  months++;
  if (months > 12)
    months = 1;
}

void inc_years()
{
  years++;
}

void inc_hours()
{
  hours++;
  if (hours > 23)
    hours = 0;
}

void inc_a_hours()
{
  a_hours++;
  if (a_hours > 23)
    a_hours = 0;
}

void inc_minutes()
{
  minutes++;
  if (minutes > 59)
    minutes = 0;

}

void inc_a_minutes()
{
  a_minutes++;
  if (a_minutes > 59)
    a_minutes = 0;
}

void dec_days()
{
  days--;
  if (days < 1)
    days = number_of_days();// chaque mois arrive à son dernier jour.
}

void dec_months()
{
  months--;
  if (months < 1)
    months = 12;
}

void dec_years()
{
  years--;
  if (years < 1970)
    years = 1970;  // Année UNIX: à changer plus tard
}

void dec_hours()
{
  if (hours == 0)
    hours = 23;
  else
    hours--;
}

void dec_a_hours()
{
  if (a_hours == 0)
    a_hours = 23;
  else
    a_hours--;
}

void dec_minutes()
{
  if (minutes == 0)
    minutes = 59;
  else
    minutes--;
}

void dec_a_minutes()
{
  if (a_minutes == 0)
    a_minutes = 59;
  else
    a_minutes--;
}

void inc_t_hours()    //Increment timer hours
{
  t_hours++;
  if (t_hours > 99)
    t_hours = 0;
}

void dec_t_hours()
{
  if (t_hours == 0)
    t_hours = 99;
  else
    t_hours--;
}

void inc_t_minutes()
{
  t_minutes++;
  if (t_minutes > 59)
    t_minutes = 0;
}

void dec_t_minutes()
{
  if (t_minutes == 0)
    t_minutes = 59;
  else
    t_minutes--;
}

void inc_t_seconds()
{
  t_seconds++;
  if (t_seconds > 59)
    t_seconds = 0;
}

void dec_t_seconds()
{
  if (t_seconds == 0)
    t_seconds = 59;
  else
    t_seconds--;
}


/* 	Création de la fonction change_t_state() qui permet le changement
  du statut du minuteur et d’alarme. */
void change_t_state()
{ // Change timer state
  t_is_active = ! t_is_active;
}
void change_a_state() // Change timer state
{
  a_is_active = !a_is_active;
}


/*Création de la fonction display_tmp() qui permet l’affichage
  de la température capter par le capteur TMP de la température. */
void display_tmp()
{
  const float BETA = 3950; // should match the Beta Coefficient of the thermistor
  int analogValue = analogRead(TMP);
  float temperature = 1 / (log(1 / (1023. / analogValue - 1)) / BETA + 1.0 / 298.15) - 273.15;

  // Afficher de température
  lcd.setCursor(8, 1); // Déplacement curseur
  lcd.print("T:"); // on écrit le mot "T: " à l'emplacement du curseur
  lcd.print (temperature, 1);// on écrit la température lue par le capteur, avec 1 chiffre derrière la virgule
  lcd.write (DEGREE_SYMBOL); // print l'indice de degrée
  lcd.print("C"); // on ajoute la lettre C pour degré Celsius
}

/*	Création de la fonction blink_time_sep() qui permet le clignotement
   des : dans l’horloge. */
void blink_time_sep()
{
  if (mode != M_CLOCK) // On ne fait rien si on n'est pas en mode Horloge
    return;
  lcd.setCursor (2, 1);
  if (!is_sep_on) { // S'il est Off,
    lcd.print(":"); // on l'affiche
    is_sep_on = true;
  }
  else { // S'il est On, on l'efface
    lcd.print(' ');
    is_sep_on = false;
  }
}

/* 	Création de la fonction blink_param() qui permet le clignotement
  de paramètre choisit pour le modifier dans les trois modes. */
void blink_param()
{
  if (mode == M_CLOCK) {
    switch (param_c) {
      case C_DAYS:
        lcd.setCursor(6, 0);
        if (is_param_on) {
          lcd.print("  ");
          is_param_on = false;
        }
        else {
          display_date();
          is_param_on = true;
        }
        break;

      case C_MONTHS:
        lcd.setCursor(9, 0);
        if (is_param_on) {
          lcd.print("  ");
          is_param_on = false;
        }
        else {
          display_date();
          is_param_on = true;
        }
        break;

      case C_YEARS:
        lcd.setCursor (12, 0);
        if (is_param_on) {
          lcd.print("  ");
          is_param_on = false;
        }
        else {
          display_date();
          is_param_on = true;
        }
        break;

      case C_HOURS:
        lcd.setCursor (0, 1);
        if (is_param_on) {
          lcd.print("  ");
          is_param_on = false;
        }
        else {
          display_time();
          is_param_on = true;
        }
        break;

      case C_MINUTES:
        lcd.setCursor (3, 1);
        if (is_param_on) {
          lcd.print("  ");
          is_param_on = false;
        }
        else {
          display_time();
          is_param_on = true;
        }
        break;
    }
    return;
  }

  if (mode == M_TIMER) {
    switch (param_t) {
      case T_HOURS:
        lcd.setCursor(4, 0);
        if (is_param_on) {
          lcd.print("  ");
          is_param_on = false;
        }
        else {
          display_timer();
          is_param_on = true;
        }
        break;

      case T_MINUTES:
        lcd.setCursor(7, 0);
        if (is_param_on) {
          lcd.print(" ");
          is_param_on = false;
        }
        else {
          display_timer();
          is_param_on = true;
        }
        break;

      case T_SECONDS:
        lcd.setCursor(10, 0);
        if (is_param_on) {
          lcd.print("  ");
          is_param_on = false;
        }
        else {
          display_timer();
          is_param_on = true;
        }
        break;

      case T_ON_OFF:
        lcd.setCursor(12, 1);
        if (is_param_on) {
          lcd.print("   ");
          is_param_on = false;
        }
        else {
          display_timer();
          is_param_on = true;
        }
        break;
    }
    return;
  }

  if (mode == M_CLOCK) {
    switch (param_c) {

    }
    return;
  }
}

/* 	Création de la fonction update_clock() qui
   permet la mise à jour de l’heure, minutes, jour, mois et années.*/
void update_clock()
{
  inc_minutes();
  if (minutes != 0)
    return;

  inc_hours();
  if (hours != 0)
    return;

  inc_days();
  if (days != 1)
    return;

  inc_months() ;
  if (months != 1)
    return;

  inc_years(); // Plus rien à faire
}


/* 	Création de la fonction update_timer()
  qui permet d’avoir le fonctionnement d’un minuteur.*/
void update_timer()
{
  dec_t_seconds();

  if (t_seconds == 0 and t_minutes == 0 and t_hours) {
    t_is_triggered = true;
    t_is_active = false;
    t_is_started = false;
    return;
  }

  if (t_seconds != 59)
    return;

  dec_t_minutes() ;
  if (t_minutes != 59)
    return;

  dec_t_hours();
}

/* 	Création de la fonction is_leap_year() qui permet
  de savoir si l’année est bissextile ou non.
  ********o	Année bissextile Remarque :
      Une année bissextile est considérée comme vraie si :
                      -1- L'année est divisible par 4, mais pas divisible par 100
                     ou
                      -2- L'année est divisible par 400.
*/
bool is_leap_year(uint16_t t_year) /*pour avoir c'est l'année est bissextile
  alors février doit 753 avoir 29 jours sinon 28 jours.*/
{
  if (years % 4 == 0 and years % 100 != 0 or years % 400 == 0)
    return true;
  return false;
}

/* 	Création de la fonction number_of_days() qui permet de donner
    le nombre maximale des jours pour chaque mois.*/
byte number_of_days() // pour calculer la valeur max des jours de mois
{
  if ( months == 2) {
    // Serial.println("Month 2");
    if (is_leap_year (years)) {
      // Serial.println("Leap year");
      return 29;
    }
    // Serial.println("Non-leap year");
    return 28;
  }
  if (months == 4 or months == 6 or months == 9 or months == 11) {
    // Serial .println("30-days year");
    return 30;
  }

  if ( months == 1 or months == 3 or months == 5 or months == 7 or months == 8 or months == 10 or months == 12) {
    // Serial.println("31-days year");
    return 31;
  }
}

/* 	Création de la fonction display() qui permet l’affichage du mode choisit*/
void display()
{
  switch (mode) {
    case M_CLOCK: display_clock(); break;
    case M_TIMER: display_timer(); break;
    case M_ALARM: display_alarm(); break;
    default: break; // We should not reach here
  }
}

/* 	Création de la fonction display_clock() qui permet l’affichage du mode horloge (mode clock). */
void display_clock() // For the clock mode
{
  /* Effacement de l'écran si affichage en cours n'est pas CLOCK*/
  if (displayed_mode != M_CLOCK)
    lcd.clear();

  displayed_mode = M_CLOCK;

  display_date();  // Affichage de la date

  display_time();  // Affichage de l'heure

  display_tmp();   // Affichage de la temperature

  name_days(days, months, years); // nffichage du non de jour
}

/* 	Création de la fonction display_timer() qui permet l’affichage du minuteur
  et si les secondes, les minutes et les heures sont inférieures à 10 on ajoute
   un zéro à gauche. */
void display_timer()
{
  byte index = 0;
  memset(temp, '\0', 11);

  /* Effacement de l'écran si ...*/
  if (displayed_mode != M_TIMER)
    lcd.clear();

  displayed_mode = M_TIMER;
  /* Plage des heures */
  if (t_hours < 10) { // Ajout du O0 décimal
    temp[index] = ascii_0;
    index++;
    temp[index] = ascii_0 + t_hours;
    index++;
  }
  else {
    temp[index] = t_hours / 10 + ascii_0;
    index++;
    temp[index] = t_hours % 10 + ascii_0;
    index++;
  }

  /* Un ‘:' pour la place du délimiteur*/
  temp[index] = ':';
  index++;

  /* Plage des minutes */
  if (t_minutes < 10) { // Ajout du 0 décimal
    temp[index] = ascii_0;
    index++;
    temp[index] = ascii_0 + t_minutes;
    index++;
  }
  else {
    temp[index] = t_minutes / 10 + ascii_0;
    index++;
    temp[index] = t_minutes % 10 + ascii_0;
    index++;
  }

  /* Un ':' pour la place du délimiteur*/
  temp[index] = ':';
  index++;

  /* Plage des secondes*/
  if (t_seconds < 10) {
    temp[index] = ascii_0;
    index++;
    temp[index] = ascii_0 + t_seconds;
    index++;
  }
  else {
    temp[index] = t_seconds / 10 + ascii_0;
    index++;
    temp[index] = t_seconds % 10 + ascii_0;
    index++;
  }

  // Affichage
  lcd.setCursor(4, 0); // Déplacement curseur
  lcd.print(temp) ;

  memset(temp, '\0', 11); // Réinitialisation pour l'affichage de l'état ON/OFF
  if (t_is_active) {
    sprintf(temp, "ON ");
  }
  else {
    sprintf(temp, "OFF");
  }

  /* Affichage */
  lcd.setCursor(12, 1);
  lcd.print(temp) ;

}

/* 	Création de la fonction display_alarm() qui permet l’affichage de l’alarme
  et si les minutes et les heures sont inférieures à 10 on ajoute un zéro à gauche.  */
void display_alarm()
{
  if (displayed_mode != M_ALARM)
    lcd.clear();

  displayed_mode = M_ALARM;

  byte index = 0;
  memset(temp,'\O', 11);

  if (a_hours < 10) { // Ajout du O0 décimal
    temp[index] = ascii_0;
    index++;
    temp[index] = ascii_0 + a_hours;
    index++;
  }
  else {
    temp[index] = a_hours / 10 + ascii_0;
    index++;
    temp[index] = a_hours % 10 + ascii_0;
    index++;
  }

  /* Un ":* pour la place du délimiteur*/
  temp[index] = ':';
  index++;

  /* Plage des minutes */
  if (a_minutes < 10) { // Ajout du 0 décimal
    temp[index] = ascii_0;
    index++;
    temp[index] = ascii_0 + a_minutes;
    index++;
  }
  else {
    temp[index] = a_minutes / 10 + ascii_0;
    index++;
    temp[index] = a_minutes % 10 + ascii_0;
    index++;
  }

  lcd.setCursor(6, 0);  // Déplacement curseur
  lcd.print(temp) ;

  memset(temp,'\O', 11); // Réinitialisation pour l'affichage de l'état ON/OFF
  if (a_is_active) {
    sprintf(temp, "ON ");
  }
  else {
    sprintf(temp, "OFF");
  }

  /* Affichage */
  lcd.setCursor(12, 1);
  lcd.print(temp) ;
}

/* 	Création de la fonction is_timer_active() qui permet
    d’activer le buzzer c’est le temps est expiré.*/
bool is_timer_active()
{
  if (t_is_active and (t_hours != 0 or t_minutes != 0 or t_seconds != 0))
    return true;
  return false;
}

/* 	Création de la fonction a_is_time() qui permet d’activer le buzzer
    c’est l’heure d’alarme coïncide avec l’heure actuelle. */
bool a_is_time() // C'est l'heure de se réveiller: Wake-up time XD
{
  if (hours == a_hours and minutes == a_minutes)
    return true;
  return false;
}

/*	Création de la fonction name_days() qui permet
  de calculer le nom du jour et l’afficher.*/
void name_days(uint8_t m_day, uint8_t m_month, uint16_t m_year) {

 /*
    J'ai utilisé la Méthode 3 proposé sur ce site web:
    https://fr.wikibooks.org/wiki/Curiosit%C3%A9s_math%C3%A9matiques/Trouver_le_jour_de_la_semaine_avec_une_date_donn%C3%A9e
 */

  // Calculer le sciècle
  c = m_year / 100;

  // Calculer 2 derniers chiffres de l'année
  yy = m_year % 100;
  // Valeur du siècle pasés sur le tableau cités en rapport
  if (c == 19) {
    cTable = 1;
  }
  if (c == 20) {
    cTable = 0;
  }
  if (c == 21) {
    cTable = 5;
  }
  if (c == 22) {
    cTable = 3;
  }

  //Calcule de février affectés par les années bissextiles
  if (m_month == 2)
  {
    if (is_leap_year(m_year))
    {
      mTable = 2;
    }
    else
    {
      mTable = 3;
    }
  }
  //  Les autres mois ne sont pas affectés et ont des valeurs définies
  if (m_month == 1) {
    mTable = 6;
  }
  if (m_month == 3 and m_month == 11) {
    mTable = 3;
  }
  if (m_month == 4 and m_month == 7) {
    mTable = 6;
  }
  if (m_month == 5) {
    mTable = 1;
  }
  if (m_month == 6) {
    mTable = 4;
  }
  if (m_month == 8) {
    mTable = 2;
  }
  if (m_month == 9 and m_month == 12) {
    mTable = 5;
  }
  if (m_month == 10) {
    mTable = 0;
  }

  // Entrer les données dans la formule
  SummedDate = m_day + mTable + yy + (yy / 4) + cTable;

  // Trouver le reste
  DoW = SummedDate % 7;

  // Résultat de sortie
  lcd.setCursor (0, 0);

  // Le reste détermine le jour de la semaine
  if (DoW == 0) {
    lcd.print("SAM");
  }
  if (DoW == 1) {
    lcd.print("DIM");
  }
  if (DoW == 2) {
    lcd.print("LUN") ;
  }
  if (DoW == 3) {
    lcd.print("MAR") ;
  }
  if (DoW == 4) {
    lcd.print("MER");
  }
  if (DoW == 5) {
    lcd.print("JEU") ;
  }
  if (DoW == 6) {
    lcd.print("VEN") ;
  }
}

/* 	Création de la fonction ring_buzzer() qui permet d’avoir une tonalité.*/
void ring_buzzer()
{
  if (millis() - buzzer_ref > BUZZER_STAMP) {
    tone(buzzer, b_frequency) ;
    b_frequency += 50;
    if (b_frequency >= 3000) // Frequency limitation
      b_frequency = 1000;
    buzzer_ref = millis();
  }
}