/* Hello OOO Centr! */
/* 
   кнопки по УМОЛЧАНИЮ свойство  противДРЕБЕЗГА (Bounce чекбокс на кнопке),
   иначе использовать программную задержку или соотвествующую библиотеку
   см  https://wokwi.com/projects/375109880860902401
   
   чтение запись в EEPROM 
   cм  https://wokwi.com/projects/362618064037289985

bool      1 байт    0 или 1             / true или  false 
char      1 байт    -128… 127           / Символ (код символа) из таблицы ASCII
int8_t    1 байт    -128… 127           / Целые числа
uint8_t   1 байт    0… 255              / Целые числа
int16_t   2 байт    -32 768… 32 767     / Целые числа
uint16_t  2 байт    0… 65 535           / Целые числа
int32_t   4 байт    -2 147 483 648 …  2 147 483 647     / Целые числа
uint32_t  4 байт    0 … 4 294 967 295   / Целые числа
float     4 байт    -3.4E+38… 3.4E+38   / Числа с плавающей точкой, точность: 6-7 знаков

https://arduino.ru/forum/programmirovanie/zapis-i-chtenie-eeprom-peremennykh-tipa-float-unsigned-long-long-unsigned-int
*/

#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);

class button {
  public:
    button (byte pin) {
      _pin = pin;
      pinMode(_pin, INPUT_PULLUP);
    }
    bool click() {
      bool btnState = digitalRead(_pin);
      if (!btnState && !_flag && millis() - _tmr >= 100) {
        _flag = true;
        _tmr = millis();
        return true;
      }
      if (!btnState && _flag && millis() - _tmr >= 500) {
        _tmr = millis ();
        return true;
      }
      if (btnState && _flag) {
        _flag = false;
        _tmr = millis();
      }
      return false;
    }
  private:
    byte _pin;
    uint32_t _tmr;
    bool _flag;
};

// чтение
float EEPROM_float_read(int addr) {    
  byte raw[4];
  for(byte i = 0; i < 4; i++) raw[i] = EEPROM.read(addr+i);
  float &num = (float&)raw;
  return num;
}
// чтение
unsigned long EEPROM_ulong_read(int addr) {    
  byte raw[4];
  for(byte i = 0; i < 4; i++) raw[i] = EEPROM.read(addr+i);
  unsigned long &num = (unsigned long&)raw;
  return num;
}

// запись
void EEPROM_float_write(int addr, float num) {
  byte raw[4];
  (float&)raw = num;
  for(byte i = 0; i < 4; i++) EEPROM.write(addr+i, raw[i]);
}
// запись
void EEPROM_ulong_write(int addr, unsigned long num) {
  byte raw[4];
  (unsigned long&)raw = num;
  for(byte i = 0; i < 4; i++) EEPROM.write(addr+i, raw[i]);
}

// Массивы символов для прогресс-бара
byte p20[8] = {
  B10000,  B10000,  B10000,  B10000,  B10000,  B10000,  B10000,  B10000,};
byte p40[8] = {
  B11000,  B11000,  B11000,  B11000,  B11000,  B11000,  B11000,  B11000,};
byte p60[8] = {
  B11100,  B11100,  B11100,  B11100,  B11100,  B11100,  B11100,  B11100,};
byte p80[8] = {
  B11110,  B11110,  B11110,  B11110,  B11110,  B11110,  B11110,  B11110,};
byte p100[8] = {
  B11111,  B11111,  B11111,  B11111,  B11111,  B11111,  B11111,  B11111,};

#define _but_LITR 3          // кнопка имит СЧ    желтая  1 имп / 1 литр
//#define _short_CONFIG 4      // перемычка CONFIG
#define _but_RECEPT 6        // кнопка РЕЦЕПТ     синяя
#define _but_SBROS 7         // кнопка СБРОС      красная
#define _but_PUSK_PAUSE 8    // кнопка ПУСК/ПАУЗА зеленая
#define _rele_EK 12          // реле ЭК
#define _top_lcd 0        // верхняя строка
#define _bot_lcd 1        // нижняя строка

#define _max_MENU 9       // кол-во пунктов в МЕНЮ
// after change menu you must change '_max_MENU' ! 
const String empty_str              = "                ";
const String menu_str               = "----  MENU  ----";
const String menu_str_test_rele     = "1. TEST RELE    ";
const String menu_str_chng_rcpt     = "2. CHANGE RECEPT";
const String menu_str_test_indc     = "3. TEST INDIC   ";
const String menu_str_inp_koeff     = "4. INP KOEFF    ";
const String menu_str_inp_doza      = "5. INP DOZA     ";
const String menu_str_setup_default = "6. SETUP DEFAULT";
const String menu_str_freq_metr     = "7. Freq METR    ";
const String menu_str_test_clock    = "8.Clock hh:mm:ss";
const String menu_str_rating_koef   = "9. RATING KOEF  ";

button b_PUSK(_but_PUSK_PAUSE);  // кнопка ПУСК/ПАУЗА зеленая
button b_SBROS(_but_SBROS);      // кнопка СБРОС      красная
button b_RECEPT(_but_RECEPT);    // кнопка РЕЦЕПТ     синяя
//(2024-09-20)button b_LITR(_but_LITR);        // кнопка имит СЧ    желтая  1 имп / 1 литр
bool b_LITR       = false;  // тек значение датчика
bool b_LITR_prev  = false;  // пред значение датчика

bool mode_INIT  = true;
bool mode_PUSK  = false;
bool stat_but_PUSK  = false;
bool mode_DIAG  = false;
int  cur_MENU  = 0;
int  prv_MENU  = 0;
float koef_CT  = 1.234;     // (мЛ / 1 имп). Значение по умолчанию. В реале читается из EEPROM в setup()
float ust_DOZA = 9999.876;  // (Литр). Значение по умолчанию. В реале читается из EEPROM в setup()
uint32_t kol_IMP = 0;       // кол-во имп-в соотв ust_DOZA
int addr_EEPROM_koef_CT  = 0;
int addr_EEPROM_ust_DOZA = 4;
int addr_EEPROM_kol_IMP  = 8;

uint32_t sec_PUSK = 0; // значение секунд для индикации в режиме PUSK

uint32_t sec ;//= millis() / 1000ul;      // полное количество секунд
int timeHours;// = (sec / 3600ul);        // часы
int timeMins ;//= (sec % 3600ul) / 60ul;  // минуты
int timeSecs ;//= (sec % 3600ul) % 60ul;  // секунды

// just for test array of RECEPTs const, but in release case at EEPROM
const String buf_rcpt("Rc_");
int rcpt_imp[]  = {10, 20, 30, 100, 200, 300, 1000, 2000, 3000, 9999};
int rcpt_litr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int act_rcpt    = 0; // текущий рецепт
int imp_rashod  = 0; // текущее значение счетчика воды ИМПУЛЬСЫ
int litr_rashod = 0; // текущее значение счетчика воды ЛИТРЫ

void lcd_0(bool b_clr, String s_stat, int rcp) {
  if (b_clr){
    lcd.clear();
  }
  lcd.setCursor(0, _top_lcd);      lcd.print(s_stat);
  lcd.setCursor(6, _top_lcd);      lcd.print(buf_rcpt);
  lcd.setCursor(9, _top_lcd);      lcd.print(String(rcp));
//  lcd.setCursor(12, _top_lcd);     lcd.print(String(rcpt_imp[rcp]));
  lcd.setCursor(12, _top_lcd);     lcd.print(String(rcpt_litr[rcp]));
}        

void test_RELE(){
  bool b_test_RELE  = true;
  bool status_RELE  = false;
  lcd.clear();  
  lcd.setCursor(0, _top_lcd);  lcd.print(menu_str_test_rele);
  lcd.setCursor(0, _bot_lcd);  lcd.print("PUSH SBROS   OFF");
  while (b_test_RELE){
    if (b_RECEPT.click()) {
      mode_DIAG = true;
      cur_MENU = 0;
      b_test_RELE  = false;
      digitalWrite(_rele_EK, LOW);
    }
    if (b_SBROS.click()) {
      status_RELE = ! status_RELE;
      digitalWrite(_rele_EK, status_RELE);
      lcd.setCursor(0, _bot_lcd);    
      if (status_RELE){
        lcd.print("PUSH SBROS   ON ");}
      else{
        lcd.print("PUSH SBROS   OFF");}
    }    
    delay(100);
  }
}

void chng_RCPT(){
  bool b_chng_RCPT  = true;
  act_rcpt = 0;
  lcd.clear();   
  lcd.setCursor(0,  _top_lcd);   lcd.print(menu_str_chng_rcpt);
  //lcd.setCursor(0,  _bot_lcd);   lcd.print(empty_str);
  lcd.setCursor(0,  _bot_lcd);   lcd.print(buf_rcpt);
  lcd.setCursor(3,  _bot_lcd);   lcd.print(String(act_rcpt));
//  lcd.setCursor(6,  _bot_lcd);   lcd.print(String(rcpt_imp[act_rcpt]));
  lcd.setCursor(6,  _bot_lcd);   lcd.print(String(rcpt_litr[act_rcpt]));

    while (b_chng_RCPT){
      if (b_RECEPT.click()) {
        lcd.noBlink();
        mode_DIAG = true;
        cur_MENU = 0;
        b_chng_RCPT  = false;
        //koef_CT = atof(bf);
        //EEPROM_float_write(addr_EEPROM_koef_CT, koef_CT);
        //Serial.println(bf);
        //Serial.println(koef_CT, 3);
      }
      if (b_SBROS.click()) { 
        act_rcpt = act_rcpt + 1;
        if (act_rcpt > 9) {
          act_rcpt = 0;
        }
        lcd.setCursor(0,  _bot_lcd);     lcd.print(empty_str);
        lcd.setCursor(0,  _bot_lcd);     lcd.print(buf_rcpt);
        lcd.setCursor(3,  _bot_lcd);     lcd.print(String(act_rcpt));
//      lcd.setCursor(6,  _bot_lcd);   lcd.print(String(rcpt_imp[act_rcpt]));
        lcd.setCursor(6,  _bot_lcd);   lcd.print(String(rcpt_litr[act_rcpt]));
      }
      if (b_PUSK.click()){

      }
    }
}

void test_INDIC(){
  for (int i = 0; i<3; i++){
    //lcd.write(i);  // печать createChar символов
    lcd.setCursor(15, _bot_lcd);  lcd.print(String(i));
    lcd.noBacklight();delay(300);  // Ожидание 300 мс.
    lcd.backlight();  delay(300);  // Ожидание 300 мс.
  }
  lcd.setCursor(0,_bot_lcd);               // Установка курсора во вторую строку, первый столбец
  lcd.print(empty_str);    // Очистка второй строки 16-ю пробелами
  for (int i = 0; i<16; i++){
    // Итерация по каждому символу на второй строке
    for (int j=0; j<5; j++)
    {
      lcd.setCursor(i, _bot_lcd);           // Установка курсора в заданную позицию
      lcd.write(j);                  // Обновление прогресс-бара
      delay(20);                     // Ожидание 100 мс.
    }  
  }
}

void inp_KOEFF(){
  bool b_inp_KOEFF  = true;
  byte poz_blink = 0;
  char bf[9];
  koef_CT = EEPROM_float_read(addr_EEPROM_koef_CT);
  dtostrf(koef_CT, 8, 3, bf);
  lcd.clear();   
  lcd.setCursor(0, _top_lcd);   lcd.print(menu_str_inp_koeff);
  lcd.setCursor(0, _bot_lcd);   lcd.print(bf);
  lcd.setCursor(poz_blink, _bot_lcd);  lcd.blink();
  while (b_inp_KOEFF){
    if (b_RECEPT.click()) {
      lcd.noBlink();
      mode_DIAG = true;
      cur_MENU = 0;
      b_inp_KOEFF  = false;
      koef_CT = atof(bf);
      EEPROM_float_write(addr_EEPROM_koef_CT, koef_CT);
      Serial.println(bf);
      Serial.println(koef_CT, 3);
    }
    if (b_PUSK.click()) { // инкремент десятичной цифры
      lcd.noBlink();
      switch (bf[poz_blink]) {
        case '0':  bf[poz_blink] = '1';    break;
        case '1':  bf[poz_blink] = '2';    break;
        case '2':  bf[poz_blink] = '3';    break;
        case '3':  bf[poz_blink] = '4';    break;
        case '4':  bf[poz_blink] = '5';    break;
        case '5':  bf[poz_blink] = '6';    break;
        case '6':  bf[poz_blink] = '7';    break;
        case '7':  bf[poz_blink] = '8';    break;
        case '8':  bf[poz_blink] = '9';    break;
        case '9':  bf[poz_blink] = '0';    break;
        case '.':  bf[poz_blink] = '.';    break;
        default:   bf[poz_blink] = '0';    break;
      }
        lcd.setCursor(poz_blink, _bot_lcd);
        lcd.print(bf[poz_blink]);
    }
    if (b_SBROS.click()) { // сдвиг блинка на одну позицию вправо
      if (poz_blink == 7){ poz_blink = 0; }
      else{  poz_blink = poz_blink + 1;   }
      lcd.setCursor(poz_blink, _bot_lcd);  lcd.blink();
    }        
  }
}

void inp_DOZA(){
  bool b_inp_DOZA  = true;
  byte poz_blink = 0;
  char bf[9];
  ust_DOZA = EEPROM_float_read(addr_EEPROM_ust_DOZA);
  dtostrf(ust_DOZA, 8, 3, bf);
  lcd.clear();   
  lcd.setCursor(0, _top_lcd);   lcd.print(menu_str_inp_doza);
  lcd.setCursor(0, _bot_lcd);   lcd.print(bf);
  lcd.setCursor(poz_blink, _bot_lcd);  lcd.blink();
  while (b_inp_DOZA){
    if (b_RECEPT.click()) {
      lcd.noBlink();
      mode_DIAG = true;
      cur_MENU = 0;
      b_inp_DOZA  = false;
      ust_DOZA = atof(bf);
      kol_IMP = trunc(1000.0 * (ust_DOZA / koef_CT));
      EEPROM_float_write(addr_EEPROM_ust_DOZA, ust_DOZA);
      EEPROM_ulong_write(addr_EEPROM_kol_IMP, kol_IMP);  
      Serial.println(koef_CT,  3);
      Serial.println(ust_DOZA, 3);
      Serial.println(kol_IMP);
    }
    if (b_PUSK.click()) { // инкремент десятичной цифры
      lcd.noBlink();
      switch (bf[poz_blink]) {
        case '0':  bf[poz_blink] = '1';    break;
        case '1':  bf[poz_blink] = '2';    break;
        case '2':  bf[poz_blink] = '3';    break;
        case '3':  bf[poz_blink] = '4';    break;
        case '4':  bf[poz_blink] = '5';    break;
        case '5':  bf[poz_blink] = '6';    break;
        case '6':  bf[poz_blink] = '7';    break;
        case '7':  bf[poz_blink] = '8';    break;
        case '8':  bf[poz_blink] = '9';    break;
        case '9':  bf[poz_blink] = '0';    break;
        case '.':  bf[poz_blink] = '.';    break;
        default:   bf[poz_blink] = '0';    break;
      }
        lcd.setCursor(poz_blink, _bot_lcd);
        lcd.print(bf[poz_blink]);
    }
    if (b_SBROS.click()) { // сдвиг блинка на одну позицию вправо
      if (poz_blink == 7){ poz_blink = 0; }
      else{  poz_blink = poz_blink + 1;   }
      lcd.setCursor(poz_blink, _bot_lcd);  lcd.blink();
    }        
  }
}

void setup_DEFAULT(){
  bool b_setup_DEFAULT  = true;  
  lcd.clear();   
  lcd.setCursor(0, _top_lcd);   lcd.print(menu_str_setup_default);
  lcd.setCursor(0, _bot_lcd);   lcd.print("write ...");
  koef_CT = 1.869;
  ust_DOZA = 9999.876;
  kol_IMP = trunc(1000.0 * (ust_DOZA / koef_CT));
  EEPROM_float_write(addr_EEPROM_koef_CT,  koef_CT);
  EEPROM_float_write(addr_EEPROM_ust_DOZA, ust_DOZA);
  EEPROM_ulong_write(addr_EEPROM_kol_IMP,  kol_IMP);  
  while (b_setup_DEFAULT){
    if (b_RECEPT.click()) {
      mode_DIAG = true;
      cur_MENU = 0;
      b_setup_DEFAULT  = false;      
      lcd.clear();   
      lcd.setCursor(0, _top_lcd);   lcd.print(menu_str_setup_default);
      lcd.setCursor(0, _bot_lcd);   lcd.print("read ...");
      koef_CT  = EEPROM_float_read(addr_EEPROM_koef_CT);
      ust_DOZA = EEPROM_float_read(addr_EEPROM_ust_DOZA);
      kol_IMP  = EEPROM_ulong_read(addr_EEPROM_kol_IMP);  
    }  
  }
}

void freq_METR(){
  // pulseIn время в мкcек логического уровня от 10 микросекунд до 3 минут
  bool b_freq_METR  = true;
  uint32_t Htime;       // целочисленная переменная для хранения времени высокого логического уровня
  uint32_t Ltime;       // целочисленная переменная для хранения времени низкого логического уровня
  //float Ttime;     // переменная для хранения общей длительности периода
  //float frequency; // переменная для хранения частоты

  while(b_freq_METR){
    if (b_RECEPT.click()) {
      b_freq_METR  = false;
      mode_DIAG = true;
      cur_MENU = 0;
      digitalWrite(_rele_EK, LOW);
    }

    Htime=pulseIn(_but_LITR,HIGH);    //  время в мкcек высокого лог. уровня
    Ltime=pulseIn(_but_LITR,LOW);     //  время в мкcек низкого лог. уровня

    lcd.clear();   
    //lcd.setCursor(0, _top_lcd);   lcd.print("                ");
    lcd.setCursor(0, _top_lcd);   lcd.print(Ltime);
    lcd.setCursor(0, _bot_lcd);   lcd.print(Htime);
      
    //Ttime = Htime+Ltime;
    //frequency=1000000/Ttime;  // получение частоты из Ttime в микросекундах

    delay(500);
  }
}

void test_CLOCK(){
  bool b_test_CLOCK  = true;
  char buf_str[8] = "00:00:00";
  lcd.clear();  
  lcd.setCursor(0, _top_lcd);   lcd.print(menu_str_test_clock);

  while(b_test_CLOCK){
    if (b_RECEPT.click()) {
      b_test_CLOCK  = false;
      mode_DIAG = true;
      cur_MENU = 0;
      digitalWrite(_rele_EK, LOW);
    }
    
    sec = millis() / 1000ul;      // полное количество секунд
    timeHours = (sec / 3600ul);         // часы
    timeMins  = (sec % 3600ul) / 60ul;  // минуты
    timeSecs  = (sec % 3600ul) % 60ul;  // секунды
    
    lcd.setCursor(8, _bot_lcd);
    sprintf(buf_str, "%02d:%02d:%02d", timeHours, timeMins, timeSecs);
    lcd.print(buf_str);

    delay(950);
  }  
}

void rating_KOEF(){
  bool b_rating_KOEF  = true;
}

void test_INPUT(){
  bool b_test_input  = true;
  byte poz_blink = 0;
  float doza = 2345.678;
  //float doza =   5.678;
  char bf[9];
  dtostrf(doza, 8, 3, bf);
  lcd.clear();  
  lcd.setCursor(0, _top_lcd);    //lcd.print("12345.678       ");
  lcd.print(bf);
  lcd.setCursor(poz_blink, _top_lcd);  lcd.blink();
  while (b_test_input){
    if (b_RECEPT.click()) {
      lcd.noBlink();
      mode_DIAG = true;
      cur_MENU = 0;
      b_test_input  = false;
      Serial.println(bf);
      float f = atof(bf);
      Serial.println(f, 3);
    }
    if (b_PUSK.click()) { // инкремент десятичной цифры
      lcd.noBlink();
      //Serial.println("b_PUSK");
      switch (bf[poz_blink]) {
        case '0':  bf[poz_blink] = '1';    break;
        case '1':  bf[poz_blink] = '2';    break;
        case '2':  bf[poz_blink] = '3';    break;
        case '3':  bf[poz_blink] = '4';    break;
        case '4':  bf[poz_blink] = '5';    break;
        case '5':  bf[poz_blink] = '6';    break;
        case '6':  bf[poz_blink] = '7';    break;
        case '7':  bf[poz_blink] = '8';    break;
        case '8':  bf[poz_blink] = '9';    break;
        case '9':  bf[poz_blink] = '0';    break;
        case '.':  bf[poz_blink] = '.';    break;
        default:   bf[poz_blink] = '0';    break;
      }
        lcd.setCursor(poz_blink, _top_lcd);
        lcd.print(bf[poz_blink]);
        //Serial.println(bf);
    }
    if (b_SBROS.click()) { // сдвиг блинка на одну позицию вправо
      Serial.println("b_SBROS");
      if (poz_blink == 7){ poz_blink = 0; }
      else{  poz_blink = poz_blink + 1;   }
      lcd.setCursor(poz_blink, _top_lcd);  lcd.blink();
    }
  }
  /*
    преобразуем массив char bf[] в десятичное число вида *****.***
  */
}

void setup() {
  //pinMode(_short_CONFIG, INPUT_PULLUP);
  pinMode(_but_LITR, INPUT_PULLUP);
  pinMode(_rele_EK,        OUTPUT);
  digitalWrite(_rele_EK, LOW);

  Serial.begin(9600);
  Serial.println("CENTR 2024.11.01");

  lcd.init();   lcd.backlight();
  lcd.clear();  lcd.setCursor(0, _top_lcd);
  lcd.print("CENTR 2024.11.01");

  // Определение пользовательских символов
  lcd.createChar(0, p20);
  lcd.createChar(1, p40);
  lcd.createChar(2, p60);
  lcd.createChar(3, p80);
  lcd.createChar(4, p100);

  delay(500);

  koef_CT  = EEPROM_float_read(addr_EEPROM_koef_CT);
  ust_DOZA = EEPROM_float_read(addr_EEPROM_ust_DOZA);
  kol_IMP  = EEPROM_ulong_read(addr_EEPROM_kol_IMP);

  //rcpt_imp[0] = int(ust_DOZA);
  rcpt_litr[0] = int(ust_DOZA);
  rcpt_imp[0]  = int(kol_IMP);
  
  //get and display the EEPROMs contents
  //getEepromData();
 /* if (mode_DIAG == false){
      koef_CT  = EEPROM_float_read(addr_EEPROM_koef_CT);
      ust_DOZA = EEPROM_float_read(addr_EEPROM_ust_DOZA);
      kol_IMP  = EEPROM_ulong_read(addr_EEPROM_kol_IMP);
  }*/

  lcd_0(true, "INIT  ", act_rcpt);
  stat_but_PUSK  = false;

  /*  check mode DIAG   =================================*/
  byte cnt_b_PUSK = 0;
  while (digitalRead(_but_PUSK_PAUSE) == 0) {
    if (b_PUSK.click()) {
      if (cnt_b_PUSK < 2) {
        mode_DIAG = true;
        cnt_b_PUSK = cnt_b_PUSK + 1;
        lcd.setCursor(0, _top_lcd);      lcd.print(menu_str);
        Serial.println("press button b_PAUSE");
      }
    }
  }  

}

void loop() {
  sec = millis() / 1000ul;      // полное количество секунд
  timeHours = (sec / 3600ul);         // часы
  timeMins  = (sec % 3600ul) / 60ul;  // минуты
  timeSecs  = (sec % 3600ul) % 60ul;  // секунды  
  /*   CONFIGs & DIAGNOSTICs   ==========================*/
  while (mode_DIAG == true) {
    if (b_SBROS.click()) {    
      cur_MENU = cur_MENU + 1;
      if (cur_MENU > _max_MENU){
        cur_MENU = 1;
      }
    }
    if (b_RECEPT.click()) {    
        cur_MENU = 0;
    }    
    if (cur_MENU != prv_MENU){
      prv_MENU = cur_MENU;
      lcd.clear();  lcd.setCursor(0, _top_lcd);
      switch(cur_MENU){
        case 0:
          lcd.print(menu_str);
          Serial.println(menu_str);
          break;
        case 1:
          lcd.print(menu_str_test_rele);
          Serial.println(menu_str_test_rele);
          break;
        case 2:
          lcd.print(menu_str_chng_rcpt);
          Serial.println(menu_str_chng_rcpt);
          break;
        case 3:
          lcd.print(menu_str_test_indc);
          Serial.println(menu_str_test_indc);
          break;
        case 4:
          lcd.print(menu_str_inp_koeff);
          Serial.println(menu_str_inp_koeff);
          break;
        case 5:
          lcd.print(menu_str_inp_doza);
          Serial.println(menu_str_inp_doza);
          break;
        case 6:
          lcd.print(menu_str_setup_default);
          Serial.println(menu_str_setup_default);
          break;
        case 7:
          lcd.print(menu_str_freq_metr);
          Serial.println(menu_str_freq_metr);
          break;
        case 8:
          lcd.print(menu_str_test_clock);
          Serial.println(menu_str_test_clock);
          break;
        case 9:
          lcd.print(menu_str_rating_koef);
          Serial.println(menu_str_rating_koef);
          break;
          
        //==============          
        //case 8:
        //  lcd.print("8. INPUT NUNB   ");
        //  Serial.println("sel MENU  8. INPUT NUNB");
        //  break;
        default:
          break;
      }
    }
    if (b_PUSK.click()) {    
      switch(cur_MENU){
        case 0:
          break;
        case 1:
          test_RELE();
          break;
        case 2:
          chng_RCPT();
          break;
        case 3:
          test_INDIC();        
          break;
        case 4:
          inp_KOEFF();        
          break;
        case 5:
          inp_DOZA();        
          break;
        case 6:
          setup_DEFAULT();        
          break;          
        case 7:
          freq_METR();        
          break;          
        case 8:
          test_CLOCK();        
          break;          
        case 9:
          rating_KOEF();        
          break;           
        //==============          
        //case 8:
        //  test_INPUT();        
        //  break;
        default:
          break;
      }
    }  
  }

//(2024-09-20)  if (b_LITR.click()) {
//(2024-09-25)  while (digitalRead(_but_LITR) == 0) { 
  if (mode_PUSK) {
    // ловим перепад с 1 на 0 на входе _but_LITR ----------------
    if (digitalRead(_but_LITR) == 0) {
      if (b_LITR_prev == 0){   // в пред цикле НЕ было сигнала
        b_LITR = true;
        b_LITR_prev = true;    
        delay(1); // эту задержку можно сделать в настройках (антидребезг)   
      }
      else{
        b_LITR = false;
      }  
    }
    else{
      b_LITR = false;
      b_LITR_prev = false;    
    }  
    //-----------------------------------------------------------
    if (b_LITR) {  
      b_LITR = false;
      if (mode_PUSK) {
        imp_rashod = imp_rashod + 1;
      }
      if ((sec - sec_PUSK) != 0){ // обновляем индикацию
        sec_PUSK = sec;
        lcd.setCursor(0, _bot_lcd);    lcd.print(empty_str);
        //lcd.setCursor(12, _bot_lcd);   lcd.print(imp_rashod);
        //------------- calculate litr_rashod --------//
        litr_rashod = map(imp_rashod, 0, rcpt_imp[act_rcpt], 0, rcpt_litr[act_rcpt] );
        lcd.setCursor(12, _bot_lcd);   lcd.print(litr_rashod);
        // imp_rashod = trunc(1000.0 * (litr_rashod / koef_CT));
                
        //Serial.println("Press button _but_LITR");
      }
    }

    if (imp_rashod >= rcpt_imp[act_rcpt]) {
      imp_rashod = 0;
      mode_INIT = true;
      lcd_0(true, "INIT  ", act_rcpt);    
      lcd.setCursor(12, _bot_lcd);      lcd.print(imp_rashod);
      digitalWrite(_rele_EK, LOW);
      mode_PUSK  = false;
    }
  }

  while (digitalRead(_but_SBROS) == 0) {
    if (b_SBROS.click()) {
      imp_rashod = 0;
      mode_INIT = true;
      lcd_0(true, "INIT  ", act_rcpt);  
      digitalWrite(_rele_EK, LOW);
      mode_PUSK  = false;
      Serial.println("press button _but_SBROS");
    }
  }

  if (mode_INIT) {
    if (b_RECEPT.click()) { 
      act_rcpt = act_rcpt + 1;
      if (act_rcpt > 9) {
        act_rcpt = 0;
      }
      lcd.setCursor(0,  _bot_lcd);      lcd.print(empty_str);
      lcd.setCursor(6,  _bot_lcd);      lcd.print(buf_rcpt);
      lcd.setCursor(9,  _bot_lcd);      lcd.print(String(act_rcpt));
//      lcd.setCursor(12, _bot_lcd);     lcd.print(String(rcpt_imp[act_rcpt]));
      lcd.setCursor(12, _bot_lcd);     lcd.print(String(rcpt_litr[act_rcpt]));
    }
  }

  byte cnt_b_PUSK = 0;
  while (digitalRead(_but_PUSK_PAUSE) == 0) {
    if (b_PUSK.click()) {
      if (cnt_b_PUSK < 2) {
        digitalWrite(_rele_EK, LOW);
        stat_but_PUSK  = false;
        lcd_0(true, "PAUSE ", act_rcpt);
        cnt_b_PUSK = cnt_b_PUSK + 1;
        Serial.println(String(cnt_b_PUSK));
        mode_INIT = false;
        mode_PUSK  = false;
      }
      else {
        if (cnt_b_PUSK < 4) {
          cnt_b_PUSK = cnt_b_PUSK + 1;
          lcd.setCursor(0, _top_lcd);      lcd.print("PUSK  ");
          Serial.println("press button b_PUSK");
          mode_INIT = false;
          mode_PUSK  = true;
          stat_but_PUSK  = true;
        }
      }
    }
  }

  if (stat_but_PUSK) {
    digitalWrite(_rele_EK, HIGH);
    stat_but_PUSK  = false;
  }

}

//get data from the EEPROM
void getEepromData()
{
  bool hex = true;
  String currentLine = "";
  String currentHex = "";
  //displayHeader(); //get and display the header information
  for (long i = 0; i < EEPROM.length()-896; i++)//read data from the EEPROM
  {
    if (i % 8 == 0)//display in rows of 8 bytes at a time
    {
      Serial.println(currentLine);//print current 8 bytes of text
      currentLine = "";//reset

      Serial.print(i);//display the memory location range for the current line
      Serial.print(" to ");
      Serial.print(i + 7);
      if (i < 20)
      {
        Serial.print("   ");//this just helps with the formatting in the monitor
      }
      Serial.print("\t");
    }
    byte currentByte = byte(EEPROM.read(i));//get the next byte of data
    if (!hex)
    {
      Serial.print(currentByte);//display decimal
    }
    else
    {
      currentHex = String(currentByte, HEX);//display hexidecimal
      Serial.print(currentHex);
    }
    if (currentByte == 255)//print a period if the value is 255
    {
      currentByte = 46;
    }
    currentLine += char(currentByte);//build up the current text line
    currentLine += " ";//makes it easire to read
    Serial.print("\t");
  }
  Serial.println(currentLine);
}