//////////////////////////////////////////////////////////////////////////////////////////////
// Скетч многофункционального универсального тестера интерфейса Modbus (МУТИМ) на Arduino Mega
//////////////////////////////////////////////////////////////////////////////////////////////
// Состав материалов:
// - Arduino Mega
// - Дисплей 128X64 (можно заменить на любой другой поддерживаемый библиотекой U8g2lib.h)
// - Энкодер
// - Модуль RS485
// - Повышающий DC-DC 5V
// - Резисторы,
// - Конденсаторы, 
// - Кнопки, 4шт
// - Переключатель
// - Разьемы
// - Аккумулятор 18532
// - Светодиоды
// - Клеммники

// Подключение контроллера:
// -

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

#define UP1 11
#define DOWN1 10
#define CLK1 9
#define DT1 8
#define SW1 7
#define ESC1 6

#define ENCODER_CLK 9
#define ENCODER_DT  8

//U8G2_ST7565_ZOLEN_128X64_F_4W_SW_SPI lcd(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); //для дисплея V2.2 раскоментировать Flip в библиотеке u8x8_d_st7565.с 
U8G2_SSD1306_128X64_NONAME_F_SW_I2C lcd(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display

////////////////////////// настройки при старте контроллера
void setup() {
  lcd.begin();                      // инициализация дисплея
  lcd.setContrast(50);              // контраст дисплея
  lcd.enableUTF8Print();            // выбор русской кодировки
  
  Serial1.begin(9600);              // открытия порта №1 для вывода отладочной информации

  pinMode(UP1, INPUT_PULLUP);       // подтяжка к питанию входов кнопок
  pinMode(DOWN1, INPUT_PULLUP);
  pinMode(CLK1, INPUT_PULLUP);
  pinMode(DT1, INPUT_PULLUP);
  pinMode(SW1, INPUT_PULLUP);
  pinMode(ESC1, INPUT_PULLUP);
  
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////// обьявления переменных ///////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
int page = 0;             // стартовая страница
int select0, select1, select2, select3, select4, select5 = 0;  // выбор пункта меню на странице 0,1,2,3
int percent = 194;        // процент заряда батареи
char str[5];              // переменная для перевода напряжения в строку
float voltag = 3.752;     // напряжение батареи
String functionM[] =   {"0x01 RCoil","0x02 RDiscI","0x03 RHResg","0x04 RIRegs","0x05 WSCoil","0x06 WSRegs","0x0F WMCoil","0x10 WMRegs"};   // массив функций модбас
String functionM1[] =  {"0x01","0x02","0x03","0x04","0x05","0x06","0x0F","0x10"};   // массив функций модбас сокращенный
int numfuncM = 7;         // номер функции в массиве
long speed[] =         {300,1200,2400,4800,9600,19200,38400,57600,115200}; // скорости 
int numspeed = 8;         // номер скорости в массиве
String format[] =      {"8N1","8E1","8O1","8N2","8E2","8O2","7N1","7E1","7O1","7N2","7E2","7O2"}; // формат
int numformat = 0;        // номер формата в массиве
int timeout = 500;        // таймаут ответа от слейва
uint16_t registor = 40001;// номер регистра
int ID = 2;               // номер адреса слейва
int count = 10;           // количество регистров
String type[] =        {"int16","uint16","float","hex","int32","uint32","ASCII","BCD"};
int numtype = 4;          // номер типа числа
int numlist = 0;          // номер страницы с результатами
int countOK = 0;          // подсчет успешных пакетов
int timeresponse = 0;     // ошибка ответа от слейва
String error = "ОШИБКА!"; // ошибка ответа или время ответа от слейва если ошибки нет
String res[] =        {"-65536.4543562","345689.4511","12345678901","---"}; // результат считывания регистров
bool resCoil[] =      {1,0,1,1,0,0,0,1,1,0};
bool writing = 0;         // команда записи регистра или бита по выбранной функции
int writeReg[] =      {-32136,231,121,21,20,31,40,51,61,71}; // содержания записи регистров
bool writeCoil[] =    {1,1,1,1,0,1,0,1,1,1}; // содержание записи битов
int numreg = 0;           // номер регистра или бита записи
int maxselect = 0;        // максимальный выбранный пункт







///////////////////////////////////////////////////////////////////////////////////////
////////////////////////// основной цикл программы Main ///////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////

void loop() {
  Buttons();              // считывание кнопок
  DrawDisplay();          // отрисовка дисплея
  
    
}

////////////////////////// картинки иконок сгенерированы из BMP программой Конвертор by Kinguf
static const unsigned char modbusRTU[]U8X8_PROGMEM  = {
  0xFF, 0x3F, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x89, 0x24, 0xD5, 0x2A, 0x95, 0x2A, 0x95, 0x2A, 0x95, 0x2A, 0x89, 0x24, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0xFF, 0x3F,
};
static const unsigned char modbusTCP[]U8X8_PROGMEM  = {
  0xFF, 0x3F, 0x01, 0x20, 0x01, 0x20, 0xF1, 0x23, 0x11, 0x23, 0x1D, 0x2F, 0x05, 0x2C, 0x05, 0x2C, 0x55, 0x2D, 0x55, 0x2D, 0xFD, 0x2F, 0x01, 0x20, 0x01, 0x20, 0xFF, 0x3F, 
};
static const unsigned char terminal[]U8X8_PROGMEM  = {
  0xFF, 0x3F, 0xF9, 0x3F, 0xF9, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0xF9, 0x27, 0x01, 0x20, 0xF9, 0x27, 0x01, 0x20, 0xF9, 0x27, 0x01, 0x20, 0xF9, 0x27, 0x03, 0x30, 0xFF, 0x3F, 
};
static const unsigned char oscil[] U8X8_PROGMEM  = {
0xFF, 0x3F, 0x41, 0x30, 0x49, 0x30, 0x1D, 0x20, 0x49, 0x30, 0x41, 0x30, 0xB7, 0x2D, 0x41, 0x30, 0x41, 0x30, 0x01, 0x20, 0x41, 0x30, 0x41, 0x30, 0xB7, 0x2D, 0xFF, 0x3F, 
};
static const unsigned char master[] U8X8_PROGMEM  = {
0xFF, 0x3F, 0x01, 0x20, 0x0D, 0x2C, 0x1D, 0x2E, 0xBD, 0x2F, 0xAD, 0x2D, 0xED, 0x2D, 0xCD, 0x2C, 0x0D, 0x2C, 0x0D, 0x2C, 0x0D, 0x2C, 0x0D, 0x2C, 0x01, 0x20, 0xFF, 0x3F, 
};  
static const unsigned char slave[] U8X8_PROGMEM  = {
0xFF, 0x3F, 0x01, 0x20, 0xF9, 0x21, 0x1D, 0x27, 0x1D, 0x26, 0x79, 0x20, 0xE1, 0x20, 0xC1, 0x27, 0x05, 0x2F, 0x0D, 0x2E, 0xB9, 0x27, 0xF1, 0x21, 0x01, 0x20, 0xFF, 0x3F, 
};  
static const unsigned char monitor[] U8X8_PROGMEM  = {
0xFF, 0x3F, 0x01, 0x20, 0x01, 0x21, 0xFD, 0x2F, 0x49, 0x24, 0x5D, 0x24, 0x55, 0x24, 0x5D, 0x2E, 0x49, 0x2A, 0xE9, 0x2E, 0xBD, 0x20, 0xE1, 0x20, 0x01, 0x20, 0xFF, 0x3F, 
};  
static const unsigned char wave[] U8X8_PROGMEM  = {
0xFF, 0x3F, 0x01, 0x20, 0x11, 0x20, 0x29, 0x20, 0x29, 0x20, 0x29, 0x20, 0x45, 0x20, 0xFD, 0x2F, 0x41, 0x28, 0x81, 0x24, 0x81, 0x24, 0x01, 0x23, 0x01, 0x20, 0xFF, 0x3F, 
};  
static const unsigned char logic[] U8X8_PROGMEM  = {
0xFF, 0x3F, 0x01, 0x20, 0x01, 0x20, 0x3F, 0x3E, 0x61, 0x23, 0xC9, 0x29, 0x95, 0x2C, 0x95, 0x28, 0xD5, 0x29, 0x49, 0x3D, 0x61, 0x23, 0x3F, 0x3E, 0x01, 0x20, 0xFF, 0x3F, 
};  
///////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////// метод вывода на экран изображения
///////////////////////////////////////////////////////////////////////////////////

/////////////////// функция добавления нулей перед цифрами
String ZeroReg(uint16_t reg1,int razr){
  String str1;
  int uslov = razr - (int)log10(reg1) ;
  switch (uslov) {
        case 1: str1 = String(reg1); break;
        case 2: str1 = "0"+String(reg1); break;
        case 3: str1 = "00"+String(reg1); break;
        case 4: str1 = "000"+String(reg1); break;
        case 5: str1 = "0000"+String(reg1); break;
      }
  return str1; 
}

void DrawDisplay() {
  lcd.clearBuffer();			// очистка экрана
  switch (page) {

////////////////////// главное меню    
    case 0:      
      lcd.setFont(u8g2_font_haxrcorp4089_t_cyrillic);	    
      lcd.setCursor(106,8);
      lcd.print(String(percent) + "%");

      lcd.setFont(u8g2_font_t0_11b_mf); 
      lcd.setCursor(36,12);
      lcd.print("Modbus RTU");
      lcd.setCursor(36,28);
      lcd.print("Modbus TCP");
      lcd.setCursor(36,44);
      lcd.print("Terminal");
      lcd.setCursor(36,60);
      lcd.print("Oscilloscope");
      lcd.drawXBMP(10, 1, 14, 14, modbusRTU);
      lcd.drawXBMP(10, 17, 14, 14, modbusTCP);
      lcd.drawXBMP(10, 33, 14, 14, terminal);
      lcd.drawXBMP(10, 49, 14, 14, oscil);
      switch (select0) {
        case 0: lcd.drawRFrame(32,1,67,14,3); break;
        case 1: lcd.drawRFrame(32,17,67,14,3); break;
        case 2: lcd.drawRFrame(32,33,54,14,3); break;
        case 3: lcd.drawRFrame(32,49,79,14,3); break;
      } 
      break;

///////////////////// меню modbus RTU
    case 1:  
      lcd.setFont(u8g2_font_haxrcorp4089_t_cyrillic);	    
      lcd.setCursor(106,8);
      lcd.print(String(percent) + "%");

      lcd.setFont(u8g2_font_t0_11b_mf); 
      lcd.setCursor(46,12);
      lcd.print("Master");
      lcd.setCursor(46,28);
      lcd.print("Slave");
      lcd.setCursor(46,44);
      lcd.print("Monitor");
      lcd.drawXBMP(20, 1, 14, 14, master);
      lcd.drawXBMP(20, 17, 14, 14, slave);
      lcd.drawXBMP(20, 33, 14, 14, monitor);
      switch (select1) {
        case 0: lcd.drawRFrame(42,1,43,14,3); break;
        case 1: lcd.drawRFrame(42,17,37,14,3); break;
        case 2: lcd.drawRFrame(42,33,49,14,3); break;
      } 
      break; 

///////////////////// меню modbus TCP
    case 2:
      lcd.setFont(u8g2_font_haxrcorp4089_t_cyrillic);	    
      lcd.setCursor(106,8);
      lcd.print(String(percent) + "%");

      lcd.setFont(u8g2_font_t0_11b_mf); 
      lcd.setCursor(46,12);
      lcd.print("Master");
      lcd.setCursor(46,28);
      lcd.print("Slave");
      lcd.drawXBMP(20, 1, 14, 14, master);
      lcd.drawXBMP(20, 17, 14, 14, slave);
      switch (select2) {
        case 0: lcd.drawRFrame(42,1,43,14,3); break;
        case 1: lcd.drawRFrame(42,17,37,14,3); break;
      } 
      break; 

///////////////////// меню осциллографа
    case 3:
      lcd.setFont(u8g2_font_haxrcorp4089_t_cyrillic);	    
      lcd.setCursor(106,8);
      lcd.print(String(percent) + "%");

      lcd.setFont(u8g2_font_t0_11b_mf); 
      lcd.setCursor(46,12);
      lcd.print("Logic");
      lcd.setCursor(46,28);
      lcd.print("Wave");
      lcd.drawXBMP(20, 1, 14, 14, logic);
      lcd.drawXBMP(20, 17, 14, 14, wave);
      switch (select3) {
        case 0: lcd.drawRFrame(42,1,37,14,3); break;
        case 1: lcd.drawRFrame(42,17,31,14,3); break;
      } 
      break; 

///////////////////// меню настроек master RTU
    case 4:
      lcd.setFont(u8g2_font_haxrcorp4089_t_cyrillic);	    // выбор шрифта
      lcd.setCursor(66,8);
      dtostrf(voltag,1,3,str);
      lcd.print(String(str) + "B");
      lcd.setCursor(106,8);
      lcd.print(String(percent) + "%");

      lcd.setFont(u8g2_font_t0_11b_mf); 
      lcd.setCursor(1,8);
      lcd.print("ModbusRTU");
      lcd.drawHLine(0,9,128);
         
      lcd.setCursor(26,22); 
      lcd.print(functionM[numfuncM]);
     
      lcd.setCursor(31,35); 
      lcd.print(String(timeout) + "mc");

      lcd.setCursor(109,35); 
      lcd.print(ID);
 
      lcd.setCursor(28,48); 
      lcd.print(speed[numspeed]);
       
      lcd.setCursor(102,48); 
      lcd.print(format[numformat]);
      
      lcd.setCursor(24,61); 
      lcd.print(registor);
      
      lcd.setCursor(96,61); 
      lcd.print(count);
      
      lcd.setFont(u8g2_font_haxrcorp4089_t_cyrillic);
      lcd.setCursor(0,22);
      lcd.print("фун="); 

      lcd.setCursor(0,35);
      lcd.print("тайм=");; 

      lcd.setCursor(73,35);
      lcd.print("адрес=");

      lcd.setCursor(0,48);
      lcd.print("скор=");

      lcd.setCursor(73,48);
      lcd.print("четн=");

      lcd.setCursor(0,61);
      lcd.print("рег="); 
   
      lcd.setCursor(73,61);
      lcd.print("кол="); 
      
      switch (select4) {
        case 0: lcd.drawRFrame(24,12,69,12,3);  break;
        case 1: lcd.drawRFrame(29,25,39,12,3);  break;
        case 2: lcd.drawRFrame(107,25,21,12,3); break;
        case 3: lcd.drawRFrame(26,38,39,12,3);  break;
        case 4: lcd.drawRFrame(100,38,21,12,3); break;
        case 5: lcd.drawRFrame(22,51,33,12,3);  break;
        case 6: lcd.drawRFrame(94,51,15,12,3);  break;
      } 
      
      break; 

///////////////////// меню результатов master RTU      
    case 5: 
      lcd.setFont(u8g2_font_trixel_square_tr);
      lcd.setCursor(0,5);
      //формат строки пример: "256_115200_8N1_2500_0x15_47031_20_100%"
      lcd.print(String(ID)+"_"+String(speed[numspeed])+"_"+format[numformat]+"_"+String(timeout)+"_"+functionM1[numfuncM]+"_"+ZeroReg(registor,5)+"_"+count+"_"+String(percent)+"%");
      
      lcd.drawHLine(0,6,128);	
      lcd.setFont(u8g2_font_haxrcorp4089_t_cyrillic);          
      lcd.setCursor(0,18);
      lcd.print(error); 
      lcd.drawVLine(103,7,12); 
      
      lcd.setFont(u8g2_font_t0_11b_mf); 
      lcd.setCursor(105,18); 
      lcd.print(ZeroReg(countOK,4)); 
      lcd.drawHLine(103,19,25);

      if ((numfuncM == 2)||(numfuncM == 3)||(numfuncM == 5)||(numfuncM == 7)) {
        lcd.setCursor(59,18); 
        lcd.print(type[numtype]);
      }
      int x1 = 0; // смещение по х для второго столбика результатов
      int y1 = 0; // смещение по y для второго столбика результатов
      
      switch (numfuncM) {
        case 0:    // функция Coil
        case 1:    // функция Discret Input
          for (int i=0; i <= 7; i++){
            if (count > i+8*numlist) {
              if (i > 3){
                x1 = 58;
                y1 = 4; } 
              else {
                x1 = 0;
                y1 = 0;} 
              lcd.setCursor(2+x1,31+(i-y1)*10);
              lcd.print(ZeroReg(registor+i+8*numlist,5));
              lcd.setCursor(34+x1,31+(i-y1)*10);
              lcd.print("=");
              lcd.setCursor(42+x1,31+(i-y1)*10);
              lcd.print(resCoil[i+8*numlist]);
            }
          }
          lcd.drawRFrame(0,21,109,43,3); 
          
          lcd.drawHLine(115,51,14);
          lcd.drawVLine(115,51,13);
          lcd.setCursor(117,62);
          lcd.print(ZeroReg(numlist+1,2));
        break;

        case 2:    // функция Holding Reg
        case 3:    // функция Input Reg
          for (int i=0; i <= 3; i++){
            if (count > i+4*numlist) {
              lcd.setCursor(2,31+i*10);
              lcd.print(ZeroReg(registor+i+4*numlist,5));
              lcd.setCursor(34,31+i*10);
              lcd.print("=");
              lcd.setCursor(42,31+i*10);
              lcd.print(res[i+4*numlist]);
            }
          }
          switch (select5) {
            case 0: lcd.drawRFrame(0,21,109,43,3); break;
            case 1: lcd.drawRFrame(56,8,46,12,3);  break;
          } 
          lcd.drawHLine(115,51,14);
          lcd.drawVLine(115,51,13);
          lcd.setCursor(117,62);
          lcd.print(ZeroReg(numlist+1,2));
        break;

        case 4:    // функция Write Coil
          lcd.setCursor(2,31);
          lcd.print(ZeroReg(registor,5));
          lcd.setCursor(34,31);
          lcd.print("=");
          lcd.setCursor(47,31);
          lcd.print(writeCoil[0]);
          switch (select5) {
            case 0: lcd.drawRFrame(40,21,19,12,3);break;
            case 1: lcd.drawRFrame(0,21,33,12,3); break;
          }
          break;

        case 5:    // функция Write Reg
          lcd.setCursor(2,31);
          lcd.print(ZeroReg(registor,5));
          lcd.setCursor(34,31);
          lcd.print("=");
          lcd.setCursor(42,31);
          lcd.print(writeReg[0]);
          switch (select5) {
            case 0: lcd.drawRFrame(40,21,87,12,3);break;
            case 1: lcd.drawRFrame(56,8,46,12,3); break;
            case 2: lcd.drawRFrame(0,21,33,12,3); break;
          }
          break;

        case 6:    // функция Write MCoil
          for (int i=0; i <= 7; i++){
            if (count > i) {
              if (i > 3){x1 = 58; y1 = 4;} 
                else    {x1 = 0;  y1 = 0;} 
              lcd.setCursor(2+x1,31+(i-y1)*10);
              lcd.print(ZeroReg(registor+i,5));
              lcd.setCursor(34+x1,31+(i-y1)*10);
              lcd.print("=");
              lcd.setCursor(47+x1,31+(i-y1)*10);
              lcd.print(writeCoil[i]);
            }
          } 
          switch (select5) {
            case 0: lcd.drawRFrame(0,21,33,12,3); break;
            case 1: 
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
            case 8:
             for (int i=0; i  <= maxselect; i++){
              if (i > 3){x1 = 58; y1 = 4;} 
                else    {x1 = 0;  y1 = 0;} 
              if (i == select5-1) {
                lcd.drawRFrame(41+x1,21+(i-y1)*10,17,12,3);
              }
            } 
            break;
          }
          break;
        case 7:    // функция Write MReg
          
          for (int i=0; i <= 3; i++){
            if (count > i) {
              lcd.setCursor(2+x1,31+(i-y1)*10);
              lcd.print(ZeroReg(registor+i,5));
              lcd.setCursor(34+x1,31+(i-y1)*10);
              lcd.print("=");
              lcd.setCursor(42+x1,31+(i-y1)*10);
              lcd.print(writeReg[i]);
            }
          } 
          Serial1.print(select5); Serial1.print("_"); Serial1.println(maxselect);
          
          switch (select5) {
            case 0: lcd.drawRFrame(0,21,33,12,3); break;
            case 1: lcd.drawRFrame(56,8,46,12,3); break;
            case 2:
            case 3:
            case 4:
            case 5:
            for (int i=0; i  <= maxselect; i++){
              if (i == select5-2) {
                lcd.drawRFrame(40,21+i*10,87,12,3);
              }
            } 
            break;
          }
          break;
      }
      break; 
///////////////////// меню результатов slave RTU      
    case 6: 


    break;
      
    







  }
  lcd.sendBuffer();				   // отрисовка дисплея
}
///////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////// метод считывания кнопок и управления меню
///////////////////////////////////////////////////////////////////////////////////////////
void Buttons() {
  bool UP     = digitalRead(UP1);
  bool DOWN   = digitalRead(DOWN1);
  bool LEFT   = digitalRead(CLK1);
  bool RIGHT  = digitalRead(DT1);
  bool SEL    = digitalRead(SW1);
  bool ESC    = digitalRead(ESC1);

  switch (page) {
///////////////////// главное меню     
    case 0:
      if (DOWN == 0) {
        Serial1.println("DOWN-0");
        select0++;
        if (select0 > 3) { select0 = 0;}
      }
      if (UP == 0) {
        Serial1.println("UP-0");
        select0--;
        if (select0 < 0) { select0 = 3;}
      }
      if (SEL == 0) {
        Serial1.println("SEL-0");
        switch (select0) {
          case 0: page = 1; break;
          case 1: page = 2; break;
          case 2: page = 0; break;  //////////////поменять на терминал
          case 3: page = 3; break;
        }
      }  
    break;
/////////////////////  меню modbus RTU
    case 1:
      if (DOWN == 0) {
        Serial1.println("DOWN-1");
        select1++;
        if (select1 > 2) { select1 = 0;}
      }
      if (UP == 0) {
        Serial1.println("UP-1");
        select1--;
        if (select1 < 0) { select1 = 2;}
      }
      if (SEL == 0) {
        Serial1.println("SEL-1");
        switch (select1) {
          case 0: page = 4; break;  
          case 1: page = 0; break;  ////поменять 
          case 2: page = 0; break;  ////поменять 
        }
      }  
      if (ESC == 0) {
        Serial1.println("ESC-1");
        page = 0;
      }  
    break;  
/////////////////////  меню modbus TCP
    case 2:
      if (DOWN == 0) {
        Serial1.println("DOWN-2");
        select2++;
        if (select2 > 1) { select2 = 0;}
      }
      if (UP == 0) {
        Serial1.println("UP-2");
        select2--;
        if (select2 < 0) { select2 = 1;}
      }
      if (SEL == 0) {
        Serial1.println("SEL-2");
        switch (select2) {
          case 0: page = 0; break;  ////поменять 
          case 1: page = 0; break;  ////поменять 
        }
      }  
      if (ESC == 0) {
        Serial1.println("ESC-2");
        page = 0;
      }  
    break;    
/////////////////////  меню осциллографа
    case 3:
      if (DOWN == 0) {
        Serial1.println("DOWN-3");
        select3++;
        if (select3 > 1) { select3 = 0;}
      }
      if (UP == 0) {
        Serial1.println("UP-3");
        select3--;
        if (select3 < 0) { select3 = 1;}
      }
      if (SEL == 0) {
        Serial1.println("SEL-3");
        switch (select3) {
          case 0: page = 0; break;  ////поменять 
          case 1: page = 0; break;  ////поменять 
        }
      }  
      if (ESC == 0) {
        Serial1.println("ESC-3");
        page = 0;
      }  
    break;    
/////////////////////  меню настроек master RTU
    case 4:
      if (DOWN == 0) {
        Serial1.println("DOWN-4");
        select4++;
        if (select4 > 6) { select4 = 0;}
      }
      if (UP == 0) {
        Serial1.println("UP-4");
        select4--;
        if (select4 < 0) { select4 = 6;}
      }
      if (SEL == 0) {
        Serial1.println("SEL-4");
        page = 5; 
        numlist = 0;
      }  
      if (ESC == 0) {
        Serial1.println("ESC-4");
        page = 1;
      }  
      if (RIGHT == 0) {
        Serial1.println("RIGHT-4");
        switch (select4) {
          case 0:
            numfuncM++;
            if (numfuncM > 7) { numfuncM = 7;}
            break;
          case 1:
            timeout = timeout + 100;
            if (timeout > 9999) { timeout = 9999;}
            break;   
          case 2:
            ID = ID + 1;
            if (ID > 255) { ID = 255;}
            break;  
          case 3:
            numspeed++;
            if (numspeed > 8) { numspeed = 8;}
            break;   
          case 4:
            numformat++;
            if (numformat > 11) { numformat = 11;}
            break; 
          case 5:
            registor = registor + 1;
            if (registor > 65535) { registor = 0;}
            break;
          case 6:
            count = count + 1;
            if (count > 99) { count = 99;}
            break;          
        }
      }
      if (LEFT == 0) {
        Serial1.println("LEFT-4");
        switch (select4) {
          case 0:
            numfuncM--;
            if (numfuncM < 0) { numfuncM = 0;}
            break;
          case 1:
            timeout = timeout - 100;
            if (timeout < 100) { timeout = 100;}
            break; 
          case 2:
            ID = ID - 1;
            if (ID < 1) { ID = 1;}
            break;  
          case 3:
            numspeed--;
            if (numspeed < 0) { numspeed = 0;}
            break; 
          case 4:
            numformat--;
            if (numformat < 0) { numformat = 0;}
            break; 
          case 5:
            registor = registor - 1;
            if (registor < 0) { registor = 65535;}
            break;  
          case 6:
            count = count - 1;
            if (count < 1) { count = 1;}
            break;         
        }
      }
    break;  
///////////////////// меню результатов master RTU   
    case 5:
      if (ESC == 0) {
        Serial1.println("ESC-5");
        page = 4;
      }  
      int maxlist = 0;
      switch (numfuncM) {
        case 0:   // функция Coil
        case 1:   // функция Discret Input
          if (DOWN == 0)  {Serial1.println("DOWN-5");}
          if (UP == 0)    {Serial1.println("UP-5");}
           
          if (RIGHT == 0) {
            Serial1.println("RIGHT-5");
            numlist++;
            maxlist = ceil(count / 4);
            if (numlist > maxlist) { numlist = maxlist;}
          }
          if (LEFT == 0) {
            Serial1.println("LEFT-5");
            numlist--;
            if (numlist < 0) { numlist = 0;}
          }
          break;
        case 2:   // функция Holding Reg
        case 3:   // функция Input Reg
          if (DOWN == 0) {
            Serial1.println("DOWN-5");
            select5++;
            if (select5 > 1) { select5 = 0;}
          }
          if (UP == 0) {
            Serial1.println("UP-5");
            select5--;
            if (select5 < 0) { select5 = 1;}
          }
          if (RIGHT == 0) {
            Serial1.println("RIGHT-5");
            switch (select5) {
              case 0:
                numlist++;
                maxlist = ceil(count / 4);
                if (numlist > maxlist) { numlist = maxlist;}
                break;  
              case 1:
                numtype++; 
                if (numtype > 7) { numtype = 7;}
                break;
            }
          }
          if (LEFT == 0) {
            Serial1.println("LEFT-5");
            switch (select5) {
              case 0:
                numlist--;
                if (numlist < 0) { numlist = 0;}
                break;  
              case 1:
                numtype--;
                if (numtype < 0) { numtype = 0;}
                break;
            }
          }
          break;
        case 4:   // функция Write Coil 
          if (DOWN == 0) {
            Serial1.println("DOWN-5");
            select5++;
            if (select5 > 1) { select5 = 0;}
          }
          if (UP == 0) {
            Serial1.println("UP-5");
            select5--;
            if (select5 < 0) { select5 = 1;}
          }
          if (RIGHT == 0) {
            Serial1.println("RIGHT-5");
            switch (select5) {
              case 0:
                writeCoil[0]=!writeCoil[0];
                break;  
              case 1:
                registor++; 
                if (registor > 65535) { registor = 0;}
                break;
            }
          }
          if (LEFT == 0) {
            Serial1.println("LEFT-5");
            switch (select5) {
              case 0:
                writeCoil[0]=!writeCoil[0];
                break;  
              case 1:
                registor--;
                if (registor < 0) { registor = 65535;}
                break;
            }
          }
          if (SEL == 0) {
            Serial1.println("SEL-5");
            writing = 1;
          }  
          break;
        case 5:   // функция Write Reg
          if (DOWN == 0) {
            Serial1.println("DOWN-5");
            select5++;
            if (select5 > 2) { select5 = 0;}
          }
          if (UP == 0) {
            Serial1.println("UP-5");
            select5--;
            if (select5 < 0) { select5 = 2;}
          }
          if (RIGHT == 0) {
            Serial1.println("RIGHT-5");
            switch (select5) {
              case 0:
                writeReg[0]++;
                break;  
              case 1:
                numtype++;
                if (numtype > 7) { numtype = 7;}
                break;  
              case 2:
                registor++; 
                if (registor > 65535) { registor = 0;}
                break;
            }
          }
          if (LEFT == 0) {
            Serial1.println("LEFT-5");
            switch (select5) {
              case 0:
                writeReg[0]--;
                break;
              case 1:
                numtype--;
                if (numtype < 0) { numtype = 0;}
                break;  
              case 2:
                registor--;
                if (registor < 0) { registor = 65535;}
                break;
            }
          }
          if (SEL == 0) {
            Serial1.println("SEL-5");
            writing = 1;
          }  
          break;

        case 6:    // функция Write MCoil
          if (count >= 8) {maxselect = 8;}
            else          {maxselect = count;}
          if (DOWN == 0) {
            Serial1.println("DOWN-5");
            select5++;
            if (select5 > maxselect) { select5 = 0;}
          }
          if (UP == 0) {
            Serial1.println("UP-5");
            select5--;
            if (select5 < 0) { select5 = maxselect;}
          }
          if (RIGHT == 0) {
            Serial1.println("RIGHT-5");
            switch (select5) {
              case 0:
                registor++; 
                if (registor > 65535) { registor = 0;}
                break; 
              case 1:
              case 2:
              case 3:
              case 4:
              case 5:
              case 6:
              case 7:
              case 8:
                for (int i=0; i <= maxselect; i++){
                  if (i == select5-1) { writeCoil[i]=!writeCoil[i];}
                }
                break;
            }
          }
          if (LEFT == 0) {
            Serial1.println("LEFT-5");
            switch (select5) {
              case 0:
                registor--;
                if (registor < 0) { registor = 65535;}
                break;
              case 1:
              case 2:
              case 3:
              case 4:
              case 5:
              case 6:
              case 7:
              case 8:
                for (int i=0; i <= maxselect; i++){
                  if (i == select5-1) { writeCoil[i]=!writeCoil[i];}
                }
                break;
            }
          }
          if (SEL == 0) {
            Serial1.println("SEL-5");
            writing = 1;
          }  
          break;

        case 7:    // функция Write MReg
          if (count >= 4) {maxselect = 5;}
            else          {maxselect = count+1;}
          if (DOWN == 0) {
            Serial1.println("DOWN-5");
            select5++;
            if (select5 > maxselect) { select5 = 0;}
          }
          if (UP == 0) {
            Serial1.println("UP-5");
            select5--;
            if (select5 < 0) { select5 = maxselect;}
          }
          if (RIGHT == 0) {
            Serial1.println("RIGHT-5");
            switch (select5) {
              case 0:
                registor++; 
                if (registor > 65535) { registor = 0;}
                break; 
              case 1:
                numtype++;
                if (numtype >= 7) {numtype = 7;}
                break;
              case 2:
              case 3:
              case 4:
              case 5:
                for (int i=0; i <= maxselect; i++){
                  if (i == select5-2) { writeReg[i]++;}
                }
                break;
            }
          }
          if (LEFT == 0) {
            Serial1.println("LEFT-5");
            switch (select5) {
              case 0:
                registor--;
                if (registor < 0) { registor = 65535;}
                break;
              case 1:
                numtype--;
                if (numtype <= 0) {numtype = 0;}
                break;
              case 2:
              case 3:
              case 4:
              case 5:
                for (int i=0; i <= maxselect; i++){
                  if (i == select5-2) { writeReg[i]--;}
                }
                break;
            }
          }
          if (SEL == 0) {
            Serial1.println("SEL-5");
            writing = 1;
          }  
          break;
      }
    break;




  
  }
}