// --- Библиотеки
#include <UTFT.h>
#include <UTouch.h>
#include <DS1307new.h>
#include <EEPROM.h>

// --- Инициализируем устройства
UTFT myGLCD(ITDB32S, 38, 39, 40, 41); // Дисплей
UTouch myTouch(46, 45, 44, 43, 42); // Сенсор

// --- Подключаем шрифты

extern uint8_t BigFont[];
extern uint8_t SmallFont[];
extern uint8_t SevenSegNumFontPlus[];

#define LARGE true
#define SMALL false

// --- Назначаем выводы

const byte ledPinCh1 = 7;  // канал 1
const byte ledPinCh2 = 8;  // канал 2
const byte ledPinCh3 = 9;  // канал 3
const byte ledPinCh4 = 10; // канал 4
const byte ledPinCh5 = 11; // канал 5
const byte ledPinCh6 = 12; // канал 6

// --- Настройки

const byte numberOfCh = 6; // количество каналов
const char *namesCh[] = {" ", "NAME1", "NAME2", "NAME3", "NAME4", "NAME5", "NAME6"}; // имя каналов (не более 5 символов)
const char *namesChMix[] = {" ", "Ch1", "Ch2", "Ch3", "Ch4", "Ch5", "Ch6"};
const byte rgbCh1[] = {0, 0, 255};     // цвет канала 1 RGB
const byte rgbCh2[] = {255, 255, 255}; // цвет канала 2 RGB
const byte rgbCh3[] = {238, 130, 238}; // цвет канала 3 RGB
const byte rgbCh4[] = {0, 225, 225};   // цвет канала 4 RGB
const byte rgbCh5[] = {255, 0, 0};     // цвет канала 5 RGB
const byte rgbCh6[] = {255, 0, 170};   // цвет канала 6 RGB

const boolean BUCKPUCK  = true; // реверс ШИМ
const boolean readEEonStart = 1; // читать EEPROM при загрузке вкл/выкл

// первоначальная настройка каналов,
// используется один раз при первой загрузке
// при условии, что в EEPROM нет данных
// в дальнейшем эти данные читаются с EEPROM
byte ch1led[96] = {
  0, 0, 0, 0, 0, 0, 0, 0,  //0 - 1
  0, 0, 0, 0, 0, 0, 0, 0,  //2 - 3
  0, 0, 0, 0, 0, 0, 0, 0,  //4 - 5
  0, 0, 0, 0, 0, 0, 0, 0,  //6 - 7
  0, 0, 0, 0, 0, 0, 0, 0,  //8 - 9
  0, 0, 0, 0, 0, 0, 0, 0,  //10 - 11
  0, 0, 0, 0, 0, 0, 0, 0,  //12 - 13
  0, 0, 0, 0, 0, 0, 0, 0,  //14 - 15
  0, 0, 0, 0, 0, 0, 0, 0,  //16 - 17
  0, 0, 0, 0, 0, 0, 0, 0,  //18 - 19
  0, 0, 0, 0, 0, 0, 0, 0,  //20 - 21
  0, 0, 0, 0, 0, 0, 0, 0   //22 - 23
};
byte ch2led[96] = {
  0, 0, 0, 0, 0, 0, 0, 0,  //0 - 1
  0, 0, 0, 0, 0, 0, 0, 0,  //2 - 3
  0, 0, 0, 0, 0, 0, 0, 0,  //4 - 5
  0, 0, 0, 0, 0, 0, 0, 0,  //6 - 7
  0, 0, 0, 0, 0, 0, 0, 0,  //8 - 9
  0, 0, 0, 0, 0, 0, 0, 0,  //10 - 11
  0, 0, 0, 0, 0, 0, 0, 0,  //12 - 13
  0, 0, 0, 0, 0, 0, 0, 0,  //14 - 15
  0, 0, 0, 0, 0, 0, 0, 0,  //16 - 17
  0, 0, 0, 0, 0, 0, 0, 0,  //18 - 19
  0, 0, 0, 0, 0, 0, 0, 0,  //20 - 21
  0, 0, 0, 0, 0, 0, 0, 0   //22 - 23
};
byte ch3led[96] = {
  0, 0, 0, 0, 0, 0, 0, 0,  //0 - 1
  0, 0, 0, 0, 0, 0, 0, 0,  //2 - 3
  0, 0, 0, 0, 0, 0, 0, 0,  //4 - 5
  0, 0, 0, 0, 0, 0, 0, 0,  //6 - 7
  0, 0, 0, 0, 0, 0, 0, 0,  //8 - 9
  0, 0, 0, 0, 0, 0, 0, 0,  //10 - 11
  0, 0, 0, 0, 0, 0, 0, 0,  //12 - 13
  0, 0, 0, 0, 0, 0, 0, 0,  //14 - 15
  0, 0, 0, 0, 0, 0, 0, 0,  //16 - 17
  0, 0, 0, 0, 0, 0, 0, 0,  //18 - 19
  0, 0, 0, 0, 0, 0, 0, 0,  //20 - 21
  0, 0, 0, 0, 0, 0, 0, 0   //22 - 23
};
byte ch4led[96] = {
  0, 0, 0, 0, 0, 0, 0, 0,  //0 - 1
  0, 0, 0, 0, 0, 0, 0, 0,  //2 - 3
  0, 0, 0, 0, 0, 0, 0, 0,  //4 - 5
  0, 0, 0, 0, 0, 0, 0, 0,  //6 - 7
  0, 0, 0, 0, 0, 0, 0, 0,  //8 - 9
  0, 0, 0, 0, 0, 0, 0, 0,  //10 - 11
  0, 0, 0, 0, 0, 0, 0, 0,  //12 - 13
  0, 0, 0, 0, 0, 0, 0, 0,  //14 - 15
  0, 0, 0, 0, 0, 0, 0, 0,  //16 - 17
  0, 0, 0, 0, 0, 0, 0, 0,  //18 - 19
  0, 0, 0, 0, 0, 0, 0, 0,  //20 - 21
  0, 0, 0, 0, 0, 0, 0, 0   //22 - 23
};
byte ch5led[96] = {
  0, 0, 0, 0, 0, 0, 0, 0,  //0 - 1
  0, 0, 0, 0, 0, 0, 0, 0,  //2 - 3
  0, 0, 0, 0, 0, 0, 0, 0,  //4 - 5
  0, 0, 0, 0, 0, 0, 0, 0,  //6 - 7
  0, 0, 0, 0, 0, 0, 0, 0,  //8 - 9
  0, 0, 0, 0, 0, 0, 0, 0,  //10 - 11
  0, 0, 0, 0, 0, 0, 0, 0,  //12 - 13
  0, 0, 0, 0, 0, 0, 0, 0,  //14 - 15
  0, 0, 0, 0, 0, 0, 0, 0,  //16 - 17
  0, 0, 0, 0, 0, 0, 0, 0,  //18 - 19
  0, 0, 0, 0, 0, 0, 0, 0,  //20 - 21
  0, 0, 0, 0, 0, 0, 0, 0   //22 - 23
};
byte ch6led[96] = {
  0, 0, 0, 0, 0, 0, 0, 0,  //0 - 1
  0, 0, 0, 0, 0, 0, 0, 0,  //2 - 3
  0, 0, 0, 0, 0, 0, 0, 0,  //4 - 5
  0, 0, 0, 0, 0, 0, 0, 0,  //6 - 7
  0, 0, 0, 0, 0, 0, 0, 0,  //8 - 9
  0, 0, 0, 0, 0, 0, 0, 0,  //10 - 11
  0, 0, 0, 0, 0, 0, 0, 0,  //12 - 13
  0, 0, 0, 0, 0, 0, 0, 0,  //14 - 15
  0, 0, 0, 0, 0, 0, 0, 0,  //16 - 17
  0, 0, 0, 0, 0, 0, 0, 0,  //18 - 19
  0, 0, 0, 0, 0, 0, 0, 0,  //20 - 21
  0, 0, 0, 0, 0, 0, 0, 0   //22 - 23
};

// --- Переменные

byte dispScreen = 0; // Номер Экрана
int x, y; // Координаты Touch

// Счётчики
unsigned long prevMillis5 = 0;
unsigned long prevMillis600 = 0;
unsigned long prevMillis900 = 0;

// LED переменные
int LedChangeTime = 0;
int selectChannel;
char tChar30[30];
int min_cnt;
int tled[96];
byte *LEDval_arr[] = {ch1led, ch2led, ch3led, ch4led, ch5led, ch6led};
byte LEDch_out[6];
byte prevLEDch_out[6];
byte LEDpin[] = {ledPinCh1, ledPinCh2, ledPinCh3, ledPinCh4, ledPinCh5, ledPinCh6};
char ch1Descr[15],  ch2Descr[15], ch3Descr[15], ch4Descr[15], ch5Descr[15], ch6Descr[15];
const byte *rgbChann[] = {rgbCh1, rgbCh2, rgbCh3, rgbCh4, rgbCh5, rgbCh6};

// переменные для часов и вывода времени/даты
char *Day[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
char *Mon[] = {"", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};


struct RTC_T
{
  int tHour;
  int tMinute;
  int tDow;
  int tDay;
  int tMonth;
  int tYear;
}
tempRTC, prevRTC;

// координаты кнопок
// * главный экран
const int KeyMenu[] = {0, 18, 189, 115}; // Меню

// * установка времени/даты
const int HourUp[] = {130, 22 - 2};
const int HourDown[] = {130, 71 - 2};
const int MinUp[] = {190, 22 - 2};
const int MinDown[] = {190, 71 - 2};
const int DayUp[] = {120, 111 - 6};
const int DayDown[] = {120, 160 - 6};
const int MonthUp[] = {179, 111 - 6};
const int MonthDown[] = {179, 160 - 6};
const int YearUp[] = {250, 111 - 6};
const int YearDown[] = {250, 160 - 6};

// * кнопки меню
const int KeyMenu1[] = {4, 21, 158, 59};
const int KeyMenu3[] = {4, 61, 158, 99};
const int KeyMenu5[] = {4, 101, 158, 139};
const int KeyMenu7[] = {4, 141, 158, 179};
const int KeyMenu2[] = {161, 21, 315, 59};
const int KeyMenu4[] = {161, 61, 315, 99};
const int KeyMenu6[] = {161, 101, 315, 139};
const int KeyMenu8[] = {161, 141, 315, 179};

// * кнопки подтверждения/отмены
const int KeyCancel[] = {161, 195, 315, 221};   //standard cancel
const int KeyOK[] = {4, 195, 158, 221};     //standard ok

// --- Функции

void initSettings()
{
  strcat(ch1Descr, namesChMix[1]);
  strcat(ch1Descr, "(" );
  strcat(ch1Descr, namesCh[1]);
  strcat(ch1Descr, ")" );
  strcat(ch2Descr, namesChMix[2]);
  strcat(ch2Descr, "(" );
  strcat(ch2Descr, namesCh[2]);
  strcat(ch2Descr, ")" );
  strcat(ch3Descr, namesChMix[3]);
  strcat(ch3Descr, "(" );
  strcat(ch3Descr, namesCh[3]);
  strcat(ch3Descr, ")" );
  strcat(ch4Descr, namesChMix[4]);
  strcat(ch4Descr, "(" );
  strcat(ch4Descr, namesCh[4]);
  strcat(ch4Descr, ")" );
  strcat(ch5Descr, namesChMix[5]);
  strcat(ch5Descr, "(" );
  strcat(ch5Descr, namesCh[5]);
  strcat(ch5Descr, ")" );
  strcat(ch6Descr, namesChMix[6]);
  strcat(ch6Descr, "(" );
  strcat(ch6Descr, namesCh[6]);
  strcat(ch6Descr, ")" );
}

// Очистка экрана
void clearScreen()
{
  myGLCD.setColor(0, 0, 0);
  myGLCD.fillRect(1, 1, 318, 225);
}

// заголовок экрана
void printHeader(char* headline)
{
  changeFont(SMALL, 255, 255, 255, 255, 255, 255);
  myGLCD.fillRect (1, 1, 318, 15);
  myGLCD.setColor(0, 0, 0);
  myGLCD.print(headline, CENTER, 2);
}

// работа с EEPROM
// * запись
void SaveToEEPROM(int what)
{
  switch (what)
  {
    case 1: // сохранить значения для канала 1
      EEPROM.update(0, 121);
      delay(5);
      for (int i = 0; i < 96; i++)
      {
        EEPROM.update(i + 1, ch1led[i]);
        delay(5);
      }
      break;
    case 2: // сохранить значения для канала 2
      EEPROM.update(97, 122);
      delay(5);
      for (int i = 0; i < 96; i++)
      {
        EEPROM.update(i + 98, ch2led[i]);
        delay(5);
      }
      break;
    case 3: // сохранить значения для канала 3
      EEPROM.update(194, 123);
      delay(5);
      for (int i = 0; i < 96; i++)
      {
        EEPROM.update(i + 195, ch3led[i]);
        delay(5);
      }
      break;
    case 4: // сохранить значения для канала 4
      EEPROM.update(291, 124);
      delay(5);
      for (int i = 0; i < 96; i++)
      {
        EEPROM.update(i + 292, ch4led[i]);
        delay(5);
      }
      break;
    case 5: // сохранить значения для канала 5
      EEPROM.update(388, 125);
      delay(5);
      for (int i = 0; i < 96; i++)
      {
        EEPROM.update(i + 389, ch5led[i]);
        delay(5);
      }
      break;
    case 6: // сохранить значения для канала 6
      EEPROM.update(485, 126);
      delay(5);
      for (int i = 0; i < 96; i++)
      {
        EEPROM.update(i + 486, ch6led[i]);
        delay(5);
      }
      break;
  }
}
// * чтение
void ReadFromEEPROM()
{
  int k = EEPROM.read(0); // читает сохраненные значения для 1 канала
  delay(5);
  if (k == 121)
  {
    for (int i = 0; i < 96; i++)
    {
      ch1led[i] = EEPROM.read(i + 1);
      delay(5);
    }
  }

  k = EEPROM.read(97); // читает сохраненные значения для 2 канала
  delay(5);
  if (k == 122)
  {
    for (int i = 0; i < 96; i++)
    {
      ch2led[i] = EEPROM.read(i + 98);
      delay(5);
    }
  }

  k = EEPROM.read(194); // читает сохраненные значения для 3 канала
  delay(5);
  if (k == 123)
  {
    for (int i = 0; i < 96; i++)
    {
      ch3led[i] = EEPROM.read(i + 195);
      delay(5);
    }
  }

  k = EEPROM.read(291); // читает сохраненные значения для 4 канала
  delay(5);
  if (k == 124)
  {
    for (int i = 0; i < 96; i++)
    {
      ch4led[i] = EEPROM.read(i + 292);
      delay(5);
    }
  }

  k = EEPROM.read(388); // читает сохраненные значения для 5 канала
  delay(5);
  if (k == 125)
  {
    for (int i = 0; i < 96; i++)
    {
      ch5led[i] = EEPROM.read(i + 389);
      delay(5);
    }
  }

  k = EEPROM.read(485); // читает сохраненные значения для 6 канала
  delay(5);
  if (k == 126)
  {
    for (int i = 0; i < 96; i++)
    {
      ch6led[i] = EEPROM.read(i + 486);
      delay(5);
    }
  }
}

// сохранить время
void SaveRTC()
{
  RTC.stopClock();
  RTC.fillByYMD(tempRTC.tYear, tempRTC.tMonth, tempRTC.tDay);
  RTC.fillByHMS(tempRTC.tHour, tempRTC.tMinute, 0);
  RTC.setTime();
  delay(10);
  RTC.startClock();
  delay(10);
}

// Шрифт
void changeFont(int font, byte cr, byte cg, byte cb, byte br, byte bg, byte bb)
{
  myGLCD.setBackColor(br, bg, bb);
  myGLCD.setColor(cr, cg, cb);
  if (font == LARGE)
    myGLCD.setFont(BigFont);
  else if (font == SMALL)
    myGLCD.setFont(SmallFont);
}

// Печатает Кнопки
void printUpButton(int x, int y)  // вверх размер 29x23px
{
  myGLCD.setColor(255, 255, 255);
  myGLCD.fillRect(x, y + 22, x + 29, y + 23);
  myGLCD.setColor(255, 255, 255);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 17 - i, x + 25 - (i / 1.5), y + 17 - i);
}

void printDownButton(int x, int y) // вниз размер 29x23px
{
  myGLCD.setColor(255, 255, 255);
  myGLCD.fillRect(x, y, x + 29, y + 1);
  myGLCD.setColor(255, 255, 255);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 7 + i, x + 25 - (i / 1.5), y + 7 + i);
}

void hlightUpButton(int x, int y) // подсветка нажатия вверх
{
  myGLCD.setColor(0, 200, 0);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 17 - i, x + 25 - (i / 1.5), y + 17 - i);
  while (myTouch.dataAvailable())
  {
    myTouch.read();
  }
  myGLCD.setColor(255, 255, 255);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 17 - i, x + 25 - (i / 1.5), y + 17 - i);
}

void hlightDownButton(int x, int y) // подсветка нажатия вниз
{
  myGLCD.setColor(0, 200, 0);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 7 + i, x + 25 - (i / 1.5), y + 7 + i);
  while (myTouch.dataAvailable())
  {
    myTouch.read();
  }
  myGLCD.setColor(255, 255, 255);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 7 + i, x + 25 - (i / 1.5), y + 7 + i);
}

// печатает кнопки меню
void drawMenuButton()
{
  for (y = 0; y < 4; y++)
  {
    myGLCD.setColor(255, 255, 255);
    myGLCD.drawRect(4, 21 + (y * 40), 158, 59 + (y * 40));
    myGLCD.drawRect(161, 21 + (y * 40), 315, 59 + (y * 40));
  }
}

void drawRegButton()
{
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRoundRect(4, 195, 158, 221);
  myGLCD.drawRoundRect(161, 195, 315, 221);
}

// подписывает кнопку меню
void printButton(char* text, int x1, int y1, int x2, int y2)
{
  int stl = strlen(text);
  int fx, fy;
  fx = x1 + (((x2 - x1) - (stl * 8)) / 2);
  fy = y1 + (((y2 - y1 - 1) - 8) / 2);
  changeFont(SMALL, 255, 255, 255, 0, 0, 0);
  myGLCD.print(text, fx, fy);
}
// подсветка нажатия меню
void hlightButton(char* text, int x1, int y1, int x2, int y2)
{
  int stl = strlen(text);
  int fx, fy;

  fx = x1 + (((x2 - x1) - (stl * 8)) / 2);
  fy = y1 + (((y2 - y1 - 1) - 8) / 2);

  myGLCD.setColor(0, 200, 0);
  myGLCD.fillRect (x1 + 4, y1 + 4, x2 - 4, y2 - 4);
  changeFont(SMALL, 255, 255, 255, 0, 200, 0);
  myGLCD.print(text, fx, fy);
  while (myTouch.dataAvailable()) {
    myTouch.read();
  }
  myGLCD.setColor(0, 0, 0);
  myGLCD.fillRect (x1 + 4, y1 + 4, x2 - 4, y2 - 4);
  changeFont(SMALL, 255, 255, 255, 0, 0, 0);
  myGLCD.print(text, fx, fy);
}

// Печатает LEDs область
void drawLedBar(int bary, byte ch)
{
  int barLength;
  char barLevel[7];
  itoa(LEDch_out[ch - 1], barLevel, 10);
  strcat(barLevel, "%");
  barLength = LEDch_out[ch - 1] * 1;  //!
  myGLCD.setColor(0, 0, 0);
  myGLCD.fillRect(46, bary, 189, (bary + 12));    //!
  changeFont(SMALL, rgbChann[ch - 1][0], rgbChann[ch - 1][1], rgbChann[ch - 1][2], 0, 0, 0);
  myGLCD.print(namesCh[ch], 5, bary);
  myGLCD.drawLine(47, (bary + 1), 47, (bary + 11));
  myGLCD.fillRect(49, (bary + 2), (barLength + 49), (bary + 10));
  myGLCD.print(barLevel, (barLength + 51), bary);
}

void printVBar(int val, int x1, int y1, const byte rgb[])
{
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRect (x1, y1 + 22, x1 + 29, y1 + 124);
  myGLCD.setColor(rgb[0], rgb[1], rgb[2]);
  myGLCD.fillRect (x1 + 1, y1 + (124 - val), x1 + 28, y1 + 124);
  myGLCD.setColor(0, 0, 0);
  myGLCD.fillRect (x1 + 1, y1 + 22, x1 + 28, y1 + (124 - val));
  printUpButton(x1, y1);
  printDownButton(x1, y1 + 124);
  changeFont(SMALL, 255, 255, 255, 0, 0, 0);
  if (val > -1)
    myGLCD.printNumI(val, x1 + 16 - (intlen(val) * 4), y1 + 66);
}

// печатает время
void printTime(int thour, int tminute, int posx, int posy)
{
  char tmpTime[6], charT[3];
  tmpTime[0] = '\0';

  if (thour >= 0 && thour <= 9)
  {
    strcat(tmpTime, "0");
    itoa(thour, charT, 10);
    strcat(tmpTime, charT);
  }
  else
    itoa(thour, tmpTime, 10);

  strcat(tmpTime, ":");

  if (tminute >= 0 && tminute <= 9)
  {
    strcat(tmpTime, "0");
    itoa(tminute, charT, 10);
    strcat(tmpTime, charT);
  }
  else
  {
    itoa(tminute, charT, 10);
    strcat(tmpTime, charT);
  }
  myGLCD.print(tmpTime, posx, posy);
}

// печатает дату

void printDate(int x, int y)
{
  char  chDate[25], tmpChar[5];
  strcat(chDate, "  ");
  chDate[0] = '\0';
  strcat(chDate, Day[RTC.dow]);
  strcat(chDate, ",");
  itoa(RTC.day, tmpChar, 10);
  strcat(chDate, tmpChar);
  strcat(chDate, " ");
  strcat(chDate, Mon[RTC.month]);
  strcat(chDate, " ");
  itoa(RTC.year, tmpChar, 10);
  strcat(chDate, tmpChar);
  myGLCD.print(chDate, x, y);
}

int intlen(int number)
{
  int length1;
  char tmpChar[7];
  itoa(number, tmpChar, 10);
  length1 = strlen(tmpChar);
  return length1;
}

int stringCenter (char *myString, boolean font = false)
{
  int chLen;
  if (font)                                   //large font
    chLen = (strlen(myString) * 8) - 1;
  else                                         //small font
    chLen = (strlen(myString) * 4) - 1;
  return chLen;
}

// --- LED levels
void LED_levels_output()
{
  int sector, sstep, t1, t2;
  int l_out;

  min_cnt = (RTC.hour * 60) + RTC.minute;
  if (min_cnt >= 1440)
  {
    min_cnt = 1;
  }

  sector = min_cnt / 15;
  sstep = min_cnt % 15;
  t1 = sector;
  if (t1 == 95)
  {
    t2 = 0;
  }
  else
  {
    t2 = t1 + 1;
  }

  for (int i = 0; i < numberOfCh; i++)
  {
    if (sstep == 0)
      LEDch_out[i] = LEDval_arr[i][t1];
    else
      LEDch_out[i] = check(&LEDval_arr[i][t1], &LEDval_arr[i][t2], sstep);

    if (BUCKPUCK)
      l_out = LEDch_out[i];
    else
      l_out = 100 - LEDch_out[i];
    l_out = map(l_out, 0, 100, 0, 255);
    analogWrite(LEDpin[i], l_out);
  }
}
int check( byte *pt1, byte *pt2, int lstep)
{
  int result;
  float fresult;

  if (*pt1 == *pt2)
  {
    result = *pt1;
  }
  else if (*pt1 < *pt2)
  {
    fresult = ((float(*pt2 - *pt1) / 15.0) * float(lstep)) + float(*pt1);
    result = int(fresult);
  }
  else
  {
    fresult = -((float(*pt1 - *pt2) / 15.0) * float(lstep)) + float(*pt1);
    result = int(fresult);
  }
  return result;
}

void printChangeLED()
{
  myGLCD.setColor(255, 0, 0);
  myGLCD.fillRect((LedChangeTime * 26) + 5, 20, (LedChangeTime * 26) + 29, 42);
  changeFont(SMALL, 255, 255, 255, 255, 0, 0);
  myGLCD.printNumI((LedChangeTime * 2), (LedChangeTime * 26) + 19 - (intlen(LedChangeTime * 2) * 4), 20);
  myGLCD.printNumI(((LedChangeTime * 2) + 1), (LedChangeTime * 26) + 19 - (intlen(LedChangeTime * 2) * 4), 31);

  for (int i = 0; i < 8; i++)
  {
    int k = (LedChangeTime * 8) + i;
    printVBar( tled[k], (i * 38) + 10, 44, rgbChann[selectChannel - 1]);
  }
}

///////////////////
// *** Экран *** //
///////////////////

/// --- Главный --- dispScreen=0
void mainScreen(boolean refreshAll = false)
{
  int h1, t1, by, bary;
  char tmpChar[10], charTmp[3];
  by = 118;

  Serial.println(refreshAll);

  if (refreshAll) // рисует статические элементы (те которые прорисовываются один раз)
  {
    myGLCD.setColor(255, 255, 255);
    myGLCD.drawRect(6, 17, 313, 18);
  }

  // время
  changeFont(LARGE, 0, 255, 0, 0, 0, 0);
  if ((RTC.hour != prevRTC.tHour) || (RTC.minute != prevRTC.tMinute) || refreshAll)
  {
    prevRTC.tHour = RTC.hour;
    prevRTC.tMinute = RTC.minute;
    printTime(RTC.hour, RTC.minute, 220, 1);
  }

  // дата
  changeFont(SMALL, 0, 255, 0, 0, 0, 0);
  if ((RTC.day != prevRTC.tDay) || (RTC.month != prevRTC.tMonth) || (RTC.year != prevRTC.tYear) || refreshAll)
  {
    prevRTC.tDay = RTC.day;
    prevRTC.tMonth = RTC.month;
    prevRTC.tYear = RTC.year;
    printDate(15, 5);
  }

  // led панель
  for (int i = 0; i < numberOfCh; i++)
  {
    if ((prevLEDch_out[i] != LEDch_out[i]) || refreshAll)
    {
      bary = 8 + 12 + ((by - 11) / (numberOfCh + 1)) * (i + 1) - 12;
      drawLedBar(bary, i + 1);
      prevLEDch_out[i] = LEDch_out[i];
    }
  }
}

// --- экран меню --- dispScreen=1

void menuScreen()
{
  printHeader("Choose setting");
  drawMenuButton();
  drawRegButton();

  printButton("SET TIME & DATE", KeyMenu1[0], KeyMenu1[1], KeyMenu1[2], KeyMenu1[3]);
  printButton("", KeyMenu3[0], KeyMenu3[1], KeyMenu3[2], KeyMenu3[3]);
  printButton("", KeyMenu5[0], KeyMenu5[1], KeyMenu5[2], KeyMenu5[3]);
  printButton("", KeyMenu7[0], KeyMenu7[1], KeyMenu7[2], KeyMenu7[3]);
  printButton("LEDs OUTPUT", KeyMenu2[0], KeyMenu2[1], KeyMenu2[2], KeyMenu2[3]);
  printButton("", KeyMenu4[0], KeyMenu4[1], KeyMenu4[2], KeyMenu4[3]);
  printButton("", KeyMenu6[0], KeyMenu6[1], KeyMenu6[2], KeyMenu6[3]);
  printButton("", KeyMenu8[0], KeyMenu8[1], KeyMenu8[2], KeyMenu8[3]);
  printButton("CANCEL", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
  printButton("", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
}

// --- экран становки время/дата --- dispScreen=2

void clockScreen(boolean refreshAll = false)
{
  char char1[4], tmp[3];

  if (refreshAll)
  {
    tempRTC.tHour = RTC.hour;
    tempRTC.tMinute = RTC.minute;
    tempRTC.tDow = RTC.dow;
    tempRTC.tDay = RTC.day;
    tempRTC.tMonth = RTC.month;
    tempRTC.tYear = RTC.year;

    printHeader("Time and Date settings");

    myGLCD.setColor(255, 255, 255);
    myGLCD.drawLine(6, 98, 313, 98);

    changeFont(LARGE, 255, 255, 0, 0, 0, 0);
    myGLCD.print("Time:", 20, 51 - 2);
    myGLCD.print("Date:", 20, 140 - 6);

    printUpButton(HourUp[0], HourUp[1]);
    printDownButton(HourDown[0], HourDown[1]);
    printUpButton(MinUp[0], MinUp[1]);
    printDownButton(MinDown[0], MinDown[1]);

    printUpButton(DayUp[0], DayUp[1]);
    printDownButton(DayDown[0], DayDown[1]);
    printUpButton(MonthUp[0], MonthUp[1]);
    printDownButton(MonthDown[0], MonthDown[1]);
    printUpButton(YearUp[0], YearUp[1]);
    printDownButton(YearDown[0], YearDown[1]);

    drawRegButton();
    printButton("SAVE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
    printButton("CANCEL", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
  }

  changeFont(LARGE, 255, 255, 255, 0, 0, 0);

  char1[0] = '\0';
  if (tempRTC.tHour <= 9)
  {
    strcat(char1, "0");
    itoa(tempRTC.tHour, tmp, 10);
    strcat(char1, tmp);
  }
  else
    itoa(tempRTC.tHour, char1, 10);
  myGLCD.print("0", HourUp[0], 51 - 2);
  myGLCD.print(char1, HourUp[0] + 14 - stringCenter(char1, LARGE), 51 - 2);
  myGLCD.print(":", 168, 51 - 2);

  char1[0] = '\0';
  if (tempRTC.tMinute <= 9)
  { //print minutes
    strcat(char1, "0");
    itoa(tempRTC.tMinute, tmp, 10);
    strcat(char1, tmp);
  }
  else
    itoa(tempRTC.tMinute, char1, 10);
  myGLCD.print("0", MinUp[0], 51 - 2);
  myGLCD.print(char1, MinUp[0] + 14 - stringCenter(char1, LARGE), 51 - 2);

  char1[0] = '\0';
  if (tempRTC.tDay <= 9)
  {
    strcat(char1, "0");
    itoa(tempRTC.tDay, tmp, 10);
    strcat(char1, tmp);
  }
  else
    itoa(tempRTC.tDay, char1, 10);
  myGLCD.print("0", DayUp[0], 140 - 6);
  myGLCD.print(char1, DayUp[0] + 14 - stringCenter(char1, LARGE), 140 - 6);

  myGLCD.print(Mon[tempRTC.tMonth], MonthUp[0] + 14 - stringCenter(Mon[tempRTC.tMonth], LARGE), 140 - 6); //print month

  char1[0] = '\0';
  itoa(tempRTC.tYear, char1, 10);
  myGLCD.printNumI(tempRTC.tYear, YearUp[0] + 14 - stringCenter(char1, LARGE), 140 - 6);
}

// --- Led меню (список каналов) --- dispScreen=3

void LEDmenuScreen()
{
  printHeader("Select LED channel:");

  printButton(ch1Descr, KeyMenu1[0], KeyMenu1[1], KeyMenu1[2], KeyMenu1[3]);
  printButton(ch2Descr, KeyMenu2[0], KeyMenu2[1], KeyMenu2[2], KeyMenu2[3]);

  if (numberOfCh > 2)
    printButton(ch3Descr, KeyMenu3[0], KeyMenu3[1], KeyMenu3[2], KeyMenu3[3]);

  if (numberOfCh > 3)
    printButton(ch4Descr, KeyMenu4[0], KeyMenu4[1], KeyMenu4[2], KeyMenu4[3]);

  if (numberOfCh > 4)
    printButton(ch5Descr, KeyMenu5[0], KeyMenu5[1], KeyMenu5[2], KeyMenu5[3]);

  if (numberOfCh > 5)
    printButton(ch6Descr, KeyMenu6[0], KeyMenu6[1], KeyMenu6[2], KeyMenu6[3]);

  drawMenuButton();
  drawRegButton();

  printButton("CANCEL", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
}

// --- текущие значения канала --- dispScreen=4
void ledSetScreen()
{
  int a;

  tChar30[0] = '\0';

  switch (selectChannel) {
    case 1:
      for (int i = 0; i < 96; i++)
        tled[i] = ch1led[i];
      strcat(tChar30, ch1Descr);
      strcat(tChar30, "output values %" );
      printHeader(tChar30);
      break;
    case 2:
      for (int i; i < 96; i++)
        tled[i] = ch2led[i];
      strcat(tChar30, ch2Descr);
      strcat(tChar30, "output values %" );
      printHeader(tChar30);
      break;
    case 3:
      for (int i; i < 96; i++)
        tled[i] = ch3led[i];
      strcat(tChar30, ch3Descr);
      strcat(tChar30, "output values %" );
      printHeader(tChar30);
      break;
    case 4:
      for (int i; i < 96; i++)
        tled[i] = ch4led[i];
      strcat(tChar30, ch4Descr);
      strcat(tChar30, "output values %" );
      printHeader(tChar30);
      break;
    case 5:
      for (int i; i < 96; i++)
        tled[i] = ch5led[i];
      strcat(tChar30, ch5Descr);
      strcat(tChar30, "output values %" );
      printHeader(tChar30);
      break;
    case 6:
      for (int i; i < 96; i++)
        tled[i] = ch6led[i];
      strcat(tChar30, ch6Descr);
      strcat(tChar30, "output values %" );
      printHeader(tChar30);
      break;
  }

  changeFont(SMALL, 255, 255, 255, 0, 0, 0);
  for (int i = 0; i < 12; i++)
  {
    myGLCD.setColor(255, 255, 0);
    myGLCD.printNumI((i * 2), (i * 26) + 19 - (intlen(i * 2) * 4), 21);
    myGLCD.printNumI(((i * 2) + 1), (i * 26) + 19 - (intlen(i * 2) * 4), 32);
    for (int j = 0; j < 8; j++)
    {
      a = (i * 8) + j;
      myGLCD.setColor(255, 255, 255);
      myGLCD.printNumI(tled[a], (i * 26) + 19 - (intlen(tled[a]) * 4), (j * 16) + 49);
      myGLCD.setColor(100, 100, 100);
      myGLCD.drawRect((i * 26) + 4, (j * 16) + 47, (i * 26) + 30, (j * 16) + 63);
    }
  }

  drawRegButton();
  printButton("CHANGE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
  printButton("BACK", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
}

// изменение настроек значений канала --- dispScreen=5

void ledChangeScreen()
{
  printHeader(tChar30);

  changeFont(SMALL, 0, 255, 255, 0, 0, 0);
  for (int i = 0; i < 12; i++)
  {
    myGLCD.setColor(255, 255, 0);
    myGLCD.printNumI((i * 2), (i * 26) + 19 - (intlen(i * 2) * 4), 20);
    myGLCD.printNumI(((i * 2) + 1), (i * 26) + 19 - (intlen(i * 2) * 4), 31);
    myGLCD.setColor(100, 100, 100);
    myGLCD.drawRect((i * 26) + 4, 19 , (i * 26) + 30, 43);
  }
  printChangeLED();

  drawRegButton();
  printButton("SAVE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
  printButton("BACK", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
}

// Режим ожидания --- Dispscreen=100
/*
  void standby(boolean refreshAll = false) //(boolean refreshAll=false)
  {
  dispScreen = 100;

  if (refreshAll)
  {
    changeFont(SMALL, 135, 206, 250, 0, 0, 0);
    myGLCD.print("TOUCH", CENTER, 200);
  }

  if ((RTC.hour != prevRTC.tHour) || (RTC.minute != prevRTC.tMinute) || (RTC.day != prevRTC.tDay) || (RTC.month != prevRTC.tMonth) || (RTC.year != prevRTC.tYear) || refreshAll)
  {
    myGLCD.setColor(135, 206, 250);
    myGLCD.setFont(SevenSegNumFontPlus);
    prevRTC.tHour = RTC.hour;
    prevRTC.tMinute = RTC.minute;
    printTime(RTC.hour, RTC.minute, CENTER, 65);
    changeFont(LARGE, 135, 206, 250, 0, 0, 0);
    prevRTC.tDay = RTC.day;
    prevRTC.tMonth = RTC.month;
    prevRTC.tYear = RTC.year;
    printDate(CENTER, 120);
  }

  //printBell (KeyBell[0], KeyBell[1]);
  printATO (KeyATO[0], KeyATO[1]);
  printTemp (KeyTempWater[0], KeyTempWater[1]);
  printService (serviceFlag, KeyService[0], KeyService[1]);
  printWaterTap (waterTapFlag, KeyWaterTap[0], KeyWaterTap[1]);
  printSound (soundFlag, KeySound[0], KeySound[1]);

  printTempWater (218, 140);
  }*/

///////////////////////////////////
// ***   ---   TOUCH   ---   *** //
///////////////////////////////////

void processMyTouch()
{
  myTouch.read();
  x = myTouch.getX();
  y = myTouch.getY();

  prevMillis600 = millis();
  if ((x >= KeyCancel[0]) && (x <= KeyCancel[2]) && (y >= KeyCancel[1]) && (y <= KeyCancel[3]) && (dispScreen != 0) && (dispScreen != 4) && (dispScreen != 5)) //press cancel
  {
    hlightButton("CANCEL", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
    dispScreen = 0;
    clearScreen();
    mainScreen(true);
  }
  else
  {
    switch (dispScreen)
    {
      case 0: // dispScreen 0
        if ((x >= KeyMenu[0]) && (x <= KeyMenu[2]) && (y >= KeyMenu[1]) && (y <= KeyMenu[3]))
        {
          dispScreen = 1;
          clearScreen();
          menuScreen();
        }
        break;

      case 1: // dispScreen 1

        if ((x >= KeyMenu1[0]) && (x <= KeyMenu1[2]))
        {
          if ((y >= KeyMenu1[1]) && (y <= KeyMenu1[3]))
          {
            hlightButton("SET TIME & DATE", KeyMenu1[0], KeyMenu1[1], KeyMenu1[2], KeyMenu1[3]);
            dispScreen = 2;
            clearScreen();
            clockScreen(true);
          }
          if ((y >= KeyMenu3[1]) && (y <= KeyMenu3[3]))
          {
            hlightButton("   ", KeyMenu3[0], KeyMenu3[1], KeyMenu3[2], KeyMenu3[3]);
          }
          if ((y >= KeyMenu5[1]) && (y <= KeyMenu5[3]))
          {
            hlightButton("   ", KeyMenu5[0], KeyMenu5[1], KeyMenu5[2], KeyMenu5[3]);
          }
          if ((y >= KeyMenu7[1]) && (y <= KeyMenu7[3]))
          {
            hlightButton("   ", KeyMenu7[0], KeyMenu7[1], KeyMenu7[2], KeyMenu7[3]);
          }
          if  ((y >= KeyOK[1]) && (y <= KeyOK[3]))
          {
            hlightButton("   ", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
          }
        }
        if ((x >= KeyMenu2[0]) && (x <= KeyMenu2[2]))
        {
          if  ((y >= KeyMenu2[1]) && (y <= KeyMenu2[3]))
          {
            hlightButton("LEDs OUTPUT", KeyMenu2[0], KeyMenu2[1], KeyMenu2[2], KeyMenu2[3]);
            dispScreen = 3;
            clearScreen();
            LEDmenuScreen();
          }
          if ((y >= KeyMenu4[1]) && (y <= KeyMenu4[3]))
          {
            hlightButton("   ", KeyMenu4[0], KeyMenu4[1], KeyMenu4[2], KeyMenu4[3]);
          }
          if ((y >= KeyMenu6[1]) && (y <= KeyMenu6[3]))
          {
            hlightButton("   ", KeyMenu6[0], KeyMenu6[1], KeyMenu6[2], KeyMenu6[3]);
          }
          if ((y >= KeyMenu8[1]) && (y <= KeyMenu8[3]))
          {
            hlightButton("   ", KeyMenu8[0], KeyMenu8[1], KeyMenu8[2], KeyMenu8[3]);
          }
        }
        break;

      case 2: // dispScreen 2
        if ((x >= KeyOK[0]) && (x <= KeyOK[2]) && (y >= KeyOK[1]) && (y <= KeyOK[3]))
        {
          hlightButton("SAVE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
          SaveRTC();
          dispScreen = 0;
          clearScreen();
          mainScreen(true);
        }
        else {
          if ((y >= HourUp[1]) && (y <= HourUp[1] + 23)) {
            if ((x >= HourUp[0]) && (x <= HourUp[0] + 29)) {
              hlightUpButton(HourUp[0], HourUp[1]);
              tempRTC.tHour++;
              if (tempRTC.tHour >= 24) {
                tempRTC.tHour = 0;
              }
            }
            if ((x >= MinUp[0]) && (x <= MinUp[0] + 29)) {
              hlightUpButton(MinUp[0], MinUp[1]);
              tempRTC.tMinute++;
              if (tempRTC.tMinute >= 60) {
                tempRTC.tMinute = 0;
              }
            }
          }
          else if ((y >= HourDown[1]) && (y <= HourDown[1] + 23))
          {
            if ((x >= HourDown[0]) && (x <= HourDown[0] + 29))
            {
              hlightDownButton(HourDown[0], HourDown[1]);
              tempRTC.tHour--;
              if (tempRTC.tHour < 0)
              {
                tempRTC.tHour = 23;
              }
            }
            if ((x >= MinDown[0]) && (x <= MinDown[0] + 29))
            {
              hlightDownButton(MinDown[0], MinDown[1]);
              tempRTC.tMinute--;
              if (tempRTC.tMinute < 0)
              {
                tempRTC.tMinute = 59;
              }
            }
          }
          else if ((y >= DayUp[1]) && (y <= DayUp[1] + 23))
          {
            if ((x >= DayUp[0]) && (x <= DayUp[0] + 29))
            {
              hlightUpButton(DayUp[0], DayUp[1]);
              tempRTC.tDay++;
              if (tempRTC.tDay > 31)
              {
                tempRTC.tDay = 1;
              }
            }
            if ((x >= MonthUp[0]) && (x <= MonthUp[0] + 29))
            {
              hlightUpButton(MonthUp[0], MonthUp[1]);
              tempRTC.tMonth++;
              if (tempRTC.tMonth > 12)
              {
                tempRTC.tMonth = 1;
              }
            }
            if ((x >= YearUp[0]) && (x <= YearUp[0] + 29))
            {
              hlightUpButton(YearUp[0], YearUp[1]);
              if (tempRTC.tYear < 2100)
                tempRTC.tYear++;
            }
          }
          else if ((y >= DayDown[1]) && (y <= DayDown[1] + 23))
          {
            if ((x >= DayDown[0]) && (x <= DayDown[0] + 29))
            {
              hlightDownButton(DayDown[0], DayDown[1]);
              tempRTC.tDay--;
              if (tempRTC.tDay <= 0)
              {
                tempRTC.tDay = 31;
              }
            }
            if ((x >= MonthDown[0]) && (x <= MonthDown[0] + 29))
            {
              hlightDownButton(MonthDown[0], MonthDown[1]);
              tempRTC.tMonth--;
              if (tempRTC.tMonth <= 0)
              {
                tempRTC.tMonth = 12;
              }
            }
            if ((x >= YearDown[0]) && (x <= YearDown[0] + 29))
            {
              hlightDownButton(YearDown[0], YearDown[1]);
              if (tempRTC.tYear > 2000)
                tempRTC.tYear--;
            }
          }
          clockScreen(false);
        }
        break;

      case 3: // dispScreen 3
        if ((x >= KeyMenu1[0]) && (x <= KeyMenu1[2]))
        { //first column
          if ((y >= KeyMenu1[1]) && (y <= KeyMenu1[3]))
          {
            hlightButton(ch1Descr, KeyMenu1[0], KeyMenu1[1], KeyMenu1[2], KeyMenu1[3]);
            selectChannel = 1;
            dispScreen = 4;
            clearScreen();
            ledSetScreen();
          }
          if ((y >= KeyMenu3[1]) && (y <= KeyMenu3[3]) && (numberOfCh > 2))
          {
            hlightButton(ch3Descr, KeyMenu3[0], KeyMenu3[1], KeyMenu3[2], KeyMenu3[3]);
            selectChannel = 3;
            dispScreen = 4;
            clearScreen();
            ledSetScreen();
          }
          if ((y >= KeyMenu5[1]) && (y <= KeyMenu5[3]) && (numberOfCh > 4))
          {
            hlightButton(ch5Descr, KeyMenu5[0], KeyMenu5[1], KeyMenu5[2], KeyMenu5[3]);
            selectChannel = 5;
            dispScreen = 4;
            clearScreen();
            ledSetScreen();
          }
        }
        if ((x >= KeyMenu2[0]) && (x <= KeyMenu2[2]))
        {
          if ((y >= KeyMenu2[1]) && (y <= KeyMenu2[3]))
          {
            hlightButton(ch2Descr, KeyMenu2[0], KeyMenu2[1], KeyMenu2[2], KeyMenu2[3]);
            selectChannel = 2;
            dispScreen = 4;
            clearScreen();
            ledSetScreen();
          }
          if ((y >= KeyMenu4[1]) && (y <= KeyMenu4[3]) && (numberOfCh > 3))
          {
            hlightButton(ch4Descr, KeyMenu4[0], KeyMenu4[1], KeyMenu4[2], KeyMenu4[3]);
            selectChannel = 4;
            dispScreen = 4;
            clearScreen();
            ledSetScreen();
          }
          if ((y >= KeyMenu6[1]) && (y <= KeyMenu6[3]) && (numberOfCh > 5))
          {
            hlightButton(ch6Descr, KeyMenu6[0], KeyMenu6[1], KeyMenu6[2], KeyMenu6[3]);
            selectChannel = 6;
            dispScreen = 4;
            clearScreen();
            ledSetScreen();
          }
        }
        break;

      case 4: // dispScreen 4
        if ((x >= KeyOK[0]) && (x <= KeyOK[2]) && (y >= KeyOK[1]) && (y <= KeyOK[3]))
        {
          hlightButton("CHANGE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
          dispScreen = 5;
          clearScreen();
          ledChangeScreen();
        }
        else if ((x >= KeyCancel[0]) && (x <= KeyCancel[2]) && (y >= KeyCancel[1]) && (y <= KeyCancel[3])) //press BACK
        {
          hlightButton("BACK", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
          dispScreen = 3;
          clearScreen();
          LEDmenuScreen();
        }
        break;

      case 5: // dispScreen 5
        if ((x >= KeyCancel[0]) && (x <= KeyCancel[2]) && (y >= KeyCancel[1]) && (y <= KeyCancel[3])) //press CANCEL
        {
          hlightButton("BACK", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
          dispScreen = 4;
          clearScreen();
          ledSetScreen();
        }
        if ((x >= KeyOK[0]) && (x <= KeyOK[2]) && (y >= KeyOK[1]) && (y <= KeyOK[3]))
        {
          hlightButton("SAVE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);

          switch (selectChannel)
          {
            case 1:
              for (int i = 0; i < 96; i++)
                ch1led[i] = tled[i];
              SaveToEEPROM(1);
              break;
            case 2:
              for (int i = 0; i < 96; i++)
                ch2led[i] = tled[i];
              SaveToEEPROM(2);
              break;
            case 3:
              for (int i = 0; i < 96; i++)
                ch3led[i] = tled[i];
              SaveToEEPROM(3);
              break;
            case 4:
              for (int i = 0; i < 96; i++)
                ch4led[i] = tled[i];
              SaveToEEPROM(4);
              break;
            case 5:
              for (int i = 0; i < 96; i++)
                ch5led[i] = tled[i];
              SaveToEEPROM(5);
              break;
            case 6:
              for (int i = 0; i < 96; i++)
                ch6led[i] = tled[i];
              SaveToEEPROM(6);
              break;
          }
          dispScreen = 4;
          clearScreen();
          ledSetScreen();
        }

        else if ((y >= 15) && (y <= 35))
        {
          if ((x >= 4) && (x <= 316))
          {
            int oldLCT = LedChangeTime;
            LedChangeTime = map(x, 4, 316, 0, 12);
            if (oldLCT != LedChangeTime)
            {
              printChangeLED();
              myGLCD.setColor(0, 0, 0);
              myGLCD.fillRect((oldLCT * 26) + 5, 20, (oldLCT * 26) + 29, 42);
              changeFont(SMALL, 255, 255, 0, 0, 0, 0);
              myGLCD.printNumI((oldLCT * 2), (oldLCT * 26) + 19 - (intlen(oldLCT * 2) * 4), 20);
              myGLCD.printNumI(((oldLCT * 2) + 1), (oldLCT * 26) + 19 - (intlen(oldLCT * 2) * 4), 31);
            }
          }
        }
        else if ((y >= 44) && (y <= 65))
        {
          for (int i = 0; i < 8; i++)
          {
            if ((x >= (i * 38) + 10) && (x <= (i * 38) + 29 + 10))
            {
              int k = (LedChangeTime * 8) + i;
              if (tled[k] < 100)
                tled[k]++;
              printVBar( tled[k], (i * 38) + 10, 44, rgbChann[selectChannel - 1]);
            }
          }
        }
        else if ((y >= 67) && (y <= 166))
        {
          for (int i = 0; i < 8; i++)
          {
            if ((x >= (i * 38) + 10) && (x <= (i * 38) + 29 + 10))
            {
              int k = (LedChangeTime * 8) + i;
              tled[k] = 166 - y;
              printVBar( tled[k], (i * 38) + 10, 44, rgbChann[selectChannel - 1]);
            }
          }
        }
        else if ((y >= 168) && (y <= 190))
        {
          for (int i = 0; i < 8; i++)
          {
            if ((x >= (i * 38) + 10) && (x <= (i * 38) + 29 + 10))
            {
              int k = (LedChangeTime * 8) + i;
              if (tled[k] > 0)
                tled[k]--;
              printVBar( tled[k], (i * 38) + 10, 44, rgbChann[selectChannel - 1]);
            }
          }
        }
        break;
    }
  }
}

void setup()
{
  initSettings();

  // настройка выводов
  pinMode(ledPinCh1, OUTPUT);
  digitalWrite(ledPinCh1, LOW);
  pinMode(ledPinCh2, OUTPUT);
  digitalWrite(ledPinCh2, LOW);
  pinMode(ledPinCh3, OUTPUT);
  digitalWrite(ledPinCh3, LOW);
  pinMode(ledPinCh4, OUTPUT);
  digitalWrite(ledPinCh4, LOW);
  pinMode(ledPinCh5, OUTPUT);
  digitalWrite(ledPinCh5, LOW);
  pinMode(ledPinCh6, OUTPUT);
  digitalWrite(ledPinCh6, LOW);

  // настройка дисплея
  myGLCD.InitLCD(LANDSCAPE);
  myGLCD.clrScr();
  // настройка сенсора
  myTouch.InitTouch(LANDSCAPE);
  myTouch.setPrecision(PREC_MEDIUM);

  // читает EEPROM если нет сохраненных данных
  if (readEEonStart)
  {
    ReadFromEEPROM();
  }
  // читает значение RTC
  RTC.getTime();
  // включает свет
  LED_levels_output();

  // прорисовывает рамку, (позже переедет в отдельную функцию)
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRect(0, 0, 319, 239);
  myGLCD.fillRect(0, 226, 319, 239);
  changeFont(SMALL, 0, 0, 0, 255, 255, 255);
  myGLCD.print("Aquarium Controller", CENTER, 227);
  myGLCD.print("v.1.0", RIGHT, 227);
  // отрисовывает главный экран
  clearScreen();
  mainScreen(true);
  Serial.begin(9600);
}

void loop()
{
  unsigned long currentMillis = millis();

  if (myTouch.dataAvailable()) // проверяет сенсор
  {
    processMyTouch();
  }

  else if (currentMillis - prevMillis5 > 5000) // 5сек проверяем, что изменилось
  {
    prevMillis5 = currentMillis;
    RTC.getTime();
    LED_levels_output();

    if (dispScreen == 0)
      mainScreen();
  }
  else if (currentMillis - prevMillis600 > 600000) // 10 мин, проверяем состояние экрана
  {
    prevMillis600 = currentMillis;
    if (dispScreen != 0)
    {
      dispScreen = 0;
      clearScreen();
      mainScreen(true);
    }
  }
}

// --- Подключаем нужные библиотеки
// можно подключить и ненужные;)

// --- Инициализируем устройства
// Дисплей
// Сенсор
// Разные датчики

// --- Подключаем шрифты

// --- Назначаем выводы

// --- Настройки
// Задаём статические переменные

// --- Переменные
// Задаём глобальные переменные
// Номер Экрана
// Координаты Touch
// Счётчики
// Координаты кнопок

// --- Функции
// тут будут прописаны разные пассивные функции
// такие как:
// очистка экрана
// заголовок экрана
// работа с EEPROM
// работа со временем
// отображение всяких кнопок
// отображение информации на экране
// работа с сенсором

// ---
void setup()
{
// Функция setup() вызывается, когда стартует скетч.
// Используется для инициализации переменных,
// определения режимов работы выводов,
// запуска используемых библиотек и т.д.
// Функция setup запускает только один раз,
// после каждой подачи питания или сброса платы Arduino.
}

// ---
void loop()
{
// После вызова функции setup(),
// которая инициализирует и устанавливает первоначальные значения,
// функция loop() делает точь-в-точь то, что означает её название,
// и крутится в цикле,
// позволяя вашей программе совершать вычисления и реагировать на них.
// Используйте её для активного управления платой Arduino.
}