Перейти к содержанию

Рекомендуемые сообщения

я не знаю, как это называется. периодически растет или заводится в малечнике, где кормлю много и часто. малька не ест точно:),так что хай живет. на аке нозотус скажет точно

Поделиться сообщением


Ссылка на сообщение
11 часов назад, ЛаГГен сказал(а):

Эт тебе надо обращаться в Волгоградскую лабораторию по распознаванию разных полтергейст(вов)

Согласен с @Idzumi очень похоже на колонию мшанок. 

Поделиться сообщением


Ссылка на сообщение
2 часов назад, Юна сказал(а):

на аке нозотус скажет точно

А нозотус-это аквариумный проктолог? :ap:

 

1 час назад, shkush сказал(а):

Согласен с @Idzumi очень похоже на колонию мшанок. 

Чё за хрень? Пошёл читать. 

Поделиться сообщением


Ссылка на сообщение
7 минут назад, ЛаГГен сказал(а):

Чё за хрень? Пошёл читать. 

Я только это нашёл..  :ap:

https://ru.wikipedia.org/wiki/Мшанка_шиловидная#Распространение_и_экология

Поделиться сообщением


Ссылка на сообщение
3 минут назад, Paracheirodon сказал(а):

Я только это нашёл..  :ap:

Да нет. Много находится - вот.

У меня такое тоже было. Но, честно говоря, подумал что это икра физы. Оторвал листья с этой фигней и выкинул. Больше не заезжала.

Поделиться сообщением


Ссылка на сообщение


Чем питаются мшанки?
Мшанки, как правило, питаются инфузориями, бактериями и прочей мелкой живностью. Причем, для нормального питания мшанок этой живности должно быть в достатке. Тем самым мшанки являются помощниками аквариумиста в борьбе за чистоту аквариума. Мшанки являются своеобразными "биологическими фильтрами", очищающими воду от лишней живой органики........ Не нада удалять, эта хрень полезнаяяяя:)

Поделиться сообщением


Ссылка на сообщение
17 часов назад, ЛаГГен сказал(а):

последняя соломинка - там!!!

Без вариантов... увы. =)))
Это у меня был пример кода для другой среды разработки, " ESP-IDF"  - более низкого уровня (=сложней, мощней), чем "Arduino IDE".
То есть недоступная для моего нынешнего уровня функция.

Тем не менее, удалось сделать "правильный" закат/рассвет. В смысле понятный для глаза, а не просто прибавление раз в определенное время единичку уровня ШИМ.
Это преобразование уровня ШИМ с использованием гамма-коррекции. К счастью, ничего выдумывать не пришлось, нашел несколько вариантов у АлексаГивера. (может кому ещё пригодится)
 

53 минут назад, ЛаГГен сказал(а):

Тем самым мшанки являются помощниками аквариумиста в борьбе за чистоту аквариума.

Опаньки! Новый фильтр! :ap:

3 часов назад, Юна сказал(а):

где кормлю много и часто. малька не ест точно:),так что хай живет

Да, я там кормлю с перебором. Но они (2 корика) такие маленькие, такие голодненькие =)))

Поделиться сообщением


Ссылка на сообщение

@ЛаГГен

а если так:

Цитата

Как и сказано выше, мшанки активно потребляют живую органику, появление которой сигнализирует о не очень чистой воде в аквариуме, перекорме и нарушении баланса.

и вот так:

Цитата

Из минусов следует отметить возможность поселения мшанок на фильтрующих устройствах, заборниках, камерах с фильтрующими элементами и даже в отсеке с импеллером. Последнее явление опасно тем, что расплодившиеся мшанки способны вызвать остановку и подклинивание импеллера

:ap:

Поделиться сообщением


Ссылка на сообщение
2 часов назад, VALKNUT сказал(а):

Опаньки! Новый фильтр! :ap:

Ну эт наверно до приезда клапана?

 

1 час назад, Antik сказал(а):

 

Из минусов следует отметить возможность поселения мшанок на фильтрующих устройствах

Значит между мшарнками и фильтром должны жить поедатели мшанок,к примеру-гидры,эти точно слопают,они больше и хищнее:biggrin:

Поделиться сообщением


Ссылка на сообщение

Пилю новый софт для старого железа.
image.thumb.png.157283435daa0086b9c70295ac0212b9.png

Теперь у меня плавней включается освещение...  в 16 раз... Новая прошивка! Тружусь... йоптеть...
Теперь куллер не стартанет на 100% днем, если папочка принял на хрудь (tVOC и eCO2)... куллер подождет, пока выветрится и тогда запустится на все деньги.

Приехал из китаев клапан... ППЦ.. жесткий! Помпа пробивает его, но о тишине похоже остается только мечтать.. буду искать замену. САМП в опасносте.

Поделиться сообщением


Ссылка на сообщение

8 минут назад, VALKNUT сказал(а):

 но о тишине похоже остается только мечтать.. буду искать замену. САМП в опасносте.

Привет,так что,....шеф,всё пропало?:biggrin:

Поделиться сообщением


Ссылка на сообщение
Только что, ЛаГГен сказал(а):

так что,....шеф,всё пропало?:biggrin:

Ты же тоже овен... =))) Разве не очевидно, что это вызов, с которым просто надо решить вопрос? :ap:

Поделиться сообщением


Ссылка на сообщение
4 минут назад, VALKNUT сказал(а):

Ты же тоже овен... =))) Разве не очевидно, что это вызов, с которым просто надо решить вопрос? :ap:

Согласен,только не так медленно:biggrin:,не по овнеровски это..

Поделиться сообщением


Ссылка на сообщение
4 минут назад, ЛаГГен сказал(а):

только не так медленно:biggrin:

Китай учит не спешить.. б...л..ин.. всё приходится ждать от узкоглазых =)))

Поделиться сообщением


Ссылка на сообщение
Только что, VALKNUT сказал(а):

Китай учит не спешить.. б...л..ин.. всё приходится ждать от узкоглазых =)))

Б...л...ин,давно б уже замутил самопальный клапан из презерватива,на худой конец - воздушного шарика....где наша находчивость,почему мы должны ждать у китайской реки проплывающий труп врага? Сходи и завали:biggrin:Видал что хуситы творят?А если клапан подобьют?

Поделиться сообщением


Ссылка на сообщение
Только что, ЛаГГен сказал(а):

А если клапан подобьют?

А чо хуситы?  По пацански ебептенят =)))
Клапан не застрянет, я же не пендос и не британец на велике..

ЗЫ... презики и самому ннада... а шарики воздушные не надежные =)))))) Да и не спешу я никуда... у меня еще гребли с софтом на пару недель :ap:

Поделиться сообщением


Ссылка на сообщение
11 минут назад, VALKNUT сказал(а):

А чо хуситы?  По пацански ебептенят =)))
Клапан не застрянет, я же не пендос и не британец на велике..

ЗЫ... презики и самому ннада... а шарики воздушные не надежные =)))))) Да и не спешу я никуда... у меня еще гребли с софтом на пару недель :ap:

Тупо скучно, не поверишь... 

Поделиться сообщением


Ссылка на сообщение

Ужоснах =)))))))))))

Если кому-то когда-то понадобится, мне не жалко...

Спойлер

//#define BLYNK_PRINT Serial
#define BLYNK_TEMPLATE_ID           "ESP32 DevKit v2"
#define BLYNK_TEMPLATE_NAME         "Device"

#define BOT_TOKEN "**************************************"
#define PWM_Freq        5000          //  Частота каналов ШИМ
#define PWM_Freq_FAN    25000         //  Частота канала ШИМ куллера
#define CoollerPower    12            //  Питание вентилятора         | 10%
#define DisplayControl  13            //  Питание дисплея             | 100%
#define FanPin          14            //  ШИМ вентилятора охлаждения  | 50%
#define ONE_WIRE_BUS    15            //  Датчики температуры         | 75%
#define PWM1_PIN        23            //  Пин канала Холодный белый
#define PWM2_PIN        25            //  Пин канала Холодный белый
#define PWM3_PIN        26            //  Пин канала Холодный белый
#define PWM4_PIN        27            //  Пин канала Холодный белый
#define rATX            32            //  ATX on/off                   | 100%
#define rHOT            33            //  Нагрев                       | 90%
#define PWM0_Ch         0             //  Таймер 0 - Куллера
#define PWM1_Ch         1             //  Таймер 1
#define PWM2_Ch         2             //  Таймер 2
#define PWM3_Ch         3             //  Таймер 3
#define PWM4_Ch         4             //  Таймер 4


#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <BlynkSimpleEsp32_SSL.h>
#include <OneWire.h>
#include <Adafruit_SGP30.h>
#include <Adafruit_AHTX0.h>
#include <Wire.h>
#include <DallasTemperature.h>
#include <LittleFS.h>
#include <GyverPortal.h>
#include <UniversalTelegramBot.h>
#include <ArduinoJson.h>
#include "03_BLColor.h"


OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress temp1DeviceAddress, temp2DeviceAddress, temp3DeviceAddress, temp4DeviceAddress;
WiFiClientSecure secured_client;
BlynkTimer timer;
GyverPortal ui(&LittleFS);


// Телеграм Бот
UniversalTelegramBot bot(BOT_TOKEN, secured_client);
String CHAT_ID, NewID;
unsigned long lastTimeBotRan;                         // Крайнее сообщение в чате/группе Телеграм
bool isCHAT;                                          // Отправлять сообщения или нет
bool fMsgStartCool = true; bool fMsgStopCool = true;  // предотвращаем повторные сообщения в телеграм
bool fMsgStartHot = true; bool fMsgStopHot = true;    // предотвращаем повторные сообщения в телеграм

//================================
Adafruit_AHTX0 aht;
Adafruit_SGP30 sgp;
uint32_t getAbsoluteHumidity(float temperature, float humidity) {
  const float absoluteHumidity = 216.7f * ((humidity / 100.0f) * 6.112f * exp((17.62f * temperature) / (243.12f + temperature)) / (273.15f + temperature)); // [g/m^3]
  const uint32_t absoluteHumidityScaled = static_cast<uint32_t>(1000.0f * absoluteHumidity); // [mg/m^3]
  return absoluteHumidityScaled;
}
long AXTemp, AXHumi;
String mTVOC, mECO2;
int iTVOC, iECO2;
//================================

char wssid[]   = "*********";
char passw[]   = "*********";
char token[]  = "***********************************";                                       //  Токен подключения к серверу
const char* bhost = "*******************";                                                  //  Адрес сервера
unsigned int bport = ****;                                                                //  Порт сервера

uint32_t LCDStart, LCDStop, CoollerDay, CoollerNight;                                     //  Время: Дисплей и Куллер(день/ночь)
bool LLCD, SDay, SNight;                                                                  //  Флаги "Дисплей" и "День/Ночь" для куллера

long myUtime;                                                                             //  Переменная времени
bool StartNRD = true;                                                                     //  Переменная флага запуска
bool isFirstConnect = true;                                                               //  Триггер первичного подключения к Blynk
bool SW1;                                                                                 //  Флаг плавного/быстрого включения/выключения освещения

int myCooller, FanPowDay, FanPowNight;
unsigned long timingFan;
int iFanSpeed;
int fDay1 = 0;    int fNight1 = 0;      // 0
int fDay2 = 0;    int fNight2 = 0;      // 0
int fDay3 = 0;    int fNight3 = 0;      // 76
int fDay4 = 0;    int fNight4 = 0;      // 128
int fDay5 = 0;    int fNight5 = 0;      // 200

int iTFS;                                             // FAN Speed
int iTL1, iTL2, iTL3, iTL4;                           // PWM in %
int WT1, WT2, WT3, WT4, WTAll;                        // W All
int WTL1, WTL2, WTL3, WTL4, WTLAll;                   // Lum/L
int AQOB;                                             // Объем аквариума

// DS18B20 - настройка температуры
byte averageFactor = 0;                               // коэффициент сглаживания (0 = не сглаживать)
int SensIndex0, SensIndex1, SensIndex2, SensIndex3;   // переназначение индекса датчиков
float tempC_0;                                        // переменная для среднего С1 и С2
float tempC_1, tempC_2, tempC_1ust, tempC_2ust;       // переменная температур и юстировки
float tempC_3, tempC_3ust;                            // переменная температур и юстировки
bool isRunHot = false;                                // Работает ли нагреватель
bool isRunCool = false;                               // Работает ли охладитель
float myTermostat = 26.00;                            // Заданная температура
float myHisteresis = 0.5;                             // Гистерезис
bool DS1ERROR, DS2ERROR, DS3ERROR;                    // Переменная ошибок датчиков
bool RCHStat1, RCHStat2, RCHStat3, RCHStat4;          // переменная состояния каналов реллейного модуля

int PWM_RES_FAN = 8;                                                                      //  8   10    12    13    битность
int PWM_Full_FAN = 255;                                                                   //  255 1023  4095  8192  максимальное значение ШИМ при битности выше
int PWM_RES = 12;                                                                         //  8   10    12    13    битность
int PWM_Full = 4095;                                                                      //  255 1023  4095  8192  максимальное значение ШИМ при битности выше
//====================================================                                    //  Канал 1 - белый холодный
unsigned long last_time1_1, last_time1_2, last_time1_3;                                   //  отметка времени
int PWM1Pow;                                                                              //  переменная уровня ШИМ
int PWM1_Max1, PWM1_Max2, PWM1_Max3;                                                      //  Максимальный уровень ШИМ
int PWM1_Interval1, PWM1_Interval2, PWM1_Interval3;                                       //  Интервал обработки 1000 = 1сек
int PWM1_DutyCycle1, PWM1_DutyCycle2, PWM1_DutyCycle3;                                    //  Начальный счетчик цикла
uint32_t PWM1Start1, PWM1Stop1, PWM1Start2, PWM1Stop2, PWM1Start3, PWM1Stop3;             //  Время начала и окончания 1
bool L1_1, L1_2, L1_3;                                                                    //  Состояние


//====================================================                                    //  Канал 2 - белый теплый
unsigned long last_time2_1, last_time2_2, last_time2_3;                                   //  отметка времени
int PWM2Pow;                                                                              //  переменная уровня ШИМ
int PWM2_Max1, PWM2_Max2, PWM2_Max3;                                                      //  Максимальный уровень ШИМ
int PWM2_Interval1, PWM2_Interval2, PWM2_Interval3;                                       //  Интервал обработки 1000 = 1сек
int PWM2_DutyCycle1, PWM2_DutyCycle2, PWM2_DutyCycle3;                                    //  Начальный счетчик цикла
uint32_t PWM2Start1, PWM2Stop1, PWM2Start2, PWM2Stop2, PWM2Start3, PWM2Stop3;             //  Время начала и окончания 1
bool L2_1, L2_2, L2_3;                                                                    //  Состояние


//====================================================                                    //  Канал 3 - синий
unsigned long last_time3_1, last_time3_2, last_time3_3;                                   //  отметка времени
int PWM3Pow;                                                                              //  переменная уровня ШИМ
int PWM3_Max1, PWM3_Max2, PWM3_Max3;                                                      //  Максимальный уровень ШИМ
int PWM3_Interval1, PWM3_Interval2, PWM3_Interval3;                                       //  Интервал обработки 1000 = 1сек
int PWM3_DutyCycle1, PWM3_DutyCycle2, PWM3_DutyCycle3;                                    //  Начальный счетчик цикла
uint32_t PWM3Start1, PWM3Stop1, PWM3Start2, PWM3Stop2, PWM3Start3, PWM3Stop3;             //  Время начала и окончания 1
bool L3_1, L3_2, L3_3;                                                                    //  Состояние
}

//====================================================                                    //  Канал 4 - белый теплый
unsigned long last_time4_1, last_time4_2, last_time4_3;                                                                 //  отметка времени
int PWM4Pow;                                                                              //  переменная уровня ШИМ
int PWM4_Max1, PWM4_Max2, PWM4_Max3;                                                      //  Максимальный уровень ШИМ
int PWM4_Interval1, PWM4_Interval2, PWM4_Interval3;                                       //  Интервал обработки 1000 = 1сек
int PWM4_DutyCycle1, PWM4_DutyCycle2, PWM4_DutyCycle3;                                    //  Начальный счетчик цикла
uint32_t PWM4Start1, PWM4Stop1, PWM4Start2, PWM4Stop2, PWM4Start3, PWM4Stop3;             //  Время начала и окончания 1
bool L4_1, L4_2, L4_3;                                                                    //  Состояние


//====================================================
int GET_TEMP_Interval;

void setup() {
  Serial.begin(115200);
  Serial.println(F("---Start Setup---"));
  Wire.begin();
  Blynk.begin(token, wssid, passw, bhost, bport);                                     //  Подключение к WI-FI
  CHAT_ID = "****************";
  secured_client.setCACert(TELEGRAM_CERTIFICATE_ROOT);

  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());                                                     //  Вывод реального IP
  requestTime();                                                                      //  Синхронизация времени
  ui.attachBuild(build);                                                        //  Создание веб морды
  ui.start();                                                                   //  Запуск веб морды
  ui.enableOTA("********", "************");  // с паролем                               //  Создание странички обновления по воздуху
  //if (!LittleFS.begin()) Serial.println("FS Error");
  ui.downloadAuto(true);

  pinMode(rHOT, OUTPUT);                                                          //  Управление питанием обогревателя
  pinMode(rATX, OUTPUT);                                                              //  Управление блоком питания АТХ
  digitalWrite(rATX, HIGH);
  //pinMode(BlynkLED, OUTPUT);                                                        // Светодиод на контроллере подключение к серверу Блинк
  pinMode(DisplayControl, OUTPUT);                                              //  Управление питанием дисплея
  pinMode(CoollerPower, OUTPUT);                                                      //  Управление питанием куллера

  sensors.begin();                                                                    //  Инициализация датчиков

  pinMode(PWM1_PIN, OUTPUT);                                                          //  Куллер
  ledcSetup(PWM0_Ch, PWM_Freq_FAN, PWM_RES_FAN);
  ledcAttachPin(FanPin, PWM0_Ch);
  ledcWrite(PWM0_Ch, 0);

  pinMode(PWM1_PIN, OUTPUT);                                                          //  Канал1 - Белый холодный свет
  ledcSetup(PWM1_Ch, PWM_Freq, PWM_RES);
  ledcAttachPin(PWM1_PIN, PWM1_Ch);
  ledcWrite(PWM1_Ch, 0);
  timer.setInterval(PWM1_Interval1, Light_CH1_1);
  timer.setInterval(PWM1_Interval2, Light_CH1_2);
  timer.setInterval(PWM1_Interval3, Light_CH1_3);

  pinMode(PWM2_PIN, OUTPUT);                                                          //  Канал2 - Белый теплый свет
  ledcSetup(PWM2_Ch, PWM_Freq, PWM_RES);
  ledcAttachPin(PWM2_PIN, PWM2_Ch);
  ledcWrite(PWM2_Ch, 0);
  timer.setInterval(PWM2_Interval1, Light_CH2_1);
  timer.setInterval(PWM2_Interval2, Light_CH2_2);
  timer.setInterval(PWM2_Interval3, Light_CH2_3);

  pinMode(PWM3_PIN, OUTPUT);                                                          //  Канал3 - Синий свет
  ledcSetup(PWM3_Ch, PWM_Freq, PWM_RES);
  ledcAttachPin(PWM3_PIN, PWM3_Ch);
  ledcWrite(PWM3_Ch, 0);
  timer.setInterval(PWM3_Interval1, Light_CH3_1);
  timer.setInterval(PWM3_Interval2, Light_CH3_2);
  timer.setInterval(PWM3_Interval3, Light_CH3_3);

  pinMode(PWM4_PIN, OUTPUT);                                                          //  Канал4 - Красный свет
  ledcSetup(PWM4_Ch, PWM_Freq, PWM_RES);
  ledcAttachPin(PWM4_PIN, PWM4_Ch);
  ledcWrite(PWM4_Ch, 0);
  timer.setInterval(PWM4_Interval1, Light_CH4_1);
  timer.setInterval(PWM4_Interval2, Light_CH4_2);
  timer.setInterval(PWM4_Interval3, Light_CH4_3);


  if (! aht.begin()) Serial.println(F("AXT10 ERROR"));
  if (! sgp.begin()) Serial.println(F("SPG - NOT FOUND"));
  sgp.setIAQBaseline(0x8E68, 0x8F41);
  //digitalWrite(CoollerPower, HIGH);

  timer.setInterval(1000L, Timer1000);                                                //  Запуск таймера 1сек
  timer.setInterval(3000L, Timer3000);                                                //  Запуск таймера 3сек
  timer.setInterval(20000L, StartNjord);
  timer.setInterval(GET_TEMP_Interval, GetTempTime);                                  //  Запуск таймера замера температуры

  //bot.sendMessage(CHAT_ID, F("-NJORD- \nСтарт"), F(""));                          //  Оповещение в Телеграм о запуске
  BLColor();
  Serial.println(F("---Stop Setup---"));                                              //  Загрузка завершена
}

void StartNjord() {                                                             // Флаг запуска контроллера
  StartNRD = false;                                                             // Снимается через 10 сек после запуска
}

void build() {
  GP.BUILD_BEGIN();
  GP.PAGE_TITLE("-NJORD-");
  GP.THEME(GP_DARK);
  GP.TITLE("-NJORD-");
  GP.IMAGE(***********************************************");
  GP.HR();
  GP.BUTTON_MINI_LINK("/ota_update", "ПРОШИВКА", "#202326", "400px");
  GP.BREAK();
  GP.HR();
  GP.SYSTEM_INFO();
  GP.BUILD_END();
}

BLYNK_CONNECTED() { // Флаг первичного подключения
  if (isFirstConnect) {
    Blynk.syncAll();
  } isFirstConnect = false;
}

void reconnectBlynk() { // Переподключение к серверу
  if (!Blynk.connected()) {
    //digitalWrite(BlynkLED, LOW);
    Blynk.connect();
    if (Blynk.connect()) {
      //BLYNK_LOG("Reconnected");
    } else {
      //BLYNK_LOG("Not reconnected");
    }
  } //else digitalWrite(BlynkLED, HIGH);
}

void requestTime() {  // Сихронизация времени
  Blynk.sendInternal("rtc", "sync");
}

BLYNK_WRITE(InternalPinRTC) {         // получение времени
  long t = param.asLong();            // Получение текущего времени в переменную
  myUtime = t;                        // Назначение переменной
  myUtime %= 86400;                   // Время с начала суток
}

/*=====ОСВЕЩЕНИЕ==============================================================================
   НАЧАЛО
*/

BLYNK_WRITE(V1) { //=========== Плавно/резко включаем каналы
  switch (param.asInt()) {
    case 1: SW1 = true; break;
    case 2: SW1 = false; break;
  }
}

//============================================================================================================== 1
//=========== (Белый холодный свет) Канал 1 - расписание 1
BLYNK_WRITE(V2) { // Установка времени работы холодного освещения - расписание 1
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM1Start1 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM1Stop1 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V3) { // Задержка между шагами ШИМ Канал 1 расписание 1
  //Blynk.setProperty(V3, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM1_Interval1 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM1_Interval1 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM1_Interval1 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM1_Interval1 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM1_Interval1 = 500;
  }
}

BLYNK_WRITE(V4) { // Установка максимального уровня канал 1 расписание 1
  int i = param.asInt();
  if (i > 0) {
    PWM1_Max1 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM1_Max1: ")); Serial.println(PWM1_Max1);
  } else {
    PWM1_Max1 = 1;
  }
}

//=========== (Белый холодный свет) Канал 1 - расписание 2
BLYNK_WRITE(V8) { // Установка времени работы холодного освещения - расписание 2
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM1Start2 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM1Stop2 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V9) { // Задержка между шагами ШИМ Канал 1 расписание 2
  //Blynk.setProperty(V9, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM1_Interval2 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM1_Interval2 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM1_Interval2 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM1_Interval2 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM1_Interval2 = 500;
  }
}

BLYNK_WRITE(V10) { // Установка максимального уровня канал 1 расписание 2
  int i = param.asInt();
  if (i > 0) {
    PWM1_Max2 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM1_Max2: ")); Serial.println(PWM1_Max2);
  } else {
    PWM1_Max2 = 1;
  }
}

//=========== (Белый теплый свет) Канал 1 - расписание 3
BLYNK_WRITE(V14) { // Установка времени работы холодного освещения - расписание 3
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM1Start3 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM1Stop3 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V15) { // Задержка между шагами ШИМ Канал 1 расписание 3
  //Blynk.setProperty(V15, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM1_Interval3 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM1_Interval3 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM1_Interval3 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM1_Interval3 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM1_Interval3 = 500;
  }
}

BLYNK_WRITE(V16) { // Установка максимального уровня канал 1 расписание 3
  int i = param.asInt();
  if (i > 0) {
    PWM1_Max3 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM1_Max3: ")); Serial.println(PWM1_Max3);
  } else {
    PWM1_Max3 = 1;
  }
}

//============================================================================================================== 2
//=========== (Белый теплый свет) Канал 2 - расписание 1
BLYNK_WRITE(V20) { // Установка времени работы холодного освещения - расписание 1
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM2Start1 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM2Stop1 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V21) { // Задержка между шагами ШИМ Канал 1 расписание 1
  //Blynk.setProperty(V21, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM2_Interval1 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM2_Interval1 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM2_Interval1 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM2_Interval1 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM2_Interval1 = 500;
  }
}

BLYNK_WRITE(V22) { // Установка максимального уровня канал 1 расписание 2
  int i = param.asInt();
  if (i > 0) {
    PWM2_Max1 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM2_Max1: ")); Serial.println(PWM2_Max1);
  } else {
    PWM2_Max1 = 1;
  }
}

//=========== (Белый теплый свет) Канал 2 - расписание 2
BLYNK_WRITE(V26) { // Установка времени работы холодного освещения - расписание 2
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM2Start2 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM2Stop2 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V27) { // Задержка между шагами ШИМ Канал 2 расписание 2
  //Blynk.setProperty(V27, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM2_Interval2 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM2_Interval2 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM2_Interval2 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM2_Interval2 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM2_Interval2 = 500;
  }
}

BLYNK_WRITE(V28) { // Установка максимального уровня канал 2 расписание 2
  int i = param.asInt();
  if (i > 0) {
    PWM2_Max2 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM2_Max2: ")); Serial.println(PWM2_Max2);
  } else {
    PWM2_Max2 = 1;
  }
}

//=========== (Белый теплый свет) Канал 2 - расписание 3
BLYNK_WRITE(V32) { // Установка времени работы холодного освещения - расписание 3
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM2Start3 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM2Stop3 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V33) { // Задержка между шагами ШИМ Канал 2 расписание 3
  //Blynk.setProperty(V33, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM2_Interval3 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM2_Interval3 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM2_Interval3 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM2_Interval3 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM2_Interval3 = 500;
  }
}

BLYNK_WRITE(V34) { // Установка максимального уровня канал 2 расписание 3
  int i = param.asInt();
  if (i > 0) {
    PWM2_Max3 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM2_Max3: ")); Serial.println(PWM2_Max3);
  } else {
    PWM2_Max3 = 1;
  }
}

//============================================================================================================== 3
//=========== (Синий свет) Канал 3 - расписание 1
BLYNK_WRITE(V38) { // Установка времени работы холодного освещения - расписание 1
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM3Start1 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM3Stop1 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V39) { // Задержка между шагами ШИМ Канал 3 расписание 1
  //Blynk.setProperty(V39, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM3_Interval1 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM3_Interval1 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM3_Interval1 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM3_Interval1 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM3_Interval1 = 500;
  }
}

BLYNK_WRITE(V40) { // Установка максимального уровня канал 1 расписание 2
  int i = param.asInt();
  if (i > 0) {
    PWM3_Max1 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM3_Max1: ")); Serial.println(PWM3_Max1);
  } else {
    PWM3_Max1 = 1;
  }
}

//=========== (Синий свет) Канал 3 - расписание 2
BLYNK_WRITE(V44) { // Установка времени работы холодного освещения - расписание 2
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM3Start2 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM3Stop2 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V45) { // Задержка между шагами ШИМ Канал 3 расписание 2
  //Blynk.setProperty(V45, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM3_Interval2 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM3_Interval2 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM3_Interval2 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM3_Interval2 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM3_Interval2 = 500;
  }
}

BLYNK_WRITE(V46) { // Установка максимального уровня канал 2 расписание 2
  int i = param.asInt();
  if (i > 0) {
    PWM3_Max2 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM3_Max2: ")); Serial.println(PWM3_Max2);
  } else {
    PWM3_Max2 = 1;
  }
}

//=========== (Синий свет) Канал 3 - расписание 3
BLYNK_WRITE(V50) { // Установка времени работы холодного освещения - расписание 3
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM3Start3 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM3Stop3 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V51) { // Задержка между шагами ШИМ Канал 2 расписание 3
  //Blynk.setProperty(V51, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM3_Interval3 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM3_Interval3 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM3_Interval3 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM3_Interval3 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM3_Interval3 = 500;
  }
}

BLYNK_WRITE(V52) { // Установка максимального уровня канал 2 расписание 3
  int i = param.asInt();
  if (i > 0) {
    PWM3_Max3 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM3_Max3: ")); Serial.println(PWM3_Max3);
  } else {
    PWM3_Max3 = 1;
  }
}

//============================================================================================================== 4
//=========== (Красный свет) Канал 4 - расписание 1
BLYNK_WRITE(V56) { // Установка времени работы холодного освещения - расписание 1
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM4Start1 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM4Stop1 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V57) { // Задержка между шагами ШИМ Канал 4 расписание 1
  //Blynk.setProperty(V57, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM4_Interval1 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM4_Interval1 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM4_Interval1 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM4_Interval1 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM4_Interval1 = 500;
  }
}

BLYNK_WRITE(V58) { // Установка максимального уровня канал 4 расписание 2
  int i = param.asInt();
  if (i > 0) {
    PWM4_Max1 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM4_Max1: ")); Serial.println(PWM4_Max1);
  } else {
    PWM4_Max1 = 1;
  }
}

//=========== (Красный свет) Канал 4 - расписание 2
BLYNK_WRITE(V62) { // Установка времени работы холодного освещения - расписание 2
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM4Start2 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM4Stop2 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V63) { // Задержка между шагами ШИМ Канал 4 расписание 2
  //Blynk.setProperty(V63, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM4_Interval2 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM4_Interval2 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM4_Interval2 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM4_Interval2 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM4_Interval2 = 500;
  }
}

BLYNK_WRITE(V64) { // Установка максимального уровня канал 4 расписание 2
  int i = param.asInt();
  if (i > 0) {
    PWM4_Max2 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM4_Max2: ")); Serial.println(PWM4_Max2);
  } else {
    PWM4_Max2 = 1;
  }
}

//=========== (Красный свет) Канал 4 - расписание 3
BLYNK_WRITE(V68) { // Установка времени работы красного освещения - расписание 3
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    PWM4Start3 = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    PWM4Stop3 = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V69) { // Задержка между шагами ШИМ Канал 4 расписание 3
  //Blynk.setProperty(V69, F("labels"), F("9 минут"), F("17 минут"), F("34 минуты"), F("51 минута"));
  switch (param.asInt()) {
    case 1: PWM4_Interval3 = 100;   break;  //  255|2min    1023|8,5min   4095|34min
    case 2: PWM4_Interval3 = 500;   break;  //  255|4min    1023|17min    4095|68min
    case 3: PWM4_Interval3 = 1000;  break;  //  255|6min    1023|34min    4095|136min
    case 4: PWM4_Interval3 = 2000;  break;  //  255|10min   1023|51min    4095|204min
    default: PWM4_Interval3 = 500;
  }
}

BLYNK_WRITE(V70) { // Установка максимального уровня канал 4 расписание 3
  int i = param.asInt();
  if (i > 0) {
    PWM4_Max3 = map(i, 0, 100, 0, PWM_Full);
    Serial.print(F("PWM4_Max3: ")); Serial.println(PWM4_Max3);
  } else {
    PWM4_Max3 = 1;
  }
}

void Light_CH1_1() {                                                                    // Холодное освещение, Канал 1 Расписание 1
  if (!L1_2 && !L1_3) {
    //Serial.print(F("PWM1-1: ")); Serial.println(PWM1Pow);
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L1_1 && millis() - last_time1_1 > PWM1_Interval1 && PWM1Pow < PWM1_Max1) {      // Плавный рассвет и плавное увеличение яркости
        last_time1_1 = millis();
        PWM1Pow++;
        ledcWrite(PWM1_Ch, PWM1Pow);
        //ledcWrite(PWM1_Ch, getBrightCRT1(PWM1Pow) + 1);
        int ii = map(PWM1Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V5, ii);
      }
      if (L1_1 && millis() - last_time1_1 > PWM1_Interval1 && PWM1Pow > PWM1_Max1) {      // Плавное уменьшение яркости
        last_time1_1 = millis();
        PWM1Pow--;
        ledcWrite(PWM1_Ch, PWM1Pow);
        //ledcWrite(PWM1_Ch, getBrightCRT1(PWM1Pow) - 1);
        int ii = map(PWM1Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V5, ii);
      }
      if (!L1_1 && millis() - last_time1_1 > PWM1_Interval1 && PWM1Pow > 0) {             // Плавный закат
        last_time1_1 = millis();
        PWM1Pow--;
        ledcWrite(PWM1_Ch, PWM1Pow);
        //ledcWrite(PWM1_Ch, getBrightCRT1(PWM1Pow) - 1);
        int ii = map(PWM1Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V5, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L1_1) ledcWrite(PWM1_Ch, PWM1_Max1); if (!L1_1) ledcWrite(PWM1_Ch, 0);
    }
  }
}

void Light_CH1_2() {                                                                    // Холодное освещение, Канал 1 Расписание 2
  if (!L1_1 && !L1_3) {
    //Serial.print(F("PWM1-2: ")); Serial.println(PWM1Pow);
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L1_2 && millis() - last_time1_2 > PWM1_Interval2 && PWM1Pow < PWM1_Max2) {      // Плавный рассвет и плавное увеличение яркости
        last_time1_2 = millis();
        PWM1Pow++;
        ledcWrite(PWM1_Ch, PWM1Pow);
        //ledcWrite(PWM1_Ch, getBrightCRT1(PWM1Pow) + 1);
        int ii = map(PWM1Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V5, ii);
      }
      if (L1_2 && millis() - last_time1_2 > PWM1_Interval2 && PWM1Pow > PWM1_Max2) {      // Плавное уменьшение яркости
        last_time1_2 = millis();
        PWM1Pow--;
        ledcWrite(PWM1_Ch, PWM1Pow);
        //ledcWrite(PWM1_Ch, getBrightCRT1(PWM1Pow) - 1);
        int ii = map(PWM1Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V5, ii);
      }
      if (!L1_2 && millis() - last_time1_2 > PWM1_Interval2 && PWM1Pow > 0) {             // Плавный закат
        last_time1_2 = millis();
        PWM1Pow--;
        ledcWrite(PWM1_Ch, PWM1Pow);
        //ledcWrite(PWM1_Ch, getBrightCRT1(PWM1Pow) - 1);
        int ii = map(PWM1Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V5, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L1_2) ledcWrite(PWM1_Ch, PWM1_Max2); if (!L1_2) ledcWrite(PWM1_Ch, 0);
    }
  }
}

void Light_CH1_3() {                                                                    // Холодное освещение, Канал 1 Расписание 3
  if (!L1_1 && !L1_2) {
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L1_3 && millis() - last_time1_3 > PWM1_Interval3 && PWM1Pow < PWM1_Max3) {      // Плавный рассвет и плавное увеличение яркости
        last_time1_3 = millis();
        PWM1Pow++;
        ledcWrite(PWM1_Ch, PWM1Pow);
        //ledcWrite(PWM1_Ch, getBrightCRT1(PWM1Pow) + 1);
        int ii = map(PWM1Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V5, ii);
      }
      if (L1_3 && millis() - last_time1_3 > PWM1_Interval3 && PWM1Pow > PWM1_Max3) {      // Плавное уменьшение яркости
        last_time1_3 = millis();
        PWM1Pow--;
        ledcWrite(PWM1_Ch, PWM1Pow);
        //ledcWrite(PWM1_Ch, getBrightCRT1(PWM1Pow) - 1);
        int ii = map(PWM1Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V5, ii);
      }
      if (!L1_3 && millis() - last_time1_3 > PWM1_Interval3 && PWM1Pow > 0) {             // Плавный закат
        last_time1_3 = millis();
        PWM1Pow--;
        ledcWrite(PWM1_Ch, PWM1Pow);
        //ledcWrite(PWM1_Ch, getBrightCRT1(PWM1Pow) - 1);
        int ii = map(PWM1Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V5, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L1_3) ledcWrite(PWM1_Ch, PWM1_Max3); if (!L1_3) ledcWrite(PWM1_Ch, 0);
    }
  }
}

void Light_CH2_1() {                                                                    // Расписание 1
  if (!L2_2 && !L2_3) {
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L2_1 && millis() - last_time2_1 > PWM2_Interval1 && PWM2Pow < PWM2_Max1) {      // Плавный рассвет и плавное увеличение яркости
        last_time2_1 = millis();
        PWM2Pow++;
        ledcWrite(PWM2_Ch, PWM2Pow);
        //ledcWrite(PWM2_Ch, getBrightCRT2(PWM2Pow) + 1);
        int ii = map(PWM2Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V23, ii);
      }
      if (L2_1 && millis() - last_time2_1 > PWM2_Interval1 && PWM2Pow > PWM2_Max1) {      // Плавное уменьшение яркости
        last_time2_1 = millis();
        PWM2Pow--;
        ledcWrite(PWM2_Ch, PWM2Pow);
        //ledcWrite(PWM2_Ch, getBrightCRT2(PWM2Pow) - 1);
        int ii = map(PWM2Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V23, ii);
      }
      if (!L2_1 && millis() - last_time2_1 > PWM2_Interval1 && PWM2Pow > 0) {             // Плавный закат
        last_time2_1 = millis();
        PWM2Pow--;
        ledcWrite(PWM2_Ch, PWM2Pow);
        //ledcWrite(PWM2_Ch, getBrightCRT2(PWM2Pow) - 1);
        int ii = map(PWM2Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V23, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L2_1) ledcWrite(PWM2_Ch, PWM2_Max1); if (!L2_1) ledcWrite(PWM2_Ch, 0);
    }
  }
}

void Light_CH2_2() {  //============== Расписание 2
  if (!L2_1 && !L2_3) {
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L2_2 && millis() - last_time2_2 > PWM2_Interval2 && PWM2Pow < PWM2_Max2) {      // Плавный рассвет и плавное увеличение яркости
        last_time2_2 = millis();
        PWM2Pow++;
        ledcWrite(PWM2_Ch, PWM2Pow);
        //ledcWrite(PWM2_Ch, getBrightCRT2(PWM2Pow) + 1);
        int ii = map(PWM2Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V23, ii);
      }
      if (L2_2 && millis() - last_time2_2 > PWM2_Interval2 && PWM2Pow > PWM2_Max2) {      // Плавное уменьшение яркости
        last_time2_2 = millis();
        PWM2Pow--;
        ledcWrite(PWM2_Ch, PWM2Pow);
        //ledcWrite(PWM2_Ch, getBrightCRT2(PWM2Pow) - 1);
        int ii = map(PWM2Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V23, ii);
      }
      if (!L2_2 && millis() - last_time2_2 > PWM2_Interval2 && PWM2Pow > 0) {             // Плавный закат
        last_time2_2 = millis();
        PWM2Pow--;
        ledcWrite(PWM2_Ch, PWM2Pow);
        //ledcWrite(PWM2_Ch, getBrightCRT2(PWM2Pow) - 1);
        int ii = map(PWM2Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V23, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L2_2) ledcWrite(PWM2_Ch, PWM2_Max2); if (!L2_2) ledcWrite(PWM2_Ch, 0);
    }
  }
}

void Light_CH2_3() {  //============== Расписание 3
  if (!L2_1 && !L2_2) {
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L2_3 && millis() - last_time2_3 > PWM2_Interval3 && PWM2Pow < PWM2_Max3) {      // Плавный рассвет и плавное увеличение яркости
        last_time2_3 = millis();
        PWM2Pow++;
        ledcWrite(PWM2_Ch, PWM2Pow);
        //ledcWrite(PWM2_Ch, getBrightCRT2(PWM2Pow) + 1);
        int ii = map(PWM2Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V23, ii);
      }
      if (L2_3 && millis() - last_time2_3 > PWM2_Interval3 && PWM2Pow > PWM2_Max3) {      // Плавное уменьшение яркости
        last_time2_3 = millis();
        PWM2Pow--;
        ledcWrite(PWM2_Ch, PWM2Pow);
        //ledcWrite(PWM2_Ch, getBrightCRT2(PWM2Pow) - 1);
        int ii = map(PWM2Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V23, ii);
      }
      if (!L2_3 && millis() - last_time2_3 > PWM2_Interval3 && PWM2Pow > 0) {             // Плавный закат
        last_time2_3 = millis();
        PWM2Pow--;
        ledcWrite(PWM2_Ch, PWM2Pow);
        //ledcWrite(PWM2_Ch, getBrightCRT2(PWM2Pow) - 1);
        int ii = map(PWM2Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V23, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L2_3) ledcWrite(PWM2_Ch, PWM2_Max3); if (!L2_3) ledcWrite(PWM2_Ch, 0);
    }
  }
}

void Light_CH3_1() {
  //============== Расписание 1
  if (!L3_2 && !L3_3) {
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L3_1 && millis() - last_time3_1 > PWM3_Interval1 && PWM3Pow < PWM3_Max1) {      // Плавный рассвет и плавное увеличение яркости
        last_time3_1 = millis();
        PWM3Pow++;
        ledcWrite(PWM3_Ch, PWM3Pow);
        //ledcWrite(PWM3_Ch, getBrightCRT3(PWM3Pow) + 1);
        int ii = map(PWM3Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V41, ii);
      }
      if (L3_1 && millis() - last_time3_1 > PWM3_Interval1 && PWM3Pow > PWM3_Max1) {      // Плавное уменьшение яркости
        last_time3_1 = millis();
        PWM3Pow--;
        ledcWrite(PWM3_Ch, PWM3Pow);
        //ledcWrite(PWM3_Ch, getBrightCRT3(PWM3Pow) - 1);
        int ii = map(PWM3Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V41, ii);
      }
      if (!L3_1 && millis() - last_time3_1 > PWM3_Interval1 && PWM3Pow > 0) {             // Плавный закат
        last_time3_1 = millis();
        PWM3Pow--;
        ledcWrite(PWM3_Ch, PWM3Pow);
        //ledcWrite(PWM3_Ch, getBrightCRT3(PWM3Pow) - 1);
        int ii = map(PWM3Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V41, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L3_1) ledcWrite(PWM3_Ch, PWM3_Max1); if (!L3_1) ledcWrite(PWM3_Ch, 0);
    }
  }
}
void Light_CH3_2() {  //============== Расписание 2
  if (!L3_1 && !L3_3) {
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L3_2 && millis() - last_time3_2 > PWM3_Interval2 && PWM3Pow < PWM3_Max2) {      // Плавный рассвет и плавное увеличение яркости
        last_time3_2 = millis();
        PWM3Pow++;
        ledcWrite(PWM3_Ch, PWM3Pow);
        //ledcWrite(PWM3_Ch, getBrightCRT3(PWM3Pow) + 1);
        int ii = map(PWM3Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V41, ii);
      }
      if (L3_2 && millis() - last_time3_2 > PWM3_Interval2 && PWM3Pow > PWM3_Max2) {      // Плавное уменьшение яркости
        last_time3_2 = millis();
        PWM3Pow--;
        ledcWrite(PWM3_Ch, PWM3Pow);
        //ledcWrite(PWM3_Ch, getBrightCRT3(PWM3Pow) - 1);
        int ii = map(PWM3Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V41, ii);
      }
      if (!L3_2 && millis() - last_time3_2 > PWM3_Interval2 && PWM3Pow > 0) {             // Плавный закат
        last_time3_2 = millis();
        PWM3Pow--;
        ledcWrite(PWM3_Ch, PWM3Pow);
        //ledcWrite(PWM3_Ch, getBrightCRT3(PWM3Pow) - 1);
        int ii = map(PWM3Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V41, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L3_2) ledcWrite(PWM3_Ch, PWM3_Max2); if (!L3_2) ledcWrite(PWM3_Ch, 0);
    }
  }
}

void Light_CH3_3() {  //============== Расписание 3
  if (!L3_1 && !L3_2) {
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L3_3 && millis() - last_time3_3 > PWM3_Interval3 && PWM3Pow < PWM3_Max3) {      // Плавный рассвет и плавное увеличение яркости
        last_time3_3 = millis();
        PWM3Pow++;
        ledcWrite(PWM3_Ch, PWM3Pow);
        //ledcWrite(PWM3_Ch, getBrightCRT3(PWM3Pow) + 1);
        int ii = map(PWM3Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V41, ii);
      }
      if (L3_3 && millis() - last_time3_3 > PWM3_Interval3 && PWM3Pow > PWM3_Max3) {      // Плавное уменьшение яркости
        last_time3_3 = millis();
        PWM3Pow--;
        ledcWrite(PWM3_Ch, PWM3Pow);
        //ledcWrite(PWM3_Ch, getBrightCRT3(PWM3Pow) - 1);
        int ii = map(PWM3Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V41, ii);
      }
      if (!L3_3 && millis() - last_time3_3 > PWM3_Interval3 && PWM3Pow > 0) {             // Плавный закат
        last_time3_3 = millis();
        PWM3Pow--;
        ledcWrite(PWM3_Ch, PWM3Pow);
        //ledcWrite(PWM3_Ch, getBrightCRT3(PWM3Pow) - 1);
        int ii = map(PWM3Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V41, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L3_3) ledcWrite(PWM3_Ch, PWM3_Max3); if (!L3_3) ledcWrite(PWM3_Ch, 0);
    }
  }
}

void Light_CH4_1() {
  //============== Расписание 1
  if (!L4_2 && !L4_3) {
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L4_1 && millis() - last_time4_1 > PWM4_Interval1 && PWM4Pow < PWM4_Max1) {      // Плавный рассвет и плавное увеличение яркости
        last_time4_1 = millis();
        PWM4Pow++;
        ledcWrite(PWM4_Ch, PWM4Pow);
        //ledcWrite(PWM4_Ch, getBrightCRT4(PWM4Pow) + 1);
        int ii = map(PWM4Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V59, ii);
      }
      if (L4_1 && millis() - last_time4_1 > PWM4_Interval1 && PWM4Pow > PWM4_Max1) {      // Плавное уменьшение яркости
        last_time4_1 = millis();
        PWM4Pow--;
        ledcWrite(PWM4_Ch, PWM4Pow);
        //ledcWrite(PWM4_Ch, getBrightCRT4(PWM4Pow) - 1);
        int ii = map(PWM4Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V59, ii);
      }
      if (!L4_1 && millis() - last_time4_1 > PWM4_Interval1 && PWM4Pow > 0) {             // Плавный закат
        last_time4_1 = millis();
        PWM4Pow--;
        ledcWrite(PWM4_Ch, PWM4Pow);
        //ledcWrite(PWM4_Ch, getBrightCRT4(PWM4Pow) - 1);
        int ii = map(PWM4Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V59, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L4_1) ledcWrite(PWM4_Ch, PWM4_Max1); if (!L4_1) ledcWrite(PWM4_Ch, 0);
    }
  }
}

void Light_CH4_2() {  //============== Расписание 2
  if (!L4_1 && !L4_3) {
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L4_2 && millis() - last_time4_2 > PWM4_Interval2 && PWM4Pow < PWM4_Max2) {      // Плавный рассвет и плавное увеличение яркости
        last_time4_2 = millis();
        PWM4Pow++;
        ledcWrite(PWM4_Ch, PWM4Pow);
        //ledcWrite(PWM4_Ch, getBrightCRT4(PWM4Pow) + 1);
        int ii = map(PWM4Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V59, ii);
      }
      if (L4_2 && millis() - last_time4_2 > PWM4_Interval2 && PWM4Pow > PWM4_Max2) {      // Плавное уменьшение яркости
        last_time4_2 = millis();
        PWM4Pow--;
        ledcWrite(PWM4_Ch, PWM4Pow);
        //ledcWrite(PWM4_Ch, getBrightCRT4(PWM4Pow) - 1);
        int ii = map(PWM4Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V59, ii);
      }
      if (!L4_2 && millis() - last_time4_2 > PWM4_Interval2 && PWM4Pow > 0) {             // Плавный закат
        last_time4_2 = millis();
        PWM4Pow--;
        ledcWrite(PWM4_Ch, PWM4Pow);
        //ledcWrite(PWM4_Ch, getBrightCRT4(PWM4Pow) - 1);
        int ii = map(PWM4Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V59, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L4_2) ledcWrite(PWM4_Ch, PWM4_Max2); if (!L4_2) ledcWrite(PWM4_Ch, 0);
    }
  }
}

void Light_CH4_3() {  //============== Расписание 3
  if (!L4_1 && !L4_2) {
    if (SW1 == true) {                                                                  // Плавно или быстро делать закат/рассвет
      if (L4_3 && millis() - last_time4_3 > PWM4_Interval3 && PWM4Pow < PWM4_Max3) {      // Плавный рассвет и плавное увеличение яркости
        last_time4_3 = millis();
        PWM4Pow++;
        ledcWrite(PWM4_Ch, PWM4Pow);
        //ledcWrite(PWM4_Ch, getBrightCRT4(PWM4Pow) + 1);
        int ii = map(PWM4Pow + 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V59, ii);
      }
      if (L4_3 && millis() - last_time4_3 > PWM4_Interval3 && PWM4Pow > PWM4_Max3) {      // Плавное уменьшение яркости
        last_time4_3 = millis();
        PWM4Pow--;
        ledcWrite(PWM4_Ch, PWM4Pow);
        //ledcWrite(PWM4_Ch, getBrightCRT4(PWM4Pow) - 1);
        int ii = map(PWM4Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V59, ii);
      }
      if (!L4_3 && millis() - last_time4_3 > PWM4_Interval3 && PWM4Pow > 0) {             // Плавный закат
        last_time4_3 = millis();
        PWM4Pow--;
        ledcWrite(PWM4_Ch, PWM4Pow);
        //ledcWrite(PWM4_Ch, getBrightCRT4(PWM4Pow) - 1);
        int ii = map(PWM4Pow - 1, 0, PWM_Full, 0, 100); Blynk.virtualWrite(V59, ii);
      }
    } else {                                                                            // Включаем/Выключаем без задержек
      if (L4_3) ledcWrite(PWM4_Ch, PWM4_Max3); if (!L4_3) ledcWrite(PWM4_Ch, 0);
    }
  }
}

void Lights() {                                             // Выключаем или выключаем освещение
  //========================================================
  if (myUtime > PWM1Start1 && myUtime < PWM1Stop1) L1_1 = true; else L1_1 = false; // Холодный свет 1
  if (myUtime > PWM1Start2 && myUtime < PWM1Stop2) L1_2 = true; else L1_2 = false; // Холодный свет 2
  if (myUtime > PWM1Start3 && myUtime < PWM1Stop3) L1_3 = true; else L1_3 = false; // Холодный свет 3
  //========================================================
  if (myUtime > PWM2Start1 && myUtime < PWM2Stop1) L2_1 = true; else L2_1 = false; // Теплый свет 1
  if (myUtime > PWM2Start2 && myUtime < PWM2Stop2) L2_2 = true; else L2_2 = false; // Теплый свет 2
  if (myUtime > PWM2Start3 && myUtime < PWM2Stop3) L2_3 = true; else L2_3 = false; // Теплый свет 3
  //========================================================
  if (myUtime > PWM3Start1 && myUtime < PWM3Stop1) L3_1 = true; else L3_1 = false; // Синий свет 1
  if (myUtime > PWM3Start2 && myUtime < PWM3Stop2) L3_2 = true; else L3_2 = false; // Синий свет 2
  if (myUtime > PWM3Start3 && myUtime < PWM3Stop3) L3_3 = true; else L3_3 = false; // Синий свет 3
  //========================================================
  if (myUtime > PWM4Start1 && myUtime < PWM4Stop1) L4_1 = true; else L4_1 = false; // Красный свет 1
  if (myUtime > PWM4Start2 && myUtime < PWM4Stop2) L4_2 = true; else L4_2 = false; // Красный свет 2
  if (myUtime > PWM4Start3 && myUtime < PWM4Stop3) L4_3 = true; else L4_3 = false; // Красный свет 3
}
/*===========^^^^^ОСВЕЩЕНИЕ^^^^^=================================================================================
   ОКОНЧАНИЕ
*/


/*
    КЛИМАТ НАЧАЛО
*/
BLYNK_WRITE(V90) {                                     // Термостат myTermostat - myHisteresis
  myTermostat = param.asFloat();
}

BLYNK_WRITE(V91) {                                     // Гистерезис
  myHisteresis = param.asFloat();
}

BLYNK_WRITE(V92) {                                     // Усреднение расчетов 0 = нет усреднения
  averageFactor = param.asInt();
}

BLYNK_WRITE(V93) {                                    // Назначение датчика 1
  switch (param.asInt()) {
    case 1: // Вода 1
      SensIndex0 = 0;
      break;
    case 2: // Вода 2
      SensIndex0 = 1;
      break;
    case 3: // Воздух
      SensIndex0 = 2;
      break;
    default:
      SensIndex0 = 0;
  }
}

BLYNK_WRITE(V94) {                                    // Назначение датчика 2
  switch (param.asInt()) {
    case 1: // Вода 1
      SensIndex1 = 0;
      break;
    case 2: // Вода 2
      SensIndex1 = 1;
      break;
    case 3: // Воздух
      SensIndex1 = 2;
      break;
    default:
      SensIndex1 = 1;
  }
}

BLYNK_WRITE(V95) {                                    // Назначение датчика 3
  switch (param.asInt()) {
    case 1: // Вода 1
      SensIndex2 = 0;
      break;
    case 2: // Вода 2
      SensIndex2 = 1;
      break;
    case 3: // Воздух
      SensIndex2 = 2;
      break;
    default:
      SensIndex2 = 2;
  }
}

void GetTempTime() {
  GetTemp();
}

BLYNK_WRITE(V96) {
  switch (param.asInt()) {
    case 1: GET_TEMP_Interval = 1000;   break;
    case 2: GET_TEMP_Interval = 5000;   break;
    case 3: GET_TEMP_Interval = 10000;  break;
    case 4: GET_TEMP_Interval = 30000;  break;
    default: GET_TEMP_Interval = 1000;
  }
}

void GetTemp() {
  float newSensor1Value = tempC_1; // DS 1
  float newSensor2Value = tempC_2; // DS 2
  float newSensor3Value = tempC_3; // DS 3

  sensors.setResolution(temp1DeviceAddress, 12);              // Разрядность замера
  sensors.setResolution(temp2DeviceAddress, 12);              // Разрядность замера
  sensors.setResolution(temp3DeviceAddress, 12);              // Разрядность замера
  sensors.requestTemperatures();                              // Запрос температуры

  tempC_1 = sensors.getTempCByIndex(SensIndex0) + tempC_1ust; // Юстировка датчика
  tempC_2 = sensors.getTempCByIndex(SensIndex1) + tempC_2ust; // Юстировка датчика
  tempC_3 = sensors.getTempCByIndex(SensIndex2) + tempC_3ust; // Юстировка датчика

  // Выводим в таблицу приложения данные с датчиков
  Blynk.virtualWrite(V77, "update", 1, "[DS18B20] ВОДА(1)°С", tempC_1);
  Blynk.virtualWrite(V77, "update", 2, "[DS18B20] ВОДА(2)°С", tempC_2);
  Blynk.virtualWrite(V77, "update", 3, "[DS18B20] ВОЗДУХ °С", tempC_3);

  if (!StartNRD) { // Среднее значение через 10 сек после старта
    String i = ("Замеры: " + String(averageFactor));
    //if (averageFactor > 0) Blynk.setProperty(V1, "label", i);
    //if (averageFactor > 0) Blynk.setProperty(V2, "label", i);
    // Усреднение данных
    if (averageFactor > 0) {
      String i = ("Замеры: " + String(averageFactor));
      //Blynk.setProperty(V1, "label", i);
      //Blynk.setProperty(V2, "label", i);
      tempC_1 = (tempC_1 * (averageFactor - 1) + newSensor1Value) / averageFactor;
      tempC_2 = (tempC_2 * (averageFactor - 1) + newSensor2Value) / averageFactor;
      tempC_3 = (tempC_3 * (averageFactor - 1) + newSensor3Value) / averageFactor;
    } else {
      //Blynk.setProperty(V1, "label", "Как есть");
      //Blynk.setProperty(V2, "label", "Как есть");
      tempC_1 = newSensor1Value;
      tempC_2 = newSensor2Value;
      tempC_3 = newSensor3Value;
    }
  } else {
    //Blynk.setProperty(V1, "label", "Текущее");
    //Blynk.setProperty(V2, "label", "Текущее");
  }

  // Проверка работоспособности датчиков
  if (tempC_1 <= -50 || tempC_1 >= 100) { // Вода 1
    String t1s = String("-.--", 4);
    DS1ERROR = true;
  } else {
    String iT = String(tempC_1, 2);
    DS1ERROR = false;
  }

  if (tempC_2 <= -50 || tempC_2 >= 100) { // Вода 2
    String t1s = String("-.--", 4);
    DS2ERROR = true;
  } else {
    String iT = String(tempC_2, 2);
    DS2ERROR = false;
  }

  if (tempC_3 <= -50 || tempC_3 >= 100) { // Воздух
    DS3ERROR = true;
  } else {
    DS3ERROR = false;
  }


  // Отображаем температуру в приложении
  if (!StartNRD) {
    if (!DS1ERROR && !DS2ERROR) {                 // Если оба датчика работают
      tempC_0 = (tempC_1 + tempC_2) / 2;
      String iT0 = String(tempC_0, 2);
      Blynk.setProperty(V81, "color", "#199cff");
      Blynk.virtualWrite(V81, iT0);
    } else if (!DS1ERROR && DS2ERROR) {           // Если работает только первый
      String iT0 = String(tempC_1, 2);
      Blynk.setProperty(V81, "color", "#00ffff");
      Blynk.virtualWrite(V81, iT0);
    } else if (DS1ERROR && !DS2ERROR) {           // Если работает только второй
      String iT0 = String(tempC_2, 2);
      Blynk.setProperty(V81, "color", "#1fcecb");
      Blynk.virtualWrite(V81, iT0);
    } else {
      Blynk.setProperty(V81, "color", "#ff0000");
      Blynk.virtualWrite(V81, "ERROR");
    }
    if (!DS3ERROR) {
      String iT = String(tempC_3, 1);
      Blynk.setProperty(V82, "color", "#ffffff");
      Blynk.virtualWrite(V82, iT);
    } else {
      String t1s = String("-.--", 4);
      Blynk.setProperty(V82, "color", "#ff0000");
      Blynk.virtualWrite(V82, "ERROR");
    }
  }
}

BLYNK_WRITE(V97) { // Установка День/Ночь для куллера
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    CoollerDay = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    CoollerNight = h * 3600 + m * 60 + s;
  }
}

BLYNK_WRITE(V98) { // Скорость куллера день
  int value = param.asInt();
  switch (value) {
    case 0: {
        digitalWrite(CoollerPower, LOW);
        //Blynk.setProperty(V36, "label", "ВЫКЛЮЧЕН");
        //Blynk.virtualWrite(V37, 1);
        FanPowDay = 0;
        break;
      }
    case 1: {
        //if (myCooller == 1) ledcWrite(FanPin, 0);
        //Blynk.setProperty(V36, "label", "День минимум");
        //Blynk.virtualWrite(V37, 2);
        FanPowDay = 1;
        break;
      }
    case 2: {
        //if (myCooller == 1) ledcWrite(FanPin, 76);
        //Blynk.setProperty(V36, "label", "День 30%");
        //Blynk.virtualWrite(V37, 2);
        FanPowDay = 2;
        break;
      }
    case 3: {
        //if (myCooller == 1) ledcWrite(FanPin, 128);
        //Blynk.setProperty(V36, "label", "День 50%");
        //Blynk.virtualWrite(V37, 2);
        FanPowDay = 3;
        break;
      }
    case 4: {
        //if (myCooller == 1) ledcWrite(FanPin, 200);
        //Blynk.setProperty(V36, "label", "День 80%");
        //Blynk.virtualWrite(V37, 2);
        FanPowDay = 4;
        break;
      }
    case 5: {
        //if (myCooller == 1) ledcWrite(FanPin, 255);
        //Blynk.setProperty(V36, "label", "День максимум");
        //Blynk.virtualWrite(V37, 2);
        FanPowDay = 5;
        break;
      }
  }
}

BLYNK_WRITE(V99) { // Скорость вкуллера ночь
  int value = param.asInt();
  switch (value) {
    case 0: {
        digitalWrite(CoollerPower, LOW);
        //Blynk.setProperty(V38, "label", "ВЫКЛЮЧЕН");
        //Blynk.virtualWrite(V39, 1);
        FanPowNight = 0;
        break;
      }
    case 1: {
        //if (myCooller == 1) analogWrite(FanPin, 0);
        digitalWrite(CoollerPower, LOW);
        //Blynk.setProperty(V38, "label", "ВЫКЛЮЧЕН");
        //Blynk.virtualWrite(V39, 1);
        FanPowNight = 1;
        break;
      }
    case 2: {
        //if (myCooller == 1) ledcWrite(FanPin, 76);
        //Blynk.setProperty(V38, "label", "Ночь 30%");
        //Blynk.virtualWrite(V39, 2);
        FanPowNight = 2;
        break;
      }
    case 3: {
        //if (myCooller == 1) ledcWrite(FanPin, 128);
        //Blynk.setProperty(V38, "label", "Ночь 50%");
        //Blynk.virtualWrite(V39, 2);
        FanPowNight = 3;
        break;
      }
    case 4: {
        //if (myCooller == 1) ledcWrite(FanPin, 200);
        //Blynk.setProperty(V38, "label", "Ночь 80%");
        //Blynk.virtualWrite(V39, 2);
        FanPowNight = 4;
        break;
      }
    case 5: {
        //if (myCooller == 1) ledcWrite(FanPin, 255);
        //Blynk.setProperty(V38, "label", "Ночь максимум");
        //Blynk.virtualWrite(V39, 2);
        FanPowNight = 5;
        break;
      }
  }
}

void DayNight() { // Установка переменных День/Ночь для куллера
  if (myUtime > CoollerDay && myUtime < CoollerNight) { // Сравниваем текущее и выбранное время
    //Blynk.setProperty(V35, F("color"), F("#f0f8ff"));
    //Blynk.setProperty(V35, F("label"), F("СЕЙЧАС ДЕНЬ"));
    SDay = true; SNight = false; // ставим флаги День -да, Ночь - нет
  } else {
    //Blynk.setProperty(V35, F("color"), F("#4e5754"));
    //Blynk.setProperty(V35, F("label"), F("СЕЙЧАС НОЧЬ"));
    SDay = false; SNight = true; // ставим флаги День -нет, Ночь - да
  }
}

void FanSetPow() { // Установка скорости вентилятора
  if (isRunCool) {
    if (SDay) {
      int value = FanPowDay;
      switch (value) {
        case 0: {
            analogWrite(CoollerPower, LOW);
            fDay1 = 0; fDay2 = 0; fDay3 = 0; fDay4 = 0; fDay5 = 0;
            iFanSpeed = 0;
            break;
          }
        case 1: {
            digitalWrite(CoollerPower, HIGH);
            if (myCooller == 1) analogWrite(FanPin, fDay1);
            fDay2 = 0;
            //Serial.print(F("FanDay1: MIN"));
            iFanSpeed = 0;
            break;
          }
        case 2: {
            digitalWrite(CoollerPower, HIGH);
            if (millis() - timingFan > 1000 && fDay2 < 76) {
              timingFan = millis(); fDay2++; fDay1 = fDay2;
              if (myCooller == 1) analogWrite(FanPin, fDay2);
              iFanSpeed = fDay2;
            }
            if (millis() - timingFan > 1000 && fDay2 > 76) {
              timingFan = millis(); fDay2--; fDay1 = fDay2;
              if (myCooller == 1) analogWrite(FanPin, fDay2);
            }
            break;
          }
        case 3: {
            digitalWrite(CoollerPower, HIGH);
            if (millis() - timingFan > 1000 && fDay3 < 128) {
              timingFan = millis(); fDay3++; fDay2 = fDay3;
              if (myCooller == 1) analogWrite(FanPin, fDay3);
              iFanSpeed = fDay3;
            }
            if (millis() - timingFan > 1000 && fDay3 > 128) {
              timingFan = millis(); fDay3--; fDay2 = fDay3;
              if (myCooller == 1) analogWrite(FanPin, fDay3);
            }
            break;
          }
        case 4: {
            digitalWrite(CoollerPower, HIGH);
            if (millis() - timingFan > 1000 && fDay4 < 200) {
              timingFan = millis(); fDay4++; fDay3 = fDay4;
              if (myCooller == 1) analogWrite(FanPin, fDay4);
              iFanSpeed = fDay4;
            }
            if (millis() - timingFan > 1000 && fDay4 > 200) {
              timingFan = millis(); fDay4--; fDay3 = fDay4;
              if (myCooller == 1) analogWrite(FanPin, fDay4);
            }
            break;
          }
        case 5: {
            digitalWrite(CoollerPower, HIGH);
            if (millis() - timingFan > 1000 && fDay5 < 255) {
              timingFan = millis(); fDay5++; fDay4 = fDay5;
              if (myCooller == 1) analogWrite(FanPin, fDay5);
              iFanSpeed = fDay5;
            }
            break;
          }
      }
    } else {
      int value = FanPowNight;
      switch (value) {
        case 0: {
            digitalWrite(CoollerPower, LOW);
            iFanSpeed = 0;
            break;
          }
        case 1: {
            digitalWrite(CoollerPower, HIGH);
            if (myCooller == 1) analogWrite(FanPin, fNight1);
            iFanSpeed = 0;
            break;
          }
        case 2: {
            digitalWrite(CoollerPower, HIGH);
            if (millis() - timingFan > 1000 && fNight2 < 76) {
              timingFan = millis(); fNight2++;
              if (myCooller == 1) analogWrite(FanPin, fNight2);
              iFanSpeed = fNight2;
            }
            break;
          }
        case 3: {
            digitalWrite(CoollerPower, HIGH);
            if (millis() - timingFan > 1000 && fNight3 < 128) {
              timingFan = millis(); fNight3++;
              if (myCooller == 1) analogWrite(FanPin, fNight3);
              iFanSpeed = fNight3;
            }
            break;
          }
        case 4: {
            digitalWrite(CoollerPower, HIGH);
            if (millis() - timingFan > 1000 && fNight4 < 200) {
              timingFan = millis(); fNight4++;
              if (myCooller == 1) analogWrite(FanPin, fNight4);
              iFanSpeed = fNight4;
            }
            break;
          }
        case 5: {
            digitalWrite(CoollerPower, HIGH);
            if (millis() - timingFan > 1000 && fNight5 < 255) {
              timingFan = millis(); fNight5++;
              if (myCooller == 1) analogWrite(FanPin, fNight5);
              iFanSpeed = fNight5;
            }
            break;
          }
      }
    }
  }
}

BLYNK_WRITE(V100) { // Юстировка датчика 1
  tempC_1ust = param.asFloat();
}

BLYNK_WRITE(V101) { // Юстировка датчика 2
  tempC_2ust = param.asFloat();
}

BLYNK_WRITE(V102) { // Юстировка датчика 3
  tempC_3ust = param.asFloat();
}

void ClimatControl() {  // Управление климатом Охлаждение/Нагрев
  if (DS1ERROR && DS2ERROR) {                                           // Если оба датчика не работают
    isRunHot = false; digitalWrite(rHOT, LOW);                          // Выключаем нагреватель
    isRunCool = false;                                                  // Выключаем охладитель
    Blynk.virtualWrite(V83, 4);
  } else {                                                              // Если датчик работает

    if (!DS1ERROR && !DS2ERROR) {                                       // Если работают 2 датчика
      // ОХЛАЖДЕНИЕ
      if (iTVOC <= 660 && iECO2 <= 1000) {
        Blynk.setProperty(V83, "opacity", 100);
        if (tempC_0 >= myTermostat + myHisteresis) {
          digitalWrite(CoollerPower, HIGH);
          if (fMsgStartCool == true) {
            String iBot = (String(tempC_0) + F("°C(ALL) \nОхлаждение старт"));
            if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStopCool = true;
          } fMsgStartCool = false; isRunCool = true;
        } else {
          digitalWrite(CoollerPower, LOW); iFanSpeed = 0;
          if (fMsgStopCool == true) {
            String iBot = (String(tempC_0) + F("°C(ALL) \nОхлаждение стоп"));
            if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStartCool = true;
          } fMsgStopCool = false; isRunCool = false;
        }
      } else {
        digitalWrite(CoollerPower, LOW); iFanSpeed = 0;
        Blynk.setProperty(V83, "opacity", 20);
      }

      // ОБОГРЕВ
      if (tempC_0 <= myTermostat - myHisteresis) {
        digitalWrite(rHOT, HIGH);                                       // Включаем нагреватель
        Blynk.setProperty(V83, "opacity", 100);
        if (fMsgStartHot) {                                             // Если сообщение еще не отправлялось
          String iBot = (String(tempC_0) + F("°C(ALL) \nНагрев старт"));
          if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStopHot = true;
        } fMsgStartHot = false; isRunHot = true;
      } else {
        digitalWrite(rHOT, LOW);                                        // Выключаем нагреватель
        if (fMsgStopHot) {
          String iBot = (String(tempC_0) + F("°C(ALL) \nНагрев стоп"));
          if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStartHot = true;
        } fMsgStopHot = false; isRunHot = false;
      }

    } else if (!DS1ERROR && DS2ERROR) {                                 // Если работает только первый датчик

      // ОХЛАЖДЕНИЕ
      if (iTVOC <= 660 && iECO2 <= 1000) {
        Blynk.setProperty(V83, "opacity", 100);
        if (tempC_1 >= myTermostat + myHisteresis) {
          digitalWrite(CoollerPower, HIGH);
          if (fMsgStartCool == true) {
            String iBot = (String(tempC_1) + F("°C(DS1) \nОхлаждение старт"));
            if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStopCool = true;
          } fMsgStartCool = false; isRunCool = true;
        } else {
          digitalWrite(CoollerPower, LOW); iFanSpeed = 0;
          if (fMsgStopCool == true) {
            String iBot = (String(tempC_1) + F("°C(DS1) \nОхлаждение стоп"));
            if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStartCool = true;
          } fMsgStopCool = false; isRunCool = false;
        }
      } else {
        digitalWrite(CoollerPower, LOW); iFanSpeed = 0;
        Blynk.setProperty(V83, "opacity", 20);
      }

      // ОБОГРЕВ
      if (tempC_1 <= myTermostat - myHisteresis) {
        digitalWrite(rHOT, HIGH);                                       // Включаем нагреватель
        Blynk.setProperty(V83, "opacity", 100);
        if (fMsgStartHot) {                                             // Если сообщение еще не отправлялось
          String iBot = (String(tempC_1) + F("°C(DS1) \nНагрев старт"));
          if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStopHot = true;
        } fMsgStartHot = false; isRunHot = true;
      } else {
        digitalWrite(rHOT, LOW);                                        // Выключаем нагреватель
        if (fMsgStopHot) {
          String iBot = (String(tempC_1) + F("°C(DS1) \nНагрев стоп"));
          if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStartHot = true;
        } fMsgStopHot = false; isRunHot = false;
      }

    } else if (DS1ERROR && !DS2ERROR) {                                 // Если работает только второй датчик
      // ОХЛАЖДЕНИЕ
      if (iTVOC <= 660 && iECO2 <= 1000) {
        Blynk.setProperty(V83, "opacity", 100);
        if (tempC_2 >= myTermostat + myHisteresis) {
          digitalWrite(CoollerPower, HIGH);
          if (fMsgStartCool == true) {
            String iBot = (String(tempC_2) + F("°C(DS2) \nОхлаждение старт"));
            if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStopCool = true;
          } fMsgStartCool = false; isRunCool = true;
        } else {
          digitalWrite(CoollerPower, LOW); iFanSpeed = 0;
          if (fMsgStopCool == true) {
            String iBot = (String(tempC_2) + F("°C(DS2) \nОхлаждение стоп"));
            if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStartCool = true;
          } fMsgStopCool = false; isRunCool = false;
        }
      } else {
        digitalWrite(CoollerPower, LOW); iFanSpeed = 0;
        Blynk.setProperty(V83, "opacity", 20);
      }

      // ОБОГРЕВ
      if (tempC_2 <= myTermostat - myHisteresis) { //!isRunHot &&
        digitalWrite(rHOT, HIGH);                                       // Включаем нагреватель
        Blynk.setProperty(V83, "opacity", 100);
        if (fMsgStartHot) {                                             // Если сообщение еще не отправлялось
          String iBot = (String(tempC_2) + F("°C(DS2) \nНагрев старт"));
          if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStopHot = true;
        } fMsgStartHot = false; isRunHot = true;
      } else {
        digitalWrite(rHOT, LOW);                                        // Выключаем нагреватель
        if (fMsgStopHot) {
          String iBot = (String(tempC_2) + F("°C(DS2) \nНагрев стоп"));
          if (isCHAT) bot.sendMessage(CHAT_ID, iBot, F("")); fMsgStartHot = true;
        } fMsgStopHot = false; isRunHot = false;
      }
    }
  }

  //------------В Приложение
  if (!isRunHot && !isRunCool && (!DS1ERROR || !DS2ERROR)) Blynk.virtualWrite(V83, 1);
  if (isRunCool && (!DS1ERROR || !DS2ERROR)) Blynk.virtualWrite(V83, 2);
  if (isRunHot && (!DS1ERROR || !DS2ERROR)) Blynk.virtualWrite(V83, 3);

}
/*
   КЛИМАТ ОКОНЧАНИЕ
*/

/*
   ОПЦИИ НАЧАЛО
*/
//===========  ДИСПЛЕЙ ============================================================================
BLYNK_WRITE(V75) { // Установка времени работы дисплея
  TimeInputParam t(param);
  if (t.hasStartTime()) {
    uint32_t h = t.getStartHour(); uint32_t m = t.getStartMinute(); uint32_t s = t.getStartSecond();
    LCDStart = h * 3600 + m * 60 + s;
  }
  if (t.hasStopTime()) {
    uint32_t h = t.getStopHour(); uint32_t m = t.getStopMinute(); uint32_t s = t.getStopSecond();
    LCDStop = h * 3600 + m * 60 + s;
  }
}

void LCDonoff() { // LCD дисплей включение и выключение
  if (myUtime > LCDStart && myUtime < LCDStop) { // Сравниваем текущее и выбранное время
    LLCD = true; // Ставим флаг "Дисплей включен"
    //LCDLed.on(); // Виртуальный светодиод в приложении включен
    //Blynk.setProperty(V75, F("color"), F("#f0f8ff")); Blynk.setProperty(V75, "label", "ДИСПЛЕЙ ВКЛ.");
    digitalWrite(DisplayControl, HIGH); // Включаем дисплей
  } else {
    LLCD = false; // Ставим флаг "Дисплей выключен"
    //LCDLed.off(); // Виртуальный светодиод в приложении выключен
    //Blynk.setProperty(V75, F("color"), F("#4e5754")); Blynk.setProperty(V75, F("label"), F("ДИСПЛЕЙ ВЫКЛ."));
    digitalWrite(DisplayControl, LOW); // Выключаем дисплей
  }
}

void myATXBP() {                                                                //  Управляется минусом
  if (PWM1Pow > 0 || PWM2Pow > 0 || PWM3Pow > 0 || PWM4Pow > 0 || isRunCool) {  //  Включаем блок питания ATX
    digitalWrite(rATX, LOW);
    Blynk.setProperty(V84, "opacity", 100);                                     //  Отображаем в приложении
  } else {
    digitalWrite(rATX, HIGH);                                                   //  Выключаем блок питания ATX
    Blynk.setProperty(V84, "opacity", 20);                                      //  Отображаем в приложении
  }
}

// Объем аквариума для расчета AQOB
BLYNK_WRITE(V76) {
  int i = param.asInt(); AQOB = i;
}

void wtlAll() {                                                                 // Ватты и люмьены/литр
  WT1 = map(PWM1Pow, 0, PWM_Full, 0, 40);
  WT2 = map(PWM2Pow, 0, PWM_Full, 0, 40);
  WT3 = map(PWM3Pow, 0, PWM_Full, 0, 20);
  WT4 = map(PWM4Pow, 0, PWM_Full, 0, 20);
  WTAll = WT1 + WT2 + WT3 + WT4;
  Blynk.virtualWrite(V78, WTAll);

  WTL1 = map(PWM1Pow, 0, PWM_Full, 0, 3600);
  WTL2 = map(PWM2Pow, 0, PWM_Full, 0, 3600);
  WTL3 = map(PWM3Pow, 0, PWM_Full, 0, 300);
  WTL4 = map(PWM4Pow, 0, PWM_Full, 0, 700);
  WTLAll = (WTL1 + WTL2 + WTL3 + WTL4) / AQOB;
  if (WTLAll < 50) Blynk.setProperty(V79, F("color"), F("#f7943c"));
  if (WTLAll >= 50 && WTLAll <= 60) Blynk.setProperty(V79, F("color"), F("#7cfc00"));
  if (WTLAll > 60) Blynk.setProperty(V79, F("color"), F("#ffa000"));
  Blynk.virtualWrite(V79, WTLAll);
}

BLYNK_WRITE(V80) { // Перезапуск контроллера
  if (param.asInt() == 1) {
    //if (isCHAT) bot.sendMessage(CHAT_ID, F("-NJORD-: \nРестарт"), F(""));
    ESP.restart();
  }
}

void Opros() {
  sensors_event_t humidity, temp;
  aht.getEvent(&humidity, &temp);
  AXTemp = temp.temperature;            Blynk.virtualWrite(V71, AXTemp);
  AXHumi = humidity.relative_humidity;  Blynk.virtualWrite(V72, AXHumi);
  Blynk.virtualWrite(V77, "update", 4, "[AHT10] --ДЕВАЙС °С", AXTemp);
  Blynk.virtualWrite(V77, "update", 5, "[AHT10] --ДЕВАЙС %H", AXHumi);

  if (! sgp.IAQmeasure()) {                                                                   // проверяем возможность измерения
    return;                                                                                   // повторяем
  } else {                                                                                    // если данные есть
    sgp.setHumidity(getAbsoluteHumidity(temp.temperature, humidity.relative_humidity));       // берем температуру и влажность из переменных

    if (sgp.TVOC <= 65) Blynk.setProperty(V73, "color", "#00FF00");                           // Отличный уровень
    else if (sgp.TVOC >= 65 & sgp.TVOC <= 220) Blynk.setProperty(V73, "color", "#CEFF1D");    // Удовлетворительный уровень
    else if (sgp.TVOC >= 220 & sgp.TVOC <= 660) Blynk.setProperty(V73, "color", "#FF9218");   // Плохой уровень
    else if (sgp.TVOC >= 660) Blynk.setProperty(V73, "color", "#F8173E");                     // Неприемлемый уровень

    if (sgp.eCO2 <= 600) Blynk.setProperty(V74, "color", "#00FF00");                          // Отличный уровень
    else if (sgp.eCO2 >= 600 & sgp.eCO2 <= 700) Blynk.setProperty(V74, "color", "#CEFF1D");   // Удовлетворительный уровень
    else if (sgp.eCO2 >= 700 & sgp.eCO2 <= 1000) Blynk.setProperty(V74, "color", "#FF9218");  // Плохой уровень
    else if (sgp.eCO2 >= 1000) Blynk.setProperty(V74, "color", "#F8173E");                    // Неприемлемый уровень

    
    //iTVOC = sgp.TVOC; iECO2 = sgp.eCO2;
    Blynk.virtualWrite(V77, "update", 6, "[SGP30] tVOC ЕДЕНИЦ", sgp.TVOC);
    Blynk.virtualWrite(V77, "update", 7, "[SGP30] eCO2 ЕДЕНИЦ", sgp.eCO2);
    Blynk.virtualWrite(V73, sgp.eCO2);
    Blynk.virtualWrite(V74, sgp.TVOC);

  }
}
//=================================================================================================
/*

*/


void Timer1000() { // 1сек
  requestTime();                                                                      //  Синхронизация времени
  //  Lights();
  ui.tick();                                                                          //  ГиверПортал
  if (Blynk.connected()) Blynk.run();                                                 //  Пинок Блинку
  LCDonoff();                                                                         //  Управление дисплеем
  myATXBP();                                                                          //  Управление блоком питания
  FanSetPow();                                                                        //  Скорость куллера
  ClimatControl();                                                                    //  Управление охлаждением/нагревом
  wtlAll();                                                                           //  Расчет Ватт и Люм/литр
}

void Timer3000() { // 3сек
  reconnectBlynk();
  Opros();
  //GetTemp();
}

void loop() {
  timer.run();
  Lights();
  Light_CH1_1(); Light_CH1_2(); Light_CH1_3();
  Light_CH2_1(); Light_CH2_2(); Light_CH2_3();
  Light_CH3_1(); Light_CH3_2(); Light_CH3_3();
  Light_CH4_1(); Light_CH4_2(); Light_CH4_3();
  ShowFPS();
}

void ShowFPS()
{
  static uint32_t tm_m = 0;
  static uint32_t cnt_m = 0;
  cnt_m++;
  if ((millis() - tm_m) > 1000)
  {
    Serial.print("loop per sec: "); Serial.println(cnt_m);
    Blynk.virtualWrite(V0, cnt_m);
    cnt_m = 0;
    tm_m = millis();
  }
}

 

 

Поделиться сообщением


Ссылка на сообщение

@AlexLi Он пока клапан не получит,не проявится:ap:А кактусы уже самп проткнули насквозь...

Поделиться сообщением


Ссылка на сообщение
48 минут назад, ЛаГГен сказал(а):

@AlexLi Он пока клапан не получит,не проявится:ap:А кактусы уже самп проткнули насквозь...

Пусть хоть + поставит, а то уже переживаю)))

Поделиться сообщением


Ссылка на сообщение
2 часов назад, AlexLi сказал(а):

Пусть хоть + поставит, а то уже переживаю)))

Ну да,с ним веселее:ap:,у товарища здоровое чувство юмора,ценю...

Поделиться сообщением


Ссылка на сообщение
В 09.02.2024 - 14:16, AlexLi сказал(а):

ты там живой? Что построил то в конце концов?!)))

Живой =) Ничего пока не построил, ищу другой клапан. Чтоб открывался на меньшем давлении.

В 09.02.2024 - 14:35, ЛаГГен сказал(а):

Он пока клапан не получит,не проявится:ap:А кактусы уже самп проткнули насквозь...

Проявитель закончился, тока фиксаж остался =)) Да, с клапаном пока залипуха. а сампик с балкона спас, стоит гордо возле моего рабочего стола. Кактусы найдут себе другое место (наверно).

В 09.02.2024 - 15:24, AlexLi сказал(а):

Пусть хоть + поставит, а то уже переживаю)))

Захожу, читаю.. писать особо нечего было.. но не сегодня =)))))

23 часов назад, ЛаГГен сказал(а):

Ну да,с ним веселее:ap:,у товарища здоровое чувство юмора,ценю...

Спасибо, я тоже ценю здоровый юмор и открытость в общении!

 

И так! У меня зацвел анубиас! Для меня это конечно очень значимое событие, т.к. в моих аквариумах ничего никогда не цвело =)
image.thumb.png.8fb8ed9faa5aaaa1a6e7d5c3bffeb779.png

Поделиться сообщением


Ссылка на сообщение
1 час назад, VALKNUT сказал(а):

И так! У меня зацвел анубиас! Для меня это конечно очень значимое событие, т.к. в моих аквариумах ничего никогда не цвело =)

 

Живой!!!))) Это точно цветок?

Поделиться сообщением


Ссылка на сообщение
15 минут назад, AlexLi сказал(а):

Это точно цветок?

На листик совсем не похож.. стебель длинней, чем самый длинный стебель у самого большого листика в 2 раза. Раскроется, еще сфотаю =)

Поделиться сообщением


Ссылка на сообщение

Пятничка.. коньячок + размышлизмы.

Домашние стали жаловаться, что от моего "Управлятора" аквариумом слышен высокочастотный шум, признаюсь я не слышу. Но учитывая, что для питания конструкции был выбран Б/У блок питания АТХ (компьютерный), то вполне могу допустить, что под нагрузкой он пищит.

Начал подбирать подходящий БП из имеющегося на рынке и весьма был удивлен, что блоков питания со стабилизацией по напряжению, гораздо меньше чем блоков питания со стабилизацией по току.
Мне надо по напряжению, т.к. именно им я и оперирую в разработке своего девайса. Блоки со стабилизацией по току, это для сетодиодных лент, где ток должен оставаться на заданном уровне, а напряжение может плясать.

Нашел я такой БП на "амперке" за 2к и далее поиском на озоне.. в 1,5 килорубля ценой.

Из минусов:
- надо переделывать почти всё по монтажу. Скорее всего новый общий корпус для всего устройства.
- денежка в минус
Из плюсов:
- постоянные 12в, без необходимости активации в нужный момент времени, что за собой тянет дополнительный ништяк - логика охлаждения ночью (не нужен внешний БП для куллера).
- пассивное охлаждение нового БП (смотрел замеры температуры на разных режимах, вытягивает нагрузку в 110% без доп. охлаждения)
- есть чем занять руки в ожидании клапана для сампа.

ЗЫ. Анубиас стрелку гонит вверх, пока не раскрылась.
ЗЗЫ. В "большом" аквасе разрослась криптокарина, просто прет ее и нет у нее совести.

ХНЫЫЫК... мне нужен аквас в 5 раз больше! "Ни меньфе!" (с) Кролик из Виннипуха

Поделиться сообщением


Ссылка на сообщение
4 минут назад, VALKNUT сказал(а):

ХНЫЫЫК... мне нужен аквас в 5 раз больше! "Ни меньфе!" (с) Кролик из Виннипуха

стопудова! 

Поделиться сообщением


Ссылка на сообщение
16 минут назад, Ника сказал(а):

стопудова! 

Человеческий фактор... жена не одобряет новые объемы акваса и новых женщин.. ну что за человек такой? Всёж в дом! :ap:

Ну и сам анубиас. Шайтанама купидон. Надеюсь, что не к соседям собрался стрелу пускать =)

image.thumb.png.e191eb65c0448459951167c32288b373.png

Поделиться сообщением


Ссылка на сообщение

3 часов назад, VALKNUT сказал(а):

Надеюсь, что не к соседям собрался стрелу пускать =)

Если и подрастет еще, то не много. Скоро цветочек будет :)

Поделиться сообщением


Ссылка на сообщение
4 часов назад, VALKNUT сказал(а):

Человеческий фактор... жена не одобряет новые объемы акваса и новых женщин.. ну что за человек такой? Всёж в дом! :ap:

Ну и сам анубиас. Шайтанама купидон. Надеюсь, что не к соседям собрался стрелу пускать =)

image.thumb.png.e191eb65c0448459951167c32288b373.png

красавец! а жену надо уговорить. или купить. чем она там увлекается?

Поделиться сообщением


Ссылка на сообщение
5 минут назад, Юна сказал(а):

или купить. чем она там увлекается?

нееее.. у меня уже все окна и балкон в мозолях от цвточков.. даже на аквасе как-то стоял карантинный =)))

если только колечко... а то зима, пальчики мерзнут :ap:

Поделиться сообщением


Ссылка на сообщение

Можно «случайно» пригласить в дом трипса или паутинного клеща…ну совершенно случайно. 
например, с букетом роз.:ce:

места сразу появицца…:ec:

я надеюсь, Ваша супруга не одна из тех ютуб блогерш, у которых легко в сортире спутать кашпо с унитазом и сикнуть не туда?

Поделиться сообщением


Ссылка на сообщение
15 минут назад, Antik сказал(а):

я надеюсь, Ваша супруга не одна из тех

нет, она не одна из тех, она эксклюзив и артефакт.. обижать нет желания :blush2:

Поделиться сообщением


Ссылка на сообщение

Для публикации сообщений создайте учётную запись или авторизуйтесь

Вы должны быть пользователем, чтобы оставить комментарий

Создать учетную запись

Зарегистрируйте новую учётную запись в нашем сообществе. Это очень просто!

Регистрация нового пользователя

Войти

Уже есть аккаунт? Войти в систему.

Войти

×