Проект 14. Автоматическое управление светом в аквариуме

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

Описание работы:

Для начала работы подключите питание к Arduino. На индикаторе появится время установленное в датчике реального времени.

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

Для задания времени включения света, необходимо нажать зеленую кнопку. На индикаторе загорится слово "On", а зеленая кнопка загорится. Затем через секунду на индикаторе появится время включения света. По умолчанию установлено "00:00". Для изменения времени включения света нажимаем либо зеленую, либо красную кнопку. При разовом нажатии красной кнопки, минуты увеличивается на один, при удержании красной кнопки минуты увеличиваются пока нажата кнопка. При разовом нажатии зеленой кнопки минуты уменьшаются на один, при удержании зеленой кнопки минуты уменьшаются пока нажата кнопка. Для завершения настройки времени необходимо подождать 2 секунды. На индикаторе пойдет текущее время, а зеленая кнопка погаснет.

Для задания времени выключения света, необходимо нажать красную кнопку. На индикаторе загорится слово "OFF", а красная кнопка загорится. Затем через секунду на индикаторе появится время выключения света. По умолчанию установлено "00:00". Для изменения времени выключения света нажимаем либо зеленую, либо красную кнопку. При разовом нажатии красной кнопки, минуты увеличивается на один, при удержании красной кнопки минуты увеличиваются пока нажата кнопка. При разовом нажатии зеленой кнопки минуты уменьшаются на один, при удержании зеленой кнопки минуты уменьшаются пока нажата кнопка. Для завершения настройки времени необходимо подождать 2 секунды. На индикаторе пойдет текущее время, а красная кнопка погаснет.

Свет включится в установленное время и будет гореть до времени выключения. Тогда когда горит свет можно задавать новые значения включения или выключения света. При этом свет будет гореть до времени отключения в любом случае. Если вы хотите отключить свет раньше, чем планировалось необходимо задать новое время выключения.

В этом проекте, как и в предыдущем, приведено два варианта подключения осветительных приборов, показанные ниже в разделе "Схема сборки".

Нам понадобится:

Для реализации проекта нам необходимо установить следующие библиотеки:

О том как устанавливать библиотеки, Вы можете ознакомиться на странице Wiki - Установка библиотек в Arduino IDE.

Схема сборки:

  • Вариант 1. Подключаем лампочку как показано на рисунке ниже.

Код программы:

#include <EEPROM.h>                                         // Подключаем библиотеку EEPROM.
                                                            //
#include <iarduino_4LED.h>                                  // Подключаем библиотеку iarduino_4LED.
iarduino_4LED dispLED(1, A0);                               // Объявляем объект для работы с функциями библиотеки iarduino_4LED, с указанием выводов дисплея ( CLK , DIO ).
                                                            //
#include <iarduino_RTC.h>                                   // Подключаем библиотеку.
iarduino_RTC time(RTC_DS3231);                              // Объявляем объект time для модуля на базе чипа DS3231.
                                                            //
const uint8_t pinRele = 3;                                  // Объявляем пин для работы с реле.
const uint8_t pinKeyRed = 11;                               // Объявляем пин для работы с красной кнопкой.
const uint8_t pinKeyGreen = A3;                             // Объявляем пин для работы с зеленой кнопкой.
const uint8_t pinKeyLedRed = 13;                            // Объявляем пин для работы со светодиодом красной кнопки.
const uint8_t pinKeyLedGreen = 5;                           // Объявляем пин для работы со светодиодом зеленой кнопки.
                                                            //
int menu;                                                   // Переменная события.
int i;                                                      // Переменная счета.
                                                            //
bool eventKeyGreen = true;                                  // Переменная события разрешаем/запрещаем разовое изменение времени зеленой кнопки.
bool eventKeyRed = true;                                    // Переменная события разрешаем/запрещаем разовое изменение времени красной кнопки.
                                                            //
int hour;                                                   // Переменная для часов.
int minut;                                                  // переменная для секунд.
                                                            //
String hourChar;                                            // Переменная для хранения часов в строковом формате.
String minutChar;                                           // Переменная для хранения минут в строковом формате.
String times;                                               // Переменная для хранения времени в строковом формате.
                                                            //
int minOff;                                                 // Переменная для хранения часов выключения света.
int hourOff;                                                // Переменная для хранения минут выключения света.
                                                            //
int minOn;                                                  // Переменная для хранения часов включения света.
int hourOn;                                                 // Переменная для хранения минут включения света.
                                                            //
int minutPrev;                                              // Переменная для хранения предыдущих минут.
long prevMicros;                                            // Переменная для хранения предыдущего значения счетчика.
bool counter;                                               // Переменная события разрешает/запрещает вывод на индикатор.
bool alarm = false;                                         // Переменная события разрешает/запрещает управление светом.
                                                            //
void Return();                                              // Функция возвращения в начальное состояние, событие 1.
void ShowTime();                                            // Функция вывода времени.
void CheckHour();                                           // Функция проверки часов/минут.
void ChangeTime();                                          // Функция изменения времени. Увеличиваем/уменьшаем минуты.
                                                            //
void setup()                                                //
{                                                           //
  pinMode(pinRele, OUTPUT);                                 // Переводим вывод pinRele в режим выхода.
  pinMode(pinKeyGreen, INPUT);                              // Переводим вывод pinKeyGreen в режим входа.
  pinMode(pinKeyRed, INPUT);                                // Переводим вывод pinKeyRed в режим входа.
  dispLED.begin();                                          // Инициируем LED дисплей.
                                                            //
  time.begin();                                             // Инициируем RTC модуль.
  menu = 1;                                                 // Задаем событие 1.
                                                            //
  minOn = EEPROM.read(1);                                   // Считываем значение минут включения света из памяти EEPROM.
  if (minOn   > 59 && minOn   < 00) {minOn   = 0;}          // Если значение не в диапазоне минут, то обнуляем.
  hourOn = EEPROM.read(2);                                  // Считываем значение часов включения света из памяти EEPROM.
  if (hourOn  > 23 && hourOn  < 00) {hourOn  = 0;}          // Если значение не в диапазоне часов, то обнуляем.
  minOff = EEPROM.read(3);                                  // Считываем значение минут выключения света из памяти EEPROM.
  if (minOff  > 59 && minOff  < 00) {minOff  = 0;}          // Если значение не в диапазоне минут, то обнуляем.
  hourOff = EEPROM.read(4);                                 // Считываем значение часов выключения света из памяти EEPROM.
  if (hourOff > 23 && hourOff < 00) {hourOff = 0;}          // Если значение не в диапазоне часов, то обнуляем.
}                                                           //
                                                            //
void loop()                                                 //
{                                                           //
  time.gettime();                                           // Читаем время, обновляя значения всех переменных.
  switch (menu)                                             // Выбираем действие.
  {                                                         //
    case 1:                                                 // Событие 1. Задание времени.
    digitalWrite(pinKeyLedRed, LOW);                        // Выключаем светодиод на красной кнопки.
    digitalWrite(pinKeyLedGreen, LOW);                      // Выключаем светодиод на зеленой кнопки.
                                                            //
    hour  = time.Hours;                                     // Считываем значение часов с датчика времени.
    minut = time.minutes;                                   // Считываем значение минут с датчика времени.
    dispLED.light(7);                                       // Устанавливаем максимальную яркость свечения LED индикатора.
    ShowTime();                                             // Функция вывода времени на индикатор.
                                                            //
    if (hourOn == hour &&  minOn == minut)                  // Если время совпадает с временем включения света.
    {                                                       //
      alarm = true;                                         // Разрешаем включение света.
      digitalWrite(pinRele, HIGH);                          // Включаем реле.
    }                                                       //
    if (alarm) {menu = 7;}                                  // Если разрешено включение света, то разрешаем переход к событию 7.
                                                            //
    i = 0;                                                  // Обнуляем переменную счета.
    if(digitalRead(pinKeyGreen))                            // Проверка нажатия зеленой кнопки.
    {                                                       //
      while(digitalRead(pinKeyGreen))                       // Цикл слежения нажатой зеленой кнопки.
      {                                                     //
        delay(10);                                          // Ждём пока мы её не отпустим.
        if(i<100 && digitalRead(pinKeyRed))                 // Проверка нажатия красной кнопки и переменной счета, когда она меньше 100.
        {                                                   //
          menu = 2;                                         // Разрешаем переход к событию 2.
          eventKeyGreen = false;                            // Запрещаем нажатие зеленой кнопки.
       }                                                    //
        else {i++;}                                         // Увеличиваем переменную счета.
      }                                                     //
      if(eventKeyGreen)                                     // Проверка нажатия зеленой кнопки.
      {                                                     //
        menu = 5;                                           // Разрешаем переход к событию 5.
        eventKeyGreen = true;                               // Разрешаем нажатие зеленой кнопки.
      }                                                     //
    }                                                       //
    i = 0;                                                  // Обнуляем переменную счета.
                                                            //
    if(digitalRead(pinKeyRed))                              // Проверка нажатия красной кнопки.
    {                                                       //
      while(digitalRead(pinKeyRed))                         // Цикл слежения нажатой красной кнопки.
      {                                                     //
        delay(10);                                          // Ждём пока мы её не отпустим.
        if(i<100 && digitalRead(pinKeyGreen))               // Проверка нажатия зеленой кнопки. Если нажаты обе, то переходим к действию обратного отсчета.
        {                                                   //
          menu = 2;                                         // Разрешаем переход к событию 2.
          eventKeyRed = false;                              // Запрещаем нажатие красной кнопки.
        }                                                   //
        else {i++;}                                         // Увеличиваем переменную счета.
      }                                                     //
      if(eventKeyRed)                                       // Проверка нажатия зеленой кнопки.
      {                                                     //
        menu = 3;                                           // Разрешаем переход к событию 2.
        eventKeyRed = true;                                 // Разрешаем нажатие красной кнопки.
      }                                                     //
    }                                                       //
    i = 0;                                                  // Обнуляем переменную счета.
    eventKeyGreen = true;                                   // Разрешаем нажатие зеленой кнопки.
    eventKeyRed = true;                                     // Разрешаем нажатие красной кнопки.
    break;                                                  // Выходим из оператора case.
                                                            //
    case 2:                                                 // Событие 2.
    dispLED.light(2);                                       // Устанавливаем небольшую яркость свечения LED индикатора.
    digitalWrite(pinKeyLedRed, HIGH);                       // Включаем светодиод на красной кнопке.
    digitalWrite(pinKeyLedGreen, HIGH);                     // Включаем светодиод на зеленой кнопке.
    ChangeTime();                                           // Функция изменение времени.
    time.settime(-1, minut, hour);                          // Датчик времени принимает установленные новые значение минут и часов.
    Return();                                               // Функция возвращения в начальное состояние, событие 1.
    break;                                                  // Выходим из оператора case.
                                                            //
      case 3:                                               // Событие 3.
      dispLED.light(2);                                     // Устанавливаем небольшую яркость свечения LED индикатора.
      digitalWrite(pinKeyLedRed, HIGH);                     // Включаем светодиод на красной кнопке.
      dispLED.print("OFF");                                 // Вывод текста из букв латинского алфавита.
      delay(1000);                                          // Задержка одна секунда.
      menu = 4;                                             // Разрешаем переход к событию 4.
      hour = hourOff;                                       // Считываем ранее установленные часы выключения света.
      minut = minOff;                                       // Считываем ранее установленные минуты выключения света.
      break;                                                // Выходим из оператора case.
                                                            //
    case 4:                                                 // Событие 4.
    dispLED.light(2);                                       // Устанавливаем небольшую яркость свечения LED индикатора.
    ShowTime();                                             // Функция вывода времени.
    ChangeTime();                                           // Функция изменение времени.
    Return();                                               // Функция возвращения в начальное состояние, событие 1.
    if (menu == 1)                                          // Если разрешен переход к событию 1.
    {                                                       //
      hourOff = hour;                                       // Сохраняем новые установленные часы выключения света.
      minOff = minut;                                       // Сохраняем новые установленные минуты выключения света.
      EEPROM.write(3, minOff);                              // Записываем новые установленные минуты выключения света в память EEPROM по адресу 3.
      EEPROM.write(4, hourOff);                             // Записываем новые установленные часы выключения света в память EEPROM по адресу 4.
    }                                                       //
    break;                                                  // Выходим из оператора case.
                                                            //
      case 5:                                               // Событие 5.
      dispLED.light(2);                                     // Устанавливаем небольшую яркость свечения LED индикатора.
      digitalWrite(pinKeyLedGreen, HIGH);                   // Включаем светодиод на зеленой кнопке.
      dispLED.print("ON");                                  // Вывод текста из букв латинского алфавита.
      delay(1000);                                          // Задержка одна секунда.
      menu = 6;                                             // Разрешаем переход к событию 6.
      hour = hourOn;                                        // Считываем ранее установленные часы включения света.
      minut = minOn;                                        // Считываем ранее установленные минуты включения света.
      break;                                                // Выходим из оператора case.
                                                            //  
    case 6:                                                 // Событие 6.
    dispLED.light(2);                                       // Устанавливаем небольшую альную яркость свечения LED индикатора.
    ShowTime();                                             // Функция вывода времени.
    ChangeTime();                                           // Функция изменение времени.
    Return();                                               // Функция возвращения в начальное состояние, событие 1.
    if (menu == 1)                                          // Если разрешен переход к событию 1.
    {                                                       //
      hourOn = hour;                                        // Сохраняем новые установленные часы включения света.
      minOn = minut;                                        // Сохраняем новые установленные минуты включения света.
      EEPROM.write(1, minOn);                               // Записываем новые установленные минуты включения света в память EEPROM по адресу 1.
      EEPROM.write(2, hourOn);                              // Записываем новые установленные часы включения света в память EEPROM по адресу 2.
    }                                                       //
    break;                                                  // Выходим из оператора case.
                                                            //
    case 7:                                                 // Событие 7.
    ShowTime();                                             // Функция вывода времени.
    hour  = time.Hours;                                     // Считываем значение часов с датчика времени.
    minut = time.minutes;                                   // Считываем значение минут с датчика времени.
    if (hourOff == hour &&  minOff == minut)                // Если время совпадает с временем выключения света.
    {                                                       //
      menu = 1;                                             // Разрешаем переход в событие 1.
      alarm = false;                                        // Запрещаем включение света.
      digitalWrite(pinRele, LOW);                           // Выключаем реле.
    }                                                       //
    if (digitalRead(pinKeyGreen) || digitalRead(pinKeyRed)) // Проверка нажатия зеленой либо красной кнопки.
    {                                                       //
      menu = 1;                                             // Разрешаем переход к событию 1.
    }                                                       //
    break;                                                  // Выходим из оператора case.
  }                                                         //
}                                                           //
                                                            //
void Return()                                               // Функция вывода времени.
{                                                           //
  if (minutPrev == minut) {i++;}                            // Если нынешнее значение времени равно предыдущему значению минут, то увеличиваем переменную счета.
  else {i = 0;}                                             // Иначе обнуляем переменную счета.
  if (i > 150){menu = 1;}                                   // Если переменная счета больше 150, то разрешаем переход к событию 1.
  minutPrev = minut;                                        // Сохраняем текущее значение времени
}                                                           //
                                                            //
void CheckHour()                                            // Функция проверки часов/минут.
{                                                           //
  if (minut > 59){hour++; minut = 00;}                      // Если минуты больше 59, увеличиваем часы на 1, обнуляем минуты.
  if (minut < 00){hour--; minut = 59;}                      // Если минуты меньше 00, уменьшаем часы на 1, устанавливаем 59 минут.
  if (hour > 23) {hour = 00;}                               // Если часы больше 23, обнуляем часы.
  if (hour < 00) {hour = 23;}                               // Если часы меньше 00, устанавливаем 23 часа.
}                                                           //
                                                            //
void ChangeTime()                                           // Функция изменения времени. Увеличиваем/уменьшаем минуты.
{                                                           //
    if(digitalRead(pinKeyRed))                              // Проверка нажатия красной кнопки.
    {                                                       //
      while(digitalRead(pinKeyRed))                         // Цикл слежения нажатой красной кнопки.
      {                                                     //
        delay(10);                                          // Ждём пока мы её не отпустим.
        if(i<100){i++;}                                     // Если переменная счета меньше 100, то увеличиваем переменную счета.
        else                                                // Если переменная счета больше 100.
        {                                                   //
          delay(50);                                        // Задержка 50 мс.
          minut++;                                          // Увеличиваем количество минут.
          CheckHour();                                      // Функция проверки часов/минут.
          ShowTime();                                       // Функция показа времени.
        }                                                   //
      }                                                     //
      if (i < 70)                                           // Если переменная счета меньше 70.
      {                                                     //
        minut++;                                            // Увеличиваем количество минут.
        CheckHour();                                        // Функция проверки часов/минут.
        ShowTime();                                         // Функция показа времени.
      }                                                     //
      i = 0;                                                // Обнуляем переменную счета.
    }                                                       //
                                                            //
    if(digitalRead(pinKeyGreen))                            // Проверка нажатия зеленой кнопки.
    {                                                       //
      while(digitalRead(pinKeyGreen))                       // Цикл слежения нажатой зеленой кнопки.
      {                                                     //
        delay(10);                                          // Ждём пока мы её не отпустим.
        if(i<100){i++;}                                     // Если переменная счета меньше 100, то увеличиваем переменную счета.
        else                                                // Если переменная счета больше 100.
        {                                                   //
          delay(50);                                        // Задержка 50 мс.
          minut--;                                          // Уменьшаем количество минут.
          CheckHour();                                      // Функция проверки часов/минут.
          ShowTime();                                       // Функция показа времени.
        }                                                   //
      }                                                     //
      if (i < 70)                                           // Если переменная счета меньше 70.
      {                                                     //
        minut--;                                            // Уменьшаем количество минут.
        CheckHour();                                        // Функция проверки часов/минут.
        ShowTime();                                         // Функция показа времени.
      }                                                     //
      i = 0;                                                // Обнуляем переменную счета.
    }                                                       //
}                                                           //
                                                            //
void ShowTime()                                             // Функция показа времени.
{                                                           //
  if (hour>=0 && hour<10)                                   // Если количество времени у левого игрока от 0 до 9.
  {hourChar = (String) "0" + hour;}                         // Добавляем спереди ноль и переводим в строковое значение.
  else{hourChar = (String) hour;}                           // Иначе просто переводим количество времени в строковое значение.
                                                            //
  if (minut>=0 && minut<10)                                 // Если количество времени у правого игрока от 0 до 9.
  {minutChar = (String) "0" + minut;}                       // Добавляем спереди ноль и переводим в строковое значение.
  else{minutChar = (String) minut;}                         // Иначе просто переводим количество времени в строковое значение.
                                                            //
  times = hourChar + minutChar;                             // Присваиваем общей переменной количество времени левого и правого игрока.
                                                            //
  if (menu == 1 || menu == 7)                               // Если разрешены событие 1 или 7.
  {                                                         //
    if (micros() - prevMicros > 500000)                     // Каждые пол секунды.
    {                                                       //
      prevMicros = micros();                                // Сохраняем предыдущее значение таймера.
      counter=!counter;                                     // Изменяем переменную события вывода значений на индикатор.
      if (!counter)                                         // Если переменная события false.
      {                                                     //
        dispLED.print(times);                               // Выводим значение на индикатор.
      }                                                     //
      else                                                  // Если переменная события true.
      {                                                     //
        dispLED.point(2, true);                             // Включаем вторую точку.
      }                                                     //
    }                                                       //
  }                                                         //
  else                                                      // Если запрещены событие 1 или 7.
  {                                                         //
    dispLED.print(times);                                   // Выводим значение на индикатор.
    dispLED.point(2, true);                                 // Включаем вторую точку.
  }                                                         //
}                                                           //

Алгоритм работы:

В начале скетча (до кода setup) выполняются следующие действия:

В коде setup выполняются следующие действия:

  • Переводим выводы pinRele для реле, pinKeyGreen для зеленой кнопки, pinKeyRed для красной кнопки в режим выхода.
  • Инициируем LED дисплей.
  • Инициируем RTC модуль.
  • Задаем событие 1.
  • Проверяем данные записанные в память EEPROM. Если они не попадают в диапазон времени (для минут от 00 до 59, для часов от 00 до 24), то обнуляем полученные данные.

В коде loop выполняются следующие действия:

  • Читаем время с датчика реального времени.
  • Событие 1.
  • Выключаем светодиоды красной и зеленой кнопки.
  • Записываем показания датчика времени. Записываем текущее время (часы и минуты) в переменные
  • Устанавливаем максимальную яркость свечения LED индикатора.
  • Выводим время на дисплей с помощью функции "ShowTime()".
  • Проверяем совпадает текущее время с временем включения света. Если совпадает, то разрешаем включение света, включаем реле.
  • Проверяем событие разрешения света. Если разрешено, то разрешаем переход к событию 7.
  • Проверка нажатия зеленой кнопки. Если нажата, то переходим к циклу проверки нажатия красной кнопки. Ждем секунду и если не нажата, то разрешаем переход к событию 5 (Событие разрешение/запрет нажатия зеленой кнопки по умолчанию разрешено). Если нажата, то переходим к событию 2 и запрещаем нажатие зеленой кнопки.
  • Проверка нажатия красной кнопки. Если нажата, то переходим к циклу проверки нажатия зеленой кнопки. Ждем секунду и если не нажата, то разрешаем переход к событию 3 (Событие разрешение/запрет нажатия красной кнопки по умолчанию разрешено). Если нажата, то переходим к событию 2 и запрещаем нажатие красной кнопки.
  • Разрешаем событие нажатия зеленой и красной кнопки.
  • Событие 2.
  • Устанавливаем небольшую яркость свечения LED индикатора.
  • Включаем светодиоды на красной и зеленой кнопках.
  • Изменяем время (увеличиваем либо уменьшаем) с помощью функции "ChangeTime()".
  • Устанавливаем новое время.
  • Разрешаем переход в событие 1 с помощью функции "Return()".
  • Событие 3.
  • Устанавливаем небольшую яркость свечения LED индикатора.
  • Включаем светодиод на красной кнопке.
  • Вывод текста "OFF" на индикатор.
  • Ждем 1 секунду и разрешаем переход к событию 4.
  • Считываем время выключения в переменные времени "hour" и "minut".
  • Событие 4.
  • Выводим время на индикатор с помощью функции "ShowTime()".
  • Изменяем время (увеличиваем либо уменьшаем) с помощью функции "ChangeTime()".
  • Разрешаем переход в событие 1 с помощью функции "Return()".
  • Если разрешен переход в событие 1, то записываем новое заданное время выключения света в переменные выключения света и в память EEPROM.
  • Событие 5.
  • Устанавливаем небольшую яркость свечения LED индикатора.
  • Включаем светодиод на зеленой кнопке.
  • Вывод текста "On" на индикатор.
  • Ждем 1 секунду и разрешаем переход к событию 6.
  • Считываем время включения в переменные времени "hour" и "minut".
  • Событие 6.
  • Выводим время на индикатор с помощью функции "ShowTime()".
  • Изменяем время (увеличиваем либо уменьшаем) с помощью функции "ChangeTime()".
  • Разрешаем переход в событие 1 с помощью функции "Return()".
  • Если разрешен переход в событие 1, то записываем новое заданное время включения света в переменные включения света и в память EEPROM.
  • Событие 7.
  • Выводим время на индикатор с помощью функции "ShowTime()".
  • Считываем значение времени с датчика реального времени.
  • Если текущее время совпадает с временем выключения света, разрешаем переход к событию 1, запрещаем включение света, выключаем реле.
  • Если нажата одна из двух кнопок: красная либо зеленая, то разрешаем переход к событию один, а затем переход к событию нажатой кнопки.
  • Функция "Return()". В ней проверяем изменение минут. Если меняются, то обнуляем переменную счета. Если минуты не меняются увеличиваем переменную счета до 150. Как только переменная счета дойдет до 150 разрешаем переход событию 1. Сохраняем новое значение минут в переменную "minutPrev".
  • Функция "CheckHour()". Проверяем выход часов и минут за диапазон времени. Если минуты больше 59, то увеличиваем часы на один и обнуляем минуты. Если минуты меньше 00, то уменьшаем часы на один и устанавливаем минуты на 59. Если часы больше 24, то обнуляем часы, если часы меньше 00, то устанавливаем часы на 23.
  • Функция "ChangeTime()". В ней изменяем время (увеличиваем либо уменьшаем). Проверяем нажатие красной/зеленой кнопки одинаковы. Входим в цикл слежения нажатия красной/зеленой кнопки, в нем пока нажата кнопка увеличиваются/уменьшаются минуты, проверяем часы/минуты на выход за диапазон времени, выводим время на индикатор. Проверка разового нажатия красной/зеленой кнопки. Если нажата, то увеличиваем/уменьшаем минуты, проверяем часы/минуты на выход за диапазон времени, выводим время на индикатор.
  • Функция "ShowTime()". В ней преобразуем время целочисленного значения в строковое, добавляя ноль, где это необходимо. А так же выводим раз в пол секунды общее время и мигающую точку по центру, для событий 1 и 7. Для остальных событий выводим время и точку постоянно.

Ссылки:

Обсуждение