Arduino.ru

if (hour >= 8 && hour < 21) digitalWrite(13, (millis() / 600000) & 1);

*за делаи в коде - ноги выдергать, спички вставить и танцевать заставить.

Спасибо за оперативность! Подскажите, а как в таком случае менять периодичность и длительность цикла?? Напрмер: периодичность циклов 15 минут, а длительность включения - 10 минут.

прочитай свой пост сам

время запуска цикла у тебя с 8:00 продолжительность каждые 10-15 минут.

Если каждый запуск будет стартовать в разное время с разной длительностью, то только так, как в исходном скетче. Циклы можно записать компактнее, но общий принцип останется тот же -  каждый запуск кодировать отдельно.

Мда. Ну накручен код. Время надо свести к подсчету минут от 12 ночи. А то получается "римский счет" вместо "арабского", а точнее "бинарного" 

по-моему, это плоды вашего "просвещения" "классы С++ для чайников" :)

А что делать. Или вы считаете что надо жить в "каменном веке программирования".  Зато сейчас многие подходы понятны. И да классы не должны быть большими, это сбивает с толку. 

А начинать надо из этого

struct str_Do {
  unsigned long time_ON ;// время вкл
  unsigned long time_OFF;// время выкл
  byte event;// какое событие должно произойти
  struct str_Do * next; // следующий элемент
};

ПС: И не верьте что Си++ можно изучить за 21 день. Что бы научится писать надо как минимум 2-3 года.

Не совсем так. Все циклы включения или отключения должны быть одинаковыми по времени. Но время во выключенном и отключеном состоянии нужно будет менять. И можно ли это делать как то удобнее, не переписывая каждый раз весь код.? Например. Настроил я включение через каждые 15 мин и задержку во выключенном состоянии 10 минут. Проведя наблюдения я понимаю, что нужно включать каждые 10 мин, и держать во выключенном состоянии 8 мин. Вот как то хочу упростить процесс внесения изменения в код.

По мне так надо делать

enum event_t {RELAY1_ON, RELAY2_ON, RELAY3_ON, RELAY4_ON, RELAY5_ON};

//-------------------Компоновка------------------------
Cl_Brain Brain;
//-----------------main()---------------------------
void setup() {
  Brain.setup();
  Brain.Add(/*время активации час*/8 ,/*мин*/0 ,/*время отмены*/8 ,/*мин*/10,/*событие*/RELAY1_ON);
  Brain.Add(/*время активации час*/8 ,/*мин*/30,/*время отмены*/8 ,/*мин*/40,/*событие*/RELAY1_ON);
  Brain.Add(/*время активации час*/9 ,/*мин*/0 ,/*время отмены*/9 ,/*мин*/10,/*событие*/RELAY2_ON);
  Brain.Add(/*время активации час*/9 ,/*мин*/30,/*время отмены*/9 ,/*мин*/40,/*событие*/RELAY2_ON);
  Brain.Add(/*время активации час*/10,/*мин*/0 ,/*время отмены*/10,/*мин*/10,/*событие*/RELAY3_ON);
  Brain.Add(/*время активации час*/10,/*мин*/30,/*время отмены*/10,/*мин*/40,/*событие*/RELAY3_ON);
//--- Вот так вы и набираете таблицу.
}

void loop() {
  // put your main code here, to run repeatedly:

}

Доброго времени суток!

Попробовал переделать код. Выдает ошибку:

restiv. Это разумеется не весь скетч.Скорее набросок

/*
  ардуино пин 2<--> реле 1
  ардуино пин 3<--> реле 2
  ардуино пин 4<--> реле 3
  ардуино пин 5<--> реле 4
  ардуино пин 6<--> реле 5
*/
uint16_t time;//время в минутах от полночи
//-----Cl_Relay-----------------------------------
// класс реле
class Cl_Relay {
    byte pin;
    bool inv;
    bool relay;
  public:
    Cl_Relay(byte _pin, bool _inv)
      : pin(_pin), inv(_inv) {}
    void setup() {
      pinMode(pin, OUTPUT);
      OFF();
    }
    void ON() {
      relay = 1;
      digitalWrite(pin, relay ^ inv);
    }
    void OFF() {
      relay = 0;
      digitalWrite(pin, relay ^ inv);
    }
};
//-----Cl_Brain----------------------------------
// класс "мозг"
enum event_t {RELAY1_ON = 0, RELAY2_ON, RELAY3_ON, RELAY4_ON, RELAY5_ON};
struct str_Do {
  uint16_t time_ON ;// время вкл
  uint16_t time_OFF;// время выкл
  event_t event;// какое событие должно произойти
  struct str_Do * next; // следующий элемент
};
class Cl_Brain {
    uint16_t *time;//указатель на время в минутах от полночи
    void (*Do1_ON)(), (*Do1_OFF)(), (*Do2_ON)(), (*Do2_OFF)(), (*Do3_ON)(), (*Do3_OFF)(),
         (*Do4_ON)(), (*Do4_OFF)(), (*Do5_ON)(), (*Do5_OFF)();
    event_t EV[5], EV_old[5];// события теперешние и старые
    struct str_Do * Start = NULL;
  public:
    Cl_Brain(uint16_t *_time,
             void (*_Do1_ON)(), void (*_Do1_OFF)(), void (*_Do2_ON)(), void (*_Do2_OFF)(),
             void (*_Do3_ON)(), void (*_Do3_OFF)(), void (*_Do4_ON)(), void (*_Do4_OFF)(),
             void (*_Do5_ON)(), void (*_Do5_OFF)())
      : time(_time),
        Do1_ON(_Do1_ON), Do1_OFF(_Do1_OFF), Do2_ON(_Do2_ON), Do2_OFF(_Do2_OFF),
        Do3_ON(_Do3_ON), Do3_OFF(_Do3_OFF), Do4_ON(_Do4_ON), Do4_OFF(_Do4_OFF),
        Do5_ON(_Do5_ON), Do5_OFF(_Do5_OFF) {}
    void setup() {
      for (byte i = 0; i < 5; ++i)EV_old[i];


    }
    void Add(byte hourON, byte minON, byte hourOFF, byte minOFF, event_t event) {
      uint16_t timeON = hourON * 60 + minON;
      uint16_t timeOFF = hourOFF * 60 + minOFF;
      if (timeON >= timeOFF)return;
      struct str_Do *New = new struct str_Do();
      New->time_ON = timeON;
      New->time_OFF = timeOFF;
      New->event = event;
      New->next = Start;
      Start = New;
    }
    void tik() {
      for (byte i = 0; i < 5; ++i)EV[i];
      for (struct str_Do *ii = Start; ii != NULL ; ii = ii->next) {
        if (ii->time_ON >= *time && *time >= ii->time_OFF)EV[ii->event] = 1;
      }
      if (EV[0] && !EV_old[0]) { // если событие 1 произошло
        EV_old[0] = 1;
        Do1_ON();
      }
      if (!EV[0] && EV_old[0]) { // если событие 1 закончилось
        EV_old[0] = 0;
        Do2_OFF();
      }
      if (EV[1] && !EV_old[1]) { // если событие 2 произошло
        EV_old[1] = 1;
        Do2_ON();
      }
      if (!EV[1] && EV_old[1]) { // если событие 2 закончилось
        EV_old[1] = 0;
        Do3_OFF();
      }
      if (EV[2] && !EV_old[2]) { // если событие 3 произошло
        EV_old[2] = 1;
        Do3_ON();
      }
      if (!EV[2] && EV_old[2]) { // если событие 3 закончилось
        EV_old[2] = 0;
        Do3_OFF();
      }
      if (EV[3] && !EV_old[3]) { // если событие 4 произошло
        EV_old[3] = 1;
        Do4_ON();
      }
      if (!EV[3] && EV_old[3]) { // если событие 4 закончилось
        EV_old[3] = 0;
        Do4_OFF();
      }
      if (EV[4] && !EV_old[4]) { // если событие 5 произошло
        EV_old[4] = 1;
        Do5_ON();
      }
      if (!EV[4] && EV_old[4]) { // если событие 5 закончилось
        EV_old[4] = 0;
        Do5_OFF();
      }
    }
};
//----------------компоновка------------------------
Cl_Relay Relay1(/*пин*/2,/*инверсия*/0);
Cl_Relay Relay2(/*пин*/3,/*инверсия*/0);
Cl_Relay Relay3(/*пин*/4,/*инверсия*/0);
Cl_Relay Relay4(/*пин*/5,/*инверсия*/0);
Cl_Relay Relay5(/*пин*/6,/*инверсия*/0);
void Do1_ON() {
  Relay1.ON();
}
void Do1_OFF() {
  Relay1.OFF();
}
void Do2_ON() {
  Relay2.ON();
}
void Do2_OFF() {
  Relay2.OFF();
}
void Do3_ON() {
  Relay3.ON();
}
void Do3_OFF() {
  Relay3.OFF();
}
void Do4_ON() {
  Relay4.ON();
}
void Do4_OFF() {
  Relay4.OFF();
}
void Do5_ON() {
  Relay5.ON();
}
void Do5_OFF() {
  Relay5.OFF();
}

Cl_Brain Brain(
  /*время в мин*/&time,
  /*активация 1 события*/Do1_ON,/*деактивация 1 события*/Do1_OFF,
  /*активация 2 события*/Do2_ON,/*деактивация 2 события*/Do2_OFF,
  /*активация 3 события*/Do3_ON,/*деактивация 3 события*/Do3_OFF,
  /*активация 4 события*/Do4_ON,/*деактивация 4 события*/Do4_OFF,
  /*активация 5 события*/Do5_ON,/*деактивация 5 события*/Do5_OFF
);
//--------------main--------------------------
void setup() {
  Relay1.setup();
  Relay2.setup();
  Relay3.setup();
  Relay4.setup();
  Relay5.setup();
  Brain.setup();
  Brain.Add(/*время активации час*/8 ,/*мин*/0 ,/*время отмены*/8 ,/*мин*/10,/*событие*/RELAY1_ON);
  Brain.Add(/*время активации час*/8 ,/*мин*/30,/*время отмены*/8 ,/*мин*/40,/*событие*/RELAY1_ON);
  Brain.Add(/*время активации час*/9 ,/*мин*/0 ,/*время отмены*/9 ,/*мин*/10,/*событие*/RELAY2_ON);
  Brain.Add(/*время активации час*/9 ,/*мин*/30,/*время отмены*/9 ,/*мин*/40,/*событие*/RELAY2_ON);
  Brain.Add(/*время активации час*/10,/*мин*/0 ,/*время отмены*/10,/*мин*/10,/*событие*/RELAY3_ON);
  Brain.Add(/*время активации час*/10,/*мин*/30,/*время отмены*/10,/*мин*/40,/*событие*/RELAY3_ON);
  //--- Вот так вы и набираете таблицу.
}

void loop() {
}
/*Скетч использует 2018 байт (6%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 80 байт (3%) динамической памяти, оставляя 1968 байт для локальных переменных. Максимум: 2048 байт.
*/.

ПС строка 8 uint16_t time;//время в минутах от полночи эту переменую надо обновлять ежеминутно.

А так же надо ежеминутно вызывать метод Brain.tik(); который и будет все делать.

Спасибо! Попробую.

при проверке выдал такую ошибку:

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

//----------ИМПОРТ БИБЛИОТЕК-------------------------
#include <Wire.h>                                   //Подключаем библиотеку для использования I2C интерфейса с модулем RTC 
//#include <OneWire.h>                                //Подключаем библиотеку для использования однопроводного интерфейса 
//#include <DallasTemperature.h>                      //Температурного датчика DS18B20
#include <RTClib.h>                                 //Подключаем библиотеку для использования модуля часов реального времени RTC

//----------Объявляем разные переменные--------------
#define     RelayChn1   6        //  Используем цифровой ПОРТ 6 для ПЕРВОГО канала релейного модуля
#define     RelayChn2   10       //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn3   10       //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn4   10       //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn5   10       //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn6   10       //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn7   10       //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn8   10       //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn9   10       //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn10   10      //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn11   10      //  Используем цифровой ПОРТ 10 для ПЕРВОГО канала релейного модуля
#define     RelayChn12   10      //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn13   10      //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn14   10      //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn15   10      //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn16   10      //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn17   10      //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn18   10      //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn19   10      //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля
#define     RelayChn20   10      //  Используем цифровой ПОРТ 10 для ВТОРОГО канала релейного модуля

//OneWire oneWire(11);                                //Подключаем датчик DS18B20 на цифровой пин 10

//DallasTemperature sensors(&oneWire);                //Создаем объект sensors, подключенный по OneWire

//Создаем переменные для работы с термометром

//DeviceAddress tempDeviceAddress;                   //переменная для хранения адреса датчика
//float temp=0;                                      //переменная для текущего значения температуры (то что показывает датчик)
//const int t0 = 25;                                 //Уставка температуры включения первого реле
//const int tGistrsis = 1;                           //Уставка гистерезиса - т.е отклонения от темп-ры уставки
                                                   //т.е. в данном случае 1 = плюс минус 0.5 градус


//------------------------------------------------------------------
class time{
public:
        time(unsigned char h=0, unsigned char m=0, unsigned char s=0){
            set_time(h, m, s);
        }
        time&   operator = (time &t){hour = t.hour; min = t.min; sec = t.sec; seconds = t.seconds; return *this;}
        boolean operator ==(time &t){return seconds==t.get_time();}
        boolean operator !=(time &t){return !(*this==t);}
        boolean operator > (time &t){return seconds>t.get_time();}
        boolean operator < (time &t){return seconds<t.get_time();}
        boolean operator >=(time &t){return seconds>=t.get_time();}
        boolean operator <=(time &t){return seconds<=t.get_time();}
        void set_time(unsigned char h, unsigned char m, unsigned char s){
            hour=h; min=m; sec=s;
            seconds=(unsigned long)h*1440 + (unsigned long)m*60 + s;
        }
        unsigned long get_time(){return seconds;};
        void print()    {Serial.print(hour); Serial.print(':');Serial.print(min); Serial.print(':');Serial.println(sec);}
private:
        unsigned char   hour;
        unsigned char   min;
        unsigned char   sec;
        unsigned long   seconds;
};
//------------------------------------------------------------------
class relay{
public:
    relay(unsigned char pin){
        pin_num = pin;
        pinMode(pin_num, OUTPUT);
        digitalWrite(pin_num, 1); 
        state=0;
    }
    void operator =(boolean val) {digitalWrite(pin_num, !val); state=val;}
    operator boolean()  {return state;}
private:
    unsigned char   pin_num;
    boolean         state;
};                    
//------------------------------------------------------------------
RTC_DS1307  RTC;                        //Создаем переменную класса - для использования RTC

time    cur_time;

time    relay_1_on(8, 00, 0);          // Время включения 1-ого реле
time    relay_1_off(11, 12, 0);        // Время отключения 1-ого реле  

time    relay_2_on(8, 0, 0);         // Время включения 2-ого реле
time    relay_2_off(8, 15, 0);       // Время отключения 2-ого реле  

time    relay_3_on(8, 25, 0);        // Время включения 2-ого реле
time    relay_3_off(8, 40, 0);       // Время отключения 2-ого реле  

time    relay_4_on(8, 50, 0);         // Время включения 2-ого реле
time    relay_4_off(9, 05, 0);       // Время отключения 2-ого реле 
 
time    relay_5_on(9, 15, 0);        // Время включения 2-ого реле
time    relay_5_off(9, 30, 0);        // Время отключения 2-ого реле 

time    relay_6_on(10, 5, 0);        // Время включения 2-ого реле
time    relay_6_off(10, 20, 0);        // Время отключения 2-ого реле 

time    relay_7_on(10, 30, 0);        // Время включения 2-ого реле
time    relay_7_off(10, 45, 0);        // Время отключения 2-ого реле

time    relay_8_on(10, 55, 0);        // Время включения 2-ого реле
time    relay_8_off(11, 10, 0);        // Время отключения 2-ого реле 

time    relay_9_on(11, 20, 0);        // Время включения 2-ого реле
time    relay_9_off(11, 35, 0);        // Время отключения 2-ого реле 

time    relay_10_on(11, 45, 0);        // Время включения 2-ого реле
time    relay_10_off(12, 0, 0);        // Время отключения 2-ого реле 

time    relay_11_on(12, 10, 0);         // Время включения 2-ого реле
time    relay_11_off(12, 25, 0);       // Время отключения 2-ого реле  

time    relay_12_on(12, 35, 0);        // Время включения 2-ого реле
time    relay_12_off(12, 50, 0);       // Время отключения 2-ого реле  

time    relay_13_on(13, 0, 0);         // Время включения 2-ого реле
time    relay_13_off(13, 15, 0);       // Время отключения 2-ого реле 
 
time    relay_14_on(13, 25, 0);        // Время включения 2-ого реле
time    relay_14_off(13, 40, 0);        // Время отключения 2-ого реле 
 
time    relay_15_on(13, 50, 0);        // Время включения 2-ого реле
time    relay_15_off(14, 5, 0);        // Время отключения 2-ого реле 

time    relay_16_on(14, 15, 0);        // Время включения 2-ого реле
time    relay_16_off(14, 30, 0);        // Время отключения 2-ого реле 

time    relay_17_on(14, 43, 0);        // Время включения 2-ого реле
time    relay_17_off(14, 55, 0);        // Время отключения 2-ого реле

time    relay_18_on(15, 5, 0);        // Время включения 2-ого реле
time    relay_18_off(15, 20, 0);        // Время отключения 2-ого реле 

time    relay_19_on(15, 30, 0);        // Время включения 2-ого реле
time    relay_19_off(15, 45, 0);        // Время отключения 2-ого реле 

time    relay_20_on(15, 55, 0);        // Время включения 2-ого реле
time    relay_20_off(16, 10, 0);        // Время отключения 2-ого реле 

relay   relay_1(RelayChn1);             // Реле 1 
relay   relay_2(RelayChn2);             // Реле 2  
relay   relay_3(RelayChn3);             // Реле 2  
relay   relay_4(RelayChn4);             // Реле 2  
relay   relay_5(RelayChn5);             // Реле 2  
relay   relay_6(RelayChn6);             // Реле 2  
relay   relay_7(RelayChn7);             // Реле 2  
relay   relay_8(RelayChn8);             // Реле 2  
relay   relay_9(RelayChn9);             // Реле 2  
relay   relay_10(RelayChn10);             // Реле 2  
relay   relay_11(RelayChn11);             // Реле 2  
relay   relay_12(RelayChn12);             // Реле 2  
relay   relay_13(RelayChn13);             // Реле 2  
relay   relay_14(RelayChn14);             // Реле 2  
relay   relay_15(RelayChn15);             // Реле 2 
relay   relay_16(RelayChn16);             // Реле 2  
relay   relay_17(RelayChn17);             // Реле 2  
relay   relay_18(RelayChn18);             // Реле 2  
relay   relay_19(RelayChn19);             // Реле 2  
relay   relay_20(RelayChn20);             // Реле 2   


//--------------------------------------------------
void setup(){
  
//    sensors.begin();                                 //Инициализируем термодатчик 
//    sensors.getAddress(tempDeviceAddress, 0);
    
    Wire.begin();                                    //Инициируем I2C интерфейс
    RTC.begin();                                     //Инициирум RTC модуль

    Serial.begin(9600);
    Serial.println("Hello !");

    Serial.print("Relay_1 ON =");
    relay_1_on.print();
    Serial.print("Relay_1 OFF =");
    relay_1_off.print();
    Serial.print("Relay_2 ON =");
    relay_2_on.print();
    Serial.print("Relay_2 OFF =");
    relay_2_off.print();
    Serial.print("Relay_3 ON =");
    relay_3_on.print();
    Serial.print("Relay_3 OFF =");
    relay_3_off.print();
    Serial.print("Relay_4 ON =");
    relay_4_on.print();
    Serial.print("Relay_4 OFF =");
    relay_4_off.print();
    Serial.print("Relay_5 ON =");
    relay_5_on.print();
    Serial.print("Relay_5 OFF =");
    relay_5_off.print();
    Serial.print("Relay_6 ON =");
    relay_6_off.print();
    Serial.print("Relay_6 OFF =");
    relay_6_off.print();
    Serial.print("Relay_7 ON =");
    relay_7_off.print();
    Serial.print("Relay_7 OFF =");
    relay_7_off.print();
    Serial.print("Relay_8 ON =");
    relay_8_off.print();
    Serial.print("Relay_8 OFF =");
    relay_8_off.print();
    Serial.print("Relay_9 ON =");
    relay_9_off.print();
    Serial.print("Relay_9 OFF =");
    relay_9_off.print();
    Serial.print("Relay_10 ON =");
    relay_10_off.print();
    Serial.print("Relay_10 OFF =");
    relay_10_off.print();
    Serial.print("Relay_11 ON =");
    relay_11_on.print();
    Serial.print("Relay_11 OFF =");
    relay_11_off.print();
    Serial.print("Relay_12 ON =");
    relay_12_on.print();
    Serial.print("Relay_12 OFF =");
    relay_12_off.print();
    Serial.print("Relay_13 ON =");
    relay_13_on.print();
    Serial.print("Relay_13 OFF =");
    relay_13_off.print();
    Serial.print("Relay_14 ON =");
    relay_14_on.print();
    Serial.print("Relay_14 OFF =");
    relay_14_off.print();
    Serial.print("Relay_15 ON =");
    relay_15_on.print();
    Serial.print("Relay_15 OFF =");
    relay_15_off.print();
    Serial.print("Relay_16 ON =");
    relay_16_off.print();
    Serial.print("Relay_16 OFF =");
    relay_16_off.print();
    Serial.print("Relay_17 ON =");
    relay_17_off.print();
    Serial.print("Relay_17 OFF =");
    relay_17_off.print();
    Serial.print("Relay_18 ON =");
    relay_18_off.print();
    Serial.print("Relay_18 OFF =");
    relay_18_off.print();
    Serial.print("Relay_19 ON =");
    relay_19_off.print();
    Serial.print("Relay_19 OFF =");
    relay_19_off.print();
    Serial.print("Relay_20 ON =");
    relay_20_off.print();
    Serial.print("Relay_20 OFF =");
    relay_20_off.print();
    
}                                                    
//--------------------------------------------------
void loop()                                         
{ 
    delay(1000);                                                         // Задержка 1 сек. Чтобы не печаталось быстро
    
    //Запуск процедуры измерения температуры
//    sensors.setWaitForConversion(false);
//    sensors.requestTemperatures();
  //  sensors.setWaitForConversion(true);
    
    //Считывание значения температуры
//    sensors.getAddress(tempDeviceAddress, 0);
  //  temp=sensors.getTempC(tempDeviceAddress);
    
    DateTime myTime = RTC.now();                                         // Получаем текущее время из DS1307  
    cur_time.set_time(myTime.hour(), myTime.minute(), myTime.second());  // Устанавливаем часы, минут, секунды в cur_time

    cur_time.print();                                                    // Выводим текущее время

    //------------КАНАЛ 1 (Контроль температуры по времени) -------
//    sensors.requestTemperatures();

//  relay_1 = ((cur_time>=relay_1_on) && (cur_time<relay_1_off) && (temp < t0-tGistrsis/2));     // Состояние реле 1 = нахождение текущего времени в диапазоне от relay_1_on до relay_1_off и в диапазоне заданных температур 
    
//------------КАНАЛ 2 (Включение насоса)------------------------------
    relay_2 = (cur_time>=relay_2_on) && (cur_time<relay_2_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_2_on до relay_2_off
    relay_3 = (cur_time>=relay_3_on) && (cur_time<relay_3_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_3_on до relay_3_off
    relay_4 = (cur_time>=relay_4_on) && (cur_time<relay_4_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_4_on до relay_4_off
    relay_5 = (cur_time>=relay_5_on) && (cur_time<relay_5_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_5_on до relay_5_off
    relay_6 = (cur_time>=relay_6_on) && (cur_time<relay_6_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_2_on до relay_2_off
    relay_7 = (cur_time>=relay_7_on) && (cur_time<relay_7_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_3_on до relay_3_off
    relay_8 = (cur_time>=relay_8_on) && (cur_time<relay_8_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_4_on до relay_4_off
    relay_9 = (cur_time>=relay_9_on) && (cur_time<relay_9_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_5_on до relay_5_off
    relay_10 = (cur_time>=relay_10_on) && (cur_time<relay_10_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_2_on до relay_2_off
    relay_11 = (cur_time>=relay_11_on) && (cur_time<relay_11_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_2_on до relay_2_off
    relay_12 = (cur_time>=relay_12_on) && (cur_time<relay_12_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_2_on до relay_2_off
    relay_13 = (cur_time>=relay_13_on) && (cur_time<relay_13_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_3_on до relay_3_off
    relay_14 = (cur_time>=relay_14_on) && (cur_time<relay_14_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_4_on до relay_4_off
    relay_15 = (cur_time>=relay_15_on) && (cur_time<relay_15_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_5_on до relay_5_off
    relay_16 = (cur_time>=relay_16_on) && (cur_time<relay_16_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_2_on до relay_2_off
    relay_17 = (cur_time>=relay_17_on) && (cur_time<relay_17_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_3_on до relay_3_off
    relay_18 = (cur_time>=relay_18_on) && (cur_time<relay_18_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_4_on до relay_4_off
    relay_19 = (cur_time>=relay_19_on) && (cur_time<relay_19_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_5_on до relay_5_off
    relay_20 = (cur_time>=relay_20_on) && (cur_time<relay_20_off);     // Состояние реле 2 = нахождение текущего времени в диапазоне от relay_2_on до relay_2_off
}//------------Конец ЦИКЛА-----------------------------

И вот что выдает монитор порта:

Почему то время включения и отключения стоят одинаковые, хотя по коду забито иначе.

В чем у меня глюк?

Свою ошибку с монитором порта я понял, но почему реле не срабатывает не понимаю.

restiv Похоже у вас и у меня(Ардуино 1.8.0) версии различные. И да я не стремлюсь обновлять.

Подход банален. У вас события обновляются раз в минуту. Так что время будет мерятся в минутах. Да и обновлять надо только в начале минуты. Вот сейчас время time=100; сейчас у вас события в матрице Ev_old[5]. настало время time=101. Теперь надо построить новую матрицу событий Ev[5] под время time=101. Ну а дальше определить какие события включились, а какие отключились.

А меня теперь и мой старый код, опубликованный в первом посте перестал работать. Не понимаю в чем дело!!!!!

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