#define VERSION "Проект V 2.0.2"

#include "Wire.h"
#define _LCD_TYPE 1
//https://portal-pk.ru/news/313-vyvodim-simvoly-na-displei-lcd-1602-i-lcd-2004.html
#include "font_LCD_1602_RUS.h"  //https://maxpromer.github.io/LCD-Character-Creator/
#include "LCD_1602_RUS_ALL.h"   //https://github.com/ssilver2007/LCD_1602_RUS_ALL
#include <LiquidCrystal_I2C.h>  //https://wiki.iarduino.ru/page/working_with_character_lcd_displays
#include "time.h"
#include <TaskScheduler.h>  //https://github.com/arkhipenko/TaskScheduler
#include "RTClib.h"         //V 2.0.2
#include <Preferences.h>    //http://developer.alexanderklimov.ru/arduino/esp32/preferences.php
#include <SD.h>             //V 1.2.3 https://www.mischianti.org/2021/03/28/how-to-use-sd-card-with-esp32-2/
#include "SdFat.h"
#include "ModbusRtu.h"  // https://github.com/smarmengol/Modbus-Master-Slave-for-Arduino

unsigned long CurrentTime, LastTime;
enum eEncoderState { eNone,
                     eLeft,
                     eRight,
                     eButton
                   };
uint8_t EncoderA, EncoderB, EncoderAPrev;
int8_t counter;
bool ButtonPrev;

#define SPI_SPEED SD_SCK_MHZ(4)
#define CS_PIN 5
#define TXEN 4

#define LEFT 1   //не пин
#define RIGHT 2  //не пин
#define ENTER 3  //не пин

#define ERASESCREEN true
#define NOERASESCREEN false
#define OffUpDown 4  //не пин

#define pin_CLK 36  //17 //право
#define pin_DT 39   //16 //лево
#define pin_Btn 32  //ввод

#define IN_MOTOR_STOP 27
#define IN_MOTOR_UP 13
#define IN_MOTOR_DOWN 33
#define OUT_MOTOR_STOP 26
#define OUT_MOTOR_UP 25
#define OUT_MOTOR_DOWN 12
//**********РАЗОБРАТЬ
#define IN_AMPER 35  //Аналог. Ток с сдатчика VP
#define OUT_PUSH 5   //Режим подъема
#define IN_HEGH 34   //высота подъема. 1 тик в минуту
//#define IN_VP 36
//#define IN_PR 39
#define MAXPOWER 14

int activScreen = 0;
int menuPositionMain = 1;
int menuPositionMain2 = 1;
int menuPositionManual = 0;
int menuPositionDigitalManual = 0;
int menuPositionSettings = 0;
int menuPositionDigitalSettings = 0;
int selectColor = 0;
String ManualOnOff = "ВЫК";
String ManualUPOnOff = "ВЫК";
String ManualDOWNOnOff = "ВЫК";
String ManualModeOnOff = "ВЫК";
String ModeStateOnOff = "ВЫК";
String AutoModeOnOff = "ВЫК";
String PushModeOnOff = "ВЫК";
String HalfAutoModeOnOff = "ВЫК";
String CyclePause = "";

bool ClickManualUPOnOff = false;
bool ClickManualDOWNOnOff = false;
bool ClickSettingsOnOff = false;
bool ClickManualModes = false;
bool ClickManualModeState = false;
int ManualModes = 0;
bool ClickAutoOnOff = false;
bool edit = false;
//int counter = 0;
String Time = "";
String Date = "";
float power = 2.00;          //Потребляемая мощность
String dimensionPower = "";  //Единицы измерения мощности
int vp = 0;                  //Управляющие сигналы с датчиков ограничения движения 0/1
int pr = 0;                  //Управляющие сигналы с датчиков ограничения движения 0/1
int heigh;                   //Высота подъема/спуска
String VP;
String PR;
String H;
String MODES;
int upMax = 0;
int downMax = 10;  //Максимальные точки подъема\спуска
int _cycle = 0;
int _switch = 0;
int cntCycle = 0;
int cycle = 3;        //Количество подъемов\спусков
int pauseCycle = 10;  //пауза между циклами
int dd = 11;
int mm = 22;
int gg = 33;
int hh = 44;
int mnt = 55;  //Время дата
volatile bool pauseAuto = false;
volatile int cntPause = 0;
int positionDigital = 1;
int positionCursor = 2;
int tenPosition, hundredPosition, onePosition;
int positionMin = 13;
int positionMax = 18;
int positionCycl = 15;
int positionPause = 19;
int positionDD = 6;
int positionMM = 12;
int positionG = 19;
int positionHH = 6;
int position_MM = 12;
int id = 3;
float AcsValue = 0.0, Samples = 0.0, AvgAcs = 0.0, AcsValueF = 0.0;
bool cycleOK = false;
int modbasCommand = 0;
//String modes[4] = {"MANUAL   ", "HALF-AUTO", "AUTO     ", "PUSH     "};
String modes[4] = { "РУЧНОЙ        ", "ПОЛУАВТО      ", "АВТО          ", "ТОЛКНУТЬ      " };
//upMax, downMax, cycle, _cycle cntCycle pauseCycle vp pr heigh   ManualOnOff ManualUPOnOff
//ManualModeOnOff ModeStateOnOff AutoModeOnOff PushModeOnOff HalfAutoModeOnOff
//uint16_t modbus_array[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };  //первоначально в массив записываем нулевые значения, размер устанавливаем сами
//uint16_t modbus_array[] = {0, 0, 0, 0, 0};
uint16_t modbus_array[18];
//LiquidCrystal_I2C lcd(0x27, 20, 4);
LCD_1602_RUS lcd(0x27, 20, 4);
RTC_DS1307 rtc;
DateTime now;
Modbus slave(4, Serial2, TXEN);

SdFat sd;
File root;
Preferences preferences;

//https://cplusplus.com/reference/ctime/tm/
//Ссылка на структуру системного времени. Обязательно нужно выставлять вручную
//Или если использовать Wi Fi, автоматическая синхронизация с NTP при старте один раз
//struct tm timeinfo;
Scheduler userScheduler;  //Управление задачами по таймеру
//Раз в минуту вызываем getTime(). Получаем системное время
void getTime();                              //Декларируем функцию обработки
void pauseFunction();                        //Декларируем функцию паузы
void printDirectory(File dir, int numTabs);  //Декларируем функцию чтения директории SD
void saveSettings();
void readSettings();
void saveLog(int vector);
void functionMODBUS();
Task taskTime(TASK_SECOND * 2, TASK_FOREVER, &getTime);
//Task taskPause(TASK_MINUTE * 1, TASK_FOREVER, &pauseFunction);  //TASK_MILLISECOND
Task taskPause(TASK_SECOND * 1, TASK_FOREVER, &pauseFunction);

void GetEncoderState() {
  // Считываем состояние энкодера
  pinMode(pin_CLK, INPUT);
  eEncoderState Result = eNone;
  CurrentTime = millis();

  if (CurrentTime - LastTime >= 5) {

    // Считываем не чаще 1 раза в 5 мс для уменьшения ложных срабатываний
    LastTime = CurrentTime;
    if (digitalRead(pin_Btn) == LOW) {
      if (ButtonPrev) {
        Result = eButton;  // Нажата кнопка
        //Serial.println("ENTER");
        _switch = ENTER;
        ButtonPrev = 0;
      }
    } else {
      ButtonPrev = 1;
      EncoderA = digitalRead(pin_DT);
      EncoderB = digitalRead(pin_CLK);

      if ((!EncoderA) && (EncoderAPrev))  // Сигнал A изменился с 1 на 0
      {
        if (EncoderB) {
          Result = eRight;  // B=1 => энкодер вращается по часовой
          _switch = RIGHT;
          //Serial.println("RIGHT");
        } else {
          Result = eLeft;  // B=0 => энкодер вращается против часовой
          //Serial.println("LEFT");
          _switch = LEFT;
          //Serial.printf("cycleOK=%d _cycle=%d ManualUPOnOff=%s ManualDOWNOnOff=%s Heigh=%d\n", cycleOK, _cycle, ManualUPOnOff, ManualDOWNOnOff, heigh);
        }
      }
      EncoderAPrev = EncoderA;  // запомним текущее состояние
    }
  }
  //return Result;
}

void getTime() {
  if (edit == false) {
    now = rtc.now();
    hh = now.hour();
    mnt = now.minute();
    dd = now.day();
    mm = now.month();
    gg = now.year();
  }

  if (edit == false and activScreen == 4) settingsScreen(NOERASESCREEN, OffUpDown);
}
static int cntTime = 0;
void pauseFunction() {
  if (AutoModeOnOff == "ВЫК" and pauseAuto == true) {
    lcd.setCursor(16, 0);
    if (++cntTime == 1) lcd.print(".  ");
    else if (cntTime == 2) lcd.print(".. ");
    else if (cntTime == 3) {
      lcd.print("...");
      cntTime = 0;
    }
    //Счетчик секунд ПАУЗА
    if (++cntPause == pauseCycle * 60) {
      cntPause = 0;
      AutoModeOnOff = "ВКЛ";
      pauseAuto = false; //Сбросить флаг ПАУЗА
    }
  }
}

void helloScreen(bool erase) {
  activScreen = 0;
  if (erase) lcd.clear();
  lcd.setCursor(5, 1);
  lcd.print("ЭЛЕВАТОР");
  lcd.setCursor(2, 2);
  lcd.print(VERSION);
}

void manualScreen(bool erase, int UpDown) {
  //Очистить если true
  activScreen = 1;
  if (erase) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.write(char(126));
    menuPositionManual = 0;
    menuPositionDigitalManual = 0;
    lcd.setCursor(0, 0);
  }
  if (UpDown == LEFT) menuPositionManual--;
  if (UpDown == RIGHT) menuPositionManual++;
  //Serial.printf("MANUAL menuPositionManual=%d\n\n", menuPositionManual);
  if (menuPositionManual > 2) {
    settingsScreen(ERASESCREEN, OffUpDown);
    return;
  }
  if (menuPositionManual < 0) {
    helloScreen(ERASESCREEN);
    return;
  }
  lcd.setCursor(2, 0);
  lcd.write(255);
  lcd.write(255);
  lcd.write(255);
  lcd.write(255);
  lcd.write(255);
  lcd.write(255);
  lcd.write(255);
  lcd.write(255);
  lcd.write(255);
  delay(150);
  lcd.setCursor(2, 0);
  lcd.print(MODES);
  lcd.setCursor(16, 0);
  if (MODES == modes[0] or MODES == "УСТАНОВКА... ") ModeStateOnOff = "   ";

  lcd.print(ModeStateOnOff);
  if (menuPositionDigitalManual == 1) {
    lcd.setCursor(0, 0);
    lcd.print(" ");
    lcd.setCursor(14, 0);
    lcd.write(char(126));
  }

  lcd.setCursor(2, 1);
  lcd.print("ВВЕРХ");
  lcd.setCursor(9, 1);
  lcd.print(ManualUPOnOff);
  lcd.setCursor(2, 2);
  lcd.print("ВНИЗ");
  lcd.setCursor(9, 2);
  lcd.print(ManualDOWNOnOff);
  lcd.setCursor(16, 1);
  lcd.print(VP);
  lcd.setCursor(16, 2);
  lcd.print(PR);
  lcd.setCursor(2, 3);
  lcd.print(H);
  lcd.setCursor(13, 3);
  lcd.print(CyclePause);

  if (UpDown == RIGHT) {
    if (MODES == modes[0]) {
      if (menuPositionManual == 1) {
        lcd.setCursor(0, 0);
        lcd.print(" ");
        lcd.setCursor(0, 1);
      }
      if (menuPositionManual == 2) {
        lcd.setCursor(0, 1);
        lcd.print(" ");
        lcd.setCursor(0, 2);
      }
    } else {
      ModeStateOnOff = "ВЫК";
      ++menuPositionDigitalManual;
      if (menuPositionDigitalManual > 1) {
        settingsScreen(ERASESCREEN, OffUpDown);
        return;
      }
      if (menuPositionDigitalManual == 1) {
        lcd.setCursor(0, 0);
        lcd.print(" ");
        lcd.setCursor(14, 0);
      }
    }
    lcd.write(char(126));

    lcd.setCursor(16, 0);
    lcd.print(ModeStateOnOff);
  }
  if (UpDown == LEFT) {
    if (MODES == modes[0]) {
      if (menuPositionManual == 1) {
        lcd.setCursor(0, 2);
        lcd.print(" ");
        lcd.setCursor(0, 1);
      }
      if (menuPositionManual == 0) {
        lcd.setCursor(0, 1);
        lcd.print(" ");
        lcd.setCursor(0, 0);
      }
      lcd.write(char(126));
    } else {
      ModeStateOnOff = "ВЫК";
      --menuPositionDigitalManual;
      if (menuPositionDigitalManual < 0) {
        menuPositionDigitalManual = 0;
        helloScreen(ERASESCREEN);
      }
      if (menuPositionDigitalManual == 0) {
        lcd.setCursor(14, 0);
        lcd.print(" ");
        lcd.setCursor(0, 0);
      }
      lcd.write(char(126));
      lcd.setCursor(16, 0);
      lcd.print(ModeStateOnOff);
    }
  }

  //lcd.setCursor(16, 0);
  //lcd.print(ModeStateOnOff);

  if (UpDown == 30) {
    lcd.setCursor(0, 0);
    lcd.write(char(126));  //lcd.print(">");
    activScreen = 1;
  }
}

void settingsScreen(bool erase, int UpDown) {
  activScreen = 2;
  //Очистить если true
  if (erase) {
    lcd.clear();
    menuPositionSettings = 0;
  }
  if (UpDown == LEFT) menuPositionSettings--;
  if (UpDown == RIGHT) menuPositionSettings++;
  Serial.printf("SETTINGS menuPositionSettings=%d\n\n", menuPositionSettings);
  if (menuPositionSettings > 3) {
    helloScreen(ERASESCREEN);
    return;
  }
  if (menuPositionSettings < 0) {
    manualScreen(ERASESCREEN, OffUpDown);
    return;
  }

  lcd.setCursor(2, 0);
  lcd.print("MinMax=");
  lcd.setCursor(10, 0);
  //lcd.print(String(upMax));
  lcd.printf("%04d", upMax);
  lcd.setCursor(14, 0);
  lcd.print("/");
  lcd.setCursor(15, 0);
  //lcd.print(String(downMax));
  lcd.printf("%04d", downMax);
  lcd.setCursor(2, 1);
  lcd.print("ЦиклПауза=");
  lcd.setCursor(13, 1);
  //lcd.print(String(cycle));
  lcd.printf("%03d", cycle);
  lcd.setCursor(16, 1);
  lcd.print("/");
  lcd.setCursor(17, 1);
  //lcd.print(String(pauseCycle));
  lcd.printf("%03d", pauseCycle);
  lcd.setCursor(2, 2);
  //lcd.print("  ");
  lcd.setCursor(2, 2);
  //lcd.print(String(dd));
  lcd.printf("%02d", dd);
  lcd.setCursor(4, 2);
  lcd.print("/");
  lcd.setCursor(5, 2);
  //lcd.print("  ");
  //lcd.setCursor(5, 2);
  //lcd.print(String(mm));
  lcd.printf("%02d", mm);
  lcd.setCursor(7, 2);
  lcd.print("/");
  lcd.setCursor(8, 2);
  lcd.print("  ");
  lcd.setCursor(8, 2);
  lcd.print(String(gg));

  lcd.setCursor(2, 3);
  //lcd.print("  ");
  lcd.setCursor(2, 3);
  //lcd.print(String(hh));
  lcd.printf("%02d", hh);
  lcd.setCursor(4, 3);
  lcd.print(":");
  lcd.setCursor(5, 3);
  //lcd.print("  ");
  lcd.setCursor(5, 3);
  //lcd.print(String(mnt));
  lcd.printf("%02d", mnt);
  lcd.setCursor(13, 3);
  lcd.print("ID=");
  lcd.setCursor(16, 3);
  lcd.printf("%03d", id);
  //lcd.printf("%d")

  if (UpDown == RIGHT) {
    lcd.setCursor(0, menuPositionSettings - 1);
    lcd.print(" ");
    if (menuPositionSettings > 3) {
      helloScreen(ERASESCREEN);
      return;
    }
  }
  if (UpDown == LEFT) {
    lcd.setCursor(0, menuPositionSettings + 1);
    lcd.print(" ");
    if (menuPositionSettings < 0) {
      manualScreen(ERASESCREEN, 30);
      return;
    }
  }
  lcd.setCursor(0, menuPositionSettings);
  lcd.write(char(126));  //lcd.print(">");
}
//Обработка кода "кнопки"
void reciveBtnCode() {
  switch (_switch) {
    case LEFT:
      // LEFT**************
      if (edit == false) {
        //Serial.printf("LEFT activScreen=%d\n",activScreen);
        if (activScreen == 0) {
          settingsScreen(ERASESCREEN, OffUpDown);  //
          break;
        }
        if (activScreen == 1) {
          //helloScreen(ERASESCREEN);
          manualScreen(NOERASESCREEN, LEFT);
          break;
        }
        if (activScreen == 2) {
          settingsScreen(NOERASESCREEN, LEFT);
          break;
        }
      }

      if (edit == true) {
        if (activScreen == 2) {
          if (menuPositionSettings == 0) {
            if (menuPositionDigitalSettings == 1) {
              --upMax;
              lcd.noBlink();
              if (upMax < 0) upMax = 9999;
              lcd.setCursor(10, 0);
              lcd.print("    ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(10, 0);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              --downMax;
              lcd.noBlink();
              if (downMax < 0) downMax = 9999;
              lcd.setCursor(15, 0);
              lcd.print("    ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(15, 0);
              lcd.blink();
              break;
            }
          }

          if (menuPositionSettings == 1) {
            if (menuPositionDigitalSettings == 1) {
              --cycle;
              lcd.noBlink();
              if (cycle < 3) cycle = 999;
              lcd.setCursor(13, 1);
              lcd.print("   ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(13, 1);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              --pauseCycle;
              lcd.noBlink();
              if (pauseCycle < 2) pauseCycle = 999;
              lcd.setCursor(17, 1);
              lcd.print("   ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(17, 1);
              lcd.blink();
              break;
            }
          }

          if (menuPositionSettings == 2) {
            if (menuPositionDigitalSettings == 1) {
              --dd;
              lcd.noBlink();
              if (dd < 1) dd = 31;
              lcd.setCursor(2, 2);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(2, 2);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              --mm;
              lcd.noBlink();
              if (mm < 1) mm = 12;
              lcd.setCursor(5, 2);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(5, 2);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 3) {
              --gg;
              lcd.noBlink();
              lcd.setCursor(8, 2);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(8, 2);
              lcd.blink();
              break;
            }
          }
          //Не забыть переустановить время в RTC
          if (menuPositionSettings == 3) {
            if (menuPositionDigitalSettings == 1) {
              --hh;
              lcd.noBlink();
              if (hh < 1) hh = 24;
              lcd.setCursor(2, 3);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(2, 3);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              --mnt;
              lcd.noBlink();
              if (mnt < 0) mnt = 59;
              lcd.setCursor(5, 3);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(5, 3);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 3) {
              --id;
              lcd.noBlink();
              if (id < 3) id = 255;
              lcd.setCursor(16, 3);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(16, 3);
              lcd.blink();
              break;
            }
          }
        }
      }
      break;

    case ENTER:
      //"ENTER" ВЫБОР
      //Экран MANUAL Ручной режим работы от энкодера*******************************************
      if (activScreen == 1) {
        //Выбор энкодером режимов работы "MANUAL", "HALF-AUTO", "AUTO", "PUSH"
        Serial.printf("ENTER menuPositionManual=%d\n\n\n", menuPositionManual);
        if (menuPositionManual == 0) {
          if (ManualModes == 0) ManualModes = 2;
          else ManualModes++;
          ModeStateOnOff = "ВЫК";
          CyclePause = "       ";
          Serial.printf("ENTER ManualModes=%d\n\n\n", ManualModes);
          if (ManualModes > 4) ManualModes = 1;
          if (ManualModes == 1) {
            MODES = modes[ManualModes - 1];
            manualScreen(NOERASESCREEN, 30);
            lcd.setCursor(16, 0);
            lcd.print("   ");
            break;
          }
          if (ManualModes == 2) {
            MODES = modes[ManualModes - 1];
            manualScreen(NOERASESCREEN, 30);
            lcd.setCursor(16, 0);
            lcd.print(ModeStateOnOff);
            break;
          }
          if (ManualModes == 3) {
            CyclePause = String(_cycle) + "/" + String(cycle);
            MODES = modes[ManualModes - 1];
            manualScreen(NOERASESCREEN, 30);
            lcd.setCursor(16, 0);
            lcd.print(ModeStateOnOff);
            break;
          }
          if (ManualModes == 4) {
            MODES = modes[ManualModes - 1];
            manualScreen(NOERASESCREEN, 30);
            lcd.setCursor(16, 0);
            lcd.print(ModeStateOnOff);
            break;
          }
        }
        //Включение-Выключение режимов работы "MANUAL", "HALF-AUTO", "AUTO", "PUSH"
        if (menuPositionManual == 1) {
          ClickManualModeState = !ClickManualModeState;
          Serial.printf("ENTER ClickManualModeState=%d\n\n\n", ClickManualModeState);
          if (ClickManualModeState == true) {
            if (ManualModes == 2) {
              HalfAutoModeOnOff = "ВКЛ";
              ModeStateOnOff = "ВКЛ";
              manualScreen(NOERASESCREEN, OffUpDown);
              break;
            }
            if (ManualModes == 3) {
              AutoModeOnOff = "ВКЛ";
              ModeStateOnOff = "ВКЛ";
              manualScreen(NOERASESCREEN, OffUpDown);
              break;
            }
            if (ManualModes == 4) {
              PushModeOnOff = "ВКЛ";
              ModeStateOnOff = "ВКЛ";
              manualScreen(NOERASESCREEN, OffUpDown);
              break;
            }
          }
          if (ClickManualModeState == false) {
            if (ManualModes == 2) {
              HalfAutoModeOnOff = "ВЫК";
              ModeStateOnOff = "ВЫК";
              manualScreen(NOERASESCREEN, OffUpDown);
              break;
            }
            if (ManualModes == 3) {
              AutoModeOnOff = "ВЫК";
              ModeStateOnOff = "ВЫК";
              manualScreen(NOERASESCREEN, OffUpDown);
              break;
            }
            if (ManualModes == 4) {
              PushModeOnOff = "ВЫК";
              ModeStateOnOff = "ВЫК";
              manualScreen(NOERASESCREEN, OffUpDown);
              break;
            }
          }
        }
        //Нажатие энкодера режим ВВЕРХ
        if (menuPositionManual == 1) {
          ClickManualUPOnOff = !ClickManualUPOnOff;
          if (ClickManualUPOnOff == true) {
            ManualUPOnOff = "ВКЛ";
            ManualDOWNOnOff = "ВЫК";
            digitalWrite(OUT_MOTOR_UP, HIGH);
            digitalWrite(OUT_MOTOR_DOWN, LOW);
            manualScreen(NOERASESCREEN, OffUpDown);
            ClickManualDOWNOnOff = !ClickManualDOWNOnOff;
            break;
          }
          if (ClickManualUPOnOff == false) {
            ManualUPOnOff = "ВЫК";
            digitalWrite(OUT_MOTOR_UP, LOW);
            manualScreen(NOERASESCREEN, OffUpDown);
            break;
          }
        }
        //Нажатие энкодера режим ВНИЗ
        if (menuPositionManual == 2) {
          ClickManualDOWNOnOff = !ClickManualDOWNOnOff;
          if (ClickManualDOWNOnOff == true) {
            ManualDOWNOnOff = "ВКЛ";
            ManualUPOnOff = "ВЫК";
            digitalWrite(OUT_MOTOR_DOWN, HIGH);
            digitalWrite(OUT_MOTOR_UP, LOW);
            manualScreen(NOERASESCREEN, OffUpDown);
            ClickManualUPOnOff = !ClickManualUPOnOff;
            break;
          }
          if (ClickManualDOWNOnOff == false) {
            ManualDOWNOnOff = "ВЫК";
            digitalWrite(OUT_MOTOR_DOWN, LOW);
            manualScreen(NOERASESCREEN, OffUpDown);
            break;
          }
        }
        break;
      }

      //Экран SETTINGS**************************************************
      if (activScreen == 2) {
        //delay(100);
        //Маркер строчек Экрана SETTINGS menuPositionDigitalSettings
        if (menuPositionSettings == 0) {
          if (menuPositionDigitalSettings == 0) edit = !edit;
          menuPositionDigitalSettings++;
          //Serial.println(menuPositionDigitalSettings);
          if (edit == true) {
            if (menuPositionDigitalSettings == 1) {
              lcd.noBlink();
              lcd.setCursor(10, 0);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              lcd.noBlink();
              lcd.setCursor(15, 0);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings > 2) {
              edit = !edit; /*menuPositionDigitalSettings=0; lcd.noBlink(); break;*/
            }
          }
          if (edit == false) {
            menuPositionDigitalSettings = 0;
            lcd.noBlink();
            saveSettings();
            break;
          }
        }

        if (menuPositionSettings == 1) {
          if (menuPositionDigitalSettings == 0) edit = !edit;
          menuPositionDigitalSettings++;
          //Serial.println(menuPositionDigitalSettings);
          if (edit == true) {
            if (menuPositionDigitalSettings == 1) {
              lcd.noBlink();
              lcd.setCursor(13, 1);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              lcd.noBlink();
              lcd.setCursor(17, 1);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings > 2) {
              edit = !edit; /*menuPositionDigitalSettings=0; lcd.noBlink(); break;*/
              saveSettings();
              //Serial.printf("Save Memory %d %d %d %d\n", upMax, downMax, cycle, pauseCycle);
            }
          }
          if (edit == false) {
            menuPositionDigitalSettings = 0;
            lcd.noBlink();
            saveSettings();
            break;
          }
        }

        if (menuPositionSettings == 2) {
          if (menuPositionDigitalSettings == 0) edit = !edit;
          menuPositionDigitalSettings++;
          //Serial.println(menuPositionDigitalSettings);
          if (edit == true) {
            if (menuPositionDigitalSettings == 1) {
              lcd.noBlink();
              lcd.setCursor(2, 2);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              lcd.noBlink();
              lcd.setCursor(5, 2);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 3) {
              lcd.noBlink();
              lcd.setCursor(8, 2);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings > 3) edit = !edit;
          }
          if (edit == false) {
            menuPositionDigitalSettings = 0;
            lcd.noBlink();
            saveSettings();
            saveTime();
            break;
          }
        }

        if (menuPositionSettings == 3) {
          if (menuPositionDigitalSettings == 0) edit = !edit;
          menuPositionDigitalSettings++;
          //Serial.println(menuPositionDigitalSettings);
          if (edit == true) {
            if (menuPositionDigitalSettings == 1) {
              lcd.noBlink();
              lcd.setCursor(2, 3);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              lcd.noBlink();
              lcd.setCursor(5, 3);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 3) {
              lcd.noBlink();
              lcd.setCursor(16, 3);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings > 3) {
              edit = !edit; /*menuPositionDigitalSettings=0; lcd.noBlink(); break;*/
            }
          }
          if (edit == false) {
            menuPositionDigitalSettings = 0;
            lcd.noBlink();
            saveSettings();
            saveTime();
            //slave.setID(id); //Не забыть вставить переустановку ID MODBUS
            //Serial.println("Save");
            break;
          }
        }
      }

      break;

    case RIGHT:
      // RIGHT
      if (edit == false) {
        //Serial.printf("RIGHT activScreen=%d\n",activScreen);
        if (activScreen == 0) {
          manualScreen(ERASESCREEN, OffUpDown);
          break;
        }
        if (activScreen == 1) {
          manualScreen(NOERASESCREEN, RIGHT);
          break;
        }
        if (activScreen == 2) {
          settingsScreen(NOERASESCREEN, RIGHT);
          break;
        }
      }

      if (edit == true) {
        if (activScreen == 2) {
          if (menuPositionSettings == 0) {
            if (menuPositionDigitalSettings == 1) {
              ++upMax;
              lcd.noBlink();
              if (upMax > 9999) upMax = 0;
              lcd.setCursor(10, 0);
              lcd.print("    ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(10, 0);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              ++downMax;
              lcd.noBlink();
              if (downMax > 9999) downMax = 0;
              lcd.setCursor(15, 0);
              lcd.print("    ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(15, 0);
              lcd.blink();
              break;
            }
          }

          if (menuPositionSettings == 1) {
            if (menuPositionDigitalSettings == 1) {
              ++cycle;
              lcd.noBlink();
              if (cycle > 999) cycle = 3;
              lcd.setCursor(13, 1);
              lcd.print("   ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(13, 1);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              ++pauseCycle;
              lcd.noBlink();
              if (pauseCycle > 999) pauseCycle = 2;
              lcd.setCursor(17, 1);
              lcd.print("   ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(17, 1);
              lcd.blink();
              break;
            }
          }

          if (menuPositionSettings == 2) {
            if (menuPositionDigitalSettings == 1) {
              ++dd;
              lcd.noBlink();
              if (dd > 31) dd = 1;
              lcd.setCursor(2, 2);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(2, 2);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              ++mm;
              lcd.noBlink();
              if (mm > 12) mm = 1;
              lcd.setCursor(5, 2);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(5, 2);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 3) {
              ++gg;
              lcd.noBlink();
              lcd.setCursor(8, 2);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(8, 2);
              lcd.blink();
              break;
            }
          }
          //Не забыть переустановить время в RTC
          if (menuPositionSettings == 3) {
            if (menuPositionDigitalSettings == 1) {
              ++hh;
              lcd.noBlink();
              if (hh > 24) hh = 1;
              lcd.setCursor(2, 3);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(2, 3);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 2) {
              ++mnt;
              lcd.noBlink();
              if (mnt > 59) mnt = 0;
              lcd.setCursor(5, 3);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(5, 3);
              lcd.blink();
              break;
            }
            if (menuPositionDigitalSettings == 3) {
              ++id;
              lcd.noBlink();
              if (id > 255) id = 3;
              lcd.setCursor(16, 3);
              lcd.print("  ");
              settingsScreen(NOERASESCREEN, OffUpDown);
              lcd.setCursor(16, 3);
              lcd.blink();
              break;
            }
          }
        }
      }
      break;
  }
}
//******************************************************************************
//Рабочее пространство для разработчика. В код МЕНЮ лазить не надо!!!
//Все переменные автоматически отобразятся в МЕНЮ
//float upMax, downMax; //Максимальные точки подъема\спуска
//int vp, pr; //Управляющие сигналы с датчиков ограничения движения 0/1
//float heigh; //Высота подъема/спуска
//String VP; String PR; String H;
//float depthUpMax, depthDownMax; //Глубина подъема\спуска
//float power; //Потребляемая мощность
//String dimensionPower = "kWh"; //Единицы измерения мощности
//int cycle = 10; //Количество подъемов\спусков
//String modes[4] = { "РУЧНОЙ             ", "ПОЛУАВТО ", "АВТО     ", "ТОЛКНУТЬ   " };

void developer() {
  //Прием данных с пинов********************
  //AcsValue = analogRead(IN_AMPER);  //Read current sensor values
  //AcsValue = (2.5 - (AcsValue * (3.3 / 1024.0))) / 0.185;
  //dimensionPower = String(AcsValue) + "A  ";

  //Управление кнопками*****************************************
  //Включить Двигатель ВВЕРХ
  if (digitalRead(IN_MOTOR_UP) == HIGH or modbasCommand == 1) {
    modbasCommand = 10;
    digitalWrite(OUT_MOTOR_UP, HIGH);
    digitalWrite(OUT_MOTOR_DOWN, LOW);
    //menuPositionManual = 0;
    ClickManualUPOnOff != ClickManualUPOnOff;  //щелкнуть выключатель
    ModeStateOnOff = "ВКЛ";
    ManualUPOnOff = "ВКЛ";
    ManualDOWNOnOff = "ВЫК";  //Нарисовать выключатели
    MODES = modes[0];         //MODES = "РУЧНОЙ         ";
    ModeStateOnOff = "ВКЛ";
    if (activScreen == 1) manualScreen(NOERASESCREEN, OffUpDown);
    else
      manualScreen(ERASESCREEN, OffUpDown);
    //Serial.printf("UP cycleOK=%d _cycle=%d ManualUPOnOff=%s ManualDOWNOnOff=%s Heigh=%d\n", cycleOK, _cycle, ManualUPOnOff, ManualDOWNOnOff, heigh);
    //delay(100);
    return;
  }
  //Включить Двигатель ВНИЗ
  if (digitalRead(IN_MOTOR_DOWN) == HIGH or modbasCommand == 2) {
    modbasCommand = 20;
    digitalWrite(OUT_MOTOR_DOWN, HIGH);
    digitalWrite(OUT_MOTOR_UP, LOW);
    //menuPositionManual = 1;
    ClickManualDOWNOnOff != ClickManualDOWNOnOff;  //щелкнуть выключатель
    ModeStateOnOff = "ВКЛ";

    ManualDOWNOnOff = "ВКЛ";  //Нарисовать выключатели
    ManualUPOnOff = "ВЫК";    //Нарисовать выключатели
    MODES = modes[0];         //MODES = "РУЧНОЙ         ";
    ModeStateOnOff = "ВКЛ";
    if (activScreen == 1) manualScreen(NOERASESCREEN, OffUpDown);
    else
      manualScreen(ERASESCREEN, OffUpDown);
    //Serial.printf("DOWN cycleOK=%d _cycle=%d ManualUPOnOff=%s ManualDOWNOnOff=%s Heigh=%d\n", cycleOK, _cycle, ManualUPOnOff, ManualDOWNOnOff, heigh);
    //delay(100);
    return;
  }
  //Сигналы кнопки Стоп*******************************************************************************
  if (digitalRead(IN_MOTOR_STOP) == HIGH or modbasCommand == 3) {
    modbasCommand = 30;
    digitalWrite(OUT_MOTOR_STOP, HIGH);
    digitalWrite(OUT_MOTOR_UP, LOW);
    digitalWrite(OUT_MOTOR_DOWN, LOW);
    delay(500);
    digitalWrite(OUT_MOTOR_STOP, LOW);
    //Serial.printf("STOP cycleOK=%d _cycle=%d ManualUPOnOff=%s ManualDOWNOnOff=%s Heigh=%d\n", cycleOK, _cycle, ManualUPOnOff, ManualDOWNOnOff, heigh);
    //delay(100);

    if (AutoModeOnOff == "ВКЛ") {
      _cycle = 0;
      cntCycle = 0;
      CyclePause = "       ";
      digitalWrite(OUT_MOTOR_UP, LOW);
      digitalWrite(OUT_MOTOR_DOWN, LOW);

      ManualUPOnOff == "ВКЛ" ? saveLog(1) : saveLog(0);

      ClickManualModeState = !ClickManualModeState;
      MODES = "РУЧНОЙ         ";
      AutoModeOnOff = "ВЫК";
      pauseAuto = false;
      ModeStateOnOff = "ВЫК";
      HalfAutoModeOnOff = "ВЫК";
      ManualDOWNOnOff = "ВЫК";
      ManualUPOnOff = "ВЫК";
      manualScreen(ERASESCREEN, OffUpDown);
      return;
    }

    if (ManualUPOnOff == "ВКЛ") {
      ClickManualUPOnOff = !ClickManualUPOnOff;  //щелкнуть выключатель
      ManualUPOnOff = "ВЫК";                     //Нарисовать выключатели
      ManualModeOnOff = "ВЫК";
      ModeStateOnOff = "ВЫК";
      AutoModeOnOff = "ВЫК";
      PushModeOnOff = "ВЫК";
      HalfAutoModeOnOff = "ВЫК";
      VP = "VP-" + String("1");
      PR = "PR-" + String("0");
      vp = 1;
      pr = 0;
      H = "ВЫСОТА-" + String(heigh) + "M  ";
      if (activScreen == 3) manualScreen(NOERASESCREEN, OffUpDown);
      else
        manualScreen(ERASESCREEN, OffUpDown);
      return;
    }
    if (ManualDOWNOnOff == "ВКЛ") {
      ClickManualDOWNOnOff = !ClickManualDOWNOnOff;  //щелкнуть выключатель
      ManualDOWNOnOff = "ВЫК";                       //Нарисовать выключатели
      ManualModeOnOff = "ВЫК";
      ModeStateOnOff = "ВЫК";
      AutoModeOnOff = "ВЫК";
      PushModeOnOff = "ВЫК";
      HalfAutoModeOnOff = "ВЫК";
      PR = "PR-" + String("1");
      pr = 1;
      VP = "VP-" + String("0");
      vp = 0;
      H = "ВЫСОТА-" + String(heigh) + "M  ";
      if (activScreen == 3) manualScreen(NOERASESCREEN, OffUpDown);
      else
        manualScreen(ERASESCREEN, OffUpDown);
      return;
    }
  }
  //********************************************Управление режимами из меню или MODBUS
  //Включить MANUAL
  if (ManualModeOnOff == "ВКЛ") {
    ModeStateOnOff = "ВЫК";

    PushModeOnOff = "ВЫК";
    HalfAutoModeOnOff = "ВЫК";
    AutoModeOnOff = "ВЫК";
    ManualModeOnOff = "ВЫК";

    MODES = modes[0];  //MODES = "РУЧНОЙ
    if (activScreen == 1) manualScreen(NOERASESCREEN, OffUpDown);
    else
      manualScreen(ERASESCREEN, OffUpDown);
  }
  //Включить PUSH
  if (PushModeOnOff == "ВКЛ") {
    ManualUPOnOff = "ВКЛ";
    ModeStateOnOff = "ВКЛ";

    HalfAutoModeOnOff = "ВЫК";
    AutoModeOnOff = "ВЫК";
    ManualModeOnOff = "ВЫК";

    MODES = modes[3];
    digitalWrite(OUT_MOTOR_UP, HIGH);
  }
  //Включить HALF-AUTO
  if (HalfAutoModeOnOff == "ВКЛ") {
    MODES = modes[1];
    ModeStateOnOff = "ВКЛ";
    PushModeOnOff = "ВЫК";
    AutoModeOnOff = "ВЫК";
    ManualModeOnOff = "ВЫК";
    //Обработка ЦИКЛА, проход ВНИЗ и ВВЕРХ

    if (_cycle == 3) {
      _cycle = 0;
      digitalWrite(OUT_MOTOR_UP, LOW);
      digitalWrite(OUT_MOTOR_DOWN, LOW);
      ClickManualModeState = !ClickManualModeState;
      HalfAutoModeOnOff = "ВЫК";
      ManualDOWNOnOff = "ВЫК";
      ManualUPOnOff = "ВЫК";
      ModeStateOnOff = "ВЫК";
      manualScreen(NOERASESCREEN, OffUpDown);
      //Serial.printf("_cicle=%d\n",_cycle);
      return;
    }
    //Двигаемся ВНИЗ
    if (ManualDOWNOnOff == "ВЫК" and heigh == upMax) {
      ModeStateOnOff = "ВКЛ";
      saveLog(0);
      ManualDOWNOnOff = "ВКЛ";
      digitalWrite(OUT_MOTOR_UP, LOW);
      delay(50);  //Регулировать инерцию трансмиссии
      digitalWrite(OUT_MOTOR_DOWN, HIGH);
      _cycle++;
      //Serial.printf("ManualDOWNOnOff=ВКЛ _cicle=%d\n",_cycle);
      //return;
    }
    //Двигаемся ВВЕРХ
    if (ManualUPOnOff == "ВЫК" and heigh == downMax) {
      ModeStateOnOff = "ВКЛ";
      saveLog(1);
      ManualUPOnOff = "ВКЛ";
      ManualDOWNOnOff = "ВЫК";
      digitalWrite(OUT_MOTOR_DOWN, LOW);
      delay(50);  //Регулировать инерцию трансмиссии
      digitalWrite(OUT_MOTOR_UP, HIGH);
      _cycle++;
      //Serial.printf("ManualUPOnOff=ВКЛ _cicle=%d\n",_cycle);
      //return;
    }
  }
  //Включить AUTO
  if (AutoModeOnOff == "ВКЛ" and pauseAuto == false) {
    MODES = modes[2];
    ModeStateOnOff = "ВКЛ";

    //Двигаемся ВНИЗ
    if (ManualDOWNOnOff == "ВЫК" and heigh == upMax) {
      saveLog(0);
      cntCycle++; //Только включает тригер ПАУЗА
      CyclePause = String(_cycle + 1) + "/" + String(cycle);
      ManualDOWNOnOff = "ВКЛ";
      ManualUPOnOff = "ВЫК";
      ModeStateOnOff = "ВКЛ";
      digitalWrite(OUT_MOTOR_UP, LOW);
      delay(50);  //Регулировать инерцию трансмиссии
      digitalWrite(OUT_MOTOR_DOWN, HIGH);
      return;
    }
    //Двигаемся ВВЕРХ
    if (ManualUPOnOff == "ВЫК" and heigh == downMax) {
      saveLog(1);
      _cycle++;
      //Только включает тригер ПАУЗА
      if (++cntCycle == 2) {
        cntCycle = 0;  //AutoModeOnOff = "ВЫК";
        pauseAuto = true;
      }
      ManualUPOnOff = "ВКЛ";
      ManualDOWNOnOff = "ВЫК";
      ModeStateOnOff = "ВКЛ";
      digitalWrite(OUT_MOTOR_DOWN, LOW);
      delay(50);  //Регулировать инерцию трансмиссии
      digitalWrite(OUT_MOTOR_UP, HIGH);
      Serial.printf("UP _cycle=%d heigh=%d\t", _cycle, heigh);
      if (_cycle == cycle) pauseAuto = false;
    }
    //Сделали все циклы АВТО и уперлись в ВВЕРХ
    if (_cycle == cycle and heigh == upMax) {
      Serial.printf(" STOP _cycle=%d cycle=%d heigh=%d\n", _cycle, cycle, heigh);
      _cycle = 0;
      cntCycle = 0;
      CyclePause = String(_cycle) + "/" + String(cycle);
      digitalWrite(OUT_MOTOR_UP, LOW);
      digitalWrite(OUT_MOTOR_DOWN, LOW);
      ClickManualModeState = !ClickManualModeState;
      PushModeOnOff = "ВЫК";
      ManualModeOnOff = "ВЫК";
      AutoModeOnOff = "ВЫК";
      pauseAuto = false;
      ModeStateOnOff = "ВЫК";
      HalfAutoModeOnOff = "ВЫК";
      ManualDOWNOnOff = "ВЫК";
      ManualUPOnOff = "ВЫК";
      manualScreen(NOERASESCREEN, OffUpDown);
    }
  }

  //Обрабтчик включения ВВЕРХ или ВНИЗ общий***************************************************************
  if (ManualUPOnOff == "ВКЛ" or ManualDOWNOnOff == "ВКЛ") {
    //Формирование строк из данных при обработки логики ON/OFF. Показывать/остановить показ
    //Здесь обработка логики включения\выключения пинов

    if (digitalRead(IN_HEGH)) {
      if (ManualUPOnOff == "ВКЛ") heigh--;
      if (ManualDOWNOnOff == "ВКЛ") heigh++;
      ModeStateOnOff = "ВКЛ";
    }

    //Проверить. Уперлись в датчик или перекрутили по счетчику
    if (heigh < upMax or heigh > downMax or digitalRead(IN_MOTOR_STOP) == HIGH or digitalRead(MAXPOWER) == HIGH) {
      if (PushModeOnOff == "ВКЛ" and digitalRead(MAXPOWER) == HIGH) return;  //игнорировать PUSH
      ClickManualModeState = !ClickManualModeState;
      ManualModeOnOff = "ВЫК";
      ModeStateOnOff = "ВЫК";
      AutoModeOnOff = "ВЫК";
      PushModeOnOff = "ВЫК";
      HalfAutoModeOnOff = "ВЫК";
      ManualDOWNOnOff = "ВЫК";
      digitalWrite(OUT_MOTOR_DOWN, LOW);
      digitalWrite(OUT_MOTOR_UP, LOW);
      ClickManualUPOnOff = !ClickManualUPOnOff;  //нажать кнопку программно
      ManualUPOnOff = "ВЫК";
      ManualDOWNOnOff = "ВЫК";  //Нарисовать выключатели

      if (heigh >= downMax) {
        digitalWrite(OUT_MOTOR_UP, HIGH);
        heigh--;
        delay(50);  //Время на инерцию трансмиссии
        digitalWrite(OUT_MOTOR_UP, LOW);
        saveLog(0);
        //manualScreen(ERASESCREEN, OffUpDown);
      }
      if (heigh <= upMax) {
        digitalWrite(OUT_MOTOR_DOWN, HIGH);
        heigh++;
        delay(50);  //Время на инерцию трансмиссии
        digitalWrite(OUT_MOTOR_DOWN, LOW);
        saveLog(1);
        //manualScreen(ERASESCREEN, OffUpDown);
      }
    }
    //dimensionPower = String(AcsValue) + "A  ";
    H = "ВЫСОТА-" + String(heigh) + "M  ";
    VP = "VP-" + String("0");
    vp = 0;
    PR = "PR-" + String("0");
    pr = 0;
    if (activScreen == 1) manualScreen(NOERASESCREEN, OffUpDown); //OffUpDown
    return;
  }
}
//******************************************************************************

void setup() {
  Serial.begin(115200);
  // Serial2.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN);
  Serial2.begin(19200);
  slave.start();
  //slave.begin(9600);

  lcd.init();       // This is the I2C LCD object initialization.
  lcd.backlight();  //  Включаем подсветку LCD дисплея

  //https://microcontrollerslab.com/save-data-esp32-flash-permanently-preferences-library/
  preferences.begin("memory", false);  //Инициализация записи в EEPROM
  //preferences.clear(); //разовая очистка памяти для отладки. Закоментарить!
  //Если ключа нет сохраняем предустановленные параметры
  if (preferences.getUInt("flagSave", 0) == 0) saveSettings();
  else
    readSettings();
  slave.setID(id);
  //Serial.printf("Save Memory %d %d %d %d\n", upMax, downMax, cycle, pauseCycle);

  //SD карта. Подключение файловой системы
  /*if (!sd.begin(CS_PIN, SPI_SPEED)) {
    if (sd.card()->errorCode()) {
      Serial.println("SD initialization failed.");
    } else if (sd.vol()->fatType() == 0) {
      Serial.println("Can't find a valid FAT16/FAT32 partition.");
    } else {
      Serial.println("Can't determine error type");
    }
    return;
    }
    Serial.println("Files on card:");
    Serial.println("   Size    Name");
    sd.ls(LS_R | LS_SIZE);*/
  //******************************************************

  if (!rtc.begin())
    ;                                              //Serial.println("Couldn't find RTC");
  rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));  //устанавливается системное время при компиляции один раз и при сбросе батареи

  pinMode(pin_CLK, INPUT);
  digitalWrite(pin_CLK, LOW);
  pinMode(pin_DT, INPUT);
  digitalWrite(pin_DT, LOW);
  pinMode(pin_Btn, INPUT);
  digitalWrite(pin_Btn, LOW);
  pinMode(IN_HEGH, INPUT);  //высота подема. 1 тик 1 метр
  pinMode(MAXPOWER, INPUT);
  digitalWrite(MAXPOWER, LOW);
  pinMode(IN_MOTOR_STOP, INPUT);
  digitalWrite(IN_MOTOR_STOP, LOW);
  pinMode(IN_MOTOR_UP, INPUT);
  digitalWrite(IN_MOTOR_UP, LOW);
  pinMode(IN_MOTOR_DOWN, INPUT);
  digitalWrite(IN_MOTOR_DOWN, LOW);
  pinMode(OUT_MOTOR_STOP, OUTPUT);
  digitalWrite(OUT_MOTOR_STOP, LOW);
  pinMode(OUT_MOTOR_UP, OUTPUT);
  digitalWrite(OUT_MOTOR_UP, LOW);
  pinMode(OUT_MOTOR_DOWN, OUTPUT);
  digitalWrite(OUT_MOTOR_DOWN, LOW);
  helloScreen(ERASESCREEN);
  delay(3000);

  now = rtc.now();
  dd = now.day();
  mm = now.month();
  gg = now.year();
  hh = now.hour();
  mnt = now.minute();

  userScheduler.init();
  userScheduler.addTask(taskTime);
  userScheduler.addTask(taskPause);

  //Проверить верхнее положение элеватора. Поднять элеватор наверх. Мотор UP
  MODES = "УСТАНОВКА... ";
  ModeStateOnOff = "   ";
  ClickManualUPOnOff != ClickManualUPOnOff;  //щелкнуть выключатель
  ManualUPOnOff = "ВКЛ";
  ManualDOWNOnOff = "ВЫК";               //Нарисовать выключатели
  manualScreen(ERASESCREEN, OffUpDown);  //нарисовать экран
  digitalWrite(OUT_MOTOR_UP, HIGH);      //Поехали ВВЕРХ
  //Выключить по дачику vp (пин 27) и датчику MAXPOWER
  bool whl = true;
  do {
    digitalWrite(OUT_MOTOR_UP, HIGH);
    H = "ВЫСОТА-...";
    vp = digitalRead(IN_MOTOR_STOP);  //на один пин заведены СТОП, VP, PR
    VP = "VP-" + String(vp);
    PR = "PR-" + String("0");
    //https://www.engineersgarage.com/acs712-current-sensor-with-arduino/
    //AcsValue = analogRead(IN_AMPER);  //Read current sensor values
    //AcsValue = (2.5 - (AcsValue * (3.3 / 1024.0))) / 0.185;
    //dimensionPower = String(AcsValue) + "A  ";
    manualScreen(NOERASESCREEN, OffUpDown);  //нарисовать экран
    if (digitalRead(IN_MOTOR_STOP) == HIGH or digitalRead(MAXPOWER) == HIGH)
      whl = false;  //стоп по СТОП или перегрузу или верхнему датчику VP
  } while (whl);
  digitalWrite(OUT_MOTOR_UP, LOW);  //STOP мотор вверх. ДОЕХАЛИ ВВЕРХ
  delay(200);
  digitalWrite(OUT_MOTOR_DOWN, HIGH);
  delay(200);  //Регулировка зазора VP
  while (digitalRead(IN_MOTOR_STOP) == HIGH)
    ;  //Ждем размыкания VP
  digitalWrite(OUT_MOTOR_DOWN, LOW);
  H = "";
  heigh = 0;  //Обнуляем счетчик высоты

  //Опустить на высоту установленную в SETTINGS
  while (heigh < upMax or digitalRead(MAXPOWER) == HIGH or digitalRead(IN_MOTOR_STOP) == HIGH) {
    digitalWrite(OUT_MOTOR_DOWN, HIGH);
    heigh++;
    manualScreen(NOERASESCREEN, OffUpDown);  //нарисовать экран
  }
  ClickManualUPOnOff != ClickManualUPOnOff;  //щелкнуть выключатель

  VP = "VP-" + String(1);  //36
  vp = 1;
  PR = "PR-" + String("0");  //39
  pr = 0;
  H = "ВЫСОТА-" + String(heigh) + "M  ";
  //Еще раз все выключили
  digitalWrite(OUT_MOTOR_DOWN, LOW);
  digitalWrite(OUT_MOTOR_UP, LOW);
  ClickManualUPOnOff != ClickManualUPOnOff;  //щелкнуть выключатель
  ManualUPOnOff = "ВЫК";
  ManualDOWNOnOff = "ВЫК";  //Нарисовать выключатели

  MODES = "РУЧНОЙ        ";
  ModeStateOnOff = "   ";
  manualScreen(ERASESCREEN, 30);  //нарисовать экран
  //delay(5000);
  taskTime.enable();
  taskPause.enable();
  //taskDrow.disable();
  preferences.end();

  //Файл Config
  //Serial.print("Initializing SD card... ");
  if (!SD.begin(CS_PIN)) {
    Serial.println("Card initialization failed!");
    //while (true);
  }
  //Serial.println("initialization done.");
  root = SD.open("/");
  //SD.remove("/log.csv"); //для единопазовой очистки
  printDirectory(root, 0);
  //Serial.println("");
  root.close();
  if (!SD.exists("/log.csv")) {
    String strn = "Date,Time,Mode,Vector,Heigh";
    root = SD.open("/log.csv", FILE_WRITE);
    root.println(strn);
    root.flush();
  } else {
    root = SD.open("/log.csv");
    if (!root)  //Serial.println("Failed to open file for reading");
      //Serial.print("Read from file: ");
      while (root.available()) {
        //Serial.write(root.read());
      }
    root.close();
    root = SD.open("/log.csv", FILE_APPEND);
  }
  modbus_array[0] = upMax;
}

void loop() {
  GetEncoderState();
  reciveBtnCode();
  _switch = 0;
  developer();
  userScheduler.execute();
  functionMODBUS();
}

void saveLog(int vector) {
  if (!root.available()) {
    root.close();
    root = SD.open("/log.csv", FILE_APPEND);
  }
  String v = "";
  vector == 1 ? v = "UP" : v = "DOWN";
  String str = String(dd) + "/" + String(mm) + "/" + String(gg) + "," + String(hh) + ":" + String(mnt) + "," + MODES + "," + v + "," + String(heigh);
  //Serial.println(str);
  root.println(str);
  root.flush();
}

void printDirectory(File dir, int numTabs) {
  while (true) {

    File entry = dir.openNextFile();
    if (!entry) {
      // no more files
      break;
    }
    for (uint8_t i = 0; i < numTabs; i++) {
      //Serial.print('\t');
    }
    //Serial.print(entry.name());
    if (entry.isDirectory()) {
      //Serial.println("/");
      printDirectory(entry, numTabs + 1);
    } else {
      // files have sizes, directories do not
      //Serial.print("\t\t");
      //Serial.println(entry.size(), DEC);
    }
    entry.close();
  }
}



void saveTime() {
  //DateTime newDT = DateTime(gg, mm, dd, hh, mnt, 0);
  rtc.adjust(DateTime(gg, mm, dd, hh, mnt, 0));
}

void saveSettings() {
  preferences.begin("memory", false);
  preferences.putUInt("upMax", upMax);
  preferences.putUInt("downMax", downMax);
  preferences.putUInt("cycle", cycle);
  preferences.putUInt("pauseCycle", pauseCycle);
  preferences.putUInt("flagSave", 1);
  preferences.putUInt("id", id);
  preferences.end();
  //Serial.printf("Save Memory %d %d %d %d\n", upMax, downMax, cycle, pauseCycle);
}
void readSettings() {
  preferences.begin("memory", false);
  upMax = preferences.getUInt("upMax", upMax);
  downMax = preferences.getUInt("downMax", downMax);
  cycle = preferences.getUInt("cycle", cycle);
  pauseCycle = preferences.getUInt("pauseCycle", pauseCycle);
  //flagSave = preferences.getUInt("flagSave", flagSave);
  id = preferences.getUInt("id", id);
  preferences.end();
  //Serial.printf("Read Memory %d %d %d %d\n", upMax, downMax, cycle, pauseCycle);
}
/*
   upMax, downMax, cycle, _cycle cntCycle pauseCycle vp pr heigh
   ManualOnOff ManualUPOnOff ManualDOWNOnOff ManualModeOnOff ModeStateOnOff
   AutoModeOnOff PushModeOnOff HalfAutoModeOnOff
*/
void functionMODBUS() {
  if (!edit) {
    int state = slave.poll(modbus_array, 16);
    if (state > 0) Serial.printf("State %d\n", state);
    //Master читает
    if (state == 37) {
      //Serial.printf("Master read %d\n",state);
      //Serial.printf("In %d Out %d ErrCnt %d LastErr %d\n\n", slave.getInCnt(), slave.getOutCnt(), slave.getErrCnt(), slave.getLastError());

      modbus_array[0] = upMax;
      modbus_array[1] = downMax;
      modbus_array[2] = cycle;
      modbus_array[3] = pauseCycle;
      modbus_array[4] = vp;
      modbus_array[5] = pr;
      modbus_array[6] = heigh;
      modbus_array[7] = _cycle;
      modbus_array[8] = ModeStateOnOff == "ВКЛ" ? 1 : 0;
      modbus_array[9] = ManualUPOnOff == "ВКЛ" ? 1 : 0;
      modbus_array[10] = ManualDOWNOnOff == "ВКЛ" ? 1 : 0;
      modbus_array[11] = ManualModeOnOff == "ВКЛ" ? 1 : 0;
      modbus_array[12] = AutoModeOnOff == "ВКЛ" ? 1 : 0;
      modbus_array[13] = PushModeOnOff == "ВКЛ" ? 1 : 0;
      modbus_array[14] = HalfAutoModeOnOff == "ВКЛ" ? 1 : 0;
      modbus_array[15] = modbasCommand;
    }
    //Master пишет
    if (state == 8) {
      Serial.printf("Master write %d\n", state);
      Serial.printf("In %d Out %d ErrCnt %d LastErr %d\n\n", slave.getInCnt(), slave.getOutCnt(), slave.getErrCnt(), slave.getLastError());
      upMax = modbus_array[0];
      downMax = modbus_array[1];
      cycle = modbus_array[2];
      pauseCycle = modbus_array[3];

      modbus_array[11] == 1 ? ManualModeOnOff = "ВКЛ" : ManualModeOnOff = "ВЫК";
      modbus_array[12] == 1 ? AutoModeOnOff = "ВКЛ" : AutoModeOnOff = "ВЫК";
      modbus_array[13] == 1 ? PushModeOnOff = "ВКЛ" : PushModeOnOff = "ВЫК";
      modbus_array[14] == 1 ? HalfAutoModeOnOff = "ВКЛ" : HalfAutoModeOnOff = "ВЫК";

      if (modbus_array[15] == 1) modbasCommand = 1;  //кнопка ВВЕРХ ManualUPOnOff
      if (modbus_array[15] == 2) modbasCommand = 2;  //кнопка ВНИЗ ManualDOWNOnOff
      if (modbus_array[15] == 3) modbasCommand = 3;  //кнопка СТОП
      if (modbus_array[15] == 0) modbasCommand = 0;  //сброс modbasCommand
      //if (activScreen == 3) manualScreen(NOERASESCREEN, OffUpDown);
      //if (activScreen == 4) settingsScreen(NOERASESCREEN, OffUpDown);

      if (state == 8) saveSettings();
    }
  }
}