// Capteur de temperature et d'humidite DHT22

#include "DHT.h"
#include "RTClib.h"
// Definit la broche de l'Arduino sur laquelle la 
// broche DATA du capteur est reliee 
#define DHTPIN 8
// Definit le type de capteur utilise
#define DHTTYPE DHT22
// Constante mesuree avec un thermometre de reference
// qui sert a etalonner le capteur de temperature
#define DELTA_TEMPERATURE 0.0
// Declare un objet de type DHT
// Il faut passer en parametre du constructeur 
// de l'objet la broche et le type de capteur
DHT dht(DHTPIN, DHTTYPE);
RTC_DS3231 rtc;

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


const int pin_relai_chauffage = 4;
const int pin_relai_frigo = 5;
const int pin_relai_humidification = 6;
const int pin_relai_deshumidification = 7;
const int pin_boutton_gauche =2;
const int pin_boutton_droit = 3;
const int pin_boutton_haut = 24;
const int pin_boutton_bas = 25;
const int pin_boutton_centre = 26;
const int pin_led = 9;
int bs=0;

float temperature_mesure;
float humidite_mesure;

const float temperature_declanchement_chauffage=10.0;
const float temperature_arret_chauffage=12.4;
const float temperature_declanchement_frigo=17.5;
const float temperature_arret_frigo=14.0;
const float humidite_declanchement_humidificateur=70.0;
const float humidite_arret_humidificateur=75.0;
const float humidite_declanchement_deshumidificateur=90.0;
const float humidite_arret_deshumidificateur=85.5;

float temperature_consigne;
float humidite_consigne;

const float alarme_temperature_basse_1=11.5;
const float alarme_temperature_basse_2=9.0;
const float alarme_temperature_haute_1=16.5;
const float alarme_temperature_haute_2=20.0;
const float alarme_humidite_basse_1=70.0;
const float alarme_humidite_basse_2=65.0;
const float alarme_humidite_haute_1=95.0;
const float alarme_humidite_haute_2=99.0;

#define interruption_declanche_btn_droit true   // Variable qui permet de savoir si une interruption à été déclanchée//controls interrupt handler
#define interruption_declanche_btn_gauche true   // Variable qui permet de savoir si une interruption à été déclanchée//controls interrupt handler
#define temps_bouton   20 // time to wait in milli secs

volatile  bool status_interruption_btn_droit = { !interruption_declanche_btn_droit }; // status de l'interruption, on l'initialise à false
volatile  bool status_interruption_btn_gauche = { !interruption_declanche_btn_gauche }; // status de l'interruption, on l'initialise à false


bool initialisation_termine = false;
//bool mode_par_default = false;
String mode="par_defaut";

#include "Wire.h"
#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C LCD(0x27,20,4); // définit le type d'ecran lcd 16 x 2

void setup() {
  Serial.begin(9600);
  
  // Initialise la capteur DHT11
  dht.begin();

  //Init Serial USB
  Serial.println(F("Initialize System"));
  //Init pwm output
  pinMode(pin_relai_chauffage, OUTPUT);
  pinMode(pin_relai_frigo, OUTPUT);
  pinMode(pin_relai_humidification, OUTPUT);
  pinMode(pin_relai_deshumidification, OUTPUT);
  pinMode(pin_boutton_gauche, INPUT);
  pinMode(pin_boutton_droit, INPUT);
  pinMode(pin_led, OUTPUT);

  attachInterrupt(digitalPinToInterrupt(pin_boutton_gauche),interruption_bouton_gauche,CHANGE);
  attachInterrupt(digitalPinToInterrupt(pin_boutton_droit),interruption_bouton_droit,CHANGE);

  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }
  rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));


  mode="par_defaut";
  LCD.init(); // initialisation de l'afficheur
  LCD.backlight();

  initialisation_termine = true;
}

void loop() {
  // Mesure la temperature et l'humidite et affichage dans la console
  // sur le moniteur serie
  temperature_mesure=dht.readTemperature() - DELTA_TEMPERATURE;
  humidite_mesure=dht.readHumidity();
  Serial.println("Temperature = " + String(temperature_mesure)+" °C");
  Serial.println("Humidite = " + String(humidite_mesure)+" %");


  // Pilotage des relais
  pilotage_relais();

  //calcul des température de consigne
  temperature_consigne=(temperature_declanchement_chauffage+temperature_declanchement_frigo)/2;
  humidite_consigne=(humidite_declanchement_humidificateur+humidite_declanchement_deshumidificateur)/2;

  if (mode == "par_defaut"){
    LCD.clear();
    affichage_par_defaut();
  }
  if (read_button_gauche() == true) {
    if (mode == "par_defaut"){  
      LCD.clear();
      mode="aff_seuils";
      affichage_seuils();
    }else{
      LCD.clear();
      mode="par_defaut";
    }
  }
  if (read_button_droit() == true) {
    if (mode == "par_defaut"){  
      LCD.clear();
      mode="aff_alarmes";
      affichage_alarmes();
    }else{
      LCD.clear();
      mode="par_defaut";
    }
  }
  LCD.display();

  affichage_date_heure();

  // Attend 10 secondes avant de reboucler
  delay(1000);

}
void pilotage_relais(){
    // Action des relais de pilotage de température
  if (temperature_mesure < temperature_declanchement_chauffage){
    digitalWrite(pin_relai_chauffage, HIGH);
  }
  if (temperature_mesure > temperature_arret_chauffage){
    digitalWrite(pin_relai_chauffage, LOW);
  }
  if (temperature_mesure > temperature_declanchement_frigo){
    digitalWrite(pin_relai_frigo, HIGH);
  }
  if (temperature_mesure < temperature_arret_frigo){
    digitalWrite(pin_relai_frigo, LOW);
  }

   // Action des relais de pilotage de l'humidite
  if (humidite_mesure < humidite_declanchement_humidificateur){
    digitalWrite(pin_relai_humidification, HIGH);
  }
  if (humidite_mesure > humidite_arret_humidificateur){
    digitalWrite(pin_relai_humidification, LOW);
  }
  if (humidite_mesure > humidite_declanchement_deshumidificateur){
    digitalWrite(pin_relai_deshumidification, HIGH);
  }
  if (humidite_mesure < humidite_arret_deshumidificateur){
    digitalWrite(pin_relai_deshumidification, LOW);
  }
}

void affichage_date_heure(){
  DateTime now = rtc.now();
  Serial.print(now.day(), DEC);
  Serial.print('/');
  Serial.print(now.month(), DEC);
  Serial.print('/');
  Serial.print(now.year(), DEC);
  Serial.print(' ');
  //Serial.print(" (");
  //Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
  //Serial.print(") ");
  Serial.print(now.hour(), DEC);
  Serial.print(':');
  Serial.print(now.minute(), DEC);
  Serial.print(':');
  Serial.println(now.second(), DEC);
}

void affichage_par_defaut(){
  // Affichage de la température
  LCD.setCursor(0, 0);
  LCD.println("Temp");
  LCD.setCursor(5, 0);
  LCD.println(temperature_mesure,1);
  //LCD.setCursor(4, 0);
  //LCD.println((String)char(223)+"C");
  LCD.setCursor(11, 0);
  LCD.println(temperature_consigne,1);

  // Affichage de l'humidité
  LCD.setCursor(0, 2);
  LCD.println("Humi");
  LCD.setCursor(5, 2);
  LCD.println(humidite_mesure,1);
  //LCD.setCursor(4, 0);
  //LCD.println((String)char(223)+"C");
  LCD.setCursor(11, 2);
  LCD.println(humidite_consigne,1);
}

void affichage_seuils(){
  LCD.setCursor(0, 0);
  LCD.print("S");
  LCD.setCursor(0, 1);
  LCD.print("e");
  LCD.setCursor(0, 2);
  LCD.print("u");
  LCD.setCursor(0, 3);
  LCD.print("i");


  // Affichage de la température de déclanchement du Chauffage
  LCD.setCursor(6, 0);
  LCD.print((String)"DC");
  LCD.setCursor(8, 0);
  LCD.print(temperature_declanchement_chauffage,1);

  // Affichage de la température de l'arret du Chauffage
  LCD.setCursor(14, 0);
  LCD.print((String)"AC");
  LCD.setCursor(16, 0);
  LCD.print(temperature_arret_chauffage,1);

  // Affichage de la température de déclanchement du frigo
  LCD.setCursor(6, 1);
  LCD.print((String)"DF");
  LCD.setCursor(8, 1);
  LCD.print(temperature_declanchement_frigo,1);
  
  // Affichage de la température de l'arret du frigo
  LCD.setCursor(14, 1);
  LCD.print((String)"AF");
  LCD.setCursor(16, 1);
  LCD.print(temperature_arret_frigo,1);

  // Affichage de l'humidité de déclanchement de l'humidificateur
  LCD.setCursor(6, 2);
  LCD.print((String)"DH");
  LCD.setCursor(8, 2);
  LCD.print(humidite_declanchement_humidificateur,1);

  // Affichage de l'humidite d'arret de l'humidificateur
  LCD.setCursor(14, 2);
  LCD.print((String)"AH");
  LCD.setCursor(16, 2);
  LCD.print(humidite_arret_humidificateur,1);


  // Affichage de l'humidité de déclanchement du déshumidificateur
  LCD.setCursor(6, 3);
  LCD.print((String)"DD");
  LCD.setCursor(8, 3);
  LCD.print(humidite_declanchement_deshumidificateur,1);

  // Affichage de l'humidite de l'arret du déshumidificateur
  LCD.setCursor(14, 3);
  LCD.print("AD");
  LCD.setCursor(16, 3);
  LCD.print(humidite_arret_deshumidificateur,1);


  //LCD.display();

}
void affichage_seuils2(int ligne_affichage){
  LCD.setCursor(0, 0);
  LCD.println("Réglages Seuils");



  // Affichage de la température de déclanchement du Chauffage
  LCD.setCursor(6, 0);
  LCD.println((String)"DC");
  LCD.setCursor(8, 0);
  LCD.println(temperature_declanchement_chauffage,1);

  // Affichage de la température de l'arret du Chauffage
  LCD.setCursor(14, 0);
  LCD.println((String)"AC");
  LCD.setCursor(16, 0);
  LCD.println(temperature_arret_chauffage,1);

  // Affichage de la température de déclanchement du frigo
  LCD.setCursor(6, 1);
  LCD.println((String)"DF");
  LCD.setCursor(8, 1);
  LCD.println(temperature_declanchement_frigo,1);
  
  // Affichage de la température de l'arret du frigo
  LCD.setCursor(14, 1);
  LCD.println((String)"AF");
  LCD.setCursor(16, 1);
  LCD.println(temperature_arret_frigo,1);

  // Affichage de l'humidité de déclanchement de l'humidificateur
  LCD.setCursor(6, 2);
  LCD.println((String)"DH");
  LCD.setCursor(8, 2);
  LCD.println(humidite_declanchement_humidificateur,1);

  // Affichage de l'humidite d'arret de l'humidificateur
  LCD.setCursor(14, 2);
  LCD.println((String)"AH");
  LCD.setCursor(16, 2);
  LCD.println(humidite_arret_humidificateur,1);


  // Affichage de l'humidité de déclanchement du déshumidificateur
  LCD.setCursor(6, 3);
  LCD.println((String)"DD");
  LCD.setCursor(8, 3);
  LCD.println(humidite_declanchement_deshumidificateur,1);

  // Affichage de l'humidite de l'arret du déshumidificateur
  LCD.setCursor(14, 3);
  LCD.println((String)"AD");
  LCD.setCursor(16, 3);
  LCD.println(humidite_arret_deshumidificateur,1);

  //LCD.display();

}





void affichage_alarmes(){
  LCD.setCursor(0, 0);
  LCD.print("A");
  LCD.setCursor(0, 1);
  LCD.print("l");
  LCD.setCursor(0, 2);
  LCD.print("a");
  LCD.setCursor(0, 3);
  LCD.print("r");

  // Affichage de la température de déclanchement du Chauffage
  LCD.setCursor(2, 0);
  LCD.print((String)"TB1");
  LCD.setCursor(6, 0);
  LCD.print(alarme_temperature_basse_1,1);

  // Affichage de la température de l'arret du Chauffage
  LCD.setCursor(12, 0);
  LCD.print((String)"TB2");
  LCD.setCursor(16, 0);
  LCD.print(alarme_temperature_basse_2,1);

  // Affichage de la température de déclanchement du frigo
  LCD.setCursor(2, 1);
  LCD.print((String)"TH1");
  LCD.setCursor(6, 1);
  LCD.print(alarme_temperature_haute_1,1);
  
  // Affichage de la température de l'arret du frigo
  LCD.setCursor(12, 1);
  LCD.print((String)"TH2");
  LCD.setCursor(16, 1);
  LCD.print(alarme_temperature_haute_2,1);

  // Affichage de l'humidité de déclanchement de l'humidificateur
  LCD.setCursor(2, 2);
  LCD.print((String)"HB1");
  LCD.setCursor(6, 2);
  LCD.print(alarme_humidite_basse_1,1);

  // Affichage de l'humidite d'arret de l'humidificateur
  LCD.setCursor(12, 2);
  LCD.print((String)"HB2");
  LCD.setCursor(16, 2);
  LCD.print(alarme_humidite_basse_2,1);

  // Affichage de l'humidité de déclanchement du déshumidificateur
  LCD.setCursor(2, 3);
  LCD.print((String)"HT1");
  LCD.setCursor(6, 3);
  LCD.print(alarme_humidite_haute_1,1);

  // Affichage de l'humidite de l'arret du déshumidificateur
  LCD.setCursor(12, 3);
  LCD.print((String)"HT2");
  LCD.setCursor(16, 3);
  LCD.print(alarme_humidite_haute_2,1);

  //LCD.display();

}


// On rentre dans cette fonction à chaque changement d'état du bouton, c'est à dire pour tous les 
// rebonds du bouton
// Le but est de renseigner la variable "status_interruption" pour qu'elle passe à "true"
// dès le premier état haut vu sur le bouton
void interruption_bouton_droit()
{
    // Si l'initialisation est bien terminée
  if (initialisation_termine == true)
  { //  all variables are initialised so we are okay to continue to process this interrupt
    Serial.println("si trigged" + String(status_interruption_btn_droit) +" "+String(!interruption_declanche_btn_droit));
    // Si le status de l'interruption correspond (par default: false) correspond à l'inverse d'une interruption déclanché (!true = false)
    if (status_interruption_btn_droit == !interruption_declanche_btn_droit) {

      // new interrupt so okay start a new button read process -
      // now need to wait for button release plus debounce period to elapse
      // this will be done in the button_read function
      // Si le niveaux de la pin du bouton est en niveau haut
      if (digitalRead(pin_boutton_droit) == HIGH) {
        // button pressed, so we can start the read on/off + debounce cycle wich will
        // be completed by the button_read() function.
        Serial.println("on set status_interruption_btn_droit à" + String(interruption_declanche_btn_droit));
        // Le status de l'interrupion passe à true
        status_interruption_btn_droit = interruption_declanche_btn_droit;  // keep this ISR 'quiet' until button read fully completed
      }
    }
  }
} 
// On rentre dans cette fonction à chaque changement d'état du bouton, c'est à dire pour tous les 
// rebonds du bouton
// Le but est de renseigner la variable "status_interruption" pour qu'elle passe à "true"
// dès le premier état haut vu sur le bouton
void interruption_bouton_gauche()
{
    // Si l'initialisation est bien terminée
  if (initialisation_termine == true)
  { //  all variables are initialised so we are okay to continue to process this interrupt
    Serial.println("si trigged" + String(status_interruption_btn_gauche) +" "+String(!interruption_declanche_btn_gauche));
    // Si le status de l'interruption correspond (par default: false) correspond à l'inverse d'une interruption déclanché (!true = false)
    if (status_interruption_btn_gauche == !interruption_declanche_btn_gauche) {

      // new interrupt so okay start a new button read process -
      // now need to wait for button release plus debounce period to elapse
      // this will be done in the button_read function
      // Si le niveaux de la pin du bouton est en niveau haut
      if (digitalRead(pin_boutton_gauche) == HIGH) {
        // button pressed, so we can start the read on/off + debounce cycle wich will
        // be completed by the button_read() function.
        Serial.println("on set status_interruption_btn_gauche à" + String(interruption_declanche_btn_gauche));
        // Le status de l'interrupion passe à true
        status_interruption_btn_gauche = interruption_declanche_btn_gauche;  // keep this ISR 'quiet' until button read fully completed
      }
    }
  }
} 

// fonction permettant de lire l'état du bouton
bool read_button_droit() {
  int button_reading;
  // Variables statiques car nous devons conserver les anciennes valeurs entre les appels de fonction
  static bool commutation = false;
  static long int minuteur;

  // Serial.println("commutation :" + String(commutation)+", minuteur :"+minuteur);
  // Si le status de l'interruption correspond (par default: false, true quand une interruption à été détecté) correspond à une interruption déclanché (true)
  if (status_interruption_btn_droit == interruption_declanche_btn_droit) {
    // Une interruption a été déclenchée sur ce bouton, 
    // il faut donc maintenant terminer le processus de lecture du bouton, 
    // c'est-à-dire attendre qu'il soit relâché et que le temps de rebond soit écoulé
    button_reading = digitalRead(pin_boutton_droit);
    // Si le bouton est toujours maintenu, et donc sur un niveau haut
    if (button_reading == HIGH) {
      commutation = true;
      minuteur = millis();
    }
    // Si le bouton est passé par un état haut et que maintenant il est sur un état bas
    if (commutation && button_reading == LOW) {
      // Si le temps de l'état haut à durée suffisament longtemps
      if (millis() - minuteur >= temps_bouton) {
        // remise des états des variables aux valeurs par default
        commutation = false;             
        status_interruption_btn_droit = !interruption_declanche_btn_droit; 
        // retour de la fonction comme quoi la bouton à été pressé
        return true;          
      }
    }
  }
  // retour de la fonction comme quoi la bouton à été correctement pressé
  return false;
} 

// fonction permettant de lire l'état du bouton
bool read_button_gauche() {
  int button_reading;
  // Variables statiques car nous devons conserver les anciennes valeurs entre les appels de fonction
  static bool commutation = false;
  static long int minuteur;

  // Serial.println("commutation :" + String(commutation)+", minuteur :"+minuteur);
  // Si le status de l'interruption correspond (par default: false, true quand une interruption à été détecté) correspond à une interruption déclanché (true)
  if (status_interruption_btn_gauche == interruption_declanche_btn_gauche) {
    // Une interruption a été déclenchée sur ce bouton, 
    // il faut donc maintenant terminer le processus de lecture du bouton, 
    // c'est-à-dire attendre qu'il soit relâché et que le temps de rebond soit écoulé
    button_reading = digitalRead(pin_boutton_gauche);
    // Si le bouton est toujours maintenu, et donc sur un niveau haut
    if (button_reading == HIGH) {
      commutation = true;
      minuteur = millis();
    }
    // Si le bouton est passé par un état haut et que maintenant il est sur un état bas
    if (commutation && button_reading == LOW) {
      // Si le temps de l'état haut à durée suffisament longtemps
      if (millis() - minuteur >= temps_bouton) {
        // remise des états des variables aux valeurs par default
        commutation = false;             
        status_interruption_btn_gauche = !interruption_declanche_btn_gauche; 
        // retour de la fonction comme quoi la bouton à été pressé
        return true;          
      }
    }
  }
  // retour de la fonction comme quoi la bouton à été correctement pressé
  return false;
}