Stab-STM32/lib/stab/stab.c

//Регулятор ТЭНа полуволнами с программным детектором нуля
//--https://github.com/JohnJohnov/Stab-avr
//--https://alcodistillers.ru/forum/viewtopic.php?id=1549
//--JohnJohnov-----------------------
//--использован код OldBean----------
//--v0.2-------------------
//--добавлен дисплей
//--v0.3-------------------
//--ПИД-подстройка частоты сети по переходу через ноль
//--опрос кнопок
//--режим разгона
//--v0.4-------------------
//--выборки набираются за целое количество периодов
//--v0.5-------------------
//--оптимизация
//--v0.6-------------------
//--организована корректная обработка отсутствия сети
//--v0.7-------------------
//--исправлена ошибка выставления мощности менее 200Вт
//--битовые переменные упакованы в структуры
//--убрано ненужное мерцание символов на дисплее
//--добавлена возможность вернуть установленную мощность после экстренного отключения (идея d.styler)
//--v0.8-------------------
//--менюшка при возвращении уст.мощности после экстр.откл.
//--v0.81------------------
//--сделано выравнивание значений по правому краю
//--перекомпонован дежурный экран
//--выводится установленная мощность в Вт и процентах
//--напряжение сети выводится с одним знаком после запятой
//--v0.9-------------------
//--оптимизация кода
//--переход на более другую библиотеку дисплея
//--русский шрифт
//--номинальная мощность устанавливается/записывается/выбирается в начальном меню
//--уставки, выбираемые в меню после экстр.откл., могут быть записаны в EEPROM
//--v0.95------------------
//--исправлены ошибки
//--значение задержки для защиты от дребезга вынесено в дефайны
//--v0.96------------------
//--исправлены ошибки, оптимизирован код
//--расширены границы диапазона сетевой частоты для поддержки канадского коллеги
//--добавлена поддержка универсального протокола общения с управляющей программой
//--v0.97------------------
//--добавлена поддержка протокола общения с Samovar (начало посылки кириллицей)
//--добавлено моргание светодиода в отладочных целях
//--добавлен таймаут менюшек
//--добавлена поддержка протокола общения с РМВ-К
//--логотип
//--оптимизация кода
//--v0.98------------------
//--добавлен альтернативный интерфейс с большими символами для опытных пользователей
//--изменена работа с EEPROM
//--повышена точность регулировки (до 0,2%)
//--оптимизация кода
//--v0.98.4----------------
//--оптимизация кода
//--уменьшение размера кода для поддержки ATmega168
//--добавлено отключение разгона внешним сигналом
//--добавлено аварийное отключение нагрузки внешним сигналом
//--работа с портами организована через регистры без использования ардуиновских функций
//--v0.99.1----------------
//--готуємось до заміни дісплея. видаляємо все зайве.
//--
//--
//-------------------------
#include "ch.h"
#include "hal.h"
#include "stab.h"
//
#define VERSION "v0.99"   // Версия скетча
#define VERSION_LEN 5     // Длина версии скетча в символах для правильного вывода на дисплей
//
static uint16_t Pnom;             // Номинальная мощность ТЭНа (хранится в EEPROM и устанавливается из менюшки)
//const uint8_t ARRAY_SIZE = max(Pnom_ARR_SIZE,PDMset_ARR_SIZE);
static uint16_t PDMset[2][ARRAY_SIZE] = {};  // Массив уставок мощности ТЭНа с адресами
static uint16_t (&Pnom_arr)[ARRAY_SIZE] = PDMset[0];  // Массив мощностей ТЭНа как ссылка на нулевую строку массива уставок
//
// В EEPROM хранятся значения номинальных мощностей ТЭНа (каждая занимает 2 байта, количество определяется величиной Pnom_ARR_SIZE)
// и уставки мощности для каждой номинальной в формате pdm (каждая занимает 2 байта),
// уставки пишутся не в конкретные ячейки, а по кругу до заполнения выделенного участка EEPROM.
// Так сделано для экономии ресурса EEPROM
static volatile uint16_t old_addr = 0;    // Адрес в EEPROM, где записана самая старая уставка
static volatile uint16_t new_addr;        // Адрес в EEPROM, куда писать новую уставку
static uint16_t start_addr;               // Начальный адрес области записи уставок в EEPROM
static uint16_t end_addr;                 // Конечный адрес области записи уставок в EEPROM
static volatile uint16_t clear_old_addr;  // Дубль адреса в EEPROM, где записана самая старая уставка, предназначенная для стирания
//
static volatile uint32_t sum;         // Сумматор квадратов отсчетов АЦП
static volatile uint16_t sc = 0;      // Счетчик просуммированных квадратов
static volatile uint16_t sc_sum = 0;  // Счетчик просуммированных квадратов, готовый к обработке
static volatile uint16_t Pust = 0;    // Установленная мощность ТЭНа
static volatile uint16_t pdm = 0;     // Текущий уровень PDM (принимает значения от 0 до CICLE)
static volatile int32_t pdm_err = 0;  // Ошибка дискретизации
static volatile uint16_t PDMust = 0;  // PDM, соответствующий установленной мощности ТЭНа
//
static volatile uint32_t U_sum = 0;   // Среднеквадратичное в сети за секунду, умноженное на 10
static uint16_t U_real = U_LINE;      // Среднеквадратичное за секунду (целая часть)
static uint8_t U_real_dec = 0;        // Среднеквадратичное за секунду (дробная часть)
//
static volatile uint8_t PID_ust = LINE_FREQ;// Данные для установки регистра сравнения таймера2
//
// Организуем флаги и индикаторы в структуру
static volatile struct flags {  // Флаги
  unsigned  dspRefresh : 1;   // Флаг выхода из режима меню / полного обновления экрана
  unsigned  dspTimeout : 1;   // Флаг истечения времени ожидания выхода из меню
  unsigned  dspNewData : 1;   // Флаг обновления данных на экране
  unsigned  PP : 1;           // Флаг полупериода сети на входе АЦП (отрицательная полуволна = 0, положительная = 1)
  unsigned  PP_fir : 1;       // Флаг полупериода после КИХ ФНЧ (отрицательная полуволна = 0, положительная = 1)
  unsigned  PP_tm : 1;        // Флаг полупериода по внутреннему таймеру (отрицательная полуволна = 0, положительная = 1)
  unsigned  zero : 1;         // Флаг перехода через ноль
  unsigned  NotZero : 1;      // Флаг аварии сети (не детектируются переходы через ноль)
  unsigned  sum : 1;          // Флаг готовности насуммированных данных к обработке
  unsigned  Tout : 1;         // Флаг включения ТЭНа (твердотельное реле)
  unsigned  TRelay : 1;       // Флаг включения ТЭНа (контактное реле)
  unsigned  Ulow : 1;         // Флаг невозможности выдать установленный уровень мощности
  unsigned  Udown : 1;        // Флаг аварии сети (действующее напряжение ниже 100В)
  unsigned  razg : 1;         // Флаг режима "разгон"
  unsigned  razg_on : 1;      // Флаг начала режима "разгон"
  unsigned  razg_off : 1;     // Флаг останова режима "разгон"
  unsigned  stab_off : 1;     // Флаг аварийного останова стабилизатора
  unsigned  butt : 1;         // Флаг опроса кнопок
  unsigned  writable : 1;     // Флаг записи уставок в EEPROM
  unsigned  uartUnhold : 1;   // Флаг разрешения передачи данных по USART
  unsigned  uartReport : 1;   // Флаг разрешения отправки данных внешнему контроллеру
  unsigned  uartTimeout : 1;  // Флаг истечения времени приема посылки по USART
} fl = {};  // Инициализируем структуру с нулевыми членами
//
//static uint8_t fl_A;  // Байт флажков A
//static uint8_t fl_B;  // Байт флажков B
//static uint8_t fl_C;  // Байт флажков C
//#define flA_dspRefresh  B00000001
//#define flA_dspTimeout  B00000010
//#define flA_dspNewData  B00000100
//#define flA_uartUnhold  B00001000
//#define flA_uartReport  B00010000
//#define flA_uartTimeout B00100000
//#define flA_writable    B01000000
//#define flA_butt        B10000000
//
static uint8_t cnt_Pnom_count;  // Количество предустановок мощности
static uint8_t cnt_Pnom_number; // Номер активной предустановки мощности
static uint8_t cnt_PDMcount;    // Счетчик для перебора уставок мощности ТЭНа
//
static uint8_t cnt_menuWDT;     // Счетчик секунд для организации отсчета ожидания выхода из меню
static uint8_t cnt_dspMenu;     // Индикатор режима меню
//
uint8_t X_position (const byte x, const uint16_t arg = 0, const byte pix = 6); // Функция возвращает начальную позицию по Х для десятичного числа, в зависимости от количества знаков в нём.
uint8_t X_centred (const byte len); // Функция возвращает начальную позицию по Х для текста длинной len знаков, для размещения оного по центру дисплея.
uint8_t A_to_HEX (const char a);    // Функция переводит символ ASCII в шестнадцатиричную цифру
char HEX_to_A (const byte x);       // Функция переводит шестнадцатиричную цифру в символ ASCII
uint16_t calc_proportion(const uint16_t multiplier1, const uint16_t multiplier2 = Pnom, const uint32_t divider = CICLE);
//
//
//==============================================================================
//============================ПРОЦЕДУРЫ И ФУНКЦИИ===============================
//==============================================================================
//
//=======Функции для работы с флагами================
//== fl_A(BC) - байт с флажками
//== flag - нулевой байт с единицей на месте нужного флажка
//void set_flag_A(const uint8_t flag) {
//  fl_A |= flag;
//}
////
//void clr_flag_A(const uint8_t flag) {
//  fl_A &= ~flag;
//}
////
//boolean check_flag_A(const uint8_t flag) {
//  return (fl_A && flag)? true : false;
//}
//
// Функция возвращает начальную позицию по Х для десятичного числа, в зависимости от количества знаков в нём.
uint8_t X_position (const byte x, const uint16_t arg, const byte pix) { // arg-выводимое число; х-позиция для arg, если бы оно было однозначно; pix - ширина шрифта в пикселях
  //  byte pix = 6; // Ширина шрифта в пикселях
  if (arg < 10) {
    return pix * x;
  } else if (arg < 100) {
    return pix * (x-1);
  } else if (arg < 1000) {
    return pix * (x-2);
  } else {
    return pix * (x-3);
  }
}
//
// Функция возвращает начальную позицию по Х для текста длинной len знаков, для размещения оного по центру дисплея.
uint8_t X_centred (const byte len) { // len - Количество знакомест в тексте
  byte wdt = 128; // Ширина дисплея в пикселях
  byte pix = 6;   // Ширина шрифта в пикселях
  if (len > wdt/pix) return 0;
  else return (wdt - (len * pix))/2;
}
//
// Функция переводит символ ASCII в шестнадцатиричную цифру, при ошибке возвращает 255
uint8_t A_to_HEX (const char a) { // a - символ 0...F
  if (a >= 48 && a <= 57) { // Если а - от 0 до 9
    return byte(a-48);
  } else if (a >= 65 && a <= 70) { // Если а - от A до F
    return byte(a-55);
  } else if (a >= 97 && a <= 102) { // Если а - от a до f
    return byte(a-87);
  } else {
    return 255;
  }
}
//
// Функция переводит шестнадцатиричную цифру в символ ASCII, при ошибке возвращает X
char HEX_to_A (const byte x) {  // x - число, кое необходимо перевести в ASCII-код
  if (x <= 9) {
    return char(x + 48);
  } else if (x <= 15) {
    return char(x + 55);
  } else {
    return 'X';
  }
}
//
void stop_razgon(void) {  //===========Подпрограммка остановки режима "Разгон"================
  fl.razg_on = 0; //выключим режим разгона
  fl.TRelay  = 0; //выключим контактное реле
}
//
//===========Подпрограммка подсчета Pust================
void set_Pust(void) {
  Pust = calc_proportion(PDMust);
} //===========Подпрограммка подсчета Pust(конец)================
//
//=========Функция пропорционального пересчета параметра================
//== Возвращает значение параметра с округлением,
//== пересчитанное из пропорции по формуле
//== (multiplier1 * multiplier2 / divider)
//==
//== multiplier1 - первый множитель
//== multiplier2 - второй множитель (по умолчанию Pnom)
//== divider - делитель (по умолчанию CICLE)
//
uint16_t calc_proportion(const uint16_t multiplier1, const uint16_t multiplier2, const uint32_t divider) {
  uint32_t p;
  p = (long)multiplier1 * 2;
  p *= (long)multiplier2;
  p /= divider;
  p ++;
  p /= 2;
  return (uint16_t)p;
} //=========Функция пропорционального пересчета параметра(конец)================
//
void pp_Delay(const uint16_t pp) {  //===Пауза, измеряется в полупериодах=====
  uint16_t  PPcount = 0;  // счетчик полупериодов
  boolean PP_tm_last = 0;
  while (PPcount < pp) {
    //if (fl.PP_sint) {
    //  PPcount++;
    //  fl.PP_sint = 0;
    //}
    if (PP_tm_last != fl.PP_tm) {
      PPcount++;
      PP_tm_last = fl.PP_tm;
    }
  }
}
//
#ifdef USE_USART//++++++++++++++++USART initialization++++++++++++++++++++++++++++
//Если задействовано управление регулятором ТЭНа через UART, инициализируем оный
//
void USART_start(void) {
  Serial.begin(9600, SERIAL_8N1); // Инициализируем USART
#ifdef Debug
  Serial.println("Started");
#endif
}
//
uint16_t get_Power(void) {  // Функция возвращает значение текущей мощности с учетом режима "Разгон"
  if (fl.stab_off || fl.Udown || fl.NotZero) {  // Если авария или сеть в дауне - передаем ноль
    return 0;
  }
  else if (fl.razg_on || fl.Ulow) { // В разгоне и при недостаточном сетевом передаем расчетную текущую мощность
    uint32_t tmp_u = (long)U_sum * U_sum;
    tmp_u /= 100;
    tmp_u *= Pnom;
    tmp_u /= U_LINE_Q;
    return tmp_u;
  }
  else {                            // В рабочем режиме - передаем уставку
    return Pust;
  }
}
//
void set_newPDM(uint16_t power) { // Функция установки текущей мощности по запросу
  if (power >= Pnom) {  // Если параметр превышает максимально возможное значение,
    PDMust = CICLE; // значит ставим максимально возможное значение.
  }
  else {
    PDMust = calc_proportion(power, CICLE, Pnom);
  }
  //
  set_Pust();    // Пересчитаем Pust
  fl.dspNewData = 1;  // Обновление информации на дисплее
}
//
#endif // USE_USART
//
#ifdef USE_ADprotocol //++++++++++++++++USART++++++++++++++++++++++++++++
//
//Байт "состав данных" b00010111 (основной параметр - мощность в нагрузке, доп. параметр - напряжение сети) в HEX-формате 0x17
static char USART_InfoData[14] = {'T','1','7','0','0','0','0','0','0','0','0','0','0',0x0D};  // Массив готовых данных для передачи внешнему контроллеру
static char USART_SetData[6];  // Массив управляющих символов от внешнего контроллера
//
void USART_parser(void) { // Парсим управляющую последовательность по универсальному протоколу
  //
  static byte index = 0;
  static byte data_size;
  //
  while (Serial.available() > 0) {
    if (fl.stab_off) {
      Serial.read(); // Вычитываем очередной байт, чтобы не засирать буфер
    }
    else if ( !index || fl.uartTimeout ) {   // Начало
      USART_SetData[0] = Serial.read(); // Вычитываем очередной байт
      fl.uartTimeout = 0;               // Сбросим флаг таймаута ожидания окончания посылки
      cnt_uartWDT = 0;                  // Сбросим таймер ожидания окончания посылки
      switch ( USART_SetData[0] ) {     // Ждём первый символ...
      case 'M':
      case 'm': {                     // ...запроса на изменение режима работы
        data_size = 2;
        index=1;
        break;
      }
      case 'P':
      case 'p': {                     // ...запроса на изменение уставки
        data_size = 5;
        index=1;
        break;
      }
      default: {
        //          break;
      }
      }
    }
    else {
      USART_SetData[index] = Serial.read(); // Вычитываем очередной байт
      if ( USART_SetData[index] == 0x0D ) { // Ждем последнего символа посылки <CR>
        if ( index == data_size ) {
          switch (index) {
          case 2: { // Парсим запрос на смену режима
            switch ( USART_SetData[1] ) {
            case '0': { // Переход в рабочий режим
              if ( fl.razg_on ) {
                stop_razgon();
              }
              break;
            }
            case '1': { // Переход в режим разгона
              if ((!fl.NotZero) & (!fl.Udown) & (!fl.razg_off)) {  // Если электросеть в дауне или разгон запрещен - не разгонишься
                fl.razg_on = 1;
                fl.razg = 1;
              }
              break;
            }
            case '2': { // Отключение нагрузки
              PDMust = 0;
              stop_razgon();
              Pust = 0;
              break;
            }
            default: {
              break;
            }
            }
            break;
          }
          case 5: { // Парсим запрос на смену уставки
            uint16_t tmp_p = 0;
            byte b;
            for (byte x=1; x <= 4; x++ ) {
              tmp_p *= 16;
              b = A_to_HEX (USART_SetData[x]);
              if (b == 255) {
                break;
              }
              tmp_p += b;
            }
            if (b != 255) {
              set_newPDM (tmp_p);   // Установим новую уставку мощности;
            }
            break;
          }
          }
          index = 0;
          fl.dspNewData = 1;  //Обновление информации на дисплее
        }
        else index = 0;
      }
      else if ( index++ == data_size ) {
        index = 0;
      }
    }
  }
}
//
void USART_report(void) { //=====Отчет внешнему контроллеру по универсальному протоколу=====
  uint16_t b;
  //
  if (fl.stab_off) {
    b = 3;  // b000000(11) - аварийное отключение нагрузки (удаленное включение невозможно)
  }
  else if (fl.Udown || fl.NotZero) {
    b = 6;  // b000001(10) - отсутствие сетевого напряжения, нагрузка отключена
  }
  else if (fl.razg_on) {
    b = 1;  // b(000000)(01) - разгон
  }
  else if (PDMust == 0) {
    b = 2;  // b000000(10) - нагрузка отключена
  }
  else if (fl.Ulow) {
    b = 8;   // b000010(00) - напряжения сети недостаточно для достижения уставки
  }
  else {
    b = 0;  // b000000(00) - режим рабочий, ошибок нет
  }
  // Закодируем состав данных
  USART_InfoData[3] = HEX_to_A ( b / 16 );  // Старший разряд байта "Режим + ошибки"
  USART_InfoData[4] = HEX_to_A ( b % 16 );  // Младший разряд байта "Режим + ошибки"
  //
  // Закодируем основной параметр - мощность на выходе
  b = get_Power();  // Получим текущую мощщу
  USART_InfoData[8] = HEX_to_A ( b % 16 );  // 0 разряд основного параметра
  b /= 16;
  USART_InfoData[7] = HEX_to_A ( b % 16 );  // 1 разряд основного параметра
  b /= 16;
  USART_InfoData[6] = HEX_to_A ( b % 16 );  // 2 разряд основного параметра
  USART_InfoData[5] = HEX_to_A ( b / 16 );  // 3 разряд основного параметра
  //
  // Закодируем доп.параметр - напряжение сети
  if (fl.NotZero) { // Если сети нет, то и на выходе пусто
    USART_InfoData[12] = '0'; // 0 разряд основного параметра
    USART_InfoData[11] = '0'; // 1 разряд основного параметра
    USART_InfoData[10] = '0'; // 2 разряд основного параметра
    USART_InfoData[9]  = '0'; // 3 разряд основного параметра
  }
  else {
    b = U_sum;
    USART_InfoData[12] = HEX_to_A ( b % 16 ); // 0 разряд основного параметра
    b /= 16;
    USART_InfoData[11] = HEX_to_A ( b % 16 ); // 1 разряд основного параметра
    b /= 16;
    USART_InfoData[10] = HEX_to_A ( b % 16 ); // 2 разряд основного параметра
    USART_InfoData[9]  = HEX_to_A ( b / 16 ); // 3 разряд основного параметра
  }
  // Отправим
  Serial.write(USART_InfoData, 14);
}
//
#endif  //+++++++++++++++++++++++USART++++++++++++++++++++++++++++
//
#ifdef USE_RMVK //++++++++++++++++RMVK_/_Samovar++++++++++++++++++++++++++++
uint16_t get_Uin(void) {     // Функция возвращает значение текущего напряжения без десятичного знака
  return ((U_real_dec < 5)? U_real : (U_real + 1));
}
//
uint16_t get_Uout(const boolean getReal) {  // Функция возвращает расчетное значение текущего (если getReal=true) или желаемого (если getReal=false) напряжения
  if ( fl.Udown || fl.NotZero || (PDMust == 0) ) {    // Если сеть в дауне или стаб в стопе - передаем ноль
    return 0;
  }
  else if ( getReal && ( fl.razg_on || fl.Ulow ) ) {  // В разгоне и при недостаточном сетевом передаем текущее сетевое, если надо
    return get_Uin();
  }
  else {    // В рабочем режиме - передаем уставку
    return calc_proportion(PDMust, U_LINE);
  }
}
//
void USART_parser(void) { // Парсим управляющую последовательность от RMVK_/_Samovar
  //
  static String inoutString;
  static byte index = 0;
  //
  while (Serial.available() > 0) {
    char inChar = (char)Serial.read();// Вычитываем очередной байт
    if ( !index || fl.uartTimeout ) { // Начало посылки
      if ((inChar == 'A') || (byte(inChar) == 0xD0)) { // Ждём первый символ посылки "A" или первый байт UTF-кириллицы из протокола Samovar'a
        inoutString = inChar;
        index=1;
        fl.uartTimeout = 0; // Сбросим флаг таймаута ожидания окончания посылки
        cnt_uartWDT = 0;    // Сбросим таймер ожидания окончания посылки
      }
    }
    else if ( index++ < 13 ) {  // Пока посылка не длиннее 13 символов, считаем её корректной
      if ( inChar == 0x0D ) {   // Ждем последнего символа посылки <CR>
        index = 0;
        // Парсим строку, поскольку кончилась
        // В протоколе Samovar стандартное начало посылки "АТ" пересылается русскими символами в Юникоде. Баг или фича?
        if (( inoutString == ("AT+VI?")) ||  // Запрос текущего напряжения сети
            ( inoutString == ("АТ+VI?"))) {  // В этой строке "АТ" - русскими символами!
          if (fl.NotZero) { // Если сети нет, то и на выходе пусто
            inoutString = String(0);
          }
          else {
            inoutString = String(get_Uin());
          }
        }
        else if (( inoutString == F("АТ+VO?")) || ( inoutString == F("АТ+VS?"))) {  // Запрос текущей мощности от Samovar. В этой строке "АТ" - русскими символами!
          inoutString = String(get_Power());
        }
        else if ( inoutString == F("AT+VO?") ) {  // Запрос текущего напряжения на выходе от РМВ-К
          inoutString = String(get_Uout(true));
        }
        else if ( inoutString == F("AT+VS?") ) {  // Запрос напряжения уставки на выходе от РМВ-К
          inoutString = String(get_Uout(false));
        }
        else if ( inoutString == F("AT+ON?") ) {  // Запрос состояния выхода от РМВ-К
          if ((PDMust == 0) || (fl.NotZero) || (fl.Udown)) {  // Если на выходе 0
            inoutString = String("OFF");
          }
          else {
            inoutString = String("ON");
          }
        }
        else if (( inoutString == F("AT+SS?")) ||   // Запрос режима от Samovar
                 ( inoutString == F("АТ+SS?"))) {    // В этой строке "АТ" - русскими символами!
          if (fl.stab_off || fl.Udown || fl.NotZero) {  // При аварии, сильно пониженном напряжении сети или его отсутствии - передаем ошибку
            inoutString = String(3);
          }
          else if (fl.razg_on) {            // Передаем "Разгон"
            inoutString = String(1);
          }
          else if (PDMust == 0) {           // Передаем "Стоп"
            inoutString = String(2);
          }
          else {                            // Передаем "Рабочий режим"
            inoutString = String(0);
          }
        }
        else if (( inoutString == F("AT+ON=0")) ||  // Запрос на выключение стабилизатора
                 ( inoutString == F("АТ+ON=0"))) {   // В этой строке "АТ" - русскими символами!
          if (!fl.stab_off) {  // Если стаб не выключен аварийно...
            PDMust = 0;
            stop_razgon();
            Pust = 0;
            fl.dspNewData = 1;  //Обновление информации на дисплее
            inoutString = "";
          }
        }
        else if (( inoutString == F("AT+ON=1")) ||  // Запрос на включение режима "Разгон"
                 ( inoutString == F("АТ+ON=1"))) {   // В этой строке "АТ" - русскими символами!
          if ((!fl.stab_off) && (!fl.NotZero) && (!fl.Udown) && (!fl.razg_off)) {  // Если авария, электросеть в дауне или разгон запрещен - не разгонишься
            fl.razg_on = 1;
            fl.razg = 1;
            fl.dspNewData = 1;  //Обновление информации на дисплее
          }
          inoutString = "";
        }
        else if ( inoutString.substring(0,8) == F("АТ+VS=") ) {  // Запрос на изменение уставки от Samovar. В этой строке "АТ" - русскими символами!
          if (!fl.stab_off) {  // Если стаб не выключен аварийно...
            //выключаем разгон, на всякий случай
            stop_razgon();
            set_newPDM (inoutString.substring(8).toInt());        // Установим новую уставку мощности
            inoutString = "";
          }
        }
        else if ( inoutString.substring(0,6) == F("AT+VS=") ) { // Запрос на изменение уставки от РМВ-К
          if (fl.stab_off || fl.Udown || fl.NotZero) {  // Если авария или сеть в дауне - ничего не меняем, передаем ошибку
            inoutString = String(F("error"));
          }
          else {
            uint16_t tmp_u = inoutString.substring(6).toInt();
            if ( tmp_u < U_LINE ) {
              tmp_u *= CICLE;
              PDMust = tmp_u / U_LINE;
            }
            else PDMust = CICLE;
            //выключаем разгон, на всякий случай
            stop_razgon();
            set_Pust();         // Посчитаем Pust
            fl.dspNewData = 1;  // Обновление информации на дисплее
            inoutString = String(get_Uout(false));
          }
        }
        else {  // Неизвестная или закосяченная команда
#ifdef Debug
          inoutString = String(F("(o_O unknown!)"));
#else
          inoutString = "";
#endif
        }
        //
        if ( inoutString != "" )  {       // Если строка не пустая
          inoutString += char(0x0D);    // Добавляем в конец <CR>
          Serial.print( inoutString );  // Шлём!
        }
      }
      else {  // Еще не конец
        inoutString += inChar;  // Добавляем и это лыко в строку
      }
    }
    else {  // Посылка длинновата, а значит - некорректна, начинаем сначала
      index = 0;
    }
  }
}
#endif  //+++++++++++++++++++++++RMVK_/_Samovar++++++++++++++++++++++++++++
//
//-------------------------------------------------------------------------
//===========Подпрограмма запоминания последней уставки====================
//== Проверяет последнюю уставку на совпадение с уже записанными в массив уставок
//== и запоминает, если надо
//
void remember_last_power_setting(void) {  // Запомним последнюю уставку
  boolean isnew = 1;
  for (int8_t x = PDMset_ARR_SIZE - 1; x >= 0; x--) {  // Проверим новое значение на совпадение с уже записанными
    if (PDMust == PDMset[0][x]) {
      isnew = 0;
      break;
    }
  }
  if (isnew) { // Если новое значение действительно новое, то...
    PDMset[0][PDMset_ARR_SIZE - 1] = PDMust;  //Запоминаем текущую мощность ТЭНа
    PDMset[1][PDMset_ARR_SIZE - 1] = 0;       //Адрес зануляем на всякий случай
    cnt_PDMcount = PDMset_ARR_SIZE - 1;       //Ставим счетчик на запомненную уставку
  }
}
//
//===========Подпрограмма запоминания последней уставки(конец)=============
//-------------------------------------------------------------------------
//===========Подпрограмма обмена двух ячеек массива========================
//== arr - массив
//== index - индекс первого измерения обмениваемых ячеек
//== index1 - индех второго измерения первой обмениваемой ячейки
//== index2 - индех второго измерения второй обмениваемой ячейки
//
// change_arr_cell(arr, index, index1, index2)
//
void change_arr_cell(uint16_t arr[2][ARRAY_SIZE], const uint8_t index, const uint8_t index1, const uint8_t index2) {
  uint16_t k = arr[index][index1];
  arr[index][index1] = arr[index][index2];// Обмениваемся
  arr[index][index2] = k;
}
//===========Подпрограмма обмена двух ячеек массива(конец)=================
//-------------------------------------------------------------------------
//===========Подпрограмма чтения начальных данных из EEPROM================
void EEPROM_read_Pnoms(void) {
  //
  uint8_t idx;
  uint16_t value;
  for (idx = 0; idx < Pnom_ARR_SIZE; idx++) {
    EEPROM.get((idx * 2),value);
    if ((value < 10000) && value) { // Если значение корректно, пишем его в массив
        Pnom_arr[idx] = value;
    } else { // если нет - уходим.
      break;
    }
  }
  cnt_Pnom_count = idx;
  Pnom = Pnom_arr[0]; // По умолчанию установим номинальную мощность из первой ячейки
}
//===========Подпрограмма чтения начальных данных из EEPROM(конец)=========
//-------------------------------------------------------------------------
//===========Функция чтения непустых ячеек из EEPROM=======================
//== возвращает количество прочитанных ячеек
//== val_arr - массив значений с адресами
//== addr_arr - массив адресов
//== count - счетчик значений
//== start_addr - начальный адрес
//== end_addr - конечный адрес
//== threshold - пороговое значение счетчика для выхода из цикла
//
// tmpcount += get_noempty_cells(PDMtmp, tmpcount, start_cell, end_cell, (PDMset_ARR_SIZE-2));
//
uint8_t get_noempty_cells(uint16_t val_arr[2][ARRAY_SIZE], const uint8_t count, const uint16_t start_cell, const uint16_t end_cell, const uint8_t threshold) {
  uint16_t addr;
  uint16_t value;
  uint8_t idx = count;
  for (addr = start_cell; addr <= end_cell; addr += 2) { // Почитаем из области для записи уставок в EEPROM, начиная с конца
    EEPROM.get(addr,value);
    if ((value <= CICLE) && value) {      // Если считанное значение корректное, то
      val_arr[0][idx] = value;         // запишем его в массив
      val_arr[1][idx] = addr;          // и туда же запишем адрес значения в памяти EEPROM
      if (++idx > threshold) {
        break; // Закончим, заполнив массив
      }
    }
  }
  return idx;
}
//===========Функция чтения непустых ячеек из EEPROM(конец)=============
//
void EEPROM_read_PDMs(void) { //===========Подпрограмма чтения уставок из EEPROM для выбранной Pnom================
  //
  uint16_t PDMtmp[2][ARRAY_SIZE] = {};
  uint8_t tmpcount = 0;
  uint16_t addr;
  uint16_t value;
  ////===Заполним массив уставок какими-то значениями
  //
  value = CICLE / PDMset_ARR_SIZE;
  for (uint8_t idx=0; idx < PDMset_ARR_SIZE - 1; idx++) {
    PDMset[0][idx] = (long)value * (idx + 1);
  }
  PDMset[0][PDMset_ARR_SIZE - 1] = CICLE;
  //
  ////===Определим границы области для записи уставок
  //
  addr = (EEPROM.length() - SRVDATA_ARR_SIZE - 2 * Pnom_ARR_SIZE)/(Pnom_ARR_SIZE);  // Размер области для записи уставок в EEPROM
  if (addr & 1) {
    addr--; // Округлим до четного вниз, чтобы влезало целое количество двухбайтовых слов
  }
  start_addr = Pnom_ARR_SIZE * 2 + cnt_Pnom_number * addr;  // Начальный адрес области
  end_addr = start_addr + addr - 2;             // Конечный адрес области
  //
  //---Дальше пытаемся читать запомненные значения, они должны быть расположены подряд---
  //
  uint16_t read_region_end_addr = end_addr; // Адрес ячейки, на которой чтение можно окончить
  EEPROM.get(end_addr,value);               // Прочтем последнюю ячейку области
  if ((value <= CICLE) && value) {          // Если считанное значение корректное, то читаем из конца области
    read_region_end_addr = start_addr + 2 * ((PDMset_ARR_SIZE - 2) - 1);  // На 3 меньше, потому что одно значение уже есть, как минимум, другое в память не пишется, ну и размер на единицу больше наибольшего индекса, Так-то!
    tmpcount = get_noempty_cells(PDMtmp, 0, (end_addr - 2 * (PDMset_ARR_SIZE-2)), end_addr, (PDMset_ARR_SIZE-2));
  }
  if (tmpcount < PDMset_ARR_SIZE - 1) {         // Проверим массив уставок на заполненность и если не полон, то читаем дальше
    tmpcount += get_noempty_cells(PDMtmp, tmpcount, start_addr, read_region_end_addr, (PDMset_ARR_SIZE-2));
  }
  //
  //---Прочитали---
  //
  if (tmpcount) { // Если записанные уставки есть, то...
    tmpcount--;   // Декрементируем счетчик, чтобы индексы начинались с нуля
    new_addr = PDMtmp[1][tmpcount] + 2;                   // Адрес для записи новой уставки...
    //new_addr += 2;
    if (new_addr > end_addr) {
      new_addr = start_addr; // на единицу больше адреса последней считанной, но не больше границы области
    }
    if (tmpcount == PDMset_ARR_SIZE-2) {  // Если массив полон
      old_addr = PDMtmp[1][0]; // то адрес самой старой уставки в нулевой ячейке
    }
    { // Уберем дублирующиеся значения
      uint8_t PDMdiff[PDMset_ARR_SIZE] = {0};   // Заведем временный массив совпадений
      for (uint8_t i = 0; i < PDMset_ARR_SIZE; i++) {   // Пробежимся по обоим массивам
        for (uint8_t j = 0; j <= tmpcount; j++) {
          if (PDMset[0][i] == PDMtmp[0][j]) {
            PDMdiff[i] = 1; // И заполним массив совпадений
          }
        }
      }
      for (uint8_t i = 0; i < PDMset_ARR_SIZE - 1; i++) { // Сортируем
        for (uint8_t j = i + 1; j < PDMset_ARR_SIZE; j++) {
          if (PDMdiff[j]) {  // Если в данной позиции есть совпадение
            change_arr_cell(PDMset, 0, i, j);
            PDMdiff[j] = PDMdiff[i];
            break;
          }
        }
      }
    }
    for (uint8_t i = 0; i <= tmpcount; i++) { // Допишем в рабочий массив считанное из EEPROM
      PDMset[0][i] = PDMtmp[0][i];
      PDMset[1][i] = PDMtmp[1][i];
    }
  }
  else {          // Записанных уставок нет
    new_addr = start_addr;  // Адрес для записи новой уставки равен начальному
  }
}//===========Подпрограмма чтения уставок из EEPROM для выбранной Pnom================
//
void ADC_init(void) { //===============Инициализация АЦП===================
  ADMUX = 0;
  ADMUX |= ( 1 << REFS0); // Задаем ИОН равный напряжению питания
  ADMUX |= 0;             // Выбираем пин A0 для преобразования
  ADCSRA |= (1 << ADPS2 ) | (1 << ADPS1) | (1 << ADPS0); // предделитель на 128
  ADCSRA |= (1 << ADIE);  // Разрешаем прерывания по завершении преобразования
  ADCSRA |= (1 << ADEN);  // Включаем АЦП
}//================================Инициализация АЦП===================
//
void Timers_init(void) { //===============Инициализация таймеров===================
  //---Инициализация таймера 0 для тактирования АЦП -------------
  TCCR0A = 0;
  TCCR0B = 0;
  TCCR0A |= (1 << WGM01); // Счетчик работает в режиме CTC (сброс по совпадению)
  TCCR0B |= (1 << CS01) | (1 << CS00); // Предделитель на 64 (на счетчик - 250 кГц)
  OCR0A = T_ADC; // Определяет период запуска АЦП
  TIMSK0 |= (1 << OCIE0A); // Разрешаем прерывания по совпадению с OCR0A
  // Инициализация таймера 2 для формирования импульса нуля Zero
  TCCR2A = 0;
  TCCR2B = 0;
  TCCR2A |= (1 << WGM21); // Счетчик работает в режиме CTC (сброс по совпадению)
  TCCR2B |= (1 << CS22) | (1 << CS21) | (1 << CS20); // Предделитель на 1024 (сч. - 15.625 кГц/64мкс)
  OCR2A = LINE_FREQ; // Прерывание с удвоенной частотой сети
  TIMSK2 |= (1 << OCIE2A); // Разрешаем прерывания по совпадению с OCR2A
}//=================================Инициализация таймеров===================
//
void Pins_init(void) { //======Инициализация входов/выходов контроллера=========
#ifdef DisplayReset
  pin_OLEDres_INIT;
  pin_OLEDres_LOW;  // Сбрасываем дисплей (!!! НЕ ЗАБЫТЬ ПЕРЕКЛЮЧИТЬ НА ВЫСОКИЙ !!!) TODO!
#endif
  pin_RAZGON_OFF_INIT;
  pin_STAB_OFF_INIT;
  //
  pin_TOut_INIT;
  pin_TRelay_INIT;
  TURN_RELAY_OFF; // Выключаем ТЭН (контактное реле)
  TURN_SSR_OFF;   // Выключаем ТЭН (твердотельное реле)
  //
  // pin_buttGND_INIT; // !!!
  //
  pin_butt_1_INIT;
  pin_butt_2_INIT;
  pin_butt_3_INIT;
  pin_butt_4_INIT;
  //
  //
}//========================Инициализация входов/выходов контроллера=========
//
void Razgon_(void) { //===========Подпрограмма обработки режима разгона================
  ////===Обеспечивает шунтирование контактов контактного реле
  ////===симистором твердотельного
  ////===в момент включения/выключения режима "Разгон"
  ////===
#define RELAY_SHUNTING_TIME 50      // количество полупериодов, в течение которых шунтируются контакты реле
  static uint8_t cnt_P_relay=0;       // Счетчик полупериодов шунтирования контактного реле
  if (fl.razg_on &&                 // Если включен разгон..
      !fl.TRelay &&                 // ..и НЕ включено контактное реле
      (++cnt_P_relay == RELAY_SHUNTING_TIME)) { // ..и все это длится уже более 500мс,
    fl.TRelay = 1;
    cnt_P_relay = 0; // то включим контактное реле и обнулим счетчик
  }
  if (fl.razg &&                    // Если включен максимум для твердотельного реле..
      !fl.razg_on &&                // ..и выключен разгон
      (++cnt_P_relay == RELAY_SHUNTING_TIME)) { // ..и все это длится уже более 500мс,
    fl.razg = 0;
    cnt_P_relay = 0;   // то выключим реле и обнулим счетчик
  }
}//===========Подпрограмма обработки режима разгона================
//
void PDM_(void) { //===========Подпрограмма управления твердотельным реле ТЭНа================
  if (fl.razg) {
    pdm = CICLE; // В режиме разгона твердотельное всегда открыто
  }
  static int8_t ps = 0;     // Текущее значение постоянной составляющей
  int32_t lev = pdm + pdm_err;    // Текущий уровень с учетом ошибки дискретизации, сделанной на предыдущем полупериоде.
  //Текущее значение постоянной составляющей
  if (fl.PP_tm) {
    if (fl.Tout) {
      ps--;
    }
  } else {
    if (fl.Tout) {
      ps++;
    }
  }
  //
  if ((lev >= CICLE/2) && ((ps == 0) || (fl.PP_tm && (ps < 0)) || (!fl.PP_tm && (ps > 0)))) { // Ставим флаг включения ТЭНа с учетом значения постоянной составляющей
    fl.Tout = 1;
    pdm_err = lev - CICLE;         // и считаем ошибку для следующего полупериода
  } else {
    fl.Tout = 0;
    pdm_err = lev;                 // Снимаем флаг включения ТЭНа и считаем ошибку
  }
}//========================Подпрограмма управления твердотельным реле ТЭНа================
//
void Buttons_(void) { //==============Опрос кнопок=====================
  static uint8_t butt = 0;       // код текущей нажатой кнопки
  static uint8_t last_butt = 0;  // код предыдущей нажатой кнопки
  static struct buttons {
    unsigned butt_1 : 1;    // текущее состояние кнопки (0 - не нажата)
    unsigned butt_2 : 1;    // текущее состояние кнопки
    unsigned butt_3 : 1;    // текущее состояние кнопки
    unsigned butt_4 : 1;    // текущее состояние кнопки
    unsigned no_select : 1; // вспомогательный флажок для начального меню
    unsigned writePnom : 1; // вспомогательный флажок записи нового Pnom в EEPROM
    unsigned clear_old : 1; // вспомогательный флажок стирания старой уставки из EEPROM
  } bt = {}; // Инициализируем структуру с нулевыми членами
  static uint8_t butt_count = 0;        // счетчик для устранения дребезга
  static uint8_t butt_force_count = 0;  // счетчик для форсирования инкремента/декремента
  //
  if (bt.clear_old) { //=====Стираем старую уставку, если нужно
    eeprom_update_word((uint16_t*)clear_old_addr,EMPTY_CELL_VALUE);    // Стираем самую старую уставку
    bt.clear_old = 0;                                     // Снимаем флажок стирания
  }
  //
  bt.butt_1 = pin_butt_1_STATE;
  bt.butt_2 = pin_butt_2_STATE;
  bt.butt_3 = pin_butt_3_STATE;
  bt.butt_4 = pin_butt_4_STATE;
  //
  uint8_t button_sum = bt.butt_1 + bt.butt_2 + bt.butt_3 + bt.butt_4;
  if ((button_sum == 0) && butt_force_count) {
    butt_force_count--; // уменьшаем счетчик форсирования инкремента/декремента
  }
  if ( button_sum == fl.butt ) { // Или нажата одна кнопка или ни одной
    butt = bt.butt_1 + (bt.butt_2 << 1) + (bt.butt_3 << 2) + (bt.butt_4 << 3);
    if ( butt == last_butt ) {
      butt_count++;
    } else {
      butt_count = 1;
      last_butt = butt;
    }
  } else if (--butt_count < 1) {
    butt_count = 1;
  }
  //
  if ( (butt_count == DEBOUNCE) || fl.dspTimeout ) {  // Есть нажатая кнопка или достаточная пауза после нажатия или таймаут выхода из меню
    if (!fl.stab_off) { // Если нет аварийного останова...
      switch (cnt_dspMenu) { //=====Проверяем режимы меню
      case 2:  {  //=============Если мы в начальном меню выбора номинальной мощности, то...
        if (fl.dspTimeout) {                  // Если кнопки слишком долго не нажимались...
          if (Pnom_arr[0] != 0xffff) {        // и есть записанное значение, уходим
            cnt_Pnom_number = 0;              //
            Pnom = Pnom_arr[0]; // По умолчанию установим номинальную мощность из нулевой ячейки
            fl.writable = 1;                  // Уставки пишутся в EERPOM
            EEPROM_read_PDMs();               // Читаем уставки
            fl.uartUnhold = 1;                // Разрешим обращение к USART
            cnt_dspMenu = 0;                   // Выйдем из менюшки
            fl.dspRefresh = 1;                // Ставим флаг обновления экрана
          }
          fl.dspTimeout = 0;                  // Снимаем флаг таймаута выхода из меню
          break;
        }
        switch (butt) {
        case 1: { //-----Кнопкой "P-" перебираем записанные значения или уменьшаем значение Pnom
          if (bt.no_select) { //Если не выбираем, а вводим значение,...
            if (butt_force_count > 20) {      // Если очень долго держим...
              if (Pnom > 100) {
                Pnom -= 100;    // Убавляем по соточке, пока есть куда
              } else {
                butt_force_count = 10;     // Если некуда убавлять - снижаем форсаж
              }
            }
            else if (butt_force_count > 10) { // Если долго держим...
              if (Pnom > 10) {
                  Pnom -= 10;      // Убавляем по десяточке, пока есть куда
              } else {
                butt_force_count = 0;      // Если некуда убавлять - снижаем форсаж
              }
            } else {
              if (--Pnom == 0) {
                Pnom=1;        // Убавляем по чуть-чуть
              }
            }
          }
          else {  //Если выбираем из записанных в EEPROM...
            if (++cnt_PDMcount > cnt_Pnom_count) {
              cnt_PDMcount=0; // Перебираем значения уставок мощности ТЭНа
            }
            Pnom = Pnom_arr[cnt_PDMcount];
          }
          butt_force_count++;
          break;                      //Закончили
        }
        case 2: { //-----Кнопкой "P+" увеличиваем значение Pnom
          if (butt_force_count > 20) {
            if ((Pnom += 100) > 9999) {
              Pnom=9999;// Если очень долго держим, прибавляем по соточке
            }
          } else if (butt_force_count > 10) {
            if ((Pnom += 10) > 9999) {
              Pnom=9999; // Если долго держим, прибавляем по десяточке
            }
          } else {
            if (++Pnom > 9999) {
              Pnom=9999;       // Прибавляем по чуть-чуть
            }
          }
          bt.no_select = 1;
          butt_force_count++;
          break;                      //Закончили
        }
        case 4: { //-----Кнопкой "Стоп" пишем значение в память и выходим из менюшки
          bt.writePnom = 1; // Ставим флаг записи нового значения Pnom в EEPROM
          fl.writable = 1;  // Ставим флаг записи уставок в EEPROM
        }
        case 8: { //-----Кнопкой "Разгон" выходим из менюшки
          if (Pnom < 10000) { // Если значение реальное...
            cnt_Pnom_number = cnt_PDMcount;               // Запомним порядковый номер выбранного Pnom
            if (bt.no_select) {                           // Если значение НЕ выбрано из записанных в EEPROM, а введено...
              for (int8_t x = cnt_Pnom_count; x >= 0; x--) { // Проверим новое значение на совпадение с уже записанными
                if (Pnom == Pnom_arr[x]) {                // Если такое значение уже есть в EEPROM...
                  cnt_Pnom_number = x;                    // Запомним порядковый номер совпавшего Pnom
                  bt.writePnom = 0;                       // Снимем флаг записи нового значения Pnom в EEPROM
                  fl.writable = 1;                        // Ставим флаг записи уставок в EEPROM
                  break;
                }
              }
            } else {                                        // Если значение выбрано из записанных в EEPROM...
              bt.writePnom = 0;                           // Снимем флаг записи нового значения Pnom в EEPROM
              fl.writable = 1;                            // Ставим флаг записи уставок в EEPROM
            }
            //
            cnt_PDMcount=0;                               //Сбрасываем счетчик
            //
            if (fl.writable) {                            // Если уставки пишутся в EERPOM, то
              EEPROM_read_PDMs();                         // читаем ранее записанное
            }
            if (bt.writePnom) {   // Запишем новое значение Pnom, если необходимо
              eeprom_update_word((uint16_t*)(cnt_Pnom_number * 2),Pnom);
              bt.writePnom = 0; // и сбросим флаг записи нового значения Pnom
            }
            cnt_dspMenu = 0;     // Снимаем флаг перехода в меню
            //
#ifdef USE_USART      //========================================
            fl.uartUnhold = 1;  // Разрешим обращение к USART
#endif                //========================================
            fl.dspRefresh = 1;  // Ставим флаг обновления экрана
          }
          fl.butt = 0;        // После нажатия должна быть пауза
          break;              // Закончили
        }
        default:
          fl.butt = 1;        // достаточная пауза между нажатиями
        }
        break;
      }
      case 1:  {  //=============Если мы в меню выбора уставки, то...
        if (fl.dspTimeout) {  // Если кнопки слишком долго не нажимались, уходим
          cnt_dspMenu = 0;     // Выйдем из менюшки
          fl.dspRefresh = 1;  // Ставим флаг обновления экрана
          fl.dspTimeout = 0;  // Снимаем флаг таймаута выхода из меню
          break;
        }
        switch (butt) {
        case 1: { //=====По кнопке "Р-" перебираем значения
          if (++cnt_PDMcount > PDMset_ARR_SIZE - 1) {
            cnt_PDMcount=0; //Перебираем значения уставок мощности ТЭНа
          }
          //          fl.butt = 0;            //После нажатия должна быть пауза
          break;                    //Закончили
        }
        case 2: { //=====По кнопке "Р+" перебираем значения
          if (cnt_PDMcount-- == 0) {
            cnt_PDMcount=PDMset_ARR_SIZE - 1;//Перебираем значения уставок мощности ТЭНа
          }
          //          fl.butt = 0;            //После нажатия должна быть пауза
          break;                    //Закончили
        }
        case 4: { //=====По кнопке "стоп" записываем уставку, если нужно, принимаем и выходим
          PDMust = PDMset[0][cnt_PDMcount];//Устанавливаем выбранную мощность ТЭНа
          if (fl.writable) {  // Если уставки запоминаются...
            if (!PDMset[1][cnt_PDMcount]) { // Если просят записать НЕ уже записанное...
              eeprom_update_word((uint16_t*)new_addr,PDMset[0][cnt_PDMcount]); // Пишем новую уставку
              PDMset[1][cnt_PDMcount] = new_addr; // Заносим в массив адрес свежезаписанной уставки
              new_addr += 2;
              if (new_addr > end_addr) {
                new_addr = start_addr; // Инкрементируем адрес для новой уставки и следим, чтобы не выходило за границы области
              }
              if (cnt_PDMcount == PDMset_ARR_SIZE - 1) {  // Если новое значение - последнее в списке
                //
                if (!old_addr) {  // Если в массиве уставок есть незаписанные в EEPROM значения, то сначала стираем их
                  boolean swapped = 1;
                  uint8_t upper_index = PDMset_ARR_SIZE - 1; //=====Пузырьковая сортировка
                  while (swapped) {                                       // Пока есть обмены, сортируем
                    swapped = 0;
                    for (uint8_t i = 1; i < upper_index; i++) {
                      if (PDMset[1][i] < PDMset[1][i - 1]) {
                        change_arr_cell(PDMset, 0, i, i - 1);
                        change_arr_cell(PDMset, 1, i, i - 1);
                        swapped = 1;
                      }
                    }
                    upper_index --;
                  } //=====Закончили сортировку
                  old_addr = PDMset[1][0];  // Обновляем адрес самой старой уставки
                }
                //
                if (old_addr) {           // Если в массиве уставок все значения записаны в EEPROM, то стираем самое старое
                  bt.clear_old = 1;       // Ставим флажок стирания (сотрём в следующий вызов подпрограммы опроса кнопок)
                  clear_old_addr = old_addr; // Плодим сущности без устали!
                }
                //
                uint16_t k = PDMset[0][0];
                for (uint8_t x = 0; x < PDMset_ARR_SIZE - 1; x++) { // Сдвинем массив
                  PDMset[0][x] = PDMset[0][x + 1];
                  PDMset[1][x] = PDMset[1][x + 1];
                }
                //
                PDMset[0][PDMset_ARR_SIZE - 1] = k; // Запишем во временную ячейку свежеудаленное значение
                PDMset[1][PDMset_ARR_SIZE - 1] = 0;
                cnt_PDMcount --;
                old_addr = PDMset[1][0];    // Обновляем адрес самой старой уставки
                //
              }
            }
          }
          cnt_dspMenu = 0;           //Снимаем флаг перехода в меню
          fl.dspRefresh = 1;        //Ставим флаг обновления экрана
          fl.butt = 0;              //После нажатия должна быть пауза
          break;                    //Закончили
        }
        case 8: { //=====По кнопке "разгон" принимаем и выходим
          PDMust = PDMset[0][cnt_PDMcount];//Устанавливаем выбранную мощность ТЭНа
          cnt_dspMenu = 0;           //Снимаем флаг перехода в меню
          fl.dspRefresh = 1;        //Ставим флаг обновления экрана
          fl.butt = 0;              //После нажатия должна быть пауза
          break;                    //Закончили
        }
        default:
          fl.butt = 1;              // достаточная пауза между нажатиями
        }
        break;
      }
      default: {  //=============А если не в меню, то...
        switch (butt) {
        case 1:
          if (PDMust-- == 0) {
            PDMust = 0; //Уменьшаем установленную мощность до минимума
          }
          break;
        case 2:
          if (++PDMust > CICLE) {
            PDMust = CICLE; //Увеличиваем установленную мощность до максимума
          }
          break;
        case 4:
          if (PDMust == 0) {    //Если мы не в меню и мощность ТЭНа нулевая, то...
            cnt_dspMenu = 1;     //Ставим флаг перехода в меню
            fl.dspRefresh = 1;  //Ставим флаг обновления экрана
          } else {                //Если мы не в меню и мощность ТЭНа НЕнулевая, то...
            remember_last_power_setting();// Запомним последнюю уставку
            PDMust = 0;                   // Экстренно выключим ТЭН
            stop_razgon();                // Остановим разгон
          }
          fl.butt = 0;          //После нажатия должна быть пауза
          break;
        case 8:
          fl.razg_on = ((!fl.NotZero) & (!fl.Udown) & (!fl.razg_off) & (!fl.razg_on)); //Триггер режима разгона (гистерезис организован в обработке начала полупериода)
          fl.razg |= fl.razg_on;                      //Если разгон включили, то твердотельное реле на максимум сразу
          fl.TRelay &= fl.razg_on;                    //Если разгон выключили, то контактное реле выключаем сразу
          fl.butt = 0;                                //После нажатия должна быть пауза
          break;
        default:
          fl.butt = 1;  // достаточная пауза между нажатиями
        }
      }
      }
    }
    //
    if (butt) {  // Если нажата кнопка,
      cnt_menuWDT = 0;  // сбросим таймер ожидания выхода из меню
      fl.stab_off = 0;  // и сбросим флажок аварийного останова
    }
    butt_count = 1;
    butt = 0;
    set_Pust();         // Пересчитаем Pust
    fl.dspNewData = 1;  //Обновление информации на дисплее
  }
  //
  if (pin_STAB_OFF_STATE && !fl.stab_off) { // Если есть сигнал аварийного останова
    if (PDMust) { // Если уставка ненулевая...
      remember_last_power_setting();// Запомним последнюю уставку
      PDMust = 0;                   // Экстренно выключим ТЭН
      Pust = 0;                     // Пересчитаем Pust
    }
    stop_razgon();    // Остановим разгон
    fl.dspNewData = 1;//Обновление информации на дисплее
    fl.stab_off = 1;  // Поставим соответствующий флажок
  } else {
    fl.razg_off = pin_RAZGON_OFF_STATE; // Прочитаем состояние вывода отключения разгона
    if (fl.razg_off && fl.razg_on) {  // Если разгон и есть внешний сигнал останова разгона...
      fl.dspNewData = 1;  //Обновление информации на дисплее
      stop_razgon();  // остановим разгон
    }
  }
  //
} //================================Опрос кнопок=====================
//
ISR(TIMER2_COMPA_vect) { //======Обработчик начала очередного полупериода по таймеру2=========
  //
  Razgon_();
  if (pdm) {
    PDM_();
  } else {
    fl.Tout = 0;    // Не будем зря теребить подпрограмму, если pdm = 0
    //pdm_err = 0;  // и обнулим ошибку дискретизации (а нужно ли?) TODO!
  }
  //
  fl.PP_tm = !fl.PP_tm; // Инвертируем флаг полуволны
  OCR2A = PID_ust;    // Грузим новое значение в регистр сравнения
  //
  fl.Tout ? TURN_SSR_ON : TURN_SSR_OFF ;  // Включаем или выключаем ТЭН (твердотельное реле)
  fl.TRelay ? TURN_RELAY_ON : TURN_RELAY_OFF ;  // Включаем или выключаем ТЭН (контактное реле)
  //
  sei(); // разрешим прерывания
  // Считаем время
  static uint8_t cnt_P_time=0;  // Счетчик полупериодов для организации отсчета времени
  if (++cnt_P_time == P_TIME_MAX) {  // Уже секунду суммируем
    cnt_P_time = 0;
    //fl.dspNewData = 1;  // Раз в секунду не грех обновить дисплей, мало ли...
    if ((cnt_dspMenu > 0) && (++cnt_menuWDT == MENU_TIMEOUT)) { // Если мы в меню и слишком долго не жмутся кнопки
      fl.dspTimeout = 1;                                        // Установим флаг таймаута
      cnt_menuWDT = 0;                                          // Сбросим таймер ожидания выхода из меню
    }
    //
#ifdef USE_USART
    if (++cnt_uartWDT == 10) {  // Если прошло уже 10 секунд от начала приема посылки по USART
      fl.uartTimeout = 1;       // Установим флаг таймаута ожидания окончания посылки
      cnt_uartWDT = 0;          // Сбросим таймер ожидания окончания посылки
    }
#endif
#ifdef USE_ADprotocol
    fl.uartReport = 1;          // пора слать рапорт
#endif
    //
  }
  //
  Buttons_();   // Опрашиваем кнопки

}//==============================Обработчик начала очередного полупериода по таймеру2=========
//------------------------------------------------------------------------------
ISR(TIMER0_COMPA_vect) { //======Обработчик запуска преобразования АЦП по таймеру0=========
  ADCSRA |=  (1 << ADSC); // Запуск преобразования
}//==============================Обработчик запуска преобразования АЦП по таймеру0=========
//------------------------------------------------------------------------------
ISR(ADC_vect) { //===============Обработчик окончания преобразования АЦП===================
  static uint8_t TM2_current;
  static int16_t Ufir = 0;           // Буферная переменная для НЧ-фильтрации
  static int16_t Udelta = 0;         // Буферная переменная для НЧ-фильтрации
  {
    int16_t U_adc;
    uint8_t TM2_tmp;
    TM2_tmp = TCNT2;  // забрали значение из таймера синхронизации с сетью
    U_adc = ADCL;
    U_adc += ADCH << 8; // забрали результат преобразования АЦП
    U_adc -= U_ZERO;  // Убираем постоянную составляющую из оцифрованного сигнала
    { //===Суммирование квадратов=======================================
      sum += (long)U_adc * U_adc; // Возводим в квадрат выборку АЦП и суммируем с предыдущими
      ++ sc;     // Счетчик выборок АЦП
    }//===Суммирование квадратов=======================================
    //
    //===детекция перехода через ноль и ПИД-синхронизация=================================
    //
    Udelta += (U_adc - Ufir); //
    U_adc = Udelta / 32;      //КИХ ФНЧ 1-го порядка с коэффициентом 1/32
    ////===
    static uint8_t cnt_P_sum = 0;     // Счетчик полупериодов для суммирования отсчетов АЦП
    static uint16_t cnt_notzero = 0;  // Счетчик выборок АЦП без перехода через ноль
    //
    if ((!fl.zero) &&
        (U_adc >= 0) &&
        (Ufir <= 0) &&
        (U_adc != Ufir)) { //=======переход через ноль детектед=======
      cnt_notzero = 0;  // Обнуляем счетчик выборок АЦП без перехода через ноль
      fl.NotZero = 0;   // Снимаем флажок отсутствия детекции перехода через ноль
      //
      if (++cnt_P_sum == PSUM_MAX) { //===Проверка насуммированных отсчетов============================
        U_sum = sum;
        fl.sum = 1;
        sc_sum = sc; // Насуммированное готово к обработке
        sc = 0;
        sum = 0;
        cnt_P_sum = 0;     // Сбрасываем счетчик, сумматор и счетчик полупериодов
      } //===Проверка насуммированных отсчетов============================
      TM2_current = TM2_tmp;  // Запомним значение для дальнейшей обработки
      fl.zero = 1;
    } else { //=======переход через ноль  NOT детектед=======
      fl.zero = 0;
      if (++cnt_notzero == ZSUM_MAX) {  // Насуммировали достаточно
        fl.NotZero = 1;
        cnt_notzero = 0;
        PID_ust = LINE_FREQ;
        stop_razgon();
        pdm = 0;
        fl.Tout = 0; //выключим твердотельное реле
        U_real = 0;
        sc = 0;
        sum = 0;
        cnt_P_sum = 0; // Обнулим счетчик, сумматор, счетчик полупериодов и значение напряжения
        fl.dspNewData = 1;
      }
      //
    }
    //
    Ufir = U_adc;
  }
  //===детекция перехода через ноль и ПИД-синхронизация=================================
  //
  sei(); // Следующие фрагменты длительны, но не требуют атомарности; разрешим прерывания
  //
  if (fl.zero) {//===ПИД-подстройка частоты внутреннего таймера к частоте сети===
    static uint16_t PID_reg = PID_ust << Km;   // Функция управления ПИД
    static int32_t PID_err_old = 0;            // Разность фаз из предыдущего шага
    static int32_t PID_int = 0;                // Интегральная составляющая из предыдущего шага
    int32_t temp_32 = (TM2_current + PHASE) << Km; // Разность фаз
    if (!fl.PP_tm) {
      temp_32 -= PID_reg + (1 << Km);  // Разность фаз должна быть с соответствующим знаком
    }
    PID_int += (temp_32 >> Ki);                 // Считаем интегральную составляющую
    PID_reg += temp_32 >> Kp;                   // Считаем новую функцию управления
    PID_reg += PID_int;
    PID_reg += ( temp_32 - PID_err_old ) >> Kd;
    PID_err_old = temp_32;
    // Готовим данные для записи в регистр сравнения таймера 2
    if ( PID_reg > (T_MAX << Km)) {
      PID_reg = (T_MAX << Km);    // Ограничим сверху
    } else if ( PID_reg < (T_MIN << Km)) {
      PID_reg = (T_MIN << Km);  // Ограничим снизу
    }
    temp_32 = PID_reg >> (Km - 1);// ...и правильно округлим
    temp_32++;                  // используя уже не нужную в этой подпрограмме
    PID_ust = temp_32 / 2;    // переменную temp_32
    //
  }//===ПИД-подстройка частоты внутреннего таймера к частоте сети===
  //
}//===============================Обработчик окончания преобразования АЦП===================
//
//
void RefreshMenu (void) { //===============Подпрограмма обновления меню===================
  ASOled.clearDisplay();
  ASOled.printString_6x8(F("Ст Принять и записать"), 0, 6);
  ASOled.printString_6x8(F("Рз Принять без записи"), 0, 7);
  ASOled.printString_6x8(F("Управление:"), X_position (1), 3);
  ASOled.printString_6x8(F("P- Выбор"), 0, 4);
#ifdef INTERFACE_ALT

#else
  ASOled.printString_6x8(F("Выберите"), 0, 0);
#endif
  //
  switch (cnt_dspMenu) { //=====Проверяем режимы меню
  case 2:  {  //=============Если мы в начальном меню, то...
#ifdef INTERFACE_ALT
    ASOled.printString_6x8(F("В"), X_position (20), 0);
    ASOled.printNumber((long)U_LINE, X_position (16), 0);
    ASOled.printString_6x8(F("Рном=         Вт"), 0, 1);
#else
    ASOled.printString_6x8(F("/введите Рном"), X_position (8), 0);
    ASOled.printString_6x8(F("Рном=      Вт, (   В)"), 0, 1);
    ASOled.printNumber((long)U_LINE, X_position (16), 1);
#endif
    ASOled.printString_6x8(F("==Мощность нагрузки=="), 0, 2);
    ASOled.printString_6x8(F("/уменьшение"), X_position (8), 4);
    ASOled.printString_6x8(F("P+ Увеличение"), 0, 5);
    break;
  }
  //
  case 1:  {  //=============Если мы в меню выбора уставки, то...
#ifdef INTERFACE_ALT
    ASOled.printString_6x8(F("Руст=         Вт"), 0, 1);
#else
    ASOled.printString_6x8(F("уставку"), X_position (9), 0);
    ASOled.printString_6x8(F("Руст=      Вт"), 0, 1);
#endif
    ASOled.printString_6x8(F("=======Уставка======="), 0, 2);
    ASOled.printString_6x8(F("P+ Выбор"), 0, 5);
    if (!fl.writable) {  // Если уставки не пишутся в EEPROM, то...
      ASOled.printString_6x8(F("Ст Принять без записи"), 0, 6);
    }
    break;
  }
  //
  default: {
  }
  }
} //===============Подпрограмма обновления меню===================
//
//==============Подпрограмма печати строки минусов================
//==str - номер строки, куда печатать минуса
//==
void Asoled_printstring_6x8_minus (const uint8_t str) {
  ASOled.printString_6x8(F("---------------------"), 0, str);
}
//===========Подпрограмма печати строки минусов(конец)============
//
void setup(void) {
  //
  cnt_dspMenu = 2; // Сначала - начальное меню
  Pins_init();    // Инициализируем входы/выходы
  ADC_init();     // Инициализируем АЦП
  Timers_init();  // Инициализируем таймеры
  sei();          // Разрешаем глобальные прерывания
  //
  pp_Delay(20);   // Подождем 20 полупериодов
  //
#ifdef DisplayReset
  pin_OLEDres_HIGH; // Разрешаем работу дисплея
#endif
  //
  pp_Delay(10);   // Подождем 10 полупериодов для гарантированного разрешения
  //
  ASOled.init();                        // Инициализируем OLED дисплей
  //ASOled.SetTurnedOrientation();        // Переворачиваем OLED дисплей
  ASOled.clearDisplay();  // Очищаем, иначе некорректно работает для дисплеев на SH1106 (косяк библиотеки)
  ASOled.printString_6x8(F("Стабилизатор мощности"), X_centred (21), 0);
  ASOled.printString_6x8(F("ТЭНа"), X_centred (4), 1);
#ifdef INTERFACE_ALT
  ASOled.printString_12x16(F("STAB-AVR"), X_centred (16), 2);
#else
  ASOled.printString_6x8(F("STAB-AVR"), X_centred (8), 2);
#endif
  ASOled.printString_6x8(F(VERSION), X_centred (VERSION_LEN), 4);
  ASOled.printString_6x8(F("JohnJohnov"), X_centred (10), 6);
  ASOled.printString_6x8(F("alcodistillers.ru"), X_centred (17), 7);
  //
  EEPROM_read_Pnoms();  // Прочитаем из EEPROM записанные номиналы ТЭНов
  //
  pp_Delay(800);        // Подождем 600 полупериодов, пережидаем переходные процессы и любуемся заставкой
  //
  fl.dspRefresh = 1;

#ifdef USE_USART//++++++++++++++++USART initialization++++++++++++++++++++++++++++
  //Если задействовано управление регулятором ТЭНа через UART, инициализируем оный
  //
  USART_start();
  //
#endif // USE_USART
}
//
void loop(void) {
  //
  if (fl.sum) { //==========Обработка данных от АЦП и корректировка выдаваемой мощности============
#ifdef NOT_LM358
    // 0,55 - Коэффициент нормирования ((380/512)^2, 380В максимальное амплитудное) для Rail-to-Rail операционника
    U_sum /= sc_sum;    //Ненормированный квадрат среднеквадратичного
    U_sum *= 0.55;      //Нормированный квадрат среднеквадратичного
#else
    // 3 - Коэффициент нормирования ((380/220)^2, 380В максимальное амплитудное) для стандартно установленного LM358
    U_sum *= 3;         //Нормированная сумма квадратов среднеквадратичного
    U_sum /= sc_sum;    //Нормированный квадрат среднеквадратичного
#endif
    //=====Корректируем pdm
    //    uint32_t tmp; // Величины великоваты, чтобы попасть в размерность приходится считать аккуратно
    //    //    pdm = U_LINE_Q*PDMust/(U_sum);
    //    tmp = (long)U_LINE_Q * 2;
    //    tmp *= (long)PDMust;
    //    tmp /= U_sum;
    //    tmp++;
    //    tmp /= 2;
    //
    uint16_t tmp = calc_proportion(PDMust, U_LINE_Q, U_sum);
    //
    if (tmp > CICLE || fl.razg) { // Следим, чтобы pdm не превышала CICLE
      pdm = CICLE;
      fl.Ulow = !fl.razg; // Или напряжение сети не позволяет выдать установленный уровень мощности, или разгон
    } else {
      fl.Ulow = 0;
      pdm = tmp;
    }

    // Проверяем величину напряжения
    U_sum *= (long)400;               // Произведем некоторое математическое колдунство,
    U_sum = sqrt(U_sum);        // чтобы получить один знак после запятой без float
    U_sum ++;
    U_sum /= 2;    // и с правильным округлением.
    U_real_dec = U_sum % 10;    // Среднеквадратичное (дробная часть)
    U_real = U_sum / 10;        // Среднеквадратичное (целая часть)
    //
    // Контролируем значение
    if ( U_real < U_MIN ) { //Действующее напряжение сети ниже U_MIN - отключим ТЭН (авария)
      fl.Udown = 1;       //поставим флажок низкого сетевого
      stop_razgon();
      pdm = 0;            //выключим твердотельное реле
    } else {
      fl.Udown = 0;
    }
    fl.sum = 0;
    fl.dspNewData = 1;  //Обновление информации на дисплее
  } //======================Обработка данных от АЦП и корректировка выдаваемой мощности============
  //
#ifdef USE_ADprotocol
  if (fl.uartReport && fl.uartUnhold) {  //==========Отправка отчета внешнему контроллеру============
    USART_report();
    fl.uartReport = 0;
  } //=========================Отправка отчета внешнему контроллеру============
#endif
  //
  if (fl.dspNewData) { //========================Вывод информации на дисплей=============
    if (fl.dspRefresh) {
      RefreshMenu(); //Обновляем дисплей, если надо
    }
    //
    switch (cnt_dspMenu) { //=====Проверяем режимы меню
    case 2:  {  //=============Если мы в начальном меню, то...
      static uint16_t Pnomold = 0;
      if (!Pnom || Pnom > 9999) {
        Pnomold = Pnom;
#ifdef INTERFACE_ALT
        ASOled.printString_12x16(F("****"), X_position (3,0,12), 0);
#else
        ASOled.printString_6x8(F("****"), X_position (6), 1);
#endif
      } else if ((Pnomold != Pnom) || fl.dspRefresh) {
        Pnomold = Pnom;
#ifdef INTERFACE_ALT
        ASOled.printString_12x16(F("    "), X_position (3,0,12), 0);
        ASOled.printNumber((long)Pnom, X_position (6,Pnom,12), 0);
#else
        ASOled.printString_6x8(F("    "), X_position (6), 1);
        ASOled.printNumber((long)Pnom, X_position (9,Pnom), 1);
#endif
      }
      fl.dspRefresh = 0;
      break;
    }
    case 1:  {  //=============Если мы в меню выбора уставки, то...
      static uint16_t PDMold = 0;
      if ((PDMold != PDMset[0][cnt_PDMcount]) || fl.dspRefresh) {
        PDMold = PDMset[0][cnt_PDMcount];
        uint16_t p = calc_proportion(PDMold); // Считаем уставку с округлением
#ifdef INTERFACE_ALT
        ASOled.printString_12x16(F("    "), X_position (3,0,12), 0);
        ASOled.printNumber((long)p, X_position (6,p,12), 0);
#else
        ASOled.printString_6x8(F("    "), X_position (6), 1);
        ASOled.printNumber((long)p, X_position (9,p), 1);
#endif
        if (PDMset[1][cnt_PDMcount]) {  // Если значение записано в EEPROM
          ASOled.printString_6x8(F("R"), X_position (20), 1);     // поставим значок
        } else {
          ASOled.printString_6x8(F(" "), X_position (20), 1);   // а если не записано - уберем
        }
      }
      fl.dspRefresh = 0;
      break;
    }
    default: {  //=============А если не в меню, то...
#ifdef INTERFACE_ALT
#define str_Ureal_big 0
#define str_Ureal 1
#define str_ust_big 3
#define str_ust 4
#define str_Ustat 2
#define str_Razgon 5
#define str_Pnom 6
#define str_Relay 7
#else
#define str_Ureal 0
#define str_Ustat 1
#define str_ust 3
#define str_Pnom 6
#define str_Razgon 4
#define str_Relay 7
#endif
      //
      if (fl.dspRefresh) {  //Обновляем дисплей
        ASOled.clearDisplay();
#ifdef INTERFACE_ALT
        ASOled.printString_6x8(F("Вт       ,  %"), X_position (8), str_ust);
#else
        ASOled.printString_6x8(F("Руст      Вт;    ,  %"), 0, str_ust);
#endif
        ASOled.printString_6x8(F("Напр.сети        ,  В"), 0, str_Ureal);
        ASOled.printString_6x8(F("Ном. мощность      Вт"), 0, str_Pnom);
        ASOled.printNumber((long)Pnom, X_position (17,Pnom), str_Pnom);
        //          ASOled.printString_6x8(F("Реле "), X_position (0), str_Relay);
      }
      //
      static uint16_t U_real_old = 0;
      if ((U_real_old != U_real) || fl.dspRefresh) {
        U_real_old = U_real;
#ifdef INTERFACE_ALT
        ASOled.printString_12x16(F("   "), X_position (7,100,12) + 5, str_Ureal_big);
        ASOled.printNumber((long)U_real_old, X_position (7,U_real_old,12) + 5, str_Ureal_big);
#else
        ASOled.printString_6x8(F("    "), X_position (13), str_Ureal);
        ASOled.printNumber((long)U_real_old, X_position (16,U_real_old), str_Ureal);
#endif
      }
      static uint8_t U_real_dec_old = 0;
      if ((U_real_dec_old != U_real_dec) || fl.dspRefresh) {
        U_real_dec_old = U_real_dec;
#ifdef INTERFACE_ALT
        ASOled.printString_12x16(F(" "), X_position (9,0,12), str_Ureal_big);
        ASOled.printNumber((long)U_real_dec_old, X_position (9,0,12), str_Ureal_big);
#else
        ASOled.printNumber((long)U_real_dec_old, X_position (18), str_Ureal);
#endif
      }
      static uint16_t Pust_old = 0;
      if ((Pust_old != Pust) || fl.dspRefresh) {
        Pust_old = Pust;
#ifdef INTERFACE_ALT
        ASOled.printString_12x16(F("    "), 0, str_ust_big);
        ASOled.printNumber((long)Pust_old, X_position (3,Pust_old,12), str_ust_big);
#else
        ASOled.printString_6x8(F("    "), X_position (5), str_ust);
        ASOled.printNumber((long)Pust_old, X_position (8,Pust_old), str_ust);
#endif
      }
      //
      static uint16_t PDMust_old = 0;
      if ((PDMust_old != PDMust) || fl.dspRefresh) {
        PDMust_old = PDMust;
        uint32_t x = 1000*(long)PDMust_old;
        x /= CICLE;
        uint8_t percent = x / 10;    // посчитаем процент
        uint8_t percent_dec = x % 10;// посчитаем десятые процента
#ifdef INTERFACE_ALT
        ASOled.printString_12x16(F("   "), X_position (7,100,12) + 5, str_ust_big);
        ASOled.printNumber((long)(percent), X_position (7,percent,12) + 5, str_ust_big);
        ASOled.printNumber((long)(percent_dec), X_position (9,0,12), str_ust_big);
#else
        ASOled.printString_6x8(F("    "), X_position (13), str_ust);
        ASOled.printNumber((long)(percent), X_position (16,percent), str_ust);
        ASOled.printNumber((long)(percent_dec), X_position (18), str_ust);
#endif
      }
      //
      if (fl.Udown || fl.NotZero) {
        ASOled.printString_6x8(F("-----Авария сети-----"), 0, str_Ustat);
      } else if (fl.Ulow) {
        ASOled.printString_6x8(F("--Недост.напр. сети--"), 0, str_Ustat);
      }
      else {
        Asoled_printstring_6x8_minus(str_Ustat);
      }
      //
      if (fl.razg_on) {
        static uint8_t count_1 = 0;
        uint8_t x1 = 5 - count_1;
        uint8_t x2 = 20 - x1;
        ASOled.printString_6x8(F("------<Разгон!>------"), 0, str_Razgon);
        ASOled.printString_6x8(F("<"), X_position (x1), str_Razgon);
        ASOled.printString_6x8(F(">"), X_position (x2), str_Razgon);
        if (++count_1 > 5) count_1 = 0;
      } else {
        Asoled_printstring_6x8_minus(str_Razgon);
      }
      //
      {
        static uint8_t trigger = 1;
        if (trigger && fl.stab_off) {
          ASOled.printString_6x8(F("!!АВАРИЙНЫЙ ОСТАНОВ!!"), 0, str_Relay);
          trigger = 0;
        } else {
          Asoled_printstring_6x8_minus(str_Relay);
          trigger = 1;
        }
      }
      //
      //        if (fl.TRelay) {
      //          ASOled.printString_6x8(F("включено"), X_position (5), str_Relay);
      //        }
      //        else {
      //          ASOled.printString_6x8(F("        "), X_position (5), str_Relay);
      //        }
      fl.dspRefresh = 0;
    }
    }
    //
    fl.dspNewData = 0;
  }//========================Вывод информации на дисплей=============
  //
#ifdef USE_USART
  if (fl.uartUnhold) {
    USART_parser();
  }
#endif
}
//