Главная » Форумы » Аппаратные вопросы

Подключить Pole Display к ардуино.

507 ответов [Последнее сообщение]
Чт, 28/10/2021 - 10:39
#401
mr.kasper_tyt
Offline
Зарегистрирован: 12.03.2018

Круто! Спасибо! Можно попросить ещё добавить возможность писать сообщения, думаю полезно будет)

Верх
Чт, 28/10/2021 - 11:16
#402
imatt
Offline
Зарегистрирован: 18.04.2020

Пардон )))) по ошибке создал канал а не группу для обсуждений

Просьба заходить по сылке https://t.me/joinchat/DCfF8RMLuuQ1YzFi 

Верх
Чт, 28/10/2021 - 11:35
#403
Amatroskin
Offline
Зарегистрирован: 21.04.2020

"Срок действия ссылки истек"  ))))

Верх
Чт, 28/10/2021 - 12:41
#404
imatt
Offline
Зарегистрирован: 18.04.2020

Матроскин Привет! Ты по какой ссылке переходишь ? по этой ? https://t.me/joinchat/DCfF8RMLuuQ1YzFi

Верх
Чт, 28/10/2021 - 12:45
#405
Amatroskin
Offline
Зарегистрирован: 21.04.2020

Привет, все теперь, вошёл)

Верх
Сб, 19/02/2022 - 20:55
#406
geniv82
Offline
Зарегистрирован: 21.02.2019

Кто-то спрашивал про датчик BMP280. Вот, прикрутил. Ну, и добавил пару плюшек в отображении температуры и влажности.

https://youtu.be/-MO7UjDYdd4  

А как сюда скетч выложить?

Верх
Сб, 19/02/2022 - 21:00
#407
Amatroskin
Offline
Зарегистрирован: 21.04.2020

Либо прямо текстом через кнопку {Code}, либо залей куда нибудь. Но наверно лучше текстом, так не потеряется)

Верх
Сб, 19/02/2022 - 21:07
#408
geniv82
Offline
Зарегистрирован: 21.02.2019 
/*BMP280
  Часы с отображением температуры и давления с индикацией на VFD (ВЛИ) дисплее покупателя 20*2 Futaba (vfd9cb1010 rev 1.2)
  AMatroskin 2020 год.
  devICEpro 2021 год.
*/

#include <GyverButton.h>
#include <SoftwareSerial.h>
#include <Wire.h>
#include <iarduino_RTC.h>
#include <Adafruit_BMP280.h>

#define SEALEVELPRESSURE_HPA (1010.7)
#define BTN1 17 //____________________________________________________Пины кнопок
#define BTN2 16
#define BTN3 15

#define COR_TEMP 0     //_____________________________________________Коректирвка температуры (вычитается из показаний датчика)
#define FIRST_LEVEL 8 //_____________________________________________Уровни переключения яркости
#define SECOND_LEVEL 150
#define THIRD_LEVEL  210
#define SHIFT 1  //___________________________________________________Изменение порядка отображения на экране время -> температура/влажность (дата, день недели) и наоборот происходит раз в минуту
//____________________________________________________________________1 -автоматическая перестановка включена, 0 - выключена. (Уменьшение неравномерности износа люминофора)

Adafruit_BMP280 bmp; //______________________________________________Объекты датчика температуры/влажности, часов RTC, последовательного порта и кнопок
iarduino_RTC watch(RTC_DS3231);
SoftwareSerial mySerial(11, 10);
GButton butt1(BTN1);
GButton butt2(BTN2);
GButton butt3(BTN3);

char dots = 0;
int temp_round, temp_round_c1, temp_round_c2, temp_round_d; //_______Переменные для отображения температуры
int pres_round, pres_round_c1, pres_round_c2, pres_round_c3;  //__________Переменные для отображения давления
uint32_t counter = 0, counter2 = 0; //_________________Переменные счетчиков
int val_filter; //___________________________________________________Переменные для фильтра датчика освещенности
long average;
int valArray[10];
byte idx = 0;

byte scr, index, min_hour = 0; //_________________________________________Служебные переменные
bool flag = 1, flag2 = 0, set_view = 0;

String up_half [12] { //_____________________________________________Верхние половины цифр
  "\260\261", // ноль
  "\264\265", // один
  "\270\271", // два
  "\274\275", // три
  "\300\301", // четыре
  "\304\305", // пять
  "\310\311", // шесть
  "\314\315", // семь
  "\320\321", // восемь
  "\324\325", // девять
  "\330",     // :
};

String down_half [12] { //___________________________________________Нижние половины цифр
  "\262\263", // ноль
  "\266\267", // один
  "\272\273", // два
  "\276\277", // три
  "\302\303", // четыре
  "\306\307", // пять
  "\312\313", // шесть
  "\316\317", // семь
  "\322\323", // восемь
  "\326\327", // девять
  "\331",     // :
  "\333",     // капля
};

/*String days [7] {
  "\202\256\341", // Вос
  "\217\256\255", // Пон
  "\202\342\256", // Вто
  "\221\340\245", // Сре
  "\227\245\342", // Чет
  "\217\357\342", // Пят
  "\221\343\241", // Суб
  };
*/

String days1 [] {
  "\202",
  "\217",
  "\202",
  "\221",
  "\227",
  "\217",
  "\221",
};

String days2 [] {
  "\256",
  "\256",
  "\342",
  "\340",
  "\245",
  "\357",
  "\343",
};

String days3 [] {
  "\341",
  "\255",
  "\256",
  "\245",
  "\342",
  "\342",
  "\241",
};
void setup() {
  delay(3000); //____________тут надо подождать
  pinMode(10, OUTPUT);
  watch.begin();
  bmp.begin(0x76);
  mySerial.begin(9600);
  Serial.begin(9600);
  mySerial.write(0x1B); //
  mySerial.write(0x40); //____инициализация дисплея
  delay(1000); //_____________и тут надо подождать
  CustomFontLoad(); //________загрузка своего шрифта
  delay(2000); //_____________и тут надо подождать
  mySerial.write(0x0b); //____курсор домой
 
  for (byte i; i < 10; i++) { //_Набираем массив значений с датчика освещенности для корректной работы сразу после запуска
    Light (analogRead(20)); //___Датчик света подключен к 20 пину (А6)
  }
}

void loop() {
  butt1.tick();

  if (butt1.isHolded() && butt1.isHold()) { //__Переключение режимов отображения/настройки времени
    set_view = ! set_view;
    mySerial.write(0x0b); //____________________курсор домой
  }
  switch (set_view) {
    case 0:   //________________________________Выводим время и устанавливаем яркость экрана раз в секунду
      min_hour = 0;


      if (millis() - counter >= 500) {
        flag = ! flag;
        show_time ();
        counter += 500;

        if ((Light (analogRead(20)) > THIRD_LEVEL)) {
          set_brightness(4);
        }
        if (((Light (analogRead(20)) <= THIRD_LEVEL)) && ((Light (analogRead(20))) > SECOND_LEVEL) ) {
          set_brightness(3);
        }
        if (((Light (analogRead(20)) <= SECOND_LEVEL)) && ((Light (analogRead(20)) > FIRST_LEVEL) )) {
          set_brightness(2);
        }
        if (Light (analogRead(20)) <= FIRST_LEVEL)  {
          set_brightness(1);
        }
      }
      break;

    case 1: //________________________________Устанавливаем время
      butt2.tick();
      butt3.tick();
      if (butt1.isClick()) {
        min_hour ++;
      }
      if (min_hour > 5) min_hour = 0;
      if (millis() - counter >= 200) {
        counter += 200;
        set_time();
      }
      break;
  }

  if (millis() - counter2 >= 5000) { //_______получаем температуру и влажность раз в 5 секунд
    counter2 += 5000;
    get_temp();
  }
}

void CustomFontLoad() { //_____________________________Создаем свои символы
  mySerial.write(0x1B);
  mySerial.write(0x25);
  mySerial.write(0x01); // Разрешаем кастомные символы

  mySerial.write(0x1B);
  mySerial.write(0x26);
  mySerial.write(0x01); // Начинаем запись кастомных символов
  mySerial.write(0xB0); // Первый адрес диапазона
  //mySerial.write(0xdb); // Последний адрес диапазона
  mySerial.write(0xdd); // Последний адрес диапазона
  //_________________________Создание символов

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1F); // Большой ноль 1
  mySerial.write(0x3F); // \260
  mySerial.write(0X70);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Большой ноль 2
  mySerial.write(0x67); // \261
  mySerial.write(0x76);
  mySerial.write(0x3F);
  mySerial.write(0x1F);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7C); // Большой ноль 3
  mySerial.write(0x7E); // \262
  mySerial.write(0x37);
  mySerial.write(0x73);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Большой ноль 4
  mySerial.write(0x3); // \263
  mySerial.write(0x7);
  mySerial.write(0x7E);
  mySerial.write(0x7C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Единица 1
  mySerial.write((int)0x00); // \264
  mySerial.write((int)0x00);
  mySerial.write(0x18);
  mySerial.write(0x38);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7F); // Единица 2
  mySerial.write(0x7F); // \265
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Единица 3
  mySerial.write((int)0x00); // \266
  mySerial.write((int)0x00);
  mySerial.write(0x3);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7F); // Единица 4
  mySerial.write(0x7F); // \267
  mySerial.write(0X3);
  mySerial.write(0x3);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Двойка 1
  mySerial.write(0x30); // \270
  mySerial.write(0X70);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x60); // Двойка 2
  mySerial.write(0x61); // \271
  mySerial.write(0X73);
  mySerial.write(0x3F);
  mySerial.write(0x1E);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Двойка 3
  mySerial.write(0x7); // \272
  mySerial.write(0XF);
  mySerial.write(0x1F);
  mySerial.write(0x3B);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x73); // Двойка 4
  mySerial.write(0x63); // \273
  mySerial.write(0X43);
  mySerial.write(0x3);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Тройка 1
  mySerial.write(0x60); // \274
  mySerial.write(0X60);
  mySerial.write(0x61);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x67); // Тройка 2
  mySerial.write(0x6E); // \275
  mySerial.write(0X7C);
  mySerial.write(0x78);
  mySerial.write(0x70);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xC); // Тройка 3
  mySerial.write(0xE); // \276
  mySerial.write(0X7);
  mySerial.write(0x43);
  mySerial.write(0x43);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x43); // Тройка 4
  mySerial.write(0x43); // \277
  mySerial.write(0X67);
  mySerial.write(0x7E);
  mySerial.write(0x3C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1); // Четверка 1
  mySerial.write(0x3); // \300
  mySerial.write(0X7);
  mySerial.write(0xE);
  mySerial.write(0x1C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x60); // Четверка 2
  mySerial.write(0x7F); // \301
  mySerial.write(0X7F);
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x70); // Четверка 3
  mySerial.write(0x70); // \302
  mySerial.write(0X30);
  mySerial.write(0x30);
  mySerial.write(0x30);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x30); // Четверка 4
  mySerial.write(0x7F); // \303
  mySerial.write(0X7F);
  mySerial.write(0x30);
  mySerial.write(0x30);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Пятерка 1
  mySerial.write(0x7F); // \304
  mySerial.write(0X7F);
  mySerial.write(0x63);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Пятерка 2
  mySerial.write(0x63); // \305
  mySerial.write(0X63);
  mySerial.write(0x61);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xC); // Пятерка 3
  mySerial.write(0xE); // \306
  mySerial.write(0X7);
  mySerial.write(0x3);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Пятерка 4
  mySerial.write(0x3); // \307
  mySerial.write(0X47);
  mySerial.write(0x7E);
  mySerial.write(0x7C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xF); // Шестерка 1
  mySerial.write(0x1F); // \310
  mySerial.write(0X39);
  mySerial.write(0x73);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Шестерка 2
  mySerial.write(0x63); // \311
  mySerial.write(0X63);
  mySerial.write(0x61);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7C); // Шестерка 3
  mySerial.write(0x7E); // \312
  mySerial.write(0X47);
  mySerial.write(0x43);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Шестерка 4
  mySerial.write(0x3); // \313
  mySerial.write(0X47);
  mySerial.write(0x7E);
  mySerial.write(0x7C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Семерка 1
  mySerial.write(0x60); // \314
  mySerial.write(0X60);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Семерка 2
  mySerial.write(0x67); // \315
  mySerial.write(0X6E);
  mySerial.write(0x7C);
  mySerial.write(0x78);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Семерка 3
  mySerial.write((int)0x00); // \316
  mySerial.write((int)0x00);
  mySerial.write(0x3F);
  mySerial.write(0x7F);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Семерка 4
  mySerial.write((int)0x00); // \317
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);


  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1E); // Восьмерка 1
  mySerial.write(0x3F); // \320
  mySerial.write(0X73);
  mySerial.write(0x61);
  mySerial.write(0x61);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x61); // Восьмерка 2
  mySerial.write(0x61); // \321
  mySerial.write(0X73);
  mySerial.write(0x3F);
  mySerial.write(0x1E);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3C); // Восьмерка 3
  mySerial.write(0x7E); // \322
  mySerial.write(0X67);
  mySerial.write(0x43);
  mySerial.write(0x43);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x43); // Восьмерка 4
  mySerial.write(0x43); // \323
  mySerial.write(0X67);
  mySerial.write(0x7E);
  mySerial.write(0x3C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1F); // Девятка 1
  mySerial.write(0x3F); // \324
  mySerial.write(0X71);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x60); // Девятка 2
  mySerial.write(0x60); // \325
  mySerial.write(0X71);
  mySerial.write(0x3F);
  mySerial.write(0x1F);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Девятка 3
  mySerial.write(0x43); // \326
  mySerial.write(0X63);
  mySerial.write(0x63);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Девятка 4
  mySerial.write(0x67); // \327
  mySerial.write(0X4E);
  mySerial.write(0x7C);
  mySerial.write(0x78);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Двоеточие верх
  mySerial.write(0xE); // \330
  mySerial.write(0XE);
  mySerial.write(0xE);
  mySerial.write((int)0x00); //

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Двоеточие низ
  mySerial.write(0x38); // \331
  mySerial.write(0X38);
  mySerial.write(0x38);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x30); // Значок градуса °
  mySerial.write(0x48); // \332
  mySerial.write(0x48);
  mySerial.write(0x30);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xe); // Значок капелька
  mySerial.write(0x1f); // \333
  mySerial.write(0x7f);
  mySerial.write(0x1f);
  mySerial.write(0xe);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x10); // Значок домик
  mySerial.write(0x3e); // \334
  mySerial.write(0x72);
  mySerial.write(0x3e);
  mySerial.write(0x10);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x04); // Значок стрелка
  mySerial.write(0x06); // \335
  mySerial.write(0x7F);
  mySerial.write(0x06);
  mySerial.write(0x04);
}

void show_time () { //_________________________________Отображение времени
  watch.gettime();
  byte m2;
  m2 = watch.minutes % 10;

  //_____________________________________________________Отрисовка содержимого экрана
  if ((SHIFT) && ((m2 % 2) == 0)) { //_____________________Если изменение порядка отображения на экране активно
    scr = constrain(scr, 1, 8);
    output();
    scr--;

  } else if ((SHIFT) && ((m2 % 2) != 0)) {
    scr = constrain(scr, 1, 8);
    output();
    scr++;

  }  else {
    if ((m2 % 2) == 0) {
      //  scr = constrain(scr, 8, 10);
      scr = 9;
      output();
      //    scr++;

    }  else if ((m2 % 2) != 0) {
      //    scr = constrain(scr, 8, 10);
      scr = 8;
      output();
      //    scr--;
    }
  }
  }



  void output() {
    byte d1, d2, mon1, mon2, wd;
    
    d1 = watch.day / 10;
    d2 = watch.day % 10;
    mon1 = watch.month / 10;
    mon2 = watch.month % 10;
    // days = watch.gettime("D");
    wd = watch.weekday;

    Serial.println(scr);

    switch (scr) {
      case 1:
        mySerial.print(" "); //Дата слева
        mySerial.print(days1 [wd]);
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print(d1); //Дата слева
        mySerial.print(d2);
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        break;

      case 2:
        mySerial.print(days1 [wd]);
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print(" ");
        mySerial.print(d2);
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" ");
        break;

      case 3:
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" \335");
        break;

      case 4:
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" \335");
        mySerial.print(pres_round_c1);
        break;

      case 5:
        mySerial.print("   ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" \335");
        mySerial.print(pres_round_c1);
        mySerial.print(pres_round_c2);
        break;

      case 6:
        mySerial.print("  ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(".");
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" \335");
        mySerial.print(pres_round_c1);
        mySerial.print(pres_round_c2);
        mySerial.print(pres_round_c3);
        break;

      case 7:
        mySerial.print(" ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(".");
        mySerial.print(temp_round_d);
        mySerial.print(" ");
        big_time_down();
        mySerial.print(" \335");
        mySerial.print(pres_round_c1);
        mySerial.print(pres_round_c2);
        mySerial.print(pres_round_c3);
        mySerial.print("H");
        break;

      case 8:
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(".");
        mySerial.print(temp_round_d);
        mySerial.print("\332");
        big_time_down();
        mySerial.print(" \335");
        mySerial.print(pres_round_c1);
        mySerial.print(pres_round_c2);
        mySerial.print(pres_round_c3);
        mySerial.print("Hg");
        break;
      
      case 9:
        big_time_up();
        mySerial.print("   "); //Дата справа
        mySerial.print(days1 [wd]);
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print(" ");
        big_time_down();
        mySerial.print("  ");
        mySerial.print(d1); //Дата справа
        mySerial.print(d2);
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        break;
    }
  }
  void big_time_up() {
    byte h1, h2, m1, m2, s1, s2;
    String dots_up;
    if (flag) { //_______________________________________Мигаем точками
      dots_up = up_half [10];
      dots = ':';
    } else {
      dots_up = " ";
      dots = ' ';
    }
    h1 = watch.Hours / 10;
    h2 = watch.Hours % 10;
    m1 = watch.minutes / 10;
    m2 = watch.minutes % 10;
    s1 = watch.seconds / 10;
    s2 = watch.seconds % 10;

    String h10_up;  //_________________Гашение старшего ноля
    if (h1 == 0) {
      h10_up = "  ";
    } else {
      h10_up = up_half [h1];
    }

    mySerial.print(" ");
    mySerial.print(h10_up); //_______________________Первая строка: верхние половины больших цифр, точек, значение температуры, символ градуса
    mySerial.print(up_half [h2]);
    mySerial.print(dots_up);
    mySerial.print(up_half [m1]);
    mySerial.print(up_half [m2]);
    mySerial.print("   ");  //три пробела
  }

  void big_time_down() {
    byte h1, h2, m1, m2, s1, s2;
    String dots_down;
    if (flag) { //_______________________________________Мигаем точками
      dots_down = down_half [10];
      dots = ' ';
    } else {
      dots_down = " ";
      dots = ' ';
    }
    h1 = watch.Hours / 10;
    h2 = watch.Hours % 10;
    m1 = watch.minutes / 10;
    m2 = watch.minutes % 10;
    s1 = watch.seconds / 10;
    s2 = watch.seconds % 10;

    String h10_down;  //_________________Гашение старшего ноля
    if (h1 == 0) {
      h10_down = "  ";
    } else {
      h10_down = down_half [h1];
    }

    mySerial.print(" ");
    mySerial.print(h10_down);  //_____________________Вторая строка: нижние половины больших цифр, точек, влажность
    mySerial.print(down_half [h2]);
    mySerial.print(dots_down);
    mySerial.print(down_half [m1]);
    mySerial.print(down_half [m2]);
    mySerial.print(dots);
    mySerial.print(watch.seconds / 10);
    mySerial.print(watch.seconds % 10);
  }

  void get_temp() { //___________________________________Получение данных о температуре и влажности и их обработка (округление, разбиение на разряды)
    temp_round = bmp.readTemperature() - COR_TEMP;
    temp_round_c1 = (temp_round / 10);
    temp_round_c2 = (temp_round % 10);
    int d  = (bmp.readTemperature() * 10);
    temp_round_d = (d % 10);

    float p = bmp.readPressure();
    pres_round = (p / 100 / 100 * 75); //________________________________________//перевод Па в мм.рт.ст.
    //Serial.print(bmp.readPressure()); 
   // Serial.print("Press_pound:");
   // Serial.println(pres_round);
    pres_round_c1 = (pres_round / 100); 
    pres_round_c2 = ((pres_round % 100) / 10); 
    pres_round_c3 = (pres_round % 10); 
   
  }

  void set_brightness(byte lev) {//______________________Установка яркости дисплея (1 - 4)
    byte level = lev;
    switch (level) {
      case 1:
        mySerial.write(0x1B); //_________________________Первый уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x01);
        break;
      case 2:
        mySerial.write(0x1B); //_________________________Второй уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x02);
        break;
      case 3:
        mySerial.write(0x1B); //_________________________Третий уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x03);
        break;
      case 4:
        mySerial.write(0x1B); //_________________________Четвертый уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x04);
        break;
    }
  }

  void set_time() { //___________________________________Экран установки времени
    flag = ! flag;
    if (min_hour == 0) {
      //  mySerial.print("   Setting Hours    ");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\227\240\341\256\242   ");
    } else if (min_hour == 1) {
      //  mySerial.print("   Setting Minutes  ");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\214\250\255\343\342   ");
    } else if (min_hour == 2) {
      //  mySerial.print("   Reset Seconds    ");
      mySerial.print("    \221\241\340\256\341\40\221\245\252\343\255\244    ");
    } else if (min_hour == 3) {
      //  mySerial.print("Setting Day of Week ");
      mySerial.print("\223\341\342\240\255\256\242\252\240\40\204\255\357\40\215\245\244\245\253\250");
    } else if (min_hour == 4) {
      //  mySerial.print("Setting Day of Month");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\227\250\341\253\240   ");
    } else if (min_hour == 5) {
      //  mySerial.print("   Setting Month    ");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\214\245\341\357\346\240  ");
    }

    watch.gettime();
    mySerial.print(watch.Hours / 10);
    mySerial.print(watch.Hours % 10);
    mySerial.print(":");
    mySerial.print(watch.minutes / 10);
    mySerial.print(watch.minutes % 10);
    mySerial.print(":");
    mySerial.print(watch.seconds / 10);
    mySerial.print(watch.seconds % 10);
    mySerial.print("  ");
    mySerial.print(watch.gettime("D"));
    mySerial.print(" ");
    mySerial.print(watch.day / 10);
    mySerial.print(watch.day % 10);
    mySerial.print(" ");
    mySerial.print(watch.gettime("M"));

    //__________________________________________Минуты
    if ((min_hour == 1) && butt2.isClick() ) {
      //flag2 = 0;
      int m = (watch.minutes + 1);
      if (m >= 60) m = 0;
      watch.settime(-1, m);
    }
    if ((min_hour == 1) && butt2.isHold() ) {
      int m = (watch.minutes + 5);
      if (m >= 60) m = 0;
      watch.settime(-1, m);
    }
    if ((min_hour == 1) && butt3.isClick()) {
      // flag2 = 0;
      int m = (watch.minutes - 1);
      if (m < 0) m = 59;
      watch.settime(-1, m);
    }
    if ((min_hour == 1) && butt3.isHold()) {
      int m = (watch.minutes - 5);
      if (m < 0) m = 59;
      watch.settime(-1, m);
    }

    //__________________________________________Часы
    if ((min_hour == 0) && butt2.isClick() ) {
      int m = (watch.Hours + 1);
      if (m >= 24) m = 0;
      watch.settime(-1, -1,  m);
    }
    if ((min_hour == 0) && butt2.isHold() ) {
      int m = (watch.Hours + 2);
      if (m >= 24) m = 0;
      watch.settime(-1, -1,  m);
    }
    if ((min_hour == 0) && butt3.isClick() ) {
      int m = (watch.Hours - 1);
      if (m < 0) m = 23;
      watch.settime(-1, -1,  m);
    }
    if ((min_hour == 0) && butt3.isHold() ) {
      int m = (watch.Hours - 2);
      if (m < 0) m = 23;
      watch.settime(-1, -1,  m);
    }
    //__________________________________________Секунды
    if ((min_hour == 2) && butt2.isClick()) {
      watch.settime(0);
    }
    if ((min_hour == 2) && butt3.isClick()) {
      watch.settime(0);
    }
    //__________________________________________День недели
    if ((min_hour == 3) && butt2.isClick()) {
      int m = (watch.weekday + 1);
      if (m > 6) m = 0;
      watch.settime(-1, -1, -1, -1, -1, -1, m);
    }
    if ((min_hour == 3) && butt3.isClick()) {
      int m = (watch.weekday - 1);
      if (m < 0) m = 6;
      watch.settime(-1, -1, -1, -1, -1, -1, m);
    }
    //__________________________________________День месяца
    if ((min_hour == 4) && butt2.isClick()) {
      int m = (watch.day + 1);
      if (m > 31) m = 1;
      watch.settime(-1, -1, -1, m);
    }
    if ((min_hour == 4) && butt3.isClick()) {
      int m = (watch.day - 1);
      if (m < 1) m = 31;
      watch.settime(-1, -1, -1, m);
    }
    //__________________________________________Месяц
    if ((min_hour == 5) && butt2.isClick()) {
      int m = (watch.month + 1);
      if (m > 12) m = 1;
      watch.settime(-1, -1, -1, -1, m);
    }
    if ((min_hour == 5) && butt3.isClick()) {
      int m = (watch.month - 1);
      if (m < 1) m = 12;
      watch.settime(-1, -1, -1, -1, m);
    }
  }

  //__________________________________________Фильтр значений для датчика света (среднее арифметическое из последних 10 значений)

  uint8_t Light(int newVal) { //________________принимает новое значение
    valArray[idx] = newVal;  //_________________пишем каждый раз в новую ячейку
    if (++idx >= 10) idx = 0; //________________перезаписывая самое старое значение
    average = 0;             //_________________обнуляем среднее
    for (int i = 0; i < 10; i++) {
      average += valArray[i]; //________________суммируем
    }
    average /= 10;            //________________делим
    return average;           //________________возвращаем
  }

 

Верх
Сб, 19/02/2022 - 21:13
#409
geniv82
Offline
Зарегистрирован: 21.02.2019 
/*
  Часы с отображением температуры и влажности с индикацией на VFD (ВЛИ) дисплее покупателя 20*2 Futaba (vfd9cb1010 rev 1.2)
  AMatroskin 2020 год.
  devICEpro 2021 год.
*/

#include <GyverButton.h>
#include <SoftwareSerial.h>
#include <Wire.h>
#include <iarduino_RTC.h>
// #include <LiquidCrystal_I2C.h>
#include <Adafruit_BME280.h>
//#include <Adafruit_BMP280.h>
// #include <EEPROM.h>

#define SEALEVELPRESSURE_HPA (1010.7)
#define BTN1 17 //____________________________________________________Пины кнопок
#define BTN2 16
#define BTN3 15

#define COR_TEMP 0     //_____________________________________________Коректирвка температуры (вычитается из показаний датчика)
#define FIRST_LEVEL 8 //_____________________________________________Уровни переключения яркости
#define SECOND_LEVEL 150
#define THIRD_LEVEL  210
#define SHIFT 1  //___________________________________________________Изменение порядка отображения на экране время -> температура/влажность (дата, день недели) и наоборот происходит раз в минуту
//____________________________________________________________________1 -автоматическая перестановка включена, 0 - выключена. (Уменьшение неравномерности износа люминофора)

Adafruit_BME280 bme; //______________________________________________Объекты датчика температуры/влажности, часов RTC, последовательного порта и кнопок
//Adafruit_BMP280 bmp; //______________________________________________Объекты датчика температуры/влажности, часов RTC, последовательного порта и кнопок
iarduino_RTC watch(RTC_DS3231);
SoftwareSerial mySerial(11, 10);
GButton butt1(BTN1);
GButton butt2(BTN2);
GButton butt3(BTN3);

char dots = 0;
int temp_round, temp_round_c1, temp_round_c2, temp_round_d; //_______Переменные для отображения температуры
int hum_round, hum_round_c1, hum_round_c2, hum_round_d;  //__________Переменные для отображения влажности
//int pres_round, pres_round_c1, pres_round_c2, pres_round_c3;  //__________Переменные для отображения давления
uint32_t counter = 0, counter2 = 0; //_________________Переменные счетчиков
int val_filter; //___________________________________________________Переменные для фильтра датчика освещенности
long average;
int valArray[10];
byte idx = 0;

byte scr, index, min_hour = 0; //_________________________________________Служебные переменные
bool flag = 1, flag2 = 0, set_view = 0;

String up_half [12] { //_____________________________________________Верхние половины цифр
  "\260\261", // ноль
  "\264\265", // один
  "\270\271", // два
  "\274\275", // три
  "\300\301", // четыре
  "\304\305", // пять
  "\310\311", // шесть
  "\314\315", // семь
  "\320\321", // восемь
  "\324\325", // девять
  "\330",     // :
};

String down_half [12] { //___________________________________________Нижние половины цифр
  "\262\263", // ноль
  "\266\267", // один
  "\272\273", // два
  "\276\277", // три
  "\302\303", // четыре
  "\306\307", // пять
  "\312\313", // шесть
  "\316\317", // семь
  "\322\323", // восемь
  "\326\327", // девять
  "\331",     // :
  "\333",     // капля
};

/*String days [7] {
  "\202\256\341", // Вос
  "\217\256\255", // Пон
  "\202\342\256", // Вто
  "\221\340\245", // Сре
  "\227\245\342", // Чет
  "\217\357\342", // Пят
  "\221\343\241", // Суб
  };
*/

String days1 [] {
  "\202",
  "\217",
  "\202",
  "\221",
  "\227",
  "\217",
  "\221",
};

String days2 [] {
  "\256",
  "\256",
  "\342",
  "\340",
  "\245",
  "\357",
  "\343",
};

String days3 [] {
  "\341",
  "\255",
  "\256",
  "\245",
  "\342",
  "\342",
  "\241",
};
void setup() {
  delay(3000); //____________тут надо подождать
  pinMode(10, OUTPUT);
  watch.begin();
  bme.begin(0x76);
  mySerial.begin(9600);
  Serial.begin(9600);
//  EEPROM.get(0, font);
//  EEPROM.get(1, SHIFT);
  mySerial.write(0x1B); //
  mySerial.write(0x40); //____инициализация дисплея
  delay(1000); //_____________и тут надо подождать
  CustomFontLoad(); //________загрузка своего шрифта
  delay(2000); //_____________и тут надо подождать
  mySerial.write(0x0b); //____курсор домой
  //  get_temp (); //_____________получаем температуру и влажность
  //  show_time (); //____________выводим информацию на дисплей

  for (byte i; i < 10; i++) { //_Набираем массив значений с датчика освещенности для корректной работы сразу после запуска
    Light (analogRead(20)); //___Датчик света подключен к 20 пину (А6)
  }
}

void loop() {
  butt1.tick();
//  butt2.tick();
//  butt3.tick();

  if (butt1.isHolded() && butt1.isHold()) { //__Переключение режимов отображения/настройки времени
    set_view = ! set_view;
    mySerial.write(0x0b); //____________________курсор домой
  }
  switch (set_view) {
    case 0:   //________________________________Выводим время и устанавливаем яркость экрана раз в секунду
      min_hour = 0;


      if (millis() - counter >= 500) {
        flag = ! flag;
        show_time ();
        counter += 500;

 /*       if (butt2.isHolded() && butt2.isHold()) { //Переключение шрифтов
          font = ! font;
          EEPROM.update(0, font);
        }
        if (butt3.isHolded() && butt3.isHold()) { //Переключение режима сдвига дисплея
          SHIFT = ! SHIFT;
          EEPROM.update(1, SHIFT);
        }
        if ((SHIFT) == 1) {
          digitalWrite(13, HIGH);
        }
        if ((SHIFT) == 0) {
          digitalWrite(13, LOW);
        }
*/
        if ((Light (analogRead(20)) > THIRD_LEVEL)) {
          set_brightness(4);
        }
        if (((Light (analogRead(20)) <= THIRD_LEVEL)) && ((Light (analogRead(20))) > SECOND_LEVEL) ) {
          set_brightness(3);
        }
        if (((Light (analogRead(20)) <= SECOND_LEVEL)) && ((Light (analogRead(20)) > FIRST_LEVEL) )) {
          set_brightness(2);
        }
        if (Light (analogRead(20)) <= FIRST_LEVEL)  {
          set_brightness(1);
        }
      }
      break;

    case 1: //________________________________Устанавливаем время
      butt2.tick();
      butt3.tick();
      if (butt1.isClick()) {
        min_hour ++;
      }
      if (min_hour > 5) min_hour = 0;
      if (millis() - counter >= 200) {
        counter += 200;
        set_time();
      }
      break;
  }

  if (millis() - counter2 >= 5000) { //_______получаем температуру и влажность раз в 5 секунд
    counter2 += 5000;
    get_temp();
  }
}

void CustomFontLoad() { //_____________________________Создаем свои символы
  mySerial.write(0x1B);
  mySerial.write(0x25);
  mySerial.write(0x01); // Разрешаем кастомные символы

  mySerial.write(0x1B);
  mySerial.write(0x26);
  mySerial.write(0x01); // Начинаем запись кастомных символов
  mySerial.write(0xB0); // Первый адрес диапазона
  //mySerial.write(0xdb); // Последний адрес диапазона
  mySerial.write(0xdd); // Последний адрес диапазона
  //_________________________Создание символов

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1F); // Большой ноль 1
  mySerial.write(0x3F); // \260
  mySerial.write(0X70);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Большой ноль 2
  mySerial.write(0x67); // \261
  mySerial.write(0x76);
  mySerial.write(0x3F);
  mySerial.write(0x1F);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7C); // Большой ноль 3
  mySerial.write(0x7E); // \262
  mySerial.write(0x37);
  mySerial.write(0x73);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Большой ноль 4
  mySerial.write(0x3); // \263
  mySerial.write(0x7);
  mySerial.write(0x7E);
  mySerial.write(0x7C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Единица 1
  mySerial.write((int)0x00); // \264
  mySerial.write((int)0x00);
  mySerial.write(0x18);
  mySerial.write(0x38);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7F); // Единица 2
  mySerial.write(0x7F); // \265
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Единица 3
  mySerial.write((int)0x00); // \266
  mySerial.write((int)0x00);
  mySerial.write(0x3);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7F); // Единица 4
  mySerial.write(0x7F); // \267
  mySerial.write(0X3);
  mySerial.write(0x3);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Двойка 1
  mySerial.write(0x30); // \270
  mySerial.write(0X70);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x60); // Двойка 2
  mySerial.write(0x61); // \271
  mySerial.write(0X73);
  mySerial.write(0x3F);
  mySerial.write(0x1E);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Двойка 3
  mySerial.write(0x7); // \272
  mySerial.write(0XF);
  mySerial.write(0x1F);
  mySerial.write(0x3B);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x73); // Двойка 4
  mySerial.write(0x63); // \273
  mySerial.write(0X43);
  mySerial.write(0x3);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Тройка 1
  mySerial.write(0x60); // \274
  mySerial.write(0X60);
  mySerial.write(0x61);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x67); // Тройка 2
  mySerial.write(0x6E); // \275
  mySerial.write(0X7C);
  mySerial.write(0x78);
  mySerial.write(0x70);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xC); // Тройка 3
  mySerial.write(0xE); // \276
  mySerial.write(0X7);
  mySerial.write(0x43);
  mySerial.write(0x43);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x43); // Тройка 4
  mySerial.write(0x43); // \277
  mySerial.write(0X67);
  mySerial.write(0x7E);
  mySerial.write(0x3C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1); // Четверка 1
  mySerial.write(0x3); // \300
  mySerial.write(0X7);
  mySerial.write(0xE);
  mySerial.write(0x1C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x60); // Четверка 2
  mySerial.write(0x7F); // \301
  mySerial.write(0X7F);
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x70); // Четверка 3
  mySerial.write(0x70); // \302
  mySerial.write(0X30);
  mySerial.write(0x30);
  mySerial.write(0x30);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x30); // Четверка 4
  mySerial.write(0x7F); // \303
  mySerial.write(0X7F);
  mySerial.write(0x30);
  mySerial.write(0x30);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Пятерка 1
  mySerial.write(0x7F); // \304
  mySerial.write(0X7F);
  mySerial.write(0x63);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Пятерка 2
  mySerial.write(0x63); // \305
  mySerial.write(0X63);
  mySerial.write(0x61);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xC); // Пятерка 3
  mySerial.write(0xE); // \306
  mySerial.write(0X7);
  mySerial.write(0x3);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Пятерка 4
  mySerial.write(0x3); // \307
  mySerial.write(0X47);
  mySerial.write(0x7E);
  mySerial.write(0x7C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xF); // Шестерка 1
  mySerial.write(0x1F); // \310
  mySerial.write(0X39);
  mySerial.write(0x73);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Шестерка 2
  mySerial.write(0x63); // \311
  mySerial.write(0X63);
  mySerial.write(0x61);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7C); // Шестерка 3
  mySerial.write(0x7E); // \312
  mySerial.write(0X47);
  mySerial.write(0x43);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Шестерка 4
  mySerial.write(0x3); // \313
  mySerial.write(0X47);
  mySerial.write(0x7E);
  mySerial.write(0x7C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Семерка 1
  mySerial.write(0x60); // \314
  mySerial.write(0X60);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Семерка 2
  mySerial.write(0x67); // \315
  mySerial.write(0X6E);
  mySerial.write(0x7C);
  mySerial.write(0x78);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Семерка 3
  mySerial.write((int)0x00); // \316
  mySerial.write((int)0x00);
  mySerial.write(0x3F);
  mySerial.write(0x7F);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Семерка 4
  mySerial.write((int)0x00); // \317
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);


  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1E); // Восьмерка 1
  mySerial.write(0x3F); // \320
  mySerial.write(0X73);
  mySerial.write(0x61);
  mySerial.write(0x61);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x61); // Восьмерка 2
  mySerial.write(0x61); // \321
  mySerial.write(0X73);
  mySerial.write(0x3F);
  mySerial.write(0x1E);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3C); // Восьмерка 3
  mySerial.write(0x7E); // \322
  mySerial.write(0X67);
  mySerial.write(0x43);
  mySerial.write(0x43);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x43); // Восьмерка 4
  mySerial.write(0x43); // \323
  mySerial.write(0X67);
  mySerial.write(0x7E);
  mySerial.write(0x3C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1F); // Девятка 1
  mySerial.write(0x3F); // \324
  mySerial.write(0X71);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x60); // Девятка 2
  mySerial.write(0x60); // \325
  mySerial.write(0X71);
  mySerial.write(0x3F);
  mySerial.write(0x1F);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Девятка 3
  mySerial.write(0x43); // \326
  mySerial.write(0X63);
  mySerial.write(0x63);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Девятка 4
  mySerial.write(0x67); // \327
  mySerial.write(0X4E);
  mySerial.write(0x7C);
  mySerial.write(0x78);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Двоеточие верх
  mySerial.write(0xE); // \330
  mySerial.write(0XE);
  mySerial.write(0xE);
  mySerial.write((int)0x00); //

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Двоеточие низ
  mySerial.write(0x38); // \331
  mySerial.write(0X38);
  mySerial.write(0x38);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x30); // Значок градуса °
  mySerial.write(0x48); // \332
  mySerial.write(0x48);
  mySerial.write(0x30);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xe); // Значок капелька
  mySerial.write(0x1f); // \333
  mySerial.write(0x7f);
  mySerial.write(0x1f);
  mySerial.write(0xe);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x10); // Значок домик
  mySerial.write(0x3e); // \334
  mySerial.write(0x72);
  mySerial.write(0x3e);
  mySerial.write(0x10);
}

void show_time () { //_________________________________Отображение времени
  watch.gettime();
  byte m2;
  m2 = watch.minutes % 10;

  //_____________________________________________________Отрисовка содержимого экрана
  if ((SHIFT) && ((m2 % 2) == 0)) { //_____________________Если изменение порядка отображения на экране активно
    scr = constrain(scr, 1, 8);
    output();
    scr--;

  } else if ((SHIFT) && ((m2 % 2) != 0)) {
    scr = constrain(scr, 1, 8);
    output();
    scr++;

  }  else {
    if ((m2 % 2) == 0) {
      //  scr = constrain(scr, 8, 10);
      scr = 9;
      output();
      //    scr++;

    }  else if ((m2 % 2) != 0) {
      //    scr = constrain(scr, 8, 10);
      scr = 8;
      output();
      //    scr--;
    }
  }
  }



  void output() {
    byte d1, d2, mon1, mon2, wd;
    /*String dots_up, dots_down;
      if (flag) { //_______________________________________Мигаем точками
        dots_up = up_half [10];
        dots_down = down_half [10];
        dots = ':';
      } else {
        dots_up = " ";
        dots_down = " ";
        dots = ' ';
      }
      h1 = watch.Hours / 10;
      h2 = watch.Hours % 10;
      m1 = watch.minutes / 10;
      m2 = watch.minutes % 10;
      s1 = watch.seconds / 10;
      s2 = watch.seconds % 10;
    */
    d1 = watch.day / 10;
    d2 = watch.day % 10;
    mon1 = watch.month / 10;
    mon2 = watch.month % 10;
    // days = watch.gettime("D");
    wd = watch.weekday;

    Serial.println(scr);

    switch (scr) {
      case 1:
        mySerial.print(" "); //Дата слева
        mySerial.print(days1 [wd]);
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print(d1); //Дата слева
        mySerial.print(d2);
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        break;

      case 2:
        mySerial.print(days1 [wd]);
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print(" ");
        mySerial.print(d2);
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" ");
        break;

      case 3:
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print("  ");
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print("  ");
        break;

      case 4:
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" \333");
        mySerial.print(hum_round_c1);
        break;

      case 5:
        mySerial.print("   ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" \333");
        mySerial.print(hum_round_c1);
        mySerial.print(hum_round_c2);
        break;

      case 6:
        mySerial.print("  ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(".");
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" \333");
        mySerial.print(hum_round_c1);
        mySerial.print(hum_round_c2);
        mySerial.print(".");
        break;

      case 7:
        mySerial.print(" ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(".");
        mySerial.print(temp_round_d);
        mySerial.print(" ");
        big_time_down();
        mySerial.print(" \333");
        mySerial.print(hum_round_c1);
        mySerial.print(hum_round_c2);
        mySerial.print(".");
        mySerial.print(hum_round_d);
        break;

      case 8:
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(".");
        mySerial.print(temp_round_d);
        mySerial.print("\332");
        big_time_down();
        mySerial.print(" \333");
        mySerial.print(hum_round_c1);
        mySerial.print(hum_round_c2);
        mySerial.print(".");
        mySerial.print(hum_round_d);
        mySerial.print("%");
        break;
      /*
          case 9:
            big_time_up();
            mySerial.print("  ");
            mySerial.print(d1); //Дата справа
            mySerial.print(d2);
            mySerial.print("/");
            mySerial.print(mon1);
            mySerial.print(mon2);
            big_time_down();
            mySerial.print("  ");
            mySerial.print(temp_round_c1);
            mySerial.print(temp_round_c2);
            mySerial.print(".");
            mySerial.print(temp_round_d);
            mySerial.print("\332");
            break;
      */
      case 9:
        big_time_up();
        mySerial.print("   "); //Дата справа
        mySerial.print(days1 [wd]);
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print(" ");
        big_time_down();
        mySerial.print("  ");
        mySerial.print(d1); //Дата справа
        mySerial.print(d2);
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        break;
    }
  }
  void big_time_up() {
    byte h1, h2, m1, m2, s1, s2;
    String dots_up;
    if (flag) { //_______________________________________Мигаем точками
      dots_up = up_half [10];
      dots = ':';
    } else {
      dots_up = " ";
      dots = ' ';
    }
    h1 = watch.Hours / 10;
    h2 = watch.Hours % 10;
    m1 = watch.minutes / 10;
    m2 = watch.minutes % 10;
    s1 = watch.seconds / 10;
    s2 = watch.seconds % 10;

    String h10_up;  //_________________Гашение старшего ноля
    if (h1 == 0) {
      h10_up = "  ";
    } else {
      h10_up = up_half [h1];
    }

    mySerial.print(" ");
    mySerial.print(h10_up); //_______________________Первая строка: верхние половины больших цифр, точек, значение температуры, символ градуса
    mySerial.print(up_half [h2]);
    mySerial.print(dots_up);
    mySerial.print(up_half [m1]);
    mySerial.print(up_half [m2]);
    mySerial.print("   ");  //три пробела
  }

  void big_time_down() {
    byte h1, h2, m1, m2, s1, s2;
    String dots_down;
    if (flag) { //_______________________________________Мигаем точками
      dots_down = down_half [10];
      dots = ' ';
    } else {
      dots_down = " ";
      dots = ' ';
    }
    h1 = watch.Hours / 10;
    h2 = watch.Hours % 10;
    m1 = watch.minutes / 10;
    m2 = watch.minutes % 10;
    s1 = watch.seconds / 10;
    s2 = watch.seconds % 10;

    String h10_down;  //_________________Гашение старшего ноля
    if (h1 == 0) {
      h10_down = "  ";
    } else {
      h10_down = down_half [h1];
    }

    mySerial.print(" ");
    mySerial.print(h10_down);  //_____________________Вторая строка: нижние половины больших цифр, точек, влажность
    mySerial.print(down_half [h2]);
    mySerial.print(dots_down);
    mySerial.print(down_half [m1]);
    mySerial.print(down_half [m2]);
    mySerial.print(dots);
    mySerial.print(watch.seconds / 10);
    mySerial.print(watch.seconds % 10);
  }

  void get_temp() { //___________________________________Получение данных о температуре и влажности и их обработка (округление, разбиение на разряды)
    temp_round = bme.readTemperature() - COR_TEMP;
    temp_round_c1 = (temp_round / 10);
    temp_round_c2 = (temp_round % 10);
    int d  = (bme.readTemperature() * 10);
    temp_round_d = (d % 10);

    hum_round = bme.readHumidity();
    hum_round_c1 = (hum_round / 10);
    hum_round_c2 = (hum_round % 10);
    int f  = (bme.readHumidity() * 10);
    hum_round_d = (f % 10);

    //pres_round = bmp.readPressure();
    //pres_round_c1 = (hum_round / 10);
    //pres_round_c2 = (hum_round % 10);
    //int f  = (bmp.readPressure() * 10);
    //pres_round_d = (f % 10);
  }

  void set_brightness(byte lev) {//______________________Установка яркости дисплея (1 - 4)
    byte level = lev;
    switch (level) {
      case 1:
        mySerial.write(0x1B); //_________________________Первый уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x01);
        break;
      case 2:
        mySerial.write(0x1B); //_________________________Второй уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x02);
        break;
      case 3:
        mySerial.write(0x1B); //_________________________Третий уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x03);
        break;
      case 4:
        mySerial.write(0x1B); //_________________________Четвертый уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x04);
        break;
    }
  }

  void set_time() { //___________________________________Экран установки времени
    flag = ! flag;
    if (min_hour == 0) {
      //  mySerial.print("   Setting Hours    ");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\227\240\341\256\242   ");
    } else if (min_hour == 1) {
      //  mySerial.print("   Setting Minutes  ");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\214\250\255\343\342   ");
    } else if (min_hour == 2) {
      //  mySerial.print("   Reset Seconds    ");
      mySerial.print("    \221\241\340\256\341\40\221\245\252\343\255\244    ");
    } else if (min_hour == 3) {
      //  mySerial.print("Setting Day of Week ");
      mySerial.print("\223\341\342\240\255\256\242\252\240\40\204\255\357\40\215\245\244\245\253\250");
    } else if (min_hour == 4) {
      //  mySerial.print("Setting Day of Month");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\227\250\341\253\240   ");
    } else if (min_hour == 5) {
      //  mySerial.print("   Setting Month    ");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\214\245\341\357\346\240  ");
    }

    watch.gettime();
    mySerial.print(watch.Hours / 10);
    mySerial.print(watch.Hours % 10);
    mySerial.print(":");
    mySerial.print(watch.minutes / 10);
    mySerial.print(watch.minutes % 10);
    mySerial.print(":");
    mySerial.print(watch.seconds / 10);
    mySerial.print(watch.seconds % 10);
    mySerial.print("  ");
    mySerial.print(watch.gettime("D"));
    mySerial.print(" ");
    mySerial.print(watch.day / 10);
    mySerial.print(watch.day % 10);
    mySerial.print(" ");
    mySerial.print(watch.gettime("M"));

    //__________________________________________Минуты
    if ((min_hour == 1) && butt2.isClick() ) {
      //flag2 = 0;
      int m = (watch.minutes + 1);
      if (m >= 60) m = 0;
      watch.settime(-1, m);
    }
    if ((min_hour == 1) && butt2.isHold() ) {
      int m = (watch.minutes + 5);
      if (m >= 60) m = 0;
      watch.settime(-1, m);
    }
    if ((min_hour == 1) && butt3.isClick()) {
      // flag2 = 0;
      int m = (watch.minutes - 1);
      if (m < 0) m = 59;
      watch.settime(-1, m);
    }
    if ((min_hour == 1) && butt3.isHold()) {
      int m = (watch.minutes - 5);
      if (m < 0) m = 59;
      watch.settime(-1, m);
    }

    //__________________________________________Часы
    if ((min_hour == 0) && butt2.isClick() ) {
      int m = (watch.Hours + 1);
      if (m >= 24) m = 0;
      watch.settime(-1, -1,  m);
    }
    if ((min_hour == 0) && butt2.isHold() ) {
      int m = (watch.Hours + 2);
      if (m >= 24) m = 0;
      watch.settime(-1, -1,  m);
    }
    if ((min_hour == 0) && butt3.isClick() ) {
      int m = (watch.Hours - 1);
      if (m < 0) m = 23;
      watch.settime(-1, -1,  m);
    }
    if ((min_hour == 0) && butt3.isHold() ) {
      int m = (watch.Hours - 2);
      if (m < 0) m = 23;
      watch.settime(-1, -1,  m);
    }
    //__________________________________________Секунды
    if ((min_hour == 2) && butt2.isClick()) {
      watch.settime(0);
    }
    if ((min_hour == 2) && butt3.isClick()) {
      watch.settime(0);
    }
    //__________________________________________День недели
    if ((min_hour == 3) && butt2.isClick()) {
      int m = (watch.weekday + 1);
      if (m > 6) m = 0;
      watch.settime(-1, -1, -1, -1, -1, -1, m);
    }
    if ((min_hour == 3) && butt3.isClick()) {
      int m = (watch.weekday - 1);
      if (m < 0) m = 6;
      watch.settime(-1, -1, -1, -1, -1, -1, m);
    }
    //__________________________________________День месяца
    if ((min_hour == 4) && butt2.isClick()) {
      int m = (watch.day + 1);
      if (m > 31) m = 1;
      watch.settime(-1, -1, -1, m);
    }
    if ((min_hour == 4) && butt3.isClick()) {
      int m = (watch.day - 1);
      if (m < 1) m = 31;
      watch.settime(-1, -1, -1, m);
    }
    //__________________________________________Месяц
    if ((min_hour == 5) && butt2.isClick()) {
      int m = (watch.month + 1);
      if (m > 12) m = 1;
      watch.settime(-1, -1, -1, -1, m);
    }
    if ((min_hour == 5) && butt3.isClick()) {
      int m = (watch.month - 1);
      if (m < 1) m = 12;
      watch.settime(-1, -1, -1, -1, m);
    }
  }

  //__________________________________________Фильтр значений для датчика света (среднее арифметическое из последних 10 значений)

  uint8_t Light(int newVal) { //________________принимает новое значение
    valArray[idx] = newVal;  //_________________пишем каждый раз в новую ячейку
    if (++idx >= 10) idx = 0; //________________перезаписывая самое старое значение
    average = 0;             //_________________обнуляем среднее
    for (int i = 0; i < 10; i++) {
      average += valArray[i]; //________________суммируем
    }
    average /= 10;            //________________делим
    return average;           //________________возвращаем
  }

 

Верх
Сб, 19/02/2022 - 21:25
#410
geniv82
Offline
Зарегистрирован: 21.02.2019

Корпус сделаю - покажу.

Верх
Вс, 20/02/2022 - 16:24
#411
devICEpro
Offline
Зарегистрирован: 11.11.2020

А откуда в BMP280 влажность? Там вроде только давление и температура.

 

Верх
Вс, 20/02/2022 - 18:03
#412
nik182
Offline
Зарегистрирован: 04.05.2015

В коде BME. Там влажность есть.

Верх
Пнд, 21/02/2022 - 23:46
#413
geniv82
Offline
Зарегистрирован: 21.02.2019

Ещё вариант под датчик BMP180. Добавлю: подсоединил Ардуино, которая 3,3 вольта и 8 MHz - не работает, хотя переделал на 5 вольт. Проблема решилась заменой кварца на 16 MHz. Часы работают как часы. Спасибо разработчикам и авторам.

/*BMP180
  Часы с отображением температуры и влажности с индикацией на VFD (ВЛИ) дисплее покупателя 20*2 Futaba (vfd9cb1010 rev 1.2)
  AMatroskin 2020 год.
  devICEpro 2021 год.
*/

#include <GyverButton.h>
#include <SoftwareSerial.h>
#include <Wire.h>
#include <iarduino_RTC.h>
#include <Adafruit_BMP085.h>

#define SEALEVELPRESSURE_HPA (1010.7)
#define BTN1 17 //____________________________________________________Пины кнопок
#define BTN2 16
#define BTN3 15

#define COR_TEMP 0     //_____________________________________________Коректирвка температуры (вычитается из показаний датчика)
#define FIRST_LEVEL 8 //_____________________________________________Уровни переключения яркости
#define SECOND_LEVEL 150
#define THIRD_LEVEL  210
#define SHIFT 1  //___________________________________________________Изменение порядка отображения на экране время -> температура/влажность (дата, день недели) и наоборот происходит раз в минуту
//____________________________________________________________________1 -автоматическая перестановка включена, 0 - выключена. (Уменьшение неравномерности износа люминофора)

Adafruit_BMP085 bmp; //______________________________________________Объекты датчика температуры/влажности, часов RTC, последовательного порта и кнопок
iarduino_RTC watch(RTC_DS3231);
SoftwareSerial mySerial(11, 10);
GButton butt1(BTN1);
GButton butt2(BTN2);
GButton butt3(BTN3);

char dots = 0;
int temp_round, temp_round_c1, temp_round_c2, temp_round_d; //_______Переменные для отображения температуры
int pres_round, pres_round_c1, pres_round_c2, pres_round_c3;  //__________Переменные для отображения давления
uint32_t counter = 0, counter2 = 0; //_________________Переменные счетчиков
int val_filter; //___________________________________________________Переменные для фильтра датчика освещенности
long average;
int valArray[10];
byte idx = 0;

byte scr, index, min_hour = 0; //_________________________________________Служебные переменные
bool flag = 1, flag2 = 0, set_view = 0;

String up_half [12] { //_____________________________________________Верхние половины цифр
  "\260\261", // ноль
  "\264\265", // один
  "\270\271", // два
  "\274\275", // три
  "\300\301", // четыре
  "\304\305", // пять
  "\310\311", // шесть
  "\314\315", // семь
  //"\400\401", // восемь
  "\320\321", // восемь
  "\324\325", // девять
  "\330",     // :
};

String down_half [12] { //___________________________________________Нижние половины цифр
  "\262\263", // ноль
  "\266\267", // один
  "\272\273", // два
  "\276\277", // три
  "\302\303", // четыре
  "\306\307", // пять
  "\312\313", // шесть
  "\316\317", // семь
  "\322\323", // восемь
  "\326\327", // девять
  "\331",     // :
  "\333",     // капля
};

/*String days [7] {
  "\202\256\341", // Вос
  "\217\256\255", // Пон
  "\202\342\256", // Вто
  "\221\340\245", // Сре
  "\227\245\342", // Чет
  "\217\357\342", // Пят
  "\221\343\241", // Суб
  };
*/

String days1 [] {
  "\202",
  "\217",
  "\202",
  "\221",
  "\227",
  "\217",
  "\221",
};

String days2 [] {
  "\256",
  "\256",
  "\342",
  "\340",
  "\245",
  "\357",
  "\343",
};

String days3 [] {
  "\341",
  "\255",
  "\256",
  "\245",
  "\342",
  "\342",
  "\241",
};
void setup() {
  delay(3000); //____________тут надо подождать
  pinMode(10, OUTPUT);
  watch.begin();
  bmp.begin(0x76);
  mySerial.begin(9600);
  Serial.begin(9600);
  mySerial.write(0x1B); //
  mySerial.write(0x40); //____инициализация дисплея
  delay(1000); //_____________и тут надо подождать
  CustomFontLoad(); //________загрузка своего шрифта
  delay(2000); //_____________и тут надо подождать
  mySerial.write(0x0b); //____курсор домой
 
  for (byte i; i < 10; i++) { //_Набираем массив значений с датчика освещенности для корректной работы сразу после запуска
    Light (analogRead(20)); //___Датчик света подключен к 20 пину (А6)
  }
}

void loop() {
  butt1.tick();

  if (butt1.isHolded() && butt1.isHold()) { //__Переключение режимов отображения/настройки времени
    set_view = ! set_view;
    mySerial.write(0x0b); //____________________курсор домой
  }
  switch (set_view) {
    case 0:   //________________________________Выводим время и устанавливаем яркость экрана раз в секунду
      min_hour = 0;


      if (millis() - counter >= 500) {
        flag = ! flag;
        show_time ();
        counter += 500;

        if ((Light (analogRead(20)) > THIRD_LEVEL)) {
          set_brightness(4);
        }
        if (((Light (analogRead(20)) <= THIRD_LEVEL)) && ((Light (analogRead(20))) > SECOND_LEVEL) ) {
          set_brightness(3);
        }
        if (((Light (analogRead(20)) <= SECOND_LEVEL)) && ((Light (analogRead(20)) > FIRST_LEVEL) )) {
          set_brightness(2);
        }
        if (Light (analogRead(20)) <= FIRST_LEVEL)  {
          set_brightness(1);
        }
      }
      break;

    case 1: //________________________________Устанавливаем время
      butt2.tick();
      butt3.tick();
      if (butt1.isClick()) {
        min_hour ++;
      }
      if (min_hour > 5) min_hour = 0;
      if (millis() - counter >= 200) {
        counter += 200;
        set_time();
      }
      break;
  }

  if (millis() - counter2 >= 5000) { //_______получаем температуру и влажность раз в 5 секунд
    counter2 += 5000;
    get_temp();
  }
}

void CustomFontLoad() { //_____________________________Создаем свои символы
  mySerial.write(0x1B);
  mySerial.write(0x25);
  mySerial.write(0x01); // Разрешаем кастомные символы

  mySerial.write(0x1B);
  mySerial.write(0x26);
  mySerial.write(0x01); // Начинаем запись кастомных символов
  mySerial.write(0xB0); // Первый адрес диапазона
  //mySerial.write(0xdb); // Последний адрес диапазона
  mySerial.write(0xdd); // Последний адрес диапазона
  //_________________________Создание символов

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1F); // Большой ноль 1
  mySerial.write(0x3F); // \260
  mySerial.write(0X70);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Большой ноль 2
  mySerial.write(0x67); // \261
  mySerial.write(0x76);
  mySerial.write(0x3F);
  mySerial.write(0x1F);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7C); // Большой ноль 3
  mySerial.write(0x7E); // \262
  mySerial.write(0x37);
  mySerial.write(0x73);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Большой ноль 4
  mySerial.write(0x3); // \263
  mySerial.write(0x7);
  mySerial.write(0x7E);
  mySerial.write(0x7C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Единица 1
  mySerial.write((int)0x00); // \264
  mySerial.write((int)0x00);
  mySerial.write(0x18);
  mySerial.write(0x38);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7F); // Единица 2
  mySerial.write(0x7F); // \265
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Единица 3
  mySerial.write((int)0x00); // \266
  mySerial.write((int)0x00);
  mySerial.write(0x3);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7F); // Единица 4
  mySerial.write(0x7F); // \267
  mySerial.write(0X3);
  mySerial.write(0x3);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Двойка 1
  mySerial.write(0x30); // \270
  mySerial.write(0X70);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x60); // Двойка 2
  mySerial.write(0x61); // \271
  mySerial.write(0X73);
  mySerial.write(0x3F);
  mySerial.write(0x1E);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Двойка 3
  mySerial.write(0x7); // \272
  mySerial.write(0XF);
  mySerial.write(0x1F);
  mySerial.write(0x3B);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x73); // Двойка 4
  mySerial.write(0x63); // \273
  mySerial.write(0X43);
  mySerial.write(0x3);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Тройка 1
  mySerial.write(0x60); // \274
  mySerial.write(0X60);
  mySerial.write(0x61);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x67); // Тройка 2
  mySerial.write(0x6E); // \275
  mySerial.write(0X7C);
  mySerial.write(0x78);
  mySerial.write(0x70);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xC); // Тройка 3
  mySerial.write(0xE); // \276
  mySerial.write(0X7);
  mySerial.write(0x43);
  mySerial.write(0x43);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x43); // Тройка 4
  mySerial.write(0x43); // \277
  mySerial.write(0X67);
  mySerial.write(0x7E);
  mySerial.write(0x3C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1); // Четверка 1
  mySerial.write(0x3); // \300
  mySerial.write(0X7);
  mySerial.write(0xE);
  mySerial.write(0x1C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x60); // Четверка 2
  mySerial.write(0x7F); // \301
  mySerial.write(0X7F);
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x70); // Четверка 3
  mySerial.write(0x70); // \302
  mySerial.write(0X30);
  mySerial.write(0x30);
  mySerial.write(0x30);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x30); // Четверка 4
  mySerial.write(0x7F); // \303
  mySerial.write(0X7F);
  mySerial.write(0x30);
  mySerial.write(0x30);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Пятерка 1
  mySerial.write(0x7F); // \304
  mySerial.write(0X7F);
  mySerial.write(0x63);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Пятерка 2
  mySerial.write(0x63); // \305
  mySerial.write(0X63);
  mySerial.write(0x61);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xC); // Пятерка 3
  mySerial.write(0xE); // \306
  mySerial.write(0X7);
  mySerial.write(0x3);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Пятерка 4
  mySerial.write(0x3); // \307
  mySerial.write(0X47);
  mySerial.write(0x7E);
  mySerial.write(0x7C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xF); // Шестерка 1
  mySerial.write(0x1F); // \310
  mySerial.write(0X39);
  mySerial.write(0x73);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Шестерка 2
  mySerial.write(0x63); // \311
  mySerial.write(0X63);
  mySerial.write(0x61);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x7C); // Шестерка 3
  mySerial.write(0x7E); // \312
  mySerial.write(0X47);
  mySerial.write(0x43);
  mySerial.write(0x3);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3); // Шестерка 4
  mySerial.write(0x3); // \313
  mySerial.write(0X47);
  mySerial.write(0x7E);
  mySerial.write(0x7C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Семерка 1
  mySerial.write(0x60); // \314
  mySerial.write(0X60);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Семерка 2
  mySerial.write(0x67); // \315
  mySerial.write(0X6E);
  mySerial.write(0x7C);
  mySerial.write(0x78);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Семерка 3
  mySerial.write((int)0x00); // \316
  mySerial.write((int)0x00);
  mySerial.write(0x3F);
  mySerial.write(0x7F);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Семерка 4
  mySerial.write((int)0x00); // \317
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);
  mySerial.write((int)0x00);


  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1E); // Восьмерка 1
  mySerial.write(0x3F); // \320
  mySerial.write(0X73);
  mySerial.write(0x61);
  mySerial.write(0x61);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x61); // Восьмерка 2
  mySerial.write(0x61); // \321
  mySerial.write(0X73);
  mySerial.write(0x3F);
  mySerial.write(0x1E);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x3C); // Восьмерка 3
  mySerial.write(0x7E); // \322
  mySerial.write(0X67);
  mySerial.write(0x43);
  mySerial.write(0x43);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x43); // Восьмерка 4
  mySerial.write(0x43); // \323
  mySerial.write(0X67);
  mySerial.write(0x7E);
  mySerial.write(0x3C);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x1F); // Девятка 1
  mySerial.write(0x3F); // \324
  mySerial.write(0X71);
  mySerial.write(0x60);
  mySerial.write(0x60);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x60); // Девятка 2
  mySerial.write(0x60); // \325
  mySerial.write(0X71);
  mySerial.write(0x3F);
  mySerial.write(0x1F);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Девятка 3
  mySerial.write(0x43); // \326
  mySerial.write(0X63);
  mySerial.write(0x63);
  mySerial.write(0x63);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x63); // Девятка 4
  mySerial.write(0x67); // \327
  mySerial.write(0X4E);
  mySerial.write(0x7C);
  mySerial.write(0x78);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Двоеточие верх
  mySerial.write(0xE); // \330
  mySerial.write(0XE);
  mySerial.write(0xE);
  mySerial.write((int)0x00); //

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write((int)0x00); // Двоеточие низ
  mySerial.write(0x38); // \331
  mySerial.write(0X38);
  mySerial.write(0x38);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x30); // Значок градуса °
  mySerial.write(0x48); // \332
  mySerial.write(0x48);
  mySerial.write(0x30);
  mySerial.write((int)0x00);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0xe); // Значок капелька
  mySerial.write(0x1f); // \333
  mySerial.write(0x7f);
  mySerial.write(0x1f);
  mySerial.write(0xe);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x10); // Значок домик
  mySerial.write(0x3e); // \334
  mySerial.write(0x72);
  mySerial.write(0x3e);
  mySerial.write(0x10);

  mySerial.write(0x05); // Размер символа 5 байт
  mySerial.write(0x04); // Значок стрелка
  mySerial.write(0x06); // \335
  mySerial.write(0x7F);
  mySerial.write(0x06);
  mySerial.write(0x04);
}

void show_time () { //_________________________________Отображение времени
  watch.gettime();
  byte m2;
  m2 = watch.minutes % 10;

  //_____________________________________________________Отрисовка содержимого экрана
  if ((SHIFT) && ((m2 % 2) == 0)) { //_____________________Если изменение порядка отображения на экране активно
    scr = constrain(scr, 1, 8);
    output();
    scr--;

  } else if ((SHIFT) && ((m2 % 2) != 0)) {
    scr = constrain(scr, 1, 8);
    output();
    scr++;

  }  else {
    if ((m2 % 2) == 0) {
      //  scr = constrain(scr, 8, 10);
      scr = 9;
      output();
      //    scr++;

    }  else if ((m2 % 2) != 0) {
      //    scr = constrain(scr, 8, 10);
      scr = 8;
      output();
      //    scr--;
    }
  }
  }



  void output() {
    byte d1, d2, mon1, mon2, wd;
    
    d1 = watch.day / 10;
    d2 = watch.day % 10;
    mon1 = watch.month / 10;
    mon2 = watch.month % 10;
    // days = watch.gettime("D");
    wd = watch.weekday;

    Serial.println(scr);

    switch (scr) {
      case 1:
        mySerial.print(" "); //Дата слева
        mySerial.print(days1 [wd]);
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print(d1); //Дата слева
        mySerial.print(d2);
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        break;

      case 2:
        mySerial.print(days1 [wd]);
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print(" ");
        mySerial.print(d2);
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" ");
        break;

      case 3:
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" \335");
        break;

      case 4:
        mySerial.print(days3 [wd]);
        mySerial.print("   ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(mon1);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" \335");
        mySerial.print(pres_round_c1);
        break;

      case 5:
        mySerial.print("   ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(mon2);
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" \335");
        mySerial.print(pres_round_c1);
        mySerial.print(pres_round_c2);
        break;

      case 6:
        mySerial.print("  ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(".");
        mySerial.print("  ");
        big_time_down();
        mySerial.print(" \335");
        mySerial.print(pres_round_c1);
        mySerial.print(pres_round_c2);
        mySerial.print(pres_round_c3);
        break;

      case 7:
        mySerial.print(" ");
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(".");
        mySerial.print(temp_round_d);
        mySerial.print(" ");
        big_time_down();
        mySerial.print(" \335");
        mySerial.print(pres_round_c1);
        mySerial.print(pres_round_c2);
        mySerial.print(pres_round_c3);
        mySerial.print("H");
        break;

      case 8:
        big_time_up();
        mySerial.print(" \334");
        mySerial.print(temp_round_c1);
        mySerial.print(temp_round_c2);
        mySerial.print(".");
        mySerial.print(temp_round_d);
        mySerial.print("\332");
        big_time_down();
        mySerial.print(" \335");
        mySerial.print(pres_round_c1);
        mySerial.print(pres_round_c2);
        mySerial.print(pres_round_c3);
        mySerial.print("Hg");
        break;
      
      case 9:
        big_time_up();
        mySerial.print("   "); //Дата справа
        mySerial.print(days1 [wd]);
        mySerial.print(days2 [wd]);
        mySerial.print(days3 [wd]);
        mySerial.print(" ");
        big_time_down();
        mySerial.print("  ");
        mySerial.print(d1); //Дата справа
        mySerial.print(d2);
        mySerial.print("/");
        mySerial.print(mon1);
        mySerial.print(mon2);
        break;
    }
  }
  void big_time_up() {
    byte h1, h2, m1, m2, s1, s2;
    String dots_up;
    if (flag) { //_______________________________________Мигаем точками
      dots_up = up_half [10];
      dots = ':';
    } else {
      dots_up = " ";
      dots = ' ';
    }
    h1 = watch.Hours / 10;
    h2 = watch.Hours % 10;
    m1 = watch.minutes / 10;
    m2 = watch.minutes % 10;
    s1 = watch.seconds / 10;
    s2 = watch.seconds % 10;

    String h10_up;  //_________________Гашение старшего ноля
    if (h1 == 0) {
      h10_up = "  ";
    } else {
      h10_up = up_half [h1];
    }

    mySerial.print(" ");
    mySerial.print(h10_up); //_______________________Первая строка: верхние половины больших цифр, точек, значение температуры, символ градуса
    mySerial.print(up_half [h2]);
    mySerial.print(dots_up);
    mySerial.print(up_half [m1]);
    mySerial.print(up_half [m2]);
    mySerial.print("   ");  //три пробела
  }

  void big_time_down() {
    byte h1, h2, m1, m2, s1, s2;
    String dots_down;
    if (flag) { //_______________________________________Мигаем точками
      dots_down = down_half [10];
      dots = ' ';
    } else {
      dots_down = " ";
      dots = ' ';
    }
    h1 = watch.Hours / 10;
    h2 = watch.Hours % 10;
    m1 = watch.minutes / 10;
    m2 = watch.minutes % 10;
    s1 = watch.seconds / 10;
    s2 = watch.seconds % 10;

    String h10_down;  //_________________Гашение старшего ноля
    if (h1 == 0) {
      h10_down = "  ";
    } else {
      h10_down = down_half [h1];
    }

    mySerial.print(" ");
    mySerial.print(h10_down);  //_____________________Вторая строка: нижние половины больших цифр, точек, влажность
    mySerial.print(down_half [h2]);
    mySerial.print(dots_down);
    mySerial.print(down_half [m1]);
    mySerial.print(down_half [m2]);
    mySerial.print(dots);
    mySerial.print(watch.seconds / 10);
    mySerial.print(watch.seconds % 10);
  }

  void get_temp() { //___________________________________Получение данных о температуре и влажности и их обработка (округление, разбиение на разряды)
    temp_round = bmp.readTemperature() - COR_TEMP;
    temp_round_c1 = (temp_round / 10);
    temp_round_c2 = (temp_round % 10);
    int d  = (bmp.readTemperature() * 10);
    temp_round_d = (d % 10);

    float p = bmp.readPressure();
    pres_round = (p / 100 / 100 * 75); //________________________________________//перевод Па в мм.рт.ст.
    //Serial.print(bmp.readPressure()); 
   // Serial.print("Press_pound:");
   // Serial.println(pres_round);
    pres_round_c1 = (pres_round / 100); 
    pres_round_c2 = ((pres_round % 100) / 10); 
    pres_round_c3 = (pres_round % 10); 
   
  }

  void set_brightness(byte lev) {//______________________Установка яркости дисплея (1 - 4)
    byte level = lev;
    switch (level) {
      case 1:
        mySerial.write(0x1B); //_________________________Первый уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x01);
        break;
      case 2:
        mySerial.write(0x1B); //_________________________Второй уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x02);
        break;
      case 3:
        mySerial.write(0x1B); //_________________________Третий уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x03);
        break;
      case 4:
        mySerial.write(0x1B); //_________________________Четвертый уровень яркости
        mySerial.write(0x2A);
        mySerial.write(0x04);
        break;
    }
  }

  void set_time() { //___________________________________Экран установки времени
    flag = ! flag;
    if (min_hour == 0) {
      //  mySerial.print("   Setting Hours    ");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\227\240\341\256\242   ");
    } else if (min_hour == 1) {
      //  mySerial.print("   Setting Minutes  ");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\214\250\255\343\342   ");
    } else if (min_hour == 2) {
      //  mySerial.print("   Reset Seconds    ");
      mySerial.print("    \221\241\340\256\341\40\221\245\252\343\255\244    ");
    } else if (min_hour == 3) {
      //  mySerial.print("Setting Day of Week ");
      mySerial.print("\223\341\342\240\255\256\242\252\240\40\204\255\357\40\215\245\244\245\253\250");
    } else if (min_hour == 4) {
      //  mySerial.print("Setting Day of Month");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\227\250\341\253\240   ");
    } else if (min_hour == 5) {
      //  mySerial.print("   Setting Month    ");
      mySerial.print("  \223\341\342\240\255\256\242\252\240\40\214\245\341\357\346\240  ");
    }

    watch.gettime();
    mySerial.print(watch.Hours / 10);
    mySerial.print(watch.Hours % 10);
    mySerial.print(":");
    mySerial.print(watch.minutes / 10);
    mySerial.print(watch.minutes % 10);
    mySerial.print(":");
    mySerial.print(watch.seconds / 10);
    mySerial.print(watch.seconds % 10);
    mySerial.print("  ");
    mySerial.print(watch.gettime("D"));
    mySerial.print(" ");
    mySerial.print(watch.day / 10);
    mySerial.print(watch.day % 10);
    mySerial.print(" ");
    mySerial.print(watch.gettime("M"));

    //__________________________________________Минуты
    if ((min_hour == 1) && butt2.isClick() ) {
      //flag2 = 0;
      int m = (watch.minutes + 1);
      if (m >= 60) m = 0;
      watch.settime(-1, m);
    }
    if ((min_hour == 1) && butt2.isHold() ) {
      int m = (watch.minutes + 5);
      if (m >= 60) m = 0;
      watch.settime(-1, m);
    }
    if ((min_hour == 1) && butt3.isClick()) {
      // flag2 = 0;
      int m = (watch.minutes - 1);
      if (m < 0) m = 59;
      watch.settime(-1, m);
    }
    if ((min_hour == 1) && butt3.isHold()) {
      int m = (watch.minutes - 5);
      if (m < 0) m = 59;
      watch.settime(-1, m);
    }

    //__________________________________________Часы
    if ((min_hour == 0) && butt2.isClick() ) {
      int m = (watch.Hours + 1);
      if (m >= 24) m = 0;
      watch.settime(-1, -1,  m);
    }
    if ((min_hour == 0) && butt2.isHold() ) {
      int m = (watch.Hours + 2);
      if (m >= 24) m = 0;
      watch.settime(-1, -1,  m);
    }
    if ((min_hour == 0) && butt3.isClick() ) {
      int m = (watch.Hours - 1);
      if (m < 0) m = 23;
      watch.settime(-1, -1,  m);
    }
    if ((min_hour == 0) && butt3.isHold() ) {
      int m = (watch.Hours - 2);
      if (m < 0) m = 23;
      watch.settime(-1, -1,  m);
    }
    //__________________________________________Секунды
    if ((min_hour == 2) && butt2.isClick()) {
      watch.settime(0);
    }
    if ((min_hour == 2) && butt3.isClick()) {
      watch.settime(0);
    }
    //__________________________________________День недели
    if ((min_hour == 3) && butt2.isClick()) {
      int m = (watch.weekday + 1);
      if (m > 6) m = 0;
      watch.settime(-1, -1, -1, -1, -1, -1, m);
    }
    if ((min_hour == 3) && butt3.isClick()) {
      int m = (watch.weekday - 1);
      if (m < 0) m = 6;
      watch.settime(-1, -1, -1, -1, -1, -1, m);
    }
    //__________________________________________День месяца
    if ((min_hour == 4) && butt2.isClick()) {
      int m = (watch.day + 1);
      if (m > 31) m = 1;
      watch.settime(-1, -1, -1, m);
    }
    if ((min_hour == 4) && butt3.isClick()) {
      int m = (watch.day - 1);
      if (m < 1) m = 31;
      watch.settime(-1, -1, -1, m);
    }
    //__________________________________________Месяц
    if ((min_hour == 5) && butt2.isClick()) {
      int m = (watch.month + 1);
      if (m > 12) m = 1;
      watch.settime(-1, -1, -1, -1, m);
    }
    if ((min_hour == 5) && butt3.isClick()) {
      int m = (watch.month - 1);
      if (m < 1) m = 12;
      watch.settime(-1, -1, -1, -1, m);
    }
  }

  //__________________________________________Фильтр значений для датчика света (среднее арифметическое из последних 10 значений)

  uint8_t Light(int newVal) { //________________принимает новое значение
    valArray[idx] = newVal;  //_________________пишем каждый раз в новую ячейку
    if (++idx >= 10) idx = 0; //________________перезаписывая самое старое значение
    average = 0;             //_________________обнуляем среднее
    for (int i = 0; i < 10; i++) {
      average += valArray[i]; //________________суммируем
    }
    average /= 10;            //________________делим
    return average;           //________________возвращаем
  }

 

Верх
Пнд, 21/02/2022 - 23:44
#414
geniv82
Offline
Зарегистрирован: 21.02.2019

Вот, что получилось.

Теперь борюсь с пятивольтовым дисплеем, вот таким.

Верх
Втр, 22/02/2022 - 10:19
#415
devICEpro
Offline
Зарегистрирован: 11.11.2020

Борешься с ICD2002F ? Ну ну.... Надоест бороться, посмотри пост #388. Этот дисплей не поддерживает загрузку символов

Верх
Втр, 22/02/2022 - 12:31
#416
geniv82
Offline
Зарегистрирован: 21.02.2019

Естественно, всё прочитал, пытаюсь создать цифры из имеющихся символов (бред, конечно).

Верх
Втр, 22/02/2022 - 21:25
#417
svm
Offline
Зарегистрирован: 06.11.2016

Давно валялся без дела такой дисплей, наконец-то нашлось применение. Решил на старости лет начать "здоровый образ жизни", приобрел самогонный аппарат. Так как живу в частном доме, то возникли проблемы с охлаждением. Насосная станция не обеспечивает постоянство давления, а большой объем утилизируемой воды, чреват частой откачкой сливной ямы. Поэтому была собрана система автономного охлаждения и небольшая автоматика. Она позволяет контролировать температуры на входе и выходе радиатора, а так-же поток охлаждающей жидкости. В дальнейшем, по итогам эксплуатации, скорее всего будут добавлены аварийная сигнализация и управление вентилятором радиатора. Скетч собран из нескольких кусков и явно не оптимален, но работает и достаточно хорошо прокомментирован, его легко модифицировать для своих хотелок. Связь с дисплеем по софт - сериалу. Аппаратный остался для программирования, и выведен в отверстие корпуса.

Картинка:

Небольшое видео можно посмотреть здесь: https://youtu.be/g19EroMPwL8

 

/*
https://arduino-diy.com/arduino-datchik-rashoda-vodi
Формула для расчета расхода воды с ипользованием датчика и Arduino
l_hour = (flow_frequency * 60 / 7.5)
Один обороте крыльчатки соответствует определенному объему жидкости. Количество импульсов,за оборот,
также фиксированно. Поэтому можно установить зависимость между количеством импульсов и расходом воды.
Для YF-S201 на 1 литр протекающей воды датчик Холла выдает 450 импульсов.Т.Е. каждый импульс означает
протекание 1/450 литра воды.
За V_total (1 литр) возьмем  объем жидкости, протекающей через датчик расхода воды за  время t(1 секунда),
а за N общее количество обнаруженных импульсов. 
Тогда мы получим:  V_total(L) = N* 1/450(L)
Кроме того, общий объем жидкости, протекающей через датчик расхода воды, равен расходу воды 
(Q - литр/секунда), умноженному на время t (секунда).
V_total(L) = Q(L/s)*t(s)
В результате  N*1/450 = Q(L/s)*t(s)
N/t = 450 * Q(L/s)
N/t - частота  f = 450*Q(L/s);
Q(L/s) = f/450;
Q(L/min) = f*60/450 = f/7.5
Q(L/hour) = f*60*60/450 = f*60/7.5
Для YF - S402 на каждый литр протекающей воды датчик Холла выдает 4380 импульсов. 
По аналогии:
f = 4380*Q(L/s);
Q(L/s) = f/4380;
Q(L/min) = f*60/4380 = f/73
Q(L/hour) = f*60*60/4380 = f*60 /73
*/

byte RI=0;
int Symbol;
int Radiator_In=255;
int Radiator_Out=200;
unsigned long total=0;
volatile int flow_frequency;          // счетчик для измерения частоты вращения
int l_hour;                           // рассчитанные литр/час
unsigned char flowsensor = 2;         // Вход сенсора
unsigned long currentTime;
unsigned long cloopTime;
unsigned long T_Ind;
String Buffer = "Система автономного      охлаждения     ";
#include <SoftwareSerial.h>
#include <OneWire.h>
SoftwareSerial display =  SoftwareSerial(12, 11);// RX, TX
OneWire  ds(10);                                 // Вход для датчиков DS18B20,подтяжка к питанию 4,7 КОм
byte ND=0;                                       // № датчика

void setup()
{
  pinMode(flowsensor, INPUT);
  digitalWrite(flowsensor, HIGH);
  Serial.begin(9600);
  display.begin(9600);
  delay(500);
  display.print(utf8rus("Система автономного      охлаждения     "));
  delay(2000);Home();
  attachInterrupt(0, impuls, RISING);            //Прерывание по нарастающему фронту на D2

sei(); // активируем прерывания
currentTime = millis();
cloopTime = currentTime;
T_Ind=millis();
for (byte i=0; i<=39;i++)display.write(32);Home();
}
//*******************************************************************************************
void loop() {
  currentTime = millis();

// Каждую секунду рассчитываем  литры в час
if(currentTime >= (cloopTime + 1000))
{
cloopTime = currentTime;                          // Обновление cloopTime
                                                  // Частота импульсов (Гц) = 7.5Q, Q - это расход в л/мин.
l_hour = (flow_frequency * 60 / 7.5);             // (Частота x 60 мин) / 7.5Q = расход в л/час
flow_frequency = 0;                               // Сбрасываем счетчик
}

  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  float celsius;
  
  if ( !ds.search(addr)) {
  if (ND==0)display.print(utf8rus("        Нет датчиков        температуры"));
    ND=0;
  
 //   Serial.println();
    ds.reset_search();
    delay(100);
    return;
  }
  ND+=1;
//if (ND<1) display.print(utf8rus("      Нет датчиков          температуры       "));
  ds.reset();
  ds.select(addr);
  ds.write(0x44,1);                                      // start conversion, with parasite power on at the end
  
  delay(500);    
  present = ds.reset();
  ds.select(addr);    
  ds.write (0xBE);                                       // Read Scratchpad

  for ( i = 0; i < 9; i++) {                             // we need 9 bytes
  data[i] = ds.read();
  }
  // convert the data to actual temperature
  unsigned int raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // count remain gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    if (cfg == 0x00) raw = raw << 3;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw << 2; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw << 1; // 11 bit res, 375 ms
    // default is 12 bit resolution, 750 ms conversion time
  }
  celsius = (float)raw / 16.0;

if (ND==1){Radiator_In=celsius*10;}                     // 1 датчик
if (ND==2){Radiator_Out=celsius*10;}                    // 2 датчик


  if (millis()-T_Ind>10000)        //Время смены экрана
  {
  RI=!RI;T_Ind=millis();          //Смена экрана
  for (byte i=0; i<=39;i++)display.write(32);Home();    // Стирание табло и возврат в первую позицию
  }

              //l_hour+=1; total+=46;                   // Тестовая строка без датчика потока

if (RI==1)
{

display.print(utf8rus("Вх.радиатора  "));
display.print(Radiator_In%1000/10);display.print(".");display.print(Radiator_In%10);display.write(248);
display.print("C"); 
 
display.print(utf8rus("Вых.радиатора "));
display.print(Radiator_Out%1000/10);display.print(".");display.print(Radiator_Out%10);display.write(248);
display.print("C");

}

else { 
display.print(utf8rus("    Расход воды     "));
//display.print (analogRead(SPIRT)/10);

if (l_hour<10)display.print("  ");
if (l_hour>=10 & l_hour<100)display.print(" ");
display.print(l_hour);
display.print(utf8rus(" л/ч Всего "));
display.print(total/450);
display.print(utf8rus(" л"));
}Home();
}







 /* Recode russian fonts from UTF-8 to Windows-1251 */
String utf8rus(String source)
{
  int i,k;
  String target;
  unsigned char n;
  char m[2] = { '0', '\0' };
  k = source.length(); i = 0;

  while (i < k) {
    n = source[i]; i++;

    if (n >= 192) {//  192-207 А----Р
      switch (n) {
        case 208: {
          n = source[i]; i++;
                  
          if (n >= 144 && n <= 191) n = n -16;                   // Большие  А---Я
          break;
        }
        case 209: {
          n = source[i]; i++;
          if (n >= 128 && n <= 143) n = n + 96;                  // малые    р-----я
          break;
        }
      }
    }
    m[0] = n; target = target + String(m);
  }
return target;
}

//                                       Подпрограмма прерывания    
void impuls(){
{flow_frequency++;
total++;}
}


void Home(){
display.write(4);
display.write(1);
display.write(80);
display.write(0x31);   // первая позиция
display.write(23);  
}

 

Верх
Чт, 17/03/2022 - 10:42
#418
geniv82
Offline
Зарегистрирован: 21.02.2019

Вот на такой ардуине запустил дисплей. СтОит дешевле настоящей. Только пришлось выводы на кнопки переназначить. В корпусе TQFP тоже работает - проверил. Так что можно сэкономить.

Верх
Ср, 20/07/2022 - 19:17
#419
Лого
Offline
Зарегистрирован: 20.07.2022

Здравствуйте, можно еще раз ссылку на телеграмм пожалуйста
Старая выдаёт ошибку , что ссылка устарела

Верх
Ср, 20/07/2022 - 21:17
#420
devICEpro
Offline
Зарегистрирован: 11.11.2020

Лого

Что Вы хотите там найти, чего нет на форуме? Или просто так, понаблюдать за развитием событий? В группу принимаются только те, кто от кого есть польза, то есть идеи, предложения и т.д. От Вас будет польза?

Верх
Сб, 30/07/2022 - 01:20
#421
Лого
Offline
Зарегистрирован: 20.07.2022

Хотел попросить скейтч для градусника на этом дисплее

Верх
Сб, 30/07/2022 - 01:21
#422
Лого
Offline
Зарегистрирован: 20.07.2022

Есть одна очень интересная идея

Верх
Пнд, 08/08/2022 - 13:55
#423
kackaqep
Offline
Зарегистрирован: 14.02.2020

Привет Всем! Я слежу за темой достаточно давно, даже есть собственная версия часов на дисплее (см 3 страницу)

Как и хотел - дописал будильник с мелодией на функции ТОН

Но здесь подобралась команда, которая проект развила до необычных высот! Прямое управление колбой! Я не успеваю у китайцев заказывать комплектующие, как выходит что-то новое!

Но, к сожалению, меня выперли из группы. Я понимаю, что пользы в группе от меня не много, мягко говоря=( но хочется последить за темой! Я хотел бы присоединиться к группе. Хотел бы опять попасть в группу. Идея управления 1 -3 кнопками меня очень привлекает, так как её можно использовать с любым корпусом! А такой функционал какой достигнут в группе мне к сожалению и не снился! 

Кто там, в группе главный?

Прошусь к вам в группу!

Постараюсь быть полезным!

Верх
Пнд, 08/08/2022 - 14:14
#424
Amatroskin
Offline
Зарегистрирован: 21.04.2020

kackaqep пишет:

Как и хотел - дописал будильник с мелодией на функции ТОН

Прикольно, ИМХО.  странно тут на форуме нет ЛС, пиши на почту posol.kenii@yandex.ru

Верх
Пнд, 08/08/2022 - 14:35
#425
kackaqep
Offline
Зарегистрирован: 14.02.2020

Принато! =)

Спасиб!

 

Верх
Пнд, 08/08/2022 - 15:09
#426
kackaqep
Offline
Зарегистрирован: 14.02.2020

Если кому то ещё интересна версия часов на интерфейсе RS то вот моя версия!

Управление одной кнопкой, есть будильник, мелодия программируется в прошивке.

Описание управления - в коде.

#include <RTClib.h> 
#include <SoftwareSerial.h>
#include <Wire.h>
#include <EEPROM.h>
//#include <pitches.h>
RTC_DS1307 RTC;  //Назначение таймером мс DS1307
/*   ТЕКСТОВЫЕ ЧАСЫ
 * Версия 3.1   ПО ТЕСТОВОЕ!!!!!!
 *- Поизведена структуризация программы
 *- Введен обработчик кнопки - поддерживает ОДИНОЧНОЕ нажатие, ДВОЙНОЕ и ДЛИТЕЛЬНОЕ 
 *- Проверена работа с размещением текстовых сонстант в ПАМЯТЬ ПРОГРАММ
 *- Реализована коррекция RTC с одной кнопки:
 *        - Из режима отображения (любого) длительным нажатием входим в режим коррекции
 *              на дисплее - дата-время-год и признак какие данные корректируемие текущие (ЧАС-МИН-ДЕНЬ-МЕСЯЦ-ГОД-СЕКУНДЫ - последовательно) 
 *                    УПРАВЛЕНИЕ В РЕЖИМЕ КОРРЕКЦИИ:
 *                    - короткое нажание  -  увеличение значения
 *                    - двойное нажатие  -  уменьшение значения
 *                    - длительное нажатие  - переход к следующим данным
 *                          В режиме СБРОСА СЕКУНД:    
 *                    - короткое нажатие  - секунды в 0 - в RTC записываются откорректированные данные       
 *                    - длительное нажатие  - выход из коррекции без изменения данных
 *- Реализована функция сохранения режима отображения в ЕЕПРОМ                   
 * **** БЛИЖАЙШИЕ ЗАДАЧИ  ******
 * ---  РЕШЕНО!!! <Необходимо научиться управлять дисплеем программно>
 * 
 * Теперь есть установка курсора в начало дисплея при каждом выводе на дисплей!
 * этим устраняется сбвиг при неверном формате выводимых данных
 * -  реализована поддержка КОМАНД FIRICH  **********
 * -- и дисплеев с набором DSP800  ************
 * *** ОБНОВЛЕНИЕ ДО V2.0  ***
 * Введена функция чтения констант из ПЗУ!!!!
 * - чтение производится в буфер
 *          надо предусмотреть прямой вывод из ПЗУ в выбранную переменную 
 *          вида     String ReadPZU(указатель) __  РЕАЛИЗОВАНО!!!!!
 *          
 * 01.02.2020  --        
 *    ВСЕ КОНСТАНТЫ РАЗМЕЩЕНЫ В ПАМЯТИ ПРОГРАММ!!!      
 *        Теперь можно расширять словарный запас часов многократно!!
 *    
 
 * 06.02.2020
 * V 3.xx
 *    ****  ДОБАВЛЯЕМ БУДИЛЬНИК !  ****
 *
 * V 3.0
 * Прописана функция вывода звука
 * Мелодия (в нотах) и темп (в частях такта) и константа длинны мелодии (в нотах)  хранится в массивах в ПЗУ
 * Указатель на нужные массивы передаются в спецПеременные, выставляется флаг Stat_Zumm
 * и всё!!
 * 
 * 
 *  * 28.02.2020
 * V 3.1
 *Завершена.
 *Один будильник 
 *Настройка его как и часов 
 */
 //******   Определения для нот ********
 #define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699

#define NOTE_Pause 10    //Нота - ПАУЗА
//*******************************************
// Массив с мелодиями  В ПАМЯТИ ПРОГРАММ!!!!!!
const int Kuz_Snd[] PROGMEM = {NOTE_A5,NOTE_Pause,NOTE_E5,NOTE_Pause,NOTE_A5,NOTE_Pause,NOTE_E5,NOTE_Pause,NOTE_A5,NOTE_Pause,NOTE_GS5,NOTE_Pause,NOTE_GS5};//Мелодия -- Кузнечик
//const int Kuz_Durat[] PROGMEM = {8,32,8,32,8,32,8,32,8,32,8,32,8};                                //Длительность нот  --  Кузнечик  (В долях такта)
const int Kuz_Durat[] PROGMEM = {2,8,2,8,2,8,2,8,2,8,2,8,2};                                //Длительность нот  --  Кузнечик  (В долях такта)
const uint16_t Kuz_Lgn PROGMEM = 13;                                        //длинна фрагмента (передаётся с массивом

const int KuKu_Snd[] PROGMEM = {NOTE_A5,NOTE_Pause,NOTE_FS5,NOTE_Pause};        //Звук  --  Ку-Ку 
const int KuKu_Durat[] PROGMEM = {4,8,4,1};                                //Длительность нот  -- Ку-Ку (В долях такта)
const uint16_t KuKu_Lgn PROGMEM = 4;                                        //длинна фрагмента (передаётся с массивом


const uint16_t Sign_KuKu[2][4] PROGMEM = {{NOTE_A5,NOTE_Pause,NOTE_FS5,NOTE_Pause},   //Вариант сдвухмерным массивом описания сигналов/мелодий
                                    {2,8,2,2}
                                    };
//********  УКАЗАТЕЛИ НА СТРОКИ ВЫВОДА ЗВУКА ******************
int *Buf_Melody = 0;     //Указатель на массив с нотами мелодии
int *Buf_Durat = 0;      //Указатель на массив длительностей нот
int BufSt_Note = 0;      //буфер с количеством нот в мелодии

// Массив со словами В ПАМЯТИ ПРОГРАММ!!!!!!

//****************  МАССИВЫ ЧИСЛИТЕЛЬНЫХ В ПЗУ  *****************************
const char Nol[] PROGMEM = {"\215\216\213\234"};                    // ноль - 0
const char Odna[] PROGMEM = {"\216\204\215\200"};                   //одна - 1
const char Dve[] PROGMEM = {"\204\202\205"};                                      //две - 2
const char _3[] PROGMEM = {"\222\220\210"};                                       //три - 3
const char _4[] PROGMEM = {"\227\205\222\233\220\205"};                           //четыре - 4
const char _5[] PROGMEM = {"\217\237\222\234"};                                   //пять - 5
const char _6[] PROGMEM = {"\230\205\221\222\234"};                               //шесть - 6
const char _7[] PROGMEM = {"\221\205\214\234"};                                   //семь - 7
const char _8[] PROGMEM = {"\202\216\221\205\214\234"};                           //восемь - 8
const char _9[] PROGMEM = {"\204\205\202\237\222\234"};                           //девять - 9
const char _10[] PROGMEM = {"\204\205\221\237\222\234"};                          // десять - 10
const char _11[] PROGMEM = {"\216\204\210\215\215\200\204\226\200\222\234"};      //одиннадцать - 11
const char _12[] PROGMEM = {"\204\202\205\215\200\204\226\200\222\234"};          // двенадцать - 12
const char _13[] PROGMEM = {"\222\220\210\215\200\204\226\200\222\234"};          //тринадцать - 13
const char _14[] PROGMEM = {"\227\205\222\233\220\215\200\204\226\200\222\234"};  //четырнадцать - 14
const char _15[] PROGMEM = {"\217\237\222\215\200\204\226\200\222\234"};          // пятнадцать - 15
const char _16[] PROGMEM = {"\230\205\221\222\215\200\204\226\200\222\234"};      //шестнадцать - 16
const char _17[] PROGMEM = {"\221\205\214\215\200\204\226\200\222\234"};          // семнадцать - 17
const char _18[] PROGMEM = {"\202\216\221\205\214\215\200\204\226\200\222\234"};  //восемнадцать - 18
const char _19[] PROGMEM = {"\204\205\202\237\222\215\200\204\226\200\222\234"};  //девятнадцать - 19
const char _20[] PROGMEM = {"\204\202\200\204\226\200\222\234"};                  // двадцать - 20
const char _30[] PROGMEM = {"\222\220\210\204\226\200\222\234"};                  // тридцать - 21
const char _40[] PROGMEM = {"\221\216\220\216\212"};                              //сорок - 22
const char _50[] PROGMEM = {"\217\237\222\234\204\205\221\237\222"};              //пятьдесят - 23
const char Odin[] PROGMEM = {"\216\204\210\215"};                     // один - 24
const char Dva[] PROGMEM = {"\204\202\200"};                           // два - 25
//****************  МАССИВЫ НАИМЕНОВАНИЙ ЧАСТЕЙ ВРЕМЕНИ В ПЗУ  ************** 
const char Chasov[] PROGMEM = {"\227\200\221\216\202"};     // часов - 26
const char Chas[] PROGMEM = {"\227\200\221"};               // час - 27
const char Chasa[] PROGMEM = {"\227\200\221\200"};          // часа - 28

const char Minut[] PROGMEM = {"\214\210\215\223\222"};      // минут - 29
const char Minuta[] PROGMEM = {"\214\210\215\223\222\200"}; // минута - 30
const char Minuty[] PROGMEM = {"\214\210\215\223\222\233"}; // минуты - 31
const char Min[] PROGMEM = {"\214\210\215"};                // мин - 32      */
//*************************** МАССИВЫ КАЛЕНДАРЯ В ПЗУ  ****************
const char Janvar[] PROGMEM = {"\237\255\242\240\340\357"};           // января - 40
const char Fevral[] PROGMEM = {"\224\245\242\340\240\253\357"};       // февраля - 41
const char Mart[] PROGMEM = {"\214\240\340\342\240"};                 // марта - 42
const char Aprel[] PROGMEM = {"\200\257\340\245\253\357"};            // апреля - 43
const char Maj[] PROGMEM = {"\214\240\357"};                          // мая - 44
const char Ijun[] PROGMEM = {"\210\356\255\357"};                     // июня - 45
const char Ijul[] PROGMEM = {"\210\356\253\357"};                     // июля - 46
const char Avgust[] PROGMEM = {"\200\242\243\343\341\342\240"};       // августа - 47
const char Sentjabr[] PROGMEM = {"\221\245\255\342\357\241\340\357"}; // сентября - 48
const char Oktjabr[] PROGMEM = {"\216\252\342\357\241\340\357"};      // октября - 49
const char Nojabr[] PROGMEM = {"\215\256\357\241\340\357"};           // ноября - 50
const char Dekabr[] PROGMEM = {"\204\245\252\240\241\340\357"};       // декабря - 51
const char God[] PROGMEM = {"\203\256\244"};                          //Год - 52
const char Korr[] PROGMEM = {"\212\256\340\340"};                     //Корр - 53
const char Day[] PROGMEM = {"\204\245\255\354"};                      //День - 54
const char Mes[] PROGMEM = {"\214\245\341"};                          //Мес - 55
//*************************** МАССИВЫ ДНЕЙ НЕДЕЛИ В ПЗУ  ****************
const char Poned[] PROGMEM = {"\217\256\255\245\244\245\253\354\255\250\252"};  // понедельник
const char Vtor[] PROGMEM = {"\202\342\256\340\255\250\252"};                   // вторник
const char Sred[] PROGMEM = {"\221\340\245\244\240"};                           // среда;
const char Chetv[] PROGMEM = {"\227\245\342\242\245\340\243"};                  // четверг
const char Pjatn[] PROGMEM = {"\217\357\342\255\250\346\240"};                  //пятница
const char Subb[] PROGMEM = {"\221\343\241\241\256\342\240"};                  // суббота
const char Vskrs[] PROGMEM = {"\202\256\341\252\340\245\341\245\255\250\245"};  // воскресенье

//const char* const DenNedeli[] PROGMEM = { Poned, Vtor, Sred, Chetv, Pjatn, Subb, Vskrs,};   //  ТАБЛИЦА ССЫЛОК НА ДНИ НЕДЕЛИ  

 const char Alarm[] PROGMEM = {"\201\343\244\250\253\354\255\250\252"} ;    //Будильник
  const char _On[] PROGMEM = {"\202\252\253\356\347\245\255"} ;    //Включен
 const char _Off[] PROGMEM = {"\216\342\252\253\356\347\245\255"} ;    //Отключен
  const char _Set[] PROGMEM = {"\223\341\342\240\255\256\242\252\240"} ;    //Установка
//********************* ******  ВСЯКАЯ ХРЕНЬ В ПЗУ  *****************
const char Zakrug[] PROGMEM = {"\40\40\40\207\240\252\340\343\243\253\357\251\341\357\40\41\40\41"};    //   Закругляйся ! !

const char Pol[] PROGMEM = {"\217\216\213"};    //ПОЛ
const char Shestoy[] PROGMEM = {"\230\245\341\342\256\251\40\347\240\341\41\40\40\40\223\340\240\41\41"};    //Шестой час!   Ура!!
const char Ostalos[] PROGMEM = {"\216\221\222\200\213\216\221\234"};    //ОСТАЛОСЬ 

//**********************************  Новые переменные для нового управления  ********************************************


void OutText();         //Объявление Функции вывода текстом
void OutFullInfo();     //Объявление функции вывода полной информации + режим коррекции
void ReadRTC();         //Чтение RTC в переменные
void ReadButton();      //Работа с кнопкой
void Setup_Reg();       // Управление Режимами работы
void KorrRTC();         //Коррекция времени РУЧКАМИ!!!!
void playMelody();      //Проигрывание мелодии для Будильника и часового боя
                        //Коррекция данных  в указанном диапазоне:
int Korr_Data(int Data, int Begin, int Range);    //параметры: (корректируемые Данные, нминимальное Значение, максимальное Значение) 

void Alarm_Out();           //Проверка условий будильника
void Alarm_ReadEE();        //
void Alarm_WriteEE();


//  *** ПРОБА  РАЗМЕЩЕНИЯ ТЕКСТОВЫХ КОНСТАНТ В ПЗУ *********************** 
String ReadPZU(int *AdrPZU);         //Чтение константы из ПЗУ в буфер
//char BufPZU[20];        //Буфер ПЗУ на 20 символов


//******** Константы для каботы опроса кнопок  **********************
  #define Delay_Long 100      //Количество 5-ти миллисекундных циклов нажатой кнопки для определения длительного нажатия
  #define Delay_Short 3        //Количество 5-ти миллисекундных циклов нажатой кнопки для определения минимума короткого  нажатия
  #define Delay_Pause 25      //Количество 5-ти миллисекундных циклов отпущенной кнопки для определения двойного нажатия нажатия
  #define Delay_Dzzz 2        //Количество 5-ти миллисекундных циклов отпущенной кнопки для определения дребезга нажатия
//*******************************************************************    
      
byte StPressBut = 0;         //Счетчик периода нажатия кнопки
byte StDisplay  = 0;          //Счетчик периодов пропуска вывода на дисплей
byte StZicl = 0;              //Счетчик циклов основного прогона
byte StPauseBut = 0;          //Счётчик циклов ненажатой кнопки

byte BitReg1 = 0;    //Первый битовый регистр РЕГИСТР РЕЖИМОВ 
          //Назначение ФЛАГОВ в первом битовом регистре
      #define ZumOff_Alarm 0      //сигнал будильника сейчас уже звучал и отключен
      #define Stat_Text 1         //Признак вывода текстом
      #define Stat_Display 2      //Признак вывода данных на дисплей
      #define Stat_Korr 3         //Признак режима коррекции
      #define Stat_Alarm 4        //Признак отображения будильника
      #define Set_Alarm 5         //Признак включеного будильника
      #define Zum_Alarm 6         //Включен сигнал будильника

      

      #define Stat_Zumm 7         //Признак вывдоа звука     

byte BitReg2 = 0;    //Второй битовый регистр  РЕГИСТР РЕЖИМОВ КОРРЕКЦИИ
          //Назначение ФЛАГОВ во втором битовом регистре

      #define Korr_Sec 0          //Режим коррекции СЕКУНД    
      #define Korr_Chas 1         //Режим коррекции ЧАС
      #define Korr_Min 2          //Режим коррекции МИН
      #define Korr_God 3          //Режим коррекции ГОД
      #define Korr_Mes 4          //Режим коррекции МЕСЯЦ
      #define Korr_Day 5          //Режим коррекции ДЕНЬ
      #define Korr_Alarm 6        //Режим коррекции БУДИЛЬНИКА
     // #define Korr_DNed 7         //Режим коррекции ДНЯ НЕДЕЛИ для будильника         

byte BitReg3 = 0;    //Третий битовый регистр РЕГИСТР СТАТУСОВ КНОПКИ
          //Назначение ФЛАГОВ в третьем битовом регистре
      #define Press_Long 0        //Признак длительного нажатия кнопки
      #define Press_Short 1       //  --    короткого   --   --
      #define Press_Duble 2       //  --    двойного    --   --
      #define Press_Pause 3       //Пауза между короткими нажатиями
      #define Press_One 4         //Кнопка нажата один раз
      


      #define EE_Text 500      //Адрес в ЕЕПРОМ режима вывода информации
      #define EE_Alarm (EE_Text + 2)    //Начальный адрес хранения установки будильника
        
uint32_t Delay_Btn,           //счётчик цикла задержки опроса кнопки
         Delay_Out;           //счётчик задержки вывода на дисплей
int      Delay_Display;       //хранение текущего значения задержки вывода на дисплей (мс)
  #define Delay_Text 500      //Время задержки вывода на дисплей ТЕКСТа
  #define Delay_Info 100      //Время задержки вывода на дисплей ПОЛНОЙ ИНФО

int Proba = NOTE_A2;


//**********************************  Конец переменных для нового управления  ********************************************

SoftwareSerial mySerial(11, 10); // RX, TX

#define buttonPin  2 // на второй вывод повесил кнопку выбора варианта отображения времени

//*************  ТЕСТОВЫЕ ВЫХОДЫ    ********************************
#define LED_Text  5 // Светодиод режима ТЕКСТ
#define LED_Long  6 // Светодиод длительного нажатия
#define LED_Duble  7 // Светодиод двойного нажатия

//********  ВЫХОД ДЛЯ ЗВУКА  ************

#define Pin_Tone  8 // звуковой выход

        int BufDurat = 10;       //буфер для вычисления значения текущей задержки
        int BufTone;        //буфер для  значения тона     
    //    int BufDurat0;       //буфер для вычисления значения текущей задержки
int StNote;               //счетчик воиспроизводимых нот  для цикла FOR
uint32_t StDurat = 0;     //Счётчик длительности ноты

//******************************************************************

//*******  БУДИЛЬНИК  *************************
 byte Alarm_Chas = 0;
 byte Alarm_Minuty = 0;

String BufData;     //Переменная для отладки

int yar, mesyac, denec, chas, minuta, sekunda,Weekday; // для коррентировки
int korrektwrem;   // коррекция ошибки часов реального времени
void setup()  
{
  // Инициализируем последовательный интерфейс и ждем открытия порта:
  Serial.begin(9600);
  while (!Serial) 
  {
    ; // ожидаем подключения к последовательному порту. Необходимо только для Leonardo  
  }
  
  //Serial.println("Goodnight moon!");
    mySerial.begin(9600);

{
Serial.begin(57600);
Wire.begin();        //Подготовка 
RTC.begin();          //Подготовка часов реального времени
//RTC.adjust(DateTime(2019, 11, 7, 16, 12, 0));  // задаём год/ месяц/ дата/ часы/ минуты/ секунды
}
{//**********************  Чтение предустановок из ЕЕПРОМ ************************
          //Режим отображения часов ****
  if (EEPROM.read(EE_Text)> 0) bitSet(BitReg1,Stat_Text);  //Если до выключения питания был режим ТЕКСТ 
                    else bitClear(BitReg1,Stat_Text);       //Если режим  ИНФО
                    
          // Значения установок будильника ***
          // 1 байт - час: 1 байт - минуты: 1 байт - режимы = вкл., мелодия и тд
          
       //*  После отладки - вернуть!!
           Alarm_Chas = EEPROM.read(EE_Alarm);             //Чтение из ЕЕПРОМ значения ЧАСА Будильника
              if (Alarm_Chas > 23) Alarm_Chas = 0;      //Если значение вне диапазона - по умолчанию
          Alarm_Minuty = EEPROM.read(EE_Alarm + 1);       //Чтение из ЕЕПРОМ значения МИНУТ Будильника
              if (Alarm_Minuty > 59) Alarm_Minuty = 16; //Если значение вне диапазона - по умолчанию //*/
/*/******* Отладка *****
       Alarm_Chas = 14;             //Чтение из ЕЕПРОМ значения ЧАСА Будильника
              if (Alarm_Chas > 23) Alarm_Chas = 0;      //Если значение вне диапазона - по умолчанию
          Alarm_Minuty = 15;       //Чтение из ЕЕПРОМ значения МИНУТ Будильника
              if (Alarm_Minuty > 59) Alarm_Minuty = 16; //Если значение вне диапазона - по умолчанию */
//*******  Конец отладки ****              
       
              if ((EEPROM.read(EE_Alarm + 2) && 1) == 0 ) bitClear(BitReg1,Set_Alarm);     //Если будильник выключен
                        else bitSet(BitReg1,Set_Alarm);                                    //или если включен
//***********  конец чтения предустановок будильника  **********************                                     
}


{
  pinMode(buttonPin, INPUT_PULLUP);  // Это кнопка 
  
  pinMode(LED_Long, OUTPUT);  //  Тестовый светодиод 1
  pinMode(LED_Text, OUTPUT);  //   Тестовый светодиод 2
  pinMode(LED_Duble, OUTPUT);  //  Тестовый светодиод 3
  digitalWrite(LED_Long, HIGH);
  digitalWrite(LED_Text, HIGH);
  digitalWrite(LED_Duble, HIGH);   //ПРЕДУСТАНОВКИ

  //********** ДЛЯ ЗВУКА  *********
    pinMode(Pin_Tone, OUTPUT);  //  пин на вывод звука

}
//**  З А Р Е М И Р О В А Н О   Д Л Я  P R O T E U S !!!!**
delay(2000);      // Задержка на прогрузку дисплея
  // mySerial.print("\f");           //Очистка дисплея
  //*************   ВЫВОД ЛОГОТИПА НА ДИСПЛЕЙ  ***************************************
             mySerial.print("\4\1\120\61\27");    //Для VFD DSP850  (КОМАНД FIRICH) Установка курсора в начало дисплея  (домой)
          // mySerial.print("\13");               //Для VFD-2300  (ESC-кодовая система) Установка курсора в начало дисплея  (домой)
                                    //Печать стартовой информации
              mySerial.println("\222\245\252\341\342\256\242\353\245\40\347\240\341\353\40\126\63\56\61\341");  //Текстовые часы V3.1с
              mySerial.print("\40\40\40\200\221\210\221\50\341\51\40\40\62\60\62\60\40\40\40\40");          //  АСИС(с) 2020 прикол 
            // Serial.print("\200\221\210\221\50\341\51\40\62\60\62\60\40\257\340\250\252\256\253\40");          //  АСИС(с) 2020 прикол              
//**  З А Р Е М И Р О В А Н О   Д Л Я  P R O T E U S !!!!**
delay(4000);      // Показ логотипа ************************************
}
 void loop() // run over and over
{
  //if (mySerial.available())
  //  Serial.write(mySerial.read());
  //if (Serial.available())
  //  mySerial.write(Serial.read());


    //*****************  Новый БЛОК работы с дисплеем и не только..  *************************

        ReadButton();                   //Проверка кнопки

         Setup_Reg();                   // Управление Режимами работы

         playMelody();                  //Проигрывание мелодии для Будильника и часового боя

       Out_Display();                   //Вывод на ДИСПЛЕЙ 
                            
         Alarm_Out();                       //Проверка условий будильника
         
          KorrRTC();                    //КОРРЕКЦИЯ!!


  

    //****************************************************************************************



}           // ********* КОНЕЦ БЛОКА LOOP  ************************

//**************************   Вывод на дисплей  **************
 void Out_Display(){
               if (bitRead(BitReg1,Stat_Zumm) == 0)                     //Если не выводится звук
                {                      
                  if ((bitRead(BitReg1,Stat_Text) > 0)&&(bitRead(BitReg1,Stat_Alarm) == 0)) Delay_Display = Delay_Text;                //Определение длительности задержки 
                        else Delay_Display = Delay_Info;                                         //обновления информации в зависимости от формы подачи ТЕКСТ/ИНФО 

             if (millis()-Delay_Out > Delay_Display)                  // Если прошло x00мс - выводим данные
                      {Delay_Out = millis();            //перезапуск цикла опроса
                      if (bitRead(BitReg1,Stat_Korr) == 0 )   ReadRTC();                  //Считать RTC в буфер если не режим коррекции
                        
                                       if ((bitRead(BitReg1,Stat_Text) > 0)&&(bitRead(BitReg1,Stat_Korr) == 0)&&(bitRead(BitReg1,Stat_Alarm) == 0)) //Вывод по признаку 
                                                OutText();                                //ТЕКСТ
                                       else                                               //или
                                         OutFullInfo();                                   // вся информация      ************
                          
        }
              }
 }
//************************************************************

//*************  Вывод ТЕКСТОМ **********************************

void OutText()  {          //ВЫВОД ТЕКСТОМ
  
String stringOne, stringTwo, stringThree, stringHour,  stringMin, stringFour, stringFive, stringSix;
        if ((sekunda % 10) < 5)
                   mySerial.print("\04\40");  
                   else  mySerial.print("\04\255");  
  /*    if (chas == 17) //Здесь вырезан прикол
      {
          byte ostatok = (60 - minuta);
           if (ostatok < 10) stringTwo = ' ';
              stringTwo = stringTwo + ostatok;
          stringHour =  ReadPZU(Shestoy) + "  "; //stringThree =  ReadPZU(Chasov); stringHour = "  " + stringOne + " " + stringThree + "  ";break;
           stringOne =  ReadPZU(Ostalos); stringThree =  ReadPZU(Min);
           stringMin = stringOne + ": " + stringTwo + " " + stringThree + "!  ";
         
      }
         else   */
    {           
      switch (chas) {   //собираем первую строку

       case 0:  stringOne =  ReadPZU(Nol); stringThree =  ReadPZU(Chasov); stringHour = "     " + stringOne + " " + stringThree + "     "; break;
       case 1:  stringOne =  ReadPZU(Odin); stringThree =  ReadPZU(Chas); stringHour = "      " + stringOne + " " + stringThree + "      ";break;
       case 2:  stringOne =  ReadPZU(Dva); stringThree =  ReadPZU(Chasa); stringHour = "      " + stringOne + " " + stringThree + "      ";break;
       case 3:  stringOne =  ReadPZU(_3); stringThree =  ReadPZU(Chasa); stringHour = "      " + stringOne + " " + stringThree + "      ";break;
       case 4:  stringOne =  ReadPZU(_4); stringThree =  ReadPZU(Chasa); stringHour = "    " + stringOne + " " + stringThree + "     ";break;
       case 5:  stringOne =  ReadPZU(_5); stringThree =  ReadPZU(Chasov); stringHour = "     " + stringOne + " " + stringThree + "     ";break;
       case 6:  stringOne =  ReadPZU(_6); stringThree =  ReadPZU(Chasov); stringHour = "    " + stringOne + " " + stringThree + "     ";break;
       case 7:  stringOne =  ReadPZU(_7); stringThree =  ReadPZU(Chasov); stringHour = "     " + stringOne + " " + stringThree + "     ";break;
       case 8:  stringOne =  ReadPZU(_8); stringThree =  ReadPZU(Chasov); stringHour = "    " + stringOne + " " + stringThree + "    ";break;
       case 9:  stringOne =  ReadPZU(_9); stringThree =  ReadPZU(Chasov); stringHour = "    " + stringOne + " " + stringThree + "    ";break;
       case 10:  stringOne =  ReadPZU(_10); stringThree =  ReadPZU(Chasov); stringHour = "    " + stringOne + " " + stringThree + "    ";break;    //Скорректирована длина 
       case 11:  stringOne =  ReadPZU(_11); stringThree =  ReadPZU(Chasov); stringHour = " " + stringOne + " " + stringThree + "  ";break;      
       case 12:  stringOne =  ReadPZU(_12); stringThree =  ReadPZU(Chasov); stringHour = "  " + stringOne + " " + stringThree + "  ";break; 
       case 13:  stringOne =  ReadPZU(_13); stringThree =  ReadPZU(Chasov); stringHour = "  " + stringOne + " " + stringThree + "  ";break;
       case 14:  stringOne =  ReadPZU(_14); stringThree =  ReadPZU(Chasov); stringHour = " " + stringOne + " " + stringThree + " ";break;
       case 15:  stringOne =  ReadPZU(_15); stringThree =  ReadPZU(Chasov); stringHour = "  " + stringOne + " " + stringThree + "  ";break;              //  ReadPZU(_15)
       case 16:  stringOne =  ReadPZU(_16); stringThree =  ReadPZU(Chasov); stringHour = " " + stringOne + " " + stringThree + "  ";break;
       case 17:  stringOne =  ReadPZU(_17); stringThree =  ReadPZU(Chasov); stringHour = "  " + stringOne + " " + stringThree + "  ";break;
       
       case 18:  stringOne =  ReadPZU(_18); stringThree =  ReadPZU(Chasov); stringHour = " " + stringOne + " " + stringThree + " ";break;
       case 19:  stringOne =  ReadPZU(_19); stringThree =  ReadPZU(Chasov); stringHour = " " + stringOne + " " + stringThree + " ";break;
       case 20:  stringOne =  ReadPZU(_20); stringThree =  ReadPZU(Chasov); stringHour = "   " + stringOne + " " + stringThree + "   ";break;
       case 21:  stringOne =  ReadPZU(_20); stringTwo =  ReadPZU(Odin); stringThree =  ReadPZU(Chas); stringHour = " " + stringOne + " " + stringTwo + " " + stringThree + "  ";break;
       case 22:  stringOne =  ReadPZU(_20); stringTwo =  ReadPZU(Dva); stringThree =  ReadPZU(Chasa); stringHour = " " + stringOne + " " + stringTwo + " " + stringThree + "  ";break;
       case 23:  stringOne =  ReadPZU(_20); stringTwo =  ReadPZU(_3); stringThree =  ReadPZU(Chasa); stringHour = " " + stringOne + " " + stringTwo + " " + stringThree + "  ";break;
       }
        
 // switch (now.minute()) {         // собираем вторую строку
   switch (minuta) {         // собираем вторую строку
   case 0:  stringFour =  ReadPZU(Nol); stringSix =  ReadPZU(Minut); stringMin = "\n     " + stringFour + " " + stringSix + "     ";  break;
    case 1:  stringFour =  ReadPZU(Odna); stringSix =  ReadPZU(Minuta); stringMin = "\n    " + stringFour + " " + stringSix + "     ";  break;
    case 2:  stringFour =  ReadPZU(Dve); stringSix =  ReadPZU(Minuty); stringMin = "\n     " + stringFour + " " + stringSix + "     ";  break;
    case 3:  stringFour =  ReadPZU(_3); stringSix =  ReadPZU(Minuty); stringMin = "\n     " + stringFour + " " + stringSix + "     ";  break;
    case 4:  stringFour =  ReadPZU(_4); stringSix =  ReadPZU(Minuty); stringMin = "\n   " + stringFour + " " + stringSix + "    ";  break;
    case 5:  stringFour =  ReadPZU(_5); stringSix =  ReadPZU(Minut); stringMin = "\n     " + stringFour + " " + stringSix + "     ";  break;
    case 6:  stringFour =  ReadPZU(_6); stringSix =  ReadPZU(Minut); stringMin = "\n    " + stringFour + " " + stringSix + "     ";  break;
    case 7:  stringFour =  ReadPZU(_7); stringSix =  ReadPZU(Minut); stringMin = "\n     " + stringFour + " " + stringSix + "     ";  break;
    case 8:  stringFour =  ReadPZU(_8); stringSix =  ReadPZU(Minut); stringMin = "\n    " + stringFour + " " + stringSix + "    ";  break;
    case 9:  stringFour =  ReadPZU(_9); stringSix =  ReadPZU(Minut); stringMin = "\n    " + stringFour + " " + stringSix + "    ";  break;
    case 10:  stringFour =  ReadPZU(_10); stringSix =  ReadPZU(Minut); stringMin = "\n    " + stringFour + " " + stringSix + "    ";  break;
    case 11:  stringFour =  ReadPZU(_11); stringSix =  ReadPZU(Minut); stringMin = "\n " + stringFour + " " + stringSix + "  ";  break;
    case 12:  stringFour =  ReadPZU(_12); stringSix =  ReadPZU(Minut); stringMin = "\n  " + stringFour + " " + stringSix + "  ";  break;
    case 13:  stringFour =  ReadPZU(_13); stringSix =  ReadPZU(Minut); stringMin = "\n  " + stringFour + " " + stringSix + "  ";  break;
    case 14:  stringFour =  ReadPZU(_14); stringSix =  ReadPZU(Minut); stringMin = "\n " + stringFour + " " + stringSix + " ";  break;
    case 15:  stringFour =  ReadPZU(_15); stringSix =  ReadPZU(Minut); stringMin = "\n  " + stringFour + " " + stringSix + "  ";  break;
    case 16:  stringFour =  ReadPZU(_16); stringSix =  ReadPZU(Minut); stringMin = "\n " + stringFour + " " + stringSix + "  ";  break;
    case 17:  stringFour =  ReadPZU(_17); stringSix =  ReadPZU(Minut); stringMin = "\n  " + stringFour + " " + stringSix + "  ";  break;
    case 18:  stringFour =  ReadPZU(_18); stringSix =  ReadPZU(Minut); stringMin = "\n " + stringFour + " " + stringSix + " ";  break;
    case 19:  stringFour =  ReadPZU(_19); stringSix =  ReadPZU(Minut); stringMin = "\n " + stringFour + " " + stringSix + " ";  break;
    case 20:  stringFour =  ReadPZU(_20); stringSix =  ReadPZU(Minut); stringMin = "\n   " + stringFour + " " + stringSix + "   ";  break;
    case 21:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(Odna);stringSix =  ReadPZU(Minuta); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix;  break;
    case 22:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(Dve);stringSix =  ReadPZU(Minuty); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 23:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_3);stringSix =  ReadPZU(Minuty); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 24:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_4);stringSix =  ReadPZU(Min); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 25:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_5);stringSix =  ReadPZU(Minut); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 26:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_6);stringSix =  ReadPZU(Minut); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix;  break;
    case 27:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_7);stringSix =  ReadPZU(Minut); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 28:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_8);stringSix =  ReadPZU(Min); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 29:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_9);stringSix =  ReadPZU(Min); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 30:  stringFour =  ReadPZU(_30); stringSix =  ReadPZU(Minut); stringMin = "\n   " + stringFour + " " + stringSix + "   ";  break;
    case 31:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(Odna);stringSix =  ReadPZU(Minuta); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix;  break;
    case 32:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(Dve);stringSix =  ReadPZU(Minuty); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 33:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_3);stringSix =  ReadPZU(Minuty); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 34:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_4);stringSix =  ReadPZU(Min); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 35:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_5);stringSix =  ReadPZU(Minut); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 36:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_6);stringSix =  ReadPZU(Minut); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix;  break;
    case 37:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_7);stringSix =  ReadPZU(Minut); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 38:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_8);stringSix =  ReadPZU(Min); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 39:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_9);stringSix =  ReadPZU(Min); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 40:  stringFour =  ReadPZU(_40); stringSix =  ReadPZU(Minut); stringMin = "\n    " + stringFour + " " + stringSix + "     ";  break;
    case 41:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(Odna);stringSix =  ReadPZU(Minuta); stringMin = "\n " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 42:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(Dve);stringSix =  ReadPZU(Minuty); stringMin = "\n  " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 43:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_3);stringSix =  ReadPZU(Minuty); stringMin = "\n  " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 44:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_4);stringSix =  ReadPZU(Minuty); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 45:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_5);stringSix =  ReadPZU(Minut); stringMin = "\n  " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 46:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_6);stringSix =  ReadPZU(Minut); stringMin = "\n " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 47:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_7);stringSix =  ReadPZU(Minut); stringMin = "\n  " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 48:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_8);stringSix =  ReadPZU(Minut); stringMin = "\n " + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 49:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_9);stringSix =  ReadPZU(Minut); stringMin = "\n " + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 50:  stringFour =  ReadPZU(_50); stringSix =  ReadPZU(Minut); stringMin = "\n  " + stringFour + " " + stringSix + "   ";  break;
    case 51:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(Odna);stringSix =  ReadPZU(Min); stringMin = "\n " + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 52:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(Dve);stringSix =  ReadPZU(Minuty); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix;  break;
    case 53:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_3);stringSix =  ReadPZU(Minuty); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix;  break;
    case 54:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_4);stringSix =  ReadPZU(Min); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix;  break;
    case 55:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_5);stringSix =  ReadPZU(Minut); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix;  break;
    case 56:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_6);stringSix =  ReadPZU(Min); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix  + " ";  break;
    case 57:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_7);stringSix =  ReadPZU(Minut); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix;  break;
    case 58:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_8);stringSix =  ReadPZU(Min); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix;  break;
    case 59:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_9);stringSix =  ReadPZU(Min); stringMin = "\n" + stringFour + " " + stringFive + " " + stringSix;  break;
    }
    }
 
     

//**  З А Р Е М И Р О В А Н О   Д Л Я  P R O T E U S !!!!**
  mySerial.print("\4\1\120\61\27");    //Для VFD DSP850  (КОМАНД FIRICH) Установка курсора в начало дисплея  (домой)
          // mySerial.print("\13");               //Для VFD-2300  (ESC-кодовая система) Установка курсора в начало дисплея  (домой)
          //  mySerial.print("\f"); // для тестирования
              mySerial.println(stringHour);   //печать первой строки
              mySerial.print(stringMin);      // печать второй строки

}

//*************  Вывод ВСЕХ ДАННЫХ **********************************
  void OutFullInfo()       //ВЫВОД ПОЛНОЙ ИНФОРМАЦИИ
          {  
 String stringdday, stringHourdd, stringMindd, stringSecdd, stringDatyd,             //stringddayy,  stringdmonthh,, 
        stringGod,  stringGodn, stringdmonth, 
        stringHourd, stringMind, stringSecd, stringPerd, stringDaty, stringVtor ;  // эту фигню объявил для сборки времени словами из массива
 String stringOne, stringTwo, stringThree;                                          //Для БУДИЛЬНИКА   

          stringGod = yar, stringGodn = ReadPZU(God)  ; stringHourdd = chas; stringMindd = minuta; stringSecdd = sekunda, stringDatyd = denec;
         //  stringdday = ' ';  

       if (bitRead(BitReg1,Stat_Alarm) == 0){               
          if (bitRead(BitReg1,Stat_Korr) == 0)      //Отображение дня недели
          { switch (Weekday) {                                                                       // блок имени дня недели
           case 0:   stringdday = ReadPZU(Vskrs); break;            //Чтение выбранной константы в буфер BufData 
           case 1:   stringdday = ReadPZU(Poned); break;            //Чтение выбранной константы в буфер BufData 
           case 2:   BufData = ReadPZU(Vtor);      //Чтение выбранной константы в буфер BufData 
                    stringdday = stringdday + "    " + BufData; break;
           case 3:   BufData = ReadPZU(Sred);      //Чтение выбранной константы в буфер BufData 
                    stringdday = stringdday + "      " + BufData; break;
           case 4:   BufData = ReadPZU(Chetv);      //Чтение выбранной константы в буфер BufData 
                    stringdday = stringdday + "    " +BufData; break;
           case 5:   BufData = ReadPZU(Pjatn);      //Чтение выбранной константы в буфер BufData 
                    stringdday = stringdday + "    " +BufData; break;
           case 6:   BufData = ReadPZU(Subb);      //Чтение выбранной константы в буфер BufData 
                    stringdday = stringdday + "    " +BufData; break;   
                            }
          }
         /* { switch (Weekday) {                                                                       // блок имени дня недели
           case 0:   stringdday = ReadPZU()[39]; break;
           case 1:   stringdday = ReadPZU()[33]; break;
           case 2:   stringdday = stringddayy + "    " + ReadPZU()[34]; break;
           case 3:   stringdday = stringddayy + "      " + ReadPZU()[35]; break;
           case 4:   stringdday = stringddayy + "    " + ReadPZU()[36]; break;
           case 5:   stringdday = stringddayy + "    " + ReadPZU()[37]; break;
           case 6:   stringdday = stringddayy + "    " + ReadPZU()[38]; break;    
                            }
          }*/

          else{                                  //Если режим коррекции
            if (bitRead(BitReg2,Korr_Chas) > 0) 
             stringdday = stringdday + "\40\212\256\340\340\40\40\227\240\341\40";      //Корр ЧАС  
            if (bitRead(BitReg2,Korr_Min) > 0) 
             stringdday = stringdday + "\40\212\256\340\340\40\40\214\250\255\40";      //Корр МИН
            if (bitRead(BitReg2,Korr_Day) > 0) 
             stringdday = stringdday + "\40\212\256\340\340\40\40\204\245\255\354";      //Корр День
            if (bitRead(BitReg2,Korr_Mes) > 0) 
             stringdday = stringdday + "\40\212\256\340\340\40\214\245\341\357\346";      //Корр Месяц
            if (bitRead(BitReg2,Korr_God) > 0) 
             stringdday = stringdday + "\40\212\256\340\340\40\40\203\256\244\40";      //Корр Год
             if (bitRead(BitReg2,Korr_Sec) > 0) 
             stringdday = stringdday + "\40\221\241\340\256\341\40\221\245\252\40";    //Сброс Сек 
            } // */
            
         

         //  блок имени месяца
           switch (mesyac) {
           case 1:  stringdmonth =  ReadPZU(Janvar) + "   ";  break;
           case 2:  stringdmonth = ReadPZU(Fevral) + "  ";  break; ;                     
           case 3:  stringdmonth = ReadPZU(Mart) + "    ";  break;
           case 4:  stringdmonth = ReadPZU(Aprel) + "   ";  break;
           case 5:  stringdmonth = ReadPZU(Maj) + "      ";  break;
           case 6:  stringdmonth = ReadPZU(Ijun) + "     ";  break;
           case 7:  stringdmonth = ReadPZU(Ijul) + "     ";  break;
           case 8:  stringdmonth = ReadPZU(Avgust) + "  ";  break;
           case 9:  stringdmonth = ReadPZU(Sentjabr) + " ";  break;
           case 10: stringdmonth = ReadPZU(Oktjabr) + "  ";  break;
           case 11: stringdmonth = ReadPZU(Nojabr) + "   ";  break;
           case 12: stringdmonth = ReadPZU(Dekabr) + "  ";  break;
      } 

           //БЛОК ОТОБРАЖЕНИЯ ВРЕМЕНИ
           

            if (chas < 10)   // это нолики перед часами до 10

           {
            stringHourd = '0' + stringHourdd;
           }
           else
           {
            stringHourd = stringHourdd;
           }
           

           if (minuta < 10)   // это нолики перед минутами до 10
           {
            stringMind = '0' + stringMindd;
           }
           else
           {
            stringMind = stringMindd;
           }

           
          if (sekunda < 10)   // это нолики перед секундами до 10
           {
            stringSecd = '0' + stringSecdd;
           }
           else
           {
            stringSecd = stringSecdd;
           }


           if (denec < 10)   // это нолики перед датой до 10
           {
            stringDaty = '0' + stringDatyd;
           }
           else
           {
            stringDaty = stringDatyd;
           }
          
           stringPerd = stringHourd + ':' + stringMind + ':' + stringSecd + " " + stringdday;       // собираем первую строку
           stringVtor = "\r\n" + stringDaty + " " + stringdmonth +  stringGod + " " + stringGodn;   // собираем вторую строку


//**  З А Р Е М И Р О В А Н О   Д Л Я  P R O T E U S !!!!**          
mySerial.print("\4\1\120\61\27");    //Для VFD DSP850  (КОМАНД FIRICH) Установка курсора в начало дисплея  (домой)
          // mySerial.print("\13");               //Для VFD-2300  (ESC-кодовая система) Установка курсора в начало дисплея  (домой)  
             // mySerial.print("\f");           //Очистка дисплея     
              mySerial.println(stringPerd);  // печатаем первую строку
              mySerial.print(stringVtor);    // а это вторую

/***  ТЕСТОВЫЙ ВЫВОД ЗВУКА  ***
 *   Каждые 10 сек надо кукукнуть :)
 *
      if (((sekunda % 10) == 0)&&(bitRead(BitReg1,Stat_Zumm) == 0))
      { bitSet(BitReg1,Stat_Zumm);
          Buf_Melody = KuKu_Snd;
          Buf_Durat = KuKu_Durat;
        BufSt_Note = KuKu_Lgn;
        StDurat = 0;
         Serial.print("Stat_Zumm = TRUE");  // печатаем первую строку
      }*/

       }      //А ЭТО ВЫВОД _ ЕСЛИ БУДИЛЬНИК!********************
       else{  stringHourdd = Alarm_Chas; stringMindd = Alarm_Minuty;          
         if (Alarm_Chas < 10)                         // это нолики перед часами до 10

           {
            stringHourd = '0' + stringHourdd;
           }
           else
           {
            stringHourd = stringHourdd;
           }
           

           if (Alarm_Minuty < 10)   // это нолики перед минутами до 10
           {
            stringMind = '0' + stringMindd;
           }
           else
           {
            stringMind = stringMindd;
           }
//Вывод инфо БУДИЛЬНИК
          if (bitRead(BitReg1,Stat_Korr) == 0)          //Отображение состояния будильника
          {stringOne = ReadPZU(Alarm);                  // слово "Будильник"
              if (bitRead(BitReg1,Set_Alarm) == 0) stringTwo = ReadPZU(_Off);     //ВКЛ
                        else stringTwo = ReadPZU(_On) + ' ';                           //или ВЫКЛ
             stringVtor = stringOne + ":  " + stringTwo;
             stringPerd = stringHourd + ':' + stringMind + "               ";

            
                            } 
            else{                                 //Будильник УСТАНОВКА
                    
                      stringOne = ReadPZU(Alarm);              // слово "Будильник"
                  
                       stringTwo = ReadPZU(_Set);                           //Установка
            if (bitRead(BitReg2,Korr_Chas) > 0) 
             stringThree = stringThree + "\40\212\256\340\340\40\40\227\240\341\40\40";      //Корр ЧАС  
            if (bitRead(BitReg2,Korr_Min) > 0) 
             stringThree = stringThree + "\40\212\256\340\340\40\40\214\250\255\40\40";      //Корр МИН
            if (bitRead(BitReg2,Korr_Alarm) > 0) {
              if (bitRead(BitReg1,Set_Alarm) == 0) stringThree = ReadPZU(_Off) + "    ";     //ВКЛ
                        else stringThree = ReadPZU(_On) + "     ";                           //или ВЫКЛ
            }
                       
             stringPerd = stringOne + ": " + stringTwo;
             stringVtor = stringHourd + ':' + stringMind + " - " + stringThree;                      
            }
mySerial.print("\4\1\120\61\27");    //Для VFD DSP850  (КОМАНД FIRICH) Установка курсора в начало дисплея  (домой)
         //  mySerial.print("\13");               //Для VFD-2300  (ESC-кодовая система) Установка курсора в начало дисплея  (домой)  
            //  mySerial.print("\f");           //Очистка дисплея     
              mySerial.println(stringPerd);  // печатаем первую строку
              mySerial.print(stringVtor);    // а это вторую                                   
       }
         
          }
          
  //************************************************************

 //****************  Чтение RTC и заполнение переменных  *************************** 
void ReadRTC(){
  DateTime now = RTC.now();

  
{
   yar = now.year();       // присваиваем переменным значения года
   mesyac = now.month();   // месяца
   denec = now.day();      // дня
   chas = now.hour();      // часа
   minuta = now.minute();  // минуты
   sekunda = now.second(); // и секунды
   Weekday = now.dayOfTheWeek();//День недели

}
       
    //Корректировка хода часов в зависимости от точности кварца ТАЙМЕРА
         if (chas == 19 && minuta == 03 && sekunda == 30 && korrektwrem == 0 )   //  корректировка часов реального времени 
         { sekunda = sekunda - 7; korrektwrem = korrektwrem + 1 ;RTC.adjust(DateTime(yar, mesyac, denec, chas, minuta, sekunda));  // на 7 секунд
             };

        if (chas == 19 && minuta == 03 && sekunda == 59 )
        { korrektwrem = 0; 
             }

  }
  //************************************************************
//***************** Коррекция времени  ********************
  void KorrRTC(){

  if ((bitRead(BitReg1,Stat_Korr) > 0)&&(bitRead(BitReg1,Stat_Alarm) == 0))                         // Если режим корреции ВКЛ и ето не будильник
  {     //КОРРЕКЦИЯ ЧАСА  *************
        if (bitRead(BitReg2,Korr_Chas) > 0)                                          //Если корректируем часы
         { chas = Korr_Data(chas, 0, 23);
                      if (bitRead(BitReg3,Press_Long) > 0) {bitClear(BitReg2,Korr_Chas);     //Если переход к следующему параметру
                                                            bitSet(BitReg2,Korr_Min);         //сброс корр предыдущего
                                                            bitClear(BitReg3,Press_Long); };  //переход к следующему
                      }
        //КОРРЕКЦИЯ МИНУТ  *************         
     if (bitRead(BitReg2,Korr_Min) > 0)                                          //Если корректируем минуты     
         {minuta = Korr_Data(minuta, 0, 59);
                      if (bitRead(BitReg3,Press_Long) > 0) {bitClear(BitReg2,Korr_Min);         //СБРОС НАЖАТИЯ  //Если переход к следующему параметру
                                                            bitClear(BitReg3,Press_Long);       //сброс корр предыдущего
                                                             bitSet(BitReg2,Korr_Day);}; 
                      }
     //КОРРЕКЦИЯ ЧИСЛА  *************             
        if (bitRead(BitReg2,Korr_Day) > 0)                                          //Если корректируем число
                      {denec = Korr_Data(denec, 1, 31);
                      if (bitRead(BitReg3,Press_Long) > 0) {bitClear(BitReg2,Korr_Day);     //Если переход к следующему параметру
                                                            bitSet(BitReg2,Korr_Mes);         //сброс корр предыдущего
                                                            bitClear(BitReg3,Press_Long); };  //переход к следующему
                      }
     //КОРРЕКЦИЯ МЕСЯЦА  *************             
        if (bitRead(BitReg2,Korr_Mes) > 0)                                          //Если корректируем час
                      {mesyac = Korr_Data(mesyac, 1, 12);
                      if (bitRead(BitReg3,Press_Long) > 0) {bitClear(BitReg2,Korr_Mes);     //Если переход к следующему параметру
                                                            bitSet(BitReg2,Korr_God);         //сброс корр предыдущего
                                                            bitClear(BitReg3,Press_Long); };  //переход к следующему
                      }
     //КОРРЕКЦИЯ ГОДА  *************             
        if (bitRead(BitReg2,Korr_God) > 0)                                          //Если корректируем час
                    {yar = Korr_Data(yar, 2020, 2050);
                      if (bitRead(BitReg3,Press_Long) > 0) {bitClear(BitReg2,Korr_God);           //сброс корр предыдущего
                                                            bitSet(BitReg2,Korr_Sec);         //переход к коррекции секунд - выходу
                                                            bitClear(BitReg3,Press_Long); };      //сброс нажатия
                                                         
                    }
                 //КОРРЕКЦИЯ СЕКУНД - ВЫХОД  *************             
        if (bitRead(BitReg2,Korr_Sec) > 0)   
                     {if (bitRead(BitReg3,Press_Short) > 0) { sekunda = 0;                        //обнуление секунд   
                                                            bitClear(BitReg1,Stat_Korr);          //сброс признака корр 
                                                            bitClear(BitReg2,Korr_Sec);           //сброс признака сброса секунд
                                                            bitClear(BitReg3,Press_Short);       //сброс нажатия
                                                            RTC.adjust(DateTime(yar, mesyac, denec, chas, minuta, sekunda));}
                      if (bitRead(BitReg3,Press_Long) > 0) { 
                                                            bitClear(BitReg1,Stat_Korr);          //сброс признака корр 
                                                            bitClear(BitReg2,Korr_Sec);           //сброс признака сброса секунд
                                                            bitClear(BitReg3,Press_Long);}       //сброс нажатия и просто ВЫХОД
                                                           
                     }             
        
  }
  if ((bitRead(BitReg1,Stat_Korr) > 0)&&(bitRead(BitReg1,Stat_Alarm) > 0))                         // Если режим корреции ВКЛ и это будильник
      {   //КОРРЕКЦИЯ ЧАСА  *************
        if (bitRead(BitReg2,Korr_Chas) > 0)                                          //Если корректируем часы установки будильника
         { Alarm_Chas = Korr_Data(Alarm_Chas, 0, 23);
                      if (bitRead(BitReg3,Press_Long) > 0) {bitClear(BitReg2,Korr_Chas);     //Если переход к следующему параметру
                                                            bitSet(BitReg2,Korr_Min);         //сброс корр предыдущего
                                                            bitClear(BitReg3,Press_Long); };  //переход к следующему
                      }
        //КОРРЕКЦИЯ МИНУТ  *************         
     if (bitRead(BitReg2,Korr_Min) > 0)                                          //Если корректируем минуты установки будильника    
         {Alarm_Minuty = Korr_Data(Alarm_Minuty, 0, 59);
                      if (bitRead(BitReg3,Press_Long) > 0) {bitClear(BitReg2,Korr_Min);         //СБРОС НАЖАТИЯ  //Если переход к следующему параметру
                                                            bitClear(BitReg3,Press_Long);       //сброс корр предыдущего
                                                             bitSet(BitReg2,Korr_Alarm);};      //переход к включению будильника
                      }
        //ВКЛ/ВЫКЛ будильника  *************         
     if (bitRead(BitReg2,Korr_Alarm) > 0)                                          //Если корректируем минуты установки будильника    
         {if (bitRead(BitReg3,Press_Short)> 0){
          if (bitRead(BitReg1,Set_Alarm) == 0) bitSet(BitReg1,Set_Alarm);
                else bitClear(BitReg1,Set_Alarm); 
                     bitClear(BitReg3,Press_Short);
                      }
                      if (bitRead(BitReg3,Press_Long) > 0) {bitClear(BitReg2,Korr_Alarm);         //СБРОС НАЖАТИЯ  
                                                            bitClear(BitReg3,Press_Long);       //сброс корр предыдущего
                                                            bitClear(BitReg1,Stat_Korr);        // сброс признака коррекции
                        EEPROM.write(EE_Alarm,Alarm_Chas);               //Запись в ЕЕПРОМ значения ЧАСА Будильника
                        EEPROM.write((EE_Alarm + 1),Alarm_Minuty) ;            //Запись в ЕЕПРОМ значения МИНУТ Будильника
                        byte SetAlarm;
                        if ( bitRead(BitReg1,Set_Alarm) == 0) SetAlarm = 0;
                                                  else        SetAlarm = 1;  
                        EEPROM.write((EE_Alarm + 2),SetAlarm);  //Запись в ЕЕПРОМ состояния Будильника 
                                             
                          
                                     }
          }
      }
  }
//*********************  КОНЕЦ БЛОКА КОРРЕКЦИИ  ****************************




  //**************************  Обработка кнопки  *******************************************************
void ReadButton()
          {if (millis()-Delay_Btn > 5)                                          // Если прошло 5мс - проверяем состояние кнопки
                      {Delay_Btn = millis();                                    //перезапуск цикла опроса
                            if (digitalRead(buttonPin)== LOW) {StPauseBut = 0;                             //Кнопка нажата
                              if (StPressBut < (Delay_Long + 5))
                                       {StPressBut++;
                                          if (StPressBut > Delay_Long) {StPressBut = (Delay_Long + 10);                   //Долго..                                                               
                                                                        bitSet(BitReg3,Press_Long);}           //Установить признак ДЛИТЕЛЬНОГО НАЖАТИЯ
                                       }
                                                              }
                              if (digitalRead(buttonPin)== HIGH)                                            //Если кнопка не нажата
                                {if (StPressBut < Delay_Dzzz) StPressBut = 0;                                        //Защита от дребезга
                                  if (bitRead(BitReg3,Press_Pause) > 0)                                      //если ожидается двойное нажатие
                                      {StPauseBut++;
                                      if (StPauseBut >Delay_Pause) {StPauseBut = 0; bitClear(BitReg3,Press_Pause);}  //если повторного нажатия не дождались - сброс
                                      }
                                    if (StPressBut > Delay_Long) StPressBut = 0;                                      //Если после длительного нажатия - сброс
                                    if ((StPressBut > (Delay_Short))&(bitRead(BitReg3,Press_Pause) >0)){ bitSet(BitReg3,Press_Duble);    //или это двойное нажатие
                                                                                              StPressBut =0;                  //сбросить счетчик нажатия
                                                                                              bitClear(BitReg3,Press_One);    //Сврос признака одиночного нажатия
                                                                                              bitClear(BitReg3,Press_Pause);}  //сбросить признак ожидания повторного нажатия  
                                   else
                                            if (StPressBut > Delay_Short) {bitSet(BitReg3,Press_One);                                //Иначе - короткое нажатие
                                                                  bitSet(BitReg3,Press_Pause);                //и ждём - вдруг будет второе нажатие
                                                                  StPressBut = 0;                                             //подготавливаем счётчик нажатия 
                                                                  StPauseBut = 0;                                             //и счётчик длительности паузы
                                                                }
                                }

                       }
                               if ((bitRead(BitReg3,Press_Pause) == 0)&(bitRead(BitReg3,Press_One) > 0)){ bitSet(BitReg3,Press_Short);
                                                                                                          bitClear(BitReg3,Press_One);}
            }
                           

 // *****************************************   Конец обработки кнопки  ***************************************          
//********************   Управление Режимами работы  ************************
void Setup_Reg(){
  if (bitRead(BitReg1,Zum_Alarm) > 0){bitClear(BitReg3,Press_Short);
                                      bitClear(BitReg3,Press_Long);
                                      }
                       else{
  byte Byt_Reg;                                               //переменная с номером текущего режима
          //вычисление текущего режима из состояния битового регистра
      if (bitRead(BitReg1,Stat_Alarm) > 0) Byt_Reg = 2;         //если отображение будильника - режим 2
            else Byt_Reg = bitRead(BitReg1,Stat_Text);          // иначе режим по биту Stat_Text : 0 -ИНФО; 1- Текст
     if (bitRead(BitReg3,Press_Short) > 0){                     //если короткое нажатие
   
if (bitRead(BitReg1,Stat_Korr) == LOW) {    //Если не Режим коррекции часов и будильника - то кружим режимы
  
                //  конец расчетам  !!
                //Теперь можно при менить конструкцию switch

                switch (Byt_Reg) {
                  case 0:{bitClear(BitReg3,Press_Short);bitClear(BitReg1,Stat_Alarm);bitSet(BitReg1,Stat_Text);
                   EEPROM.write(EE_Text,1);}break;
                  case 1:{bitClear(BitReg3,Press_Short);bitSet(BitReg1,Stat_Alarm);bitClear(BitReg1,Stat_Text);
                   EEPROM.write(EE_Text,0);}break;
                  case 2:{bitClear(BitReg3,Press_Short);bitClear(BitReg1,Stat_Alarm);bitClear(BitReg1,Stat_Text);}break;
                         
                }
    }
    }
      if (bitRead(BitReg3,Press_Long) > 0) {                                                  //Если ДЛИТЕЛЬНОЕ нажатие    
            if (bitRead(BitReg1,Stat_Zumm) > 0 ) bitClear(BitReg3,Press_Long);
            else{
         if (bitRead(BitReg1,Stat_Korr) == 0)  
                          { bitClear(BitReg3,Press_Long);      
                            bitSet(BitReg1,Stat_Korr);bitSet(BitReg2,Korr_Chas);}   //Установить РЕЖИМ КОРРЕКЦИИ ВРЕМЕНИ
            }
                 
      }
             /*    
    
         if (bitRead(BitReg3,Press_Long) > 0) {                                                  //Если ДЛИТЕЛЬНОЕ нажатие  
                if (bitRead(BitReg1,Stat_Korr) == 0 )  
                          { bitClear(BitReg3,Press_Long);      
                            bitSet(BitReg1,Stat_Korr);bitSet(BitReg2,Korr_Chas);}   //Установить РЕЖИМ КОРРЕКЦИИ ВРЕМЕНИ

                                            }
                           
      if (bitRead(BitReg3,Press_Short) > 0){                                                    //Если КОРОТКОЕ нажатие 
               if (bitRead(BitReg1,Stat_Korr) == 0 )                                            //и если не коррекция 
                                   {bitClear(BitReg3,Press_Short);                              //то просто ТЕСТ
                                       if (digitalRead(LED_Text) == LOW)  {bitClear(BitReg1,Stat_Text);
                                                      digitalWrite(LED_Text, HIGH);}                              //Тестовый светодиод реакции кнопки
                      else    {digitalWrite(LED_Text, LOW);                                                       //
                              bitSet(BitReg1,Stat_Text);                                        //иначе переключение режимов отображения
                              }                                                                 //и 
                              byte tempVar = bitRead(BitReg1,Stat_Text);                        //Запись режима вывода в ЕЕПРОМ
                              EEPROM.update(EE_Text, tempVar);                                  //для сохранения режима после пропадания питания
                                    }
                                          }
        if (bitRead(BitReg3,Press_Duble) > 0) {                                                  //Если ДВОЙНОЕ нажатие 
                if (bitRead(BitReg1,Stat_Korr) == 0 )                                           //и если не коррекция
                                    {bitClear(BitReg3,Press_Duble);                             //то просто ТЕСТ
                                      if (digitalRead(LED_Duble) == LOW)  digitalWrite(LED_Duble, HIGH);          //Тестовый светодиод реакции кнопки
                                            else     digitalWrite(LED_Duble, LOW);                                //         
                                    }                                                           //иначе - обработка в другом месте (КОРР -)
                                              } */                           
}
}
//**************   Чтение из ПЗУ в буфер   *****************************
String ReadPZU(char* AdrPZU){                 //Получаем указатель на сонстанту
String TempData;                            //Временная строка для возврата

        for (byte i = 0; i < strlen_P(AdrPZU); i++) {     //определяем значимую длинну массива
                   TempData  =  TempData + ((char)pgm_read_byte(&AdrPZU[i]));}      //Чтение в промБуфер данных 
              // BufData = TempData;                          //перезагрузка в Буфер
              return TempData;                  //Счинанная константа для возврата
           
}
//*****************************************************************

// *************  ВЫВОД МЕЛОДИИ  **********************************

// *************  ВЫВОД МЕЛОДИИ  - СВОЙ ВАРИАНТ  **********************************
//****  Версия с двумя массивами под мелодию и длинной в константе  **************
/*\
 * В два буфеа - Buf_Durat и Buf_Melody заносятся данные длительности и тону нот соответсвенно
 * В буфер - BufDurat переносим значение длинны мелодии в количестве нот (включая паузы между ними - Tone_Pausa значенрие - менее 20Гц) 
 * 
 */
void playMelody(){

      if (bitRead(BitReg1,Stat_Zumm) > 0){                                //Выводим мелодию
          if (StDurat == 0)                                     //Инициализируем вывод мелодии (Загрузка необходимых данных
                            StNote = 0;                         //цикл  - в начало          
                //** воспроизведение нот по порядку 
          if (millis()-StDurat > BufDurat){                                          // Если прошло 5мс - проверяем состояние кнопки
                      StDurat = millis();                                    //перезапуск цикла опроса
         
                      if (StNote < BufSt_Note ){                                        //Если мелодия не закончена
                         BufDurat = 1000/((int)pgm_read_word(&Buf_Durat[StNote]));       //вычисляем значение длительности ноты
               // BufDurat = 1000/BufDurat0;                  //перевод из долей в мс звучания ноты
                BufTone = ((int)pgm_read_word(&Buf_Melody[StNote]));           //буфер для  значения тона  (возможно прямое чтение в функцию "tone()"   
                    if (BufTone < 15) noTone(Pin_Tone);                                 //Если пауза меж нот - отключаем звук на время указаное для паузы
                                   else{
                                      tone(Pin_Tone, BufTone, BufDurat);}       //иначе - Тон в вывод
                     StNote ++;  
                           }
                          else {StDurat = 0;                  
                                bitClear(BitReg1,Stat_Zumm);
                                noTone(Pin_Tone);
                                BufDurat = 10;
                                ReadRTC();
                          //       Serial.println("Stat_Zumm = FALSE");  // печатаем первую строку
                          }
        
                    }
                }
    //  return true;            
      }
//*************  Работа с БУДИЛЬНИКОМ  **********************      
void   Alarm_Out(){
  if (bitRead(BitReg1,Stat_Korr) == 0 ){
  if (bitRead(BitReg1,Set_Alarm) > 0)     //Если будильник включен 
            {if ((Alarm_Chas == chas)&&(Alarm_Minuty == minuta)&&(bitRead(BitReg1,Stat_Zumm) == 0)&&(bitRead(BitReg1,ZumOff_Alarm) == 0))
                 {if (bitRead(BitReg3,Press_Duble) >0) {//bitClear(BitReg1,Set_Alarm);
                                                       digitalWrite(LED_Duble, HIGH);
                                                       bitClear(BitReg3,Press_Duble);
                                                       bitClear(BitReg1,Zum_Alarm);
                                                       bitSet(BitReg1,ZumOff_Alarm);}
  
              else { bitSet(BitReg1,Stat_Zumm);
                 Buf_Melody = KuKu_Snd;
                 Buf_Durat = KuKu_Durat;
                 BufSt_Note = KuKu_Lgn;
                 StDurat = 0;
                 bitSet(BitReg1,Zum_Alarm);
                 
                 //digitalWrite(LED_Duble, LOW);
                 }
                 }
    if ((Alarm_Chas != chas)||(Alarm_Minuty != minuta)) { bitClear(BitReg1,ZumOff_Alarm);  
                                                          bitClear(BitReg1,Zum_Alarm);}

                                                                
 
     
            }
  }          
}
//************  Конец ***************************************

//************ Подпрограмма коррекции данных по диапазону  *****************
int Korr_Data(int Data, int Begin, int Range){            //Входные параметры Изменяемая величина и диапазон измерений
  if (bitRead(BitReg3,Press_Short) > 0) {Data++;                          //  ВПЕРЁД
                                                 if (Data > Range) Data = Begin;         //Если 
                                                 if (Data < Begin) Data = Range;         //вне диапазона
                                                 bitClear(BitReg3,Press_Short); }          //СБРОС НАЖАТИЯ
                      if (bitRead(BitReg3,Press_Duble) > 0) {Data--;                    //Если   коррекция НАЗАД
                                                             if (Data > Range) Data = Begin;       //Если 
                                                              if (Data < Begin) Data = Range;      //вне диапазона
                                                             bitClear(BitReg3,Press_Duble);} //СБРОС НАЖАТИЯ
                       
                    // Serial.print("Data = "); Serial.println(Data); 
                                     return Data ;
}
//****************************************************************************

 

Верх
Пнд, 08/08/2022 - 15:17
#427
Amatroskin
Offline
Зарегистрирован: 21.04.2020

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

Верх
Пнд, 08/08/2022 - 16:00
#428
kackaqep
Offline
Зарегистрирован: 14.02.2020

Сделаю, не проблема....

Сейчас нет часов под рукой.

 

Верх
Втр, 09/08/2022 - 03:55
#429
kackaqep
Offline
Зарегистрирован: 14.02.2020

Блин, нарисовалась поездка на несколько дней. Вернусь в воскресенье вечером. В понедельник распишу про свои часики,   

а сейчас пока фото моего отладочного стенда, вытащил из под коробок, сдул пыль и включил... Работает!!!

Первичная отладка производится в PROTEUSе.

 

Верх
Втр, 09/08/2022 - 11:57
#430
kackaqep
Offline
Зарегистрирован: 14.02.2020

Но сначала прогоняю здесь до работоспособного состояния

Верх
Втр, 16/08/2022 - 16:36
#431
kackaqep
Offline
Зарегистрирован: 14.02.2020

Итак, по часам с будильником, краткое описание моей модификации прошивки.

Первое, что мне не понравилось в исходном коде - хранение констант в ОЗУ и ДЕВЯТЬ КНОПОК управления! 

Расположил все текстовые константы в ПЗУ, написал обработку кнопки (жуть как коряво, ну как смог!), для ускорения процессов делаи были убраны и программа была завёрнута в функции. Результат почти понравился, только работа кнопки пока не радует - нет чёткости опознания  в режиме двойного клика, но работает.

Товарищ посмотрел и спросил - А будильник как включить? ОПА! А будильника то и нет! Опять сел за книжки и в результате появился будильник на функции ТОНЕ. Естественно, все константы мелодий и длительностей тоже расположились в ПЗУ. 

Отлаживал всё, даже звук в PROTEUSе, затем уже заливал в камень.

Вообще. хотелось бы программировать пограмотней, но занимаюсь этим набегами и после перерыва приходится вспоминать азы, а не то что код свой совершенствовать! Стараюсь из-за этого код комментировать побогаче, а то сам заблужусь в том что ваворотил! 8-))

Как то так...

Да! Для генерации текстовых сообщений написал небольшую утилитку:

Набираешь текст, нажимаешь "применить" и копируешь код в скетч.

Верх
Втр, 30/08/2022 - 15:44
#432
Носмас
Offline
Зарегистрирован: 13.06.2020

Никто не реализовывал такие часы на таких же дисплеях, но где стоят USB разъёмы? 

Верх
Втр, 30/08/2022 - 15:56
#433
Amatroskin
Offline
Зарегистрирован: 21.04.2020

Что за дисплей? Модель? маркировка? Документация есть?

Верх
Втр, 30/08/2022 - 16:18
#434
Носмас
Offline
Зарегистрирован: 13.06.2020

1P00A985, Futaba, Wincor nixdorf
Проц df3687.

Верх
Втр, 30/08/2022 - 16:39
#435
Amatroskin
Offline
Зарегистрирован: 21.04.2020

Если я правильно понял этот вот этот аппарат:
https://manualzz.com/doc/52504849/wincor-nixdorf-ba63gv-operating-manual
это графический дисплей, именно с таким тут никто не работал, редкая модель,  т.к. например лично я первый раз читаю про такой, не говоря уже о том чтобы работать с ним вживую, из документации понятно, что возможности у него очень неплохие. Например можно выбрать из нескольких размеров символов, и даже загружать свой логотип. Документация довольно подробная, при желании разобраться можно, да и примеров работы в этой теме тоже достаточно. Интерфейс подключения (USB или RS232) роли не играет, т.к. подключение осуществляется через UART,. напрямую к процу.

Верх
Втр, 30/08/2022 - 16:53
#436
Носмас
Offline
Зарегистрирован: 13.06.2020

Т.е. если я правильно понял Вас понял можно сразу к процу цепляться.
Спасибо.
Я пробовал цепляться к rx-tx, но не был уверен в нане. И rx-tx на проце две пары, чем отличаются так и не вычитал. Я думал что как раз rs232 на этой плате и нет.

Верх
Втр, 30/08/2022 - 17:03
#437
Amatroskin
Offline
Зарегистрирован: 21.04.2020

Смотрите куда подключен выход преобразователя интерфейса (USB -> UART  в вашем случае наверно). 
ЗЫ: тут после падения радикала все фотки пропали, вот в этой статье есть описание подключения к уарту проца напрямую.

https://cxem.net/arduino/arduino250.php

Верх
Втр, 30/08/2022 - 18:11
#438
devICEpro
Offline
Зарегистрирован: 11.11.2020

А можно фотки этого чуда в студию?

Верх
Втр, 30/08/2022 - 20:28
#439
imatt
Offline
Зарегистрирован: 18.04.2020

Согласен, прикольный зверь у него колба получается без разделитель что-ли?

Верх
Втр, 30/08/2022 - 20:28
#440
imatt
Offline
Зарегистрирован: 18.04.2020

Согласен, прикольный зверь у него колба получается без разделитель что-ли?

Верх
Втр, 30/08/2022 - 20:28
#441
imatt
Offline
Зарегистрирован: 18.04.2020

Согласен, прикольный зверь у него колба получается без разделитель что-ли?

Верх
Втр, 30/08/2022 - 22:15
#442
Носмас
Offline
Зарегистрирован: 13.06.2020

https://www.google.com/search?q=1P00A985&source=lnms&tbm=isch&sa=X&ved=2ahUKEwj3pLvUle_5AhVD6CoKHSToD9wQ_AUoA3oECAEQBQ&biw=1600&bih=789&dpr=1

Верх
Втр, 30/08/2022 - 22:20
#443
Amatroskin
Offline
Зарегистрирован: 21.04.2020

Я то думал.. обычный 202md25 сто раз уже про такой писали, читайте тему.

Верх
Пт, 16/09/2022 - 21:21
#444
Носмас
Offline
Зарегистрирован: 13.06.2020

Сильно то не пинайте.

Может ли быть такое что rs 232 нет на плате.

Плата с usb разъёмом. Сигнал с usb колодки идёт через usbn9604-2bm сразу на проц df3687. Подозреваю что rs 232 тут отсутствует от слова совсем. 

Верх
Сб, 17/09/2022 - 00:17
#445
Amatroskin
Offline
Зарегистрирован: 21.04.2020

Ну конечно может, а он и не надо, земля и нога rx от проца, лучше отсоединенная от преобразователя, и все, данные по уарту.

Верх
Чт, 29/09/2022 - 17:01
#446
Лого
Offline
Зарегистрирован: 20.07.2022

Здравствуйте, можно скетч и схему сборки пожалуйста

Верх
Чт, 29/09/2022 - 17:03
#447
Лого
Offline
Зарегистрирован: 20.07.2022

devICEpro пишет:


Здравствуйте, можно пожалуйста скетч и схему сборки

Верх
Чт, 29/09/2022 - 18:01
#448
devICEpro
Offline
Зарегистрирован: 11.11.2020

Это то, с чего всё начиналось.

https://drive.google.com/drive/folders/1nfX1-58qgjRTRJZNomgP-VUjyrogzefS?usp=sharing

Сейчас это выглядит так

И устроено совсем по-другому.

Верх
Пт, 30/09/2022 - 11:26
#449
Лого
Offline
Зарегистрирован: 20.07.2022

devICEpro пишет:

Это то, с чего всё начиналось.

https://drive.google.com/drive/folders/1nfX1-58qgjRTRJZNomgP-VUjyrogzefS?usp=sharing

Сейчас это выглядит так

И устроено совсем по-другому.


Большое спасибо

Верх
Втр, 04/10/2022 - 09:31
#450
Amatroskin
Offline
Зарегистрирован: 21.04.2020

Продолжение темы дисплеев, прямое управление колбой, без использования "мозгов" платы на безе МК ESP32, прошу ознакомиться, протестить, а лучше взять и использовать для чего нибудь интересного)
https://cxem.net/mc/mc503.php

Верх