/*---------------------------------------------------------------
 * Aquaruim 
 * gestion d'un aquaruim
 * Ajouter 2 ventilateurs pour abaisser la température de l'eau
 * de l'aquarium, en cas de canicule 
Auteur : Desurmont Patrick
Date   : 20/07/2021*/
#define Version   5.18     //version
 /*----------------------------------------------------------------*/
 /* DS18S20 Temperature Sensor Module sample project
*/
#include <OneWire.h>
#include "LiquidCrystal.h"
#include <SoftwareSerial.h>
#include "Servo.h"
#include "SPI.h"
#include <Wire.h>
#include <ds3231.h>
#include "VirtuinoBluetooth.h"
#define Offset 0.00            //deviation compensate
#define samplingInterval 20
#define printInterval 800
#define titre1 "Aqua-Ardui V%s"
#define titre2 "10/2021 Mega2560"
#define ArrayLenth  40    //times of collection
#define MSG   "-1@"
#define btnDT  1
#define btnHT  2
#define btnBS  3
#define btnGH  4
#define btnST  5
#define btnNC  0
#define tempOffSet 0.00
#define responseTime 20
#define VOLTAGE 5.00    //system voltage
#define OFFSET 0        //zero drift voltage
#define forcer_eclairage   1
#define forcer_nourriture  2
#define rien               -1
#define lngTab             21
#define nbrPar             16
#define nbrFon              8
#define PhMaxi             14
#define ArrayLenth  40    //times of collection
#define orpPin 1     
#define BUFF_MAX 30
#define BUFF_MAXI 200
#define Status 50
#define Enable 51
#define Jours7  7
#define Jours15 15
#define Jours21 21
#define Offset -5.00 //deviation compensate


/*-----------------------------------------------------
 * Les relais ou E/S
 ------------------------------------------------------*/
#define LED                13 
#define Electro_Eclaire    10
#define PinDS18S20         31
#define Relay_Nourriture   32
#define Relay_Eclairage    34
#define Ventilateur1  	   29    // limite de 29° degré 
#define Ventilateur2       30    // Supérieur à 30°
#define pinServo           44    // pin pwm 44 45 46

// Interruption 5 pin 18
/*-------------------------------------------------------
 * Gestion de la mémoire
 --------------------------------------------------------*/
 #define Vtemperature      0
 #define VtempBME280       1
 #define Vpression         2
 #define Vdate			       3
 #define Vtime             4
 #define Vannee            5
 #define Veau              6
 #define Vacquitter        7
 #define VAutomatique      12
/*-------------------------------------------------------
 * Gestion sensors
 --------------------------------------------------------*/ 
 #define Sensors           3
 #define SensorTemp      0
 #define SensorDebitmeter  2
 #define MAX_POS           90
 #define MIN_POS           0  

/*--------------------------------------------------------
 *  Appariel Bluetooth
 --------------------------------------------------------*/
 #define BTTemperature    1
 #define BTBME280         2
 #define BTreglageBME280  3
 #define BTMiniPH         4
 #define BTMaxiPH         5
 #define BTPhmetre        6
 #define BTDebimetre      7
 #define BTAlarmeDeb      8
/*--------------------------------------------------------
 * Gestion du bluetooth
 --------------------------------------------------------*/ 
#define bt_ERROR_PIN       1
#define bt_ERROR_VALUE     2
#define bt_ERROR_TYPE      3
#define bt_ERROR_SIZE      4
#define bt_ERROR_PASSWORD  5
#define bt_ERROR_COMMAND   6
#define bt_ERROR_UNKNOWN   7 
/*--------------------------------------------------------
 * a changer selon les envie
 --------------------------------------------------------*/

#define tps_debut_eclairage "08:30:00"
#define tps_fin_eclairage   "22:00:00"
#define distribution1       "08:35:00"
#define distribution2       "19:00:00"
#define Temperature         "24 27 30"              // Temperature mini: normal: maxi
#define ValeurPh             "6 7 8"                // Ph  Acide : Normal : dure
#define intervalle          2                       // en seconde
void(* resetFunc) (void) = 0;                       //declare reset function @ address 0
SoftwareSerial BTSerial =  SoftwareSerial(52,53);   // ne pas utiliser les pins 53,52,51,50
VirtuinoBluetooth BTVirtuino(BTSerial);        
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
Servo myservo;


struct ate {
                         char sep; 
                         int Data1;
                         int Data2;
                         int Data3;
                         byte etat;
                   };
               
struct alar {
                         bool Tps1;
                         String Start1;
                         String End1;
                         bool Tps2;
                         String distr1;
                         String distr2;
                      
             };   
struct Dial  {
                 bool bluetooth;
                 bool excel;
                 bool echo;
                 const int timeout;
               };  
                                
typedef struct coordonnes  {
                 short a;
                 short b;
             };  

struct lim {
               int debut;
               int fin; 
           };
           
byte IconBluetooth[8] = {
  0b00110,
  0b10101,
  0b01101,
  0b00110,
  0b00110,
  0b01101,
  0b10101,
  0b00110
};

byte IconEclairage[8] = {
  0b00100,
  0b00100,
  0b01010,
  0b10001,
  0b10001,
  0b11111,
  0b01010,
  0b10001
};

byte IconNourriture[8] = {
  0b10001,
  0b11111,
  0b10001,
  0b10001,
  0b10101,
  0b01010,
  0b00100,
  0b01010
};

byte IconRefroidir[8] = {
  0b00000,
  0b00000,
  0b00000,
  0b01110,
  0b11011,
  0b10101,
  0b11011,
  0b01110
};

byte IconRefroidir2[8] = {
  0b01010,
  0b10101,
  0b00001,
  0b01110,
  0b11011,
  0b10101,
  0b11011,
  0b01110
};

byte IconEau[8] = {
  0b01010,
  0b10101,
  0b00000,
  0b01010,
  0b10101,
  0b00000,
  0b01010,
  0b10101
};

byte IconNettoyage[8] = {
  0b01111,
  0b10001,
  0b10011,
  0b11110,
  0b10100,
  0b10011,
  0b10001,
  0b11111
};

byte IconExcel[8] = {
  0b11111,
  0b10001,
  0b01000,
  0b00100,
  0b00100,
  0b01000,
  0b10001,
  0b11111
};

typedef struct chmps_saisie {
 struct coordonnes frmt_coord[lngTab]={{0,0},{0,1},{0,2},{1,3},{1,4},{1,5},{2,6},{2,7},{3,6},{3,7},{4,8},{4,9},{4,10},{5,8},{5,9},{5,10},{6,11},{6,12},{6,13},{7,14},{7,15}};
 const short nbr[nbrFon]={3,3,2,2,3,3,3,2};
 struct lim saisies[nbrPar]={{1,31},{1,12},{2000,2100},{0,23},{0,59},{0,59},{0,23},{0,59},{0,23},{0,59},{0,59},{20,22},{23,26},{27,29},{3,10},{10,33}};
 const char *frmt_ligne1[nbrFon]={"Reglage la Date","Reglage l'Heure","Eclairage Debut","Eclairage Fin","Dis Nourriture 1","Dis Nourriture 2","Temperature Eau","Debit Eau L/Mn"};
 const char *frmt_ligne2[nbrPar]={">%02d</%02d/%04d","%02d/>%02d</%04d","%02d/%02d/>%04d<",">%02d<:%02d:%02d","%02d:>%02d<:%02d","%02d:%02d:>%02d<",">%02d<:%02d Heure","%02d:>%02d< Minute",
 ">%02d<:%02d:%02d Heure","%02d:>%02d<:%02d Minut","%02d:%02d:>%02d< Duree",">%02d< %02d %02d Tbase","%02d >%02d< %02d Tnor","%02d %02d >%02d< Thaut",">%02d< %02d Val Mini","%02d >%02d< Val Maxi"};
 struct ate donnee;
};
typedef struct chmps_capteurs {
   struct ate paramatre[Sensors]={{0,0,0},{6,7,8},{3,14,0}}; 
   float valeur_sensors[Sensors]={0,0,0};
};
typedef struct alarmeEau {
	byte changementeaujours;
	byte Jour;
  boolean Etat;
};	
 

double orpValue; 
unsigned long Temps[5] ={0,0,0,0,0};               
struct ts t;
struct chmps_capteurs sensor; 
struct chmps_saisie frmt;
struct alarmeEau EAU = {0,0,false}; 
int tache=0;
bool flg_Affichage=false;
struct alar set_al = {true,tps_debut_eclairage,tps_fin_eclairage,true,distribution1,distribution2};
struct Dial dialogue ={false,false,false,2000};


/************************************************************************/
/* Jour de la semaine                                                   */
/************************************************************************/
 byte dayOfWeek(byte d, byte m, int y)
 {
	static int t[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
    y -= m < 3;
	byte jour=((y + y/4 - y/100 + y/400 + t[m-1] + d) % 7) + 1; // 01 - 07, 01 = Sunday  
	return jour;
 }	 
 
void electro_eclairage(int etat)
{
  if (BTVirtuino.vMemoryRead(Electro_Eclaire)==1) digitalWrite(Electro_Eclaire,HIGH);
      else digitalWrite(Electro_Eclaire,etat);
}

void ventillateurs(int number)
{
  if (BTVirtuino.vMemoryRead(number)==1) digitalWrite(number,HIGH);
	   else digitalWrite(number,LOW);
}
 
struct ate Reglages(int etat,struct ate donnes,String info)
{
   String buf="";
   byte etape=0;
   char incomingByte;
   donnes.etat=0; 
   for (int pos = 0; pos <= info.length(); pos++)
      {
       incomingByte = info.charAt(pos);
       if ((incomingByte==donnes.sep) || (pos==info.length()))
       {
           switch(++etape)
           {
             case 1:
                {
                    donnes.Data1=buf.toInt();
                    buf="";
                    break;
                }
             case 2:
                {
                    donnes.Data2=buf.toInt(); 
                    buf="";
                    break;
                }   
            case 3:
                {
                    donnes.Data3=buf.toInt();
                    buf="";
                    donnes.etat=etat; 
                    break; 
                }            
            }
       }
       else
       {
         buf += incomingByte;
       }
   }
  return donnes;  
}

void confirmation(int etat,int info1,int info2,int info3)
{
  uint8_t flags[5] = { 0, 0, 0, 1, 1 };
  uint8_t flags1[4] = { 0, 0, 1, 1 };
  switch (etat) 
  {
    case 1:
        t.hour=info1;
        t.min=info2;
        t.sec=info3;
        DS3231_set(t);
        break;
   case 2:
        t.mday=info1;
        t.mon=info2;
        t.year=info3;
        DS3231_set(t);
        break;
   case  3:
        DS3231_set_a1(0, info2, info1, 0,  flags);
        DS3231_set_creg(DS3231_INTCN | DS3231_A1IE);
        set_al.Tps1=info3;
        break;
   case 4:
        DS3231_set_a2(info2, info1, 0, flags1);
        DS3231_set_creg(DS3231_INTCN | DS3231_A2IE);
        set_al.Tps2=info3;
        break;  
    }
}

void reglage(String Etat,String info)
{
  struct ate td;
  char buff[BUFF_MAX];
  DS3231_get(&t);
  if (info==MSG) reglage(Etat,Serial_readln(3000));
  if (Etat=="Hr")
  {
    td=Reglages(1,{':',t.hour,t.min,t.sec,0},info);
    confirmation(td.etat,td.Data1,td.Data2,td.Data3);
  } 
  else if (Etat=="Dt")
  {
    td=Reglages(2,{'/',t.mday,t.mon,t.year,0},info);
     confirmation(td.etat,td.Data1,td.Data2,td.Data3);   
  } 
  else if (Etat=="A1")
  {
    td=Reglages(3,{':',t.hour,t.min,t.sec,0},info);
     confirmation(td.etat,td.Data1,td.Data2,td.Data3);
    DS3231_get_a1(&buff[0],BUFF_MAX);
  } 
  else if (Etat=="A2")
  {
    td=Reglages(4,{':',t.hour,t.min,t.sec,0},info);
    confirmation(td.etat,td.Data1,td.Data2,td.Data3);
    DS3231_get_a2(&buff[0],BUFF_MAX);
  } 
  else if (Etat=="EL")
  {
    digitalWrite(Electro_Eclaire,HIGH);
  } 
  else if (Etat=="CL")
  {
    sei();
    Serial.println("Reset");
    Serial.flush();
    resetFunc();
  } 
} 

 /*****************************************************
  *  Affichage sur l'écran 
  *  '0' = Affiche les 2 lignes
  *  '1' = Affiche la premiére ligne
  *  '2' = Affiche la deuxiéme ligne
  * Par défaut le Status et les 2 lignes
 *****************************************************/
void message_lcd(char Etat,char *dialog,char *msg)
{
 switch(Etat)
   {
    case '0':
      lcd.clear();
      lcd.print(dialog);
      lcd.setCursor(0, 1);
      lcd.print(msg);
    break;
    case '1':
      if (sizeof(dialog)>0) lcd.setCursor(atoi(dialog),0);
        else lcd.setCursor(0, 0);
      lcd.print(msg);
    break;
    case '2':
      if (sizeof(dialog)>0) lcd.setCursor(atoi(dialog),1);
        else lcd.setCursor(0, 1);
      lcd.print(msg); 
    break;
    default:
       lcd.clear();
       lcd.print(Etat);
       lcd.print(" <- ");
       lcd.print(dialog);
       lcd.setCursor(0, 1);
       lcd.print(msg);
     break;   
    }    
}

/************************************************
 * Affichage des icones 
 * 
 ************************************************/
 
 void affichage_icones()
 {
    lcd.setCursor(14, 1);
    dialogue.bluetooth=(digitalRead(Status)==HIGH);
     if (dialogue.bluetooth) lcd.write((uint8_t)0);
        else lcd.write(" ");
	  lcd.setCursor(13, 1);	
     if (digitalRead(Relay_Eclairage)==HIGH) lcd.write((uint8_t)1);
        else lcd.write(" ");
	  lcd.setCursor(12, 1);	
     if (digitalRead(Relay_Nourriture)==HIGH) lcd.write((uint8_t)2);
           else lcd.write(" ");
    lcd.setCursor(15, 1);	
     if (EAU.changementeaujours>=Jours15) lcd.write((uint8_t)6);	
	     else if (EAU.changementeaujours>=Jours7) lcd.write((uint8_t)5);
		     else lcd.write(" "); 
    lcd.setCursor(15, 0); 
     if (dialogue.excel) lcd.write((uint8_t)7);
        else lcd.write(" ");    
	  lcd.setCursor(14, 0);
	 if (digitalRead(Ventilateur1)==HIGH) lcd.write((uint8_t)4); 
	   else lcd.write(" ");
   lcd.setCursor(13, 0);       	
 if (digitalRead(Ventilateur2)==HIGH) lcd.write((uint8_t)3);
        else lcd.write(" ");        
 } 

/*-------------------------------------------------
 *  Gestion des 5 touches
 -------------------------------------------------*/

 int read_LCD_buttons()
 {               // read the buttons
    int adc_key_in  = 0;
    adc_key_in = analogRead(A0); 
    if (adc_key_in <= 1000)  electro_eclairage(HIGH);
	  if (adc_key_in > 1000) return btnNC; 
    if (adc_key_in < 100)  return btnDT;  
    if (adc_key_in < 250)  return btnHT; 
    if (adc_key_in < 450)  return btnBS; 
    if (adc_key_in < 650)  return btnGH; 
    if (adc_key_in < 850)  return btnST; 
    return btnNC;            
}

/*--------------------------------------------
 *  recupérer les informations données
 ---------------------------------------------*/

void recuperer_donnees(short num)
{
   if (frmt.frmt_coord[num].a==0) frmt.donnee=ConverDatetoint(false);
     else if (frmt.frmt_coord[num].a==1) frmt.donnee=ConverDatetoint(true);
      else if (frmt.frmt_coord[num].a==2) frmt.donnee=ConverStrtoint(set_al.Start1);
       else if (frmt.frmt_coord[num].a==3) frmt.donnee=ConverStrtoint(set_al.End1);
         else if (frmt.frmt_coord[num].a==4) frmt.donnee=ConverStrtoint(set_al.distr1); 
          else if (frmt.frmt_coord[num].a==5) frmt.donnee=ConverStrtoint(set_al.distr2); 
            else if (frmt.frmt_coord[num].a==6) frmt.donnee=sensor.paramatre[SensorTemp]; 
              else if (frmt.frmt_coord[num].a==7) frmt.donnee=sensor.paramatre[SensorDebitmeter]; 
}

/*--------------------------------------------
 *  Sauvegarder les informations données
 ---------------------------------------------*/
 
void Sauvegarder_donnees(short num)
{
    if (frmt.frmt_coord[num].a==0) DS3231_set(ConverinttoDat(false,frmt.donnee));
     else if (frmt.frmt_coord[num].a==1) DS3231_set(ConverinttoDat(true,frmt.donnee));
      else if (frmt.frmt_coord[num].a==2) { 
        set_al.Start1=ConverInttostr(frmt.donnee);
        if (set_al.Tps1) confirmer_alarme(1,frmt.donnee);  
      }
       else if (frmt.frmt_coord[num].a==3) {
        set_al.End1=ConverInttostr(frmt.donnee);
        if (!(set_al.Tps1)) confirmer_alarme(1,frmt.donnee);  
       }
         else if (frmt.frmt_coord[num].a==4) {
          set_al.distr1=ConverInttostr(frmt.donnee); 
          if (set_al.Tps2) confirmer_alarme(2,frmt.donnee);
         }
          else if (frmt.frmt_coord[num].a==5) { 
            set_al.distr2=ConverInttostr(frmt.donnee);
            if (!(set_al.Tps2)) confirmer_alarme(2,frmt.donnee); 
          } 
           else if (frmt.frmt_coord[num].a==6) sensor.paramatre[SensorTemp]=frmt.donnee;
             else if (frmt.frmt_coord[num].a==7) sensor.paramatre[SensorDebitmeter]=frmt.donnee;
 
}

/*--------------------------------------------
 *  Affiche les données 
 ---------------------------------------------*/
 
void affichage_donnees(short num)
{
   char buff[BUFF_MAX];
   if ((frmt.frmt_coord[num].a==2) || (frmt.frmt_coord[num].a==3) || (frmt.frmt_coord[num].a==7))
  {
     snprintf(buff, BUFF_MAX, frmt.frmt_ligne2[frmt.frmt_coord[num].b], frmt.donnee.Data1, frmt.donnee.Data2);
     frmt.donnee.Data3=0;
     message_lcd('0',frmt.frmt_ligne1[frmt.frmt_coord[num].a],buff);
  }
  else
  {
     snprintf(buff, BUFF_MAX, frmt.frmt_ligne2[frmt.frmt_coord[num].b], frmt.donnee.Data1, frmt.donnee.Data2, frmt.donnee.Data3);
     message_lcd('0',frmt.frmt_ligne1[frmt.frmt_coord[num].a],buff);
  }
}

/*--------------------------------------------
 *  Incrémentation de la donnée
 *  Heure, Minute, etc..
 ---------------------------------------------*/
void Increment_Donnee(short num,short idx)
{
  switch (idx) 
   {
    case 0:
          if (frmt.donnee.Data1<frmt.saisies[frmt.frmt_coord[num].b].fin) frmt.donnee.Data1++;
            else frmt.donnee.Data1=frmt.saisies[frmt.frmt_coord[num].b].debut;
          break;
    case 1:
          if (frmt.donnee.Data2<frmt.saisies[frmt.frmt_coord[num+idx].b].fin) frmt.donnee.Data2++;
            else frmt.donnee.Data2=frmt.saisies[frmt.frmt_coord[num+idx].b].debut;
         break;
    case 2:
         if (frmt.donnee.Data3<frmt.saisies[frmt.frmt_coord[num+idx].b].fin) frmt.donnee.Data3++;
            else frmt.donnee.Data3=frmt.saisies[frmt.frmt_coord[num+idx].b].debut;
         break;
    }      
}

/*--------------------------------------------
 *  Décrémentation de la donnée
 *  Heure, Minute, etc..
 ---------------------------------------------*/
void Decrement_Donnee(short num,short idx)
{
  switch (idx) 
   {
    case 0:
          if (frmt.donnee.Data1>frmt.saisies[frmt.frmt_coord[num].b].debut) frmt.donnee.Data1--;
            else frmt.donnee.Data1=frmt.saisies[frmt.frmt_coord[num].b].fin;
          break;
    case 1:
          if (frmt.donnee.Data2>frmt.saisies[frmt.frmt_coord[num+idx].b].debut) frmt.donnee.Data2--;
            else frmt.donnee.Data2=frmt.saisies[frmt.frmt_coord[num+idx].b].fin;
         break;
    case 2:
         if (frmt.donnee.Data3>frmt.saisies[frmt.frmt_coord[num+idx].b].debut) frmt.donnee.Data3--;
            else frmt.donnee.Data3=frmt.saisies[frmt.frmt_coord[num+idx].b].fin;
         break;
    }      
}
/*--------------------------------------------
 * Réglage des paramétres
 ---------------------------------------------*/

void Reglage_Fonctions(short num,short Nbr)
{
  short idx=0;
  recuperer_donnees(num);
  affichage_donnees(num);
  while (true) {
  int bp=read_LCD_buttons();
  delay(400);
   switch (bp) 
   {
    case btnST:
         while (read_LCD_buttons()!=btnNC) { };
         Sauvegarder_donnees(num);
         return ;
    case btnDT:
         if (idx<(Nbr-1)) { idx++;
         affichage_donnees(num+idx);
         }
         break;
    case btnGH:
         if (idx>0) { idx--;
         affichage_donnees(num+idx);
         }
         break; 
    case btnHT:
         Increment_Donnee(num,idx);
         affichage_donnees(num+idx);
         break;        
    case btnBS:
         Decrement_Donnee(num,idx);
         affichage_donnees(num+idx);
         break;    
   }
  } 
}

/*--------------------------------------------
 * Saisir les paramétres
 ---------------------------------------------*/
void saisie_paramatres()
{
  short num=0;
  for (short idx=0; idx<nbrFon; idx++)
    {
       Reglage_Fonctions(num,frmt.nbr[idx]);
       num+=frmt.nbr[idx];
    }
   
}
/*-------------------------------------------------
 * Attendre la touche et puis relachement
 -------------------------------------------------*/
 
bool attente_Touche(int touche,const int timeout)
{
    long int time = millis();
    while ((time+timeout) > millis())
    {
       int bp=read_LCD_buttons();
       if (bp!=touche) return false;
    }
    while (read_LCD_buttons()!=btnNC) { };
    return true;
}

//-------------------------------------------------------
// on test si on rencoit bien le caractére retour chariot
String Serial_readln(const int timeout)
{
   String buf="";
   char incomingByte;
   long int time = millis();
   if (!(dialogue.excel)) message_lcd('A',"[Excel]","En Cours Lecture");
   while ((incomingByte!='\n') && ((time+timeout) > millis()))
          { 
            if (Serial.available() > 0) 
                {
                    incomingByte = Serial.read();
                     if (incomingByte>(char) 13) buf += incomingByte;
                }  
        } 
  dialogue.excel=((time+timeout) > millis());      
  if (!(dialogue.excel))
  {
         message_lcd('E',"[Excel]","Err : Connexion");
         delay(1000);
         
         return "";
  }  else    
  return buf;  
}
/*------------------------------------------------
Allume l'éclairage de l'aquarium
--------------------------------------------------*/
void activeeclairage()
{
	confirmer_alarme(1,ConverStrtoint(set_al.End1));
  digitalWrite(Relay_Eclairage, HIGH);
	set_al.Tps1=false;
}  
/*--------------------------------------------------
Eteint l'éclairage
----------------------------------------------------*/
void desactiveeclairage()
{
	confirmer_alarme(1,ConverStrtoint(set_al.Start1));
  digitalWrite(Relay_Eclairage, LOW);
  set_al.Tps1=true;
}
/*--------------------------------------------------
Calcul le temps en seconde
---------------------------------------------------*/
int pointerheure(ate donnes) 
 {
  int calcul=0;
	calcul=(donnes.Data1*100)+donnes.Data2;
	return calcul;
 }  
 
/*--------------------------------------------------
Test si l'heure est dans la limite
---------------------------------------------------*/  
 bool limiteheure(ate deb,ate fin,struct ts t)
 {
	ate donnes;
	int heures;
	donnes.Data1=t.hour;
  donnes.Data2=t.min;
  donnes.Data3=t.sec;
	heures=pointerheure(donnes);
	if ((heures>=pointerheure(deb)) && (heures<=pointerheure(fin))) return true;
	   else return false;
	
 }
/*-------------------------------------------------
 * initialiser les entrées et Sorties
 -------------------------------------------------*/
void setup()
{
  String buff="";
  char buffs[BUFF_MAX];
  char str_version[6];
  Serial.begin(9600);
  BTSerial.begin(9600);                                               // RISING to trigger when the pin goes from low to high,
  pinMode(Status, INPUT);
  pinMode(Enable, OUTPUT);
  pinMode(pinServo, OUTPUT);
  myservo.attach(pinServo);                    // attachement du servo moteur
  myservo.write(MIN_POS);
  
   /*--------------------------------------------
      Bluetooth
  ----------------------------------------------*/
  BTVirtuino.vPinMode(Electro_Eclaire,OUTPUT);
  BTVirtuino.vPinMode(Relay_Nourriture,OUTPUT);
  BTVirtuino.vPinMode(Relay_Eclairage,OUTPUT);
  BTVirtuino.vPinMode(Ventilateur1,OUTPUT);
  BTVirtuino.vPinMode(Ventilateur2,OUTPUT);
  BTVirtuino.vPinMode(LED,OUTPUT);
  BTVirtuino.vMemoryWrite(11,Version);
  BTVirtuino.vMemoryWrite(VAutomatique,1);
  digitalWrite(pinServo,LOW);
  digitalWrite(Relay_Nourriture, LOW);
  digitalWrite(Relay_Eclairage, LOW);
  digitalWrite(Ventilateur1, LOW);
  digitalWrite(Ventilateur2, LOW);
  digitalWrite(Enable, LOW);
  dtostrf(Version, 3, 2, str_version);
  digitalWrite(Electro_Eclaire, HIGH);
  lcd.begin(16,2);  
  snprintf(buffs, BUFF_MAX, titre1, str_version);   
  message_lcd('0',buffs,titre2);                 
  lcd.createChar(0, IconBluetooth);
  lcd.createChar(1, IconEclairage);
  lcd.createChar(2, IconNourriture);
  lcd.createChar(3, IconRefroidir);
  lcd.createChar(4, IconRefroidir2);
  lcd.createChar(5, IconEau);
  lcd.createChar(6, IconNettoyage);
  lcd.createChar(7, IconExcel);
  Wire.begin();
  delay(1000);
 
  Serial.println("CELL,GET,H1");         // synchronisation de la date et l'heure
  buff=Serial_readln(15000);
  reglage("Dt",buff.substring(0,10));
  reglage("Hr",buff.substring(11));
  if (dialogue.excel) Serial.println("LABEL,TIME,TEMPERATURE,PRESSION"); 
 

 /*----------------------------------------------     
  *  Test les alarmes
  ----------------------------------------------*/
 

	DS3231_get(&t);  
	DS3231_clear_a1f();                     // des alarmes
	DS3231_clear_a2f();
	EAU.Jour=dayOfWeek(t.mday, t.mon, t.year);
	BTVirtuino.vMemoryWrite(Vacquitter,0);
	if (limiteheure(ConverStrtoint(set_al.Start1),ConverStrtoint(set_al.End1),t)) 
		activeeclairage();	
	else
		desactiveeclairage();
	digitalWrite(Electro_Eclaire, LOW);
	DS3231_init(DS3231_INTCN);              // initialisation 
  confirmer_alarme(2,ConverStrtoint(set_al.distr1));
  EAU.changementeaujours=int(BTVirtuino.vMemoryRead(Veau));
}


/*---------------------------------------------
 *  Convertir String 
 ---------------------------------------------*/
 
 struct ate ConverStrtoint(String info)
 {
   String buff="";
   ate donnes;
   buff=info.substring(0,2);
   donnes.Data1=buff.toInt();
   buff=info.substring(3,5);
   donnes.Data2=buff.toInt();
   buff=info.substring(6,info.length()+1);
   donnes.Data3=buff.toInt();
   return donnes;  
 }

 String ConverInttostr(ate donnes)
 {
   char buff[BUFF_MAX];
   snprintf(buff, BUFF_MAX, "%02d:%02d:%02d",donnes.Data1, donnes.Data2, donnes.Data3);
   return buff;  
 }
 
 /*---------------------------------------------
 *  Convertir format date ou heure en entier
 ---------------------------------------------*/
 
 struct ate ConverDatetoint(bool DateorHeure)
 {
   ate donnes;
   if (DateorHeure)
   {
      donnes.Data1=t.hour;
      donnes.Data2=t.min;
      donnes.Data3=t.sec;
   }
   else
   {
      donnes.Data1=t.mday;
      donnes.Data2=t.mon;
      donnes.Data3=t.year;
  }
  return donnes;  
 }

 struct ts ConverinttoDat(bool DateorHeure,ate donnes)
 {
   DS3231_get(&t);
   if (DateorHeure)
   {
      t.hour=donnes.Data1;
      t.min=donnes.Data2;
      t.sec=donnes.Data3;
   }
   else
   {
      t.mday=donnes.Data1;
      t.mon=donnes.Data2;
      t.year=donnes.Data3;
  }
  return t;
}


/*---------------------------------------------
 * gestion des alarmes 
 ---------------------------------------------*/

void confirmer_alarme(int type_Alarme,ate donnes)
{
  uint8_t flags[5] = { 0, 0, 0, 1, 1 };
  uint8_t flags1[4] = { 0, 0, 1, 1 };
  if (type_Alarme==1)
  {
        DS3231_set_a1(0, donnes.Data2, donnes.Data1, 0,  flags);
        DS3231_set_creg(DS3231_INTCN | DS3231_A1IE);
  }
  else
  {
        DS3231_set_a2(donnes.Data2, donnes.Data1, 0, flags1);
        DS3231_set_creg(DS3231_INTCN | DS3231_A2IE);
  }  
}
/*-----------------------------------------------
  * Le cycle du servomoteur qui 
  * le déclenchement de la nourriture
  -----------------------------------------------*/
void cycleservomotor()
{
  delay(200);
  affichage_icones();
  digitalWrite(pinServo,HIGH);
  delay(200);
  myservo.write(MAX_POS);
  delay(1000);
  myservo.write(MIN_POS);
  delay(1000);
  digitalWrite(pinServo,LOW);
  digitalWrite(Relay_Nourriture, LOW);
  affichage_icones();

}
 /*-----------------------------------------------
  * gestion du déclenchement de la Nourriture à
  * l'heure précise ou en bluetooth
  -----------------------------------------------*/
void Declenchement_Nourriture() 
{
	  if (DS3231_triggered_a2())
	  {
        DS3231_clear_a2f();
        if (set_al.Tps2) 
          confirmer_alarme(2,ConverStrtoint(set_al.distr2));
        else 
          confirmer_alarme(2,ConverStrtoint(set_al.distr1));
        set_al.Tps2=!set_al.Tps2;
        digitalWrite(Relay_Nourriture, HIGH);
        cycleservomotor();
    }
}

/*-----------------------------------------------
  * commander la nourriture par la commande
  * bluetooth
  -----------------------------------------------*/
void Commander_Nourriture() 
{
    if (digitalRead(Relay_Nourriture)==HIGH)
       cycleservomotor();
}
 /*-----------------------------------------------
  * gestion du déclenchement de la Nourriture à
  * l'heure précise ou en bluetooth
  -----------------------------------------------*/

  
void Declenchement_Eclairage()
{
	if (DS3231_triggered_a1())
  {
       DS3231_clear_a1f();
       if (set_al.Tps1)
			    activeeclairage();
       else
			    desactiveeclairage();
	}
	else if ((set_al.Tps1) && (digitalRead(Relay_Eclairage)==HIGH))
  {
    confirmer_alarme(1,ConverStrtoint(set_al.End1));
    set_al.Tps1=false;
  }  
	else if ((!set_al.Tps1) && (digitalRead(Relay_Eclairage)==LOW))
  {
	  confirmer_alarme(1,ConverStrtoint(set_al.Start1));
    set_al.Tps1=true;
  } 
}	

/*--------------------------------------------------
* on envoi la température tous les minutes
* 
---------------------------------------------------- */
 bool attente_envoi(byte idx,const unsigned long timeout)     
 {
      if ((Temps[idx]+timeout)<millis())
      {
         Temps[idx]=millis()+timeout;
         return true;
      }
      else return false;
 }
 
 /*-----------------------------------------------------*/
 /* Renvoi le jour de la Semaine en string				*/
 /*-----------------------------------------------------*/
 char *jourdelasemaine(byte d, byte m, int y)
 {
    byte jour=0;
	jour= dayOfWeek(d, m, y);
	if (jour != EAU.Jour) 
	   {
		   EAU.Jour = jour;
		   EAU.changementeaujours++;
	   }   
    switch(jour){
    case 1: 
      return "Di";
      break;
    case 2: 
      return "Lu";
      break;
    case 3: 
      return "Ma";
      break;
    case 4: 
      return "Me";
      break;
    case 5: 
      return "Je";
      break;
    case 6: 
      return "Ve";
      break;
    case 7: 
      return "Sa";
      break;
   }
} 
  
/*----------------------------------------------- 
 * 
 */
void loop()
{
   char buff[BUFF_MAX];
   float temperature;
   static unsigned long samplingTime = millis();
   static unsigned long printTime = millis();
   BTVirtuino.run();
   DS3231_get(&t);
   temperature = DS3231_get_treg();       //lecture de la température
   Commander_Nourriture();
   Declenchement_Eclairage();
   Declenchement_Nourriture(); 
   snprintf(buff, BUFF_MAX,"%s%02d/%02d/%04d",jourdelasemaine(t.mday, t.mon, t.year), t.mday, t.mon, t.year);
   message_lcd('1',"",buff);
   snprintf(buff, BUFF_MAX, "%02d:%02d:%02d %02dC", t.hour, t.min, t.sec,(int) temperature);
   message_lcd('2',"",buff);
   
   affichage_icones();
   
   if ((EAU.changementeaujours>=Jours7) && (!BTVirtuino.vMemoryRead(Vacquitter))) // tester l'eau
     {
        BTVirtuino.vMemoryWrite(Vacquitter,1);
        EAU.Etat=true;
     }
   else if  ((!BTVirtuino.vMemoryRead(Vacquitter)) && (EAU.Etat))
     {
        EAU.changementeaujours=0;
        EAU.Etat=false;
     }   


   if (attente_Touche(btnST,1000)) saisie_paramatres();
   if (attente_Touche(btnHT,1000)) 
   {
    
       message_lcd('0',"Bluetooth Patrick","En Cours Connexion");
       digitalWrite(Electro_Eclaire,HIGH);
       BTVirtuino.InitialtiserHC05("Patrick1234",0,-1,"1234");
       message_lcd('0',"Patrick1234 1234","Appuyez sur bntST");
       while (attente_Touche(btnST,1000)==false) ;
       sei();
    Serial.println("Reset");
    Serial.flush();
    resetFunc();
   }
   if (attente_Touche(btnBS,200))
   {  
    if (digitalRead(Relay_Eclairage)==HIGH)
         desactiveeclairage();
      else
         activeeclairage();
   }
   if (attente_Touche(btnDT,200))  
   {
      if (digitalRead(Ventilateur1)==HIGH) digitalWrite(Ventilateur1,LOW);
        else digitalWrite(Ventilateur1,HIGH);
      if (digitalRead(Ventilateur2)==HIGH) digitalWrite(Ventilateur2,LOW);
        else digitalWrite(Ventilateur2,HIGH);
   }
   if (attente_envoi(0,500)) {
       switch (tache) 
            {
             case 0:
                   tache=1;
                   BTVirtuino.vMemoryWrite(Vtemperature,temperature);
             break;
             case 1:
                  BTVirtuino.vMemoryWrite(Veau,EAU.changementeaujours);
                  BTVirtuino.vMemoryWrite(Vtime,(t.min*0.01) + t.hour);
                  BTVirtuino.vMemoryWrite(Vdate,(t.mon*0.01) + t.mday);
                  BTVirtuino.vMemoryWrite(Vannee,t.year);
                  tache=2;
             break;
			       case 2:
			            if (Serial.available() > 0)
						      reglage(Serial_readln(3000),MSG); 
				          tache=3;	
			      break;
			      case 3:
					        RegulationVent(int (Vtemperature+Offset));
                  tache=4;
			       break;
             case 4:     
                  if (attente_envoi(1,2000)) tache=5;
                    else tache=0;
                    
                  if (dialogue.excel) {
                    Serial.print("DATA,TIME,"); 
                    
                    dialogue.excel=(Serial_readln(1000)=="@POK");
                  }
             break;
             case 5:
                 electro_eclairage(LOW);
                 tache=0; 
             break; 
            }
   }
   
}   

/*-----------------------------------------
 *  gestion des alarmes et régulation
 *  du refroidissement
 ------------------------------------------*/
void RegulationVent(int ValCapteur)
 {
   if (BTVirtuino.vMemoryRead(VAutomatique)==1) 
   {
      if (ValCapteur >= sensor.paramatre[SensorTemp].Data3) 
          digitalWrite(Ventilateur1,HIGH);
          else if (ValCapteur < sensor.paramatre[SensorTemp].Data2) 
              digitalWrite(Ventilateur1,LOW);
   
      if (ValCapteur >= sensor.paramatre[SensorTemp].Data2) 
          digitalWrite(Ventilateur2,HIGH);
          else if (ValCapteur < sensor.paramatre[SensorTemp].Data1)
              digitalWrite(Ventilateur2,LOW);
   } 
   else
   {
        ventillateurs(Ventilateur1);
        ventillateurs(Ventilateur2);
   }
}