#include <EEPROM.h>
#include <DS3231.h>
#include <Wire.h>
#include <OneWire.h>
//#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h> //Warning you must connect the Sda to  pin A4 and the Clock to pin A5 
#if defined(ARDUINO) && ARDUINO >= 100
#define printByte(args)  write(args);
#else
#define printByte(args)  print(args,BYTE);
#endif

#include "FastLED.h"
//#include "PCF8574.h"
#include <string.h>

#define _nr_led  8 //The amount of LEDs on your ARGB LED Strip that you wish to use
#define DATA_PIN 3 //The Digital Pin on Arduino that connects to the LED Strip's Data Pin (DIN)

CRGB Bar_LED[_nr_led]; 
const CRGB Negru = CRGB(0, 0, 0);
const CRGB Verde = CRGB(255, 0, 0);
const CRGB Verde_m = CRGB(10, 0, 0);
const CRGB Rosu = CRGB(0, 255, 0);
const CRGB Rosu_m = CRGB(0, 10, 0);
const CRGB Albastru = CRGB(0, 0, 255);
const CRGB Violet = CRGB(0, 255, 255);
const CRGB Cyan = CRGB(255, 0, 255);
const CRGB Cyan_m = CRGB(10, 0, 10);
const CRGB Galben = CRGB(255, 255, 0);
const CRGB Galben_m = CRGB(10, 10, 0);
const CRGB Portocaliu = CRGB(100, 255, 0);
const CRGB Alb = CRGB(255, 255, 255);

#define _off_culoare_LED_C  Negru
#define _by_culoare_LED_C   Portocaliu
#define _on_culoare_LED_C   Verde
#define _er_culoare_LED_C   Rosu

#define _off_culoare_LED_R  Negru
#define _by_culoare_LED_R   Galben
#define _on_culoare_LED_R   Violet
#define _er_culoare_LED_R   Rosu

#define _off_culoare_LED_P  Negru
#define _by_culoare_LED_P   Galben
#define _on_culoare_LED_P   Cyan
#define _er_culoare_LED_P   Rosu

//PCF8574 PCF_01(0x20);
//PCF8574 PCF_02(0x21);
DS3231 Clock;
LiquidCrystal_I2C lcd(0x27, 20, 4); 

#define ONE_WIRE_BUS 2
#define TEMPERATURE_PRECISION 9

//OneWire oneWire(ONE_WIRE_BUS);
//DallasTemperature sensors(&oneWire);

//DeviceAddress Address_B0 = {0x28, 0xAA, 0x1D, 0x4F, 0x53, 0x14, 0x01, 0x71};
//DeviceAddress Address_B1 = {0x28, 0xAA, 0x41, 0x36, 0x53, 0x14, 0x01, 0xFE};
//DeviceAddress Address_P0 = {0x28, 0xAA, 0xAE, 0x4C, 0x53, 0x14, 0x01, 0xF8};
//DeviceAddress Address_P1 = {0x28, 0xAA, 0x3C, 0x36, 0x53, 0x14, 0x01, 0x7F};
//DeviceAddress Address_P2 = {0x28, 0xAA, 0xF1, 0x53, 0x53, 0x14, 0x01, 0xA0};
//DeviceAddress Address_P3 = {0x28, 0xAA, 0x2F, 0x3E, 0x53, 0x14, 0x01, 0x51};

//DeviceAddress sensorsAddresses[] = {
//                                    {0x28, 0xAA, 0x1D, 0x4F, 0x53, 0x14, 0x01, 0x71}, // Address_B0
//                                    {0x28, 0xAA, 0x41, 0x36, 0x53, 0x14, 0x01, 0xFE}, // Address_B1
//                                    {0x28, 0xAA, 0xAE, 0x4C, 0x53, 0x14, 0x01, 0xF8}, // Address_P0
//                                    {0x28, 0xAA, 0x3C, 0x36, 0x53, 0x14, 0x01, 0x7F}, // Address_P1
//                                    {0x28, 0xAA, 0xF1, 0x53, 0x53, 0x14, 0x01, 0xA0}, // Address_P2
//                                    {0x28, 0xAA, 0x2F, 0x3E, 0x53, 0x14, 0x01, 0x51}, // Address_P3    
//                                   };


#define BUTTON_MODE    8
#define BUTTON_MINUS   9
#define BUTTON_PLUS   10

//Bar_LED
#define _led_C  0
#define _led_BE 1
#define _led_R1 2
#define _led_R2 3
#define _led_PB 4
#define _led_PP 5
#define _led_PE 6
#define _led_PC 7

//LCD_iesiri
#define _lcd_C  0
//spatiu        1
#define _lcd_BE 2
#define _lcd_R1 3
#define _lcd_R2 4
//spatiu        5
#define _lcd_PB 6
#define _lcd_PP 7
#define _lcd_PE 8
#define _lcd_PC 9
//spatiu        10
//spatiu        11
#define _lcd_WF 12

//byte_ies_rel
#define _ies_C   0
#define _ies_BE  1   
#define _ies_R1  2           
#define _ies_R2  3          
#define _ies_PB  4    
#define _ies_PP  5
#define _ies_PE  6
#define _ies_PC  7

//byte_intrari
#define _int_BE  0
#define _int_PP  1   
#define _int_PE  2           
#define _int_SC  3 //SC Senzor curent         
#define _ies_X   4    
#define _ies_LR  5 //Led Rosu
#define _ies_LV  6 //Led Verde
#define _ies_LA  7 //Led Albastru

#define _B0 0
#define _B1 1
#define _P0 2
#define _P1 3
#define _P2 4
#define _P3 5
#define _Nv 3 // _Nv = nivel senzor; 3 = pozitia buffer afisare temp

// byte_alarme
#define _alarma_B0 0
#define _alarma_PP 1
#define _alarma_PE 2
#define _alarma_Pu 3
#define _alarma_t1 4
#define _alarma_t2 5
#define _alarma_TP 6

//byte_centrala
#define _stare_C   0  // OFF/ON 
#define _mod_auto  1 // M/A
#define _mod_prog  2 // A/P 
#define _eroare    3 // Eroare
#define _vara      4

//byte_tip_memorie
#define _mem_centrala 0
#define _mem_erori    1
#define _mem_alarme   2

#define _gol       7
#define _plin      1
#define _nefolosit 2//'x' //2
#define _activ     3
#define _inactiv   4
#define _electric  5
#define _wifi      6
#define _vid       ' '

//#define _nivel       0
//#define _eroare_senz 1

#define _meniu_0        0
#define _iesire_meniu_0 3
#define _meniu_1        10
#define _meniu_2        30
#define _meniu_3        50

#define _set_temp_Pu_max       75
#define _set_temp_Pu_min       15
#define _set_hist_temp_Pu_max  20
#define _set_hist_temp_Pu_min   1
#define _set_temp_B_max        70
#define _set_temp_B_min        20
#define _set_hist_temp_B_max   20
#define _set_hist_temp_B_min    1
//#define _hist_temp_pompe        5
#define _temp_al_Pu_min        30
#define _temp_al_Pu_max        80
#define _set_temp_PP_min       20
#define _ora_1_RE_min          10
#define _ora_1_RE_max          12
#define _ora_2_RE_min          15
#define _ora_2_RE_max          20
#define _ora_1_Pr_min          10
#define _ora_2_Pr_max          22
#define _nr_erori_min           1
#define _nr_erori_max           9

#define _temp_eroare       0
#define _nr_senzori        6
#define _nr_citiri_intrari 5
#define _max_aj_temp       100 // max ajustare temp senzori +-1.00° 

#define _set_timp_iluminare_lcd_max 90
#define _set_timp_iluminare_lcd_min 30
#define _nr_memorie_max             39 

#define _an_max   60
#define _an_min   20
#define _luna_max 12
#define _luna_min  1
#define _ziua_min  1
#define _ora_max  23
#define _ora_min   0
#define _min_max  59
#define _min_min   0

#define _on     HIGH
#define _off    LOW
#define _b_on   HIGH
#define _iesire_on LOW
#define _iesire_off HIGH
#define _manual 0
#define _auto   1

#define adresa_i2c_24C32 0x57

#define initiere             1
#define address_set_temp_Pu  0
#define address_set_temp_B0  1
#define address_set_temp_B1  2
#define address_aj_temp_B0   3
#define address_aj_temp_B1   4
#define address_aj_temp_P0   5
#define address_aj_temp_P1   6
#define address_aj_temp_P2   7
#define address_aj_temp_P3   8
#define address_set_nr_erori 9

#define address_set_hist_temp_Pu       10
#define address_set_hist_temp_B0       11
#define address_set_hist_temp_B1       12
#define address_set_temp_PP            13
#define address_temp_al_Pu             14
#define address_set_timp_iluminare_lcd 15
#define address_byte_centrala          16
#define address_nr_info_memorie        17
#define address_set_ora_1_Pr           18
#define address_set_ora_2_Pr           19
#define address_set_ora_1_RE           20
#define address_set_ora_2_RE           21
#define address_set_temp_al_Pu         22

#define _interval_citire_senz        1000 * 5        //  5sec
#define _timp_meniu_3                1000 * 5        //  5sec
#define _timp_on_off_centrala        1000 * 10       // 10sec
#define _timp_alarma_PP              1000 * 10   // 60m = 1h:00
#define _timp_alarma_PE              1000 * 60 * 75  // 75m = 1h:15
//#define _timp_min_centrala_auto      36000000 // 10h
//#define _timp_max_centrala_auto      46800000 // 13h
#define _timp_off_centrala_eroare   1000 * 60 * 15      // 15min
#define _timp_alarma_t1             1000 * 60 * 45      // 45min
#define _timp_alarma_t2             1000 * 60 * 60 * 6  // 6h
#define _perioada_test_pompe        1000 * 30  // 30s 
#define _interval_test_pompe        1000 * 60 * 60 * 24 * 30 //30zile  


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
boolean setari_noi = LOW; // HIGH pt a memora datele de mai jos, !!!! dupa instalare soft se trece in LOW
byte set_temp_Pu            = 60,
     set_hist_temp_Pu       = 3,
     set_temp_B0            = 40,
     set_hist_temp_B0       = 2,
     set_temp_B1            = 45,
     set_hist_temp_B1       = 5,
     set_temp_PP            = 50,
     set_temp_al_Pu         = 75,
     set_ora_1_Pr           = 10,
     set_ora_2_Pr           = 22,
     set_ora_1_RE           = 10,
     set_ora_2_RE           = 20,   
     set_timp_iluminare_lcd = 30,
     set_nr_erori           = 5, 
     aj_temp_senzor[_nr_senzori] = {_max_aj_temp, _max_aj_temp, _max_aj_temp, _max_aj_temp, _max_aj_temp, _max_aj_temp};       
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
              
int  adresa_mem_24C32;
bool h12, PM, l = false;
bool stop_b_mode, stop_b_minus, stop_b_plus, b_plus, b_minus; 
bool stare_centrala, stare_centrala_noua;
bool senzori_ok = LOW;
bool on_noBacklight, bit_secunda, on_afisare;
bool on_centrala_auto, test_pompe_man, test_pompe_auto, schimbare_stare_C;
bool on_ies_RE, on_temp_B0, on_temp_PP, on_temp_PE;
bool ledChanged = false;

byte ziua_max[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
byte aj_ziua_max, an_RTC, luna_RTC, ziua_RTC, ora_RTC, min_RTC, sec_RTC, temp_RTC, anbisect, dw, h, m, s;
byte an_m, luna_m, ziua_m, ora_m, min_m, info_m_1, info_m_2, info_m_3, nr_memorie, nr_info_memorie, nr_m;
byte mod = _meniu_0;
byte byte_alarme = 0;
byte byte_centrala = 0;
byte byte_erori_senzor = 0;
byte byte_ies_rel, byte_ies_rel_nou;
byte byte_intrari, nr_citiri_intrari; 

bool bit_1;
byte nn;

float temp_citita, temp_initiala_P0; 

float temp_senzor[_nr_senzori] = {10, 20, 10, 12, 20, 70};
byte  nivel[_nr_senzori] = {_plin, _plin, _plin, _plin, _plin, _plin};
byte  nr_erori_senzor[_nr_senzori] = {0, 0, 0, 0, 10, 0};
byte  buffer_nivel[_nr_senzori];

unsigned long timp_iluminare_lcd, timp_on_off_centrala, timp_calcul_bit_secunda, timp_meniu_3;
unsigned long interval_citire_senz, perioada_test_pompe, interval_test_pompe; 
unsigned long timp_alarma_PP, timp_alarma_PE, timp_alarma_t1, timp_alarma_t2, timp_off_centrala_eroare;
unsigned long lastRequestTime = 0;
unsigned long conversionDelay = 0;
unsigned long lastReadTime = 0;
bool conversionInProgress;

char buffer_ceas[12];     // 00:00_25°w_ 
char buffer_ceas_nou[12];                  
char buffer_data[9];      // 00-00-00   
char buffer_data_nou[9];
char buffer_info[16];     // Centrala_A_OFF__
char buffer_info_nou[16];
char buffer_temp[6][5];   //25°[] 
char buffer_temp_nou[6][5];

char lcd_iesiri[16] = {' ', ' ', _inactiv, _inactiv, _inactiv, ' ', _inactiv, _inactiv, _inactiv, _inactiv, ' ', ' ', ' ', ' ', ' ','\0'};
char lcd_iesiri_nou[16];

byte NEFOLOSIT[] = {
  B11111,
  B10001,
  B11011,
  B10101,
  B11011,
  B10001,
  B11111,
  B00000
};  
byte GOL[] = {
  B11111,
  B10001,
  B10001,
  B10001,
  B10001,
  B10001,
  B11111,
  B00000
};
byte PLIN[] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B00000
};

byte INACTIV[] = {
 // B00000,
  B01110,
  B10001,
  B10001,
  B10101,
  B10001,
  B10001,
  B01110,  
  B00000
};
byte ACTIV[] = {
 // B00000, 
  B01110,
  B11111,
  B11111,
  B11011,
  B11111,
  B11111,
  B01110,
  B00000
};

byte WIFI[] = {
  B00000, 
  B11111,
  B00000,
  B01110,
  B00000,
  B00100,
  B00000,
  B00000
};
byte ELECTRIC[] = {
  B11111, 
  B10101,
  B11001,
  B11111,
  B10011,
  B10101,
  B11111,
  B00000
};

void setup(void)
{
 TCCR1B = 0;
 TCCR1A = 0;
 //TCCR1B = _BV(WGM12);
// OCR1A = 15624;               // Valoarea de comparație (1 secundă pentru prescaler = 1024)
//TCCR1B |= _BV(CS12) | _BV(CS10); // Prescaler = 1024
 
 //TCCR1A = 0;
//TCCR1B = 0;
//TCNT1 = 0;
//TIMSK1 = 0; // Dezactivează toate întreruperile asociate Timer1


 pinMode(BUTTON_MODE, INPUT_PULLUP);
 pinMode(BUTTON_PLUS, INPUT_PULLUP);
 pinMode(BUTTON_MINUS, INPUT_PULLUP);

 //Wire.begin();
 //PCF_01.begin();
 //PCF_02.begin();
 Clock.setClockMode(false);
 lcd.init();
 lcd.createChar(_gol, GOL);
 lcd.createChar(_plin, PLIN);
 lcd.createChar(_nefolosit, NEFOLOSIT);
 lcd.createChar(_activ, ACTIV);
 lcd.createChar(_inactiv, INACTIV);
 lcd.createChar(_wifi, WIFI);
 lcd.createChar(_electric, ELECTRIC);
 
 FastLED.addLeds<WS2812, DATA_PIN>(Bar_LED, _nr_led); 
 
 
 //conversionDelay = sensors.millisToWaitForConversion(TEMPERATURE_PRECISION);
 //interval_citire_senz = millis();
 //lastReadTime = millis();
 //sensors.requestTemperatures();
 //conversionInProgress = true;
 lcd.setCursor(0, 0);
 lcd.print("ok");
 Serial.begin(9600);
 Serial.println("Conumicare OK");
 

          
 timp_iluminare_lcd = millis();
 timp_on_off_centrala = millis();
 interval_test_pompe = millis();  
 perioada_test_pompe = millis(); 
                   // Modul Normal (biturile COM1A1 și COM1A0 = 0)
    //TCCR1B = _BV(WGM12);         // Modul CTC (Clear Timer on Compare Match)
    OCR1A = 15624;               // Valoarea de comparație (1 secundă pentru prescaler = 1024)
          
    //TCNT1 = 0;                   // Resetează contorul la 0
   /// TCCR1B |= _BV(CS12) | _BV(CS10); // Prescaler = 1024
    TCCR1B = _BV(WGM12) | _BV(CS12) | _BV(CS10);
    TIMSK1 = _BV(OCIE1A);  // Activarea întreruperii pe comparație (OCIE1A)



  
}


ISR(TIMER1_COMPA_vect) 
{
  //Comută starea pinului la fiecare întrerupere
 Serial.println("ISR");
} 


void citire_RTC()
{
 ora_RTC = Clock.getHour(h12, PM);
 min_RTC = Clock.getMinute();
 ziua_RTC = Clock.getDate();
 luna_RTC = Clock.getMonth(l);
 an_RTC = Clock.getYear();
 temp_RTC = Clock.getTemperature();
 anbisect = an_RTC % 4;
}


void inregistrare_memorie (byte tip_memorie, byte date_memorie)
{
 nr_info_memorie++;
 if (nr_info_memorie > _nr_memorie_max) nr_info_memorie = 0;
 EEPROM.update(address_nr_info_memorie, nr_info_memorie);

 adresa_mem_24C32 = int(nr_info_memorie * 8);
 Wire.beginTransmission(adresa_i2c_24C32);
 Wire.write(byte(adresa_mem_24C32 >> 8));
 Wire.write(byte(adresa_mem_24C32 & 0xFF)); 
 Wire.write(ora_RTC);
 Wire.write(min_RTC);
 Wire.write(ziua_RTC);
 Wire.write(luna_RTC);
 Wire.write(an_RTC);
 Wire.write(tip_memorie);
 Wire.write(date_memorie);
 Wire.endTransmission();
}


void citire_memorie (int adresa_memorie)
{
  adresa_mem_24C32 = adresa_memorie * 8;
  Wire.beginTransmission(adresa_i2c_24C32);
  Wire.write(byte(adresa_mem_24C32 >> 8));
  Wire.write(byte(adresa_mem_24C32 & 0xFF));
  Wire.endTransmission();
  Wire.requestFrom(adresa_i2c_24C32, 8);
  ora_m = Wire.read();  if(ora_m > 99) ora_m = 0;
  min_m = Wire.read();  if(min_m > 99) min_m = 0;
  ziua_m = Wire.read(); if(ziua_m > 99) ziua_m = 0;
  luna_m = Wire.read(); if(luna_m > 99) luna_m = 0;
  an_m = Wire.read();  if(an_m > 99) an_m = 0;    
  info_m_1 = Wire.read(); if(info_m_1 > 99) info_m_1 = 0;
  info_m_2 = Wire.read(); if(info_m_2 > 99) info_m_2 = 0;
  info_m_3 = Wire.read(); if(info_m_3 > 99) info_m_3 = 0;
  Wire.endTransmission();
}


void calcul_stare_centrala ()
{   
 //verifica erori
 if (bitRead(byte_erori_senzor, _P0) || bitRead(byte_erori_senzor, _P2) || bitRead(byte_alarme, _alarma_t1) || bitRead(byte_alarme, _alarma_t2)) {
  bitSet(byte_centrala, _eroare);} else {bitClear(byte_centrala, _eroare);}
 
 //calcul pornire centrala
 if (!bitRead(byte_erori_senzor, _P0) && bitRead(byte_centrala, _mod_auto) && on_centrala_auto) { 
    if (nivel[_P0] == _gol | (nivel[_B1] == _gol && nivel[_P1] == _gol)) stare_centrala_noua = _on;} //pornire centrala auto/program/golire boiler
    
  
 //calcul oprire centrala
 if ((bitRead(byte_erori_senzor,_P0) || bitRead(byte_erori_senzor,_P2) || bitRead(byte_centrala,_vara)) && !stare_centrala) stare_centrala_noua = _off; //Nu porneste centrala la alarma P0 P2 vara   
 if (nivel[_P2] == _plin || bitRead(byte_centrala, _vara)) stare_centrala_noua = _off; //oprire centrala man/auto/program
 
 if (nivel[_P0] == _plin || temp_senzor[_P0] > temp_initiala_P0 + 1.00) timp_alarma_t1 =  millis();
 
 if (stare_centrala == _on) { 
    if (!bitRead(byte_erori_senzor, _P2)) timp_off_centrala_eroare = millis(); //declansare eroare centrala 
    if (millis() - timp_off_centrala_eroare > _timp_off_centrala_eroare) {
       if (!bitRead(byte_alarme, _alarma_Pu)) {bitSet(byte_alarme, _alarma_Pu); inregistrare_memorie(_mem_alarme, _alarma_Pu);}
       stare_centrala_noua = _off;}    
      
     if (millis() - timp_alarma_t1 > _timp_alarma_t1){         
        if (!bitRead(byte_alarme, _alarma_t1)) {bitSet(byte_alarme, _alarma_t1); inregistrare_memorie(_mem_alarme, _alarma_t1);}}
         //setari_noi = _on;}
         
     if (millis() - timp_alarma_t2 > _timp_alarma_t2){          
        if (!bitRead(byte_alarme, _alarma_t2)) {bitSet(byte_alarme, _alarma_t2); inregistrare_memorie(_mem_alarme, _alarma_t2);}
        bitClear(byte_centrala, _mod_auto); //centrala_mod = _manual; 
        stare_centrala_noua = _off;
        setari_noi = _on;}}   

 // schimbare stare centrala
 schimbare_stare_C = _on;   
 if (stare_centrala == stare_centrala_noua) {timp_on_off_centrala = millis(); schimbare_stare_C = _off;} 
 if (millis() - timp_on_off_centrala > _timp_on_off_centrala){
    stare_centrala = stare_centrala_noua;
    if (stare_centrala){
        if (!bitRead(byte_centrala, _stare_C)) {bitSet(byte_centrala, _stare_C); inregistrare_memorie(_mem_centrala, byte_centrala);} 
        bitClear(byte_alarme, _alarma_Pu);
        bitClear(byte_alarme, _alarma_PP);
        bitClear(byte_alarme, _alarma_PE);
        bitClear(byte_alarme, _alarma_t1);
        bitClear(byte_alarme, _alarma_t2);
        timp_alarma_PP = millis();
        timp_alarma_PE = millis(); 
        timp_alarma_t1 = millis(); 
        timp_alarma_t2 = millis(); 
        temp_initiala_P0 = temp_senzor[_P0];}
        else {
              if (bitRead(byte_centrala, _stare_C)) {bitClear(byte_centrala, _stare_C); inregistrare_memorie(_mem_centrala, byte_centrala);}}}  
}


void calcul_test_pompe_auto()
{
 if(millis() - interval_test_pompe > _interval_test_pompe) {test_pompe_auto = _on; interval_test_pompe = millis(); perioada_test_pompe = millis();} 
 if(millis() - perioada_test_pompe > _perioada_test_pompe) test_pompe_auto = _off;  
}


void Set_LED(int ledIndex, CRGB color) 
{
 if (Bar_LED[ledIndex] != color) {
     Bar_LED[ledIndex] = color;  // Setezi culoarea doar dacă este diferită
    ledChanged = true;}  // Flag-ul este setat pe true doar dacă s-a modificat culoarea
}

  
void calcul_elemente ()    
{
 byte citire_noua_intrari;
 //byte citire_noua_intrari = PCF_02.read8(); // citire intrari
 //if (byte_intrari != citire_noua_intrari) nr_citiri_intrari++; if(nr_citiri_intrari > _nr_citiri_intrari) {nr_citiri_intrari = 0; byte_intrari = citire_noua_intrari;}
 
 lcd_iesiri[_lcd_BE] = _inactiv; // initializare lcd_iesiri
 lcd_iesiri[_lcd_R1] = _inactiv;
 lcd_iesiri[_lcd_R2] = _inactiv;
 lcd_iesiri[_lcd_PB] = _inactiv;
 lcd_iesiri[_lcd_PP] = _inactiv;
 lcd_iesiri[_lcd_PE] = _inactiv;
 lcd_iesiri[_lcd_PC] = _inactiv;
 lcd_iesiri[_lcd_WF] = _vid;
 lcd_iesiri[_lcd_WF-1] = _electric;
 lcd_iesiri[_lcd_WF+1] = _inactiv;

 byte_ies_rel = 0b11111111; // initializare byte iesiri
 FastLED.clear();
 //Set_LED(_led_C, _off_culoare_LED_C);
 //Set_LED(_led_BE, _off_culoare_LED_R);
 //Set_LED(_led_R1, _off_culoare_LED_R);
 //Set_LED(_led_R2, _off_culoare_LED_R);
 
 //stare centrala
 if (bitRead(byte_centrala, _vara)) {
    lcd_iesiri[_lcd_C] = _nefolosit; // C
    Set_LED(_led_C, _off_culoare_LED_C);}
    else {
          if (bitRead(byte_centrala, _eroare)){
             //Er clipitor centrala on 
             //Er centrala of 
             if ((stare_centrala && bit_secunda) || !stare_centrala) { 
    
                lcd_iesiri[_lcd_C] = _nefolosit;
                Set_LED(_led_C, _er_culoare_LED_C);}}
             else {
                   if (schimbare_stare_C) {
                      if (stare_centrala_noua) {
                          if (bit_secunda) {lcd_iesiri[_lcd_C] = _activ; Set_LED(_led_C, _on_culoare_LED_C);} else {lcd_iesiri[_lcd_C] = _vid; Set_LED(_led_C, _off_culoare_LED_C);}}//clipeste la pornire
                          else {
                                if (bit_secunda) {lcd_iesiri[_lcd_C] = _inactiv; Set_LED(_led_C, _by_culoare_LED_C);} else {lcd_iesiri[_lcd_C] = _vid; Set_LED(_led_C, _off_culoare_LED_C);}}}  // clipeste la oprire
                      else {
                            if (stare_centrala) { 
                               //On C
                               lcd_iesiri[_lcd_C] = _activ; 
                               Set_LED(_led_C, _on_culoare_LED_C); 
                               bitClear(byte_ies_rel, _ies_C);} 
                               else {
                                     //Off C
                                     lcd_iesiri[_lcd_C] = _inactiv; 
                                     Set_LED(_led_C, _by_culoare_LED_C);}}}}

 //stare iesire BE R1 R2
 
 if (on_ies_RE) {
    if (bitRead(byte_intrari, _int_BE)) {
       //on BE
       lcd_iesiri[_lcd_BE] = _activ; 
       Set_LED(_led_BE, _on_culoare_LED_R); 
       bitClear(byte_ies_rel, _ies_BE);} 
       else {
             if (nivel[_P1] == _gol && !bitRead(byte_erori_senzor,_P1)) {
                //On R1
                lcd_iesiri[_lcd_R1] = _activ; 
                Set_LED(_led_R1, _on_culoare_LED_R); 
                bitClear(byte_ies_rel, _ies_R1);} 
                else {
                      if (!bitRead(byte_alarme, _alarma_TP)) {
                          // On R2
                          lcd_iesiri[_lcd_R2] = _activ; 
                          Set_LED(_led_R2, _on_culoare_LED_R); 
                          bitClear(byte_ies_rel, _ies_R2);} 
                          else 
                              Set_LED(_led_R2, _er_culoare_LED_R);}}}        
    else {if (bitRead(byte_intrari, _int_BE)) Set_LED(_led_BE, _by_culoare_LED_R);}

 // Stare iesiri PB PP PE PC
 if (!test_pompe_man && !test_pompe_auto){
  
    if (bitRead(byte_erori_senzor,_B1) || bitRead(byte_erori_senzor,_P0)) {
       // Er PB
       lcd_iesiri[_lcd_PB] = _nefolosit; 
       if (bit_secunda) Set_LED(_led_PB, _er_culoare_LED_P);}
       else {
             if (nivel[_B1] == _gol) {
                // On PB
                lcd_iesiri[_lcd_PB] = _activ; 
                Set_LED(_led_PB, _on_culoare_LED_P);
                bitClear(byte_ies_rel, _ies_PB);}}       
     
    if (bitRead(byte_erori_senzor,_P0) || bitRead(byte_centrala, _vara)) {
       // Er PP PE
       lcd_iesiri[_lcd_PP] = _nefolosit; 
       lcd_iesiri[_lcd_PE] = _nefolosit; 
       lcd_iesiri[_lcd_PC] = _nefolosit;
       if (bitRead(byte_intrari, _int_PP) && bit_secunda) Set_LED(_led_PP, _er_culoare_LED_P);
       if (bitRead(byte_intrari, _int_PE) && bit_secunda) Set_LED(_led_PE, _er_culoare_LED_P);}
       else {
             if (bitRead(byte_intrari, _int_PP)) {
                if (on_temp_PP){
                   // On PP
                   lcd_iesiri[_lcd_PP] = _activ; 
                   Set_LED(_led_PP, _on_culoare_LED_P);
                   bitClear(byte_ies_rel, _ies_PP);}
                   //By PP 
                   else Set_LED(_led_PE, _by_culoare_LED_P);} 

             if (bitRead(byte_intrari, _int_PE)) {
                if (on_temp_PE) {
                   //On PE
                   lcd_iesiri[_lcd_PE] = _activ; //PE
                   Set_LED(_led_PE, _on_culoare_LED_P);
                   bitClear(byte_ies_rel, _ies_PE); }
                   //By PE
                   else Set_LED(_led_PE, _by_culoare_LED_P);}}}
    else {         
          if (bit_secunda) {
             //On PB PP PE PC
             lcd_iesiri[_lcd_PB] = _activ;
             lcd_iesiri[_lcd_PP] = _activ;
             lcd_iesiri[_lcd_PE] = _activ;
             lcd_iesiri[_lcd_PC] = _activ;
             Set_LED(_led_PB, _on_culoare_LED_P);
             Set_LED(_led_PP, _on_culoare_LED_P);
             Set_LED(_led_PE, _on_culoare_LED_P);
             Set_LED(_led_R1, _on_culoare_LED_R);
             Set_LED(_led_PC, _on_culoare_LED_P);}
           else {
            Set_LED(_led_PB, _off_culoare_LED_P);
            Set_LED(_led_PP, _off_culoare_LED_P);
            Set_LED(_led_PE, _off_culoare_LED_P);
            Set_LED(_led_PC, _off_culoare_LED_P);
           }  
           
          bitClear(byte_ies_rel, _ies_PB);
          bitClear(byte_ies_rel, _ies_PP);
          bitClear(byte_ies_rel, _ies_PE);
          bitClear(byte_ies_rel, _ies_PC);}

if (bit_secunda) lcd_iesiri[_lcd_WF] = _wifi;
if (bit_secunda) lcd_iesiri[_lcd_WF-1] = _gol;
if (bit_1) lcd_iesiri[_lcd_WF+1] = _plin;
}



void afisare_temperaturi_lcd ()
{  
 for (byte i = 0; i < 6; i++) {
     if (nr_erori_senzor[i] >= set_nr_erori) { 
        strcpy(buffer_temp[i], "Er.");  //daca sunt erori salveaza mesajul Er.!
        if (!bitRead(byte_erori_senzor, i)) {bitSet(byte_erori_senzor, i);}} //inregistreaza eroarea senzor
        else {
              //byte aa = 10;//byte(temp_senzor[i]);
              sprintf(buffer_temp[i], "%02d\xDF", byte(temp_senzor[i]));} //pregateste valoarea temp pt LCD
           //   bitClear(byte_erori_senzor, i);   //sterge eroarea senzor   
       if (!bitRead(byte_erori_senzor, i)) buffer_temp[i][_Nv] = buffer_nivel[i]; else buffer_temp[i][_Nv] = _nefolosit;       
     if (strcmp(buffer_temp[i], buffer_temp_nou[i]) != 0) {
         strcpy(buffer_temp_nou[i], buffer_temp[i]);
         switch (i) { 
                    case 0: lcd.setCursor(11, 0); break;
                    case 1: lcd.setCursor(11, 1); break;
                    case 2: lcd.setCursor(16, 0); break;
                    case 3: lcd.setCursor(16, 1); break;
                    case 4: lcd.setCursor(16, 2); break;
                    case 5: lcd.setCursor(16, 3); break;}
       
        //buffer_temp[i][_Nv+1] = '\0';
        for (int ii = 0; ii < 4; ii++) {
        lcd.print(buffer_temp[i][ii]);}}}
}



void calcul_nivel()
{
 if (!bitRead(byte_erori_senzor, _B0)){
    if (temp_senzor[_B0] < set_temp_B0) {nivel[_B0] = _gol; on_temp_B0 = _off; if (!bitRead(byte_alarme, _alarma_B0)) {bitSet(byte_alarme, _alarma_B0); inregistrare_memorie(_mem_alarme, _alarma_B0);}} 
    if (temp_senzor[_B0] > set_temp_B0 + set_hist_temp_B0) {nivel[_B0] = _plin; on_temp_B0 = _on; bitClear(byte_alarme, _alarma_B0);}
    buffer_nivel[_B0] = nivel[_B0];
    if (bitRead(byte_alarme, _alarma_B0) && !bit_secunda)  buffer_nivel[_B0] = _vid;} //clipeste daca alarma_B0 = ON 

 if (!bitRead(byte_erori_senzor, _B1)){
    if (stare_centrala) nivel[_B1] = _gol; /// incalzire boiler la pornirea centralei 
    if (temp_senzor[_B1] < set_temp_B1 - set_hist_temp_B1) nivel[_B1] = _gol;
    if (temp_senzor[_B1] > set_temp_B1) nivel[_B1] = _plin;
    buffer_nivel[_B1] = nivel[_B1];     
    if (bitSet(byte_ies_rel, _ies_BE) && bitSet(byte_intrari, _int_SC)) {if(bit_secunda) buffer_temp[_B1][_Nv] = _plin; else buffer_temp[_B1][_Nv] = _electric;}} 

 if (!bitRead(byte_erori_senzor, _P0)) {
    if (temp_senzor[_P0] < set_temp_Pu - set_hist_temp_Pu) {nivel[_P0] = _gol; on_temp_PP = _on; on_temp_PE = _off;} 
    if (temp_senzor[_P0] >= set_temp_Pu)                   {nivel[_P0] = _plin; on_temp_PE = _on;}
    if (temp_senzor[_P0] < set_temp_PP) on_temp_PP = _off;
     
    if (on_temp_PE) timp_alarma_PE = millis(); 
    if (on_temp_PP) timp_alarma_PP = millis();
    if (millis() - timp_alarma_PP > _timp_alarma_PP && !bitRead(byte_alarme, _alarma_PP)) {bitSet(byte_alarme, _alarma_PP); inregistrare_memorie(_mem_alarme, _alarma_PP);}  
    if (millis() - timp_alarma_PE > _timp_alarma_PE && !bitRead(byte_alarme, _alarma_PE)) {bitSet(byte_alarme, _alarma_PE); inregistrare_memorie(_mem_alarme, _alarma_PE);}
    //if (stare_centrala) {bitClear(byte_alarme, _alarma_PP); bitClear(byte_alarme, _alarma_PP);}
    buffer_nivel[_P0] = nivel[_P0];
    if (bitRead(byte_alarme, _alarma_PP) && !bit_secunda)  buffer_nivel[_P0] = _vid;} //clipeste daca alarma_Pu = ON    
    
 if (!bitRead(byte_erori_senzor, _P1)) {
    if (temp_senzor[_P1] < set_temp_Pu - set_hist_temp_Pu) nivel[_P1] = _gol; 
    if (temp_senzor[_P1] >= set_temp_Pu)                   nivel[_P1] = _plin; 

    buffer_nivel[_P1] = nivel[_P1];
    if (bitSet(byte_ies_rel, _ies_R1) && bitSet(byte_intrari, _int_SC)) {if(bit_secunda) buffer_temp[_P1][_Nv] = _plin; else buffer_temp[_P1][_Nv] = _electric;}}

 if (!bitRead(byte_erori_senzor, _P2)){
    if (temp_senzor[_P2] < set_temp_Pu - set_hist_temp_Pu) nivel[_P2] = _gol; 
    if (temp_senzor[_P2] >= set_temp_Pu)                   nivel[_P2] = _plin; 
    buffer_nivel[_P2] = nivel[_P2];}

 if (!bitRead(byte_erori_senzor, _P3)){
    if (temp_senzor[_P3] < set_temp_Pu - set_hist_temp_Pu) nivel[_P3] = _gol; 
    if (temp_senzor[_P3] >= set_temp_Pu)                   nivel[_P3] = _plin; 

    buffer_nivel[_P3] = nivel[_P3];
    if (bitSet(byte_ies_rel, _ies_R2) && bitSet(byte_intrari, _int_SC)) {if(bit_secunda) buffer_temp[_P3][_Nv] = _plin; else buffer_temp[_P3][_Nv] = _electric;}} 

 bitClear(byte_alarme, _alarma_TP);
 for (byte i = _P0; i <= _P3; i++) {if (temp_senzor[i] >= set_temp_al_Pu) bitSet(byte_alarme, _alarma_TP);}      
}     


//void citire_senzori()
//{
 //if (millis() - interval_citire_senz > _interval_citire_senz && !conversionInProgress) {//interval citire senzori 
 //   interval_citire_senz = millis();
 //   lastReadTime = millis();
 //   sensors.requestTemperatures();
 //   conversionInProgress = true;}
   
// if (millis() - lastReadTime >= conversionDelay && conversionInProgress) { //citire senzori 
 //   conversionInProgress = false;
 //   senzori_ok = _on;
 //   for (byte i = 0; i < _nr_senzori; i++) {
  //      float temp_citita = sensors.getTempC(sensorsAddresses[i]); // citeste temp senzor
  //      if (temp_citita < _temp_eroare) 
  //         {if (nr_erori_senzor[i] <= nr_erori_senzor) nr_erori_senzor[i]++;} // calculeaza nr de erori
  //          else {nr_erori_senzor[i] = 0; temp_senzor[i] = temp_citita;}}} // salveaza valoarea temp                 
//}
    

void update_EEPROM ()
{ 
 EEPROM.update(address_set_temp_Pu, set_temp_Pu);
 EEPROM.update(address_aj_temp_B0, aj_temp_senzor[_B0]);
 EEPROM.update(address_aj_temp_B1, aj_temp_senzor[_B1]);
 EEPROM.update(address_aj_temp_P0, aj_temp_senzor[_P0]);
 EEPROM.update(address_aj_temp_P1, aj_temp_senzor[_P1]);
 EEPROM.update(address_aj_temp_P2, aj_temp_senzor[_P2]);
 EEPROM.update(address_aj_temp_P3, aj_temp_senzor[_P3]);
 EEPROM.update(address_set_temp_B0, set_temp_B0);
 EEPROM.update(address_set_temp_B1, set_temp_B1);
 EEPROM.update(address_set_hist_temp_Pu, set_hist_temp_Pu);
 EEPROM.update(address_set_hist_temp_B0, set_hist_temp_B0);
 EEPROM.update(address_set_hist_temp_B1, set_hist_temp_B1);
 EEPROM.update(address_set_temp_PP,  set_temp_PP);
 EEPROM.update(address_set_nr_erori, set_nr_erori);
 EEPROM.update(address_set_timp_iluminare_lcd, set_timp_iluminare_lcd);
 EEPROM.update(address_byte_centrala, byte_centrala);
 EEPROM.update(address_set_temp_al_Pu, set_temp_al_Pu);
 EEPROM.update(address_set_ora_1_Pr, set_ora_1_Pr);
 EEPROM.update(address_set_ora_2_Pr, set_ora_2_Pr);
 EEPROM.update(address_set_ora_1_RE, set_ora_1_RE);
 EEPROM.update(address_set_ora_2_RE, set_ora_2_RE);
}


void stari_butoane ()
{
 timp_iluminare_lcd = millis();
 interval_citire_senz = millis();
 if (!on_noBacklight) lcd.backlight(); //activeaza functia butonului daca lcd.backlight(); este activ
 on_noBacklight = _on;
}


void citire_butoane()
{
 if (millis() - timp_iluminare_lcd > (long(set_timp_iluminare_lcd) * 1000)) { // calcul timp iluminare
    if (on_noBacklight) {
       on_noBacklight = LOW;
       //lcd.clear();
       lcd.noBacklight();
       mod = _meniu_0;
       setari_noi = _on;}}

 if (millis() - timp_meniu_3 > _timp_meniu_3 && mod == _meniu_0) { //intrare in mod 3
    mod = _meniu_3;}
    //lcd.clear();}

 if (!digitalRead(BUTTON_MODE)){
    delay(50);
    if (!digitalRead(BUTTON_MODE) && stop_b_mode) { 
        stop_b_mode = LOW;
        if (on_noBacklight) mod++;
        stari_butoane();
        nr_memorie = nr_info_memorie;
        citire_memorie(nr_memorie);}}
    else {
          stop_b_mode = HIGH;
          timp_meniu_3 = millis();}

 b_plus = LOW;
 if (!digitalRead(BUTTON_PLUS)){
     delay(50);
    if (!digitalRead(BUTTON_PLUS) && stop_b_plus) {
       stop_b_plus = LOW;
       if (on_noBacklight) b_plus = HIGH;
       stari_butoane();}}
    else {stop_b_plus = HIGH;}

 b_minus = LOW;
 if (!digitalRead(BUTTON_MINUS)){
   delay(50);
if (!digitalRead(BUTTON_MINUS) && stop_b_minus) {
       stop_b_minus = LOW;
       if (on_noBacklight) b_minus = HIGH;
       stari_butoane();}}
    else {stop_b_minus = HIGH;}
}


void calcul_butoane()
{
 buffer_info[0] = '\0';  // Golește buffer-ul  
 switch (mod)
 {
  case 0: test_pompe_man = _off;
          if (b_plus  == _b_on) {
             if (stare_centrala_noua == _off) bitClear(byte_centrala, _mod_auto);
                else {if bitRead(byte_centrala, _mod_auto) bitClear(byte_centrala, _mod_auto); else bitSet(byte_centrala, _mod_auto);}  
              
             stare_centrala_noua = _on; 
             setari_noi = _on;}
     
          if (b_minus == _b_on) {
             if (stare_centrala_noua == _on) bitClear(byte_centrala, _mod_auto);
                else {if bitRead(byte_centrala, _mod_auto) bitClear(byte_centrala, _mod_auto); else bitSet(byte_centrala, _mod_auto);}
                stare_centrala_noua = _off; 
                //if (bitRead(byte_alarme, _alarma_Pu) == 1) bit_stare_centrala = _off; //oprire de urgenta
                setari_noi = _on;}
             
          if (set_ora_1_Pr == set_ora_2_Pr) bitClear(byte_centrala, _mod_prog); else bitSet(byte_centrala, _mod_prog); // Selectie centrala Auto/Prog    
          strcat(buffer_info, "Centrala: ");   
          if (bitRead(byte_centrala, _vara)) strcat(buffer_info, "VARA");
             else {if (bitRead(byte_centrala, _eroare)) strcat(buffer_info, "Er.");
                   else {if (!bitRead(byte_centrala, _mod_auto)) strcat(buffer_info, "M "); else {if (bitRead(byte_centrala, _mod_prog)) strcat(buffer_info, "P "); else strcat(buffer_info, "A ");} 
                          if (schimbare_stare_C && !bit_secunda) strcat(buffer_info, "   "); else {if (stare_centrala_noua == _on) strcat(buffer_info, "ON "); else strcat(buffer_info, "OFF");}}}          
          break;    
  case 1: if (b_plus  == _b_on) {if (nr_memorie < _nr_memorie_max) nr_memorie++; else nr_memorie = 0;}
          if (b_minus == _b_on) {if (nr_memorie > 0) nr_memorie--; else nr_memorie = _nr_memorie_max;}
          if ((b_plus  == _b_on) || (b_minus == _b_on)) citire_memorie(nr_memorie);       
          bitClear(byte_alarme, _alarma_t1); 
          bitClear(byte_alarme, _alarma_t2);  
          if (nr_memorie > nr_info_memorie) nr_m = _nr_memorie_max + nr_info_memorie - nr_memorie + 2; else nr_m = nr_info_memorie - nr_memorie + 1;
          
          info_m_1 = _mem_centrala;
          //lcd.setCursor(0, 2); 
          strcat(buffer_info, "Info: ");
          if (info_m_1 == _mem_centrala) {
             strcat(buffer_info, "C "); 
             if (bitRead(info_m_2, _eroare)) strcat(buffer_info, "E"); 
                else if (bitRead(info_m_2, _mod_prog)) strcat(buffer_info, "P");
                        else if (bitRead(info_m_2, _mod_auto)) strcat(buffer_info, "A"); else strcat(buffer_info, "M");
             if (bitRead(info_m_2, _stare_C)) {strcat(buffer_info, " ON");} else {strcat(buffer_info, " OFF");}}
                         
          if (info_m_1 == _mem_alarme) {
             strcat(buffer_info, "Al "); 
             switch (info_m_2){
                    case _alarma_B0: strcat(buffer_info, "B0"); break;
                    case _alarma_PP: strcat(buffer_info, "PP"); break;
                    case _alarma_PE: strcat(buffer_info, "PP"); break;
                    case _alarma_Pu: strcat(buffer_info, "Pu"); break;
                    case _alarma_t1: strcat(buffer_info, "t1"); break;
                    case _alarma_t2: strcat(buffer_info, "t2"); break; 
                    case _alarma_TP: strcat(buffer_info, "TP"); break;}}
              
          if (info_m_1 == _mem_erori) {
             strcat(buffer_info, "Er "); 
             switch (info_m_2){
                    case _B0: strcat(buffer_info, "B0"); break;
                    case _B1: strcat(buffer_info, "B1"); break;
                    case _P0: strcat(buffer_info, "P0"); break;
                    case _P1: strcat(buffer_info, "P1"); break;
                    case _P2: strcat(buffer_info, "P2"); break;
                    case _P3: strcat(buffer_info, "P3"); break;}}               
          break;
  case 2: strcat(buffer_info, "Meniu? 1- 2+");
          if (b_plus  == _b_on) {mod = _meniu_2;}
          if (b_minus == _b_on) {mod = _meniu_1;}
          break;
  case 3: mod = _meniu_0;
          break;
 case 10: if (b_plus  == _b_on) {if (set_ora_2_Pr <= _ora_2_Pr_max) set_ora_2_Pr++; if (set_ora_2_Pr > _ora_2_Pr_max) set_ora_2_Pr = set_ora_1_Pr;}
          if (b_minus == _b_on) {if (set_ora_1_Pr <= _ora_1_Pr_min) set_ora_1_Pr++; if (set_ora_1_Pr > set_ora_2_Pr) set_ora_1_Pr = _ora_2_Pr_max;}
          sprintf(buffer_info, "Prog C: %02dh%02dh", set_ora_1_Pr, set_ora_2_Pr);  
          break; 
 case 11: if (b_plus  == _b_on) {if (set_ora_2_RE <= _ora_2_RE_max) set_ora_2_RE++; if (set_ora_2_RE > _ora_2_RE_max) set_ora_2_RE = _ora_2_RE_min;}
          if (b_minus == _b_on) {if (set_ora_1_RE <= _ora_1_RE_max) set_ora_1_RE++; if (set_ora_1_RE > _ora_2_RE_max) set_ora_1_RE = _ora_2_RE_min;}
          sprintf(buffer_info, "On RE: %02dh%02dh", set_ora_1_RE, set_ora_2_RE); 
          break;          
 case 12: if (b_plus  == _b_on) {if (set_temp_Pu < _set_temp_Pu_max) set_temp_Pu++;}
          if (b_minus == _b_on) {if (set_temp_Pu > _set_temp_Pu_min) set_temp_Pu--;}
          //if (set_temp_B1 > set_temp_Pu - 5) set_temp_B1 = set_temp_Pu - 5;
          sprintf(buffer_info, "Puf: Temp %02d\xDFC", set_temp_Pu); 
          break;          
 case 13: if (b_plus  == _b_on) {if (set_hist_temp_Pu < _set_hist_temp_Pu_max) set_hist_temp_Pu++;}
          if (b_minus == _b_on) {if (set_hist_temp_Pu > _set_hist_temp_Pu_min) set_hist_temp_Pu--;}
          sprintf(buffer_info, "Puf.: Hist %02d\xDF\C", set_hist_temp_Pu); 
          break;
 case 14: if (b_plus  == _b_on) {if (set_temp_PP <  set_temp_Pu - set_hist_temp_Pu) set_temp_PP++;}
          if (b_minus == _b_on) {if (set_temp_PP > _set_temp_PP_min) set_temp_PP--;}
          sprintf(buffer_info, "PP: Temp %02d\xDF\C", set_temp_PP); 
          break;
 case 15: if (b_plus  == _b_on) {if (set_temp_B0 < set_temp_Pu - set_hist_temp_Pu)  set_temp_B0++;}
          if (b_minus == _b_on) {if (set_temp_B0 > _set_temp_B_min) set_temp_B0--;}
        
          sprintf(buffer_info, "B0: T %02d\xDF\C", set_temp_B0); 
          break;
 case 16: if (b_plus  == _b_on) {if (set_hist_temp_B0 < _set_hist_temp_B_max) set_hist_temp_B0++;}
          if (b_minus == _b_on) {if (set_hist_temp_B0 > _set_hist_temp_B_min) set_hist_temp_B0--;}
          sprintf(buffer_info, "H B0: %02d\xDF", set_hist_temp_B0); 
          break;
 case 17: if (b_plus  == _b_on) {if (set_temp_B1 < set_temp_Pu - set_hist_temp_Pu) set_temp_B1++;}
          if (b_minus == _b_on) {if (set_temp_B1 > _set_temp_B_min) set_temp_B1--;}
          sprintf(buffer_info, "T B1: %02d\xDF", set_temp_B1); 
          break;            
 case 18: if (b_plus  == _b_on) {if (set_hist_temp_B1 < _set_hist_temp_B_max) set_hist_temp_B1++;}
          if (b_minus == _b_on) {if (set_hist_temp_B1 > _set_hist_temp_B_min) set_hist_temp_B1--;}
          sprintf(buffer_info, "H B1: %02d\xDF", set_hist_temp_B1);
          break;            
 case 19: mod = _meniu_0; setari_noi = _on;
          break;
    
 case 30: if (b_plus == _b_on)  {if (set_timp_iluminare_lcd < _set_timp_iluminare_lcd_max) set_timp_iluminare_lcd = set_timp_iluminare_lcd + 10;}
          if (b_minus == _b_on) {if (set_timp_iluminare_lcd > _set_timp_iluminare_lcd_min) set_timp_iluminare_lcd = set_timp_iluminare_lcd - 10;}
          sprintf(buffer_info, "Disp: timp %02ds", set_timp_iluminare_lcd);
          break; 
 case 31: if (b_plus  == _b_on) {if (set_temp_al_Pu < _temp_al_Pu_max) set_temp_al_Pu++;}
          if (b_minus == _b_on) {if (set_temp_al_Pu > _temp_al_Pu_min) set_temp_al_Pu--;}
          sprintf(buffer_info, "Puf: T Al %02d\xDF\C", set_temp_al_Pu); 
          break; 
 case 32: if (b_plus  == _b_on) {if (set_nr_erori < _nr_erori_max) set_nr_erori++;}
          if (b_minus == _b_on) {if (set_nr_erori > _nr_erori_min) set_nr_erori--;}
          sprintf(buffer_info, "Senz: Nr er %02d", set_nr_erori);    
          break;                        
 case 33: if (b_plus == _b_on) test_pompe_man = _on;
          if (b_minus == _b_on) test_pompe_man = _off;
          strcat(buffer_info, "Test pompe: "); if (test_pompe_man) strcat(buffer_info, "ON"); else strcat(buffer_info, "OFF");
          break;
 case 34: if (b_plus  == _b_on) bitSet(byte_centrala, _vara);
          if (b_minus == _b_on) bitClear(byte_centrala, _vara);
          if (bitRead(byte_centrala, _vara)) strcat(buffer_info, "Mod C: VARA"); else strcat(buffer_info, "Mod C: IARNA");
          break;          
 case 35: mod = _meniu_0; setari_noi = _on;
          break;
             
 case 50: if (b_plus == _b_on)  if (an_RTC < _an_max) {an_RTC++; Clock.setYear(an_RTC);}
          if (b_minus == _b_on) if (an_RTC > _an_min) {an_RTC--; Clock.setYear(an_RTC);}
          strcat(buffer_info, "Set an");
          break;             
 case 51: if (b_plus == _b_on)  if (luna_RTC < _luna_max) {luna_RTC++; Clock.setMonth(luna_RTC);}
          if (b_minus == _b_on) if (luna_RTC > _luna_min) {luna_RTC--; Clock.setMonth(luna_RTC);}
          strcat(buffer_info, "Set luna");
          break;            
 case 52: if (anbisect == 0 & luna_RTC == 2 ) aj_ziua_max = 1; else aj_ziua_max = 0;
          if (b_plus == _b_on)  if (ziua_RTC < ziua_max[luna_RTC - 1] + aj_ziua_max)  {ziua_RTC++; Clock.setDate(ziua_RTC);}
          if (b_minus == _b_on) if (ziua_RTC > _ziua_min)                           {ziua_RTC--; Clock.setDate(ziua_RTC);}
          strcat(buffer_info, "Set ziua");
          break;            
 case 53: if (b_plus == _b_on)  if (ora_RTC < _ora_max) {ora_RTC++; Clock.setHour(ora_RTC);}
          if (b_minus == _b_on) if (ora_RTC > _ora_min) {ora_RTC--; Clock.setHour(ora_RTC);}
          strcat(buffer_info, "Set ora");
          break;             
 case 54: if (b_plus == _b_on)  if (min_RTC < _min_max) {min_RTC++; sec_RTC = 0; Clock.setMinute(min_RTC); Clock.setSecond(0);}
          if (b_minus == _b_on) if (min_RTC > _min_min) {min_RTC--; sec_RTC = 0; Clock.setMinute(min_RTC); Clock.setSecond(0);}
          strcat(buffer_info, "Set min");
          break; 
 case 55: strcat(buffer_info, "B0=");
          aj_temp_senzor[_B0] = set_aj_temp_senzor(aj_temp_senzor[_B0], temp_senzor[_B0]);
          break;
 case 56: strcat(buffer_info, "B1=");
          aj_temp_senzor[_B1] = set_aj_temp_senzor(aj_temp_senzor[_B1], temp_senzor[_B1]);
          break;            
 case 57: strcat(buffer_info, "P0=");
          aj_temp_senzor[_P0] = set_aj_temp_senzor(aj_temp_senzor[_P0], temp_senzor[_P0]);
          break;             
 case 58: strcat(buffer_info, "P1=");
          aj_temp_senzor[_P1] = set_aj_temp_senzor(aj_temp_senzor[_P1], temp_senzor[_P1]);
          break;            
 case 59: strcat(buffer_info, "P2=");
          aj_temp_senzor[_P2] = set_aj_temp_senzor(aj_temp_senzor[_P2], temp_senzor[_P2]);
          break;            
 case 60: strcat(buffer_info, "P3=");
          aj_temp_senzor[_P3] = set_aj_temp_senzor(aj_temp_senzor[_P3], temp_senzor[_P3]);
          break;
 case 61: mod = _meniu_0; setari_noi = _on;
          break;
}}


void loop(void)
{ 
TCNT1 = 0; 
//TIMSK1 = _BV(OCIE1A);

//TCCR1A = 0;                  // Modul Normal (biturile COM1A1 și COM1A0 = 0)
//TCCR1B = _BV(WGM12);         // Modul CTC (Clear Timer on Compare Match)
//OCR1A = 15624;               // Valoarea de comparație (1 secundă pentru prescaler = 1024)
//TIMSK1 = _BV(OCIE1A);        // Activarea întreruperii pe comparație (OCIE1A)
//TCNT1 = 0;                   // Resetează contorul la 0
//TCCR1B |= _BV(CS12) | _BV(CS10); // Prescaler = 1024



 if (millis() - timp_calcul_bit_secunda > 500) 
    {timp_calcul_bit_secunda = millis();// bit_secunda = ! bit_secunda; on_afisare = _on;
    on_afisare = _on;
    nn++;
    //if (bit_secunda) nn++;
    //if (nn >= 3) nn = 0;
    //if((nn <= 0) && bit_secunda) bit_1 = HIGH; else bit_1 = LOW;
     if (bitRead(nn, 0)) bit_secunda = _on; else bit_secunda = _off;
     bit_1 = LOW;
     //byte ff = 0b11111110 & nn;
     //ff = ff / 2;
     //ff = ff % 2;
     //Serial.println(ff);
     if (bitRead(nn, 0) && (nn/2)%3 == 0) bit_1 = HIGH;}
    
    
 citire_butoane();
 calcul_butoane();
 //bitClear(byte_centrala, _vara); 
      

 if (on_afisare){ 
    on_afisare = _off;
    on_centrala_auto = _off;
    on_ies_RE  = _off;
    if (set_ora_1_Pr <= ora_RTC && set_ora_2_Pr >= ora_RTC) on_centrala_auto = _on;   //calcul on centrala auto/program
    if (set_ora_1_RE >= ora_RTC && set_ora_2_RE <= ora_RTC) on_ies_RE  = _on;        // calcul on Rezistente electrice RE 
    if (setari_noi) {setari_noi = _off; update_EEPROM();} //update EEPROM
    citire_RTC(); 
    //calcul_test_pompe_auto();
    //citire_senzori();
         
    calcul_stare_centrala();
    calcul_elemente(); 
  
    calcul_nivel();  
    afisare_temperaturi_lcd();
    
    if (mod != 1) {
       sprintf(buffer_ceas, "%02d:%02d %02d\xDF", ora_RTC, min_RTC, temp_RTC);
       if(!bit_secunda) buffer_ceas[2] = ' '; //clipire :
       if(!bit_secunda && mod == 53) {buffer_ceas[0] = ' '; buffer_ceas[1] = ' ';}  //clipire set ora
       if(!bit_secunda && mod == 54) {buffer_ceas[3] = ' '; buffer_ceas[4] = ' ';}  //clipire set min 
       sprintf(buffer_data, "%02d-%02d-%02d", ziua_RTC, luna_RTC, an_RTC);     
       if(!bit_secunda && mod == 50) {buffer_data[6] = ' '; buffer_data[7] = ' ';}  //clipire set an
       if(!bit_secunda && mod == 51) {buffer_data[3] = ' '; buffer_data[4] = ' ';}  //clipire set luna
       if(!bit_secunda && mod == 52) {buffer_data[0] = ' '; buffer_data[1] = ' ';}} //clipire set ziua       
       else {
             sprintf(buffer_ceas, "%02d.%02d:%02d", nr_m, ora_m, min_m);  //afiseaza ceas memorie
             sprintf(buffer_data, "%02d-%02d-%02d", ziua_m, luna_m, an_m);} //afiseaza data memorie
    for (byte i = strlen(buffer_ceas); i < sizeof(buffer_ceas) - 1; i++) {strcat(buffer_ceas, " ");} // completeaza spatii goale pentru a nu intefera mesajele intre ele;    
    if (strcmp(buffer_ceas, buffer_ceas_nou) != 0) {
       strcpy(buffer_ceas_nou, buffer_ceas);
       lcd.setCursor(0, 0); 
       lcd.print(buffer_ceas);}  // afiseaza ceasul
         
    for (byte i = strlen(buffer_data); i < sizeof(buffer_data) - 1; i++) {strcat(buffer_data, " ");} // completeaza spatii goale pentru a nu intefera mesajele intre ele;   
    if (strcmp(buffer_data, buffer_data_nou) != 0) {
       strcpy(buffer_data_nou, buffer_data);
       lcd.setCursor(0, 1); 
       lcd.print(buffer_data);}  // afiseaza data        
    
    for (byte i = strlen(buffer_info); i < sizeof(buffer_info) - 1; i++) {strcat(buffer_info, " ");} // completeaza spatii goale pentru a nu intefera mesajele intre ele;   
    if (strcmp(buffer_info, buffer_info_nou) != 0) {
       strcpy(buffer_info_nou, buffer_info);
       lcd.setCursor(0, 2);
       lcd.print(buffer_info);}  // afiseaza data 
         
    if (strcmp(lcd_iesiri, lcd_iesiri_nou) != 0) {
       strcpy(lcd_iesiri_nou, lcd_iesiri);
       lcd.setCursor(0, 3);       
       lcd.print(lcd_iesiri);}   // Afiseaza iesirile
       
    if (ledChanged) {FastLED.show(); ledChanged = false;}} // Afiseaza LED doar la schimbare
 
    //if (byte_ies_rel != byte_ies_rel_nou) {byte_ies_rel =  byte_ies_rel_nou; PCF_01.write8(byte_ies_rel);}} //activeaza iesirile relee                       

}


byte set_aj_temp_senzor (byte aj_temp, float af_temp_aj)
{
 if (b_plus == _b_on)  if (aj_temp < _max_aj_temp * 2) {aj_temp = aj_temp + 25;}// if(aj_temp_B1 > 100) aj_temp_B1 = 100;}
 if (b_minus == _b_on) if (aj_temp > 0)   {aj_temp = aj_temp - 25;}
 char aj_temp_str[6];
 char af_temp_str[6];
 dtostrf((float(aj_temp - _max_aj_temp)/100), 5, 2, aj_temp_str);
 dtostrf(af_temp_aj, 5, 2, af_temp_str);
 sprintf(buffer_info + strlen(buffer_info), "%s\xDF%s\xDF", aj_temp_str, af_temp_str);
 return aj_temp;
}