#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include "ParameterControl.h"
#include "zpr.h"
#include "Timer.h"

LiquidCrystal_I2C lcd(0x27, 20, 4);
// IO Variables
int IO_sPorte = 1;
int IO_sTemp = 2;
int IO_sHumi = 3;
int IO_sCO2 = 4;
int IO_Chauff1 = 13;
int IO_Chauff2 = 6;
int IO_Humi = 12;
int IO_Vntl = 8;
int IO_Extr = 9;
int IO_Md = 10;
int IO_Mg = 11;
int IO_Ecl = 12;

bool start = true;

int upButton = 9;
int downButton = 8;
int selectButton = 7;
int menu = 1;
int mode = 1;
int temp = 1;
int humi = 1;
int motor = 1;

bool bmenu;
bool bsmenu;
bool bselect;
bool bmode;
bool btemp;
bool bhumi;
bool bmotor;
bool backlight = true;


unsigned long startMillis;
unsigned long currentMillis;
unsigned long blstart;
unsigned long blcurrent;
const unsigned long tperiod = 50;
const unsigned long hperiod = 5;
const unsigned long mperiod = 200;
const unsigned long blperiod = 15000;

// Mode
bool bsmode1 =false;
bool bsmode2 =false;
bool bsmode3 =true;
const char incubation[] PROGMEM = "Incubation";
const char incubation1[] PROGMEM = "__Oeufs_de_poules___";
const char incubation2[] PROGMEM = "__Oeufs_de_canards__";
const char incubation3[] PROGMEM = "__Oeufs_de_cailles__";
const char date[] PROGMEM = "Past";

// Tempertur
const float tempStep = 0.01;
float temperatur = 38.5;
float istemp = 00.00;
float tempMax = 40.0;
float tempMin = 35.0;
float normTempMax = 40.0;
float normTempMin = 35.0;

// Humidity
const float humiStep = 0.01;
float humidity = 45.00;
float ishumi = 48.23;
float humiMax = 99.99;
float humiMin = 35.0;
float normHumiMax = 99.99;
float normHumiMin = 35.0;

// CO2
const float CO2Step = 0.01;
float CO2 = 45.00;
float isCO2 = 48.23;
float CO2Max = 99.99;
float CO2Min = 35.0;
float normCO2Max = 99.99;
float normCO2Min = 35.0;

// Motor
float turntime = 02.00;
bool automatik = true;
float motorStep = 0.05;
float normTurntimeMax = 24.0;
float normTurntimeMin = 0.1;
byte minu =30, h = 2;
unsigned long m_start;
unsigned long m_current;
unsigned long m_interval = 200;

byte rtc_sec, rtc_minu, rtc_h, rtc_d;
unsigned long rtc_start;
unsigned long rtc_current;
unsigned long rtc_interval = 1000;

// Date
int isttime = 14;
int solltime = 21;

//Menu principal
const char hmenu[] PROGMEM = "________Menu________";
const char menu1[] PROGMEM = "  Mode              ";
const char menu2[] PROGMEM = "  Temperatur        ";
const char menu3[] PROGMEM = "  Humidity         ";
const char menu4[] PROGMEM = "  Motor            ";

//Sous-Menu Mode
const char smode[] PROGMEM = "________Mode________";
const char mode1[] PROGMEM = "  Oeuf Poule        ";
const char mode2[] PROGMEM = "  Oeuf canard       ";
const char mode3[] PROGMEM = "  Oeuf caille      ";

//Sous-Menu solltempe
const char stemp[] PROGMEM = "_____Temperatur_____";
const char temp1[] PROGMEM = "  Temperatur";
const char temp2[] PROGMEM = "  Temp min  ";
const char temp3[] PROGMEM = "  Temp max  ";

//Sous-Menu humidity
const char shumi[] PROGMEM = "______Humidity______";
const char humi1[] PROGMEM = "  Humidity  ";
const char humi2[] PROGMEM = "  Humi min  ";
const char humi3[] PROGMEM = "  Humi max  ";

//Sous-Menu Motor turn time
const char smotor[] PROGMEM = "________Motor_______";
const char motor1[] PROGMEM = "  Automatic        ";
const char motor2[] PROGMEM = "  Turn time";
const char motor3[] PROGMEM = "  Manuel           ";

//Default LCD
const char tempdef[] PROGMEM = "Temp";
const char humidef[] PROGMEM = "Humi";
const char daydef[] PROGMEM = "Day";
const char sepadef[] PROGMEM = "/";
const char motorh[] PROGMEM = "h";
const char motorm[] PROGMEM = "m";
const char error[] PROGMEM = "Error";


const char retour[] PROGMEM = "  exit             ";
const char leer20[] PROGMEM = "                    ";
const char leer1[] PROGMEM = " ";

byte select = 0;
byte sel[] = {
  B11000,
  B11100,
  B11110,
  B11111,
  B11110,
  B11100,
  B11000,
  B00000
};
byte Grad = 1;
byte gradCelcius[] = {
  B11100,
  B10100,
  B11100,
  B00000,
  B01111,
  B01000,
  B01000,
  B01111
};
byte dimRH = 2;
byte rH[] = {
  B11000,
  B11001,
  B00010,
  B00100,
  B01000,
  B10011,
  B00011,
  B00000
};

byte down = 3;
byte dirDown[] = {
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B01110,
  B00100,
  B00000
};

byte up = 4;
byte dirUp[] = {
  B00000,
  B00100,
  B01110,
  B11111,
  B00000,
  B00000,
  B00000,
  B00000
};
byte yes = 5;
byte ye[] = {
  B00000,
  B00000,
  B00000,
  B00001,
  B00010,
  B10100,
  B01000,
  B00000
};

//int sensortemp = A0;
#define sensortemp 3
OneWire oneWire(sensortemp);
DallasTemperature sensors(&oneWire);
zpr tzpr;
zpr hzpr;

//Timer
const unsigned long t_on = 30000; // Globale Variable für t_on (en ms)
unsigned long t_off = 2; // Globale Variable für T_off (en heure)
Timer timer(t_on); // Initialisierung mit t_on

ParameterControl temperatureControl(lcd, upButton, downButton, selectButton, tempStep, &temperatur, &bselect);
ParameterControl tempMaxControl(lcd, upButton, downButton, selectButton, tempStep, &tempMax, &bselect);
ParameterControl tempMinControl(lcd, upButton, downButton, selectButton, tempStep, &tempMin, &bselect);
ParameterControl humidityControl(lcd, upButton, downButton, selectButton, humiStep, &humidity, &bselect);
ParameterControl humiMaxControl(lcd, upButton, downButton, selectButton, humiStep, &humiMax, &bselect);
ParameterControl humiMinControl(lcd, upButton, downButton, selectButton, humiStep, &humiMin, &bselect);

void setup() {
  initialisation();
  pinConfig();
  //gestionAfiche();
  //afficheDefaut();
}

void loop() {
  run();
  gestionAfiche();
}
void initialisation(){
  lcd.begin(20, 4);
  lcd.init();
  sensors.begin();
  Serial.begin(9600);
  lcd.backlight();
  lcd.createChar(select, sel);
  lcd.createChar(Grad, gradCelcius);
  lcd.createChar(dimRH, rH);
  lcd.createChar(down, dirDown);
  lcd.createChar(up, dirUp);
  lcd.createChar(yes, ye);
  lcd.clear();
  timer.setTOff(t_off);
  humidityControl.settPeriode(5);
  humiMaxControl.settPeriode(5);
  humiMinControl.settPeriode(5);
  t_off = (h*60 + minu)*3600;
  timer.setTOff(t_off);
  Serial.println(t_off);
  rtc_start = millis();
  m_start = millis();
}
void pinConfig(){
  //IO-Input / Capteurs
  pinMode(upButton, INPUT_PULLUP);
  pinMode(downButton, INPUT_PULLUP);
  pinMode(selectButton, INPUT_PULLUP);
  pinMode(IO_sHumi, INPUT);
/*  
  pinMode(IO_sPorte, INPUT);
  pinMode(IO_sTemp, INPUT);
  pinMode(IO_sHumi, INPUT);
  pinMode(IO_sCO2, INPUT);

  //IO-Output / Acteurs
  pinMode(IO_Chauff1, OUTPUT);
  pinMode(IO_Chauff2, OUTPUT);
  pinMode(IO_Humi, OUTPUT);
  pinMode(IO_Vntl, OUTPUT);
  pinMode(IO_Extr, OUTPUT);
  pinMode(IO_Md, OUTPUT);
  pinMode(IO_Mg, OUTPUT);
  pinMode(IO_Ecl, OUTPUT);
*/
}
void modeConfig(){

}
void run(){
  rtc();
  processSensorTemp();
  processSensorHumi();
  processSensorCO2();
  processControl(start);
}
void microSD(){

}

//Gestion des capteurs de temperature
void processSensorTemp(){
  sensors.requestTemperatures();
  istemp = sensors.getTempCByIndex(0);
}

//Gestion des capteurs d'humidité
void processSensorHumi(){
  sensors.requestTemperatures();
  ishumi = sensors.getTempCByIndex(0);
}

//Gestion des capteurs de qualité d'air
void processSensorCO2(){
  isCO2 = analogRead(IO_sCO2);
}

//Gestion de timing de tournage d'oeufs
void processTimingMotor(bool en){

  //Veränderung der T_off actualisieren
  if (t_off != (h*60 + minu)*3600){
    t_off = (h*60 + minu)*3600;
    timer.setTOff(t_off);
  }
  timer.setFreigabe(en); // Oder false, um die Freigabe zu deaktivieren
  timer.update();
}


//Gestion des acteurs
void processControl(bool en){
  //Acteur de chauffage
  tzpr.def(true, istemp, tempMinControl.gettValue(), tempMaxControl.gettValue() );
  acteur(IO_Chauff1, en, tzpr.getAktiv());

  //Acteur humidificateur
  hzpr.def(true, ishumi, humiMinControl.gettValue(), humiMaxControl.gettValue() );
  acteur(IO_Humi, en, hzpr.getAktiv());

  //Moteur tourne gauche
  acteur(IO_Mg, en, timer.getQ1() && !digitalRead(IO_Md));
  //Moteur tourne droite
  acteur(IO_Md, en, timer.getQ2() && !digitalRead(IO_Mg));

  //Eclerage
  
  //Extraction
}

//fonction actionneurs
void acteur(int pin, bool en, bool aktiv){
  digitalWrite(pin, (en && aktiv));
}

// affichage du menu principal
void gestionAfiche(){

  if ((!digitalRead(upButton) || !digitalRead(downButton) || !digitalRead(selectButton)) && !bmenu){
    bmenu = true;
    lcd.backlight();
    updateMenu();
    while (!digitalRead(upButton) || !digitalRead(downButton) || !digitalRead(selectButton));
  }

  if (bmenu){
    menuPrincipal();

    if (!bmenu){
      blstart = millis();
      backlight = true;
    }
  }else{
    afficheDefaut();
  }
  sousMenu();

  if (!bmenu && backlight){
    blcurrent = millis();  
    if (blcurrent - blstart >= blperiod)  
    {
      blstart = blcurrent;
      lcd.noBacklight();
      backlight = false;
    }
    
  }
}

// affichage du menu principal
void menuPrincipal(){
  if (!digitalRead(downButton)){
    menu++;
    if (menu > 5){
      menu = 5;
    }
    updateMenu();
    while (!digitalRead(downButton));
  }
  if (!digitalRead(upButton)){
    menu--;
    if (menu <= 0){
      menu = 1;
    }
    updateMenu();
    while(!digitalRead(upButton));
  }
  if (!digitalRead(selectButton)){
    bsmenu = true;
    menuToSmenu();
    while (!digitalRead(selectButton));
  }
}

// affichage du menu mode
void menuMode(){
  if (!digitalRead(downButton)){
    mode++;
    if (mode > 4){
      mode = 4;
    }
    updateMode();
    while (!digitalRead(downButton));
  }
  if (!digitalRead(upButton)){
    mode--;
    if (mode <= 0){
      mode = 1;
    }
    updateMode();
    while(!digitalRead(upButton));
  }
  if (!digitalRead(selectButton)){
    executeMode();
    while (!digitalRead(selectButton));
  }
}


// affichage du menu temperatur
void menuTemp(){
  if (!digitalRead(downButton)){
    temp++;
    if (temp > 4){
      temp = 4;
    }
    updateTemp();
    while (!digitalRead(downButton));
  }
  if (!digitalRead(upButton)){
    temp--;
    if (temp <= 0){
      temp = 1;
    }
    updateTemp();
    while(!digitalRead(upButton));
  }
  if (!digitalRead(selectButton)){
    executeTemp();
    while (!digitalRead(selectButton));
  }
}


// affichage du menu Humidity
void menuHumi(){
  if (!digitalRead(downButton)){
    humi++;
    if (humi > 4){
      humi = 4;
    }
    updateHumi();
    while (!digitalRead(downButton));
  }
  if (!digitalRead(upButton)){
    humi--;
    if (humi <= 0){
      humi = 1;
    }
    updateHumi();
    while(!digitalRead(upButton));
  }
  if (!digitalRead(selectButton)){
    executeHumi();
    while (!digitalRead(selectButton));
  }
}

// affichage du menu Motor
void menuMotor(){
  if (!digitalRead(downButton)){
    motor++;
    if (motor > 4){
      motor = 4;
    }
    updateMotor();
    while (!digitalRead(downButton));
  }
  if (!digitalRead(upButton)){
    motor--;
    if (motor <= 0){
      motor = 1;
    }
    updateMotor();
    while(!digitalRead(upButton));
  }
  if (!digitalRead(selectButton)){
    executeMotor();
    while (!digitalRead(selectButton));
  }
}

//actualise le menu principal lorsque les boutons de direction sont appuyés
void updateMenu() {
  switch (menu) {
    case 1:
      afficheMenuLCD1();
      break;
    case 2:
      afficheMenuLCD1();
      break;
    case 3:
      afficheMenuLCD1();
      break;
    case 4:
      afficheMenuLCD2();
      break;
    case 5:
      afficheMenuLCD2();
      break;
  }
}

//actualise le menu Mode lorsque les boutons de direction sont appuyés
void updateMode() {
  switch (mode) {
    case 1:
      afficheModeLCD1();
      break;
    case 2:
      afficheModeLCD1();
      break;
    case 3:
      afficheModeLCD1();
      break;
    case 4:
      afficheModeLCD2();
      break;
  }
}


//actualise le menu Temp lorsque les boutons de direction sont appuyés
void updateTemp() {
  switch (temp) {
    case 1:
      afficheTempLCD1();
      break;
    case 2:
      afficheTempLCD1();
      break;
    case 3:
      afficheTempLCD1();
      break;
    case 4:
      afficheTempLCD2();
      break;
  }
}


//actualise le menu Humi lorsque les boutons de direction sont appuyés
void updateHumi() {
  switch (humi) {
    case 1:
      afficheHumiLCD1();
      break;
    case 2:
      afficheHumiLCD1();
      break;
    case 3:
      afficheHumiLCD1();
      break;
    case 4:
      afficheHumiLCD2();
      break;
  }
}

//actualise le menu Motor lorsque les boutons de direction sont appuyés
void updateMotor() {
  switch (motor) {
    case 1:
      afficheMotorLCD1();
      break;
    case 2:
      afficheMotorLCD1();
      break;
    case 3:
      afficheMotorLCD1();
      break;
    case 4:
      afficheMotorLCD2();
      break;
  }
}

void executeMode() {
  switch (mode) {
    case 1:
      modeAction1();
      break;
    case 2:
      modeAction2();
      break;
    case 3:
      modeAction3();
      break;
    case 4:
      bmode = false;
      backToMenu1();
      break;
  }
}

// du sousmenu Temp au action de stemp
void executeTemp() {
  switch (temp) {
    case 1:
      tempAction1();
      break;
    case 2:
      tempAction2();
      break;
    case 3:
      tempAction3();
      break;
    case 4:
      btemp = false;
      backToMenu1();
      break;
  }
}


// du sousmenu Humi au action de shumi
void executeHumi() {
  switch (humi) {
    case 1:
      humiAction1();
      break;
    case 2:
      humiAction2();
      break;
    case 3:
      humiAction3();
      break;
    case 4:
      bhumi = false;
      backToMenu1();
      break;
  }
}

// du sousmenu Motor au action de smotor
void executeMotor() {
  switch (motor) {
    case 1:
      motorAction1();
      break;
    case 2:
      motorAction2();
      break;
    case 3:
      motorAction3();
      break;
    case 4:
      bmotor = false;
      backToMenu2();
      break;
  }
}

// du menu au sousmenus
void menuToSmenu() {
  if(bsmenu){
    if(!digitalRead(selectButton)){
      if(menu == 1){
        mode = 1;
        updateMode();
        bmode = true;
      }else
      if(menu == 2){
        temp = 1;
        updateTemp();
        btemp = true;
      }else
      if(menu == 3){
        humi = 1;
        updateHumi();
        bhumi = true;
      }else
      if(menu == 4){
        motor = 1;
        updateMotor();
        bmotor = true;
      }else
      if(menu == 5){
        menu = 1;
        bmenu = false;
        backToDefaut();
      }
    }
  }
}


void sousMenu(){
  while(bmode){
    menuMode();
    run();
  }
  while(btemp){
    menuTemp();
    run();
      
  }
  while(bhumi){
    menuHumi();
    run();
  }
  while(bmotor){
    menuMotor();
    run();
  }
}

// Reglage du mode 1
void modeAction1(){
  if(!digitalRead(selectButton)){
    bsmode1 = true;
    bsmode2 = false;
    bsmode3 = false;
    updateMode();
    bselect=false;
  }
}

// Reglage du mode 2
void modeAction2(){
  if(!digitalRead(selectButton)){
    bsmode1 = false;
    bsmode2 = true;
    bsmode3 = false;
    updateMode();
    bselect=false;
  }
}

// Reglage du mode 3
void modeAction3(){
  if(!digitalRead(selectButton)){
    bsmode1 = false;
    bsmode2 = false;
    bsmode3 = true;
    updateMode();
    bselect=false;
  }
}

// Reglage de la solltempe 
void tempAction1(){
  setbselectTrue();
  while(temp == 1 && bselect ){
    temperatureControl.updateParameter(12, 1, tempMin, tempMax);
    run();
  }
}

// Reglage de la solltempe minimale 
void tempAction2(){
  setbselectTrue();
  while(temp == 2 && bselect ){
    tempMinControl.updateParameter(12, 2, normTempMin, tempMax);
    run();
  }
}

// Reglage de la solltempe maximale
void tempAction3(){
  setbselectTrue();
  while(temp == 3 && bselect ){
    tempMaxControl.updateParameter(12, 3, tempMin, normTempMax);
    run();
  }
}

// Reglage de l'humidité 
void humiAction1(){
  setbselectTrue();
  while(humi == 1 && bselect ){
    humidityControl.updateParameter(12, 1, humiMin, humiMax);
    run();
  }
}

// Reglage de l'humidité minimale 
void humiAction2(){
  setbselectTrue();
  while(humi == 2 && bselect ){
    humiMinControl.updateParameter(12, 2, normHumiMin, humiMax);
    run();
  }
}

// Reglage de l'humidité maximale
void humiAction3(){
  setbselectTrue();
  while(humi == 3 && bselect ){
    humiMaxControl.updateParameter(12, 3, humiMin, normHumiMax);
    run();
  }
}

// Reglage du motor 1
void motorAction1(){
  setbselectTrue();
  if(motor == 1 && bselect ){
    automatik = true;
    bselect = false;
    updateMotor();
  }
}

// Reglage de l'interval de rotation de moteur
void motorAction2(){
  setbselectTrue();
  while(motor == 2 && bselect ){
    setTime();
    run();
  }
}

// Reglage du motor 3
void motorAction3(){
  setbselectTrue();
  if(motor == 3 && bselect ){
    automatik = false;
    bselect = false;
    updateMotor();
  }
}

// retour au principale
void backToMenu1(){
  afficheMenuLCD1();
  setBsmenuFalse();
}

// retour au principale
void backToMenu2(){
  afficheMenuLCD2();
  setBsmenuFalse();
}

// retour au principale
void backToDefaut(){
  lcd.clear();
  afficheDefaut();
  setBmenuFalse();
}

// Affichage par defaut
void afficheDefaut(){
  if(bsmode1){
    afficheText(0, 0, incubation1);
  }
  else
  if(bsmode2){
    afficheText(0, 0, incubation2);
  }
  else
  if(bsmode3){
    afficheText(0, 0, incubation3);
  }
  afficheText(0, 1, tempdef);
  afficheDecale(6, 1, istemp);
  afficheText(12, 1, sepadef);
  afficheValue(14, 1, temperatur);
  afficheSymbole(19, 1, Grad);
  afficheText(0, 2, humidef);
  afficheDecale(6, 2, ishumi);
  afficheText(12, 2, sepadef);
  afficheValue(14, 2, humidity);
  afficheSymbole(19, 2, dimRH);/////////////////////////////
  AfficheRTCTime();
}

// Affichage des elements du menu principal
void afficheMenuLCD1(){
  afficheText(0, 0, hmenu);
  afficheText(0, 1, menu1);
  afficheText(0, 2, menu2);
  afficheText(0, 3, menu3);
  afficheSymbole(0, menu, select);
  afficheSymbole(19, 3, down);
}
void afficheMenuLCD2(){
  clean0x (3);
  afficheText(0, 0, hmenu);
  afficheText(0, 1, menu4);
  afficheText(0, 2, retour);
  afficheSymbole(0, menu-3, select);
  afficheSymbole(19, 1, up);
}

// Affichage des elements du menu mode
void afficheModeLCD1(){
  afficheText(0, 0, smode);
  afficheText(0, 1, mode1);
  afficheText(0, 2, mode2);
  afficheText(0, 3, mode3);
  if(bsmode1){
    afficheSymbole(18, 1, yes);
  }
  else
  if(bsmode2){
    afficheSymbole(18, 2, yes);
  }
  else
  if(bsmode3){
    afficheSymbole(18, 3, yes);
  }
  afficheSymbole(0, mode, select);
  afficheSymbole(19, 3, down);
}
void afficheModeLCD2(){
  clean0x (2, 3);
  afficheText(0, 0, smode);
  afficheText(0, 1, retour);
  afficheSymbole(0, mode-3, select);
  afficheSymbole(19, 1, up);
}

// Affichage des elements du menu Temp
void afficheTempLCD1(){
  clean ();
  afficheText(0, 0, stemp);
  afficheText(0, 1, temp1);
  afficheText(0, 2, temp2);
  afficheText(0, 3, temp3);
  //Valeurs
  afficheValue(12, 1, temperatur);
  afficheValue(12, 2, tempMin);
  afficheValue(12, 3, tempMax);
  afficheSymbole(18, 1, 2, 3, Grad);
  //Symboles
  afficheSymbole(0, temp, select);
  afficheSymbole(19, 3, down);
}
void afficheTempLCD2(){
  clean0x (2, 3);
  afficheText(0, 0, stemp);
  afficheText(0, 1, retour);
  //Symboles
  afficheSymbole(0, temp-3, select);
  afficheSymbole(19, 1, up);
}

// Affichage des elements du menu Humi
void afficheHumiLCD1(){
  clean ();
  //textes
  afficheText(0, 0, shumi);
  afficheText(0, 1, humi1);
  afficheText(0, 2, humi2);
  afficheText(0, 3, humi3);
  //Valeurs
  afficheValue(12, 1, humidity);
  afficheValue(12, 2, humiMin);
  afficheValue(12, 3, humiMax);
  afficheSymbole(18, 1, 2, 3, dimRH);
  //Symboles
  afficheSymbole(0, humi, select);
  afficheSymbole(19, 3, down);
}
void afficheHumiLCD2(){
  clean0x (2, 3);
  //textes
  afficheText(0, 0, shumi);
  afficheText(0, 1, retour);
  //Symboles
  afficheSymbole(0, humi-3, select);
  afficheSymbole(19, 1, up);
}

// Affichage des elements du menu Motor
void afficheMotorLCD1(){
  cleanxx (19, 1);
  afficheText(0, 0, smotor);
  afficheText(0, 1, motor1);
  afficheText(0, 2, motor2);
  afficheText(0, 3, motor3);
  afficheDecale(12, 2, h);
  afficheText(14, 2, motorh);
  afficheDecale(15, 2, minu);
  afficheText(17, 2, motorm);
  if(automatik){
  afficheSymbole(18, 1, yes);
  }
  else
  {
  afficheSymbole(18, 3, yes);
  }
  afficheSymbole(0, motor, select);
  afficheSymbole(19, 3, down);
}
void afficheMotorLCD2(){
  clean0x (2, 3);
  afficheText(0, 0, smotor);
  afficheText(0, 1, retour);
  afficheSymbole(0, motor-3, select);
  afficheSymbole(19, 1, up);
}

// affichage d'un symbole à une positon donnée
void afficheSymbole(int col, int row, byte symbole){
  lcd.setCursor(col, row);
  lcd.write(symbole);
}

// affichage d'un symbole à 3 positons données
void afficheSymbole(int col, int row1, int row2, int row3, byte symbole){
  lcd.setCursor(col, row1);
  lcd.write(symbole);
  lcd.setCursor(col, row2);
  lcd.write(symbole);
  lcd.setCursor(col, row3);
  lcd.write(symbole);
}

void afficheText(int col, int row, const char* text) {
  char buffer[21]; // Annahme: 20 Zeichen pro Zeile + null-Terminator
  strncpy_P(buffer, text, sizeof(buffer));
  buffer[sizeof(buffer) - 1] = '\0'; // Null-Terminator sicherstellen
  lcd.setCursor(col, row);
  lcd.print(buffer);
}

void cleanxx (int col, int row){
  afficheText(col, row, leer1);
}

void clean0x (int row){
  afficheText(0, row, leer20);
}

void clean0x (int row1, int row2){
  afficheText(0, row1, leer20);
  afficheText(0, row2, leer20);
}

void clean (){
  afficheText(17, 1, leer1);
  afficheText(17, 2, leer1);
  afficheText(17, 3, leer1);
  afficheText(19, 1, leer1);
  afficheText(19, 2, leer1);
}

// affichage de la valeur d'une variable float à une positon donnée
void afficheValue(int col, int row, float value){
  lcd.setCursor(col, row);
  lcd.print(value, 2);
}

// affichage de la valeur d'une variable Integer à une positon donnée
void afficheValue(int col, int row, int value){
  lcd.setCursor(col, row);
  lcd.print(value);
}


//Gestion de l'affiche avec decalage de chiffres
void afficheDecale(int col, int row, float value){
  if (value > 0.0 && value < 10.0){
    afficheValue(col, row, 0);
    afficheValue((col + 1), row, value);
  }
  else if(value > 99.99 || value < -9.99){
    afficheText(col, row, error);
  }
  else{
    afficheValue(col, row, value);
  }
}
//Gestion de l'affiche avec decalage de chiffres
void afficheDecale(int col, int row, byte value){
  if (value > -10 && value < 10){
    afficheValue(col, row, 0);
    afficheValue((col + 1), row, value);
  }
  else{
    afficheValue(col, row, value);
  }
}

void setTime(){
  m_current = millis();
  if (!digitalRead(upButton) && h < 24){

    if (m_current - m_start >= m_interval){
      m_start = m_current; 
      minu = minu + 5;
    }
  }

  if (!digitalRead(downButton) && minu > 0){

    if (m_current - m_start >= m_interval){
      m_start = m_current; 
      minu = minu - 5;
    }
  }

  if (!digitalRead(downButton) && minu == 0 && h >= 1){

    if (m_current - m_start >= m_interval){
      m_start = m_current; 
      minu = 55;
      h = h - 1;
    }
  }

  if(minu >= 60){
    if(h < 24){
      h = h + 1; 
      minu = 0;
    }
    else 
    {
      h = 24;
    }
  }
  
  afficheDecale(12, 2, h);
  afficheText(14, 2, motorh);
  afficheDecale(15, 2, minu);
  afficheText(17, 2, motorm);

  setbselectfalse();
} 

// RTC Time 
void rtc(){
  rtc_current = millis(); 
  if (rtc_current - rtc_start >= rtc_interval){
    rtc_start += rtc_interval; 
    rtc_sec = rtc_sec + 1;
  }
  if(rtc_sec >= 60){
    rtc_minu = rtc_minu + 1; 
    rtc_sec = 0;
  }
  if(rtc_minu >= 60){
    rtc_h = rtc_h + 1; 
    rtc_minu = 0;
  }
  if(rtc_h >= 24){
    rtc_d = rtc_d + 1; 
    rtc_h = 0;
  }
} 
// Affichage de Temp ecoulé
void AfficheRTCTime(){
  static bool change;
  if(rtc_d == 0){
    afficheDecale(15, 3, rtc_sec);
    afficheText(14, 3, sepadef );
    afficheDecale(12, 3, rtc_minu);
    afficheText(11, 3, sepadef );
    afficheDecale(9, 3, rtc_h);
    afficheText(8, 3, sepadef );
    afficheDecale(6, 3, rtc_d);
    change = true;
  }
  else
  if(rtc_d == 1 && rtc_h == 0 && rtc_minu == 0 && rtc_sec == 0 && change){
    clean0x(3);
    change = false;
  }
  else
  {
    afficheDecale(10, 3, rtc_minu);
    afficheText(12, 3, sepadef);
    afficheValue(13, 3, solltime);
  }

  afficheText(0, 3, date);
  afficheText(17, 3, daydef);
}

void setbselectTrue(){
  if (!digitalRead(selectButton)){
    bselect = true;
    while (!digitalRead(selectButton));
  }
}
void setbselectfalse(){
  if (!digitalRead(selectButton)){
    bselect = false;
    while (!digitalRead(selectButton));
  }
}

void setBsmenuFalse(){
  if (!digitalRead(selectButton)){
    bsmenu = false;
    while (!digitalRead(selectButton));
  }
}

void setBmenuFalse(){
  if (!digitalRead(selectButton)){
    bmenu = false;
    while (!digitalRead(selectButton));
  }
}