hoermann_hcp.cpp

Go to the documentation of this file.

#include "hoermann_hcp.h"
 
#include <algorithm>
#include <utility>
 
#include "esphome/core/hal.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
 
namespace esphome::hoermann_hcp {
 
ESPHOME_LOG_TAG(TAG, "hoermann_hcp");
 
// Hoermann HCP holding-register blocks.
static constexpr uint16_t COMMAND_REG = 0x9C41;    // Commands written by the bus controller
static constexpr uint16_t STATE_REG = 0x9CB9;      // Internal state read back by the bus controller
static constexpr uint16_t BROADCAST_REG = 0x9D31;  // Door status broadcast by the bus controller
static constexpr float CLOSE_POSITION_THRESHOLD = 0.05f;
static constexpr float OPEN_POSITION_THRESHOLD = 0.95f;
 
static constexpr HoermannHcpCommand COMMAND_OPEN{"open", 0x0110};
static constexpr HoermannHcpCommand COMMAND_CLOSE{"close", 0x0120};
static constexpr HoermannHcpCommand COMMAND_IMPULSE{"impulse", 0x0140};
static constexpr HoermannHcpCommand COMMAND_VENT{"vent", 0x0100, 0x4000};
static constexpr HoermannHcpCommand COMMAND_HALF_OPEN{"half open", 0x0100, 0x0400};
// Absolute, as a vendor gateway sends them, so a late or repeated one cannot switch the lamp the wrong way.
static constexpr HoermannHcpCommand COMMAND_LIGHT_ON{"light on", 0x0880};
static constexpr HoermannHcpCommand COMMAND_LIGHT_OFF{"light off", 0x0800, 0x0100};
// Kept as the intent, as the same impulse starts a door at rest; only a door still moving at the fetch gets it.
static constexpr HoermannHcpCommand COMMAND_STOP{"stop", 0x0140};
 
// High byte of the state register and the door state it stands for. State 0x00 is decoded separately because
// its low byte tells a plain stop from the vent position.
struct DoorStateMapping {
  uint8_t code;
  DoorState state;
};
static constexpr DoorStateMapping DOOR_STATE_MAPPINGS[] = {
    {0x01, DoorState::OPENING},      {0x02, DoorState::CLOSING},   {0x05, DoorState::MOVE_HALF},
    {0x09, DoorState::MOVE_VENTING}, {0x0A, DoorState::VENT},      {0x20, DoorState::OPEN},
    {0x40, DoorState::CLOSED},       {0x80, DoorState::HALF_OPEN},
};
 
// The hub rejects a reply whose register count does not match the request, so an unrecognized block length
// is padded with zeros rather than answered with an exception that would fail the controller's whole poll.
static void push_zeros(modbus::RegisterValues &registers, uint16_t count) {
  for (uint16_t i = 0; i < count; i++)
    registers.push_back(0x0000);
}
 
// True while the door is travelling. An impulse toggles the door, so it only stops one that is moving.
static bool is_moving(DoorState state) {
  switch (state) {
    case DoorState::OPENING:
    case DoorState::CLOSING:
    case DoorState::MOVE_HALF:
    case DoorState::MOVE_VENTING:
      return true;
    default:
      return false;
  }
}
 
static bool at_destination(const HoermannHcpCommand &command, DoorState state) {
  if (&command == &COMMAND_OPEN)
    return state == DoorState::OPEN;
  if (&command == &COMMAND_CLOSE)
    return state == DoorState::CLOSED;
  if (&command == &COMMAND_VENT)
    return state == DoorState::VENT;
  if (&command == &COMMAND_HALF_OPEN)
    return state == DoorState::HALF_OPEN;
  return false;
}
 
// Only a status poll's answer carries commands.
static constexpr uint8_t STATUS_COMMAND = 0x03;
// A second stop this soon after one went out is ignored, so a double press cannot restart the door.
static constexpr uint32_t STOP_LOCK_MS = 500;
 
#ifdef USE_HOERMANN_HCP_IDENTITY
// A status answer with this code in the low byte of its second register asks the bus controller for a value,
// named in the high byte of the third.
static constexpr uint8_t ANSWER_REQUEST = 0x22;
static constexpr uint8_t REQUEST_SERIAL = 0x05;
static constexpr uint8_t REQUEST_FIRMWARE = 0x06;
// Each request goes out in one answer, up to this many times, this far apart.
static constexpr uint8_t IDENTITY_MAX_ATTEMPTS = 3;
static constexpr uint32_t IDENTITY_RETRY_MS = 30000;
// The value comes back as a payload transfer: this command in the low byte of the first command register, a sub
// code in the high byte of the second, the payload from the third on.
static constexpr uint8_t TRANSFER_COMMAND = 0x04;
static constexpr uint8_t TRANSFER_SUB_SERIAL = 0x0C;
static constexpr uint8_t TRANSFER_SUB_FIRMWARE = 0x0D;
static constexpr uint8_t TRANSFER_ACK = 0xFD;
static constexpr size_t TRANSFER_PAYLOAD_REG = 2;
// Marks the first half of the serial number in the counter byte, and is not part of the count.
static constexpr uint8_t COUNTER_FIRST_HALF = 0x80;
// Older motors (index B1 seen) send the whole serial number in one frame, without the half marker. It is as long
// as a second half, so one copy path serves both.
static constexpr size_t SERIAL_SINGLE_FRAME_REGS = 6;
static_assert(SERIAL_SINGLE_FRAME_REGS == SERIAL_SECOND_HALF_REGS, "one copy path serves both serial frames");
 
// Registers hold two payload bytes each, high byte first.
static void copy_payload(const modbus::RegisterValues &registers, size_t count, char *out) {
  for (size_t i = 0; i < count; i++) {
    const uint16_t value = registers[TRANSFER_PAYLOAD_REG + i];
    out[2 * i] = static_cast<char>(value >> 8);
    out[2 * i + 1] = static_cast<char>(value);
  }
}
 
// Length of the printable text at the start, without trailing spaces. The padding after it varies.
static size_t text_length(const char *text, size_t len) {
  size_t at = 0;
  while (at < len && text[at] >= 0x20 && text[at] <= 0x7E)
    at++;
  while (at > 0 && text[at - 1] == ' ')
    at--;
  return at;
}
 
static void terminate_text(char *text, size_t len) { text[text_length(text, len)] = '\0'; }
 
// dump_config() is replayed to remote log clients, so they see the outcome of the exchange at boot.
static void log_identity_value(text_sensor::TextSensor *sensor) {
  if (sensor != nullptr) {
    ESP_LOGCONFIG(TAG, "    Value: %s",
                  sensor->has_state() ? sensor->get_state().c_str() : LOG_STR_LITERAL("not received"));
  }
}
#endif
 
void HoermannHcp::update() {
  const uint32_t now = millis();
  // Time out the connection flag if the bus controller stopped polling.
  if (this->valid_ && now - this->last_response_ > this->connection_timeout_ms_)
    this->set_valid_(false);
  // Status broadcasts alone keep the connection alive, so a command the controller never fetches would
  // otherwise block every later one for as long as it keeps broadcasting.
  // A stop held for a door that has not reported its start yet is timed by the start window instead.
  const bool stop_held = this->next_command_ == &COMMAND_STOP && this->starting_;
  if (this->next_command_ != nullptr && !stop_held && now - this->command_queued_at_ > this->connection_timeout_ms_) {
    ESP_LOGW(TAG, "Bus controller did not fetch '%s' command, dropping it", this->next_command_->name);
    this->drop_command_();
    // Children may have assumed the command would land, so let them re-derive from the door.
    this->changed_ = true;
  }
  // A target the door never started towards would otherwise cut a later move short.
  if (this->has_target_() && !this->target_started_ && now - this->target_queued_at_ > this->start_window_ms_) {
    ESP_LOGW(TAG, "Door did not start moving towards the requested position, dropping it");
    this->clear_target_();
  }
  // A door that never answers a fetched command is at rest after all.
  if (this->starting_ && now - this->start_fetched_at_ > this->start_window_ms_) {
    this->starting_ = false;
    if (stop_held) {
      ESP_LOGW(TAG, "Door did not report moving, dropping the stop");
      this->next_command_ = nullptr;
    } else {
      ESP_LOGD(TAG, "Door did not start after the command");
    }
  }
  // A lamp command held while the door starts or moves waits on purpose, so its deadline starts once the door rests.
  if (this->is_moving_or_starting_() && this->light_requested_ && !this->light_command_sent_)
    this->light_since_ = now;
  // Neither fire late nor block the next request.
  if (this->light_requested_ && now - this->light_since_ > this->connection_timeout_ms_) {
    if (this->light_command_sent_) {
      ESP_LOGW(TAG, "Door did not report the lamp changing, giving up");
    } else {
      ESP_LOGW(TAG, "Bus controller did not fetch the lamp command, dropping it");
    }
    this->clear_light_request_();
  }
#ifdef USE_HOERMANN_HCP_IDENTITY
  this->publish_identity_();
#endif
  if (this->changed_) {
    this->changed_ = false;
    this->state_callback_.call();
  }
}
 
void HoermannHcp::dump_config() {
  ESP_LOGCONFIG(TAG,
                "Hoermann HCP bridge:\n"
                "  Modbus server address: 0x%02X",
                this->get_address());
#ifdef USE_HOERMANN_HCP_IDENTITY
  LOG_TEXT_SENSOR("  ", "Serial Number", this->serial_number_text_sensor_);
  log_identity_value(this->serial_number_text_sensor_);
  LOG_TEXT_SENSOR("  ", "Firmware Version", this->version_text_sensor_);
  log_identity_value(this->version_text_sensor_);
#endif
}
 
modbus::ResponseStatus HoermannHcp::on_read_holding_registers(uint16_t start_address, uint16_t number_of_registers,
                                                              modbus::RegisterValues &registers) {
  if (start_address != STATE_REG) {
    ESP_LOGW(TAG, "Unknown read address 0x%04X", start_address);
    return modbus::ExceptionCode::ILLEGAL_DATA_ADDRESS;
  }
 
  this->record_response_();
  const bool status_poll = std::exchange(this->status_poll_pending_, false);
 
#ifdef USE_HOERMANN_HCP_IDENTITY
  // Acknowledge the transfer taken by the write half of this frame.
  if (this->transfer_answer_counter_ != NO_TRANSFER_ANSWER) {
    this->push_transfer_answer_(registers, number_of_registers);
    return {};
  }
#endif
 
  // 0x17 read half: STATE_REG is read back right after COMMAND_REG was written, so echo the stored message
  // counter (high byte) and command (low byte). The read length identifies which internal block is requested.
  const uint16_t counter = this->command_reg_value_ & 0xFF00;
  const uint16_t command = static_cast<uint16_t>((this->command_reg_value_ & 0x00FF) << 8);
 
  switch (number_of_registers) {
    case 8:
      // Command request: return the internal state, injecting any pending command.
      registers.push_back(counter);
      registers.push_back(static_cast<uint16_t>(0x0001 | command));
      if (status_poll && static_cast<uint8_t>(this->command_reg_value_) == STATUS_COMMAND) {
        this->push_command_registers_(registers);
      } else {
        push_zeros(registers, 2);
      }
      push_zeros(registers, 4);
#ifdef USE_HOERMANN_HCP_IDENTITY
      this->add_identity_request_(registers, command);
#endif
      break;
    case 2:
      // Empty command request.
      registers.push_back(static_cast<uint16_t>(0x0004 | counter));
      registers.push_back(command);
      break;
    case 5:
      // Bus scan (the bus controller discovering us, typically at startup).
      ESP_LOGD(TAG, "Bus scan received from bus controller");
      registers.push_back(counter);
      registers.push_back(static_cast<uint16_t>(0x0005 | command));
      registers.push_back(0x0430);
      registers.push_back(0x10FF);
      registers.push_back(0xA845);
      break;
    default:
      ESP_LOGW(TAG, "Unknown read request (read %u registers)", number_of_registers);
      push_zeros(registers, number_of_registers);
      break;
  }
 
  return {};
}
 
modbus::ResponseStatus HoermannHcp::on_write_registers(uint16_t start_address,
                                                       const modbus::RegisterValues &registers) {
  if (start_address == COMMAND_REG) {
    // 0x17 write half: stash the command register so the following read half can echo its message counter and
    // command byte back from STATE_REG. The hub always runs the write before the read within one request.
    this->record_response_();
    this->command_reg_value_ = registers[0];
    this->status_poll_pending_ = true;
#ifdef USE_HOERMANN_HCP_IDENTITY
    this->transfer_answer_counter_ = this->take_identity_transfer_(registers);
#endif
    return {};
  }
 
  if (start_address != BROADCAST_REG) {
    // Every device sees every broadcast, so a frame meant for another node is ordinary traffic
    ESP_LOGV(TAG, "Ignoring write to address 0x%04X", start_address);
    return modbus::ExceptionCode::ILLEGAL_DATA_ADDRESS;
  }
 
  this->record_response_();
 
  // Door status broadcast. The state is decoded first so that a frame reporting both a new state and a new
  // position checks the target against the new state.
  if (registers.size() > 2)
    this->on_state_reg_(registers[2]);
  if (registers.size() > 1)
    this->on_position_reg_(registers[1]);
  if (registers.size() > 6) {
    this->on_light_reg_(registers[6]);
    return {};
  }
  // Nothing refreshes the lamp any more, so what was read before must not be commanded against.
  this->set_light_seen_(false);
  if (!this->short_broadcast_logged_) {
    this->short_broadcast_logged_ = true;
    ESP_LOGD(TAG, "Broadcast of %u registers carries no lamp state", static_cast<unsigned>(registers.size()));
  }
  return {};
}
 
void HoermannHcp::push_command_registers_(modbus::RegisterValues &registers) {
  const HoermannHcpCommand *command = this->take_command_();
  if (command == nullptr)
    command = this->take_light_command_();
  if (command == nullptr) {
    push_zeros(registers, 2);
    return;
  }
  ESP_LOGI(TAG, "Sending '%s' command to door", command->name);
  registers.push_back(command->value);
  registers.push_back(command->value_2);
}
 
const HoermannHcpCommand *HoermannHcp::take_command_() {
  const HoermannHcpCommand *command = this->next_command_;
  if (command == nullptr)
    return nullptr;
  const bool moving = is_moving(this->door_state_);
  // The door was just told to start and has not said so yet, so an impulse now could start it instead.
  if (command == &COMMAND_STOP && this->starting_ && !moving)
    return nullptr;
  this->next_command_ = nullptr;
  if (moving) {
    // The door may have been started from elsewhere since the command was queued.
    if ((command == &COMMAND_OPEN && this->door_state_ == DoorState::OPENING) ||
        (command == &COMMAND_CLOSE && this->door_state_ == DoorState::CLOSING)) {
      ESP_LOGD(TAG, "Door is already moving that way, dropping '%s'", command->name);
      return nullptr;
    }
    if (command != &COMMAND_STOP) {
      ESP_LOGD(TAG, "Door is moving, stopping it instead of '%s'", command->name);
    }
    this->last_stop_at_ = millis();
    this->stop_sent_ = true;
    return &COMMAND_STOP;
  }
  if (command == &COMMAND_STOP) {
    ESP_LOGD(TAG, "Door came to rest before the stop was fetched, dropping it");
    return nullptr;
  }
  // Until the door answers, it still reads as at rest.
  if (!this->door_state_seen_ || !at_destination(*command, this->door_state_)) {
    this->starting_ = true;
    this->start_command_ = command;
    this->start_fetched_at_ = millis();
  }
  return command;
}
 
const HoermannHcpCommand *HoermannHcp::take_light_command_() {
  // The motor ignores the lamp while its door moves and may switch it itself as it starts, so the lamp waits for rest.
  if (!this->light_requested_ || this->light_command_sent_ || this->is_moving_or_starting_() ||
      this->light_target_ == this->light_on_)
    return nullptr;
  this->light_command_sent_ = true;
  this->light_since_ = millis();
  return this->light_target_ ? &COMMAND_LIGHT_ON : &COMMAND_LIGHT_OFF;
}
 
#ifdef USE_HOERMANN_HCP_IDENTITY
void HoermannHcp::add_identity_request_(modbus::RegisterValues &registers, uint16_t command) {
  if (static_cast<uint8_t>(this->command_reg_value_) != STATUS_COMMAND)
    return;
  // Like Hoermann's own bus accessory, only after one ordinary answer.
  if (this->identity_phase_ == IdentityPhase::IDENTITY_PHASE_IDLE) {
    if (this->serial_number_text_sensor_ != nullptr || this->version_text_sensor_ != nullptr)
      this->arm_identity_request_(IdentityPhase::IDENTITY_PHASE_SERIAL);
    return;
  }
  // Uses the command registers, so it waits while a command is pending.
  if (registers[2] != 0 || registers[3] != 0 || !this->take_identity_request_())
    return;
  registers[1] = static_cast<uint16_t>(ANSWER_REQUEST | command);
  registers[2] = encode_uint16(this->identity_request_(), 0);
}
 
void HoermannHcp::arm_identity_request_(IdentityPhase phase) {
  this->identity_phase_ = phase;
  this->identity_attempts_ = 0;
}
 
bool HoermannHcp::take_identity_request_() {
  const uint8_t request = this->identity_request_();
  if (request == 0)
    return false;
  const uint32_t now = millis();
  if (this->identity_attempts_ != 0 && now - this->identity_asked_at_ <= IDENTITY_RETRY_MS)
    return false;
  if (this->identity_attempts_ >= IDENTITY_MAX_ATTEMPTS) {
    this->identity_unanswered_ = request;
    if (request == REQUEST_SERIAL) {
      // Still ask for the firmware version, and drop a leftover first half.
      this->serial_number_[0] = '\0';
      this->arm_identity_request_(IdentityPhase::IDENTITY_PHASE_FIRMWARE);
    } else {
      this->identity_phase_ = IdentityPhase::IDENTITY_PHASE_DONE;
    }
    return false;
  }
  this->identity_attempts_++;
  this->identity_asked_at_ = now;
  return true;
}
 
uint8_t HoermannHcp::take_identity_transfer_(const modbus::RegisterValues &registers) {
  if (this->identity_phase_ == IdentityPhase::IDENTITY_PHASE_IDLE || registers.size() < TRANSFER_PAYLOAD_REG ||
      static_cast<uint8_t>(registers[0]) != TRANSFER_COMMAND)
    return NO_TRANSFER_ANSWER;
  const uint8_t counter = static_cast<uint8_t>(registers[0] >> 8);
  const uint8_t sub_code = static_cast<uint8_t>(registers[1] >> 8);
  if (sub_code != TRANSFER_SUB_SERIAL && sub_code != TRANSFER_SUB_FIRMWARE)
    return NO_TRANSFER_ANSWER;
  // Acknowledged whether kept or not, as Hoermann's own bus accessory does. What was not kept is asked for again.
  const uint8_t answer = counter & ~COUNTER_FIRST_HALF;
  // Only an answer to the request that went out is kept.
  const uint8_t request = sub_code == TRANSFER_SUB_SERIAL ? REQUEST_SERIAL : REQUEST_FIRMWARE;
  if (this->identity_attempts_ == 0 || this->identity_request_() != request)
    return answer;
 
  const size_t payload_regs = registers.size() - TRANSFER_PAYLOAD_REG;
  if (request == REQUEST_FIRMWARE) {
    const size_t regs = std::min(payload_regs, FIRMWARE_REGS);
    copy_payload(registers, regs, this->firmware_version_);
    if (regs == FIRMWARE_REGS && text_length(this->firmware_version_, 2 * regs) != 0) {
      terminate_text(this->firmware_version_, 2 * regs);
      // Clear an earlier unreadable answer, so this one is shown.
      this->firmware_unreadable_ = false;
      this->identity_phase_ = IdentityPhase::IDENTITY_PHASE_DONE;
      return answer;
    }
    // Left as received for update() to log.
    this->firmware_unreadable_ = true;
    this->firmware_unreadable_len_ = 2 * regs;
    // A short answer is asked for again; unreadable text would come back the same.
    if (regs == FIRMWARE_REGS)
      this->identity_phase_ = IdentityPhase::IDENTITY_PHASE_DONE;
    return answer;
  }
  if ((counter & COUNTER_FIRST_HALF) != 0) {
    // Even a half too short to keep says the number comes in two halves; a first half already kept stays kept.
    if (this->identity_phase_ == IdentityPhase::IDENTITY_PHASE_SERIAL)
      this->identity_phase_ = IdentityPhase::IDENTITY_PHASE_SERIAL_SPLIT;
    if (payload_regs >= SERIAL_FIRST_HALF_REGS) {
      copy_payload(registers, SERIAL_FIRST_HALF_REGS, this->serial_number_);
      this->identity_phase_ = IdentityPhase::IDENTITY_PHASE_SERIAL_SECOND_HALF;
    }
    return answer;
  }
  // Without a half marker seen, the frame is the whole number; after one, it can only be the second half.
  if (this->identity_phase_ == IdentityPhase::IDENTITY_PHASE_SERIAL_SPLIT || payload_regs < SERIAL_SINGLE_FRAME_REGS)
    return answer;
  const size_t at =
      this->identity_phase_ == IdentityPhase::IDENTITY_PHASE_SERIAL_SECOND_HALF ? 2 * SERIAL_FIRST_HALF_REGS : 0;
  copy_payload(registers, SERIAL_SINGLE_FRAME_REGS, this->serial_number_ + at);
  terminate_text(this->serial_number_, at + 2 * SERIAL_SINGLE_FRAME_REGS);
  this->serial_unreadable_ = this->serial_number_[0] == '\0';
  this->arm_identity_request_(IdentityPhase::IDENTITY_PHASE_FIRMWARE);
  return answer;
}
 
void HoermannHcp::push_transfer_answer_(modbus::RegisterValues &registers, uint16_t number_of_registers) {
  const uint16_t answer[] = {encode_uint16(this->transfer_answer_counter_, 0),
                             encode_uint16(TRANSFER_COMMAND, TRANSFER_ACK)};
  this->transfer_answer_counter_ = NO_TRANSFER_ANSWER;
  for (uint16_t i = 0; i < number_of_registers; i++)
    registers.push_back(i < 2 ? answer[i] : 0x0000);
}
 
void HoermannHcp::publish_identity_() {
  // Buffers are cleared once published, so each value goes out once. The serial number is whole once the firmware
  // version is requested.
  if (this->serial_number_text_sensor_ != nullptr && this->identity_request_() != REQUEST_SERIAL &&
      this->serial_number_[0] != '\0') {
    this->serial_number_text_sensor_->publish_state(this->serial_number_);
    this->serial_number_[0] = '\0';
  }
  if (this->serial_unreadable_) {
    this->serial_unreadable_ = false;
    ESP_LOGW(TAG, "Unreadable serial number");
  }
  // Checked first: the buffer then holds raw bytes, not text.
  if (this->firmware_unreadable_) {
    this->firmware_unreadable_ = false;
    const uint8_t len = this->firmware_unreadable_len_;
    // All zeros: the motor does not report a version (index B1 seen).
    if (len == 2 * FIRMWARE_REGS &&
        std::all_of(this->firmware_version_, this->firmware_version_ + len, [](char c) { return c == '\0'; })) {
      ESP_LOGD(TAG, "Motor does not report its firmware version");
    } else {
      char hex[format_hex_size(2 * FIRMWARE_REGS)];
      ESP_LOGW(TAG, "Unreadable firmware version (%u bytes): %s", len,
               format_hex_to(hex, reinterpret_cast<const uint8_t *>(this->firmware_version_), len));
    }
    this->firmware_version_[0] = '\0';
  }
  if (this->version_text_sensor_ != nullptr && this->firmware_version_[0] != '\0') {
    this->version_text_sensor_->publish_state(this->firmware_version_);
    this->firmware_version_[0] = '\0';
  }
  if (this->identity_unanswered_ != 0) {
    ESP_LOGW(TAG, "No usable %s received",
             this->identity_unanswered_ == REQUEST_SERIAL ? LOG_STR_LITERAL("serial number")
                                                          : LOG_STR_LITERAL("firmware version"));
    this->identity_unanswered_ = 0;
  }
}
#endif
 
void HoermannHcp::on_position_reg_(uint16_t value) {
  // Low byte: current position.
  const uint8_t position = static_cast<uint8_t>(value);
  if (this->position_raw_ == position)
    return;
 
  this->position_raw_ = position;
  this->update_current_position_();
  // Until the door actually travels the way it was told to, its position says nothing about the target.
  if (!this->has_target_() || !this->target_started_)
    return;
 
  // The door only knows "open" and "close", so a half-open target is reached by stopping it on the way.
  const bool reached = this->target_direction_ == DoorState::OPENING
                           ? this->current_position_ >= this->target_position_
                           : this->current_position_ <= this->target_position_;
  if (reached)
    this->stop_door();
}
 
void HoermannHcp::on_state_reg_(uint16_t value) {
  // The low byte is part of the state for 0x00, so the whole register has to be compared, not just the high byte.
  const uint16_t previous = this->prev_state_reg_;
  this->prev_state_reg_ = value;
  if (previous == value)
    return;
 
  const uint8_t state = value >> 8;
  if (state == 0x00) {
    // Low byte 0x61 marks the door resting in the vent position, anything else a plain stop.
    this->set_door_state_((value & 0x00FF) == 0x61 ? DoorState::VENT : DoorState::STOPPED);
    return;
  }
  for (const auto &mapping : DOOR_STATE_MAPPINGS) {
    if (mapping.code == state) {
      this->set_door_state_(mapping.state);
      return;
    }
  }
  // The low byte can change on its own, so only report a state we cannot decode once.
  if (state != (previous >> 8)) {
    ESP_LOGW(TAG, "Unknown door state 0x%02X", state);
  }
}
 
// Low byte of register 6: bit 0x10 is the lamp, bit 0x04 the relay. The reference implementation records
// 0x00, 0x04, 0x10 and 0x14, so only the lamp bit decides here.
void HoermannHcp::on_light_reg_(uint16_t value) {
  this->set_light_seen_(true);
  this->set_light_on_((value & 0x0010) != 0);
}
 
bool HoermannHcp::queue_command_(const HoermannHcpCommand &command) {
  if (!this->valid_) {
    // Queueing now would fire the command whenever the controller comes back, which may be much later.
    ESP_LOGW(TAG, "Not connected to the bus controller, dropping '%s' command", command.name);
    return false;
  }
  // A stop still waiting for a door that has come to rest would be dropped at the fetch anyway.
  if (this->next_command_ == &COMMAND_STOP)
    this->next_command_ = nullptr;
  if (this->next_command_ != nullptr) {
    ESP_LOGW(TAG, "Previous command not yet fetched by the bus controller");
    return false;
  }
  // A new command supersedes any half-open target the door was still travelling to.
  this->clear_target_();
  this->next_command_ = &command;
  this->command_queued_at_ = millis();
  return true;
}
 
bool HoermannHcp::is_moving_or_starting_() const { return this->starting_ || is_moving(this->door_state_); }
 
bool HoermannHcp::command_door_(const HoermannHcpCommand &command) {
  // Only stopped, so it is never reversed at speed. take_command_() drops one queued before the door started the same
  // way.
  if (this->is_moving_or_starting_())
    return this->stop_door();
  return this->queue_command_(command);
}
 
bool HoermannHcp::open_door() { return this->command_door_(COMMAND_OPEN); }
bool HoermannHcp::close_door() { return this->command_door_(COMMAND_CLOSE); }
bool HoermannHcp::impulse_door() { return this->command_door_(COMMAND_IMPULSE); }
bool HoermannHcp::vent_door() { return this->command_door_(COMMAND_VENT); }
bool HoermannHcp::half_open_door() { return this->command_door_(COMMAND_HALF_OPEN); }
bool HoermannHcp::stop_door() {
  this->clear_target_();
  // A stop outranks whatever is still waiting, so a door at rest does not start after the user pressed stop.
  if (this->next_command_ != nullptr && this->next_command_ != &COMMAND_STOP) {
    ESP_LOGD(TAG, "Stop cancels the unfetched '%s' command", this->next_command_->name);
    this->next_command_ = nullptr;
  }
  if (!this->is_moving_or_starting_())
    return true;
  if (!this->valid_) {
    ESP_LOGW(TAG, "Not connected to the bus controller, dropping 'stop' command");
    return false;
  }
  if (this->next_command_ == &COMMAND_STOP)
    return true;
  if (this->stop_sent_ && millis() - this->last_stop_at_ < STOP_LOCK_MS) {
    ESP_LOGD(TAG, "Door already stopping, ignoring stop");
    return true;
  }
  this->next_command_ = &COMMAND_STOP;
  this->command_queued_at_ = millis();
  return true;
}
 
bool HoermannHcp::set_position(float position) {
  // The first and last movement segments are inconsistent on some doors, so snap to fully open/closed.
  if (position <= CLOSE_POSITION_THRESHOLD)
    return this->close_door();
  if (position >= OPEN_POSITION_THRESHOLD)
    return this->open_door();
  // Asking the door to travel to where it already is, or anywhere while it moves, means stopping it.
  if (position == this->current_position_ || this->is_moving_or_starting_())
    return this->stop_door();
 
  // The door itself has no notion of a target, so it is started in the right direction and stopped on the way.
  const bool opening = position > this->current_position_;
  if (!this->queue_command_(opening ? COMMAND_OPEN : COMMAND_CLOSE))
    return false;
  this->target_position_ = position;
  this->target_queued_at_ = millis();
  this->target_direction_ = opening ? DoorState::OPENING : DoorState::CLOSING;
  return true;
}
 
void HoermannHcp::record_response_() {
  this->last_response_ = millis();
  this->set_valid_(true);
}
 
void HoermannHcp::set_valid_(bool valid) {
  if (this->valid_ == valid)
    return;
  this->valid_ = valid;
  this->changed_ = true;
  if (valid) {
    ESP_LOGI(TAG, "Bus controller connected");
    return;
  }
  ESP_LOGW(TAG, "Bus controller connection lost (no request for %" PRIu32 "ms)", millis() - this->last_response_);
  // Drop what the controller never fetched, so it neither blocks later commands nor fires on reconnect.
  this->drop_command_();
  this->starting_ = false;
  this->clear_light_request_();
  // The lamp can be switched at the door while the bus is quiet, so what was last read is no longer trusted.
  this->set_light_seen_(false);
  // The same holds for the door. The next broadcast is decoded even if it repeats the last one.
  this->door_state_seen_ = false;
  this->prev_state_reg_ = 0xFFFF;
  this->short_broadcast_logged_ = false;
}
 
void HoermannHcp::drop_command_() {
  this->next_command_ = nullptr;
  this->clear_target_();
}
 
void HoermannHcp::set_door_state_(DoorState state) {
  // The first state may equal the default, so being seen is a change of its own.
  if (!this->door_state_seen_) {
    this->door_state_seen_ = true;
    this->changed_ = true;
  }
  // Only moving or the command's destination answers it, even as a first report that changes nothing.
  if (this->starting_ && (is_moving(state) || at_destination(*this->start_command_, state))) {
    // A stop held for the start is due now, so its fetch deadline starts here.
    if (this->next_command_ == &COMMAND_STOP)
      this->command_queued_at_ = millis();
    this->starting_ = false;
  }
  if (this->door_state_ == state)
    return;
  this->door_state_ = state;
  this->changed_ = true;
  if (!is_moving(state)) {
    // A door at rest cannot be restarted by a second stop, as stop_door() sends nothing then.
    this->stop_sent_ = false;
  }
  this->update_current_position_();
  if (!this->has_target_())
    return;
  if (state == this->target_direction_) {
    this->target_started_ = true;
  } else if (this->target_started_ && !is_moving(state)) {
    // The door came to rest without reaching the target, so the request it belonged to is over.
    this->clear_target_();
  }
}
 
void HoermannHcp::update_current_position_() {
  // Doors do not always park at exactly 0 or 200, and Cover::is_fully_closed() is an exact comparison, so
  // trust the reported end stop over the raw count.
  float position = static_cast<float>(this->position_raw_) / 200.0f;
  if (this->door_state_ == DoorState::CLOSED) {
    position = 0.0f;
  } else if (this->door_state_ == DoorState::OPEN) {
    position = 1.0f;
  }
  if (this->current_position_ != position) {
    this->current_position_ = position;
    this->changed_ = true;
  }
}
 
void HoermannHcp::clear_target_() {
  this->target_position_ = 0.0f;
  this->target_started_ = false;
}
 
void HoermannHcp::set_light_on_(bool on) {
  if (this->light_on_ == on)
    return;
  this->light_on_ = on;
  this->changed_ = true;
  if (!this->light_requested_) {
    ESP_LOGD(TAG, "Lamp %s at the door", ONOFF(on));
    return;
  }
  if (on == this->light_target_) {
    this->clear_light_request_();
    return;
  }
  // Switched away from the target while the command was out: send again.
  this->light_command_sent_ = false;
  this->light_since_ = millis();
}
 
bool HoermannHcp::set_light(bool on) {
  // A known lamp implies a live connection.
  if (!this->light_seen_)
    return false;
  this->light_target_ = on;
  const bool was_requested = this->light_requested_;
  // A sent command may still switch it away.
  this->light_requested_ = on != this->light_on_ || this->light_command_sent_;
  // The deadline belongs to the request, so more taps cannot keep it alive.
  if (!was_requested)
    this->light_since_ = millis();
  this->changed_ = true;
  return true;
}
 
void HoermannHcp::clear_light_request_() {
  if (!this->light_requested_)
    return;
  this->light_requested_ = false;
  this->light_command_sent_ = false;
  this->changed_ = true;
}
 
void HoermannHcp::set_light_seen_(bool seen) {
  if (this->light_seen_ == seen)
    return;
  this->light_seen_ = seen;
  if (!seen)
    this->clear_light_request_();
  // A resting door changes nothing else, so without this the light would never hear about it.
  this->changed_ = true;
}
 
}  // namespace esphome::hoermann_hcp