// telecommande aquarium led centre  ( 5592323 )
// telecommande lumiere meuble tv ( on/off 1601921 )  gradateur (+ 1601924) (- 1601922 )
// telecommande lumiere lit ( on/off 12612369 )  gradateur (+ 12612372) (- 12612370 )
// telecommande desodirisant couloir ( on/off 1864065 )  gradateur (+ 1864068) (- 1864066 )
//prise 1 on Received 4277585 / 24bit Protocol: 1
//prize 1 off Received 4277588 / 24bit Protocol: 1
//prize 2 on Received 4280657 / 24bit Protocol: 1
//prize 2 off Received 4280660 / 24bit Protocol: 1
//prise 3 on Received 4281425 / 24bit Protocol: 1
//prize 3 off Received 4281428 / 24bit Protocol: 1
//prise 4 on Received 4281617 / 24bit Protocol: 1
//prize 4 off  Received 4281620 / 24bit Protocol: 1

/*
Arduino Masterbalby Controller
 sonde temps ds18B20 pin 13 = Température Sensor
 Analog Pin 0 = Température Sensor
 Digital Pin 6 = // la pin de connexion de mon emmeteur 433 mhz
 Digital Pin 12 = LCD
 Digital Pin 9 = LCD
 Digital Pin 5 = LCD
 Digital Pin 3 = LCD
 Digital Pin 2 = LCD
 Digital Pin 6 = 433 mhz

 Digital Pin 10 = OutputLED1 //days
 Digital Pin 11 = OutputLED2 //moon

 Branchement du module RTC DS1307
 - DS1307 -> Arduino
 - SDA -> Pin A4
 - SCL -> Pin A5
 - GND -> GND
 - VCC+ -> +5V
 */

#include <stdio.h>
#include <stdlib.h>
#include <Wire.h>
#include <RTClib.h>
#include <Time.h>
#include <LiquidCrystal.h>
#include <WProgram.h>
#include <DS1307.h>
#include <RCSwitch.h>
#include <OneWire.h> // Inclusion de la librairie OneWire
RCSwitch mySwitch = RCSwitch();
RTC_DS1307 RTC;

//temperature ds18B20
#define DS18B20 0x28     // Adresse 1-Wire du DS18B20
#define BROCHE_ONEWIRE 13 // Broche utilisée pour le bus 1-Wire

OneWire ds(BROCHE_ONEWIRE); // Création de l'objet OneWire ds

// Fonction récupérant la température depuis le DS18B20
// Retourne true si tout va bien, ou false en cas d'erreur
boolean getTemperature(float *temp1){
  byte data[9], addr[8];
  // data : Données lues depuis le scratchpad
  // addr : adresse du module 1-Wire détecté

  if (!ds.search(addr)) { // Recherche un module 1-Wire
    ds.reset_search();    // Réinitialise la recherche de module
    return false;         // Retourne une erreur
  }

  if (OneWire::crc8(addr, 7) != addr[7]) // Vérifie que l'adresse a été correctement reçue
    return false;                        // Si le message est corrompu on retourne une erreur

  if (addr[0] != DS18B20) // Vérifie qu'il s'agit bien d'un DS18B20
      return false;         // Si ce n'est pas le cas on retourne une erreur

  ds.reset();             // On reset le bus 1-Wire
  ds.select(addr);        // On sélectionne le DS18B20

  ds.write(0x44, 1);      // On lance une prise de mesure de température
  delay(8);             // Et on attend la fin de la mesure

  ds.reset();             // On reset le bus 1-Wire
  ds.select(addr);        // On sélectionne le DS18B20
  ds.write(0xBE);         // On envoie une demande de lecture du scratchpad

  for (byte i = 0; i < 9; i++) // On lit le scratchpad
    data[i] = ds.read();       // Et on stock les octets reçus

  // Calcul de la température en degré Celsius
  *temp1 = ((data[1] << 8) | data[0]) * 0.0625;

  // Pas d'erreur
  return true;
}

//Définition de structure

struct Heure{
  int h;
  int m;
};


int minut;
//int heure;
int seconde;
int date;
int mois;
int annee;
int temps_perso = 0;
int sensorPin = 0;
int relais_pompe = 8;
int OutputLED1 = 10;//allume rampe led 1 progressivement en fonction de l heure
int OutputLED2 = 11;//allume rampe led 1 progressivement en fonction de l heure
int heater_on_temp = 24;  //allume chauffage à cette température
int heater_off_temp = 26; //éteint le chauffage à cette température




boolean isCode1Emitted= false;
Heure heure_pompe_on={7,30};
Heure heure_pompe_off={21,30};

Heure heure_emission_on={7,30};
Heure heure_emission_off ={21,30};

Heure heure_OutputLED1_on={7,30};
Heure heure_OutputLED1_off={21,30};
unsigned int temps_allumage=10;//temps d'allumage pour le fading en minutes

Heure heure_OutputLED2_on={21,59};
Heure heure_OutputLED2_off={7,30};

Heure heure={0,0};//contient l'heure actuelle




LiquidCrystal lcd(12, 2, 5, 4, 3, 9);

void setup() {


  Serial.begin(9600);
  mySwitch.enableTransmit(6);  // la pin de connexion de mon émetteur
  mySwitch.setProtocol(1); // le protocol (cf screenshot ci dessus, que je mets donc à 1)
  mySwitch.setRepeatTransmit(4); // nombre de répétitions du signal histoire d'être sur que la prise recevra le signal
  lcd.begin(16, 2);
  lcd.print("MasterBalby 2.1");
  lcd.setCursor(0, 1) ;
  lcd.print("Gestion Aqua");
  delay(1700);
  lcd.clear();
  lcd.print(" initialisation");
  delay(1700);
  lcd.clear();
  Wire.begin();
  RTC.begin();
  pinMode(OutputLED1, OUTPUT);  // digital pin pour OutputLED1 en sortie
  pinMode(OutputLED2, OUTPUT);  // digital pin pour OutputLED2 en sortie
  pinMode(relais_pompe, OUTPUT);
  digitalWrite(relais_pompe, LOW);
  // pinMode(moon_light_1, OUTPUT);
  // digitalWrite(moon_light_1, LOW);
  Serial.println("Start program");
  lcd.print("Start program");
  delay(2700);
  lcd.clear();


  //Récupérer l heure du DS1307 ********************************************************************
  if (! RTC.isrunning())
  {
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    //RTC.adjust(DateTime(__DATE__, __TIME__));
  }
}
void displayTime(DateTime dateTime)
{
  lcd.setCursor(0, 1);
  if (dateTime.hour() < 10) // Si les heure sont inférieur à 10
  {
    lcd.print ("0");
  }
  lcd.print(dateTime.hour(), DEC);
  lcd.print(':');
  if (dateTime.minute() <10) // Si les minute sont inférieurl à 10
  {
    lcd.print ("0");
  }
  lcd.print(dateTime.minute(), DEC);
  lcd.print(':');
  if (dateTime.second() < 10) // Si les second sont inférieurl à 10
  {
    lcd.print ("0");
  }
  lcd.print(dateTime.second(), DEC);
  lcd.print(' ');
  temps_perso = dateTime.hour()*60 + dateTime.minute();   // Mise à jour de temps_perso
  heure.h=dateTime.hour();//mise à jour de l'heure
  heure.m=dateTime.minute();

}


//Affichage température DS18B20***************************************************************************

void displayTemperature1(int temp1)
{
  lcd.setCursor(8, 0);
  lcd.print("Temp:");
  lcd.print(temp1);
  lcd.println("C");
  lcd.print(' ');
  delay(20);
}

void Afficher_statut(){
  Serial.print("Time= ");
  Serial.print(heure.h);
  Serial.print("H");
  if(heure.m<10)
  {
    Serial.print(0);
  }
  Serial.print(heure.m);
  Serial.print("       isCode1Emitted= ");
  Serial.println(isCode1Emitted);
}

void programmer_moon(){
  boolean allumage_necessaire(false);

  allumage_necessaire |= heure.h>=heure_pompe_on.h && heure.m>=heure_pompe_on.m;
  allumage_necessaire &= heure.h<=heure_pompe_off.h && heure.m<=heure_pompe_off.m;

  digitalWrite(relais_pompe, !allumage_necessaire);
 }


//Calcule la valeur à envoyer à une led pour l'allumer en fading
unsigned int allumage_progressif(unsigned int h_on,unsigned int m_on, unsigned int h_off,unsigned int m_off, unsigned long const& temps_allumage){
  unsigned int consigne = 0;//contient la valeur à envoyer à la PWM

  //contient le nombre de secondes écoulées depuis minuit, c'est à dire l'heure actuelle en secondes
  unsigned long t(heure.h);
  t*=3600;
  t+=heure.m*60+RTC.now().second();
  Serial.print("Heure actuelle= ");
  Serial.print(t);
  //contient l'heure de démarrage de la led1 en secondes
  unsigned long t_on=h_on;
  t_on*=3600;
  t_on+=m_on*60;
  Serial.print("    t_on= ");
  Serial.print(t_on);
  //contient l'heure d'extinction de la led1 en secondes
  unsigned long t_off=h_off;
  t_off*=3600;
  t_off+=m_off*60;
  Serial.print("    t_off= ");
  Serial.print(t_off);
  if (t>=t_on && t<=t_off)
  {
    if (t<(t_on+temps_allumage*60)){
      consigne = int(((t-t_on)*255)/(temps_allumage*60));//on gère l'allumage en linéaire
    }
    else if (t<(t_off-temps_allumage*60)){
      consigne= 255;
    }
    else {
      float p = float(t-(t_off-temps_allumage*60))/float(temps_allumage*60);
      Serial.print("   p= ");
      Serial.print(p);
      consigne=int((1-p)*255.0);
    }
  }
  Serial.print("   Consigne= ");
  Serial.println(consigne);
  return consigne;
}

void loop() {
  //Afficher_statut();


  //Affichage temps*****************************************************************************
  displayTime(RTC.now());

  //Affichage température***********************************************************************
  //    displayTemperature(temp);

  //Affichage température ds18B20***********************************************************************
  float temp1;

  // Lit la température ambiante à ~1Hz
  if(getTemperature(&temp1))
  {
    displayTemperature1(temp1);
  }
  //programation relais**************************************************************************

  programmer_moon();


  //programation emission on led central **************************************************************************
  //Serial.print("emission_on : ") ;
  //Serial.println(emission_on);
  if((heure.h==heure_emission_on.h) && (heure.m==heure_emission_on.m) && !isCode1Emitted)
  {
    Serial.print("On entre dans le premier if emission et isCode1Emitted = ");
    Serial.println(isCode1Emitted);
    mySwitch.send(4277585, 24); // on allume la pompe en envoyant le bon signal lu via l'emeteur
    delay(20);
    mySwitch.send(5592323, 24); // on allume les led en envoyant le bon signal lu via l'emeteur
    isCode1Emitted= true;//
    Serial.print("On sort du premier if et isCode1Emitted = ");
    Serial.println(isCode1Emitted);

  }

  //programation emission off led central **************************************************************************

  if((heure.h==heure_emission_off.h) && (heure.m ==heure_emission_off.m) && isCode1Emitted)
  {
    Serial.print("On entre dans le deuxième if emission et isCode1Emitted = ");
    Serial.println(isCode1Emitted);
    mySwitch.send(5592323, 24); // on allume les led en envoyant le bon signal lu via l'emeteur
    delay(20);
    mySwitch.send(4277588, 24); // on eteint la pompe en envoyant le bon signal lu via l'emeteur
    isCode1Emitted= false;
    Serial.print("On sort du deuxième if et isCode1Emitted = ");
    Serial.println(isCode1Emitted);
  }



  //****************Day Lights**********************************************************************************

  analogWrite(OutputLED1,allumage_progressif(heure_OutputLED1_on.h,heure_OutputLED1_on.m,heure_OutputLED1_off.h,heure_OutputLED1_off.m,temps_allumage));//


  //****************Moon Lights**********************************************************************************

 analogWrite(OutputLED2,allumage_progressif(heure_OutputLED2_on.h,heure_OutputLED2_on.m,heure_OutputLED2_off.h,heure_OutputLED2_off.m,temps_allumage));