// P TEPLO

#include <LiquidCrystal_I2C.h>                // Подключаем библиотеку LiquidCrystal для работы с ЖК-дисплеем
#include <OneWire.h>                          // Библиотека для работы с шиной  1-Wire 
#include <DallasTemperature.h>                // Библиотека для работы с датчиками температуры 
#include "GyverTimer.h"                      // библиотека для назначение таймеров 
#include <EEPROM.h>
#include <SimpleKeypad.h>
#define REMOTEXY_MODE__ESP8266_HARDSERIAL_CLOUD
#include <RemoteXY.h>
//#include <ESP8266WiFi.h>
//#include <ESP8266AutoWifi.h>

OneWire T1(53);                                // Задаем пин для датчика 1 на шину 1-Wire с именем Т1 Дом
OneWire T2(52);                                // Задаем пин для датчика 2 на шину 1-Wire с именем Т2 Теплица
OneWire T3(51);                                // Задаем пин для датчика 3 на шину 1-Wire с именем Т3 Вентилятор
OneWire T4(50);                                // Задаем пин для датчика 4 на шину 1-Wire с именем Т4 Узел подмеса
OneWire T5(49);                                // Задаем пин для датчика 5 на шину 1-Wire с именем Т5 Дом воздух
OneWire T6(48);                                // Задаем пин для датчика 6 на шину 1-Wire с именем Т6 река проток


DallasTemperature sensors1(&T1);              // Датчик 1 на шине Т1
DallasTemperature sensors2(&T2);              // Датчик 2 на шине Т2
DallasTemperature sensors3(&T3);              // Датчик 3 на шине Т3
DallasTemperature sensors4(&T4);              // Датчик 4 на шине Т4
DallasTemperature sensors5(&T5);              // Датчик 5 на шине Т5
DallasTemperature sensors6(&T6);              // Датчик 6 на шине Т6


#define DOM1           12 // Контакт к которому подключено включение сервопривода обогрева дома 
#define DOM2          11 // контакт к которому подключено выключение сервопривода обогрева дома 
#define TEPL           10 
#define FAN1          9 // Контакт к которому подключена малая обмотка вентилятора
#define FAN2          8 // Контакт к которому подключена средняя обмотка вентилятора
#define FAN3          7 // Контакт к которому подключена большая обмотка вентилятора
#define SERVP1          6 // Контакт к которому подключено реле поворота сервопривода подмеса
#define SERVP2          5 // Контакт к которому подключено реле поворота сервопривода подмеса в другую сторону

#define F1          26 // Контакт к которому подключено включение сервопривода  обогрева вентилятора
#define F2          27 // Контакт к которому подключено выключение сервопривода обогрева вентилятора 
#define B1          28 // Контакт к которому подключено включение сервопривода  давления реки
#define B2          29 // Контакт к которому подключено выключение сервопривода давления реки
#define T1          32// Контакт к которому подключено включение сервопривода  теплицы
#define T2          33 //

#define DN          30 // Контакт к которому подключено включение насоса дома
#define HOT          31 // Контакт к которому подключено аварийое отключение
#define DOG                   44 // Контакт для сторожевого таймера

#define KP_ROWS  5 // количество строчек в клавиатуре
#define KP_COLS  4 // количество столбцов

// пины подключения (по порядку штекера)
byte colPins[KP_COLS] = {54, 55, 56, 57};
byte rowPins[KP_ROWS] = {62, 61, 60, 59, 58};
// массив имён кнопок
char keys[KP_ROWS][KP_COLS] = {
  {'A', 'B', 'C', 'D'},
  {'1', '2', '3', '^'},
  {'4', '5', '6', '!'},
  {'7', '8', '9', 'O'},
  {'<', '0', '>', 'E'}
};
// создаём клавиатуру
SimpleKeypad pad((char*)keys, rowPins, colPins, KP_ROWS, KP_COLS);

#define REMOTEXY_SERIAL Serial3
#define REMOTEXY_SERIAL_SPEED 115200

//const char* REMOTEXY_WIFI_SSID; 
//const char* REMOTEXY_WIFI_PASSWORD ="";


//char REMOTEXY_WIFI_SSID[30];
//char REMOTEXY_WIFI_PASSWORD[30];

//#define REMOTEXY_WIFI_SSID "DomClika"
//#define REMOTEXY_WIFI_PASSWORD "110320150"
#define REMOTEXY_WIFI_SSID "1"
#define REMOTEXY_WIFI_PASSWORD "12345679"
#define REMOTEXY_CLOUD_SERVER "cloud.remotexy.com"
#define REMOTEXY_CLOUD_PORT 6376
#define REMOTEXY_CLOUD_TOKEN "31268d1e7a3a36db3022eacdc5adf601"


// конфигурация интерфейса  
#pragma pack(push, 1)
uint8_t RemoteXY_CONF[] =   // 257 bytes
  { 255,19,0,125,0,250,0,17,0,0,0,31,1,126,200,1,1,24,0,67,
  6,4,25,9,4,2,26,9,67,6,16,25,9,4,2,26,9,67,6,29,
  25,9,4,2,26,9,67,35,4,25,9,4,2,26,9,67,35,16,25,9,
  4,2,26,9,67,35,29,25,9,4,2,26,9,67,64,4,25,9,4,2,
  26,9,67,64,16,25,9,4,2,26,9,67,64,29,25,9,4,2,26,9,
  67,93,4,25,9,4,2,26,9,67,93,16,25,9,4,2,26,9,67,93,
  29,25,9,4,2,26,9,67,5,122,114,11,4,2,26,11,69,88,164,25,
  25,0,1,71,4,156,41,41,56,0,2,24,135,0,0,0,0,0,0,52,
  66,0,0,32,65,0,0,160,64,0,0,128,63,24,0,1,11,56,12,12,
  0,2,31,0,1,12,96,12,12,0,2,31,0,1,41,55,12,12,0,2,
  31,0,1,42,95,12,12,0,2,31,0,1,70,55,12,12,0,2,31,0,
  1,71,95,12,12,0,2,31,0,1,101,55,12,12,0,2,31,0,1,102,
  95,12,12,0,2,31,0,7,5,140,113,11,36,2,26,2,11 };
  
// структура определяет все переменные и события вашего интерфейса управления 
struct {                                      

    // input variables
  uint8_t button_a_p; // =1 если кнопка нажата, иначе =0
  uint8_t button_a_m; // =1 если кнопка нажата, иначе =0
  uint8_t button_t_p; // =1 если кнопка нажата, иначе =0
  uint8_t button_t_m; // =1 если кнопка нажата, иначе =0
  uint8_t button_v_p; // =1 если кнопка нажата, иначе =0
  uint8_t button_v_m; // =1 если кнопка нажата, иначе =0
  uint8_t button_r_p; // =1 если кнопка нажата, иначе =0
  uint8_t button_r_m; // =1 если кнопка нажата, иначе =0
  char edit_com[11]; // string UTF8 end zero
    // output variables
  char text_A[9]; // =строка UTF8 оканчивающаяся нулем
  char text_a[9]; // =строка UTF8 оканчивающаяся нулем
  char text_inf[9]; // =строка UTF8 оканчивающаяся нулем
  char text_T[9]; // =строка UTF8 оканчивающаяся нулем
  char text_t[9]; // =строка UTF8 оканчивающаяся нулем
  char text_t_pos[9]; // =строка UTF8 оканчивающаяся нулем
  char text_V[9]; // =строка UTF8 оканчивающаяся нулем
  char text_v[9]; // =строка UTF8 оканчивающаяся нулем
  char text_v_pos[9]; // =строка UTF8 оканчивающаяся нулем
  char text_out[9]; // =строка UTF8 оканчивающаяся нулем
  char text_r[9]; // =строка UTF8 оканчивающаяся нулем
  char text_r_pos[9]; // =строка UTF8 оканчивающаяся нулем
  char text_com[11]; // =строка UTF8 оканчивающаяся нулем
  int16_t sound_alarm; // =0 нет звука, иначе ID звука, для примера 1001, смотри список звуков в приложении
  float instrument_pod; // oт 0 до 45

    // other variable
  uint8_t connect_flag;  // =1 if wire connected, else =0

} RemoteXY;
#pragma pack(pop)


int rcv = 0;

char remoty_str_text[8] = "";
char remoty_str[8] ="";
 
// переменные

LiquidCrystal_I2C lcd(0x27, 20, 4); // инициализация жк дисплея с переходником l2c помогает уменьшить количество проводов
////  Если надпись не появилась, замените адрес 0x27 на 0x3F
// установки температуры срабатывания контуров
float set_temp_air = 0;  // изначальная установка дома воздуха
float set_temp_tepl = 0;
float set_temp_fan =  0; // температура включения сервопривода вентилятора 
float set_temp_riv =  0; // температура реки
float set_temp_podmes = 0; // изначальная установка температуры на выходе из 3х позиционного клапана
float set_temp_home = 0;  // изначальная установка дома



//float fan_d = 0.4;
float set_temp_fan_1 = 0.5;
float set_temp_fan_2 = 1;  // добавляем включение обмотки через 3 градуса
float set_temp_fan_3 = 1.2;
float set_temp_hyst_home = 1; // изначальная установка гистерезиса дома
float set_temp_hyst_fan = 0;  // изначальная установка гистерезиса вентилятора

// установка коэфициентов 

float set_k_p = 7; // установка коэф подмеса используется для отклонения узла подмеса при уходе температуры за пределы установки

float set_k_t = 5;

float set_k = 5; // изначальная установка коэфициента для поворота сервопривода реки 
float set_incr_k = 6; // изначальная установка коэффициента при плохой динамике
float set_static_k = 1.6; // изначальная установка статичного коэффициента k при окончании шторма
float k_plus = 1; // коэфициент дополнительного усиления для подбора соотношения значение разности температур и процента поворота воды 

float temp_diff = 0; // разность последующе и пердыдуще температуры 

int incr = 0; //при плохой динамеке активируем счетчик сколько раз она была 
int stab = 0; //счетчик при улучшение динамики подмеса воды будет происходить вращение в обратную сторону для стабилизации 

int stability = 0; // включение и отключение режима
int increase = 0; // включение и отключение режима

float set_temp_diff = 0.4; // разница датчика температур для срабатывания обратного поворота

// те же коэф для сервопривода вулкана
float set_k_f = 5; // изначальная установка коэфициента для поворота сервопривода реки 
float set_incr_k_f = 12; // изначальная установка коэффициента при плохой динамике
float set_static_k_f = 3; // изначальная установка статичного коэффициента k при окончании шторма
float k_plus_f = 1; // коэфициент дополнительного усиления для подбора соотношения значение разности температур и процента поворота воды 

float temp_diff_f = 0; // разность последующе и пердыдуще температуры 

int incr_f = 0; //при плохой динамеке активируем счетчик сколько раз она была 
int stab_f = 0; //счетчик при улучшение динамики подмеса воды будет происходить вращение в обратную сторону для стабилизации 

int stability_f = 0;
int increase_f = 0;

float set_temp_diff_f = 0.4; // разница датчика температур для срабатывания обратного поворота



float set_time_podmes = 12; // изначальная установка времени опроса подмеса
float set_time_temp = 10; // период опроса сенсоров тепла

float time_P1 = 0; //время поворота узла подмеса в одну сторону
float time_P2 = 0; //время поворта в противоположную сторону
float time_R1 = 0;
float time_R2 = 0;
float time_V1 = 0;
float time_V2 = 0;
float time_T1 = 0;
float time_T2 = 0;

// время поворота сервоприводов для полного открытия и закрытия (120 секунд те которые мы купили +2-5 сек зазор)

float time_dom = 122000; // время поворота сервопривода дома на 90 град в с и задержки теплицы



float sensor_home = 30; // изначальные установки температур датчиков
float sensor_tepl = 25;
float sensor_fan = 30;
float sensor_podmes = 30;
float sensor_air = 21;
float sensor_out = 15;

float sensor_home_1 = 0; // изначальные установки температур датчиков
float sensor_tepl_1 = 0;
float sensor_fan_1 = 0;
float sensor_podmes_1 = 0;
float sensor_air_1 = 0;
float sensor_out_1 = 0;


// состояния включенных устройств

int d = 1; // фиксатор состояния клпана дома считаем изначально что выключен обогрев дома  
int v = 0; // фиксатор состояния клпана вентилятора считаем изначально что выключен обогрев вентилятора
int r = 0; //  фиксатор состояния реки считаем изначально что выключен обогрев реки
int t = 1; // фиксатор состояния теплицы
int h = 0; // фиксатор положения аварийного реле
int speed = 0; //скорость вентилятора


// аварийные режими работы 
int h_r_high = 0; // фиксатор состояния аварийной работы реки при выходе за пределы 2 градусов от установки
int r_cold_high = 0; // счетчик количества раз охлаждения 

int h_v_high = 0; // фиксатор состояния аварийной работы вулкана
int v_cold_high = 0; // счетчик количества раз охлаждения
int h_v_med = 0; // фиксатор состояния аварийной работы вулкана
int v_cold_med = 0; // счетчик количества раз охлаждения
int h_v_low = 0; // фиксатор состояния аварийной работы вулкана
int v_cold_low = 0; // счетчик количества раз охлаждения

float hot = 39;

int start = 0; //для старта и колибровки
int i = 0; //счетчик точечек

// положение клапана b и p и v
float p_1 = 0;
float p_1_min = 0;
float p_1_max = 99; // фиксатор состояния клапана подмеса
float percent_p_1 = 0;
float timer_pod_1 = 0;
float timer_pod_2 = 0;

float t_1 = 120000;
float t_1_min = 0;
float t_1_max = 100; // 
float percent_t_1 = 100;
float timer_t_1 = 0;
float timer_t_2 = 0;

float percent_d = 100;


float kol = 14400; // изначальное положение клапана 12%

float b = 0; // фиксатор состояния клапана давления  
float percent = 0;
float b_min = 0;  // минимальное значение закрытия клапана
float b_max = 99; 
float timer_a = 0; // таймер движения открытия
float timer_b = 0; // таймер движения закрытия 
int calibration = 0; // показывает пройдена ли колибровка

float kol_f = 48000; // изначальное положение открытия вулкана 40%

float op_fan = 0; // фиксатор состояния клапана давления  
float percent_f = 0;
float op_fan_min = 0; // минимальное значение закрытия клапана
float op_fan_max = 99;
float timer_c = 0; // таймер движения открытия
float timer_d = 0; // таймер движения закрытия 
int calibration_f = 0; // показывает пройдена ли колибровка

int winter = 0; // показывает зима или лето 
float set_winter = -1;

int screen3 = 0;

// описание таймеров
GTimer TimerP(MS); // время работы сервопривода > < создать миллисекундный таймер (ms)
GTimer TimerTEP(MS); 
GTimer TimerT(MS); // время опроса датчиков температуры 
GTimer TimerO(MS); // время опроса сработки подмеса
GTimer TimerD(MS); // время работы сервопривода > < для включения дома 

GTimer TimerB(MS); // время работы сервопривода  для колибровки
GTimer TimerSETB(MS); // время работы сервопривода > < для включения регулировки давления 

GTimer TimerSETV(MS); // время работы сервопривода > < для включения регулировки открытия вулкана
GTimer TimerV(MS); // время работы сервопривода для сработки колибровки


GTimer Timer1000(MS); // создаем вспомогательный таймер для того чтобы убрать задержку 750 мс при считывании датчика температуры(перевод с делея на таймер) 
GTimer Timer1200(MS); // 
GTimer Timer500(MS); // 

GTimer TimerDOG(MS); // сторожевой таймер

GTimer TimerBUT(MS);
GTimer TimerSCREEN3(MS);



int set_mode = 0;
int position = 0;
int cur = 0;
String strinput_key ="";
int screen = 1;
int minus = 0;
int unit = 0;
int in_num = 0;
float number = 0;
int input_number = 0;




String strData = ""; //для записи команд подаваемых ардуино
String strinput = "";
boolean recievedFlag;






// функция для расчета адаптации в сравенении предыдущего значения, текущего, и разницы их изменения
// на входе имеем: 1) температура до 2) текущая температура 3) установка разницы между установкой и температурой (дельта покоя)
// 4) установка значения 5) коэф к при спокойствии 6) коэф к при усилении
// на выходе имеем: 7) разница пред и тек значений 8) коэф усиления k 9) счетчик кол-ва раз сработки стабилизации 
//10)  счетчик кол-ва раз сработки усиления 11) переменная для включения усиления 12)переменная для включения стабилизации
void adaptation(float sensor_before, float sensor, float set_diff, float set, float static_k, float incr_k,
float& sensor_diff, float& k, int& counter_s, int& counter_i, int& mode_stab, int& mode_incr, int max_counter = 9)
{
  // описания действий в зависимости от предыдущей температуры и разности установленной температуры и текущей
  if ((abs(sensor - set) < set_diff) && (abs(sensor - sensor_before) < set_diff))
  {
    k = static_k;
    mode_stab = 0;
    counter_s = 0; // убираем стабилизацию разворот закончился
    mode_incr = 0;
    counter_i = 0; // усиление тоже закончилось
    //Serial.println("Режим покоя");

  }// если идет поворот в какую то сторону и это не помогает (динамика ухудшается) то необходимо увеличить коэффициент
  else if (((sensor > set) && (sensor > sensor_before)) || ((sensor < set) && (sensor < sensor_before))) 
  {
    k = incr_k;
    counter_i += 1; 
    //если каждая последующая температура больше предыдущей температуры на значение set_temp_diff например 0.4 это значит что динамика и так плохая так еще и ухудшается и наш коэф не справляется 
    if ((abs(sensor - sensor_before) > set_diff) && (((counter_i % 3) == 0) || (counter_i == 1)))  
    {
      sensor_diff = abs(sensor - sensor_before); // разница температур
      mode_incr = 1;// активируем режим усиления
    }
    mode_stab = 0;
    counter_s = 0; // убираем стабилизацию разворот закончился
    
  } // если идет поворот в какую то сторону но при этом динамика улучшается то надо остановить подмес (произошел разворот)
  else if (((sensor > set) && (sensor_before > sensor)) || ((sensor < set) && (sensor_before < sensor)))
  {
    k = 0; // останавливаем
    counter_s += 1; // добавляем такт 
    //сработает только когда счетчик будет равен 1 это первый такт и затем через 1 такт будет сработка чтобы дать время воде прогрется
    if ((abs(sensor - sensor_before) > set_diff) && (((counter_s % 3) == 0) || (counter_s == 1)) && (abs(sensor - set) < 3)) // если разворот слишком крутой и каждая следующая температура изменяется слишком быстро то крутим в обратную сторону  
    {
      sensor_diff = abs(sensor - sensor_before); // разница температур
      mode_stab = 1;// активируем режим стабилизации
    }
    else if (((abs(sensor - sensor_before) < 0.2) && (abs(sensor - set) > 0.8)) || (counter_s > max_counter)) // если уж слишком застоялась или никак не может подойти то отключаем стабилизацию
    {
      k = static_k;
    }
    counter_i = 0;
    mode_incr = 0; // усиление тоже закончилось
  }
  else if (sensor == sensor_before)
  {
    k = static_k;
    mode_stab = 0;
    counter_s = 0; // убираем стабилизацию разворот закончился
    mode_incr = 0;
    counter_i = 0; // усиление тоже закончилось
  }
}

void lcddisp(String position = "")// функция для отображения дисплея
{
  // первая строка 1 го экрана 
  if ((position == "sensor_air_eror") && (screen == 1) && ((set_mode % 2) == 0))
  {
    lcd.setCursor(1,0);
    lcd.print("    ");
    lcd.setCursor(1,0);
    lcd.print("Eror");
  }
  else if (((((position == "sensor_air") || (position == "screen1")) && ((set_mode % 2) == 0)) || (position == "set")) && (screen == 1))              
  {
    lcd.setCursor(0,0);      
    lcd.print("A");
    lcd.setCursor(1,0);
    lcd.print("    ");
    lcd.setCursor(1,0);
    lcd.print(sensor_air, 1);
  }

  if ((position == "sensor_tepl_eror") && (screen == 1) && ((set_mode % 2) == 0))
  {
    lcd.setCursor(7,0);
    lcd.print("     ");
    lcd.setCursor(7,0);
    lcd.print("Eror");
  }
  else if (((((position == "sensor_tepl") || (position == "screen1")) && ((set_mode % 2) == 0)) || (position == "set")) && (screen == 1))
  {
    lcd.setCursor(6,0);    // устанавливаем надпись и добавляем значение 
    lcd.print("T");
    lcd.setCursor(7,0);
    lcd.print("     ");      
    lcd.setCursor(7,0);
    lcd.print(sensor_tepl, 1);
  }

  if ((position == "sensor_fan_eror") && (screen == 1) && ((set_mode % 2) == 0))
  {
    lcd.setCursor(13,0);
    lcd.print("    ");
    lcd.setCursor(13,0);
    lcd.print("Eror");
  }
  else if (((((position == "sensor_fan") || (position == "screen1")) && ((set_mode % 2) == 0)) || (position == "set")) && (screen == 1))
  {
    lcd.setCursor(12,0);     // устанавливаем надпись и добавляем значение 
    lcd.print("V"); 
    lcd.setCursor(13,0);
    lcd.print("    ");      
    lcd.setCursor(13,0);
    lcd.print(sensor_fan, 1);
    lcd.setCursor(6,2);            
    lcd.print("R");
    lcd.setCursor(7,2);
    lcd.print("    ");
    lcd.setCursor(7,2);
    lcd.print(sensor_fan, 1);
  }
  // вторая строка 1 го экрана
  if (((position == "dom_percent") || (position == "screen1")) && (screen == 1) && ((set_mode % 2) == 0))
  {
    lcd.setCursor(0,1);     
    lcd.print("      ");
    lcd.setCursor(0,1);
    lcd.print(percent_d, 0);
    lcd.print("%");
  }

  if (((position == "tep_percent") || (position == "screen1")) && (screen == 1) && ((set_mode % 2) == 0))
  {  percent_t_1 = t_1 / 1200;
    lcd.setCursor(6,1);
    lcd.print("      ");
    lcd.setCursor(6,1);
    lcd.print(percent_t_1,0);
    lcd.print("%");
  }   

  if (((position == "vul_percent") || (position == "screen1")) && (screen == 1) && ((set_mode % 2) == 0))
  { 
    percent_f = op_fan / 1200;
    lcd.setCursor(12,1);
    lcd.print("      ");
    lcd.setCursor(12,1);
    lcd.print(percent_f,0);
    lcd.print("%");
    lcd.setCursor(18,1);
    lcd.print("  ");
    lcd.setCursor(18,1);    
    lcd.print(speed);
  }  
  // третья строка 1 го экрана 

  if ((position == "sensor_podmes_eror") && (screen == 1) && ((set_mode % 2) == 0))
  {
    lcd.setCursor(1,2);
    lcd.print("    ");
    lcd.setCursor(1,2);
    lcd.print("Eror");
  }
  else if (((((position == "sensor_podmes") || (position == "screen1")) && ((set_mode % 2) == 0)) || (position == "set")) && (screen == 1))
  {
    lcd.setCursor(0,2);
    lcd.print("P"); 
    lcd.setCursor(1,2);
    lcd.print("    ");
    lcd.setCursor(1,2);
    lcd.print(sensor_podmes, 1);
  }

  

  if ((position == "sensor_home_eror") && (screen == 1) && ((set_mode % 2) == 0))
  {
    lcd.setCursor(13,2);
    lcd.print("    ");
    lcd.setCursor(13,2);
    lcd.print("Eror");
  }
  else if (((((position == "sensor_home") || (position == "screen1")) && ((set_mode % 2) == 0)) || (position == "set")) && (screen == 1))
  {
    lcd.setCursor(12,2);     // устанавливаем надпись и добавляем значение  
    lcd.print("D");
    lcd.setCursor(13,2);
    lcd.print("     ");      
    lcd.setCursor(13,2);
    lcd.print(sensor_home, 1);
  }
  // четвертая строка 1го дисплея 
  if (((position == "pod_percent") || (position == "screen1")) && (screen == 1) && ((set_mode % 2) == 0))
  { 
    percent_p_1 = p_1 / 1200;
    lcd.setCursor(0,3);
    lcd.print("      ");
    lcd.setCursor(0,3);
    lcd.print(percent_p_1,0);
    lcd.print("%");
  } 

  if (((position == "riv_percent") || (position == "screen1")) && (screen == 1) && ((set_mode % 2) == 0))
  {
    percent = b / 1200;
    lcd.setCursor(6,3);
    lcd.print("      ");
    lcd.setCursor(6,3);
    lcd.print(percent,0);
    lcd.print("%");  
  }    

  if ((position == "sensor_out_eror") && ((set_mode % 2) == 0) && (screen == 1) && ((set_mode % 2) == 0))
  {
    lcd.setCursor(13,3);
    lcd.print("    ");
    lcd.setCursor(13,3);
    lcd.print("Eror");
  }
  else if (((position == "sensor_out") || (position == "screen1")) && (screen == 1) && ((set_mode % 2) == 0))
  {
    lcd.setCursor(12,3);            
    lcd.print("O");
    lcd.setCursor(13,3);
    lcd.print("     ");
    lcd.setCursor(13,3);
    lcd.print(sensor_out, 1);
  }

  if (((position == "wifi") || (position == "screen1")) && (screen == 1) && ((set_mode % 2) == 0))
  {
    lcd.setCursor(18,3);
    lcd.print("  ");
    lcd.setCursor(18,3);
    lcd.print("W");
    if (RemoteXY.connect_flag) lcd.print("1");
    else lcd.print("0"); 
  }
  


  
  
  
  // 1й экран режим установки
  
  if (((position == "set_temp_air") || (position == "set")) && (set_mode == 1) && (screen == 1))
  {
    lcd.setCursor(0,1);
    lcd.print("      ");   
    lcd.setCursor(0,1);
    lcd.print("a");
    lcd.print(set_temp_air,1);    
  }

  if (((position == "set_temp_tepl") || (position == "set")) && (set_mode == 1) && (screen == 1))
  {
    lcd.setCursor(6,1);
    lcd.print("      ");   
    lcd.setCursor(6,1);
    lcd.print("t");       
    lcd.print(set_temp_tepl,1);
  }

  if (((position == "set_temp_fan") || (position == "set")) && (set_mode == 1) && (screen == 1))
  {
    lcd.setCursor(12,1);
    lcd.print("      ");   
    lcd.setCursor(12,1);
    lcd.print("v");       
    lcd.print(set_temp_fan,1);   
  } 

  if (((position == "set_temp_podmes") || (position == "set")) && (set_mode == 1) && (screen == 1))
  {
    lcd.setCursor(0,3);
    lcd.print("      ");   
    lcd.setCursor(0,3);
    lcd.print("p");       
    lcd.print(set_temp_podmes,1);   
  } 

  if (((position == "set_temp_riv") || (position == "set")) && (set_mode == 1) && (screen == 1))
  {
    lcd.setCursor(6,3);
    lcd.print("      ");   
    lcd.setCursor(6,3);
    lcd.print("r");       
    lcd.print(set_temp_riv,1);    
  }

  if (((position == "set_temp_home") || (position == "set")) && (set_mode == 1) && (screen == 1))
  {
    lcd.setCursor(12,3);
    lcd.print("      ");       // очищаем ячейку чтобы при  уменьшении не оставались лишние цифры
    lcd.setCursor(12,3);
    lcd.print("d");
    lcd.print(set_temp_home,1);
  }  
  
  // 2й экран 
  if ((position == "screen2") && (screen == 2))
  { // 1 строка
    lcd.setCursor(0,0);
    lcd.print("sR");
    lcd.print(set_static_k,1);

    lcd.setCursor(6,0);
    lcd.print("iR");
    lcd.print(set_incr_k,1);

    lcd.setCursor(13,0);
    lcd.print("diR");
    lcd.print(set_temp_diff,1);

  // 2 строка
    lcd.setCursor(0,1);
    lcd.print("sF");
    lcd.print(set_static_k_f,1);

    lcd.setCursor(6,1);
    lcd.print("iF");
    lcd.print(set_incr_k_f,1);
    
    lcd.setCursor(13,1);
    lcd.print("diF");
    lcd.print(set_temp_diff_f,1);
  // 3 строка

    lcd.setCursor(0,2);
    lcd.print("w");
    lcd.print(set_winter,0);
    
    lcd.setCursor(4,2);
    lcd.print("h");
    lcd.print(hot,0);
    
    lcd.setCursor(8,2);
    lcd.print("pR");
    lcd.print(k_plus,1);
    
    lcd.setCursor(14,2);
    lcd.print("pF");
    lcd.print(k_plus_f,1); 
  // 4 строка

    lcd.setCursor(0,3);
    lcd.print("1f");
    lcd.print(set_temp_fan_1,1);
    lcd.setCursor(6,3);
    lcd.print("2f");
    lcd.print(set_temp_fan_2,1);
    lcd.setCursor(12,3);
    lcd.print("3f");
    lcd.print(set_temp_fan_3,1);
    

  }

  // 3й экран

  if ((position == "screen3") && (screen == 3) && ((set_mode % 2) == 0))
  {
    if (screen3 == 0)
    {
      lcd.setCursor(0,0);
      lcd.print("A-home_air T-teplits");
      lcd.setCursor(0,1);
      lcd.print("V-Vulkan P-Podmes");
      lcd.setCursor(0,2);
      lcd.print("R-River D-home water");
      lcd.setCursor(0,3);
      lcd.print("O-outside air W-WiFi");
    }
    else if (screen3 == 1)
    {
      lcd.setCursor(0,0);
      lcd.print("sR-stability River");
      lcd.setCursor(0,1);
      lcd.print("iR-increase River");
      lcd.setCursor(0,2);
      lcd.print("diR-pokoy River");
      lcd.setCursor(0,3);
      lcd.print("sF iF diF-for Fan");
    }
    else if (screen3 == 2)
    {
      lcd.setCursor(0,0);
      lcd.print("w-winter begin");
      lcd.setCursor(0,1);
      lcd.print("h-hot alarm off");
      lcd.setCursor(0,2);
      lcd.print("pRpF-incr razvorot");
      lcd.setCursor(0,3);
      lcd.print("123f-start vulk vent");
    }
    
  }

  
  
  
} 



 

void action(String command, float time = 0) // функция действия и запуска таймера если он нужен
{
  if (command == "dom_on")
  {
    digitalWrite(DOM2, HIGH);// Выключаем отключение обогрева дома(включаем обогрев)
    digitalWrite(DOM1, LOW);// Включаем дом и обновляем значок активности на включен
    TimerD.setTimeout(time);
    
    d = 1;  // устанавливаем положение включенного дома 
    digitalWrite(DN, LOW);// Включаем циркуляционный насос дома
    Serial2.println("dom_on");
  }
  else if (command == "dom_off")
  {
    digitalWrite(DOM1, HIGH);  // Выключаем дом и обновляем значок активности
    digitalWrite(DOM2, LOW);   // Включаем выключение обогрева дома 
    TimerD.setTimeout(time);
    
    d = 0;  // устанавливаем положение выклюенного дома
    Serial2.println("dom_off");
  }
  else if (command == "riv_open")
  {
    digitalWrite(B2, HIGH);  // открываем 
    digitalWrite(B1, LOW);
    if (calibration == 1) TimerSETB.setTimeout(time);
    else TimerB.setTimeout(time);
    timer_a = millis();
    // выводим значок стрелочки мол сервопривод работает
  }
  else if (command == "riv_close")
  {
    digitalWrite(B1, HIGH);  // закрываем
    digitalWrite(B2, LOW);
    if (calibration == 1) TimerSETB.setTimeout(time);
    else TimerB.setTimeout(time);
    timer_b = millis();
     // выводим значок стрелочки мол сервопривод работает
  }
  else if (command == "riv_stop")
  {
    digitalWrite(B1, HIGH); // выключаем сервопривод 
    digitalWrite(B2, HIGH); // выключаем сервопривод 
    TimerSETB.stop();
    
  }
  else if (command == "vul_open")
  {
    digitalWrite(F2, HIGH);  // открываем 
    digitalWrite(F1, LOW);
    if (calibration_f == 1) TimerSETV.setTimeout(time);
    else TimerV.setTimeout(time);
    timer_c = millis();
     // выводим значок стрелочки мол сервопривод работает
  }   
  else if (command == "vul_close")
  {
    digitalWrite(F1, HIGH);  // закрываем
    digitalWrite(F2, LOW);
    if (calibration_f == 1) TimerSETV.setTimeout(time);
    else TimerV.setTimeout(time);
    timer_d = millis();
     // выводим значок стрелочки мол сервопривод работает
  }  
  else if (command == "vul_stop")
  {
    digitalWrite(F1, HIGH); // выключаем сервопривод 
    digitalWrite(F2, HIGH); // выключаем сервопривод 
    TimerSETV.stop();
    
  }
  else if (command == "pod_open")
  {
    digitalWrite(SERVP2, HIGH);   // выключаем реле сервопривода
    digitalWrite(SERVP1, LOW); // включаем в другую сторону
    TimerP.setTimeout(time);   // запустить таймер для отсчета времени работы реле
    timer_pod_1 = millis();
    // выводим значок стрелочки мол сервопривод работает
    
  }   
  else if (command == "pod_close")
  {
    digitalWrite(SERVP1, HIGH);   // выключаем реле сервопривода
    digitalWrite(SERVP2, LOW); // включаем в другую сторону
    TimerP.setTimeout(time);   // запустить таймер для отсчета времени работы реле
    timer_pod_2 = millis();
    
  }  
  else if (command == "pod_stop")
  {
    digitalWrite(SERVP1, HIGH); // выключаем реле
    digitalWrite(SERVP2, HIGH); // выключаем реле
    TimerP.stop();
    
  }  
  else if (command == "tep_open")
  {
    digitalWrite(T2, HIGH);   // выключаем реле сервопривода
    digitalWrite(T1, LOW); // включаем в другую сторону
    TimerTEP.setTimeout(time);   // запустить таймер для отсчета времени работы реле
    timer_t_1 = millis();
    // выводим значок стрелочки мол сервопривод работает

    
  }   
  else if (command == "tep_close")
  {
    digitalWrite(T1, HIGH);   // выключаем реле сервопривода
    digitalWrite(T2, LOW); // включаем в другую сторону
    TimerTEP.setTimeout(time);   // запустить таймер для отсчета времени работы реле
    timer_t_2 = millis();
   
  }  
  else if (command == "tep_stop")
  {
    digitalWrite(T1, HIGH); // выключаем реле
    digitalWrite(T2, HIGH); // выключаем реле
    TimerTEP.stop();
    
  }                                     
}

void fix(String stop, String display, float& timer_plus, float& timer_minus, float& position) // функция для колибровкии и фиксации положения
{
  if (timer_plus != 0)
  {
    position += (millis() - timer_plus); // фиксируем положение
  }
  else if (timer_minus != 0)
  {
    position -= (millis() - timer_minus); 
  }
  timer_plus = 0; 
  timer_minus = 0;
  action(stop);
  lcddisp(display);
}

void calibr(String open, String close, String display, float cal, float& position, int& complete)
{
  if (position > 0) // если клапан не закрыт колибруем 
  {      
    if ((cal - position) > 0)
    {
      action(open, (cal - position));
    }
    else if ((cal - position) < 0)
    {
      action(close, (position - cal));
    }
    else if (position == cal) complete = 1; // включаем работу потока воды
  }
  else  
  {
    action(open, cal);
    position = 0;
    lcddisp(display);
  }
}

// функция для поворота сервопривода 
// на вход подаётся 6 параметров 1,2  команды 3- текущее положение сервопривода , 4,5 - минимальный уровень и максимальный
void rotation_act(String command, String effect, float time, float& position, float minimum, float maximum)
{
  //Serial2.print("Command: ");
  //Serial2.println(command);
  //Serial2.print("effect: ");
  //Serial2.println(effect);
  //Serial2.print("position: ");
  //Serial2.println((position/1200));
  //Serial2.print("time: ");
  //Serial2.println((time));
  //Serial2.print("maximum: ");
  //Serial2.println(maximum * 1200);
  if (command == "rotation_close")
  {
    if ((position - time) >= (minimum * 1200)) // проверяем что воздействие точно не закроет нам клапан
    {
      action(effect, time);// запустить таймер для отсчета времени работы реле
    }
    else if ((position - (minimum * 1200)) > 0) // если воздействие слишком большое формируем малое воздействия для отклонения в предельное значение 
    {
      time = position - (minimum * 1200); // формируем воздействие для отклонения в предельное положение
      action(effect, time);
    } 
  }
  else if (command == "rotation_open")
  {
    if ((position + time) <= (maximum * 1200)) // проверяем что воздействие не откроет больше максимума
    {
      action(effect, time);// открываем 
    }
    else if (((maximum * 1200) - position) > 0) // если воздействие слишком большое формируем малое воздействия для отклонения в предельное значение max%
    {
      time = (maximum * 1200) - position;
      action(effect, time);// открываем 
    }
  }

  if (position < 0) position = 0 ;
  else if (position > 120000) position = 120000;

}

void set_cursor(int uni, int num) // функция определения курсора в режиме установки значений в зависимости от того какой символ вводится перемещается курсор
{
  
  if (screen == 1)
  {
    if ((uni == 0) && (num == 0)) lcd.setCursor(1+minus,1);
    else if ((uni == 0) && (num == 1)) lcd.setCursor(2+minus,1);
    else if ((uni == 0) && (num == 2)) lcd.setCursor(4+minus,1);
    else if ((uni == 1) && (num == 0)) lcd.setCursor(7+minus,1);
    else if ((uni == 1) && (num == 1)) lcd.setCursor(8+minus,1);
    else if ((uni == 1) && (num == 2)) lcd.setCursor(10+minus,1);
    else if ((uni == 2) && (num == 0)) lcd.setCursor(13+minus,1);
    else if ((uni == 2) && (num == 1)) lcd.setCursor(14+minus,1);
    else if ((uni == 2) && (num == 2)) lcd.setCursor(16+minus,1);
    else if ((uni == 3) && (num == 0)) lcd.setCursor(1+minus,3);
    else if ((uni == 3) && (num == 1)) lcd.setCursor(2+minus,3);
    else if ((uni == 3) && (num == 2)) lcd.setCursor(4+minus,3);
    else if ((uni == 4) && (num == 0)) lcd.setCursor(7+minus,3);
    else if ((uni == 4) && (num == 1)) lcd.setCursor(8+minus,3);
    else if ((uni == 4) && (num == 2)) lcd.setCursor(10+minus,3);
    else if ((uni == 5) && (num == 0)) lcd.setCursor(13+minus,3);
    else if ((uni == 5) && (num == 1)) lcd.setCursor(14+minus,3);
    else if ((uni == 5) && (num == 2)) lcd.setCursor(16+minus,3);
  }
  else if (screen == 2)
  {
    if ((uni == 0) && (num == 0)) lcd.setCursor(2+minus,0);
    else if ((uni == 0) && (num == 1)) lcd.setCursor(4+minus,0);
    else if ((uni == 1) && (num == 0)) lcd.setCursor(8+minus,0);
    else if ((uni == 1) && (num == 1)) lcd.setCursor(9+minus,0);
    else if ((uni == 1) && (num == 2)) lcd.setCursor(11+minus,0);
    else if ((uni == 2) && (num == 0)) lcd.setCursor(16+minus,0);
    else if ((uni == 2) && (num == 1)) lcd.setCursor(18+minus,0);
    else if ((uni == 3) && (num == 0)) lcd.setCursor(2+minus,1);
    else if ((uni == 3) && (num == 1)) lcd.setCursor(4+minus,1);
    else if ((uni == 4) && (num == 0)) lcd.setCursor(8+minus,1);
    else if ((uni == 4) && (num == 1)) lcd.setCursor(9+minus,1);
    else if ((uni == 4) && (num == 2)) lcd.setCursor(11+minus,1);
    else if ((uni == 5) && (num == 0)) lcd.setCursor(16+minus,1);
    else if ((uni == 5) && (num == 1)) lcd.setCursor(18+minus,1);
    else if ((uni == 6) && (num == 0)) lcd.setCursor(1+minus,2);
    else if ((uni == 6) && (num == 1)) lcd.setCursor(2+minus,2);
    else if ((uni == 7) && (num == 0)) lcd.setCursor(5+minus,2);
    else if ((uni == 7) && (num == 1)) lcd.setCursor(6+minus,2);
    else if ((uni == 8) && (num == 0)) lcd.setCursor(10+minus,2);
    else if ((uni == 8) && (num == 1)) lcd.setCursor(12+minus,2);
    else if ((uni == 9) && (num == 0)) lcd.setCursor(16+minus,2);
    else if ((uni == 9) && (num == 1)) lcd.setCursor(18+minus,2);
    else if ((uni == 10) && (num == 0)) lcd.setCursor(2+minus,3);
    else if ((uni == 10) && (num == 1)) lcd.setCursor(4+minus,3);
    else if ((uni == 11) && (num == 0)) lcd.setCursor(8+minus,3);
    else if ((uni == 11) && (num == 1)) lcd.setCursor(10+minus,3);
    else if ((uni == 12) && (num == 0)) lcd.setCursor(14+minus,3);
    else if ((uni == 12) && (num == 1)) lcd.setCursor(16+minus,3);
  }
}

// функция подсчета принятых символов и образования чисел
// next_unit_f - позиция куда записываем число in_num_f - порядковый номер цифры в числе val - значение цифры
// number_f - итоговое число
void enumerate_numbers(int next_unit_f, int& in_num_f, int val, float& number_f) 
{
  if ((in_num_f == 2) && (screen == 1)) // третья цифра
  {
    number_f += 0.1 * val; 
    if (next_unit_f == 0) set_temp_air = number_f;
    else if (next_unit_f == 1) {set_temp_tepl = number_f; minus = 0;}
    else if (next_unit_f == 2) set_temp_fan = number_f;
    else if (next_unit_f == 3) set_temp_riv = number_f;
    else if (next_unit_f == 4) set_temp_podmes = number_f;
    else if (next_unit_f == 5) set_temp_home = number_f;
    number_f = 0; // обнуляем число приняли
    in_num_f = 0; // обнуляем порядковый номер цифры числа
  }
  else if ((in_num_f == 1) && (screen == 1)) // вторая цифра
  {
    number_f += val;
    in_num_f += 1; // пришел второй символ значит дальше должен быть третий  
    // раз уж пришли все цифры записываем получившееся число в установку
    
  }
  else if ((in_num_f == 0) && (screen == 1)) // первая цифра
  {
    number_f = 10 * val; 
    in_num_f += 1; // пришел первый символ значит дальше должен быть второй
  }


  if ((in_num_f == 2) && (screen == 2) && ((next_unit_f == 1) || (next_unit_f == 4))) // третья цифра
  {
    number_f += 0.1 * val; 
    if (next_unit_f == 1) set_incr_k = number_f;
    else if (next_unit_f == 4) set_incr_k_f = number_f;
    number_f = 0; // обнуляем число приняли
    in_num_f = 0; // обнуляем порядковый номер цифры числа
  }
  else if ((in_num_f == 1) && (screen == 2)) // вторая цифра
  {
    if ((next_unit_f == 1) || (next_unit_f == 4))
    {
      number_f += val;
      in_num_f += 1; // пришел второй символ значит дальше должен быть третий  
    }
    else if ((next_unit_f == 6) || (next_unit_f == 7))
    {
      number_f += val;
      if (next_unit_f == 6) {set_winter = number_f; minus = 0;}
      else if (next_unit_f == 7) hot = number_f;
      number_f = 0; // обнуляем число приняли
      in_num_f = 0; // обнуляем порядковый номер цифры числа
    }
    else
    {
      number_f += 0.1 * val; 
      if (next_unit_f == 0) set_static_k = number_f;
      else if (next_unit_f == 2) set_temp_diff = number_f;
      else if (next_unit_f == 3) set_static_k_f = number_f;
      else if (next_unit_f == 5) set_temp_diff_f = number_f;
      else if (next_unit_f == 8) k_plus = number_f;
      else if (next_unit_f == 9) k_plus_f = number_f;
      else if (next_unit_f == 10) set_temp_fan_1 = number_f;
      else if (next_unit_f == 11) set_temp_fan_2 = number_f;
      else if (next_unit_f == 12) set_temp_fan_3 = number_f;
      number_f = 0; // обнуляем число приняли
      in_num_f = 0; // обнуляем порядковый номер цифры числа
    }
    
  }
  else if ((in_num_f == 0) && (screen == 2)) // первая цифра
  {
    if ((next_unit_f == 1) || (next_unit_f == 4) || (next_unit_f == 6) || (next_unit_f == 7))
    {
      number_f = 10 * val; // для 2хзначных переменных
      in_num_f += 1; // пришел первый символ значит дальше должен быть второй
    }
    else 
    {
      number_f = val;  // для однозначных переменных
      in_num_f += 1; // пришел первый символ значит дальше должен быть второй
    }
  }
  
}

void remote_disp(float value, String show, String place, int aft_zer, int first_show)
{ 
  //char remoty_str[8] = "";
  //char remoty_str_text[8]= "";

  show.toCharArray(remoty_str_text, 8);
  dtostrf(value, 0, aft_zer,  remoty_str); // преобразуем флоат в char
  
  if (first_show == 1) strcat(remoty_str_text, remoty_str); // складываем 2 текста
  else strcat(remoty_str, remoty_str_text);
  

  if (place == "text_a") strcpy (RemoteXY.text_a, remoty_str_text); 
  else if (place == "text_t") strcpy (RemoteXY.text_t, remoty_str_text); 
  else if (place == "text_v") strcpy (RemoteXY.text_v, remoty_str_text); 
  else if (place == "text_r") strcpy (RemoteXY.text_r, remoty_str_text); 
  else if (place == "text_A") strcpy (RemoteXY.text_A, remoty_str_text); 
  else if (place == "text_T") strcpy (RemoteXY.text_T, remoty_str_text); 
  else if (place == "text_V") strcpy (RemoteXY.text_V, remoty_str_text); 
  else if (place == "text_t_pos") strcpy (RemoteXY.text_t_pos, remoty_str); 
  else if (place == "text_v_pos") strcpy (RemoteXY.text_v_pos, remoty_str); 
  else if (place == "text_r_pos") strcpy (RemoteXY.text_r_pos, remoty_str);
  else if (place == "text_inf") strcpy (RemoteXY.text_inf, remoty_str); 
  else if (place == "text_out") strcpy (RemoteXY.text_out, remoty_str_text); 
  else if (place == "text_com") strcpy (RemoteXY.text_com, remoty_str_text); 
}



void setup() {

  //const char* REMOTEXY_WIFI_SSID = "NETGEAR";
  //const char* REMOTEXY_WIFI_PASSWORD = "12345679";

  // ;

  
  
  RemoteXY_Init();

  //remotexy = new CRemoteXY (RemoteXY_CONF_PROGMEM, &RemoteXY, REMOTEXY_ACCESS_PASSWORD, &REMOTEXY_SERIAL, REMOTEXY_SERIAL_SPEED, REMOTEXY_WIFI_SSID, REMOTEXY_WIFI_PASSWORD, REMOTEXY_CLOUD_SERVER, REMOTEXY_CLOUD_PORT, REMOTEXY_CLOUD_TOKEN);

  

  EEPROM.get(0,set_temp_air); // 
  EEPROM.get(4,set_temp_tepl);
  EEPROM.get(8,set_temp_fan); // 
  EEPROM.get(12,set_temp_riv);
  EEPROM.get(16,set_temp_podmes); // 
  EEPROM.get(20,set_temp_home);
  
  if (isnan(set_temp_air)) set_temp_air = 22;
  if (isnan(set_temp_tepl)) set_temp_tepl = 35;
  if (isnan(set_temp_fan)) set_temp_fan =  34.8;
  if (isnan(set_temp_riv)) set_temp_riv = 37;
  if (isnan(set_temp_podmes)) set_temp_podmes = 25;
  if (isnan(set_temp_home)) set_temp_home = 45;

  EEPROM.get(24,set_static_k); // 
  EEPROM.get(28,set_incr_k);
  EEPROM.get(32,set_temp_diff); // 
  EEPROM.get(36,set_static_k_f);
  EEPROM.get(40,set_incr_k_f); // 
  EEPROM.get(44,set_temp_diff_f);
  EEPROM.get(48,set_winter); // 
  EEPROM.get(52,hot);
  EEPROM.get(56,k_plus); // 
  EEPROM.get(60,k_plus_f);
  EEPROM.get(64,set_temp_fan_1); // 
  EEPROM.get(68,set_temp_fan_2);
  EEPROM.get(72,set_temp_fan_3); // 

  if (isnan(set_static_k)) set_static_k = 1.6;
  if (isnan(set_incr_k)) set_incr_k = 6;
  if (isnan(set_temp_diff)) set_temp_diff =  0.4;
  if (isnan(set_static_k_f)) set_static_k_f = 3;
  if (isnan(set_incr_k_f)) set_incr_k_f = 12;
  if (isnan(set_temp_diff_f)) set_temp_diff_f = 0.4;
  if (isnan(set_winter)) set_winter = -1;
  if (isnan(hot)) hot = 39;
  if (isnan(k_plus)) k_plus =  1;
  if (isnan(k_plus_f)) k_plus_f = 1;
  if (isnan(set_temp_fan_1)) set_temp_fan_1 = 0.5;
  if (isnan(set_temp_fan_2)) set_temp_fan_2 = 1;
  if (isnan(set_temp_fan_3)) set_temp_fan_3 = 1.2;




  TimerT.setInterval(set_time_temp * 1000);   // запуск в режиме заданного интервала опроса сенсоров температуры
  TimerO.setInterval(set_time_podmes * 1000);   // запуск в режиме заданного интервала опроса установки температуры подмеса 

  TimerDOG.setInterval(4000);

  Timer1000.setTimeout(1000); // запуск в режиме выключения вспомогательного таймера (убираем задержку из библиотеки даласа)
  Timer1000.stop();

  Timer1200.setInterval(1200); // запуск в режиме заданного интервала 
  Timer500.setInterval(500); // запуск в режиме заданного интервала 

  TimerSCREEN3.setInterval(8000);
  TimerSCREEN3.stop();
  TimerBUT.setTimeout(500);

  Serial2.begin(115200);
  sensors1.begin();                           // Инициализируем датчик 1  
  sensors2.begin();                           // Инициализируем датчик 2
  sensors3.begin();                           // Инициализируем датчик 3
  sensors4.begin();                           // Инициализируем датчик 4
  sensors5.begin();                           // Инициализируем датчик 5
  sensors6.begin();                           // Инициализируем датчик 6

  Serial2.setTimeout(10);

  

  pinMode(DOM1, OUTPUT);      // устанавливает режим работы - выход
  pinMode(TEPL, OUTPUT);      // устанавливает режим работы - выход
  pinMode(DOM2, OUTPUT);      // устанавливает режим работы - выход
  pinMode(FAN1, OUTPUT);      // устанавливает режим работы - выход
  pinMode(FAN2, OUTPUT);      // устанавливает режим работы - выход
  pinMode(FAN3, OUTPUT);      // устанавливает режим работы - выход
  pinMode(SERVP1, OUTPUT);      // устанавливает режим работы - выход
  pinMode(SERVP2, OUTPUT);      // устанавливает режим работы - выход
  pinMode(F1, OUTPUT);      // устанавливает режим работы - выход
  pinMode(F2, OUTPUT);      // устанавливает режим работы - выход
  pinMode(DN, OUTPUT);      // устанавливает режим работы - выход
  pinMode(B1, OUTPUT);      // устанавливает режим работы - выход
  pinMode(B2, OUTPUT);      // устанавливает режим работы - выход
  pinMode(T1, OUTPUT);      // устанавливает режим работы - выход
  pinMode(T2, OUTPUT);      // устанавливает режим работы - выход
  pinMode(HOT, OUTPUT);      // устанавливает режим работы - выход
  pinMode(DOG, OUTPUT);

 
  digitalWrite(DOM1, HIGH); // изначально дом выключен приходится ставить HIGH т к реле срабатывает от низкого сигнала
  digitalWrite(DOM2, HIGH); // изначально дом выключен приходится ставить HIGH т к реле срабатывает от низкого сигнала
  digitalWrite(FAN1, HIGH);
  digitalWrite(FAN2, HIGH);
  digitalWrite(FAN3, HIGH);
  digitalWrite(SERVP1, HIGH);
  digitalWrite(SERVP2, HIGH);
  digitalWrite(F1, HIGH);
  digitalWrite(F2, HIGH);
  digitalWrite(DN, HIGH);
  digitalWrite(TEPL, HIGH);
  digitalWrite(B1, HIGH);
  digitalWrite(B2, HIGH);
  digitalWrite(T1, HIGH);
  digitalWrite(T2, HIGH);
  digitalWrite(HOT, HIGH);
  digitalWrite(DOG, HIGH);

 
  
  

  
  
  //lcd.print(((float)((int)(sensor_home * 10)))/10, 1);    // отсекаем значение до десятых простым способом

  lcd.init();
  lcd.backlight();
 
  
  lcd.setCursor(0,0);       // устанавливаем на каждой позиции свою надпись
  lcd.print("BATYA_MINER #-help");
  lcd.setCursor(0,1);
  lcd.print("VER_2.0");
  lcd.print(" skip press *");
 
  lcd.setCursor(0,2);
  lcd.print("Colibration");
  lcd.setCursor(0,3);
  lcd.print("Processing...:");
  lcd.setCursor(14,3);
  lcd.print("0");
  Serial2.println("Colibration");
  Serial2.println("Processing...:");

  digitalWrite(DOM1, LOW); // открываем дом
  digitalWrite(DN, LOW);
  digitalWrite(SERVP2, LOW); // включаем холод подмеса
  digitalWrite(F2, LOW); // закрываем вулкан
  digitalWrite(B2, LOW); // закрываем реку
  digitalWrite(T1, LOW); // открываем теплиц
  digitalWrite(TEPL, LOW); // включаем насос теплицы
  


  while (start != 100)
  {
    char key = pad.getKey();// режим нажатия позволяет избежать двойного нажатия
    if (key) // если кнопка нажата (не 0 символ) 
    {
      strinput_key += key; // делаем переход на string 
      if (strinput_key == "D") start = 99; 
      strinput_key = ""; 
    }    
    if (Timer500.isReady())
    {
      if (i == 3)
      {
        i = 0;
      }

      if (i == 0)
      {
        lcd.setCursor(10,3);
        lcd.print("   ");
        lcd.setCursor(10,3);
        lcd.print(".");
        i += 1;
      }
      else if (i == 1)
      {
        lcd.setCursor(10,3);
        lcd.print("   ");
        lcd.setCursor(10,3);
        lcd.print("..");
        i += 1;
      }
      else
      {
        lcd.setCursor(10,3);
        lcd.print("   ");
        lcd.setCursor(10,3);
        lcd.print("...");
        i += 1;
      }
    }
    if (Timer1200.isReady())
    {
      start += 1;
      lcd.setCursor(14,3);
      lcd.print(start);
      lcd.print("%");
      Serial2.print(start);
      Serial2.println("%");
    }
  }
  Timer1200.stop();
  Timer500.stop();

  lcd.setCursor(0,3);
  lcd.print("                   ");
  lcd.setCursor(0,3);
  lcd.print("Completed !");
  Serial2.println("Completed !");

  RemoteXY_delay(2000);
  
  digitalWrite(DOM1, HIGH); // изначально дом выключен приходится ставить HIGH т к реле срабатывает от низкого сигнала
  digitalWrite(DOM2, HIGH); // изначально дом выключен приходится ставить HIGH т к реле срабатывает от низкого сигнала
  digitalWrite(FAN1, HIGH);
  digitalWrite(FAN2, HIGH);
  digitalWrite(FAN3, HIGH);
  digitalWrite(SERVP1, HIGH);
  digitalWrite(SERVP2, HIGH);
  digitalWrite(F1, HIGH);
  digitalWrite(F2, HIGH);
  digitalWrite(DN, HIGH);
  digitalWrite(TEPL, LOW);
  digitalWrite(B1, HIGH);
  digitalWrite(B2, HIGH);
  digitalWrite(T1, HIGH);
  digitalWrite(T2, HIGH);
  digitalWrite(HOT, HIGH);
  digitalWrite(DOG, LOW);


  lcd.clear();
  lcddisp("screen1");// вызываем функцию дисплей 

}

 
void loop()
{
  RemoteXY_Handler ();

// следующий блок считывает температуру 
  if (TimerT.isReady())   // Вводим цикл который будет срабатывать только раз в определенное время
  {    
    sensors4.setWaitForConversion(false);  // makes it async помогает избавится от delay 
    sensors4.requestTemperatures();           // Запрашиваем регистрацию температуры на датчике 4
    sensors4.setWaitForConversion(true); 

    sensors3.setWaitForConversion(false);  // makes it async  
    sensors3.requestTemperatures();           // Запрашиваем регистрацию температуры на датчике 3
    sensors3.setWaitForConversion(true);                 

    sensors2.setWaitForConversion(false);  // makes it async  
    sensors2.requestTemperatures();           // Запрашиваем регистрацию температуры на датчике 2
    sensors2.setWaitForConversion(true);                  

    sensors1.setWaitForConversion(false);  // makes it async  
    sensors1.requestTemperatures();           // Запрашиваем регистрацию температуры на датчике 1
    sensors1.setWaitForConversion(true);    

    sensors5.setWaitForConversion(false);  // makes it async  
    sensors5.requestTemperatures();           // Запрашиваем регистрацию температуры на датчике 1
    sensors5.setWaitForConversion(true);  

    sensors6.setWaitForConversion(false);  // makes it async  
    sensors6.requestTemperatures();           // Запрашиваем регистрацию температуры на датчике 1
    sensors6.setWaitForConversion(true);                

    Timer1000.start();   // запустить таймер для отсчета времени работы датчика температуры 
  
  }

  if (Timer1000.isReady())
  {
    sensor_out_1 = sensors6.getTempCByIndex(0);
    sensor_out_1 = ((float)((int)(sensor_out_1 * 10)))/10;

    sensor_air_1 = sensors5.getTempCByIndex(0);

    sensor_podmes_1 = sensors4.getTempCByIndex(0);
    sensor_podmes_1 = ((float)((int)(sensor_podmes_1 * 10)))/10; 

    sensor_fan_1 = sensors3.getTempCByIndex(0);
    //sensor_fan_1 = 37;
    sensor_fan_1 = ((float)((int)(sensor_fan_1 * 10)))/10;

    sensor_tepl_1 = sensors2.getTempCByIndex(0);
    sensor_home_1 = sensors1.getTempCByIndex(0);

   



    // вводим ограничения в случае с поломкой датчика 
    if ((sensor_out_1 > 80) || (sensor_out_1 < -50)) {lcddisp("sensor_out_eror");}
    else {sensor_out = sensor_out_1; lcddisp("sensor_out");} // Снимаем показания с датчика 6
    
    if ((sensor_air_1 > 90) || (sensor_air_1 < -50)) {lcddisp("sensor_air_eror");}
    else {sensor_air = sensor_air_1; lcddisp("sensor_air");} // Снимаем показания с датчика 5
    
    if ((sensor_podmes_1 > 90) || (sensor_podmes_1 < -50)) {lcddisp("sensor_podmes_eror");}
    else {sensor_podmes = sensor_podmes_1; lcddisp("sensor_podmes");}// Снимаем показания с датчика 4
    
    if ((sensor_fan_1 > 90) || (sensor_fan_1 < -50)) {lcddisp("sensor_fan_eror");}
    else 
    {
      adaptation(sensor_fan, sensor_fan_1, set_temp_diff, set_temp_fan, set_static_k, set_incr_k,
      temp_diff, set_k, stab, incr, stability, increase);

      adaptation(sensor_fan, sensor_fan_1, set_temp_diff_f, set_temp_fan, set_static_k_f, set_incr_k_f,
      temp_diff_f, set_k_f, stab_f, incr_f, stability_f, increase_f, 18);
      
      sensor_fan = sensor_fan_1;  // Снимаем показания с датчика 3
      lcddisp("sensor_fan");
    }

    if ((sensor_tepl_1 > 90) || (sensor_tepl_1 < -50)) {lcddisp("sensor_tepl_eror");}
    else {sensor_tepl = sensor_tepl_1; lcddisp("sensor_tepl");} // Снимаем показания с датчика 2
    
    if ((sensor_home_1 > 90) || (sensor_home_1 < -50)) {lcddisp("sensor_home_eror");}
    else {sensor_home = sensor_home_1; lcddisp("sensor_home");} // Снимаем показания с датчика 1

    if ((sensor_out > set_winter) && (winter == 1)) {winter = 0;}
    else if ((sensor_out < (set_winter - 1)) && (winter == 0)) {winter = 1;}

    // отображение remote_xy ЧИСЛО ЧТО ОТОБРАЗИТЬ ГДЕ ОТОБРАЗИТЬ ЦИФР ПОСЛЕ ЗАПЯТОЙ ЧТО ПЕРВОЕ 

    
    
    /*strcpy (remoty_str_text, "A:");
    dtostrf(sensor_air, 0, 1,  remoty_str); // преобразуем флоат в char
    strcat(remoty_str_text, remoty_str); // складываем 2 текста
    strcpy (RemoteXY.text_A, remoty_str_text);

    strcpy (remoty_str_text, "T:");
    dtostrf(sensor_tepl, 0, 1,  remoty_str); // преобразуем флоат в char
    strcat(remoty_str_text, remoty_str); // складываем 2 текста
    strcpy (RemoteXY.text_T, remoty_str_text);

    strcpy (remoty_str_text, "V:");
    dtostrf(sensor_fan, 0, 1,  remoty_str); // преобразуем флоат в char
    strcat(remoty_str_text, remoty_str); // складываем 2 текста
    strcpy (RemoteXY.text_V, remoty_str_text);

    strcpy (remoty_str_text, "O:");
    dtostrf(sensor_out, 0, 1,  remoty_str); // преобразуем флоат в char
    strcat(remoty_str_text, remoty_str); // складываем 2 текста
    strcpy (RemoteXY.text_out, remoty_str_text);

    strcpy (remoty_str_text, "%");
    dtostrf(percent_t_1, 0, 0,  remoty_str); // преобразуем флоат в char
    strcat(remoty_str, remoty_str_text);
    strcpy (RemoteXY.text_t_pos, remoty_str);

    strcpy (remoty_str_text, "%");
    dtostrf(percent, 0, 0,  remoty_str); // преобразуем флоат в char
    strcat(remoty_str, remoty_str_text);
    strcpy (RemoteXY.text_r_pos, remoty_str);

    strcpy (remoty_str_text, "%");
    dtostrf(percent_f, 0, 0,  remoty_str); // преобразуем флоат в char
    strcat(remoty_str, remoty_str_text);
    strcpy (RemoteXY.text_v_pos, remoty_str);

    strcpy (remoty_str_text, "%");
    dtostrf(percent_d, 0, 0,  remoty_str); // преобразуем флоат в char
    strcat(remoty_str, remoty_str_text);
    strcpy (RemoteXY.text_inf, remoty_str);*/
  
    remote_disp(sensor_air, "A:", "text_A", 1, 1);
    remote_disp(sensor_tepl, "T:", "text_T", 1, 1);
    remote_disp(sensor_fan, "V:", "text_V", 1, 1);
    remote_disp(sensor_out, "O:", "text_out", 1, 1);
    remote_disp(percent_t_1, "%", "text_t_pos", 0, 0);
    remote_disp(percent, "%", "text_r_pos", 0, 0);
    remote_disp(percent_f, "%", "text_v_pos", 0, 0);
    remote_disp(percent_d, "%", "text_inf", 0, 0);
    
    

    RemoteXY.instrument_pod = sensor_podmes; // шкала перегрева

  }
  

  

// следующий блок показывает что нужно делать при нажатии кнопок
  


  //char key = pad.scan();
  //rcv = 1;
  //&& (rcv == 0)
  //TimerBUT.start();

  char key = pad.getKey();// режим нажатия позволяет избежать двойного нажатия
  if (key) // если кнопка нажата (не 0 символ) 
  {
    strinput_key =""; 
    strinput_key += key; // делаем переход на string 
    if ((strinput_key == "O") && (screen == 1) && (set_mode != 1)) // экран 1 активация изменений 
    {
      set_mode = 1;
      lcd.clear();
      lcddisp("set");
      
      lcd.setCursor(1,1);
      Timer500.start(); //мигание курсора
    }
    else if ((strinput_key == "O") && (screen == 1) && (set_mode != 0)) // переход в режим движения к установленным значениям
    {
      Timer500.stop(); //мигание курсора выключаем
      lcd.noCursor();
      set_mode = 0;
      unit = 0;
      in_num = 0;
      number = 0;
      minus = 0;
      lcd.clear();
      lcddisp("screen1");
    }
    else if ((strinput_key == "O") && (screen == 2) && (set_mode != 3)) // экран 2 активация изменений 
    {
      set_mode = 3;
      lcd.clear();
      lcddisp("screen2");
      
      lcd.setCursor(2,0);
      Timer500.start(); //мигание курсора
    }
    else if ((strinput_key == "O") && (screen == 2) && (set_mode != 4)) // экран 2 деактивация изменений 
    {
      set_mode = 4;
      Timer500.stop(); //мигание курсора выключаем
      lcd.noCursor();
      
      unit = 0;
      in_num = 0;
      number = 0;
      minus = 0;
      lcd.clear();
      lcddisp("screen2");
    }
    else if ((strinput_key == "A") && ((set_mode % 2) == 0)) //переключение на 1й экран
    {
      
      screen = 1;
      lcd.clear();
      lcddisp("screen1"); // отображаем 1й дисплей 
    }
    else if ((strinput_key == "B") && ((set_mode % 2) == 0)) //переключение на 2й экран
    {
      
      //remote_disp();
      screen = 2;
      lcd.clear();
      lcddisp("screen2");// отображаем 2й дисплей
    }
    else if ((strinput_key == "C") && ((set_mode % 2) == 0)) //переключение на 3й экран
    {
      TimerSCREEN3.start();
      screen = 3;
      lcd.clear();
      lcddisp("screen3");// отображаем 3й дисплей
    }
    else if ((strinput_key == ">") && ((set_mode % 2) != 0) && (in_num == 0) && (minus == 0)) // выбор переменной
    {
      unit += 1;
      if ((unit > 5) && (screen == 1)) unit = 0;
      else if ((unit > 12) && (screen == 2)) unit = 0;
      set_cursor(unit, in_num);
    }
    else if ((strinput_key == "<") && ((set_mode % 2) != 0) && (in_num == 0) && (minus == 0)) // выбор переменной
    {
      unit -= 1;
      if ((unit < 0) && (screen == 1)) unit = 5;
      else if ((unit < 0) && (screen == 2)) unit = 12;
      set_cursor(unit, in_num);
    }
    else if ((strinput_key == "0") && ((set_mode % 2) != 0)) // нажимаем 0 пользоваться цифрами можно только в режиме установки
    {
      input_number = 0;
      if ((in_num == 0) && (minus == 0)) {lcd.print("   "); set_cursor(unit, in_num);}
      lcd.print(input_number);// пишем полученную цифру на экране
      if ((in_num == 1) && (screen == 1)) lcd.print("."); // ставим точку после 2 цифры
      else if ((((in_num == 1) && ((unit == 1) || (unit == 4))) || ((in_num == 0) && (unit != 6) && (unit != 7) && (unit != 1) && (unit != 4))) && (screen == 2)) 
      {                                                                                                                          
        lcd.print(".");
      }

      enumerate_numbers(unit, in_num, input_number, number);// считаем цифры и переходим в другой разряд
      set_cursor(unit, in_num); // переводим курсор на следующую цифру        
    }
    else if ((strinput_key == "1") && ((set_mode % 2) != 0))
    {
      input_number = 1;
      if ((in_num == 0) && (minus == 0)) {lcd.print("   "); set_cursor(unit, in_num);}
      lcd.print(input_number);// пишем полученную цифру на экране
      if ((in_num == 1) && (screen == 1)) lcd.print("."); // ставим точку после 2 цифры
      else if ((((in_num == 1) && ((unit == 1) || (unit == 4))) || ((in_num == 0) && (unit != 6) && (unit != 7) && (unit != 1) && (unit != 4))) && (screen == 2)) 
      {                                                                                                                            
        lcd.print(".");
      }
      if (minus == 1) input_number = -input_number; // если нажат минус то число будет отрицательное

      enumerate_numbers(unit, in_num, input_number, number);// считаем цифры и переходим в другой разряд
      set_cursor(unit, in_num); // переводим курсор на следующую цифру        
    }
    else if ((strinput_key == "2") && ((set_mode % 2) != 0))
    {
      input_number = 2;
      if ((in_num == 0) && (minus == 0)) {lcd.print("   "); set_cursor(unit, in_num);}
      lcd.print(input_number);// пишем полученную цифру на экране
      if ((in_num == 1) && (screen == 1)) lcd.print("."); // ставим точку после 2 цифры
      else if ((((in_num == 1) && ((unit == 1) || (unit == 4))) || ((in_num == 0) && (unit != 6) && (unit != 7) && (unit != 1) && (unit != 4))) && (screen == 2)) 
      {                                                                                                                            
        lcd.print(".");
      }
      if (minus == 1) input_number = -input_number;

      enumerate_numbers(unit, in_num, input_number, number);// считаем цифры и переходим в другой разряд
      set_cursor(unit, in_num); // переводим курсор на следующую цифру        
    }
    else if ((strinput_key == "3") && ((set_mode % 2) != 0))
    {
      input_number = 3;
      if ((in_num == 0) && (minus == 0)) {lcd.print("   "); set_cursor(unit, in_num);}
      lcd.print(input_number);// пишем полученную цифру на экране
      if ((in_num == 1) && (screen == 1)) lcd.print("."); // ставим точку после 2 цифры
      else if ((((in_num == 1) && ((unit == 1) || (unit == 4))) || ((in_num == 0) && (unit != 6) && (unit != 7) && (unit != 1) && (unit != 4))) && (screen == 2)) 
      {                                                                                                                            
        lcd.print(".");
      }
      if (minus == 1) input_number = -input_number;

      enumerate_numbers(unit, in_num, input_number, number);// считаем цифры и переходим в другой разряд
      set_cursor(unit, in_num); // переводим курсор на следующую цифру        
    }
    else if ((strinput_key == "4") && ((set_mode % 2) != 0))
    {
      input_number = 4;
      if ((in_num == 0) && (minus == 0)) {lcd.print("   "); set_cursor(unit, in_num);}
      lcd.print(input_number);// пишем полученную цифру на экране
      if ((in_num == 1) && (screen == 1)) lcd.print("."); // ставим точку после 2 цифры
      else if ((((in_num == 1) && ((unit == 1) || (unit == 4))) || ((in_num == 0) && (unit != 6) && (unit != 7) && (unit != 1) && (unit != 4))) && (screen == 2)) 
      {                                                                                                                            
        lcd.print(".");
      }
      if (minus == 1) input_number = -input_number;

      enumerate_numbers(unit, in_num, input_number, number);// считаем цифры и переходим в другой разряд
      set_cursor(unit, in_num); // переводим курсор на следующую цифру        
    }
    else if ((strinput_key == "5") && ((set_mode % 2) != 0)) 
    {
      input_number = 5;
      if ((in_num == 0) && (minus == 0)) {lcd.print("   "); set_cursor(unit, in_num);}
      lcd.print(input_number);// пишем полученную цифру на экране
      if ((in_num == 1) && (screen == 1)) lcd.print("."); // ставим точку после 2 цифры
      else if ((((in_num == 1) && ((unit == 1) || (unit == 4))) || ((in_num == 0) && (unit != 6) && (unit != 7) && (unit != 1) && (unit != 4))) && (screen == 2)) 
      {                                                                                                                            
        lcd.print(".");
      }
      if (minus == 1) input_number = -input_number;

      enumerate_numbers(unit, in_num, input_number, number);// считаем цифры и переходим в другой разряд
      set_cursor(unit, in_num); // переводим курсор на следующую цифру        
    }
    else if ((strinput_key == "6") && ((set_mode % 2) != 0)) 
    {
      input_number = 6;
      if ((in_num == 0) && (minus == 0)) {lcd.print("   "); set_cursor(unit, in_num);}
      lcd.print(input_number);// пишем полученную цифру на экране
      if ((in_num == 1) && (screen == 1)) lcd.print("."); // ставим точку после 2 цифры
      else if ((((in_num == 1) && ((unit == 1) || (unit == 4))) || ((in_num == 0) && (unit != 6) && (unit != 7) && (unit != 1) && (unit != 4))) && (screen == 2)) 
      {                                                                                                                            
        lcd.print(".");
      }
      if (minus == 1) input_number = -input_number;

      enumerate_numbers(unit, in_num, input_number, number);// считаем цифры и переходим в другой разряд
      set_cursor(unit, in_num); // переводим курсор на следующую цифру        
    }
    else if ((strinput_key == "7") && ((set_mode % 2) != 0))
    {
      input_number = 7;
      if ((in_num == 0) && (minus == 0)) {lcd.print("   "); set_cursor(unit, in_num);}
      lcd.print(input_number);// пишем полученную цифру на экране
      if ((in_num == 1) && (screen == 1)) lcd.print("."); // ставим точку после 2 цифры
      else if ((((in_num == 1) && ((unit == 1) || (unit == 4))) || ((in_num == 0) && (unit != 6) && (unit != 7) && (unit != 1) && (unit != 4))) && (screen == 2))  
      {                                                                                                                            
        lcd.print(".");
      }
      if (minus == 1) input_number = -input_number;

      enumerate_numbers(unit, in_num, input_number, number);// считаем цифры и переходим в другой разряд
      set_cursor(unit, in_num); // переводим курсор на следующую цифру        
    }
    else if ((strinput_key == "8") && ((set_mode % 2) != 0))
    {
      input_number = 8;
      if ((in_num == 0) && (minus == 0)) {lcd.print("   "); set_cursor(unit, in_num);}
      lcd.print(input_number);// пишем полученную цифру на экране
      if ((in_num == 1) && (screen == 1)) lcd.print("."); // ставим точку после 2 цифры
      else if ((((in_num == 1) && ((unit == 1) || (unit == 4))) || ((in_num == 0) && (unit != 6) && (unit != 7) && (unit != 1) && (unit != 4))) && (screen == 2)) 
      {                                                                                                                            
        lcd.print(".");
      }
      if (minus == 1) input_number = -input_number;

      enumerate_numbers(unit, in_num, input_number, number);// считаем цифры и переходим в другой разряд
      set_cursor(unit, in_num); // переводим курсор на следующую цифру        
    }
    else if ((strinput_key == "9") && ((set_mode % 2) != 0))
    {
      input_number = 9;
      if ((in_num == 0) && (minus == 0)) {lcd.print("   "); set_cursor(unit, in_num);}
      lcd.print(input_number);// пишем полученную цифру на экране
      if ((in_num == 1) && (screen == 1)) lcd.print("."); // ставим точку после 2 цифры
      else if ((((in_num == 1) && ((unit == 1) || (unit == 4))) || ((in_num == 0) && (unit != 6) && (unit != 7) && (unit != 1) && (unit != 4))) && (screen == 2)) 
      {                                                                                                                            
        lcd.print(".");
      }
      if (minus == 1) input_number = -input_number;

      enumerate_numbers(unit, in_num, input_number, number);// считаем цифры и переходим в другой разряд
      set_cursor(unit, in_num); // переводим курсор на следующую цифру        
    }
    else if ((strinput_key == "D") && ((set_mode % 2) != 0) && (in_num == 0) && (minus == 0) && (((unit == 1) && (screen == 1)) || ((unit == 6) && (screen == 2)))) // только некоторые переменные могут быть отрицательные
    {
      set_cursor(unit, in_num);
      lcd.print("   ");
      set_cursor(unit, in_num); // переводим курсор на следующую цифру
      lcd.print("-");
      minus = 1;
    }
    else if ((strinput_key == "E") && ((set_mode % 2) == 0) && (screen == 1)) 
    {
      Serial2.println("writing_memory");
      EEPROM.put(0,set_temp_air); // 
      EEPROM.put(4,set_temp_tepl);
      EEPROM.put(8,set_temp_fan); // 
      EEPROM.put(12,set_temp_riv);
      EEPROM.put(16,set_temp_podmes); // 
      EEPROM.put(20,set_temp_home);
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("WRITTING_MEMORY_1");
      lcd.setCursor(0,1);
      lcd.print("OK_1");
    }
    else if ((strinput_key == "E") && ((set_mode % 2) == 0) && (screen == 2)) 
    {
      Serial2.println("writing_memory");
      EEPROM.put(24,set_static_k); // 
      EEPROM.put(28,set_incr_k);
      EEPROM.put(32,set_temp_diff); // 
      EEPROM.put(36,set_static_k_f);
      EEPROM.put(40,set_incr_k_f); // 
      EEPROM.put(44,set_temp_diff_f);
      EEPROM.put(48,set_winter); // 
      EEPROM.put(52,hot);
      EEPROM.put(56,k_plus); // 
      EEPROM.put(60,k_plus_f);
      EEPROM.put(64,set_temp_fan_1); // 
      EEPROM.put(68,set_temp_fan_2);
      EEPROM.put(72,set_temp_fan_3); // 
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("WRITTING_MEMORY_2");
      lcd.setCursor(0,1);
      lcd.print("OK_2");
    }

    


    
    

    
  }


   if (TimerSCREEN3.isReady())//перелистываем страницы
    {
      lcd.clear();
      screen3 += 1;
      lcddisp("screen3");
      if (screen3 == 3)
      {
        screen = 1;
        lcddisp("screen1");
        screen3 = 0;
        TimerSCREEN3.stop();
      }
    }

  if (Timer500.isReady())// мигание курсора
    {
      if (cur == 0)
      {
        lcd.cursor();
        cur = 1;
      }
      else 
      {
        cur = 0;
        lcd.noCursor();
      }
    }




 
// следующий блок это обогрев теплицы, дома и реки при этом сначала нагревается дом, потом теплица а потом река (вентилятор отдельно страхует) 
  //при включении дома теплица и река отрубаются LOW HIGH поменяны местами из за сработки реле

  if ((d == 0) && (sensor_home < (set_temp_home - set_temp_hyst_home)) && (sensor_air < (set_temp_air - 0.5))) // включение дома на нагрев при меньше заданной температуры минус гистерезис
  {
    action("dom_on", time_dom); // запустить таймер для включения дома (за 120 секунд попорачивает на 90 градусов)         
  }
  else if ((d == 1) && ((sensor_home > set_temp_home ) || (sensor_air > set_temp_air))) // выключение дома при повышении температуры установки
  {
    action("dom_off", time_dom); // запустить таймер для выключения дома (за 120 секунд попорачивает на 90 градусов)
  }

  //if ((sensor_tepl < (set_temp_tepl - set_temp_hyst_home)) && (t == 0)) // включение теплицы 
  //{
  //   action("tepl_on", 122000);
  //}  
  //else if ((sensor_tepl > set_temp_tepl) && (t == 1)) // выключение теплицы при повышении заданной температуры 
  //{
  //  action("tepl_off", 122000);
  //}

  if ((t_1 > 2400) && (t == 0))
  {
    t = 1;
    digitalWrite(TEPL, LOW);// включаем насос
  } 
  else if ((t_1 < 2000) && (t == 1))  
  {
    t = 0;
    digitalWrite(TEPL, HIGH);
  }

  if (TimerD.isReady())
  {
    digitalWrite(DOM1, HIGH); // выключаем сервопривод дома чтобы просто так не работал
    digitalWrite(DOM2, HIGH); // выключаем сервопривод дома чтобы  просто так не работал
    if (d == 0)
    {
      percent_d = 0;
      lcddisp("dom_percent");
      digitalWrite(DN, HIGH);// Выключаем циркуляционный насос дома
    }
    else if (d == 1)
    {
      percent_d = 100;
      lcddisp("dom_percent");            
    }
  }

  if (r == 0) // колибруем реку
  {
    fix("riv_stop", "riv_percent", timer_a, timer_b, b);
    calibr("riv_open", "riv_close", "riv_percent", kol, b, calibration);
    r = 1; // устанавливаем положение включенной реки
  } 

  if (v == 0) // колибруем вулкан
  {
    fix("vul_stop", "vul_percent", timer_c, timer_d, op_fan);
    calibr("vul_open", "vul_close", "vul_percent", kol_f, op_fan, calibration_f);
    v = 1; // устанавливаем положение включенной реки
  } 


  if (TimerV.isReady()) // таймер исключительно  для отключения сервопривода после колибровки
  {
    fix("vul_stop", "vul_percent", timer_c, timer_d, op_fan);
    Serial2.println("Vulkan_is_Calebrated");
    calibration_f = 1; // включаем работу подмеса
  }

  if (TimerB.isReady()) // таймер исключительно  для отключения сервопривода после колибровки
  {
    fix("riv_stop", "riv_percent", timer_a, timer_b, b);
    Serial2.println("River_is_Calibrated");
    calibration = 1; // включаем работу потока воды
  }

  
// следующий блок описывает работу вентилятора при повышении температуры включается сервопривод для открытия клапана вентилятора потом  1 потом подхватывает 2 потом 3
  
  if ((digitalRead(FAN1) == HIGH) && (sensor_fan > (set_temp_fan_1 + set_temp_fan))) // сработка 1го вентилятора 
  {
    digitalWrite(FAN1, LOW);
    speed = 1;
    
  }
  else if ((digitalRead(FAN1) == LOW) && (sensor_fan < (set_temp_fan_1 + set_temp_fan)))// выключение 1,2,3 го вентилятора при понижении температуры 
  {
    digitalWrite(FAN1, HIGH);
    digitalWrite(FAN2, HIGH);
    digitalWrite(FAN3, HIGH);
    speed = 0;
    
      
  }

  if ((digitalRead(FAN2) == HIGH) && (sensor_fan > (set_temp_fan_2 + set_temp_fan))) // сработка 2 го вентилятора  
  {
    digitalWrite(FAN2, LOW);
    digitalWrite(FAN1, LOW);
    speed = 2;
                  // выводим на экран 2 номер включенного вентилятора 
  }
  else if ((digitalRead(FAN2) == LOW) && (sensor_fan < (set_temp_fan_2 + set_temp_fan))) // выключение 2 го вентилятора 
  {
    digitalWrite(FAN1, HIGH);
    digitalWrite(FAN2, HIGH);
    digitalWrite(FAN3, HIGH);
    speed = 0;
       
  }

  if ((digitalRead(FAN3) == HIGH) && (sensor_fan > (set_temp_fan_3 + set_temp_fan))) // включение 3го вентилятора 
  {
    digitalWrite(FAN1, LOW);
    digitalWrite(FAN2, LOW);
    digitalWrite(FAN3, LOW);
    speed = 3;
                   // выводим на экран 3 номер включенного вентилятора 

  }
  else if ((digitalRead(FAN3) == LOW) && (sensor_fan < (set_temp_fan_3 + set_temp_fan))) // выключение в случае снижения температуры 
  {
    digitalWrite(FAN1, HIGH);
    digitalWrite(FAN2, HIGH);
    digitalWrite(FAN3, HIGH);
    speed = 0;
    
  }

  
    
    

  

// следующий блок описывает работу сервоприводов 
  if (TimerO.isReady())   // Вводим цикл который будет выполнять регулировку подмеса только в определенные промежутки
  {
    

  //работа узла подмеса на входе асиков
    if (set_temp_podmes > sensor_podmes) // проверка на то в какую сторону отклонение ( цикл добавления горячей воды)
    {
      time_P1 = (set_temp_podmes - sensor_podmes) * (set_k_p / 10) * 1000;
      fix("pod_stop", "pod_percent", timer_pod_1, timer_pod_2, p_1);
      rotation_act("rotation_open", "pod_open", time_P1, p_1, p_1_min, p_1_max);
    }
    else if (set_temp_podmes < sensor_podmes)  // проверка на то в какую сторону отклонение ( цикл добавления холодной воды)
    {
      time_P2 = (sensor_podmes - set_temp_podmes) * (set_k_p / 10) * 1000;
      fix("pod_stop", "pod_percent", timer_pod_1, timer_pod_2, p_1); 
      rotation_act("rotation_close", "pod_close", time_P2, p_1, p_1_min, p_1_max);
    }
    else if (set_temp_podmes == sensor_podmes)
    {
      fix("pod_stop", "pod_percent", timer_pod_1, timer_pod_2, p_1);
      percent_p_1 = p_1 / 1200;
    }
  //работа сервоприводов теплицы НЕ зимой
    if ((set_temp_tepl > sensor_tepl) && (winter == 0)) // проверка на то в какую сторону отклонение ( цикл добавления горячей воды)
    {
      time_T1 = (set_temp_tepl - sensor_tepl) * (set_k_t / 10) * 1000;
      fix("tep_stop", "tep_percent", timer_t_1, timer_t_2, t_1);
      rotation_act("rotation_open", "tep_open", time_T1, t_1, t_1_min, t_1_max);
    }
    else if ((set_temp_tepl < sensor_tepl) && (winter == 0))  // проверка на то в какую сторону отклонение ( цикл добавления холодной воды)
    {
      time_T2 = (sensor_tepl - set_temp_tepl) * (set_k_t / 10) * 1000;
      fix("tep_stop", "tep_percent", timer_t_1, timer_t_2, t_1); 
      rotation_act("rotation_close", "tep_close", time_T2, t_1, t_1_min, t_1_max);
    }
    else if ((set_temp_tepl == sensor_tepl) && (winter == 0))
    {
      fix("tep_stop", "tep_percent", timer_t_1, timer_t_2, t_1); 
      percent_t_1 = t_1 / 1200;
    }
  //работа сервоприводов теплицы зимой
    if (((set_temp_fan - 0.2) > sensor_fan) && (winter == 1)) // проверка на то в какую сторону отклонение ( цикл добавления горячей воды)
    {
      time_T2 = ((set_temp_fan - 0.2) - sensor_fan) * (set_k_t / 10) * 1000;
      fix("tep_stop", "tep_percent", timer_t_1, timer_t_2, t_1);
      rotation_act("rotation_close", "tep_close", time_T2, t_1, t_1_min, t_1_max);
    }
    else if (((set_temp_fan - 0.2) < sensor_fan) && (winter == 1))  // проверка на то в какую сторону отклонение ( цикл добавления холодной воды)
    {
      time_T1 = (sensor_fan - (set_temp_fan - 0.2)) * (set_k_t / 10) * 1000;
      fix("tep_stop", "tep_percent", timer_t_1, timer_t_2, t_1); 
      rotation_act("rotation_open", "tep_open", time_T1, t_1, t_1_min, t_1_max);
    }
    else if (((set_temp_fan - 0.2) == sensor_fan) && (winter == 1))
    {
      fix("tep_stop", "tep_percent", timer_t_1, timer_t_2, t_1); 
      percent_t_1 = t_1 / 1200;
    }

  //работа регулировки температуры реки 

    if ((set_temp_riv > sensor_fan) && (calibration == 1)) // проверка на то в какую сторону отклонение ( цикл добавления горячей воды)
    {
      time_R1 = (set_temp_riv - sensor_fan) * (set_k / 10) * 1000;
      fix("riv_stop", "riv_percent", timer_a, timer_b, b); 
      if ((stability != 1) && (set_k != 0)) // закрываем клапан
      {
        if (increase == 1) time_R1 += temp_diff * (k_plus * 1200); increase = 0;// если необходимо увеличение        
        rotation_act("rotation_close", "riv_close", time_R1, b, b_min, b_max);  
      }
      else if (stability == 1) // стабилизация открываем реку
      {
        time_R2 = temp_diff * (k_plus * 1200);
        stability = 0;
        rotation_act("rotation_open", "riv_open", time_R2, b, b_min, b_max);
      }
    }
    else if ((set_temp_riv < sensor_fan) && (calibration == 1))  // проверка на то в какую сторону отклонение ( цикл добавления холодной воды)
    {
      time_R2 = (sensor_fan - set_temp_riv) * (set_k / 10) * 1000;
      if ((h_r_high == 1) && (r_cold_high < 4))
      {
        if ((r_cold_high % 3) == 0) time_R2 += 3 * 1200; Serial2.println("Avariya_hot_river"); //каждый 3 такт будет действоать радикально и открывать на 3% 
        r_cold_high += 1;
      }
      fix("riv_stop", "riv_percent", timer_a, timer_b, b);
      if ((stability != 1) && (set_k != 0))  // открываем клапан
      {
        if (increase == 1) time_R2 += temp_diff * (k_plus * 1200); increase = 0;
        rotation_act("rotation_open", "riv_open", time_R2, b, b_min, b_max);
      }
      else if (stability == 1)
      {
        time_R1 = temp_diff * (k_plus * 1200);
        stability = 0; 
        rotation_act("rotation_close", "riv_close", time_R1, b, b_min, b_max);
      } 
    }
    else if ((set_temp_riv == sensor_fan) && (calibration == 1)) fix("riv_stop", "riv_percent", timer_a, timer_b, b);
    

  // работа регулировки сервопривода вентилятора
    if ((set_temp_fan > sensor_fan) && (calibration_f == 1)) // проверка на то в какую сторону отклонение (закрытие вулкана)
    {
      time_V1 = (set_temp_fan - sensor_fan) * (set_k_f / 10) * 1000;
      fix("vul_stop", "vul_percent", timer_c, timer_d, op_fan);
      
      if ((stability_f != 1) && (set_k_f != 0)) // закрываем вулкан
      {
        if (increase_f == 1) time_V1 += temp_diff_f * (k_plus_f * 1200); increase_f = 0;
        
        rotation_act("rotation_close", "vul_close", time_V1, op_fan, op_fan_min, op_fan_max);
      }
      else if (stability_f == 1) // стабилизация вертим вдругую сторону значит открываем
      {
        time_V2 = temp_diff_f * (k_plus_f * 1200);
        stability_f = 0;
        rotation_act("rotation_open", "vul_open", time_V2, op_fan, op_fan_min, op_fan_max);
      }
    }
    else if ((set_temp_fan < sensor_fan) && (calibration_f == 1))  // проверка на то в какую сторону отклонение (открываем вулкан)
    {
      
      time_V2 = (sensor_fan - set_temp_fan) * (set_k_f / 10) * 1000;

      if ((h_v_low == 1) && (v_cold_low < 10))
      {
        if ((v_cold_low % 2) == 0) time_V2 += 1 * 1200; //каждый 2 такт будет действоать радикально и открывать на 1% 
        v_cold_low += 1;
      }

      if ((h_v_med == 1) && (v_cold_med < 10))
      {
        if ((v_cold_med % 2) == 0) time_V2 += 3 * 1200;//каждый 2 такт будет действоать радикально и открывать на 3% 
        v_cold_med += 1;
      }
      
      if ((h_v_high == 1) && (v_cold_high < 20))
      {
        if ((v_cold_high % 3) == 0) time_V2 = 9 * 1200; Serial2.println("Avariya_hot_vulkan");//каждый 2 такт будет действоать радикально и открывать на 9% 
        v_cold_high += 1;
      }

      fix("vul_stop", "vul_percent", timer_c, timer_d, op_fan);
      if ((stability_f != 1) && (set_k_f != 0))  // открываем клапан
      {
        //Serial2.println("Обычный режим");
        if (increase_f == 1) time_V2 += temp_diff_f * (k_plus_f * 1200); increase_f = 0;
        rotation_act("rotation_open", "vul_open", time_V2, op_fan, op_fan_min, op_fan_max);
      }
      else if (stability_f == 1)
      {
        time_V1 = temp_diff_f * (k_plus_f * 1200);
        stability_f = 0; 
        rotation_act("rotation_close", "vul_close", time_V1, op_fan, op_fan_min, op_fan_max);
      } 
    }
    else if ((set_temp_fan == sensor_fan) && (calibration_f == 1)) fix("vul_stop", "vul_percent", timer_c, timer_d, op_fan);
  }
  

  if (TimerP.isReady())//  после того как прошло достаточно времени выключаем
  {
    fix("pod_stop", "pod_percent", timer_pod_1, timer_pod_2, p_1);
    percent_p_1 = p_1 / 1200;
    if (p_1 <= 0) Serial2.println("Podmes_on_Zero");
  }
  if (TimerTEP.isReady())//  после того как прошло достаточно времени выключаем
  {
    fix("tep_stop", "tep_percent", timer_t_1, timer_t_2, t_1); 
    percent_t_1 = t_1 / 1200;
    if (t_1 <= 0) Serial2.println("Tepl_is_OFF");
  }
  if (TimerSETB.isReady()) // таймер для регулерувки положения сервопривода реки и отключения после задержки
  {
    fix("riv_stop", "riv_percent", timer_a, timer_b, b);
    if (b <= 0) Serial2.println("River_is_OFF");
  }
  if (TimerSETV.isReady()) // таймер для регулерувки положения сервопривода реки и отключения после задержки
  {
    fix("vul_stop", "vul_percent", timer_c, timer_d, op_fan);
    if (op_fan <= 0) Serial2.println("Vulkan_is_OFF");
  }

//следующий блок описывает действия при аварийном отключении при перегреве
  if ((sensor_podmes > hot) && (h == 0)) // 
  {
    Serial2.println("AVARIA_VISOKAYA_TEMPERATURA!!!");
    RemoteXY.sound_alarm = 2001;
    digitalWrite(HOT, LOW);// 
    h = 1;  // устанавливаем положение включенного реле          
  }
  else if ((h == 1) && (sensor_podmes < hot)) // 
  {
    RemoteXY.sound_alarm = 0;
    digitalWrite(HOT, HIGH);//  
    h = 0;  // устанавливаем положение выклюенного реле
  }

  if ((sensor_fan > (set_temp_riv + 1.5)) && (h_r_high == 0)) // включение аварийной работы реки (колибровка и увеличение минимального уровня)
  {
    h_r_high = 1;  // устанавливаем включенный режим аварии       
  }
  else if ((sensor_fan < (set_temp_riv + 1.4)) && (h_r_high == 1)) // 
  {      
    h_r_high = 0;  // устанавливаем положение выклюенного режима аварии
    r_cold_high = 0;// обнуляем счетчик для добавления холодной воды
  }


  if ((sensor_fan > (set_temp_fan + 1)) && (h_v_high == 0)) // включение аварийной работы реки (колибровка и увеличение минимального уровня)
  {
    h_v_high = 1;  // устанавливаем включенный режим аварии       
  }
  else if ((sensor_fan < (set_temp_fan + 0.9)) && (h_v_high == 1)) // 
  {      
    h_v_high = 0;  // устанавливаем положение выклюенного режима аварии
    v_cold_high = 0;// обнуляем счетчик для добавления холодной воды
  }

  if ((sensor_fan > (set_temp_fan + 0.6)) && (h_v_med == 0)) // включение аварийной работы реки (колибровка и увеличение минимального уровня)
  {
    h_v_med = 1;  // устанавливаем включенный режим аварии       
  }
  else if ((sensor_fan < (set_temp_fan + 0.5)) && (h_v_med == 1)) // 
  {      
    h_v_med = 0;  // устанавливаем положение выклюенного режима аварии
    v_cold_med = 0;// обнуляем счетчик для добавления холодной воды
  }

  if ((sensor_fan > (set_temp_fan + 0.3)) && (h_v_low == 0)) // включение аварийной работы реки (колибровка и увеличение минимального уровня)
  {
    h_v_low = 1;  // устанавливаем включенный режим аварии       
  }
  else if ((sensor_fan < (set_temp_fan + 0.2)) && (h_v_low == 1)) // 
  {      
    h_v_low = 0;  // устанавливаем положение выклюенного режима аварии
    v_cold_low = 0;// обнуляем счетчик для добавления холодной воды
  }

  if (TimerDOG.isReady())
  {
    digitalWrite(DOG, HIGH);
    RemoteXY_delay(50);
    digitalWrite(DOG, LOW);
  }

  
  



  
//следующий блок произоводит взаимодействие с вай фай модулем с помощью команд


  while (Serial2.available() > 0) // считываем данные пока хоть что то поступает
  {
    strData += (char)Serial2.read();// забиваем строку принятыми данными       
    recievedFlag = true;// поднять флаг что получили данные             
    RemoteXY_delay(2);          
  }
  if (recievedFlag) // если данные получены
  {                      
    strinput += strData[0]; // считываем только первый 2 символа т к часто отправляется невидимый
    strinput += strData[1];
 
    if ((strinput == "d0") && (set_temp_home > 1))  // если нажата кнопка уменьшения темп дома 
    {
      set_temp_home -= 1;
      Serial2.print("d:");
      Serial2.println(set_temp_home);
    } 
    else if ((strinput == "d1") && (set_temp_home < 75)) // если нажата кнопка увеличения темп дома 
    {
      set_temp_home += 1;
      Serial2.print("d:");
      Serial2.println(set_temp_home);
    }
    else if ((strinput == "t0") && (set_temp_tepl > -30)) // если нажата кнопка уменьшения темп теплицы
    {
      set_temp_tepl -= 1;
      Serial2.print("t:");
      Serial2.println(set_temp_tepl);
    } 
    else if ((strinput == "t1") && (set_temp_tepl < 75)) // если нажата кнопка увеличения темп теплицы
    {
      set_temp_tepl += 1; 
      Serial2.print("t:");
      Serial2.println(set_temp_tepl);
    } 
    else if ((strinput == "v0") && (set_temp_fan > 10)) // если нажата кнопка уменьшения темп вентилятора
    {
      set_temp_fan -= 0.2;
      Serial2.print("v:");
      Serial2.println(set_temp_fan,1);        
    } 
    else if ((strinput == "v1") && (set_temp_fan < 75)) // если нажата кнопка увеличения темп вентилятора
    {
      set_temp_fan += 0.2;
      Serial2.print("v:");
      Serial2.println(set_temp_fan,1);   
    }
    else if ((strinput == "r0") && (set_temp_riv > 0.4)) // если нажата кнопка уменьшения температуры реки
    {
      set_temp_riv -= 0.2;
      set_temp_riv = ((float)((int)(set_temp_riv * 10)))/10; // нужно т к выставляем мы кнопкой чтобы убрать погрешность вызванную флоатом    
      Serial2.print("r:");
      Serial2.println(set_temp_riv,1);  
    }  
    else if ((strinput == "r1") && (set_temp_riv < 75)) // если нажата кнопка увеличения температуры реки 
    {
      set_temp_riv += 0.2;
      set_temp_riv = ((float)((int)(set_temp_riv * 10)))/10; // нужно т к выставляем мы кнопкой чтобы убрать погрешность вызванную флоатом       
      Serial2.print("r:");
      Serial2.println(set_temp_riv,1);  
    }  
    else if ((strinput == "p0") && (set_temp_podmes > 10)) // если нажата кнопка уменьшения температуры выхода подмеса 
    {
      set_temp_podmes -= 0.2;
      set_temp_podmes = ((float)((int)(set_temp_podmes * 10)))/10; // нужно т к выставляем мы кнопкой чтобы убрать погрешность вызванную флоатом      
      Serial2.print("p:");
      Serial2.println(set_temp_podmes,1);  
    }  
    else if ((strinput == "p1") && (set_temp_podmes < 50)) // если нажата кнопка увеличения температуры выхода подмеса 
    {
      set_temp_podmes += 0.2;
      set_temp_podmes = ((float)((int)(set_temp_podmes * 10)))/10; // нужно т к выставляем мы кнопкой чтобы убрать погрешность вызванную флоатом
      Serial2.print("p:");
      Serial2.println(set_temp_podmes,1);  
    }  
    else if ((strinput == "k0") && (set_incr_k > 2)) // если нажата кнопка уменьшения коэфициента К
    {    
      set_incr_k -= 1; 
      Serial2.print("k:");
      Serial2.println(set_incr_k,1);    
    }  
    else if ((strinput == "k1") && (set_incr_k < 20)) // если нажата кнопка увеличения коэфициента К
    {
      set_incr_k += 1;
      Serial2.print("k:");
      Serial2.println(set_incr_k,1);  
    }  
    else if ((strinput == "a0") && (set_temp_air > 0.4)) // если нажата кнопка уменьшения температуры воздуха
    {
      set_temp_air -= 0.1;
      Serial2.print("a:");
      Serial2.println(set_temp_air,1);            
    }  
    else if ((strinput == "a1") && (set_temp_air < 35)) // если нажата кнопка увеличения температуры воздуха
    {
      set_temp_air += 0.1;
      Serial2.print("a:");
      Serial2.println(set_temp_air,1);     
    }
    else if ((strinput == "s0") && (k_plus > 0.2)) // 
    {
      k_plus -= 0.1;
      Serial2.print("k_plus:");
      Serial2.println(k_plus,1);            
    }  
    else if ((strinput == "s1") && (k_plus < 3)) // 
    {
      k_plus += 0.1;
      Serial2.print("k_plus:");
      Serial2.println(k_plus,1);     
    }
    else if ((strinput == "q0") && (set_temp_diff > 0.3)) // 
    {
      set_temp_diff -= 0.1;
      Serial2.print("temp_diff:");
      Serial2.println(set_temp_diff,1);            
    }  
    else if ((strinput == "q1") && (set_temp_diff < 2)) // 
    {
      set_temp_diff += 0.1;
      Serial2.print("temp_diff:");
      Serial2.println(set_temp_diff,1);     
    }
    else if ((strinput == "w0") && (set_incr_k_f > 2)) // 
    {
      set_incr_k_f -= 1;
      Serial2.print("incr_k_f:");
      Serial2.println(set_incr_k_f,1);            
    }  
    else if ((strinput == "w1") && (set_incr_k_f < 30)) // 
    {
      set_incr_k_f += 1;
      Serial2.print("incr_k_f:");
      Serial2.println(set_incr_k_f,1);     
    }
    else if ((strinput == "y0") && (set_static_k_f > 1)) // 
    {
      set_static_k_f -= 0.4;
      Serial2.print("set_static_k_f:");
      Serial2.println(set_static_k_f,1);            
    }  
    else if ((strinput == "y1") && (set_static_k_f < 20)) // 
    {
      set_static_k_f += 0.4;
      Serial2.print("set_static_k_f:");
      Serial2.println(set_static_k_f,1);     
    }
    else if ((strinput == "i0") && (set_temp_diff_f > 0.1)) // 
    {
      set_temp_diff_f -= 0.1;
      Serial2.print("set_temp_diff_f:");
      Serial2.println(set_temp_diff_f,1);            
    }  
    else if ((strinput == "i1") && (set_temp_diff_f < 2)) // 
    {
      set_temp_diff_f += 0.1;
      Serial2.print("set_temp_diff_f:");
      Serial2.println(set_temp_diff_f,1);     
    }
    else if ((strinput == "v2") && (set_temp_fan_2 < 75)) // если нажата кнопка увеличения темп вентилятора
    {
      set_temp_fan_2 += 0.1;
      if (set_temp_fan_2 > 4) set_temp_fan_2 = 0.1;
      Serial2.print("v2:");
      Serial2.println(set_temp_fan_2,1);   
    }
    else if ((strinput == "v3") && (set_temp_fan_3 < 75)) // если нажата кнопка увеличения темп вентилятора
    {
      set_temp_fan_3 += 0.1;
      if (set_temp_fan_3 > 4) set_temp_fan_3 = 0.1;
      Serial2.print("v3:");
      Serial2.println(set_temp_fan_3,1);   
    }
    else if ((strinput == "v4") && (set_temp_fan_1 < 75)) // если нажата кнопка увеличения темп вентилятора
    {
      set_temp_fan_1 += 0.1;
      if (set_temp_fan_1 > 4) set_temp_fan_1 = 0.1;
      Serial2.print("v1:");
      Serial2.println(set_temp_fan_1,1);   
    }
    else if ((strinput == "h0") && (hot > 30)) //
    {
      hot -= 1;
      Serial2.print("hot: ");
      Serial2.println(hot,1);   
    }
    else if ((strinput == "h1") && (hot < 90)) // если нажата кнопка увеличения темп вентилятора
    {
      hot += 1;      
      Serial2.print("hot: ");
      Serial2.println(hot,1);   
    }
    else if ((strinput == "o0") && (set_winter > -25)) //
    {
      set_winter -= 1;
      Serial2.print("set_winter: ");
      Serial2.println(set_winter);   
    }
    else if ((strinput == "o1") && (set_winter < 40)) // если нажата кнопка увеличения темп вентилятора
    {
      set_winter += 1;      
      Serial2.print("set_winter: ");
      Serial2.println(set_winter);   
    }
    else if (strinput == "di") 
    {      
      Serial2.print("A:");
      Serial2.print(sensor_air,1);
      Serial2.print("   ");
      Serial2.print("T:");
      Serial2.print(sensor_tepl,1);
      Serial2.print("   ");
      Serial2.print("V:");
      Serial2.print(sensor_fan,1);
      Serial2.print("   ");
      Serial2.print(speed,1);
      Serial2.print("  ");
      Serial2.print("Vulkan:");
      Serial2.print(percent_f,1);
      Serial2.println("%");

      Serial2.print("a:");
      Serial2.print(set_temp_air,1);
      if (d ==0) Serial2.print(" + ");
      else Serial2.print(" * ");
      Serial2.print("t:");
      Serial2.print(set_temp_tepl);
      if (t ==0) Serial2.print(" + ");
      else Serial2.print(" * ");
      Serial2.print("  ");
      Serial2.print("v:");
      Serial2.print(set_temp_fan,1);
      if (v ==0) Serial2.print(" + ");
      else Serial2.print(" * ");
      Serial2.print("  ");
      Serial2.print("K_plus:");
      Serial2.print(k_plus,1);
      Serial2.print("  ");
      Serial2.print("temp_diff:");
      Serial2.println(set_temp_diff,1);
      

      Serial2.print("O:");
      Serial2.print(sensor_out,1);
      Serial2.print("   ");
      Serial2.print("P:");
      Serial2.print(sensor_podmes,1);
      Serial2.print("   ");
      Serial2.print("D:");
      Serial2.print(sensor_home,1);
      Serial2.print("   ");
      Serial2.print("River:");
      Serial2.print(percent,1);
      Serial2.println("%");

      Serial2.print("r:");
      Serial2.print(set_temp_riv,1);
      if (r ==0) Serial2.print(" + ");
      else Serial2.print(" * ");
      Serial2.print("p:");
      Serial2.print(set_temp_podmes,1);
      Serial2.print("   ");
      Serial2.print("d:");
      Serial2.print(set_temp_home);
      Serial2.print("     ");
      Serial2.print("Podmes:");
      Serial2.print(percent_p_1,1);
      Serial2.print("%");
      Serial2.print("   ");
      Serial2.print("K:");
      Serial2.println(set_incr_k,1);

     

      
      
      
      
      Serial2.println("============================================");
    }
    else
    {
      Serial2.println("Повторите ввод");
      Serial2.println("Список команд: a0,a1; t0,t1; v0,v1; r0,r1; p0,p1; d0,d1; - служат для ");
      Serial2.println("изминения темпертур k0,k1; - k_incr s0,s1; - k_plus");
      Serial2.println("q0,q1; - temp_diff w0,w1 - k_incr_f; y0,y1 - k_static_f i0,i1 - set_temp_diff_f");
      Serial2.println("v2,v3,v4; - изменение f2,f3,f1 h0,h1 - изменение температуры отключения");
      Serial2.println("o0,o1 - температура наступления зимы");
    } 
    strinput ="";              
    strData = "";                          // очистить
    recievedFlag = false;                  // опустить флаг
  }

// следующий блок производит взаимодействие со 2 м модулем с помощью приложения Remoty XY
  if (TimerBUT.isReady()) rcv = 0;

  if ((RemoteXY.button_a_p != 0) && (set_temp_air < 45) && (rcv == 0))
  {
    set_temp_air += 0.1;
    remote_disp(set_temp_air, "a:", "text_a", 1, 1);
    rcv = 1;
    TimerBUT.start();
  }

  if ((RemoteXY.button_a_m != 0) && (set_temp_air > 0.4) && (rcv == 0))
  {
    set_temp_air -= 0.1;
    remote_disp(set_temp_air, "a:", "text_a", 1, 1);
    rcv = 1;
    TimerBUT.start();
  }
  if ((RemoteXY.button_t_p != 0) && (set_temp_tepl < 45) && (rcv == 0))
  {
    set_temp_tepl += 0.1;
    remote_disp(set_temp_tepl, "t:", "text_t", 1, 1);
    rcv = 1;
    TimerBUT.start();
  }

  if ((RemoteXY.button_t_m != 0) && (set_temp_tepl > -20) && (rcv == 0))
  {
    set_temp_tepl -= 0.1;
    remote_disp(set_temp_tepl, "t:", "text_t", 1, 1);
    rcv = 1;
    TimerBUT.start();
  }

  if ((RemoteXY.button_v_p != 0) && (set_temp_fan < 40) && (rcv == 0))
  {
    set_temp_fan += 0.1;
    remote_disp(set_temp_fan, "v:", "text_v", 1, 1);
    rcv = 1;
    TimerBUT.start();
  }

  if ((RemoteXY.button_v_m != 0) && (set_temp_fan > 0.4) && (rcv == 0))
  {
    set_temp_fan -= 0.1;
    remote_disp(set_temp_fan, "v:", "text_v", 1, 1);
    rcv = 1;
    TimerBUT.start();
  }

  if ((RemoteXY.button_r_p != 0) && (set_temp_riv < 45) && (rcv == 0))
  {
    set_temp_riv += 0.1;
    remote_disp(set_temp_riv, "r:", "text_r", 1, 1);
    rcv = 1;
    TimerBUT.start();
  }

  if ((RemoteXY.button_r_m != 0) && (set_temp_riv > 0.4) && (rcv == 0))
  {
    set_temp_riv -= 0.1;
    remote_disp(set_temp_riv, "r:", "text_r", 1, 1);
    rcv = 1;
    TimerBUT.start();
  }


  if ((strcmp (RemoteXY.edit_com, "d0") == 0) && (set_temp_home > 1))  // если нажата кнопка уменьшения темп дома 
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_home -= 1;
    remote_disp(set_temp_home, "d:", "text_com", 1, 1);
  } 
  else if ((strcmp (RemoteXY.edit_com, "d1") == 0) && (set_temp_home < 75)) // если нажата кнопка увеличения темп дома 
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_home += 1;
    remote_disp(set_temp_home, "d:", "text_com", 1, 1);
  }
  else if ((strcmp (RemoteXY.edit_com, "p0") == 0) && (set_temp_podmes > 10)) // если нажата кнопка уменьшения температуры выхода подмеса 
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_podmes -= 0.2;
    set_temp_podmes = ((float)((int)(set_temp_podmes * 10)))/10; // нужно т к выставляем мы кнопкой чтобы убрать погрешность вызванную флоатом      
    remote_disp(set_temp_podmes, "p:", "text_com", 1, 1);
  }  
  else if ((strcmp (RemoteXY.edit_com, "p1") == 0) && (set_temp_podmes < 50)) // если нажата кнопка увеличения температуры выхода подмеса 
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_podmes += 0.2;
    set_temp_podmes = ((float)((int)(set_temp_podmes * 10)))/10; // нужно т к выставляем мы кнопкой чтобы убрать погрешность вызванную флоатом
    remote_disp(set_temp_podmes, "p:", "text_com", 1, 1);   
  }  
  else if ((strcmp (RemoteXY.edit_com, "k0") == 0) && (set_incr_k > 2)) // если нажата кнопка уменьшения коэфициента К
  {
    strcpy (RemoteXY.edit_com, "");    
    set_incr_k -= 1;
    remote_disp(set_incr_k, "k:", "text_com", 1, 1); 
  }  
  else if ((strcmp (RemoteXY.edit_com, "k1") == 0) && (set_incr_k < 20)) // если нажата кнопка увеличения коэфициента К
  {
    strcpy (RemoteXY.edit_com, "");
    set_incr_k += 1;
    remote_disp(set_incr_k, "k:", "text_com", 1, 1);
  }  
  else if ((strcmp (RemoteXY.edit_com, "s0") == 0) && (k_plus > 0.2)) // 
  {
    strcpy (RemoteXY.edit_com, "");
    k_plus -= 0.1;
    remote_disp(k_plus, "kp", "text_com", 1, 1);            
  }  
  else if ((strcmp (RemoteXY.edit_com, "s1") == 0) && (k_plus < 3)) // 
  {
    strcpy (RemoteXY.edit_com, "");
    k_plus += 0.1;
    remote_disp(k_plus, "kp", "text_com", 1, 1);    
  }
  else if ((strcmp (RemoteXY.edit_com, "q0") == 0) && (set_temp_diff > 0.3)) // 
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_diff -= 0.1;
    remote_disp(set_temp_diff, "td", "text_com", 1, 1);         
  }  
  else if ((strcmp (RemoteXY.edit_com, "q1") == 0) && (set_temp_diff < 2)) // 
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_diff += 0.1;
    remote_disp(set_temp_diff, "td", "text_com", 1, 1);   
  }
  else if ((strcmp (RemoteXY.edit_com, "w0") == 0) && (set_incr_k_f > 2)) // 
  {
    strcpy (RemoteXY.edit_com, "");
    set_incr_k_f -= 1;
    remote_disp(set_incr_k_f, "kif", "text_com", 1, 1);     
  }  
  else if ((strcmp (RemoteXY.edit_com, "w1") == 0) && (set_incr_k_f < 30)) // 
  {
    set_incr_k_f += 1;
    remote_disp(set_incr_k_f, "kif", "text_com", 1, 1);
  }
  else if ((strcmp (RemoteXY.edit_com, "i0") == 0) && (set_temp_diff_f > 0.1)) // 
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_diff_f -= 0.1;
    remote_disp(set_temp_diff_f, "dif", "text_com", 1, 1);         
  }  
  else if ((strcmp (RemoteXY.edit_com, "i1") == 0) && (set_temp_diff_f < 2)) // 
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_diff_f += 0.1;
    remote_disp(set_temp_diff_f, "dif", "text_com", 1, 1);
  }
  else if ((strcmp (RemoteXY.edit_com, "v2+") == 0) && (set_temp_fan_2 < 15)) // если нажата кнопка увеличения темп вентилятора
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_fan_2 += 0.1;
    remote_disp(set_temp_fan_2, "v2", "text_com", 1, 1);
  }
  else if ((strcmp (RemoteXY.edit_com, "v2-") == 0) && (set_temp_fan_2 > 0.2)) // если нажата кнопка увеличения темп вентилятора
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_fan_2 -= 0.1;
    remote_disp(set_temp_fan_2, "v2", "text_com", 1, 1);
  }
  else if ((strcmp (RemoteXY.edit_com, "v3+") == 0) && (set_temp_fan_3 < 15)) // если нажата кнопка увеличения темп вентилятора
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_fan_3 += 0.1;
    remote_disp(set_temp_fan_3, "v3", "text_com", 1, 1);
  }
  else if ((strcmp (RemoteXY.edit_com, "v3-") == 0) && (set_temp_fan_3 > 0.2)) // если нажата кнопка увеличения темп вентилятора
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_fan_3 -= 0.1;
    remote_disp(set_temp_fan_3, "v3", "text_com", 1, 1);
  }
  else if ((strcmp (RemoteXY.edit_com, "v1+") == 0) && (set_temp_fan_1 < 15)) // если нажата кнопка увеличения темп вентилятора
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_fan_1 += 0.1;
    remote_disp(set_temp_fan_1, "v1", "text_com", 1, 1);
  }
    else if ((strcmp (RemoteXY.edit_com, "v1-") == 0) && (set_temp_fan_1 > 0.2)) // если нажата кнопка увеличения темп вентилятора
  {
    strcpy (RemoteXY.edit_com, "");
    set_temp_fan_1 -= 0.1;
    remote_disp(set_temp_fan_1, "v1", "text_com", 1, 1);
  }
  else if ((strcmp (RemoteXY.edit_com, "h0") == 0) && (hot > 30)) //
  {
    strcpy (RemoteXY.edit_com, "");
    hot -= 1;
    remote_disp(hot, "hot", "text_com", 1, 1);
  }
  else if ((strcmp (RemoteXY.edit_com, "h1") == 0) && (hot < 90)) // если нажата кнопка увеличения темп вентилятора
  {
    strcpy (RemoteXY.edit_com, "");
    hot += 1;      
    remote_disp(hot, "hot", "text_com", 1, 1);
  }
  else if ((strcmp (RemoteXY.edit_com, "o0") == 0) && (set_winter > -25)) //
  {
    strcpy (RemoteXY.edit_com, "");
    set_winter -= 1;
    remote_disp(set_winter, "wi", "text_com", 1, 1);
  }
  else if ((strcmp (RemoteXY.edit_com, "o1") == 0) && (set_winter < 40)) // если нажата кнопка увеличения темп вентилятора
  {
    set_winter += 1;      
    strcpy (RemoteXY.edit_com, "");
    remote_disp(set_winter, "wi", "text_com", 1, 1);
  }

}