/*
############################################################################
MEGA 1280 - DOMOTIC PROJECT

Binary sketch size: 28598 bytes (of a 126976 byte maximum)
############################################################################

Le 13 Decembre 2011

TAG : programme en cours. Utilisation ancienne librairie S1D13700.
      Ajout mode hors-gel ou off.

Le 16 decembre 2011
      Refonte inertie -1, 0, 1. Perdition, stable, distribution.
      Moyenne sur 5 valeurs, 1 valeur/mn pour coller à la courbe.
      TouchScreen.cpp --> NUMSAMPLE 1
      
Le 19 decembre 2011
      Modification inertie --> regulation
      Ajout variable sommetCourbe, HYSTERESIS, ecart.

Le 26 decembre 2011
      Regulation en logique floue.
      Le temperature exterieure est fixe : 6
      Ajout cycle de forcage

Ajout menu, layer1.

MODIFICATION :
	- liaison pc seriel a la demande
	- variable temperature de declenchement chauffage fixe a t+O.8
	- default temperatures : 18.4, 17.5, 15.0, 5.0 (Jour, nuit, abs, vac, hors-gel)
        - DS18B20 OneWire Pin 3
                - Ajout securite mauvaise lecture (DEVICE_DISCONNECTED = -127)
	- Rs485 Pin 2 declaration (Tx3, Rx3)
		- bit 1, Tx
		- bit 0, release
	- Modification librairie Time (Time.cpp)
		- Ligne 239/259 : Desactivation de la synchro automatique.
	- LED Pins :
                - Pin 8, voyant Auto.
                - Pin 9, voyant Absence.
                - Pin 10, voyant Vacances.
                - Pin 11, voyant OFF.
        - GLCD S1D13700
                - Modification librairie S1D13700.h :
                       - Utilisation du port A, pins D0 a D7.
                       - DDRA, PORTA, PINA
                - Pins : rd = 38
                         wr = 39
                         a0 = 40
                         cs = 41
                         rst = 42
        - TouchScreen (librairie from ladyada)
                - Pins : YP (Y2 ou YD) A13
                         YM (Y1 ou YU) A15
                         XM (X1 ou XL) A12
                         XP (X2 ou XR) A14
                - Utilisation function map.

TODO :
        - GLCD menu.
                - layer0 : affichage principal (date, heure, mode en cours, temperatures, etat de chauffe)
                - layer1 : boutons options (auto, off, abs, vac, cycle)
                - layer2 :
                - layer3 :
        >> - Securiser la chauffe avec une temporisation.(20*60*1000)
        >> - determiner une zone rouge avant la chauffe en mode nocturne.
        >> - calibration glcd/touchscreen

REMARQUE :
        - suppression application carte Sd (manque de fiabilite: 1 ecriture sur 2).
                - Sd Card Pins
		        - CS pin 53
		        - DI pin 51
		        - DO pin 50
		        - CLK pin 52

HELP :
        - char * dtostrf(double val, signed char width, unsigned char prec, char * s) // convert double to string.
        - int sprintf(char * str, const char * format, ...)                           // write formatted data to string.
        - int printf ( const char * format, ...)                                      // print formatted data to stdout.
*/

/*
############################################################################
GLOBAL : GLOBAL TIME DECLARATIONS
############################################################################
*/
#include <Time.h>
#define TIME_REQUEST  7
#define TIME_MSG_LEN  11
/*
############################################################################
GLOBAL : DECLARATION VARIABLES TEMPS
############################################################################
*/
int _hour; //= (hour());
int _minute; //= (minute());
int current_time; //= (_hour*60) + _minute;
int last_minute;

time_t timeAbsence, timeVacances;                                          // sauvegarde since epoch time

int run_task;
int tempo3;
boolean overheat;
/*
############################################################################
GLOBAL : GLOBAL TEMPERATURE SENSORS DECLARATIONS
############################################################################
*/
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 3
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
uint8_t sonde_ds18b20_1[8] = {0x28, 0xFC, 0x97, 0x56, 0x2, 0x0, 0x0, 0x69};
//uint8_t sonde_ds18b20_2[8] = {};
//uint8_t sonde_ds18b20_3[8] = {};
//uint8_t sonde_ds18b20_4[8] = {};
/*
############################################################################
GLOBAL : GLOBAL SERIAL MESSAGE DECLARATIONS
############################################################################
*/
#define STARTBIT '*'
#define STOPBIT '!'
#define BUFFERSIZE 96
char buffer[BUFFERSIZE + 1];
char* TRAME[12]; // Set there default data
/*
############################################################################
GLOBAL : SERIAL RELAY CARD PIN DECLARATION
############################################################################
*/
#define txPin 2
/*
############################################################################
GLOBAL : GLCD S1D13700 DECLARATIONS
############################################################################
*/
#include "lucida_font.h"
#include <S1D13700.h>
S1D13700 glcd;
/*
############################################################################
GLOBAL : TOUCH SCREEN DECLARATIONS
############################################################################
*/
#include <stdint.h>
#include "TouchScreen.h"

#define YP A13                                                              // must be an analog pin, use "An" notation! (Y2 = YD)
#define XM A12                                                              // must be an analog pin, use "An" notation! (X1 = XL)
#define YM A15                                                              // can be a digital pin (Y1 = YU)
#define XP A14                                                              // can be a digital pin (X2 = XR)

TouchScreen ts = TouchScreen(XP, YP, XM, YM, 630);                          // mesured : 630 ohms 
/*
############################################################################
GLOBAL : DECLARATION VARIABLES CHAUFFAGE
############################################################################
*/
int intervalle_journuit[] = {390, 1365};                                   // 06h30 a 22h45
float consigne_chauffage[] = {18.4, 17.5, 16.0, 10.0, 5.0};                // values to start with (jour, nuit, abs, vac, hors-gel)
float calibrage;                                                           // temperature_marche_max = temperature1 + calibrage

boolean redzone;
int h_redzone = intervalle_journuit[1] - 15;

float temperature1;
float temperature_marche_max;
float consigne_courante;

int mode_select;
int etat_chauffage, prev_etat_chauffage;
/*
############################################################################
GLOBAL : DECLARATION REGULATION
############################################################################
*/
const float POIDS1 = 0.7; /* CONSIGNE */
const float POIDS2 = 0.1; /* PROBABILITE DEPERDITION CALORIFIQUE */
const float POIDS3 = 0.15; /* TEMPERATURE EXTERIEURE */

float CIBLE[4][3] = {
	{ -127.0, 0.0, POIDS1*100 }, /* UNDER */
	{ 0.0, 0.1, POIDS1*86 }, /* TOUCH */
	{ 0.1, 0.2, POIDS1*80 }, /* MEDIUM */
	{ 0.2, 127.0, POIDS1*0 }, /* FAR */
};

float PROBABILITY[5][3] = {
        { -127.0, 0.0, POIDS2*0 },
	{ 0.0, 0.1, POIDS2*10 }, /* ECART P1 */
	{ 0.1, 0.15, POIDS2*30 }, /* ECART P2 */
	{ 0.15, 0.2, POIDS2*80 }, /* ECART P3 */
	{ 0.2, 127.0, POIDS2*100 } /* ECART P4 */
};

float EXTERIEUR[6][3] = {
	{ -127.0, -2.0, POIDS3*100 }, /* FREEZE */
	{ -2.0, 2.0, POIDS3*80 }, /* COLD */
	{ 2.0, 6.0, POIDS3*60 }, /* WINTER */
	{ 6.0, 10.0, POIDS3*40 }, /* AUTOMN */
	{ 10.0, 16.0, POIDS3*20 }, /* SPRING */
	{ 16.0, 127.0, POIDS3*0 } /* SUMMER */
};

const int longueurTable1 = sizeof(EXTERIEUR)/sizeof(EXTERIEUR[0]);
const int longueurTable2 = sizeof(CIBLE)/sizeof(CIBLE[0]);
const int longueurTable3 = sizeof(PROBABILITY)/sizeof(PROBABILITY[0]);

float sommetCourbe, ecart;
float temperature_ext = 6.0;
boolean check_regulation, chauffage, forcage;
int value1, value2, value3;
/*
############################################################################
GLOBAL : LOGS DELAY
############################################################################
*/
int eventTimer2 = _minute % 10;               
/*
############################################################################
GLOBAL : DECLARATION VARIABLES IHM
############################################################################
*/
int menu;
int prev_led;
int localClient, remoteClient;
/*
############################################################################
GLOBAL : DECLARATION VARIABLES ACTIONNEUR
############################################################################
*/
int state_relay1;
/*
############################################################################
GLOBAL : DECLARATION VARIABLES MILLIS
############################################################################
*/
//unsigned long timer1 = 0, timer2 = 0;
//unsigned long timeout1 = 60*1000, timeout2 = 10*1000;
unsigned long timeout2 = 10*1000;
/*
############################################################################
GLOBAL : CLASS IHM
############################################################################
*/
#define PIXH 14

class Objet {
  public:
    Objet();
    int gadget;
    char *text;
    
    //int _layer;
    int radius;
    
    Objet(int,char*,int,int,int,int);     // type, text, x0, y0, x1, y1

    void draw() {
      switch(gadget) {
        case 0 : {                                                 // BitmapText
          glcd.writeBitmapText(text, x1, y1, LUCIDA_FONT);
          break;
        }
        case 1 : {                                                 // Box
          //int dx1 = ((x2 + sizeof(text)) - x1)/2;
          int dx1 = (x2 + x1 - (strlen(text)*PIXH))/2;
          int dy1 = ((y2 + y1)/2) - PIXH;
      
          glcd.drawBox(x1, y1, x2, y2);
          glcd.writeBitmapText(text, dx1, dy1, LUCIDA_FONT);
          break;
        }
        case 2 : {                                                 // circle
          int dx1 = x1 - (PIXH/2);
          int dy1 = y1 + (PIXH/2);
          radius = x2;
          glcd.drawCircle(x1, y1, radius);
          if (radius > PIXH) { glcd.writeBitmapText(text, dx1, dy1, LUCIDA_FONT); }
          break;
        }
      }
    };

    void disable() {
      switch(gadget) {
        case 0 : { break; }
        case 1 : { break; }
        case 2 : { break; }
      }
    };
    
    boolean check(int x, int y) {
        // Adjust value from determinated calibration formula.
        int X = float((1.22*x) + (-0.02*y) - 26.08);    // Xd = 1.22*x + -0.02*y - 26.06
        int Y = float((-0.01*x) + (1.28*y) - 35.53);    // Yd = -0.01*x + 1.28*y - 35.53
        
        if ((gadget == 1) && (X > x1) && (X < x2) && (Y > y1) && (Y < y2))
        { return true; }
        else if ((gadget == 2) && (X > (x1 - (radius/2))) && (X < (x1 + (radius/2))) && (Y > (y1 - (radius/2))) && (Y < (y1 + (radius/2))))
        { return true; }
      return false;
    };
          
  private:
    int x1,y1,x2,y2;
};

Objet::Objet(int g, char *t, int a, int b, int c=0, int d=0) {
  gadget = g;
  text = t;
  x1 = a;
  y1 = b;
  x2 = c;
  y2 = d;
}

/*
############################################################################
GLOBAL : DECLARATION DES OBJETS IHM
############################################################################
*/
// LAYER 0
Objet IHM_menu(1, "menu", 165, 190, 300, 230);                              // box
Objet IHM_clock(0, "", 230, 10);                                            // text
Objet IHM_mode(0, "", 10, 10);                                              // text
Objet IHM_temp1(0, "", 10, 100);                                            // text
Objet IHM_etat1(0, "", 100, 40);                                            // text
// LAYER 1
Objet IHM_auto(1, "auto", 20, 20, 150, 60);                                 // box
Objet IHM_off(1, "off", 20, 80, 150, 120);                                  // box
Objet IHM_abs2(1, "Abs 2H", 170, 20, 300, 60);                          // box
Objet IHM_abs4(1, "Abs 4H", 170, 80, 300, 120);                         // box
Objet IHM_forcage(1, "forcage", 20, 140, 150, 180);                     // box
Objet IHM_return(1, "Back", 200, 180, 300, 220);                            // box
Objet IHM_selectionLayer0(0, "", 30, 200);                                  // text
// LAYER 2

/*
############################################################################
############################################################################
############################################################################
SETUP - SETUP - SETUP - SETUP - SETUP - SETUP - SETUP - SETUP - SETUP
############################################################################
############################################################################
############################################################################
*/
void setup() {
/*
############################################################################
SETUP : INITIALISER LES VOYANTS
############################################################################
*/
  pinMode(8, OUTPUT);                                                      // voyant auto
  pinMode(9, OUTPUT);                                                      // voyant absence 
  pinMode(10, OUTPUT);                                                     // voyant vacances
  pinMode(11, OUTPUT);                                                     // voyant off 
/*
############################################################################
SETUP : INITIALISER LES VARIABLES DE CHAUFFE
############################################################################
*/
  calibrage = 0.75;
  temperature_marche_max = consigne_chauffage[0];
  etat_chauffage = 0;
  mode_select = 1;
  overheat = false;
  tempo3 = 0; 
  check_regulation = true;
  forcage = false;
/*
############################################################################
SETUP : INITIALISER LES VARIABLES IHM
############################################################################
*/  
  menu = 1;
  localClient = 0;
  remoteClient = 0;
/*
############################################################################
SETUP : INITIALISER LES VARIABLES SEQUENTIELLES
############################################################################
*/    
  run_task = 0;	
/*
############################################################################
SETUP : INITIALISER LA LIAISON SERIE
############################################################################
*/
  Serial.begin(57600);
  delay(1000);
/*
############################################################################
SETUP : INITIALISER LA CARTE RELAIS RS485
############################################################################
*/
  Serial3.begin(9600);
  delay(1000);
  pinMode(txPin, OUTPUT);
  digitalWrite(txPin, LOW);
  delay(50);
/*
############################################################################
SETUP : INITIALISER LE RELAIS DE CHAUFFE
############################################################################
*/ 
 rs485TxMsg("\xFF\x01\x00");
 state_relay1 = 0;
 delay(50);
/*
############################################################################
SETUP : INITIALISER LES SONDES DE TEMPERATURES
############################################################################
*/
  sensors.begin();
  sensors.setResolution(sonde_ds18b20_1, 12);
  sensors.requestTemperatures();
  delay(1000);
/*
############################################################################
SETUP : INITIALISER AFFICHEUR
############################################################################
*/  
 glcd.pins.rd = 38;
 glcd.pins.wr = 39;
 glcd.pins.a0 = 40;
 glcd.pins.cs = 41;
 glcd.pins.rst = 42;
 delay(50);

 glcd.initLCD();
 glcd.clearText();
 glcd.clearGraphic();
 delay(2000);
 
 layer0();                                                                  // draw initial display.
/*
############################################################################
SETUP :
############################################################################
*/
  Serial.println("LOG : Setup complete");
} 
/*
############################################################################
############################################################################
############################################################################
LOOP - LOOP - LOOP - LOOP - LOOP - LOOP - LOOP - LOOP - LOOP - LOOP
############################################################################
############################################################################
############################################################################
*/
void loop() {
  Point p = ts.getPoint();
  if (p.z > 0) {                                                       //if (p.z > ts.pressureThreshhold)
    int x = map(p.x, 0, 1023, 0, 320);                                // to test : map(p.x, 128, 895, 0, 320)
    int y = map(p.y, 0, 1023, 0, 240);                                // to test : map(p.y, 170, 853, 0, 240)
    switch(menu) {
      case 1: {
        if (IHM_menu.check(x, y)) { layer1(); }
        break;
      }
      case 2: { 
        if (IHM_auto.check(x, y)) { mode_select = 1; IHM_selectionLayer0.text = "Auto"; IHM_selectionLayer0.draw(); }
        if (IHM_off.check(x, y)) { mode_select = 4; IHM_selectionLayer0.text = "Off"; IHM_selectionLayer0.draw(); }
        if (IHM_forcage.check(x, y)) { mode_select = 5; IHM_selectionLayer0.text = "Run"; IHM_selectionLayer0.draw(); check_regulation = false; forcage = true; }
        if (IHM_abs2.check(x, y)) { mode_select = 2; timeAbsence = now() + (2*3600); IHM_selectionLayer0.text = "Abs 2H"; IHM_selectionLayer0.draw(); }
        if (IHM_abs4.check(x, y)) { mode_select = 2; timeAbsence = now() + (4*3600); IHM_selectionLayer0.text = "Abs 4H"; IHM_selectionLayer0.draw(); }
        if (IHM_return.check(x, y)) { layer0(); }
        break;
      }
    }
  }

if (!localClient) { checkMsg(); }
// AMELIORER CETTE PARTIE
/*
if (touched) {
  unsigned long timer0 = millis();
  
  if (timer2 == 0) { timer2 = timer0; localClient = 1; remoteClient = 0; }
  else {
    if ((timer0 - timer2) > timeout2) { localClient = 0; timer2 = 0;}
  }
  Tactile();
}
*/

switch (run_task) {
  case 0 :
      {
      if (timeStatus() == timeNotSet) { Serial.println(TIME_REQUEST, BYTE); delay(1000); checkMsg();}
      else { Serial.println("CLOCK UPDATED"); voyant(8); run_task = 1; }
      break; 
      }
  case 1 :
    {
      mainProgram();
      break;
    }
  default :
    {
      run_task = 0;
    }
  }
}

void voyant(int led) {
  if (prev_led != led) {
    switch (led) {
      case 8 : { digitalWrite(led, HIGH); digitalWrite(9, LOW); digitalWrite(10, LOW); digitalWrite(11, LOW); break; }
      case 9 : { digitalWrite(8, LOW); digitalWrite(led, HIGH); digitalWrite(10, LOW); digitalWrite(11, LOW); break; }
      case 10 : { digitalWrite(8, LOW); digitalWrite(9, LOW); digitalWrite(led, HIGH); digitalWrite(11, LOW); break; }
      case 11 : { digitalWrite(8, LOW); digitalWrite(9, LOW); digitalWrite(10, LOW); digitalWrite(led, HIGH); break; }
      default : ;;
    }
    prev_led = led;
  }
}

/*
MAIN ROUTINE
*/
void mainProgram() {
/*
############################################################################
LOOP : DECLARATION OF ROLLING VARIABLES
############################################################################
*/
  	_hour = (hour());
  	_minute = (minute());

  	current_time = (_hour*60) + _minute;

        //eventTimer1 = _minute % 4;
        eventTimer2 = _minute % 10;
/*
############################################################################
LOOP : FURNACE MODE : 1-AUTO, 2-AWAY, 3-HOLLYDAYS, 4-OFF
############################################################################
*/  
  switch(mode_select) {
  		case 1 :      // auto
                {
		  if (intervalle_journuit[0] < current_time && current_time < intervalle_journuit[1])
		  {
		    if (consigne_courante != consigne_chauffage[0]) { consigne_courante = consigne_chauffage[0]; }
		    if (h_redzone != (intervalle_journuit[1] - 15)) { h_redzone = intervalle_journuit[1] - 15; }// consigne diurne
		  }
		  else
		  {
		    if (consigne_courante != consigne_chauffage[1]) { consigne_courante = consigne_chauffage[1];}// consigne nocturne
		  }
		  voyant(8);
                  if ((IHM_mode.text != "Auto") && (menu == 1)) { IHM_mode.text = "Auto"; IHM_mode.draw(); }
        	  break;
                }
  		case 2 :      // absence
                {
                  if (timeAbsence <= now()) { mode_select = 1; timeAbsence = 0; }
                  else { if (consigne_courante != consigne_chauffage[2]) { consigne_courante = consigne_chauffage[2]; } }                       
		  voyant(9);
                  if ((IHM_mode.text != "Abs") && (menu == 1)) { IHM_mode.text = "Abs"; IHM_mode.draw(); }
		  break;
                }
  		case 3 :      // vacances
                {
                  if (timeVacances <= now()) { mode_select = 1; timeVacances = 0; }
                  else { if (consigne_courante != consigne_chauffage[3]) { consigne_courante = consigne_chauffage[3]; } }                       
		  voyant(10);
                  if ((IHM_mode.text != "Vac") && (menu == 1)) { IHM_mode.text = "Vac"; IHM_mode.draw(); }
		  break;
                }
  		case 4 :      // OFF ou hors-gel
                {
		  if (etat_chauffage != 0)
		  {
		    rs485TxMsg("\xFF\x01\x00");
		  }
                  if (consigne_courante != consigne_chauffage[4]) { consigne_courante = consigne_chauffage[4]; }
		  voyant(11);
                  if ((IHM_mode.text != "Off") && (menu == 1)) { IHM_mode.text = "Off"; IHM_mode.draw(); }
		  break;
                }
                case 5 :      // launch 1 cycle
                {
                  if ((IHM_mode.text != "Run") && (menu == 1)) { IHM_mode.text = "Run"; IHM_mode.draw(); }
                  if (forcage == false) { mode_select = 1; }
                  break;
                }
  		default :
                {
    		  mode_select = 1;
                }
              }
/*
############################################################################
LOOP : UPDATE TIME AND TEMPERATURE EVERY MINUTE
############################################################################
*/
  	      if (_minute != last_minute) {
    
    		last_minute = _minute;
    
                sensors.requestTemperaturesByAddress(sonde_ds18b20_1);
                temperature1 = sensors.getTempC(sonde_ds18b20_1);
    		
    		if (h_redzone < current_time && current_time < intervalle_journuit[1]) { redzone = true; }
    		else { redzone = false; }

                if ((temperature1 != DEVICE_DISCONNECTED) && check_regulation) { chauffage = regulation(); }
                    
    		if (((chauffage == true) && (!redzone)) || (forcage == true))
		  {
		  etat_chauffage = 1;
		  if (etat_chauffage != prev_etat_chauffage)
		    {
		    temperature_marche_max = temperature1 + calibrage;      // ajustement de la temperature
                    sommetCourbe = 0.0;                                     // init sommetCourbe
                    check_regulation = false;
		    rs485TxMsg("\xFF\x01\x01");                             // marche
                    if (menu == 1) { IHM_etat1.text = "Marche"; IHM_etat1.draw(); }
		    }
		  }
		if ((temperature1 >= temperature_marche_max) || (overheat))
		  {
		  etat_chauffage = 0;
		  if (etat_chauffage != prev_etat_chauffage)
		    {
		    overheat = false;
		    check_regulation = true;
                    if (forcage == true) { forcage = false; }
		    temperature_marche_max = consigne_courante;
		    rs485TxMsg("\xFF\x01\x00");                             // arret
                    if (menu == 1) { IHM_etat1.text = "Arret"; IHM_etat1.draw(); }
		    }
		  }
                prev_etat_chauffage = etat_chauffage;
		if(remoteClient) { sendData(); }
            
                if (etat_chauffage) {
		  if (tempo3 >= 20) { overheat = true; tempo3 = 0; }         // temps maxi chauffe.
		  else { tempo3++; }
		  }
                else { if (tempo3 != 0) { tempo3 = 0; } }                   // reinitialisation de la tempo si la temperature est atteinte avant.
                
          if ((etat_chauffage) || (eventTimer2 == 0)) { logs(); }
                
                if (menu == 1) { 
                  IHM_clock.text = update_clock(); IHM_clock.draw();
                  IHM_temp1.text = update_temp1(); IHM_temp1.draw();
                }
	      }
}
/*
############################################################################
SECTION : LOOK AND MANAGE INCOMING SERIAL MESSAGE
############################################################################
The getSerialString function looks for a valid message, with a header and a foot.
if message is valid, it is split to each TRAME spaces in filldata function.
Every splited data begins with a unique identifier flag, which will build valid 
functions and variables depending on position. This is my choice!
For exemple, the 'T' flag means that data is concerning clock update.
More things could be combined.
############################################################################
*/
void checkMsg() {
  if (getSerialString()) {                                                  // On verifie que la trame soit complete
    filldata(buffer);                                                       // On remplit la structure des donnees
    checkdata();                                                            // On renseigne les variables modifiees
  }
}

boolean getSerialString() {
  int dataBufferIndex = 0;
  boolean storebuffer = false;
  delay(20);
  if(Serial.available() > 1){
        char incoming = Serial.read();
        if(incoming==STARTBIT){
            dataBufferIndex = 0;                                            //Initialize our dataBufferIndex variable
            storebuffer = true;
        }
        if(storebuffer){
          while(Serial.available()){
            char incoming = Serial.read();
            delay(50);
            if(dataBufferIndex == BUFFERSIZE){dataBufferIndex = 0; break; }
            if(incoming == STOPBIT) {buffer[dataBufferIndex] = 0; dataBufferIndex = 0; storebuffer = false; return true; }
            else { buffer[dataBufferIndex++] = incoming; }
          }
        }
  }
  return false;
}

void filldata(char *buffer) {
  char *p = buffer;
  char *str;
  int i = 0;
  while ((str = strtok_r(p, ";", &p)) != NULL) {                             // delimiter is the semicolon
    char *q = str;
    TRAME[i] = q;
    i++;
  }
}

void checkdata() {
  if (strcmp(TRAME[0], "CLOCK") == 0) { 
    if (strcmp(TRAME[1], "#") != 0) { updateTime(); }                        // Auto update Time
  }
  if (strcmp(TRAME[0], "SYNCTIME") == 0) { Serial.println(TIME_REQUEST, BYTE); delay(50); } // Manual update Time
  if (strcmp(TRAME[0], "RELAY") == 0) { 
    // 0, relay number, relay state
    if ((strcmp(TRAME[1], "1") == 0) && (strcmp(TRAME[2], "0") == 0)) { rs485TxMsg("\xFF\x01\x00"); state_relay1 = 0; Serial.print("@relay1:"); Serial.println(state_relay1); etat_chauffage = 0; }
    if ((strcmp(TRAME[1], "1") == 0) && (strcmp(TRAME[2], "1") == 0)) { rs485TxMsg("\xFF\x01\x01"); state_relay1 = 1; Serial.print("@relay1:"); Serial.println(state_relay1); etat_chauffage = 1; }
  }
  if (strcmp(TRAME[0], "PARAM") == 0) { 
	// 'mode':'#', 'abs':'#', 'vac':'#', 't_jour':'#', 't_nuit':'#', 't_abs':'#', 't_vac':'#', 'cal':'#', 'day_at':'#', 'night_at':'#'
	if (strcmp(TRAME[1], "#") != 0) { mode_select = string2integer(TRAME[1]); }
	if (strcmp(TRAME[2], "#") != 0) { timeAbsence = string2long(TRAME[2]); }
	if (strcmp(TRAME[3], "#") != 0) { timeVacances = string2long(TRAME[3]); } 
	if (strcmp(TRAME[4], "#") != 0) { consigne_chauffage[0] = string2float(TRAME[4]); }
	if (strcmp(TRAME[5], "#") != 0) { consigne_chauffage[1] = string2float(TRAME[5]); }
	if (strcmp(TRAME[6], "#") != 0) { consigne_chauffage[2] = string2float(TRAME[6]); }
	if (strcmp(TRAME[7], "#") != 0) { consigne_chauffage[3] = string2float(TRAME[7]); }
	if (strcmp(TRAME[8], "#") != 0) { calibrage = string2float(TRAME[8]); }
	if (strcmp(TRAME[9], "#") != 0) { intervalle_journuit[0] = string2integer(TRAME[9]); }
	if (strcmp(TRAME[10], "#") != 0) { intervalle_journuit[1] = string2integer(TRAME[10]); }							
  }
  if (strcmp(TRAME[0], "START_CLI") == 0) { 
    // send data next to real time (1 mn)
    remoteClient = 1; Serial.println("LOG : Client connected");
	}
  if (strcmp(TRAME[0], "STOP_CLI") == 0) { 
    // send data to normal timer (5 mn)
    remoteClient = 0; Serial.println("LOG : Client dropped");
  }
}

void updateTime() { 
  int i = 0;
  time_t pctime = 0;    
  for(i = 0; i < TIME_MSG_LEN; i++) {
      if( int(TRAME[1][i]) >= '0' && int(TRAME[1][i]) <= '9'){   
        pctime = (10 * pctime) + (int(TRAME[1][i]) - '0') ;                 // convert digits to a number    
        }
      }
      setTime(pctime);                                                      // Sync Arduino clock to the time received on the serial port
}

/*
############################################################################
SECTION : CONVERT STRING TO SOMETHING
############################################################################
*/
int string2integer(char* data) { return atoi(data); }
float string2float(char* data) { return atof(data); }
unsigned long string2long(char* data) { return atol(data); }

/*
############################################################################
SECTION : SWITCH RS485 FURNACE RELAY
############################################################################
*/
void rs485TxMsg(char *msg) {
  Serial3.flush();
  digitalWrite(txPin, HIGH);
  delay(10);
  Serial3.print(msg);
  delay(10);
  digitalWrite(txPin, LOW);
}

/*
############################################################################
SECTION : SEND STATUS TO REMOTE CLIENT
############################################################################
*/
void sendData() {
    // 'mode':'#', 'abs':'#', 'vac':'#', 't_jour':'#', 't_nuit':'#', 't_abs':'#', 't_vac':'#', 'cal':'#', 'day_at':'#', 'night_at':'#'
    Serial.flush();
    Serial.print("@data;");
    Serial.print(temperature1); Serial.print(";");                           // temperature 1
    Serial.print("00.0"); Serial.print(";");                                 // temperature 2
    Serial.print("00.0"); Serial.print(";");                                 // temperature 3
    Serial.print("00.0"); Serial.print(";");                                 // temperature 4
    Serial.print("0"); Serial.print(";");                                    // luminosite 1
    Serial.print("0"); Serial.print(";");                                    // lux 1
    Serial.print(mode_select); Serial.print(";");                            // mode
    Serial.print(etat_chauffage); Serial.print(";");                         // chauffage on/off          
    Serial.print(_hour); Serial.print(";");                                  // heure
    Serial.print(_minute); Serial.print(";");                                // minute
    if (mode_select == 2) { Serial.print(timeAbsence); }                 // Absence
    else { Serial.print("0"); }
    Serial.print(";");
    if (mode_select == 3) { Serial.print(timeVacances); }                // Vacances
    else { Serial.print("0"); }
    Serial.print(";");
    Serial.print(consigne_chauffage[0]); Serial.print(";");              // consigne jour
    Serial.print(consigne_chauffage[1]); Serial.print(";");              // consigne nuit
    Serial.print(consigne_chauffage[2]); Serial.print(";");              // consigne abs
    Serial.print(consigne_chauffage[3]); Serial.print(";");              // consigne vac
    Serial.print(calibrage); Serial.print(";");                          // calibrage
    Serial.print(intervalle_journuit[0]); Serial.print(";");             // debut horaire jour
    Serial.print(intervalle_journuit[1]);                                // fin horaire jour
    Serial.println();
    Serial.print("Zone rouge="); Serial.println(h_redzone);
}
/*
############################################################################
SECTION : SEND LOGS TO SERVER
############################################################################
*/
void logs() {
	Serial.print("LOG:");
	Serial.print(_hour); Serial.print("h"); Serial.print(_minute); 
	Serial.print(";"); Serial.print(temperature1); Serial.print(";"); 
	Serial.print(etat_chauffage); Serial.print(";"); 
	Serial.print(mode_select); Serial.print(";"); 
        //if(inertie == true) { Serial.println("true"); }
        //if(inertie == false) { Serial.println("false"); }
	Serial.println(ecart);
}
/*
############################################################################
SECTION : GLCD S1D13700 MENU
############################################################################
*/
char* update_clock() {
  static char time_buff[17] = { '\0' };
  snprintf(time_buff, 17, "%02dh%02d", _hour, _minute);
  return time_buff;
}

char* update_temp1() {
  char ibuff1[6] = { '\0' };
  static char obuff1[20] = { '\0' };                                       // static = conserver en memoire, non detruite a la fin de la fonction.
  dtostrf(temperature1,5,2,ibuff1);
  snprintf(obuff1, 20, "T: %s", ibuff1);
  return obuff1;
}
  
void layer0() { 
  glcd.clearText();
  glcd.clearGraphic();
  //glcd.drawBitmap(RAIN, 180, 60, 128, 75);
  IHM_menu.draw();
  IHM_clock.text = "##h##"; IHM_clock.draw();
  IHM_mode.text = "###"; IHM_mode.draw();
  IHM_temp1.text = "###"; IHM_temp1.draw();
  IHM_etat1.text = "###"; IHM_etat1.draw();
  menu = 1;
  delay(200);
}

void layer1() { 
  glcd.clearText();
  glcd.clearGraphic();
  IHM_auto.draw();
  IHM_off.draw();
  IHM_forcage.draw();
  IHM_abs2.draw();
  IHM_abs4.draw();
  IHM_return.draw();
  IHM_selectionLayer0.text = IHM_mode.text; IHM_selectionLayer0.draw();
  menu = 2;
  delay(200);
}

void layer2() {
}

void layer3() {
}

boolean regulation() {
	
    sommetCourbe = max(sommetCourbe, temperature1);
    ecart = (sommetCourbe - temperature1);

    for (int i = 0; i < longueurTable1; i++) {
	if ((temperature_ext > EXTERIEUR[i][0]) && (temperature_ext <= EXTERIEUR[i][1])) { value1 = EXTERIEUR[i][2]; }
    }

    for (int i = 0; i < longueurTable2; i++) {
	if (((temperature1 - consigne_courante) > CIBLE[i][0]) && ((temperature1 - consigne_courante) <= CIBLE[i][1])) { value2 = CIBLE[i][2]; }
    }

    for (int i = 0; i < longueurTable3; i++) {
	  if ((ecart > PROBABILITY[i][0]) && (ecart <= PROBABILITY[i][1])) { value3 = PROBABILITY[i][2]; }
    }

    if ((value1+value2+value3) >= 80) { return true; }
    else { return false; };
  
}