Haier component updated to support new protocol variations (#5713)

Co-authored-by: Pavlo Dudnytskyi <pdudnytskyi@astrata.eu>
2026-05-28 08:48:27 +02:00 · 2023-11-21 02:12:36 +01:00
parent 55f13dc347
commit cf6b56c1ac
10 changed files with 870 additions and 717 deletions
@@ -19,56 +19,45 @@ constexpr size_t STATUS_REQUEST_INTERVAL_MS = 5000;
 constexpr size_t PROTOCOL_INITIALIZATION_INTERVAL = 10000;
 constexpr size_t DEFAULT_MESSAGES_INTERVAL_MS = 2000;
 constexpr size_t CONTROL_MESSAGES_INTERVAL_MS = 400;
-constexpr size_t CONTROL_TIMEOUT_MS = 7000;
-constexpr size_t NO_COMMAND = 0xFF;  // Indicate that there is no command supplied

-#if (HAIER_LOG_LEVEL > 4)
-// To reduce size of binary this function only available when log level is Verbose
 const char *HaierClimateBase::phase_to_string_(ProtocolPhases phase) {
  static const char *phase_names[] = {
      "SENDING_INIT_1",
-      "WAITING_INIT_1_ANSWER",
      "SENDING_INIT_2",
-      "WAITING_INIT_2_ANSWER",
      "SENDING_FIRST_STATUS_REQUEST",
-      "WAITING_FIRST_STATUS_ANSWER",
      "SENDING_ALARM_STATUS_REQUEST",
-      "WAITING_ALARM_STATUS_ANSWER",
      "IDLE",
-      "UNKNOWN",
      "SENDING_STATUS_REQUEST",
-      "WAITING_STATUS_ANSWER",
      "SENDING_UPDATE_SIGNAL_REQUEST",
-      "WAITING_UPDATE_SIGNAL_ANSWER",
      "SENDING_SIGNAL_LEVEL",
-      "WAITING_SIGNAL_LEVEL_ANSWER",
      "SENDING_CONTROL",
-      "WAITING_CONTROL_ANSWER",
-      "SENDING_POWER_ON_COMMAND",
-      "WAITING_POWER_ON_ANSWER",
-      "SENDING_POWER_OFF_COMMAND",
-      "WAITING_POWER_OFF_ANSWER",
+      "SENDING_ACTION_COMMAND",
      "UNKNOWN"  // Should be the last!
  };
+  static_assert(
+      (sizeof(phase_names) / sizeof(char *)) == (((int) ProtocolPhases::NUM_PROTOCOL_PHASES) + 1),
+      "Wrong phase_names array size. Please, make sure that this array is aligned with the enum ProtocolPhases");
  int phase_index = (int) phase;
  if ((phase_index > (int) ProtocolPhases::NUM_PROTOCOL_PHASES) || (phase_index < 0))
    phase_index = (int) ProtocolPhases::NUM_PROTOCOL_PHASES;
  return phase_names[phase_index];
 }
-#endif
+
+bool check_timeout(std::chrono::steady_clock::time_point now, std::chrono::steady_clock::time_point tpoint,
+                   size_t timeout) {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(now - tpoint).count() > timeout;
+}

 HaierClimateBase::HaierClimateBase()
    : haier_protocol_(*this),
      protocol_phase_(ProtocolPhases::SENDING_INIT_1),
-      action_request_(ActionRequest::NO_ACTION),
      display_status_(true),
      health_mode_(false),
      force_send_control_(false),
-      forced_publish_(false),
      forced_request_status_(false),
-      first_control_attempt_(false),
      reset_protocol_request_(false),
-      send_wifi_signal_(true) {
+      send_wifi_signal_(true),
+      use_crc_(false) {
  this->traits_ = climate::ClimateTraits();
  this->traits_.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_COOL, climate::CLIMATE_MODE_HEAT,
                                     climate::CLIMATE_MODE_FAN_ONLY, climate::CLIMATE_MODE_DRY,
@@ -84,42 +73,43 @@ HaierClimateBase::~HaierClimateBase() {}

 void HaierClimateBase::set_phase(ProtocolPhases phase) {
  if (this->protocol_phase_ != phase) {
-#if (HAIER_LOG_LEVEL > 4)
    ESP_LOGV(TAG, "Phase transition: %s => %s", phase_to_string_(this->protocol_phase_), phase_to_string_(phase));
-#else
-    ESP_LOGV(TAG, "Phase transition: %d => %d", (int) this->protocol_phase_, (int) phase);
-#endif
    this->protocol_phase_ = phase;
  }
 }

-bool HaierClimateBase::check_timeout_(std::chrono::steady_clock::time_point now,
-                                      std::chrono::steady_clock::time_point tpoint, size_t timeout) {
-  return std::chrono::duration_cast<std::chrono::milliseconds>(now - tpoint).count() > timeout;
+void HaierClimateBase::reset_phase_() {
+  this->set_phase((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
+                                                                  : ProtocolPhases::SENDING_INIT_1);
+}
+
+void HaierClimateBase::reset_to_idle_() {
+  this->force_send_control_ = false;
+  if (this->current_hvac_settings_.valid)
+    this->current_hvac_settings_.reset();
+  this->forced_request_status_ = true;
+  this->set_phase(ProtocolPhases::IDLE);
+  this->action_request_.reset();
 }

 bool HaierClimateBase::is_message_interval_exceeded_(std::chrono::steady_clock::time_point now) {
-  return this->check_timeout_(now, this->last_request_timestamp_, DEFAULT_MESSAGES_INTERVAL_MS);
+  return check_timeout(now, this->last_request_timestamp_, DEFAULT_MESSAGES_INTERVAL_MS);
 }

 bool HaierClimateBase::is_status_request_interval_exceeded_(std::chrono::steady_clock::time_point now) {
-  return this->check_timeout_(now, this->last_status_request_, STATUS_REQUEST_INTERVAL_MS);
-}
-
-bool HaierClimateBase::is_control_message_timeout_exceeded_(std::chrono::steady_clock::time_point now) {
-  return this->check_timeout_(now, this->control_request_timestamp_, CONTROL_TIMEOUT_MS);
+  return check_timeout(now, this->last_status_request_, STATUS_REQUEST_INTERVAL_MS);
 }

 bool HaierClimateBase::is_control_message_interval_exceeded_(std::chrono::steady_clock::time_point now) {
-  return this->check_timeout_(now, this->last_request_timestamp_, CONTROL_MESSAGES_INTERVAL_MS);
+  return check_timeout(now, this->last_request_timestamp_, CONTROL_MESSAGES_INTERVAL_MS);
 }

 bool HaierClimateBase::is_protocol_initialisation_interval_exceeded_(std::chrono::steady_clock::time_point now) {
-  return this->check_timeout_(now, this->last_request_timestamp_, PROTOCOL_INITIALIZATION_INTERVAL);
+  return check_timeout(now, this->last_request_timestamp_, PROTOCOL_INITIALIZATION_INTERVAL);
 }

 #ifdef USE_WIFI
-haier_protocol::HaierMessage HaierClimateBase::get_wifi_signal_message_(uint8_t message_type) {
+haier_protocol::HaierMessage HaierClimateBase::get_wifi_signal_message_() {
  static uint8_t wifi_status_data[4] = {0x00, 0x00, 0x00, 0x00};
  if (wifi::global_wifi_component->is_connected()) {
    wifi_status_data[1] = 0;
@@ -131,7 +121,8 @@ haier_protocol::HaierMessage HaierClimateBase::get_wifi_signal_message_(uint8_t
    wifi_status_data[1] = 1;
    wifi_status_data[3] = 0;
  }
-  return haier_protocol::HaierMessage(message_type, wifi_status_data, sizeof(wifi_status_data));
+  return haier_protocol::HaierMessage(haier_protocol::FrameType::REPORT_NETWORK_STATUS, wifi_status_data,
+                                      sizeof(wifi_status_data));
 }
 #endif

@@ -140,7 +131,7 @@ bool HaierClimateBase::get_display_state() const { return this->display_status_;
 void HaierClimateBase::set_display_state(bool state) {
  if (this->display_status_ != state) {
    this->display_status_ = state;
-    this->set_force_send_control_(true);
+    this->force_send_control_ = true;
  }
 }

@@ -149,15 +140,24 @@ bool HaierClimateBase::get_health_mode() const { return this->health_mode_; }
 void HaierClimateBase::set_health_mode(bool state) {
  if (this->health_mode_ != state) {
    this->health_mode_ = state;
-    this->set_force_send_control_(true);
+    this->force_send_control_ = true;
  }
 }

-void HaierClimateBase::send_power_on_command() { this->action_request_ = ActionRequest::TURN_POWER_ON; }
+void HaierClimateBase::send_power_on_command() {
+  this->action_request_ =
+      PendingAction({ActionRequest::TURN_POWER_ON, esphome::optional<haier_protocol::HaierMessage>()});
+}

-void HaierClimateBase::send_power_off_command() { this->action_request_ = ActionRequest::TURN_POWER_OFF; }
+void HaierClimateBase::send_power_off_command() {
+  this->action_request_ =
+      PendingAction({ActionRequest::TURN_POWER_OFF, esphome::optional<haier_protocol::HaierMessage>()});
+}

-void HaierClimateBase::toggle_power() { this->action_request_ = ActionRequest::TOGGLE_POWER; }
+void HaierClimateBase::toggle_power() {
+  this->action_request_ =
+      PendingAction({ActionRequest::TOGGLE_POWER, esphome::optional<haier_protocol::HaierMessage>()});
+}

 void HaierClimateBase::set_supported_swing_modes(const std::set<climate::ClimateSwingMode> &modes) {
  this->traits_.set_supported_swing_modes(modes);
@@ -165,9 +165,7 @@ void HaierClimateBase::set_supported_swing_modes(const std::set<climate::Climate
    this->traits_.add_supported_swing_mode(climate::CLIMATE_SWING_OFF);
 }

-void HaierClimateBase::set_answer_timeout(uint32_t timeout) {
-  this->answer_timeout_ = std::chrono::milliseconds(timeout);
-}
+void HaierClimateBase::set_answer_timeout(uint32_t timeout) { this->haier_protocol_.set_answer_timeout(timeout); }

 void HaierClimateBase::set_supported_modes(const std::set<climate::ClimateMode> &modes) {
  this->traits_.set_supported_modes(modes);
@@ -183,29 +181,42 @@ void HaierClimateBase::set_supported_presets(const std::set<climate::ClimatePres

 void HaierClimateBase::set_send_wifi(bool send_wifi) { this->send_wifi_signal_ = send_wifi; }

-haier_protocol::HandlerError HaierClimateBase::answer_preprocess_(uint8_t request_message_type,
-                                                                  uint8_t expected_request_message_type,
-                                                                  uint8_t answer_message_type,
-                                                                  uint8_t expected_answer_message_type,
-                                                                  ProtocolPhases expected_phase) {
+void HaierClimateBase::send_custom_command(const haier_protocol::HaierMessage &message) {
+  this->action_request_ = PendingAction({ActionRequest::SEND_CUSTOM_COMMAND, message});
+}
+
+haier_protocol::HandlerError HaierClimateBase::answer_preprocess_(
+    haier_protocol::FrameType request_message_type, haier_protocol::FrameType expected_request_message_type,
+    haier_protocol::FrameType answer_message_type, haier_protocol::FrameType expected_answer_message_type,
+    ProtocolPhases expected_phase) {
  haier_protocol::HandlerError result = haier_protocol::HandlerError::HANDLER_OK;
-  if ((expected_request_message_type != NO_COMMAND) && (request_message_type != expected_request_message_type))
+  if ((expected_request_message_type != haier_protocol::FrameType::UNKNOWN_FRAME_TYPE) &&
+      (request_message_type != expected_request_message_type))
    result = haier_protocol::HandlerError::UNSUPPORTED_MESSAGE;
-  if ((expected_answer_message_type != NO_COMMAND) && (answer_message_type != expected_answer_message_type))
+  if ((expected_answer_message_type != haier_protocol::FrameType::UNKNOWN_FRAME_TYPE) &&
+      (answer_message_type != expected_answer_message_type))
    result = haier_protocol::HandlerError::UNSUPPORTED_MESSAGE;
-  if ((expected_phase != ProtocolPhases::UNKNOWN) && (expected_phase != this->protocol_phase_))
+  if (!this->haier_protocol_.is_waiting_for_answer() ||
+      ((expected_phase != ProtocolPhases::UNKNOWN) && (expected_phase != this->protocol_phase_)))
    result = haier_protocol::HandlerError::UNEXPECTED_MESSAGE;
-  if (is_message_invalid(answer_message_type))
+  if (answer_message_type == haier_protocol::FrameType::INVALID)
    result = haier_protocol::HandlerError::INVALID_ANSWER;
  return result;
 }

-haier_protocol::HandlerError HaierClimateBase::timeout_default_handler_(uint8_t request_type) {
-#if (HAIER_LOG_LEVEL > 4)
-  ESP_LOGW(TAG, "Answer timeout for command %02X, phase %s", request_type, phase_to_string_(this->protocol_phase_));
-#else
-  ESP_LOGW(TAG, "Answer timeout for command %02X, phase %d", request_type, (int) this->protocol_phase_);
-#endif
+haier_protocol::HandlerError HaierClimateBase::report_network_status_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::REPORT_NETWORK_STATUS, message_type,
+                               haier_protocol::FrameType::CONFIRM, ProtocolPhases::SENDING_SIGNAL_LEVEL);
+  this->set_phase(ProtocolPhases::IDLE);
+  return result;
+}
+
+haier_protocol::HandlerError HaierClimateBase::timeout_default_handler_(haier_protocol::FrameType request_type) {
+  ESP_LOGW(TAG, "Answer timeout for command %02X, phase %s", (uint8_t) request_type,
+           phase_to_string_(this->protocol_phase_));
  if (this->protocol_phase_ > ProtocolPhases::IDLE) {
    this->set_phase(ProtocolPhases::IDLE);
  } else {
@@ -219,79 +230,95 @@ void HaierClimateBase::setup() {
  // Set timestamp here to give AC time to boot
  this->last_request_timestamp_ = std::chrono::steady_clock::now();
  this->set_phase(ProtocolPhases::SENDING_INIT_1);
-  this->set_handlers();
  this->haier_protocol_.set_default_timeout_handler(
      std::bind(&esphome::haier::HaierClimateBase::timeout_default_handler_, this, std::placeholders::_1));
+  this->set_handlers();
 }

 void HaierClimateBase::dump_config() {
  LOG_CLIMATE("", "Haier Climate", this);
-  ESP_LOGCONFIG(TAG, "  Device communication status: %s",
-                (this->protocol_phase_ >= ProtocolPhases::IDLE) ? "established" : "none");
+  ESP_LOGCONFIG(TAG, "  Device communication status: %s", this->valid_connection() ? "established" : "none");
 }

 void HaierClimateBase::loop() {
  std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
  if ((std::chrono::duration_cast<std::chrono::milliseconds>(now - this->last_valid_status_timestamp_).count() >
       COMMUNICATION_TIMEOUT_MS) ||
-      (this->reset_protocol_request_)) {
+      (this->reset_protocol_request_ && (!this->haier_protocol_.is_waiting_for_answer()))) {
+    this->last_valid_status_timestamp_ = now;
    if (this->protocol_phase_ >= ProtocolPhases::IDLE) {
      // No status too long, reseting protocol
+      // No need to reset protocol if we didn't pass initialization phase
      if (this->reset_protocol_request_) {
        this->reset_protocol_request_ = false;
        ESP_LOGW(TAG, "Protocol reset requested");
      } else {
        ESP_LOGW(TAG, "Communication timeout, reseting protocol");
      }
-      this->last_valid_status_timestamp_ = now;
-      this->set_force_send_control_(false);
-      if (this->hvac_settings_.valid)
-        this->hvac_settings_.reset();
-      this->set_phase(ProtocolPhases::SENDING_INIT_1);
+      this->process_protocol_reset();
      return;
-    } else {
-      // No need to reset protocol if we didn't pass initialization phase
-      this->last_valid_status_timestamp_ = now;
    }
  };
-  if ((this->protocol_phase_ == ProtocolPhases::IDLE) ||
-      (this->protocol_phase_ == ProtocolPhases::SENDING_STATUS_REQUEST) ||
-      (this->protocol_phase_ == ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST) ||
-      (this->protocol_phase_ == ProtocolPhases::SENDING_SIGNAL_LEVEL)) {
+  if ((!this->haier_protocol_.is_waiting_for_answer()) &&
+      ((this->protocol_phase_ == ProtocolPhases::IDLE) ||
+       (this->protocol_phase_ == ProtocolPhases::SENDING_STATUS_REQUEST) ||
+       (this->protocol_phase_ == ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST) ||
+       (this->protocol_phase_ == ProtocolPhases::SENDING_SIGNAL_LEVEL))) {
    // If control message or action is pending we should send it ASAP unless we are in initialisation
    // procedure or waiting for an answer
-    if (this->action_request_ != ActionRequest::NO_ACTION) {
-      this->process_pending_action();
-    } else if (this->hvac_settings_.valid || this->force_send_control_) {
+    if (this->action_request_.has_value() && this->prepare_pending_action()) {
+      this->set_phase(ProtocolPhases::SENDING_ACTION_COMMAND);
+    } else if (this->next_hvac_settings_.valid || this->force_send_control_) {
      ESP_LOGV(TAG, "Control packet is pending...");
      this->set_phase(ProtocolPhases::SENDING_CONTROL);
+      if (this->next_hvac_settings_.valid) {
+        this->current_hvac_settings_ = this->next_hvac_settings_;
+        this->next_hvac_settings_.reset();
+      } else {
+        this->current_hvac_settings_.reset();
+      }
    }
  }
  this->process_phase(now);
  this->haier_protocol_.loop();
 }

-void HaierClimateBase::process_pending_action() {
-  ActionRequest request = this->action_request_;
-  if (this->action_request_ == ActionRequest::TOGGLE_POWER) {
-    request = this->mode == CLIMATE_MODE_OFF ? ActionRequest::TURN_POWER_ON : ActionRequest::TURN_POWER_OFF;
-  }
-  switch (request) {
-    case ActionRequest::TURN_POWER_ON:
-      this->set_phase(ProtocolPhases::SENDING_POWER_ON_COMMAND);
-      break;
-    case ActionRequest::TURN_POWER_OFF:
-      this->set_phase(ProtocolPhases::SENDING_POWER_OFF_COMMAND);
-      break;
-    case ActionRequest::TOGGLE_POWER:
-    case ActionRequest::NO_ACTION:
-      // shouldn't get here, do nothing
-      break;
-    default:
-      ESP_LOGW(TAG, "Unsupported action: %d", (uint8_t) this->action_request_);
-      break;
-  }
-  this->action_request_ = ActionRequest::NO_ACTION;
+void HaierClimateBase::process_protocol_reset() {
+  this->force_send_control_ = false;
+  if (this->current_hvac_settings_.valid)
+    this->current_hvac_settings_.reset();
+  if (this->next_hvac_settings_.valid)
+    this->next_hvac_settings_.reset();
+  this->mode = CLIMATE_MODE_OFF;
+  this->current_temperature = NAN;
+  this->target_temperature = NAN;
+  this->fan_mode.reset();
+  this->preset.reset();
+  this->publish_state();
+  this->set_phase(ProtocolPhases::SENDING_INIT_1);
+}
+
+bool HaierClimateBase::prepare_pending_action() {
+  if (this->action_request_.has_value()) {
+    switch (this->action_request_.value().action) {
+      case ActionRequest::SEND_CUSTOM_COMMAND:
+        return true;
+      case ActionRequest::TURN_POWER_ON:
+        this->action_request_.value().message = this->get_power_message(true);
+        return true;
+      case ActionRequest::TURN_POWER_OFF:
+        this->action_request_.value().message = this->get_power_message(false);
+        return true;
+      case ActionRequest::TOGGLE_POWER:
+        this->action_request_.value().message = this->get_power_message(this->mode == ClimateMode::CLIMATE_MODE_OFF);
+        return true;
+      default:
+        ESP_LOGW(TAG, "Unsupported action: %d", (uint8_t) this->action_request_.value().action);
+        this->action_request_.reset();
+        return false;
+    }
+  } else
+    return false;
 }

 ClimateTraits HaierClimateBase::traits() { return traits_; }
@@ -302,23 +329,22 @@ void HaierClimateBase::control(const ClimateCall &call) {
    ESP_LOGW(TAG, "Can't send control packet, first poll answer not received");
    return;  // cancel the control, we cant do it without a poll answer.
  }
-  if (this->hvac_settings_.valid) {
-    ESP_LOGW(TAG, "Overriding old valid settings before they were applied!");
+  if (this->current_hvac_settings_.valid) {
+    ESP_LOGW(TAG, "New settings come faster then processed!");
  }
  {
    if (call.get_mode().has_value())
-      this->hvac_settings_.mode = call.get_mode();
+      this->next_hvac_settings_.mode = call.get_mode();
    if (call.get_fan_mode().has_value())
-      this->hvac_settings_.fan_mode = call.get_fan_mode();
+      this->next_hvac_settings_.fan_mode = call.get_fan_mode();
    if (call.get_swing_mode().has_value())
-      this->hvac_settings_.swing_mode = call.get_swing_mode();
+      this->next_hvac_settings_.swing_mode = call.get_swing_mode();
    if (call.get_target_temperature().has_value())
-      this->hvac_settings_.target_temperature = call.get_target_temperature();
+      this->next_hvac_settings_.target_temperature = call.get_target_temperature();
    if (call.get_preset().has_value())
-      this->hvac_settings_.preset = call.get_preset();
-    this->hvac_settings_.valid = true;
+      this->next_hvac_settings_.preset = call.get_preset();
+    this->next_hvac_settings_.valid = true;
  }
-  this->first_control_attempt_ = true;
 }

 void HaierClimateBase::HvacSettings::reset() {
@@ -330,19 +356,9 @@ void HaierClimateBase::HvacSettings::reset() {
  this->preset.reset();
 }

-void HaierClimateBase::set_force_send_control_(bool status) {
-  this->force_send_control_ = status;
-  if (status) {
-    this->first_control_attempt_ = true;
-  }
-}
-
-void HaierClimateBase::send_message_(const haier_protocol::HaierMessage &command, bool use_crc) {
-  if (this->answer_timeout_.has_value()) {
-    this->haier_protocol_.send_message(command, use_crc, this->answer_timeout_.value());
-  } else {
-    this->haier_protocol_.send_message(command, use_crc);
-  }
+void HaierClimateBase::send_message_(const haier_protocol::HaierMessage &command, bool use_crc, uint8_t num_repeats,
+                                     std::chrono::milliseconds interval) {
+  this->haier_protocol_.send_message(command, use_crc, num_repeats, interval);
  this->last_request_timestamp_ = std::chrono::steady_clock::now();
 }