Arduino.ru

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

Пытаюсь сделать такие часы.

kackaqep

Использую ваш код.

Плата такая же как у Amatroskinа

RX на плате нашёл и даже вывел хело ворд, т.е. плата исправна (снимаю с D10 ардуино). Перемычку одну воткнул (без неё вообще ничего).

Модуль часов DS3231 (в коде вписал), подсоединил к А4 и А5 (плата UNO).

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

Далее дисплей переходит в следующий режим и верхняя строка пустая, а на нижней снова кракозябры.

Сейчас к ардуино подключен дисплей и модуль часов (кнопка и бузер можно позже)

Что я делаю не так, куда копать?

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

именно такой

Прошу прощения, поторопился с выводами по поводу вывода символов. Вообще то должно работать. Возможно проблема из-за контроля чётности, NIXDOFR ставит её по умолчанию вкл.  Фото давай что происходит, будем разбираться

Есть такой дисплей. Завтра попробую

Что то я при беглом просмотре не увидел возможности задавать пользовательские символы у этого дисплея, максимум можно использовать кириллицу, если установить соответствующую кодовую страницу (стр 14 датшита)
https://www.manualslib.com/download/1146241/Wincor-Nixdorf-Ba63.html

[quote=devICEpro]

Прошу прощения, поторопился с выводами по поводу вывода символов. Вообще то должно работать. Возможно проблема из-за контроля чётности, NIXDOFR ставит её по умолчанию вкл.  Фото давай что происходит, будем разбираться

[/qu​ote]

Так у него просто не та кодовая страница выставлена. Читай докцию

ндааа, ясности не добавило

Команду 1B 52 35 или 1B 52 29 надо дать дисплею один раз. RealTerm в помощь

Проблема русских букв решается просто. В Setup после mySerial.begin(9600); 

mySerial.print("\33\122\65");

Дисплей эту настройку не запоминает, поэтому эта команда необходима каждый раз при подаче питания. А вот почему всё скачет в первой строке пока не разобрался

mySerial.print("\33\122\65");

спасибо большое, попробую

  //*************   ВЫВОД ЛОГОТИПА НА ДИСПЛЕЙ  ***************************************
          // mySerial.print("\4\1\120\61\27");    //Для VFD DSP850  (КОМАНД FIRICH) Установка курсора в начало дисплея  (домой)
          // mySerial.print("\13");               //Для VFD-2300  (ESC-кодовая система) Установка курсора в начало дисплея  (домой)
             mySerial.print("\15");               //Для BA-63  (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 прикол 

Теперь заставка выводится корректно, а в основном режиме всё равно всё дёргается. ищу причину

mySerial.print("\33\122\65");

заставка и сейчас заработала, единственное что перед фразой "текстовые часы" пишет "Р1".

при переходе к режиму часов:

- верхняя строка пустая

- на второй всё чётко.

Но есть момент. Хаотичное мерцание в верхней строке букв по одиночке или по две, три. При чём буквы мерцающие буквы повторяют нижнюю строку

У меня тоже самое

  //*************   ВЫВОД ЛОГОТИПА НА ДИСПЛЕЙ  ***************************************
          // mySerial.print("\4\1\120\61\27");    //Для VFD DSP850  (КОМАНД FIRICH) Установка курсора в начало дисплея  (домой)
          // mySerial.print("\13");               //Для VFD-2300  (ESC-кодовая система) Установка курсора в начало дисплея  (домой)
             mySerial.print("\15");               //Для BA-63  (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 прикол 

Теперь корректно: "Р1" в начале логотипа исчезла, видимо мусор.

в коде

 // mySerial.print("\4\1\120\61\27");    //Для VFD DSP850  (КОМАНД FIRICH) Установка курсора в начало дисплея  (домой)
          // mySerial.print("\13");               //Для VFD-2300  (ESC-кодовая система) Установка курсора в начало дисплея  (домой)

Встречается три раза. везде поменял. Ничего не изменилось

Это не мусор в коде, а команда для дисплея другого типа. Должна быть активна одна, остальные закомментированы

https://radiokot.ru/forum/viewtopic.php?f=66&t=183038&start=0

вот тут некто OlegRu пишет про точно такой же дисплей (насколько я понял).

Мой вариант подключения:

перемычку J3 надо замкнуть.

Скорость по умолчанию будет 9600.

Микрухи выпаивать не надо !!! ), подключаемся к CN3 (это нераспаянные пины около центрального разъема

1. RX платы дисплея = TX от ардуино (в моем случае от D6)

2. - пустой

3 +12В

4. 0В - земля

Строка инициализации будет = SoftwareSerial vfd(255, 6, 1); //это для выхода с пина D6

Завтра ещё раз попробую. С указанных пинов CN3 - билиберда

Знатная ересь!!!  Перемычка J3 отвечает за отключение контроля чётности, то есть её действительно надо замкнуть. За скорость передачи отвечают J1 и J2. Если разомкнуты скорость 9600. Здесь ничего трогать не надо. На плате около процессора есть пятаки с подписями, один из них RXD. Здесь вопросов возникнуть не должно. Микросхему интерфейса RS232 можно не трогать, но лучше снять, или поднять ей девятую лапку

подпаялся к пятаку возле процессора, ногу/микросхему не поднимал, J3 замкнул

https://github.com/MrTransistorsChannel/NixdorfVFD

А вот это вещь правильная

Я извиняюсь за задержку ответа. Сообщение принял не дома. Попав домой достал отобранные две недели назад у товарища свои часы и прошил в них скетч из поста и всё у меня работает как надо!

Товарищ возил часы в машине и ни разу не включил, зато пошарпал конкретно! Так что извиняюсь за их вид!

Хотел вставить видео загрузки но не  смог(((

видимо платы с дисплеями разные. фото платы нет?

Это DSP850. Там другие команды. С BA-63 будем дальше работать.

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

Текстовые часы от kaskaqep с заточкой под дисплей Nixdorf BA-63

#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);
    mySerial.print("\33\122\65");

{
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.print("\e[1;1H");               //Для BA-63  (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 = "     " + stringFour + " " + stringSix + "     ";  break;
    case 1:  stringFour =  ReadPZU(Odna); stringSix =  ReadPZU(Minuta); stringMin = "    " + stringFour + " " + stringSix + "     ";  break;
    case 2:  stringFour =  ReadPZU(Dve); stringSix =  ReadPZU(Minuty); stringMin = "     " + stringFour + " " + stringSix + "     ";  break;
    case 3:  stringFour =  ReadPZU(_3); stringSix =  ReadPZU(Minuty); stringMin = "     " + stringFour + " " + stringSix + "     ";  break;
    case 4:  stringFour =  ReadPZU(_4); stringSix =  ReadPZU(Minuty); stringMin = "   " + stringFour + " " + stringSix + "    ";  break;
    case 5:  stringFour =  ReadPZU(_5); stringSix =  ReadPZU(Minut); stringMin = "     " + stringFour + " " + stringSix + "     ";  break;
    case 6:  stringFour =  ReadPZU(_6); stringSix =  ReadPZU(Minut); stringMin = "    " + stringFour + " " + stringSix + "     ";  break;
    case 7:  stringFour =  ReadPZU(_7); stringSix =  ReadPZU(Minut); stringMin = "     " + stringFour + " " + stringSix + "     ";  break;
    case 8:  stringFour =  ReadPZU(_8); stringSix =  ReadPZU(Minut); stringMin = "    " + stringFour + " " + stringSix + "    ";  break;
    case 9:  stringFour =  ReadPZU(_9); stringSix =  ReadPZU(Minut); stringMin = "    " + stringFour + " " + stringSix + "    ";  break;
    case 10:  stringFour =  ReadPZU(_10); stringSix =  ReadPZU(Minut); stringMin = "    " + stringFour + " " + stringSix + "    ";  break;
    case 11:  stringFour =  ReadPZU(_11); stringSix =  ReadPZU(Minut); stringMin = " " + stringFour + " " + stringSix + "  ";  break;
    case 12:  stringFour =  ReadPZU(_12); stringSix =  ReadPZU(Minut); stringMin = "  " + stringFour + " " + stringSix + "  ";  break;
    case 13:  stringFour =  ReadPZU(_13); stringSix =  ReadPZU(Minut); stringMin = "  " + stringFour + " " + stringSix + "  ";  break;
    case 14:  stringFour =  ReadPZU(_14); stringSix =  ReadPZU(Minut); stringMin = " " + stringFour + " " + stringSix + " ";  break;
    case 15:  stringFour =  ReadPZU(_15); stringSix =  ReadPZU(Minut); stringMin = "  " + stringFour + " " + stringSix + "  ";  break;
    case 16:  stringFour =  ReadPZU(_16); stringSix =  ReadPZU(Minut); stringMin = " " + stringFour + " " + stringSix + "  ";  break;
    case 17:  stringFour =  ReadPZU(_17); stringSix =  ReadPZU(Minut); stringMin = "  " + stringFour + " " + stringSix + "  ";  break;
    case 18:  stringFour =  ReadPZU(_18); stringSix =  ReadPZU(Minut); stringMin = " " + stringFour + " " + stringSix + " ";  break;
    case 19:  stringFour =  ReadPZU(_19); stringSix =  ReadPZU(Minut); stringMin = " " + stringFour + " " + stringSix + " ";  break;
    case 20:  stringFour =  ReadPZU(_20); stringSix =  ReadPZU(Minut); stringMin = "   " + stringFour + " " + stringSix + "   ";  break;
    case 21:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(Odna);stringSix =  ReadPZU(Minuta); stringMin = stringFour + " " + stringFive + " " + stringSix;  break;
    case 22:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(Dve);stringSix =  ReadPZU(Minuty); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 23:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_3);stringSix =  ReadPZU(Minuty); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 24:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_4);stringSix =  ReadPZU(Min); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 25:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_5);stringSix =  ReadPZU(Minut); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 26:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_6);stringSix =  ReadPZU(Minut); stringMin = stringFour + " " + stringFive + " " + stringSix;  break;
    case 27:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_7);stringSix =  ReadPZU(Minut); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 28:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_8);stringSix =  ReadPZU(Min); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 29:  stringFour =  ReadPZU(_20); stringFive =  ReadPZU(_9);stringSix =  ReadPZU(Min); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 30:  stringFour =  ReadPZU(_30); stringSix =  ReadPZU(Minut); stringMin = "   " + stringFour + " " + stringSix + "   ";  break;
    case 31:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(Odna);stringSix =  ReadPZU(Minuta); stringMin = stringFour + " " + stringFive + " " + stringSix;  break;
    case 32:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(Dve);stringSix =  ReadPZU(Minuty); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 33:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_3);stringSix =  ReadPZU(Minuty); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 34:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_4);stringSix =  ReadPZU(Min); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 35:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_5);stringSix =  ReadPZU(Minut); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 36:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_6);stringSix =  ReadPZU(Minut); stringMin = stringFour + " " + stringFive + " " + stringSix;  break;
    case 37:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_7);stringSix =  ReadPZU(Minut); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 38:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_8);stringSix =  ReadPZU(Min); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 39:  stringFour =  ReadPZU(_30); stringFive =  ReadPZU(_9);stringSix =  ReadPZU(Min); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 40:  stringFour =  ReadPZU(_40); stringSix =  ReadPZU(Minut); stringMin = "    " + stringFour + " " + stringSix + "     ";  break;
    case 41:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(Odna);stringSix =  ReadPZU(Minuta); stringMin = " " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 42:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(Dve);stringSix =  ReadPZU(Minuty); stringMin = "  " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 43:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_3);stringSix =  ReadPZU(Minuty); stringMin = "  " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 44:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_4);stringSix =  ReadPZU(Minuty); stringMin = stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 45:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_5);stringSix =  ReadPZU(Minut); stringMin = "  " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 46:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_6);stringSix =  ReadPZU(Minut); stringMin = " " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 47:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_7);stringSix =  ReadPZU(Minut); stringMin = "  " + stringFour + " " + stringFive + " " + stringSix + "  ";  break;
    case 48:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_8);stringSix =  ReadPZU(Minut); stringMin = " " + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 49:  stringFour =  ReadPZU(_40); stringFive =  ReadPZU(_9);stringSix =  ReadPZU(Minut); stringMin = " " + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 50:  stringFour =  ReadPZU(_50); stringSix =  ReadPZU(Minut); stringMin = "  " + stringFour + " " + stringSix + "   ";  break;
    case 51:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(Odna);stringSix =  ReadPZU(Min); stringMin = " " + stringFour + " " + stringFive + " " + stringSix + " ";  break;
    case 52:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(Dve);stringSix =  ReadPZU(Minuty); stringMin = stringFour + " " + stringFive + " " + stringSix;  break;
    case 53:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_3);stringSix =  ReadPZU(Minuty); stringMin = stringFour + " " + stringFive + " " + stringSix;  break;
    case 54:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_4);stringSix =  ReadPZU(Min); stringMin = stringFour + " " + stringFive + " " + stringSix;  break;
    case 55:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_5);stringSix =  ReadPZU(Minut); stringMin = stringFour + " " + stringFive + " " + stringSix;  break;
    case 56:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_6);stringSix =  ReadPZU(Min); stringMin = stringFour + " " + stringFive + " " + stringSix  + " ";  break;
    case 57:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_7);stringSix =  ReadPZU(Minut); stringMin = stringFour + " " + stringFive + " " + stringSix;  break;
    case 58:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_8);stringSix =  ReadPZU(Min); stringMin = stringFour + " " + stringFive + " " + stringSix;  break;
    case 59:  stringFour =  ReadPZU(_50); stringFive =  ReadPZU(_9);stringSix =  ReadPZU(Min); stringMin = 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("\e[1;1H");               //Для BA-63  (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" + 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("\e[1;1H");               //Для BA-63  (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("\e[1;1H");               //Для BA-63  (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 ;
}
//****************************************************************************

 без перемычек?

J3 установлена, просто с другой стороны

кнопка как я понимаю на минус?

сейчас пробую прошиться

Да, кнопка с D2 на минус. Пищалка на D8

devICEpro золотой Вы человек. Спасибо kackaqep

разбираюсь с управлением проводом. 

Спасибо огромное, devICEpro!!

Обнаружил что некоторые пиксели битые: выгоревшие наверно.

А за свой код мне всё равно неудобно, больно "кривой"((

Спасибо.

корявый или нет, но работает и без гребёнок кнопок

Это была чуть ли не главная цель моей писанины.

Код не кривой, он просто не для этого дисплея. Так всегда бывает. Универсальная версия получается далеко не с третьего раза ( Это я про версию 3.1)

теперь прикручивать "пора бухать", флешки...

Есть ещё готовые платы, может кому надо, пишите.

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

просто красота. сколько ж такие стоят. связывался с китаем: всё что больше 100х100 мм цена ого.

есть два дисплея USB. чуть ли не на выкид

Покажи

http://img.radiokot.ru/files/42906/medium/1j8rkkxzo8.JPG

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

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

Сами колбы целые? При подаче питания что-нибудь пишет?

целые, тесты проходили при включении

Это главное. Остальное дело техники.

Есть вот такой дисп. Никто не пробовал подключить? https://img.radiokot.ru/files/43023/2z71a9mur0.jpeg

А как тут личные сообщения отправлять, а то мож платку прикупил? Сижу с телефона не совсем удобно. 

Такое не попадалось. Подключать через RxD. Предварительно искать мануал с описанием команд.