hon_climate.cpp

Go to the documentation of this file.

#include <chrono>
#include <string>
#include "esphome/components/climate/climate.h"
#include "esphome/components/uart/uart.h"
#include "esphome/core/application.h"
#include "esphome/core/hal.h"
#include "esphome/core/helpers.h"
#include "esphome/core/progmem.h"
#include "hon_climate.h"
#include "hon_packet.h"
 
using namespace esphome::climate;
using namespace esphome::uart;
 
namespace esphome::haier {
 
static bool vertical_axis_is_auto(climate::ClimateSwingMode swing_mode) {
  return (swing_mode == climate::CLIMATE_SWING_VERTICAL) || (swing_mode == climate::CLIMATE_SWING_BOTH);
}
 
static bool horizontal_axis_is_auto(climate::ClimateSwingMode swing_mode) {
  return (swing_mode == climate::CLIMATE_SWING_HORIZONTAL) || (swing_mode == climate::CLIMATE_SWING_BOTH);
}
 
static bool is_auto(hon_protocol::VerticalSwingMode mode) {
  return (mode == hon_protocol::VerticalSwingMode::AUTO) || (mode == hon_protocol::VerticalSwingMode::AUTO_SPECIAL);
}
 
static bool is_auto(hon_protocol::HorizontalSwingMode mode) { return mode == hon_protocol::HorizontalSwingMode::AUTO; }
 
// A position the user just set wins over the appliance's echo of the old one for this long
constexpr uint32_t AIRFLOW_SELECT_DEBOUNCE_MS = 10000;
static bool in_debounce(uint32_t set_time, uint32_t now) {
  return set_time != 0 && now - set_time < AIRFLOW_SELECT_DEBOUNCE_MS;
}
 
ESPHOME_LOG_TAG(TAG, "haier.climate");
constexpr size_t SIGNAL_LEVEL_UPDATE_INTERVAL_MS = 10000;
constexpr int PROTOCOL_OUTDOOR_TEMPERATURE_OFFSET = -64;
constexpr uint8_t CONTROL_MESSAGE_RETRIES = 5;
constexpr std::chrono::milliseconds CONTROL_MESSAGE_RETRIES_INTERVAL = std::chrono::milliseconds(500);
constexpr size_t ALARM_STATUS_REQUEST_INTERVAL_MS = 600000;
const uint8_t ONE_BUF[] = {0x00, 0x01};
const uint8_t ZERO_BUF[] = {0x00, 0x00};
 
// Alarm texts indexed by alarm code; the last entry is the fallback for unknown codes
PROGMEM_STRING_TABLE(
    HonAlarmMessages, "Outdoor module failure", "Outdoor defrost sensor failure",
    "Outdoor compressor exhaust sensor failure", "Outdoor EEPROM abnormality", "Indoor coil sensor failure",
    "Indoor-outdoor communication failure", "Power supply overvoltage protection",
    "Communication failure between panel and indoor unit", "Outdoor compressor overheat protection",
    "Outdoor environmental sensor abnormality", "Full water protection", "Indoor EEPROM failure",
    "Outdoor out air sensor failure", "CBD and module communication failure", "Indoor DC fan failure",
    "Outdoor DC fan failure", "Door switch failure", "Dust filter needs cleaning reminder", "Water shortage protection",
    "Humidity sensor failure", "Indoor temperature sensor failure", "Manipulator limit failure",
    "Indoor PM2.5 sensor failure", "Outdoor PM2.5 sensor failure", "Indoor heating overload/high load alarm",
    "Outdoor AC current protection", "Outdoor compressor operation abnormality", "Outdoor DC current protection",
    "Outdoor no-load failure", "CT current abnormality", "Indoor cooling freeze protection",
    "High and low pressure protection", "Compressor out air temperature is too high",
    "Outdoor evaporator sensor failure", "Outdoor cooling overload", "Water pump drainage failure",
    "Three-phase power supply failure", "Four-way valve failure", "External alarm/scraper flow switch failure",
    "Temperature cutoff protection alarm", "Different mode operation failure", "Electronic expansion valve failure",
    "Dual heat source sensor Tw failure", "Communication failure with the wired controller",
    "Indoor unit address duplication failure", "50Hz zero crossing failure", "Outdoor unit failure",
    "Formaldehyde sensor failure", "VOC sensor failure", "CO2 sensor failure", "Firewall failure", "Unknown");
 
HonClimate::HonClimate()
    : cleaning_status_(CleaningState::NO_CLEANING),
      got_valid_outdoor_temp_(false),
      active_alarms_{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} {
  this->fan_mode_speed_ = (uint8_t) hon_protocol::FanMode::FAN_MID;
  this->other_modes_fan_speed_ = (uint8_t) hon_protocol::FanMode::FAN_AUTO;
}
 
HonClimate::~HonClimate() {}
 
void HonClimate::set_beeper_state(bool state) {
  if (state != this->settings_.beeper_state) {
    this->settings_.beeper_state = state;
#ifdef USE_SWITCH
    if (this->beeper_switch_ != nullptr) {
      this->beeper_switch_->publish_state(state);
    }
#endif
    this->hon_rtc_.save(&this->settings_);
  }
}
 
bool HonClimate::get_beeper_state() const { return this->settings_.beeper_state; }
 
void HonClimate::set_quiet_mode_state(bool state) {
  if (state != this->get_quiet_mode_state()) {
    if ((this->mode != ClimateMode::CLIMATE_MODE_OFF) && (this->mode != ClimateMode::CLIMATE_MODE_FAN_ONLY)) {
      this->quiet_mode_state_ = state ? SwitchState::PENDING_ON : SwitchState::PENDING_OFF;
      this->force_send_control_ = true;
    } else {
      this->quiet_mode_state_ = state ? SwitchState::SWITCH_ON : SwitchState::SWITCH_OFF;
    }
    this->settings_.quiet_mode_state = state;
#ifdef USE_SWITCH
    if (this->quiet_mode_switch_ != nullptr) {
      this->quiet_mode_switch_->publish_state(state);
    }
#endif
    this->hon_rtc_.save(&this->settings_);
  }
}
 
bool HonClimate::get_quiet_mode_state() const {
  return (this->quiet_mode_state_ == SwitchState::SWITCH_ON) || (this->quiet_mode_state_ == SwitchState::PENDING_ON);
}
 
esphome::optional<hon_protocol::VerticalSwingMode> HonClimate::get_vertical_airflow() const {
  if (!this->current_vertical_swing_.has_value()) {
    return this->current_vertical_swing_;
  }
  // While the appliance swings, or right after the user chose a position, report the chosen position
  if (is_auto(this->current_vertical_swing_.value()) ||
      in_debounce(this->vertical_direction_set_time_, App.get_loop_component_start_time())) {
    return this->settings_.last_vertiacal_swing;
  }
  return this->current_vertical_swing_;
}
 
void HonClimate::set_vertical_airflow(hon_protocol::VerticalSwingMode direction) {
  if (is_auto(direction)) {
    ESP_LOGW(TAG, "Vertical AUTO mode is not allowed for airflow position selector");
    return;
  }
  if (this->settings_.last_vertiacal_swing != direction) {
    this->settings_.last_vertiacal_swing = direction;
    this->hon_rtc_.save(&this->settings_);
  }
  this->pending_vertical_direction_ = direction;
  this->force_send_control_ = true;
  this->vertical_direction_set_time_ = App.get_loop_component_start_time();
#ifdef USE_SELECT
  this->publish_airflow_selects_();
#endif
}
 
esphome::optional<hon_protocol::HorizontalSwingMode> HonClimate::get_horizontal_airflow() const {
  if (!this->current_horizontal_swing_.has_value()) {
    return this->current_horizontal_swing_;
  }
  if (is_auto(this->current_horizontal_swing_.value()) ||
      in_debounce(this->horizontal_direction_set_time_, App.get_loop_component_start_time())) {
    return this->settings_.last_horizontal_swing;
  }
  return this->current_horizontal_swing_;
}
 
void HonClimate::set_horizontal_airflow(hon_protocol::HorizontalSwingMode direction) {
  if (is_auto(direction)) {
    ESP_LOGW(TAG, "Horizontal AUTO mode is not allowed for airflow position selector");
    return;
  }
  if (this->settings_.last_horizontal_swing != direction) {
    this->settings_.last_horizontal_swing = direction;
    this->hon_rtc_.save(&this->settings_);
  }
  this->pending_horizontal_direction_ = direction;
  this->force_send_control_ = true;
  this->horizontal_direction_set_time_ = App.get_loop_component_start_time();
#ifdef USE_SELECT
  this->publish_airflow_selects_();
#endif
}
 
const char *HonClimate::get_cleaning_status_text() const {
  switch (this->cleaning_status_) {
    case CleaningState::SELF_CLEAN:
      return "Self clean";
    case CleaningState::STERI_CLEAN:
      return "56°C Steri-Clean";
    default:
      return "No cleaning";
  }
}
 
CleaningState HonClimate::get_cleaning_status() const { return this->cleaning_status_; }
 
void HonClimate::start_self_cleaning() {
  if (this->cleaning_status_ == CleaningState::NO_CLEANING) {
    ESP_LOGI(TAG, "Sending self cleaning start request");
    this->action_request_ =
        PendingAction({ActionRequest::START_SELF_CLEAN, esphome::optional<haier_protocol::HaierMessage>()});
  }
}
 
void HonClimate::start_steri_cleaning() {
  if (this->cleaning_status_ == CleaningState::NO_CLEANING) {
    ESP_LOGI(TAG, "Sending steri cleaning start request");
    this->action_request_ =
        PendingAction({ActionRequest::START_STERI_CLEAN, esphome::optional<haier_protocol::HaierMessage>()});
  }
}
 
haier_protocol::HandlerError HonClimate::get_device_version_answer_handler_(haier_protocol::FrameType request_type,
                                                                            haier_protocol::FrameType message_type,
                                                                            const uint8_t *data, size_t data_size) {
  // Should check this before preprocess
  if (message_type == haier_protocol::FrameType::INVALID) {
    ESP_LOGW(TAG, "It looks like your ESPHome Haier climate configuration is wrong. You should use the smartAir2 "
                  "protocol instead of hOn");
    this->set_phase(ProtocolPhases::SENDING_INIT_1);
    return haier_protocol::HandlerError::INVALID_ANSWER;
  }
  haier_protocol::HandlerError result =
      this->answer_preprocess_(request_type, haier_protocol::FrameType::GET_DEVICE_VERSION, message_type,
                               haier_protocol::FrameType::GET_DEVICE_VERSION_RESPONSE, ProtocolPhases::SENDING_INIT_1);
  if (result == haier_protocol::HandlerError::HANDLER_OK) {
    if (data_size < sizeof(hon_protocol::DeviceVersionAnswer)) {
      // Wrong structure
      return haier_protocol::HandlerError::WRONG_MESSAGE_STRUCTURE;
    }
    // All OK
    hon_protocol::DeviceVersionAnswer *answr = (hon_protocol::DeviceVersionAnswer *) data;
    HardwareInfo info{};  // zero-init guarantees null-termination
    strncpy(info.protocol_version_, answr->protocol_version, HARDWARE_INFO_STR_SIZE - 1);
    strncpy(info.software_version_, answr->software_version, HARDWARE_INFO_STR_SIZE - 1);
    strncpy(info.hardware_version_, answr->hardware_version, HARDWARE_INFO_STR_SIZE - 1);
    strncpy(info.device_name_, answr->device_name, HARDWARE_INFO_STR_SIZE - 1);
    info.functions_[0] = (answr->functions[1] & 0x01) != 0;  // interactive mode support
    info.functions_[1] = (answr->functions[1] & 0x02) != 0;  // controller-device mode support
    info.functions_[2] = (answr->functions[1] & 0x04) != 0;  // crc support
    info.functions_[3] = (answr->functions[1] & 0x08) != 0;  // multiple AC support
    info.functions_[4] = (answr->functions[1] & 0x20) != 0;  // roles support
    this->use_crc_ = info.functions_[2];
#ifdef USE_TEXT_SENSOR
    this->update_sub_text_sensor_(SubTextSensorType::APPLIANCE_NAME, info.device_name_);
    this->update_sub_text_sensor_(SubTextSensorType::PROTOCOL_VERSION, info.protocol_version_);
#endif
    this->hvac_hardware_info_ = info;
    this->set_phase(ProtocolPhases::SENDING_INIT_2);
    return result;
  } else {
    this->reset_phase_();
    return result;
  }
}
 
haier_protocol::HandlerError HonClimate::get_device_id_answer_handler_(haier_protocol::FrameType request_type,
                                                                       haier_protocol::FrameType message_type,
                                                                       const uint8_t *data, size_t data_size) {
  haier_protocol::HandlerError result =
      this->answer_preprocess_(request_type, haier_protocol::FrameType::GET_DEVICE_ID, message_type,
                               haier_protocol::FrameType::GET_DEVICE_ID_RESPONSE, ProtocolPhases::SENDING_INIT_2);
  if (result == haier_protocol::HandlerError::HANDLER_OK) {
    this->set_phase(ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
    return result;
  } else {
    this->reset_phase_();
    return result;
  }
}
 
haier_protocol::HandlerError HonClimate::status_handler_(haier_protocol::FrameType request_type,
                                                         haier_protocol::FrameType message_type, const uint8_t *data,
                                                         size_t data_size) {
  haier_protocol::HandlerError result =
      this->answer_preprocess_(request_type, haier_protocol::FrameType::CONTROL, message_type,
                               haier_protocol::FrameType::STATUS, ProtocolPhases::UNKNOWN);
  if (result == haier_protocol::HandlerError::HANDLER_OK) {
    result = this->process_status_message_(data, data_size);
    if (result != haier_protocol::HandlerError::HANDLER_OK) {
      ESP_LOGW(TAG, "Error %d while parsing Status packet", (int) result);
      this->reset_phase_();
      this->action_request_.reset();
      this->force_send_control_ = false;
    } else {
      if (!this->last_status_message_) {
        this->real_control_packet_size_ = sizeof(hon_protocol::HaierPacketControl) + this->extra_control_packet_bytes_;
        this->real_sensors_packet_size_ = sizeof(hon_protocol::HaierPacketSensors) + this->extra_sensors_packet_bytes_;
        this->last_status_message_.reset();
        this->last_status_message_ = std::unique_ptr<uint8_t[]>(new uint8_t[this->real_control_packet_size_]);
      };
      if (data_size >= this->real_control_packet_size_ + 2) {
        memcpy(this->last_status_message_.get(), data + 2 + this->status_message_header_size_,
               this->real_control_packet_size_);
        this->status_message_callback_.call((const char *) data, data_size);
      } else {
        ESP_LOGW(TAG, "Status packet too small: %zu (should be >= %zu)", data_size, this->real_control_packet_size_);
      }
      switch (this->protocol_phase_) {
        case ProtocolPhases::SENDING_FIRST_STATUS_REQUEST:
          ESP_LOGI(TAG, "First HVAC status received");
          this->set_phase(ProtocolPhases::SENDING_FIRST_ALARM_STATUS_REQUEST);
          break;
        case ProtocolPhases::SENDING_ACTION_COMMAND:
          // Do nothing, phase will be changed in process_phase
          break;
        case ProtocolPhases::SENDING_STATUS_REQUEST:
          this->set_phase(ProtocolPhases::IDLE);
          break;
        case ProtocolPhases::SENDING_CONTROL:
          if (!this->control_messages_queue_.empty())
            this->control_messages_queue_.pop();
          if (this->control_messages_queue_.empty()) {
            this->set_phase(ProtocolPhases::IDLE);
            this->force_send_control_ = false;
            if (this->current_hvac_settings_.valid)
              this->current_hvac_settings_.reset();
          } else {
            this->set_phase(ProtocolPhases::SENDING_CONTROL);
          }
          break;
        default:
          break;
      }
    }
    return result;
  } else {
    this->action_request_.reset();
    this->force_send_control_ = false;
    this->reset_phase_();
    return result;
  }
}
 
haier_protocol::HandlerError HonClimate::get_management_information_answer_handler_(
    haier_protocol::FrameType request_type, haier_protocol::FrameType message_type, const uint8_t *data,
    size_t data_size) {
  haier_protocol::HandlerError result = this->answer_preprocess_(
      request_type, haier_protocol::FrameType::GET_MANAGEMENT_INFORMATION, message_type,
      haier_protocol::FrameType::GET_MANAGEMENT_INFORMATION_RESPONSE, ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST);
  if (result == haier_protocol::HandlerError::HANDLER_OK) {
    this->set_phase(ProtocolPhases::SENDING_SIGNAL_LEVEL);
    return result;
  } else {
    this->set_phase(ProtocolPhases::IDLE);
    return result;
  }
}
 
haier_protocol::HandlerError HonClimate::get_alarm_status_answer_handler_(haier_protocol::FrameType request_type,
                                                                          haier_protocol::FrameType message_type,
                                                                          const uint8_t *data, size_t data_size) {
  if (request_type == haier_protocol::FrameType::GET_ALARM_STATUS) {
    if (message_type != haier_protocol::FrameType::GET_ALARM_STATUS_RESPONSE) {
      // Unexpected answer to request
      this->set_phase(ProtocolPhases::IDLE);
      return haier_protocol::HandlerError::UNSUPPORTED_MESSAGE;
    }
    if ((this->protocol_phase_ != ProtocolPhases::SENDING_FIRST_ALARM_STATUS_REQUEST) &&
        (this->protocol_phase_ != ProtocolPhases::SENDING_ALARM_STATUS_REQUEST)) {
      // Don't expect this answer now
      this->set_phase(ProtocolPhases::IDLE);
      return haier_protocol::HandlerError::UNEXPECTED_MESSAGE;
    }
    if (data_size < sizeof(active_alarms_) + 2)
      return haier_protocol::HandlerError::WRONG_MESSAGE_STRUCTURE;
    this->process_alarm_message_(data, data_size, this->protocol_phase_ >= ProtocolPhases::IDLE);
    this->set_phase(ProtocolPhases::IDLE);
    return haier_protocol::HandlerError::HANDLER_OK;
  } else {
    this->set_phase(ProtocolPhases::IDLE);
    return haier_protocol::HandlerError::UNSUPPORTED_MESSAGE;
  }
}
 
haier_protocol::HandlerError HonClimate::alarm_status_message_handler_(haier_protocol::FrameType type,
                                                                       const uint8_t *buffer, size_t size) {
  haier_protocol::HandlerError result = haier_protocol::HandlerError::HANDLER_OK;
  if (size < sizeof(this->active_alarms_) + 2) {
    // Log error but confirm anyway to avoid to many messages
    result = haier_protocol::HandlerError::WRONG_MESSAGE_STRUCTURE;
  }
  this->process_alarm_message_(buffer, size, true);
  this->haier_protocol_.send_answer(haier_protocol::HaierMessage(haier_protocol::FrameType::CONFIRM));
  this->last_alarm_request_ = std::chrono::steady_clock::now();
  return result;
}
 
void HonClimate::set_handlers() {
  // Set handlers
  this->haier_protocol_.set_answer_handler(
      haier_protocol::FrameType::GET_DEVICE_VERSION,
      [this](haier_protocol::FrameType req, haier_protocol::FrameType msg, const uint8_t *data, size_t size) {
        return this->get_device_version_answer_handler_(req, msg, data, size);
      });
  this->haier_protocol_.set_answer_handler(
      haier_protocol::FrameType::GET_DEVICE_ID,
      [this](haier_protocol::FrameType req, haier_protocol::FrameType msg, const uint8_t *data, size_t size) {
        return this->get_device_id_answer_handler_(req, msg, data, size);
      });
  this->haier_protocol_.set_answer_handler(
      haier_protocol::FrameType::CONTROL,
      [this](haier_protocol::FrameType req, haier_protocol::FrameType msg, const uint8_t *data, size_t size) {
        return this->status_handler_(req, msg, data, size);
      });
  this->haier_protocol_.set_answer_handler(
      haier_protocol::FrameType::GET_MANAGEMENT_INFORMATION,
      [this](haier_protocol::FrameType req, haier_protocol::FrameType msg, const uint8_t *data, size_t size) {
        return this->get_management_information_answer_handler_(req, msg, data, size);
      });
  this->haier_protocol_.set_answer_handler(
      haier_protocol::FrameType::GET_ALARM_STATUS,
      [this](haier_protocol::FrameType req, haier_protocol::FrameType msg, const uint8_t *data, size_t size) {
        return this->get_alarm_status_answer_handler_(req, msg, data, size);
      });
  this->haier_protocol_.set_answer_handler(
      haier_protocol::FrameType::REPORT_NETWORK_STATUS,
      [this](haier_protocol::FrameType req, haier_protocol::FrameType msg, const uint8_t *data, size_t size) {
        return this->report_network_status_answer_handler_(req, msg, data, size);
      });
  this->haier_protocol_.set_message_handler(haier_protocol::FrameType::ALARM_STATUS,
                                            [this](haier_protocol::FrameType type, const uint8_t *data, size_t size) {
                                              return this->alarm_status_message_handler_(type, data, size);
                                            });
}
 
void HonClimate::dump_config() {
  HaierClimateBase::dump_config();
  ESP_LOGCONFIG(TAG,
                "  Protocol version: hOn\n"
                "  Control method: %d",
                (uint8_t) this->control_method_);
  if (this->hvac_hardware_info_.has_value()) {
    ESP_LOGCONFIG(TAG,
                  "  Device protocol version: %s\n"
                  "  Device software version: %s\n"
                  "  Device hardware version: %s\n"
                  "  Device name: %s",
                  this->hvac_hardware_info_.value().protocol_version_,
                  this->hvac_hardware_info_.value().software_version_,
                  this->hvac_hardware_info_.value().hardware_version_, this->hvac_hardware_info_.value().device_name_);
    ESP_LOGCONFIG(TAG, "  Device features:%s%s%s%s%s",
                  (this->hvac_hardware_info_.value().functions_[0] ? LOG_STR_LITERAL(" interactive") : ""),
                  (this->hvac_hardware_info_.value().functions_[1] ? LOG_STR_LITERAL(" controller-device") : ""),
                  (this->hvac_hardware_info_.value().functions_[2] ? LOG_STR_LITERAL(" crc") : ""),
                  (this->hvac_hardware_info_.value().functions_[3] ? LOG_STR_LITERAL(" multinode") : ""),
                  (this->hvac_hardware_info_.value().functions_[4] ? LOG_STR_LITERAL(" role") : ""));
    ESP_LOGCONFIG(TAG, "  Active alarms: %s", buf_to_hex(this->active_alarms_, sizeof(this->active_alarms_)).c_str());
  }
}
 
void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
  switch (this->protocol_phase_) {
    case ProtocolPhases::SENDING_INIT_1:
      if (this->can_send_message() && this->is_protocol_initialisation_interval_exceeded_(now)) {
        // Indicate device capabilities:
        // bit 0 - if 1 module support interactive mode
        // bit 1 - if 1 module support controller-device mode
        // bit 2 - if 1 module support crc
        // bit 3 - if 1 module support multiple devices
        // bit 4..bit 15 - not used
        uint8_t module_capabilities[2] = {0b00000000, 0b00000111};
        static const haier_protocol::HaierMessage DEVICE_VERSION_REQUEST(
            haier_protocol::FrameType::GET_DEVICE_VERSION, module_capabilities, sizeof(module_capabilities));
        this->send_message_(DEVICE_VERSION_REQUEST, this->use_crc_);
      }
      break;
    case ProtocolPhases::SENDING_INIT_2:
      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
        static const haier_protocol::HaierMessage DEVICEID_REQUEST(haier_protocol::FrameType::GET_DEVICE_ID);
        this->send_message_(DEVICEID_REQUEST, this->use_crc_);
      }
      break;
    case ProtocolPhases::SENDING_FIRST_STATUS_REQUEST:
    case ProtocolPhases::SENDING_STATUS_REQUEST:
      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
        static const haier_protocol::HaierMessage STATUS_REQUEST(
            haier_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcommandsControl::GET_USER_DATA);
        static const haier_protocol::HaierMessage BIG_DATA_REQUEST(
            haier_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcommandsControl::GET_BIG_DATA);
        if ((this->protocol_phase_ == ProtocolPhases::SENDING_FIRST_STATUS_REQUEST) ||
            (!this->should_get_big_data_())) {
          this->send_message_(STATUS_REQUEST, this->use_crc_);
        } else {
          this->send_message_(BIG_DATA_REQUEST, this->use_crc_);
        }
        this->last_status_request_ = now;
      }
      break;
#ifdef USE_WIFI
    case ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST:
      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
        static const haier_protocol::HaierMessage UPDATE_SIGNAL_REQUEST(
            haier_protocol::FrameType::GET_MANAGEMENT_INFORMATION);
        this->send_message_(UPDATE_SIGNAL_REQUEST, this->use_crc_);
        this->last_signal_request_ = now;
      }
      break;
    case ProtocolPhases::SENDING_SIGNAL_LEVEL:
      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
        this->send_message_(this->get_wifi_signal_message_(), this->use_crc_);
      }
      break;
#else
    case ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST:
    case ProtocolPhases::SENDING_SIGNAL_LEVEL:
      this->set_phase(ProtocolPhases::IDLE);
      break;
#endif
    case ProtocolPhases::SENDING_FIRST_ALARM_STATUS_REQUEST:
    case ProtocolPhases::SENDING_ALARM_STATUS_REQUEST:
      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
        static const haier_protocol::HaierMessage ALARM_STATUS_REQUEST(haier_protocol::FrameType::GET_ALARM_STATUS);
        this->send_message_(ALARM_STATUS_REQUEST, this->use_crc_);
        this->last_alarm_request_ = now;
      }
      break;
    case ProtocolPhases::SENDING_CONTROL:
      if (this->control_messages_queue_.empty()) {
        switch (this->control_method_) {
          case HonControlMethod::SET_GROUP_PARAMETERS: {
            haier_protocol::HaierMessage control_message = this->get_control_message();
            this->control_messages_queue_.push(control_message);
          } break;
          case HonControlMethod::SET_SINGLE_PARAMETER:
            this->fill_control_messages_queue_();
            break;
          case HonControlMethod::MONITOR_ONLY:
            ESP_LOGI(TAG, "AC control is disabled, monitor only");
            this->reset_to_idle_();
            return;
          default:
            ESP_LOGW(TAG, "Unsupported control method for hOn protocol!");
            this->reset_to_idle_();
            return;
        }
      }
      if (this->control_messages_queue_.empty()) {
        ESP_LOGW(TAG, "Control message queue is empty!");
        this->reset_to_idle_();
      } else if (this->can_send_message() && this->is_control_message_interval_exceeded_(now)) {
        ESP_LOGI(TAG, "Sending control packet, queue size %d", this->control_messages_queue_.size());
        this->send_message_(this->control_messages_queue_.front(), this->use_crc_, CONTROL_MESSAGE_RETRIES,
                            CONTROL_MESSAGE_RETRIES_INTERVAL);
      }
      break;
    case ProtocolPhases::SENDING_ACTION_COMMAND:
      if (this->action_request_.has_value()) {
        if (this->action_request_.value().message.has_value()) {
          this->send_message_(this->action_request_.value().message.value(), this->use_crc_);
          this->action_request_.value().message.reset();  // NOLINT(bugprone-unchecked-optional-access)
        } else {
          // Message already sent, reseting request and return to idle
          this->action_request_.reset();
          this->set_phase(ProtocolPhases::IDLE);
        }
      } else {
        ESP_LOGW(TAG, "SENDING_ACTION_COMMAND phase without action request!");
        this->set_phase(ProtocolPhases::IDLE);
      }
      break;
    case ProtocolPhases::IDLE: {
      if (this->forced_request_status_ || this->is_status_request_interval_exceeded_(now)) {
        this->set_phase(ProtocolPhases::SENDING_STATUS_REQUEST);
        this->forced_request_status_ = false;
      } else if (std::chrono::duration_cast<std::chrono::milliseconds>(now - this->last_alarm_request_).count() >
                 ALARM_STATUS_REQUEST_INTERVAL_MS) {
        this->set_phase(ProtocolPhases::SENDING_ALARM_STATUS_REQUEST);
      }
#ifdef USE_WIFI
      else if (this->send_wifi_signal_ &&
               (std::chrono::duration_cast<std::chrono::milliseconds>(now - this->last_signal_request_).count() >
                SIGNAL_LEVEL_UPDATE_INTERVAL_MS)) {
        this->set_phase(ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST);
      }
#endif
    } break;
    default:
      // Shouldn't get here
      ESP_LOGE(TAG, "Wrong protocol handler state: %s (%d), resetting communication",
               phase_to_string_(this->protocol_phase_), (int) this->protocol_phase_);
      this->set_phase(ProtocolPhases::SENDING_INIT_1);
      break;
  }
}
 
haier_protocol::HaierMessage HonClimate::get_power_message(bool state) {
  if (state) {
    static haier_protocol::HaierMessage power_on_message(
        haier_protocol::FrameType::CONTROL, ((uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER) + 1,
        std::initializer_list<uint8_t>({0x00, 0x01}).begin(), 2);
    return power_on_message;
  } else {
    static haier_protocol::HaierMessage power_off_message(
        haier_protocol::FrameType::CONTROL, ((uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER) + 1,
        std::initializer_list<uint8_t>({0x00, 0x00}).begin(), 2);
    return power_off_message;
  }
}
 
void HonClimate::initialization() {
  HaierClimateBase::initialization();
  constexpr uint32_t restore_settings_version = 0x57EB59DDUL;
  this->hon_rtc_ = this->make_entity_preference<HonSettings>(restore_settings_version);
  HonSettings recovered;
  if (this->hon_rtc_.load(&recovered)) {
    this->settings_ = recovered;
  } else {
    this->settings_ = {hon_protocol::VerticalSwingMode::CENTER, hon_protocol::HorizontalSwingMode::CENTER, true, false};
  }
  bool settings_fixed = false;
  if (is_auto(this->settings_.last_vertiacal_swing)) {
    this->settings_.last_vertiacal_swing = hon_protocol::VerticalSwingMode::CENTER;
    settings_fixed = true;
  }
  if (is_auto(this->settings_.last_horizontal_swing)) {
    this->settings_.last_horizontal_swing = hon_protocol::HorizontalSwingMode::CENTER;
    settings_fixed = true;
  }
  if (settings_fixed) {
    this->hon_rtc_.save(&this->settings_);
  }
  this->current_vertical_swing_ = this->settings_.last_vertiacal_swing;
  this->current_horizontal_swing_ = this->settings_.last_horizontal_swing;
  this->quiet_mode_state_ = this->settings_.quiet_mode_state ? SwitchState::SWITCH_ON : SwitchState::SWITCH_OFF;
}
 
haier_protocol::HaierMessage HonClimate::get_control_message() {
  uint8_t control_out_buffer[haier_protocol::MAX_FRAME_SIZE];
  memcpy(control_out_buffer, this->last_status_message_.get(), this->real_control_packet_size_);
  hon_protocol::HaierPacketControl *out_data = (hon_protocol::HaierPacketControl *) control_out_buffer;
  control_out_buffer[4] = 0;  // This byte should be cleared before setting values
  bool has_hvac_settings = false;
  if (this->current_hvac_settings_.valid) {
    has_hvac_settings = true;
    HvacSettings &climate_control = this->current_hvac_settings_;
    if (climate_control.mode.has_value()) {
      switch (climate_control.mode.value()) {
        case CLIMATE_MODE_OFF:
          out_data->ac_power = 0;
          break;
        case CLIMATE_MODE_HEAT_COOL:
          out_data->ac_power = 1;
          out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::AUTO;
          out_data->fan_mode = this->other_modes_fan_speed_;
          break;
        case CLIMATE_MODE_HEAT:
          out_data->ac_power = 1;
          out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::HEAT;
          out_data->fan_mode = this->other_modes_fan_speed_;
          break;
        case CLIMATE_MODE_DRY:
          out_data->ac_power = 1;
          out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
          out_data->fan_mode = this->other_modes_fan_speed_;
          break;
        case CLIMATE_MODE_FAN_ONLY:
          out_data->ac_power = 1;
          out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::FAN;
          out_data->fan_mode = this->fan_mode_speed_;  // Auto doesn't work in fan only mode
          // Disabling boost for Fan only
          out_data->fast_mode = 0;
          break;
        case CLIMATE_MODE_COOL:
          out_data->ac_power = 1;
          out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::COOL;
          out_data->fan_mode = this->other_modes_fan_speed_;
          break;
        default:
          ESP_LOGE("Control", "Unsupported climate mode");
          break;
      }
    }
    // Set fan speed, if we are in fan mode, reject auto in fan mode
    if (climate_control.fan_mode.has_value()) {
      switch (climate_control.fan_mode.value()) {
        case CLIMATE_FAN_LOW:
          out_data->fan_mode = (uint8_t) hon_protocol::FanMode::FAN_LOW;
          break;
        case CLIMATE_FAN_MEDIUM:
          out_data->fan_mode = (uint8_t) hon_protocol::FanMode::FAN_MID;
          break;
        case CLIMATE_FAN_HIGH:
          out_data->fan_mode = (uint8_t) hon_protocol::FanMode::FAN_HIGH;
          break;
        case CLIMATE_FAN_AUTO:
          if (mode != CLIMATE_MODE_FAN_ONLY)  // if we are not in fan only mode
            out_data->fan_mode = (uint8_t) hon_protocol::FanMode::FAN_AUTO;
          break;
        default:
          ESP_LOGE("Control", "Unsupported fan mode");
          break;
      }
    }
    // Set swing mode
    if (climate_control.swing_mode.has_value()) {
      switch (climate_control.swing_mode.value()) {
        case CLIMATE_SWING_OFF:
          out_data->horizontal_swing_mode = (uint8_t) this->settings_.last_horizontal_swing;
          out_data->vertical_swing_mode = (uint8_t) this->settings_.last_vertiacal_swing;
          break;
        case CLIMATE_SWING_VERTICAL:
          out_data->horizontal_swing_mode = (uint8_t) this->settings_.last_horizontal_swing;
          out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::AUTO;
          break;
        case CLIMATE_SWING_HORIZONTAL:
          out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::AUTO;
          out_data->vertical_swing_mode = (uint8_t) this->settings_.last_vertiacal_swing;
          break;
        case CLIMATE_SWING_BOTH:
          out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::AUTO;
          out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::AUTO;
          break;
      }
    }
    if (climate_control.target_temperature.has_value()) {
      float target_temp = climate_control.target_temperature.value();
      out_data->set_point = ((int) target_temp) - 16;  // set the temperature with offset 16
      out_data->half_degree = (target_temp - ((int) target_temp) >= 0.49f) ? 1 : 0;
    }
    if (out_data->ac_power == 0) {
      // If AC is off - no presets allowed
      out_data->fast_mode = 0;
      out_data->sleep_mode = 0;
    } else if (climate_control.preset.has_value()) {
      switch (climate_control.preset.value()) {
        case CLIMATE_PRESET_NONE:
          out_data->fast_mode = 0;
          out_data->sleep_mode = 0;
          out_data->ten_degree = 0;
          break;
        case CLIMATE_PRESET_BOOST:
          // Boost is not supported in Fan only mode
          out_data->fast_mode = (this->mode != CLIMATE_MODE_FAN_ONLY) ? 1 : 0;
          out_data->sleep_mode = 0;
          out_data->ten_degree = 0;
          break;
        case CLIMATE_PRESET_AWAY:
          out_data->fast_mode = 0;
          out_data->sleep_mode = 0;
          // 10 degrees allowed only in heat mode
          out_data->ten_degree = (this->mode == CLIMATE_MODE_HEAT) ? 1 : 0;
          break;
        case CLIMATE_PRESET_SLEEP:
          out_data->fast_mode = 0;
          out_data->sleep_mode = 1;
          out_data->ten_degree = 0;
          break;
        default:
          ESP_LOGE("Control", "Unsupported preset");
          out_data->fast_mode = 0;
          out_data->sleep_mode = 0;
          out_data->ten_degree = 0;
          break;
      }
    }
  }
  const ClimateSwingMode target_swing_mode = this->current_hvac_settings_.swing_mode.value_or(this->swing_mode);
  if (this->pending_vertical_direction_.has_value()) {
    if (!vertical_axis_is_auto(target_swing_mode)) {
      out_data->vertical_swing_mode = (uint8_t) this->pending_vertical_direction_.value();
    } else {
      ESP_LOGD(TAG, "Vertical swing is on; the position is kept for when it is turned off");
    }
    this->pending_vertical_direction_.reset();
  }
  if (this->pending_horizontal_direction_.has_value()) {
    if (!horizontal_axis_is_auto(target_swing_mode)) {
      out_data->horizontal_swing_mode = (uint8_t) this->pending_horizontal_direction_.value();
    } else {
      ESP_LOGD(TAG, "Horizontal swing is on; the position is kept for when it is turned off");
    }
    this->pending_horizontal_direction_.reset();
  }
  {
    // Quiet mode
    if ((out_data->ac_power == 0) || (out_data->ac_mode == (uint8_t) hon_protocol::ConditioningMode::FAN)) {
      // If AC is off or in fan only mode - no quiet mode allowed
      out_data->quiet_mode = 0;
    } else {
      out_data->quiet_mode = this->get_quiet_mode_state() ? 1 : 0;
    }
    // Clean quiet mode state pending flag
    this->quiet_mode_state_ = (SwitchState) ((uint8_t) this->quiet_mode_state_ & 0b01);
  }
  out_data->beeper_status = ((!this->get_beeper_state()) || (!has_hvac_settings)) ? 1 : 0;
  out_data->display_status = this->get_display_state() ? 1 : 0;
  this->display_status_ = (SwitchState) ((uint8_t) this->display_status_ & 0b01);
  out_data->health_mode = this->get_health_mode() ? 1 : 0;
  this->health_mode_ = (SwitchState) ((uint8_t) this->health_mode_ & 0b01);
  return haier_protocol::HaierMessage(haier_protocol::FrameType::CONTROL,
                                      (uint16_t) hon_protocol::SubcommandsControl::SET_GROUP_PARAMETERS,
                                      control_out_buffer, this->real_control_packet_size_);
}
 
void HonClimate::process_alarm_message_(const uint8_t *packet, uint8_t size, bool check_new) {
  constexpr size_t active_alarms_size = sizeof(this->active_alarms_);
  if (size >= active_alarms_size + 2) {
    if (check_new) {
      size_t alarm_code = 0;
      for (int i = active_alarms_size - 1; i >= 0; i--) {
        if (packet[2 + i] != active_alarms_[i]) {
          uint8_t alarm_bit = 1;
          for (int b = 0; b < 8; b++) {
            if ((packet[2 + i] & alarm_bit) != (this->active_alarms_[i] & alarm_bit)) {
              bool alarm_status = (packet[2 + i] & alarm_bit) != 0;
              int log_level = alarm_status ? ESPHOME_LOG_LEVEL_WARN : ESPHOME_LOG_LEVEL_INFO;
#ifdef USE_ESP8266
              // Static so a delayed on_alarm automation can still read it, but only until the next
              // alarm change, including a later one in this packet; `code` stays correct
              static char alarm_message[HonAlarmMessages::MAX_LENGTH + 1];
              ESPHOME_strncpy_P(alarm_message,
                                reinterpret_cast<const char *>(
                                    HonAlarmMessages::get_progmem_str(alarm_code, HonAlarmMessages::LAST_INDEX)),
                                sizeof(alarm_message));
#else
              const char *alarm_message = HonAlarmMessages::get_progmem_str(alarm_code, HonAlarmMessages::LAST_INDEX);
#endif
              esp_log_printf_(log_level, TAG, __LINE__, "Alarm %s (%d): %s", alarm_status ? "activated" : "deactivated",
                              alarm_code, alarm_message);
              if (alarm_status) {
                this->alarm_start_callback_.call(alarm_code, alarm_message);
                this->active_alarm_count_ += 1.0f;
              } else {
                this->alarm_end_callback_.call(alarm_code, alarm_message);
                this->active_alarm_count_ -= 1.0f;
              }
            }
            alarm_bit <<= 1;
            alarm_code++;
          }
          active_alarms_[i] = packet[2 + i];
        } else {
          alarm_code += 8;
        }
      }
    } else {
      float alarm_count = 0.0f;
      static uint8_t nibble_bits_count[] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
      for (size_t i = 0; i < sizeof(this->active_alarms_); i++) {
        alarm_count += (float) (nibble_bits_count[packet[2 + i] & 0x0F] + nibble_bits_count[packet[2 + i] >> 4]);
      }
      this->active_alarm_count_ = alarm_count;
      memcpy(this->active_alarms_, packet + 2, sizeof(this->active_alarms_));
    }
  }
}
 
#ifdef USE_SENSOR
void HonClimate::set_sub_sensor(SubSensorType type, sensor::Sensor *sens) {
  if (type < SubSensorType::SUB_SENSOR_TYPE_COUNT) {
    if (type >= SubSensorType::BIG_DATA_FRAME_SUB_SENSORS) {
      if ((this->sub_sensors_[(size_t) type] != nullptr) && (sens == nullptr)) {
        this->big_data_sensors_--;
      } else if ((this->sub_sensors_[(size_t) type] == nullptr) && (sens != nullptr)) {
        this->big_data_sensors_++;
      }
    }
    this->sub_sensors_[(size_t) type] = sens;
  }
}
 
void HonClimate::update_sub_sensor_(SubSensorType type, float value) {
  if (type < SubSensorType::SUB_SENSOR_TYPE_COUNT) {
    size_t index = (size_t) type;
    if ((this->sub_sensors_[index] != nullptr) &&
        ((!this->sub_sensors_[index]->has_state()) || (this->sub_sensors_[index]->get_raw_state() != value)))
      this->sub_sensors_[index]->publish_state(value);
  }
}
#endif  // USE_SENSOR
 
#ifdef USE_BINARY_SENSOR
void HonClimate::set_sub_binary_sensor(SubBinarySensorType type, binary_sensor::BinarySensor *sens) {
  if (type < SubBinarySensorType::SUB_BINARY_SENSOR_TYPE_COUNT) {
    if ((this->sub_binary_sensors_[(size_t) type] != nullptr) && (sens == nullptr)) {
      this->big_data_sensors_--;
    } else if ((this->sub_binary_sensors_[(size_t) type] == nullptr) && (sens != nullptr)) {
      this->big_data_sensors_++;
    }
    this->sub_binary_sensors_[(size_t) type] = sens;
  }
}
 
void HonClimate::update_sub_binary_sensor_(SubBinarySensorType type, uint8_t value) {
  if (value < 2) {
    bool converted_value = value == 1;
    size_t index = (size_t) type;
    if ((this->sub_binary_sensors_[index] != nullptr) && ((!this->sub_binary_sensors_[index]->has_state()) ||
                                                          (this->sub_binary_sensors_[index]->state != converted_value)))
      this->sub_binary_sensors_[index]->publish_state(converted_value);
  }
}
#endif  // USE_BINARY_SENSOR
 
#ifdef USE_TEXT_SENSOR
void HonClimate::set_sub_text_sensor(SubTextSensorType type, text_sensor::TextSensor *sens) {
  this->sub_text_sensors_[(size_t) type] = sens;
  switch (type) {
    case SubTextSensorType::APPLIANCE_NAME:
      if (this->hvac_hardware_info_.has_value())
        sens->publish_state(this->hvac_hardware_info_.value().device_name_);
      break;
    case SubTextSensorType::PROTOCOL_VERSION:
      if (this->hvac_hardware_info_.has_value())
        sens->publish_state(this->hvac_hardware_info_.value().protocol_version_);
      break;
    case SubTextSensorType::CLEANING_STATUS:
      sens->publish_state(this->get_cleaning_status_text());
      break;
    default:
      break;
  }
}
 
void HonClimate::update_sub_text_sensor_(SubTextSensorType type, const char *value) {
  size_t index = (size_t) type;
  if (this->sub_text_sensors_[index] != nullptr)
    this->sub_text_sensors_[index]->publish_state(value);
}
#endif  // USE_TEXT_SENSOR
 
#ifdef USE_SWITCH
void HonClimate::set_beeper_switch(switch_::Switch *sw) {
  this->beeper_switch_ = sw;
  if (this->beeper_switch_ != nullptr) {
    this->beeper_switch_->publish_state(this->get_beeper_state());
  }
}
 
void HonClimate::set_quiet_mode_switch(switch_::Switch *sw) {
  this->quiet_mode_switch_ = sw;
  if (this->quiet_mode_switch_ != nullptr) {
    this->quiet_mode_switch_->publish_state(this->settings_.quiet_mode_state);
  }
}
#endif  // USE_SWITCH
 
#ifdef USE_SELECT
template<typename Mode, size_t N>
static void publish_airflow_index(select::Select *sel, const std::array<Mode, N> &order, Mode mode) {
  if (sel == nullptr) {
    return;
  }
  // Saved settings never hold AUTO after initialization(); any other value outside the table shows as Center
  size_t index = N;
  size_t center = 0;
  for (size_t i = 0; i < N; i++) {
    const Mode entry = airflow_order_at(order, i);
    if (entry == mode) {
      index = i;
    } else if (entry == Mode::CENTER) {
      center = i;
    }
  }
  if (index == N) {
    index = center;
  }
  const auto active = sel->active_index();
  if (active.has_value() && *active == index) {
    return;
  }
  sel->publish_state(index);
}
 
void HonClimate::publish_airflow_selects_() {
  publish_airflow_index(this->vertical_airflow_select_, VERTICAL_SWING_MODES_ORDER,
                        this->settings_.last_vertiacal_swing);
  publish_airflow_index(this->horizontal_airflow_select_, HORIZONTAL_SWING_MODES_ORDER,
                        this->settings_.last_horizontal_swing);
}
#endif  // USE_SELECT
 
haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *packet_buffer, uint8_t size) {
  size_t expected_size =
      2 + this->status_message_header_size_ + this->real_control_packet_size_ + this->real_sensors_packet_size_;
  if (size < expected_size) {
    ESP_LOGW(TAG, "Unexpected message size %u (expexted >= %zu)", size, expected_size);
    return haier_protocol::HandlerError::WRONG_MESSAGE_STRUCTURE;
  }
  uint16_t subtype = (((uint16_t) packet_buffer[0]) << 8) + packet_buffer[1];
  if ((subtype == 0x7D01) && (size >= expected_size + sizeof(hon_protocol::HaierPacketBigData))) {
    // Got BigData packet
    const hon_protocol::HaierPacketBigData *bd_packet =
        (const hon_protocol::HaierPacketBigData *) (&packet_buffer[expected_size]);
#ifdef USE_SENSOR
    this->update_sub_sensor_(SubSensorType::INDOOR_COIL_TEMPERATURE, bd_packet->indoor_coil_temperature / 2.0 - 20);
    this->update_sub_sensor_(SubSensorType::OUTDOOR_COIL_TEMPERATURE, bd_packet->outdoor_coil_temperature - 64);
    this->update_sub_sensor_(SubSensorType::OUTDOOR_DEFROST_TEMPERATURE, bd_packet->outdoor_defrost_temperature - 64);
    this->update_sub_sensor_(SubSensorType::OUTDOOR_IN_AIR_TEMPERATURE, bd_packet->outdoor_in_air_temperature - 64);
    this->update_sub_sensor_(SubSensorType::OUTDOOR_OUT_AIR_TEMPERATURE, bd_packet->outdoor_out_air_temperature - 64);
    this->update_sub_sensor_(SubSensorType::POWER, encode_uint16(bd_packet->power[0], bd_packet->power[1]));
    this->update_sub_sensor_(SubSensorType::COMPRESSOR_FREQUENCY, bd_packet->compressor_frequency);
    this->update_sub_sensor_(SubSensorType::COMPRESSOR_CURRENT,
                             encode_uint16(bd_packet->compressor_current[0], bd_packet->compressor_current[1]) / 10.0);
    this->update_sub_sensor_(
        SubSensorType::EXPANSION_VALVE_OPEN_DEGREE,
        encode_uint16(bd_packet->expansion_valve_open_degree[0], bd_packet->expansion_valve_open_degree[1]) / 4095.0);
#endif  // USE_SENSOR
#ifdef USE_BINARY_SENSOR
    this->update_sub_binary_sensor_(SubBinarySensorType::OUTDOOR_FAN_STATUS, bd_packet->outdoor_fan_status);
    this->update_sub_binary_sensor_(SubBinarySensorType::DEFROST_STATUS, bd_packet->defrost_status);
    this->update_sub_binary_sensor_(SubBinarySensorType::COMPRESSOR_STATUS, bd_packet->compressor_status);
    this->update_sub_binary_sensor_(SubBinarySensorType::INDOOR_FAN_STATUS, bd_packet->indoor_fan_status);
    this->update_sub_binary_sensor_(SubBinarySensorType::FOUR_WAY_VALVE_STATUS, bd_packet->four_way_valve_status);
    this->update_sub_binary_sensor_(SubBinarySensorType::INDOOR_ELECTRIC_HEATING_STATUS,
                                    bd_packet->indoor_electric_heating_status);
#endif  // USE_BINARY_SENSOR
  }
  struct {
    hon_protocol::HaierPacketControl control;
    hon_protocol::HaierPacketSensors sensors;
  } packet;
  memcpy(&packet.control, packet_buffer + 2 + this->status_message_header_size_,
         sizeof(hon_protocol::HaierPacketControl));
  memcpy(&packet.sensors, packet_buffer + 2 + this->status_message_header_size_ + this->real_control_packet_size_,
         sizeof(hon_protocol::HaierPacketSensors));
  if (packet.sensors.error_status != 0) {
    ESP_LOGW(TAG, "HVAC error, code=0x%02X", packet.sensors.error_status);
  }
#ifdef USE_SENSOR
  if ((this->sub_sensors_[(size_t) SubSensorType::OUTDOOR_TEMPERATURE] != nullptr) &&
      (this->got_valid_outdoor_temp_ || (packet.sensors.outdoor_temperature > 0))) {
    this->got_valid_outdoor_temp_ = true;
    this->update_sub_sensor_(SubSensorType::OUTDOOR_TEMPERATURE,
                             (float) (packet.sensors.outdoor_temperature + PROTOCOL_OUTDOOR_TEMPERATURE_OFFSET));
  }
  if ((this->sub_sensors_[(size_t) SubSensorType::HUMIDITY] != nullptr) && (packet.sensors.room_humidity <= 100)) {
    this->update_sub_sensor_(SubSensorType::HUMIDITY, (float) packet.sensors.room_humidity);
  }
#endif  // USE_SENSOR
  bool should_publish = false;
  {
    // Extra modes/presets
    optional<ClimatePreset> old_preset = this->preset;
    if (packet.control.fast_mode != 0) {
      this->preset = CLIMATE_PRESET_BOOST;
    } else if (packet.control.sleep_mode != 0) {
      this->preset = CLIMATE_PRESET_SLEEP;
    } else if (packet.control.ten_degree != 0) {
      this->preset = CLIMATE_PRESET_AWAY;
    } else {
      this->preset = CLIMATE_PRESET_NONE;
    }
    should_publish = should_publish || (!old_preset.has_value()) ||
                     (old_preset.value_or(CLIMATE_PRESET_NONE) != this->preset.value_or(CLIMATE_PRESET_NONE));
  }
  {
    // Target temperature
    float old_target_temperature = this->target_temperature;
    this->target_temperature = packet.control.set_point + 16.0f + ((packet.control.half_degree == 1) ? 0.5f : 0.0f);
    should_publish = should_publish || (old_target_temperature != this->target_temperature);
  }
  {
    // Current temperature
    float old_current_temperature = this->current_temperature;
    this->current_temperature = packet.sensors.room_temperature / 2.0f;
    should_publish = should_publish || (old_current_temperature != this->current_temperature);
  }
  {
    // Fan mode
    optional<ClimateFanMode> old_fan_mode = this->fan_mode;
    // remember the fan speed we last had for climate vs fan
    if (packet.control.ac_mode == (uint8_t) hon_protocol::ConditioningMode::FAN) {
      if (packet.control.fan_mode != (uint8_t) hon_protocol::FanMode::FAN_AUTO)
        this->fan_mode_speed_ = packet.control.fan_mode;
    } else {
      this->other_modes_fan_speed_ = packet.control.fan_mode;
    }
    switch (packet.control.fan_mode) {
      case (uint8_t) hon_protocol::FanMode::FAN_AUTO:
        if (packet.control.ac_mode != (uint8_t) hon_protocol::ConditioningMode::FAN) {
          this->fan_mode = CLIMATE_FAN_AUTO;
        } else {
          // Shouldn't accept fan speed auto in fan-only mode even if AC reports it
          ESP_LOGI(TAG, "Fan speed Auto is not supported in Fan only AC mode, ignoring");
        }
        break;
      case (uint8_t) hon_protocol::FanMode::FAN_MID:
        this->fan_mode = CLIMATE_FAN_MEDIUM;
        break;
      case (uint8_t) hon_protocol::FanMode::FAN_LOW:
        this->fan_mode = CLIMATE_FAN_LOW;
        break;
      case (uint8_t) hon_protocol::FanMode::FAN_HIGH:
        this->fan_mode = CLIMATE_FAN_HIGH;
        break;
      default:
        break;
    }
    should_publish = should_publish || (!old_fan_mode.has_value()) ||
                     (old_fan_mode.value_or(CLIMATE_FAN_ON) != this->fan_mode.value_or(CLIMATE_FAN_ON));
  }
  // Display status
  // should be before "Climate mode" because it is changing this->mode
  if (packet.control.ac_power != 0) {
    // if AC is off display status always ON so process it only when AC is on
    bool disp_status = packet.control.display_status != 0;
    if (disp_status != this->get_display_state()) {
      // Do something only if display status changed
      if (this->mode == CLIMATE_MODE_OFF) {
        // AC just turned on from remote need to turn off display
        this->force_send_control_ = true;
      } else if ((((uint8_t) this->display_status_) & 0b10) == 0) {
        this->display_status_ = disp_status ? SwitchState::SWITCH_ON : SwitchState::SWITCH_OFF;
      }
    }
  }
  // Health mode
  if ((((uint8_t) this->health_mode_) & 0b10) == 0) {
    bool old_health_mode = this->get_health_mode();
    this->health_mode_ = packet.control.health_mode == 1 ? SwitchState::SWITCH_ON : SwitchState::SWITCH_OFF;
    should_publish = should_publish || (old_health_mode != this->get_health_mode());
  }
  {
    CleaningState new_cleaning;
    if (packet.control.steri_clean == 1) {
      // Steri-cleaning
      new_cleaning = CleaningState::STERI_CLEAN;
    } else if (packet.control.self_cleaning_status == 1) {
      // Self-cleaning
      new_cleaning = CleaningState::SELF_CLEAN;
    } else {
      // No cleaning
      new_cleaning = CleaningState::NO_CLEANING;
    }
    if (new_cleaning != this->cleaning_status_) {
      ESP_LOGD(TAG, "Cleaning status change: %d => %d", (uint8_t) this->cleaning_status_, (uint8_t) new_cleaning);
      if (new_cleaning == CleaningState::NO_CLEANING) {
        // Turning AC off after cleaning
        this->action_request_ =
            PendingAction({ActionRequest::TURN_POWER_OFF, esphome::optional<haier_protocol::HaierMessage>()});
      }
      this->cleaning_status_ = new_cleaning;
#ifdef USE_TEXT_SENSOR
      this->update_sub_text_sensor_(SubTextSensorType::CLEANING_STATUS, this->get_cleaning_status_text());
#endif  // USE_TEXT_SENSOR
    }
  }
  {
    // Climate mode
    ClimateMode old_mode = this->mode;
    if (packet.control.ac_power == 0) {
      this->mode = CLIMATE_MODE_OFF;
    } else {
      // Check current hvac mode
      switch (packet.control.ac_mode) {
        case (uint8_t) hon_protocol::ConditioningMode::COOL:
          this->mode = CLIMATE_MODE_COOL;
          break;
        case (uint8_t) hon_protocol::ConditioningMode::HEAT:
          this->mode = CLIMATE_MODE_HEAT;
          break;
        case (uint8_t) hon_protocol::ConditioningMode::DRY:
          this->mode = CLIMATE_MODE_DRY;
          break;
        case (uint8_t) hon_protocol::ConditioningMode::FAN:
          this->mode = CLIMATE_MODE_FAN_ONLY;
          break;
        case (uint8_t) hon_protocol::ConditioningMode::AUTO:
          this->mode = CLIMATE_MODE_HEAT_COOL;
          break;
        default:
          break;
      }
    }
    should_publish = should_publish || (old_mode != this->mode);
  }
  {
    // Quiet mode, should be after climate mode
    if ((this->mode != CLIMATE_MODE_FAN_ONLY) && (this->mode != CLIMATE_MODE_OFF) &&
        ((((uint8_t) this->quiet_mode_state_) & 0b10) == 0)) {
      // In proper mode and not in pending state
      bool new_quiet_mode = packet.control.quiet_mode != 0;
      if (new_quiet_mode != this->get_quiet_mode_state()) {
        this->quiet_mode_state_ = new_quiet_mode ? SwitchState::SWITCH_ON : SwitchState::SWITCH_OFF;
        this->settings_.quiet_mode_state = new_quiet_mode;
#ifdef USE_SWITCH
        if (this->quiet_mode_switch_ != nullptr) {
          this->quiet_mode_switch_->publish_state(new_quiet_mode);
        }
#endif  // USE_SWITCH
        this->hon_rtc_.save(&this->settings_);
      }
    }
  }
  {
    // Swing mode
    ClimateSwingMode old_swing_mode = this->swing_mode;
    const auto &swing_modes = traits_.get_supported_swing_modes();
    bool vertical_swing_supported = swing_modes.count(CLIMATE_SWING_VERTICAL);
    bool horizontal_swing_supported = swing_modes.count(CLIMATE_SWING_HORIZONTAL);
    if (horizontal_swing_supported &&
        (packet.control.horizontal_swing_mode == (uint8_t) hon_protocol::HorizontalSwingMode::AUTO)) {
      if (vertical_swing_supported &&
          (packet.control.vertical_swing_mode == (uint8_t) hon_protocol::VerticalSwingMode::AUTO)) {
        this->swing_mode = CLIMATE_SWING_BOTH;
      } else {
        this->swing_mode = CLIMATE_SWING_HORIZONTAL;
      }
    } else {
      if (vertical_swing_supported &&
          (packet.control.vertical_swing_mode == (uint8_t) hon_protocol::VerticalSwingMode::AUTO)) {
        this->swing_mode = CLIMATE_SWING_VERTICAL;
      } else {
        this->swing_mode = CLIMATE_SWING_OFF;
      }
    }
    // Saving last known non auto mode for vertical and horizontal swing
    this->current_vertical_swing_ = (hon_protocol::VerticalSwingMode) packet.control.vertical_swing_mode;
    this->current_horizontal_swing_ = (hon_protocol::HorizontalSwingMode) packet.control.horizontal_swing_mode;
    const uint32_t now_ms = App.get_loop_component_start_time();
    bool save_vertical = !in_debounce(this->vertical_direction_set_time_, now_ms) &&
                         !is_auto(this->current_vertical_swing_.value()) &&
                         (this->current_vertical_swing_.value() != this->settings_.last_vertiacal_swing);
    bool save_horizontal = !in_debounce(this->horizontal_direction_set_time_, now_ms) &&
                           !is_auto(this->current_horizontal_swing_.value()) &&
                           (this->current_horizontal_swing_.value() != this->settings_.last_horizontal_swing);
    if (save_vertical || save_horizontal) {
      if (save_vertical) {
        this->settings_.last_vertiacal_swing = this->current_vertical_swing_.value();
      }
      if (save_horizontal) {
        this->settings_.last_horizontal_swing = this->current_horizontal_swing_.value();
      }
      this->hon_rtc_.save(&this->settings_);
    }
#ifdef USE_SELECT
    this->publish_airflow_selects_();
#endif
    should_publish = should_publish || (old_swing_mode != this->swing_mode);
  }
  this->last_valid_status_timestamp_ = std::chrono::steady_clock::now();
  if (should_publish) {
    this->publish_state();
  }
  if (should_publish) {
    ESP_LOGI(TAG, "HVAC values changed");
  }
  int log_level = should_publish ? ESPHOME_LOG_LEVEL_INFO : ESPHOME_LOG_LEVEL_DEBUG;
  esp_log_printf_(log_level, TAG, __LINE__, "HVAC Mode = 0x%X", packet.control.ac_mode);
  esp_log_printf_(log_level, TAG, __LINE__, "Fan speed Status = 0x%X", packet.control.fan_mode);
  esp_log_printf_(log_level, TAG, __LINE__, "Horizontal Swing Status = 0x%X", packet.control.horizontal_swing_mode);
  esp_log_printf_(log_level, TAG, __LINE__, "Vertical Swing Status = 0x%X", packet.control.vertical_swing_mode);
  esp_log_printf_(log_level, TAG, __LINE__, "Set Point Status = 0x%X", packet.control.set_point);
  return haier_protocol::HandlerError::HANDLER_OK;
}
 
void HonClimate::fill_control_messages_queue_() {
  if (!this->current_hvac_settings_.valid && !this->force_send_control_)
    return;
  this->clear_control_messages_queue_();
  HvacSettings climate_control;
  climate_control = this->current_hvac_settings_;
  // Beeper command
  {
    this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                          (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                              (uint8_t) hon_protocol::DataParameters::BEEPER_STATUS,
                                          this->get_beeper_state() ? ZERO_BUF : ONE_BUF, 2);
  }
  // Health mode
  {
    this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                          (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                              (uint8_t) hon_protocol::DataParameters::HEALTH_MODE,
                                          this->get_health_mode() ? ONE_BUF : ZERO_BUF, 2);
    this->health_mode_ = (SwitchState) ((uint8_t) this->health_mode_ & 0b01);
  }
  // Climate mode
  ClimateMode climate_mode = this->mode;
  bool new_power = this->mode != CLIMATE_MODE_OFF;
  uint8_t fan_mode_buf[] = {0x00, 0xFF};
  uint8_t quiet_mode_buf[] = {0x00, 0xFF};
  if (climate_control.mode.has_value()) {
    climate_mode = climate_control.mode.value();
    uint8_t buffer[2] = {0x00, 0x00};
    switch (climate_control.mode.value()) {
      case CLIMATE_MODE_OFF:
        new_power = false;
        break;
      case CLIMATE_MODE_HEAT_COOL:
        new_power = true;
        buffer[1] = (uint8_t) hon_protocol::ConditioningMode::AUTO;
        this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                              (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                  (uint8_t) hon_protocol::DataParameters::AC_MODE,
                                              buffer, 2);
        fan_mode_buf[1] = this->other_modes_fan_speed_;
        break;
      case CLIMATE_MODE_HEAT:
        new_power = true;
        buffer[1] = (uint8_t) hon_protocol::ConditioningMode::HEAT;
        this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                              (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                  (uint8_t) hon_protocol::DataParameters::AC_MODE,
                                              buffer, 2);
        fan_mode_buf[1] = this->other_modes_fan_speed_;
        break;
      case CLIMATE_MODE_DRY:
        new_power = true;
        buffer[1] = (uint8_t) hon_protocol::ConditioningMode::DRY;
        this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                              (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                  (uint8_t) hon_protocol::DataParameters::AC_MODE,
                                              buffer, 2);
        fan_mode_buf[1] = this->other_modes_fan_speed_;
        break;
      case CLIMATE_MODE_FAN_ONLY:
        new_power = true;
        buffer[1] = (uint8_t) hon_protocol::ConditioningMode::FAN;
        this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                              (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                  (uint8_t) hon_protocol::DataParameters::AC_MODE,
                                              buffer, 2);
        fan_mode_buf[1] = this->other_modes_fan_speed_;  // Auto doesn't work in fan only mode
        break;
      case CLIMATE_MODE_COOL:
        new_power = true;
        buffer[1] = (uint8_t) hon_protocol::ConditioningMode::COOL;
        this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                              (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                  (uint8_t) hon_protocol::DataParameters::AC_MODE,
                                              buffer, 2);
        fan_mode_buf[1] = this->other_modes_fan_speed_;
        break;
      default:
        ESP_LOGE("Control", "Unsupported climate mode");
        break;
    }
  }
  // Climate power
  {
    this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                          (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                              (uint8_t) hon_protocol::DataParameters::AC_POWER,
                                          new_power ? ONE_BUF : ZERO_BUF, 2);
  }
  // CLimate preset
  {
    uint8_t fast_mode_buf[] = {0x00, 0xFF};
    uint8_t away_mode_buf[] = {0x00, 0xFF};
    if (!new_power) {
      // If AC is off - no presets allowed
      fast_mode_buf[1] = 0x00;
      away_mode_buf[1] = 0x00;
    } else if (climate_control.preset.has_value()) {
      switch (climate_control.preset.value()) {
        case CLIMATE_PRESET_NONE:
          fast_mode_buf[1] = 0x00;
          away_mode_buf[1] = 0x00;
          break;
        case CLIMATE_PRESET_BOOST:
          // Boost is not supported in Fan only mode
          fast_mode_buf[1] = (this->mode != CLIMATE_MODE_FAN_ONLY) ? 0x01 : 0x00;
          away_mode_buf[1] = 0x00;
          break;
        case CLIMATE_PRESET_AWAY:
          fast_mode_buf[1] = 0x00;
          away_mode_buf[1] = (this->mode == CLIMATE_MODE_HEAT) ? 0x01 : 0x00;
          break;
        default:
          ESP_LOGE("Control", "Unsupported preset");
          break;
      }
    }
    {
      // Quiet mode
      if (new_power && (climate_mode != CLIMATE_MODE_FAN_ONLY) && this->get_quiet_mode_state()) {
        quiet_mode_buf[1] = 0x01;
      } else {
        quiet_mode_buf[1] = 0x00;
      }
      // Clean quiet mode state pending flag
      this->quiet_mode_state_ = (SwitchState) ((uint8_t) this->quiet_mode_state_ & 0b01);
    }
    auto presets = this->traits_.get_supported_presets();
    if (quiet_mode_buf[1] != 0xFF) {
      this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                            (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                (uint8_t) hon_protocol::DataParameters::QUIET_MODE,
                                            quiet_mode_buf, 2);
    }
    if ((fast_mode_buf[1] != 0xFF) && presets.count(climate::ClimatePreset::CLIMATE_PRESET_BOOST)) {
      this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                            (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                (uint8_t) hon_protocol::DataParameters::FAST_MODE,
                                            fast_mode_buf, 2);
    }
    if ((away_mode_buf[1] != 0xFF) && presets.count(climate::ClimatePreset::CLIMATE_PRESET_AWAY)) {
      this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                            (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                (uint8_t) hon_protocol::DataParameters::TEN_DEGREE,
                                            away_mode_buf, 2);
    }
  }
  // Target temperature
  if (climate_control.target_temperature.has_value() && (this->mode != ClimateMode::CLIMATE_MODE_FAN_ONLY)) {
    uint8_t buffer[2] = {0x00, 0x00};
    buffer[1] = ((uint8_t) climate_control.target_temperature.value()) - 16;
    this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                          (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                              (uint8_t) hon_protocol::DataParameters::SET_POINT,
                                          buffer, 2);
  }
  ClimateSwingMode target_swing_mode = this->swing_mode;
  // Vertical swing mode
  if (climate_control.swing_mode.has_value()) {
    target_swing_mode = climate_control.swing_mode.value();
    uint8_t vertical_swing_buf[] = {0x00, (uint8_t) hon_protocol::VerticalSwingMode::AUTO};
    uint8_t horizontal_swing_buf[] = {0x00, (uint8_t) hon_protocol::HorizontalSwingMode::AUTO};
    switch (climate_control.swing_mode.value()) {
      case CLIMATE_SWING_OFF:
        horizontal_swing_buf[1] = (uint8_t) this->settings_.last_horizontal_swing;
        vertical_swing_buf[1] = (uint8_t) this->settings_.last_vertiacal_swing;
        break;
      case CLIMATE_SWING_VERTICAL:
        horizontal_swing_buf[1] = (uint8_t) this->settings_.last_horizontal_swing;
        break;
      case CLIMATE_SWING_HORIZONTAL:
        vertical_swing_buf[1] = (uint8_t) this->settings_.last_vertiacal_swing;
        break;
      case CLIMATE_SWING_BOTH:
        break;
    }
    this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                          (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                              (uint8_t) hon_protocol::DataParameters::HORIZONTAL_SWING_MODE,
                                          horizontal_swing_buf, 2);
    this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                          (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                              (uint8_t) hon_protocol::DataParameters::VERTICAL_SWING_MODE,
                                          vertical_swing_buf, 2);
  }
  // A swing change above already sent both axes from settings_.last_*, which set_*_airflow() updated
  const bool swing_sent = climate_control.swing_mode.has_value();
  if (this->pending_vertical_direction_.has_value()) {
    if (vertical_axis_is_auto(target_swing_mode)) {
      ESP_LOGD(TAG, "Vertical swing is on; the position is kept for when it is turned off");
    } else if (!swing_sent) {
      uint8_t vertical_swing_buf[] = {0x00, (uint8_t) this->pending_vertical_direction_.value()};
      this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                            (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                (uint8_t) hon_protocol::DataParameters::VERTICAL_SWING_MODE,
                                            vertical_swing_buf, 2);
    }
    this->pending_vertical_direction_.reset();
  }
  if (this->pending_horizontal_direction_.has_value()) {
    if (horizontal_axis_is_auto(target_swing_mode)) {
      ESP_LOGD(TAG, "Horizontal swing is on; the position is kept for when it is turned off");
    } else if (!swing_sent) {
      uint8_t horizontal_swing_buf[] = {0x00, (uint8_t) this->pending_horizontal_direction_.value()};
      this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                            (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                (uint8_t) hon_protocol::DataParameters::HORIZONTAL_SWING_MODE,
                                            horizontal_swing_buf, 2);
    }
    this->pending_horizontal_direction_.reset();
  }
  // Fan mode
  if (climate_control.fan_mode.has_value()) {
    switch (climate_control.fan_mode.value()) {
      case CLIMATE_FAN_LOW:
        fan_mode_buf[1] = (uint8_t) hon_protocol::FanMode::FAN_LOW;
        break;
      case CLIMATE_FAN_MEDIUM:
        fan_mode_buf[1] = (uint8_t) hon_protocol::FanMode::FAN_MID;
        break;
      case CLIMATE_FAN_HIGH:
        fan_mode_buf[1] = (uint8_t) hon_protocol::FanMode::FAN_HIGH;
        break;
      case CLIMATE_FAN_AUTO:
        if (mode != CLIMATE_MODE_FAN_ONLY)  // if we are not in fan only mode
          fan_mode_buf[1] = (uint8_t) hon_protocol::FanMode::FAN_AUTO;
        break;
      default:
        ESP_LOGE("Control", "Unsupported fan mode");
        break;
    }
    if (fan_mode_buf[1] != 0xFF) {
      this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                            (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                (uint8_t) hon_protocol::DataParameters::FAN_MODE,
                                            fan_mode_buf, 2);
    }
  }
}
 
void HonClimate::clear_control_messages_queue_() {
  while (!this->control_messages_queue_.empty())
    this->control_messages_queue_.pop();
}
 
bool HonClimate::prepare_pending_action() {
  auto &action_request = this->action_request_.value();  // NOLINT(bugprone-unchecked-optional-access)
  switch (action_request.action) {
    case ActionRequest::START_SELF_CLEAN:
      if (this->control_method_ == HonControlMethod::SET_GROUP_PARAMETERS) {
        uint8_t control_out_buffer[haier_protocol::MAX_FRAME_SIZE];
        memcpy(control_out_buffer, this->last_status_message_.get(), this->real_control_packet_size_);
        hon_protocol::HaierPacketControl *out_data = (hon_protocol::HaierPacketControl *) control_out_buffer;
        out_data->self_cleaning_status = 1;
        out_data->steri_clean = 0;
        out_data->set_point = 0x06;
        out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::CENTER;
        out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::CENTER;
        out_data->ac_power = 1;
        out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
        out_data->light_status = 0;
        action_request.message = haier_protocol::HaierMessage(
            haier_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcommandsControl::SET_GROUP_PARAMETERS,
            control_out_buffer, this->real_control_packet_size_);
        return true;
      } else if (this->control_method_ == HonControlMethod::SET_SINGLE_PARAMETER) {
        action_request.message =
            haier_protocol::HaierMessage(haier_protocol::FrameType::CONTROL,
                                         (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                             (uint8_t) hon_protocol::DataParameters::SELF_CLEANING,
                                         ONE_BUF, 2);
        return true;
      } else {
        this->action_request_.reset();
        return false;
      }
    case ActionRequest::START_STERI_CLEAN:
      if (this->control_method_ == HonControlMethod::SET_GROUP_PARAMETERS) {
        uint8_t control_out_buffer[haier_protocol::MAX_FRAME_SIZE];
        memcpy(control_out_buffer, this->last_status_message_.get(), this->real_control_packet_size_);
        hon_protocol::HaierPacketControl *out_data = (hon_protocol::HaierPacketControl *) control_out_buffer;
        out_data->self_cleaning_status = 0;
        out_data->steri_clean = 1;
        out_data->set_point = 0x06;
        out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::CENTER;
        out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::CENTER;
        out_data->ac_power = 1;
        out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
        out_data->light_status = 0;
        action_request.message = haier_protocol::HaierMessage(
            haier_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcommandsControl::SET_GROUP_PARAMETERS,
            control_out_buffer, this->real_control_packet_size_);
        return true;
      } else {
        // No Steri clean support (yet?) in SET_SINGLE_PARAMETER
        this->action_request_.reset();
        return false;
      }
    default:
      return HaierClimateBase::prepare_pending_action();
  }
}
 
void HonClimate::process_protocol_reset() {
  HaierClimateBase::process_protocol_reset();
#ifdef USE_SENSOR
  for (auto &sub_sensor : this->sub_sensors_) {
    if ((sub_sensor != nullptr) && sub_sensor->has_state())
      sub_sensor->publish_state(NAN);
  }
#endif  // USE_SENSOR
  this->got_valid_outdoor_temp_ = false;
  this->hvac_hardware_info_.reset();
  this->last_status_message_.reset(nullptr);
}
 
bool HonClimate::should_get_big_data_() {
  if (this->big_data_sensors_ > 0) {
    this->big_data_counter_ = (this->big_data_counter_ + 1) % 3;
    return this->big_data_counter_ == 1;
  }
  return false;
}
 
}  // namespace esphome::haier