src/controls.cpp - main - singlwolf/Radiola-2S3

src/controls.cpp
1 413 строк31 KB
SinglWolf
v1.0.4
07 апр 2026, 08:56
07 апр 2026, 08:563a9f57c
// #include "Arduino.h"
#include "eeStorage.h"
#include "services.h"
#include "controls.h"
#include "audioVS.h"
#include "web_server.h"
#include "RotaryEncoder.h"
#include "OneButton.h"
#include "hardware.h"
#include "screens.h"
#include "actions.h"
#include "lv_i18n.h"
#include "pinout.h"
// #define NO_LED_RECEIVE_FEEDBACK_CODE
#define SEND_PWM_BY_TIMER
// #define DEBUG
#if !defined(STR_HELPER) && !defined(STR)
#define STR_HELPER(x) #x
#define STR(x) STR_HELPER(x)
#endif
// #define DECODE_LG
#define DECODE_NEC
// #define DECODE_SAMSUNG
// #define DECODE_SONY
#define DECODE_RC5
#define DECODE_RC6
#include <IRremote.hpp>
OneButton *button = nullptr;
static bool enc_btn = false;
// Encoder vol acceleration; 0 or 1 means disabled acceleration
#define VOL_ACCELERATION 0

#define BTN_PRESS_TICKS 500
#define BTN_CLICK_TICKS 300

#define ENC_HALFQUARD false
#if ENC_HALFQUARD == false
#define ENCODER_STEPS 4
#elif ENC_HALFQUARD == true
#define ENCODER_STEPS 2
#elif ENC_HALFQUARD == 255
#define ENCODER_STEPS 1
#endif

#define ENC_INTERNALPULLUP true
#define ENC2_INTERNALPULLUP true

#define txtPrintInfo(fmt, ...)    \
  do                              \
  {                               \
    printf(LOG_COLOR_I);          \
    printf(fmt, ##__VA_ARGS__);   \
    printf(LOG_RESET_COLOR "\n"); \
  } while (0)
//
#define txtPrintWarn(fmt, ...)    \
  do                              \
  {                               \
    printf(LOG_COLOR_W);          \
    printf(fmt, ##__VA_ARGS__);   \
    printf(LOG_RESET_COLOR "\n"); \
  } while (0)
//
#define txtPrintError(fmt, ...)   \
  do                              \
  {                               \
    printf(LOG_COLOR_E);          \
    printf(fmt, ##__VA_ARGS__);   \
    printf(LOG_RESET_COLOR "\n"); \
  } while (0)

RotaryEncoder encoder = RotaryEncoder();

int8_t irCodeRepeat = -1;
//
uint32_t IR_Key[KEY_MAX][2] = {{0}};

uint8_t KBD_Btn[BTN_MAX] = {0};

lv_indev_t *kbd_indev = nullptr; // Драйвер клавиатуры
lv_indev_t *ir_indev = nullptr;  // Драйвер ИК-пульта
lv_indev_t *enc_indev = nullptr; // Драйвер энкодера

static bool Mute = false;
static bool MenuON = false;
static bool ExtON = false;

bool openMenu[mMAX] = {false};

void checkMenu(uint8_t numMenu)
{
  if (numMenu != mMAX)
  {
    openMenu[numMenu] = false;
  }
  MenuON = false;
  uint8_t i = 0;
  for (i = mFIRST; i < mMAX; i++)
  {
    if (openMenu[i] == true)
    {
      MenuON = !MenuON;
      break;
    }
  }
}

void ir_read(lv_indev_t *indev, lv_indev_data_t *data);
void kbd_read(lv_indev_t *indev, lv_indev_data_t *data);
void enc_read(lv_indev_t *indev, lv_indev_data_t *data);
//
void menuOnOff(uint8_t num_menu);

uint8_t check_key()
{
  uint32_t IrCode =
      ((uint32_t)IrReceiver.decodedIRData.protocol << 24) |
      ((uint32_t)(IrReceiver.decodedIRData.address >> 4) << 12) |
      (uint32_t)IrReceiver.decodedIRData.command;
  uint8_t i = 0;
  for (i = KEY_FIRST; i < KEY_MAX; i++)
  {
    if (IrCode == IR_Key[i][eeprom.getIRSet()])
      break;
  }
  return i;
}
//
uint8_t check_btn(uint8_t btn_num)
{
  uint8_t i = 0;
  for (i = BTN_FIRST; i < BTN_MAX; i++)
  {
    if (btn_num == KBD_Btn[i])
      break;
  }
  return i;
}
//
// custom ir code init from hardware nvs partition
esp_err_t ir_key_init()
{
  esp_err_t err = ESP_OK;
  memset(IR_Key, 0, sizeof(IR_Key));

  JsonObject obj = IR_KEY.as<JsonObject>();
  uint8_t key_num = 0;

  for (JsonPair p : obj)
  {
    JsonArray arr = p.value().as<JsonArray>();
    uint8_t dev = 0;
    for (JsonVariant v : arr)
    {
      const char *hex_str = v.as<const char *>();
      if (hex_str)
      {
        IR_Key[key_num][dev] = strtoul(hex_str, nullptr, 16);
      }
      dev++;
    }
    key_num++;
  }

  return err;
}
//
// custom ir code init from hardware nvs partition
esp_err_t kbd_btn_init()
{
  esp_err_t err = ESP_OK;
  memset(&KBD_Btn, 0, sizeof(uint8_t) * BTN_MAX);

  JsonObject obj = KBD_BTN.as<JsonObject>();
  uint8_t btn_num = 0;

  for (JsonPair p : obj)
  {
    KBD_Btn[btn_num] = p.value().as<unsigned int>();
    // txtPrintInfo("%s[%u]: %u", p.key().c_str(), btn_num, KBD_Btn[btn_num]);
    btn_num++;
  }

  return err;
}
//

void IRAM_ATTR readEncoderISR()
{
  encoder.readEncoder_ISR();
}

void initControls()
{
  ui_create_groups();
  lv_group_set_default(groups.main);

  ESP_ERROR_CHECK(kbd_btn_init());
  kbd_indev = lv_indev_create(); // Драйвер клавиатуры
  lv_indev_set_type(kbd_indev, LV_INDEV_TYPE_KEYPAD);
  lv_indev_set_read_cb(kbd_indev, kbd_read);

  lv_indev_set_group(kbd_indev, groups.main);

  ////////////////
  ESP_ERROR_CHECK(ir_key_init());
  pinMode(PIN_MODE, OUTPUT);
  IrReceiver.begin(PIN_IR, true, PIN_MODE);
  ir_indev = lv_indev_create(); // Драйвер ИК-пульта
  lv_indev_set_type(ir_indev, LV_INDEV_TYPE_KEYPAD);
  lv_indev_set_read_cb(ir_indev, ir_read);

  lv_indev_set_group(ir_indev, groups.main);
  //
  button = new OneButton(PIN_ENC_BTN, true, ENC_INTERNALPULLUP);
  button->attachClick(onBtnClick);
  button->attachDoubleClick(onBtnDoubleClick);
  button->attachLongPressStart(onBtnLongPressStart);
  button->attachLongPressStop(onBtnLongPressStop);
  button->setClickTicks(BTN_CLICK_TICKS);
  button->setPressTicks(BTN_PRESS_TICKS);

  encoder.begin(PIN_ENC_R, PIN_ENC_L, ENCODER_STEPS, ENC_INTERNALPULLUP);
  encoder.setup(readEncoderISR);
  encoder.setBoundaries(0, 255, true);
  encoder.setAcceleration(VOL_ACCELERATION);

  enc_indev = lv_indev_create(); // Драйвер энкодера
  lv_indev_set_type(enc_indev, LV_INDEV_TYPE_ENCODER);
  lv_indev_set_read_cb(enc_indev, enc_read);

  lv_indev_set_group(enc_indev, groups.main);
}
//
void onBtnLongPressStart()
{
  //
}
//
void onBtnLongPressStop()
{
  Serial.println("onBtnLongPressStop");
  menuOnOff(mMENU);
  enc_btn = true;
}
//
void onBtnClick()
{
  if (Config->beep.enc)
    dev.beep(10);
  if (!MenuON)
  {
    player.toggle();
  }
  else
  {
    enc_btn = true;
  }
}

void onBtnDoubleClick()
{
  // Serial.println("onBtnDoubleClick ENC1");
  if (Config->beep.enc)
    dev.beep(10);
  enc_btn = true;
  menuOnOff(mPLAYLIST);
}
//-----------------------
void enc_read(lv_indev_t *indev, lv_indev_data_t *data)
{
  if (dev.Stop)
    return;
  button->tick();
  auto diff = (int16_t)encoder.encoderChanged();
  if (diff > 1)
  {
    diff = 1;
  }
  if (diff < -1)
  {
    diff = -1;
  }
  if ((Config->beep.enc) && (diff != 0))
    dev.beep(10);
  if (MenuON)
  {
    data->enc_diff = diff;
  }
  else
  {
    if (diff > 0)
    {
      player.setRelVolume(10);
    }
    if (diff < 0)
    {
      player.setRelVolume(-10);
    }
  }

  if (!enc_btn)
  {
    data->state = LV_INDEV_STATE_RELEASED;
  }
  else
  {
    data->state = LV_INDEV_STATE_PRESSED;
    enc_btn = false;
  }
  checkMenu();
}
//----------------------
// #define SHOW_RAW
#define KBD_WAIT 50U
bool press_kbd = false;
uint16_t kbd_raw = 0xFFFF;
uint8_t btn_num = 0xFF;
void kbd_read(lv_indev_t *indev, lv_indev_data_t *data)
{
  if (dev.Stop)
    return;
  static uint32_t last_btn = 0;
  uint32_t act_btn = 0;
  (void)indev; /*Unused*/

  // kbd1
  {
    if ((dev.AnalogR(PIN_KBD1) + dev.AnalogR(PIN_KBD1) + dev.AnalogR(PIN_KBD1) + dev.AnalogR(PIN_KBD1)) / 4 < 3800 && !press_kbd)
    {
      delay(KBD_WAIT);
      kbd_raw = (dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1) +
                 dev.AnalogR(PIN_KBD1)) /
                16;
#ifdef SHOW_RAW
      txtPrintInfo("KBD1 RAW: %u", kbd_raw);
#endif
      if (kbd_raw < 300)
      { // BTN_1

        btn_num = BTN_POWER;
      }
      else if ((kbd_raw > 300) && (kbd_raw < 900))
      { // BTN_2
        btn_num = BTN_MODE;
      }
      else if ((kbd_raw > 900) && (kbd_raw < 1400))
      { // BTN_3
        btn_num = BTN_MUTE;
      }
      else if ((kbd_raw > 1400) && (kbd_raw < 1800))
      { // BTN_4
        btn_num = BTN_NEXT;
      }
      else if ((kbd_raw > 1800) && (kbd_raw < 2300))
      { // BTN_5
        btn_num = BTN_PREV;
      }
      else if ((kbd_raw > 2300) && (kbd_raw < 2700))
      { // BTN_6
        btn_num = BTN_STOP;
      }
      else if ((kbd_raw > 2700) && (kbd_raw < 3000))
      { // BTN_7
        btn_num = BTN_EQ;
      }
      else if ((kbd_raw > 3000) && (kbd_raw < 3300))
      { // BTN_8
        btn_num = BTN_VOLm;
      }
      else if ((kbd_raw > 3300) && (kbd_raw < 3800))
      { // BTN_9
        btn_num = BTN_VOLp;
      }
    }
  }
  // kbd2
  {
    if ((dev.AnalogR(PIN_KBD2) + dev.AnalogR(PIN_KBD2) + dev.AnalogR(PIN_KBD2) + dev.AnalogR(PIN_KBD2)) / 4 < 3300 && !press_kbd)
    {
      delay(KBD_WAIT);
      kbd_raw = (dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2) +
                 dev.AnalogR(PIN_KBD2)) /
                16;
#ifdef SHOW_RAW
      txtPrintInfo("KBD2 RAW: %u", kbd_raw);
#endif
      if (kbd_raw < 300)
      { // BTN_10
        btn_num = BTN_DOWN;
      }
      else if ((kbd_raw > 300) && (kbd_raw < 900))
      { // BTN_11
        btn_num = BTN_RIGHT;
      }
      else if ((kbd_raw > 900) && (kbd_raw < 1400))
      { // BTN_12
        btn_num = BTN_UP;
      }
      else if ((kbd_raw > 1400) && (kbd_raw < 1800))
      { // BTN_13
        btn_num = BTN_LEFT;
      }
      else if ((kbd_raw > 1800) && (kbd_raw < 2300))
      { // BTN_14
        btn_num = BTN_PAUSE;
      }
      else if ((kbd_raw > 2300) && (kbd_raw < 2700))
      { // BTN_15
        btn_num = BTN_TUNER;
      }
      else if ((kbd_raw > 2700) && (kbd_raw < 3000))
      { // BTN_16
        btn_num = BTN_PLAY;
      }
      else if ((kbd_raw > 3000) && (kbd_raw < 3300))
      { // BTN_17
        btn_num = BTN_ALARM;
      }
    }
  } ///////////////////////////////////////////////////////////////////////
  if (kbd_raw != 0xFFFF)
  {
    kbd_raw = 0xFFFF;
    uint8_t btn = check_btn(btn_num);
    if (btn < BTN_MAX)
    {
      vTaskDelay(1);
      if (Config->beep.kbd)
        dev.beep(10);
      switch (btn)
      {
      case BTN_POWER:
      {
#ifdef SHOW_RAW
        Serial.println("POWER");
#else
        menuOnOff(mMENU);
#endif
        press_kbd = true;
      }
      break;
      case BTN_MODE:
      {
#ifdef SHOW_RAW
        Serial.println("MODE");
#else
        ExtON = !ExtON;
        serv.evtExtInfo(ExtON);
#endif
        press_kbd = true;
      }
      break;
      case BTN_MUTE:
      {
#ifdef SHOW_RAW
        Serial.println("MUTE");
#else
        Mute = !Mute;
        serv.evtMute(Mute);
#endif
        press_kbd = true;
      }
      break;
      case BTN_NEXT:
      {
#ifdef SHOW_RAW
        Serial.println("NEXT");
#else
        serv.evtStation(true);
#endif
        press_kbd = true;
      }
      break;
      case BTN_PREV:
      {
#ifdef SHOW_RAW
        Serial.println("PREV");
#else
        serv.evtStation(false);
#endif
        press_kbd = true;
      }
      break;
      case BTN_STOP:
      {
#ifdef SHOW_RAW
        Serial.println("STOP");
#else
        player.stop();
#endif
        press_kbd = true;
      }
      break;
      case BTN_EQ:
      {
#ifdef SHOW_RAW
        Serial.println("EQ");
#else
        // menuOnOff(mEQUALIZER);
#endif
        press_kbd = true;
      }
      break;
      case BTN_VOLm:
      {
#ifdef SHOW_RAW
        Serial.println("VOL-");
#else
        player.setRelVolume(-10);
#endif
      }
      break;
      case BTN_VOLp:
      {
#ifdef SHOW_RAW
        Serial.println("VOL+");
#else
        player.setRelVolume(10);
#endif
      }
      break;
      case BTN_DOWN:
      {
#ifdef SHOW_RAW
        Serial.println("DOWN");
#else
        if (MenuON)
        {
          act_btn = LV_KEY_DOWN;
        }
#endif
        press_kbd = true;
      }
      break;
      case BTN_RIGHT:
      {
#ifdef SHOW_RAW
        Serial.println("RIGHT");
#else
        if (MenuON)
        {
          act_btn = LV_KEY_NEXT;
        }
#endif
        press_kbd = true;
      }
      break;
      case BTN_UP:
      {
#ifdef SHOW_RAW
        Serial.println("UP");
#else
        if (MenuON)
        {
          act_btn = LV_KEY_UP;
        }
#endif
        press_kbd = true;
      }
      break;
      case BTN_LEFT:
      {
#ifdef SHOW_RAW
        Serial.println("LEFT");
#else
        if (MenuON)
        {
          act_btn = LV_KEY_PREV;
        }
#endif
        press_kbd = true;
      }
      break;
      case BTN_PAUSE:
      {
#ifdef SHOW_RAW
        Serial.println("PAUSE");
#else
        menuOnOff(mPLAYLIST);
#endif
        press_kbd = true;
      }
      break;
      case BTN_TUNER:
      {
#ifdef SHOW_RAW
        Serial.println("TUNER");
#else
        // ;
#endif
        press_kbd = true;
      }
      break;
      case BTN_PLAY:
      {
#ifdef SHOW_RAW
        Serial.println("PLAY");
#else
        if (MenuON)
        {
          act_btn = LV_KEY_ENTER;
        }
        else
        {
          if (player.play_mode != PLAY)
          {
            player.play(eeprom.GetID());
          }
        }
#endif
        press_kbd = true;
      }
      break;
      case BTN_ALARM:
      {
#ifdef SHOW_RAW
        Serial.println("ALARM");
#else
        // menuOnOff(mALARM);
#endif
        press_kbd = true;
      }
      break;
      default:
      {
        act_btn = 0;
      }
      }
#ifdef SHOW_RAW
      if (MenuON)
        Serial.println("MenuON");

#endif
      checkMenu();
    }
  }
  if ((dev.AnalogR(PIN_KBD1) > 3800) &&
      (dev.AnalogR(PIN_KBD2) > 3300))
  {
    press_kbd = false;
  }
  ///////////////////////////////////////////////////////////////////////
  if (act_btn != 0)
  {
    last_btn = act_btn;
    data->state = LV_INDEV_STATE_PRESSED;
  }
  else
  {
    data->state = LV_INDEV_STATE_RELEASED;
  }
  data->key = last_btn;
}
//----------------------
// Compute the ir code
//----------------------
void ir_read(lv_indev_t *indev, lv_indev_data_t *data)
{
  if (dev.Stop)
    return;
  static uint32_t last_key = 0;
  uint32_t act_key = 0;
  (void)indev; /*Unused*/

  // if (irrecv.decode(&irCode))
  // if (IrReceiver.decode_old(&irCode))
  if (IrReceiver.decode())
  {
    // if (!irCode.isRepeat /* && irCode.command!=0*/)
    if (!(IrReceiver.decodedIRData.flags & IRDATA_FLAGS_IS_REPEAT))
    {
      irCodeRepeat = -1;
    }
    switch (irCodeRepeat)
    {
    case KEY_VOLp:
    {
      if (MenuON)
      {
        act_key = LV_KEY_RIGHT;
      }
      else
      {
        player.setRelVolume(10);
      }
      break;
    }
    case KEY_VOLm:
    {
      if (MenuON)
      {
        act_key = LV_KEY_LEFT;
      }
      else
      {
        player.setRelVolume(-10);
      }
      break;
    }
    default:
      break;
    }
    if (irCodeRepeat == -1)
    {
      if (!web.ir_training)
      {
        uint8_t key = check_key();
        // txtPrintInfo("key: %u", key);
        // txtPrintInfo("decodedRawData: 0x%" PRIx64, IrReceiver.decodedIRData.decodedRawData);
        if (key < KEY_MAX)
        {
          vTaskDelay(1);
          if ((!(IrReceiver.decodedIRData.flags & IRDATA_FLAGS_IS_REPEAT)) && (Config->beep.ir))
            dev.beep(10);
          switch (key)
          {
          case KEY_PREV:
          {
            if (MenuON)
            {
              act_key = LV_KEY_PREV;
            }
            else
            {
              serv.evtStation(false);
            }
            irCodeRepeat = KEY_PREV;
          }
          break;
          case KEY_NEXT:
          {
            if (MenuON)
            {
              act_key = LV_KEY_NEXT;
            }
            else
            {
              serv.evtStation(true);
            }
            irCodeRepeat = KEY_NEXT;
          }
          break;
          case KEY_VOLm:
          {
            if (MenuON)
            {
              act_key = LV_KEY_LEFT;
            }
            else
            {
              player.setRelVolume(-5);
            }
            irCodeRepeat = KEY_VOLm;
          }
          break;
          case KEY_PLAY:
          {
            if (MenuON)
            {
              act_key = LV_KEY_ENTER;
            }
            else
            {
              onBtnClick();
            }
            irCodeRepeat = KEY_PLAY;
          }
          break;
          case KEY_VOLp:
          {
            if (MenuON)
            {
              act_key = LV_KEY_RIGHT;
            }
            else
            {
              player.setRelVolume(5);
            }
            irCodeRepeat = KEY_VOLp;
          }
          break;
          case KEY_0:
          {
            if (MenuON)
            {
              act_key = '0';
            }
            else
            {
              serv.setNumberbStation('0');
            }
            irCodeRepeat = KEY_0;
          }
          break;
          case KEY_1:
          {
            if (MenuON)
            {
              act_key = '1';
            }
            else
            {
              serv.setNumberbStation('1');
            }
            irCodeRepeat = KEY_1;
          }
          break;
          case KEY_2:
          {
            if (MenuON)
            {
              act_key = '2';
            }
            else
            {
              serv.setNumberbStation('2');
            }
            irCodeRepeat = KEY_2;
          }
          break;
          case KEY_3:
          {
            if (MenuON)
            {
              act_key = '3';
            }
            else
            {
              serv.setNumberbStation('3');
            }
            irCodeRepeat = KEY_3;
          }
          break;
          case KEY_4:
          {
            if (MenuON)
            {
              act_key = '4';
            }
            else
            {
              serv.setNumberbStation('4');
            }
            irCodeRepeat = KEY_4;
          }
          break;
          case KEY_5:
          {
            if (MenuON)
            {
              act_key = '5';
            }
            else
            {
              serv.setNumberbStation('5');
            }
            irCodeRepeat = KEY_5;
          }
          break;
          case KEY_6:
          {
            if (MenuON)
            {
              act_key = '6';
            }
            else
            {
              serv.setNumberbStation('6');
            }
            irCodeRepeat = KEY_6;
          }
          break;
          case KEY_7:
          {
            if (MenuON)
            {
              act_key = '7';
            }
            else
            {
              serv.setNumberbStation('7');
            }
            irCodeRepeat = KEY_7;
          }
          break;
          case KEY_8:
          {
            if (MenuON)
            {
              act_key = '8';
            }
            else
            {
              serv.setNumberbStation('8');
            }
            irCodeRepeat = KEY_8;
          }
          break;
          case KEY_9:
          {
            if (MenuON)
            {
              act_key = '9';
            }
            else
            {
              serv.setNumberbStation('9');
            }
            irCodeRepeat = KEY_9;
          }
          break;
          case KEY_CLOCK:
          { // mALARM
            // Serial.println("ALARM");
            if (serv.startShowSensor(5))
            {
              serv.evtSetSensor(false);
            }
            // menuOnOff(mALARM);
            irCodeRepeat = KEY_CLOCK;
          }
          break;
          case KEY_RPT:
          { // mPLAYLIST;
            menuOnOff(mPLAYLIST);
            irCodeRepeat = KEY_RPT;
          }
          break;
          case KEY_MUTE:
          {
            Mute = !Mute;
            serv.evtMute(Mute);
            irCodeRepeat = KEY_MUTE;
          }
          break;
          case KEY_POWER:
          { // MENU
            Serial.println("POWER");
            menuOnOff(mMENU);
            irCodeRepeat = KEY_POWER;
          }
          break;
          case KEY_MODE:
          {
            ExtON = !ExtON;
            serv.evtExtInfo(ExtON);
            irCodeRepeat = KEY_MODE;
          }
          break;
          case KEY_EQ:
          {
            Serial.println("EQ");
            // menuOnOff(mEQUALIZER);
            irCodeRepeat = KEY_EQ;
          }
          break;
          default:
          {
            act_key = 0;
          }
          }
          checkMenu();
        }
        // ESP_LOGI(TAG, "ir_read success, evtir %x, i: %d", evtir, i);
      }
      else
      {
        if (IrReceiver.decodedIRData.flags & IRDATA_FLAGS_WAS_OVERFLOW)
        {
          printf("IR: Overflow detected\n");
          printf("IR: Increase RAW_BUFFER_LENGTH from " STR(RAW_BUFFER_LENGTH) "\n");
          dev.beep(10);
        }
        else if (IrReceiver.decodedIRData.protocol == UNKNOWN)
        {
          printf("IR: Unknown protocol or noise\n");

          IrReceiver.printIRResultRawFormatted(&Serial, true);
          dev.beep(10);
        }
        else
        {

          // IrReceiver.printIRResultShort(&Serial);
          // IrReceiver.printIRSendUsage(&Serial);

          uint32_t id =
              ((uint32_t)IrReceiver.decodedIRData.protocol << 24) |
              ((uint32_t)(IrReceiver.decodedIRData.address >> 4) << 12) |
              (uint32_t)IrReceiver.decodedIRData.command;

          printf("Code button: %07X\n", id);
          web.irToWs(id);
          dev.beep(30);
        }

        act_key = 0;
        vTaskDelay(30);
      }
    }
    IrReceiver.resume();
  }
  //
  if (act_key != 0)
  {
    last_key = act_key;
    data->state = LV_INDEV_STATE_PRESSED;
    // ESP_LOGW("KEY", "last_key: %u", last_key);
  }
  else
  {
    data->state = LV_INDEV_STATE_RELEASED;
  }
  data->key = last_key;
}
//-----------------------------------------------------------------
lv_timer_t *closeMenu = nullptr;
void show_menu(lv_timer_t *timer)
{

  auto *numMenu = (uint32_t *)lv_timer_get_user_data(timer);
  switch (*numMenu)
  {
  case mALARM:
  {
    txtPrintWarn("mALARM not Released");
  }
  break;
  case mSLEEP:
  {
    txtPrintWarn("mSLEEP not Released");
  }
  break;

  case mPLAYLIST:
  {
    serv.evtPlayList(false);
  }
  break;
  case mEQUALIZER:
  {
    txtPrintWarn("mEQUALIZER not Released");
  }
  break;
  default:
    break;
  }
  lv_timer_delete(closeMenu);
  closeMenu = nullptr;
}
//
static uint32_t user_data = 0;
void startCoseMenu(uint8_t numberMenu)
{
  user_data = numberMenu;
  if (closeMenu == nullptr)
  {
    closeMenu = lv_timer_create(show_menu, 10000, &user_data);
  }
}
//
void resetCloseMenu()
{
  if (closeMenu)
    lv_timer_reset(closeMenu);
}
//
//-----------------------------------------------------------------
void action_event_main_menu(lv_event_t *e)
{
  txtPrintWarn("%s", lv_event_code_get_name(e->code));
  if (e->code == LV_EVENT_VALUE_CHANGED)
  {
    if (e->user_data == 0) // main menu
    {
      uint32_t m_sel = lv_roller_get_selected(objects.m_menu);
      txtPrintError("Menu select: %u", m_sel);
      if (m_sel == 0)
      {
        lv_label_set_text(objects.label_menu, _("ТЕКУЩИЙ ПЛЕЙЛИСТ"));
        StringPS pls_name = _("< назад\n");
        for (uint8_t i = 0; i < 4; i++)
        {
          if (eeprom.GetTotalSta(i))
            pls_name += eeprom.GetPlayListName(i) + "\n";
        }
        lv_roller_set_options(objects.m_playlist, pls_name.c_str(), LV_ROLLER_MODE_NORMAL);
        lv_roller_set_selected(objects.m_playlist, eeprom.GetCurrentPlayList() + 1, LV_ANIM_OFF);
        lv_obj_add_flag(objects.m_menu, LV_OBJ_FLAG_HIDDEN);
        lv_obj_remove_flag(objects.m_playlist, LV_OBJ_FLAG_HIDDEN);
        // lv_group_focus_next(groups.main);
        lv_obj_add_state(objects.m_playlist, LV_STATE_FOCUSED);
        lv_group_focus_obj(objects.m_playlist);
      }
      else if (m_sel == 1)
      {
        lv_label_set_text(objects.label_menu, _("РЕЖИМ РАБОТЫ")); // OPERATING MODE
        lv_roller_set_selected(objects.m_mode, Config->mode + 1, LV_ANIM_OFF);
        lv_obj_add_flag(objects.m_menu, LV_OBJ_FLAG_HIDDEN);
        lv_obj_remove_flag(objects.m_mode, LV_OBJ_FLAG_HIDDEN);
        lv_obj_add_state(objects.m_mode, LV_STATE_FOCUSED);
        lv_group_focus_obj(objects.m_mode);
      }
      else if (m_sel == 2)
      {
        lv_label_set_text(objects.label_menu, _("БУДИЛЬНИК"));
      }
      else if (m_sel == 3)
      {
        lv_label_set_text(objects.label_menu, _("СОН"));
      }
      return;
    }
    else if (e->user_data == (void *)1) // current playlist
    {
      // v_roller_get_selected_str(objects.roller_playlist, num_sta, 128);
      uint32_t m_sel = lv_roller_get_selected(objects.m_playlist);
      txtPrintError("m_playlist select: %u", m_sel);
      if (m_sel == 0)
      {
        lv_obj_remove_state(objects.m_playlist, LV_STATE_FOCUSED);
        lv_obj_add_flag(objects.m_playlist, LV_OBJ_FLAG_HIDDEN);
      }
      else
      {
        m_sel--;
        if ((eeprom.GetCurrentPlayList() != m_sel) && eeprom.GetTotalSta(m_sel))
        {
          eeprom.SetCurrentPlayList(m_sel);
        }
        return;
      }
    }
    else if (e->user_data == (void *)2) // OPERATING MODE
    {
      uint32_t m_sel = lv_roller_get_selected(objects.m_mode);
      txtPrintError("m_mode select: %u", m_sel);
      if (m_sel == 0)
      {
        lv_obj_remove_state(objects.m_mode, LV_STATE_FOCUSED);
        lv_obj_add_flag(objects.m_mode, LV_OBJ_FLAG_HIDDEN);
      }
      else
      {
        m_sel--;
        if (Config->mode != m_sel)
        {
          txtPrintInfo("m_mode saved: %u", m_sel);
          Config->mode = (work_mode_e)m_sel;
          eeprom.SaveConfig();
        }
        return;
      }
    }
    lv_label_set_text(objects.label_menu, _("ГЛАВНОЕ МЕНЮ"));
    lv_obj_remove_flag(objects.m_menu, LV_OBJ_FLAG_HIDDEN);
    lv_obj_add_state(objects.m_menu, LV_STATE_FOCUSED);
    lv_group_focus_obj(objects.m_menu);
  }
  // if (e->code == LV_EVENT_KEY)
  // {
  //   uint32_t key_code = lv_event_get_key(e);

  //   txtPrintError("Menu key: %lu", key_code);
  // }
}
//
void MainMenu(bool enable)
{
  if (!enable)
  {
    checkMenu(mMENU);
    lv_obj_remove_state(objects.m_menu, LV_STATE_FOCUSED);
    lv_obj_add_flag(objects.m_panel, LV_OBJ_FLAG_HIDDEN);
    return;
  }
  if (!lv_obj_has_flag(objects.sensors_panel, LV_OBJ_FLAG_HIDDEN))
  {
    lv_obj_add_flag(objects.sensors_panel, LV_OBJ_FLAG_HIDDEN);
  }

  lv_label_set_text(objects.label_menu, _("ГЛАВНОЕ МЕНЮ"));

  lv_obj_remove_flag(objects.m_panel, LV_OBJ_FLAG_HIDDEN);
  if (lv_obj_has_flag(objects.m_menu, LV_OBJ_FLAG_HIDDEN))
  {
    lv_obj_remove_flag(objects.m_menu, LV_OBJ_FLAG_HIDDEN);
  }
  if (!lv_obj_has_flag(objects.m_playlist, LV_OBJ_FLAG_HIDDEN))
  {
    lv_obj_add_flag(objects.m_playlist, LV_OBJ_FLAG_HIDDEN);
  }
  lv_obj_add_state(objects.m_menu, LV_STATE_FOCUSED);
  lv_group_focus_obj(objects.m_menu);
}
//-----------------------------------------------------------------

uint8_t start_sta, frame, begin_list, pos_in_list, end_list = 0;
int8_t counter = 0;
void action_event_play_list(lv_event_t *e)
{
  char num_sta[128] = {0};
  uint32_t key_code = lv_event_get_key(e);

  // txtPrintError("Code key: %u", key_code);

  if (key_code != LV_KEY_ENTER)
  {
    lv_roller_get_selected_str(objects.roller_playlist, num_sta, 128);
  }
  if (key_code == LV_KEY_LEFT || key_code == LV_KEY_UP)
  {
    counter--;
    if (counter < 0)
    {
      if (!((atoi(num_sta) - 2) <= -1))
      {
        getListStations(atoi(num_sta) - 2);
      }
      counter++;
    }
  }
  if (key_code == LV_KEY_RIGHT || key_code == LV_KEY_DOWN)
  {
    counter++;
    if (counter > 7)
    {
      if (!(atoi(num_sta) >= MAXSTATIONS))
      {
        getListStations(atoi(num_sta));
      }
      counter--;
    }
  }

  // txtPrintError("Selected PlayList ID: %u", lv_dropdown_get_selected(ListStation));

  resetCloseMenu();

  if (key_code == LV_KEY_ENTER)
  {
    uint8_t set_play = (frame * eeprom.GetShowRows()) + lv_roller_get_selected(objects.roller_playlist);
    set_play++;
    // txtPrintError("Enter PlayList ID: %u", set_play);
    if (eeprom.GetID() != set_play)
    {
      eeprom.SetID(set_play);
    }
    player.play(set_play);
    startCoseMenu(mPLAYLIST);
    enc_btn = true;
  }
}
//
void list_station(bool enable)
{
  if (!enable)
  {
    checkMenu(mPLAYLIST);
    lv_obj_add_flag(objects.roller_playlist, LV_OBJ_FLAG_HIDDEN);
    lv_obj_remove_state(objects.roller_playlist, LV_STATE_FOCUSED);
    return;
  }
  if (!lv_obj_has_flag(objects.sensors_panel, LV_OBJ_FLAG_HIDDEN))
  {
    lv_obj_add_flag(objects.sensors_panel, LV_OBJ_FLAG_HIDDEN);
  }
  lv_obj_remove_flag(objects.roller_playlist, LV_OBJ_FLAG_HIDDEN);
  lv_group_focus_obj(objects.roller_playlist);
  lv_obj_add_state(objects.roller_playlist, LV_STATE_FOCUSED);
  getListStations();

  counter = (int8_t)lv_roller_get_selected(objects.roller_playlist);
}
//
void getListStations(uint16_t start)
{
  if (!eeprom.GetTotalSta())
  {
    return;
  }
  if (start == MAXSTATIONS)
  {
    start_sta = eeprom.GetID() - 1;
  }
  else
  {
    if (start)
    {
      start_sta = start;
    }
    else
    {
      start_sta = 0;
    }
  }
  frame = (start_sta / eeprom.GetShowRows());

  pos_in_list = (start_sta % eeprom.GetShowRows());

  begin_list = (eeprom.GetShowRows() * frame);

  end_list = (begin_list + eeprom.GetShowRows());

  if (end_list >= eeprom.GetTotalSta())
  {
    end_list = eeprom.GetTotalSta();
  }

  std::string listOption = "";
  for (uint8_t i = begin_list; i < end_list; i++)
  {
    listOption += std::to_string(i + 1);
    listOption += ": ";
    listOption += eeprom.GetStaName(i + 1);
    if (i == end_list - 1)
      break;
    listOption += "\n";
    taskYIELD();
  };

  lv_roller_set_options(objects.roller_playlist, listOption.c_str(), LV_ROLLER_MODE_NORMAL);

  if (start == MAXSTATIONS)
  {
    lv_roller_set_selected(objects.roller_playlist, ((eeprom.GetID() - 1) % eeprom.GetShowRows()), LV_ANIM_OFF);
  }
  else
  {
    lv_roller_set_selected(objects.roller_playlist, pos_in_list, LV_ANIM_OFF);
    counter = (int8_t)pos_in_list;
  }

  //
}
//
void menuOnOff(uint8_t num_menu)
{
  if ((!openMenu[num_menu]) && (!MenuON))
  {
    openMenu[num_menu] = true;
  }
  else if ((openMenu[num_menu]) && (MenuON))
  {
    openMenu[num_menu] = false;
  }
  else
  {
    return;
  }
  switch (num_menu)
  {
  case mALARM:
  {
    serv.evtAlarm(openMenu[mALARM]);
  }
  break;
  case mPLAYLIST:
  {
    serv.evtPlayList(openMenu[mPLAYLIST]);
  }
  break;
  case mSLEEP:
  {
    serv.evtSleep(openMenu[mSLEEP]);
  }
  break;
  case mMENU:
  {
    serv.evtMenu(openMenu[mMENU]);
  }
  break;
  case mEQUALIZER:
  {
    txtPrintWarn("openMenu[mEQUALIZER] %s",
                 openMenu[mEQUALIZER] ? "true" : "false");
    // serv.evtSleep(openMenu[mEQUALIZER]);
  }
  break;

  default:
    break;
  }
}