platform_companion_sensors.cpp

Go to the documentation of this file.

/// @file platform_companion_sensors.cpp
/// @brief The auto-generated per-device diagnostic companion sensors.
/// @ingroup hioc_platforms
 
#include "platform_companion_sensors.h"
 
#include "entity_helpers.h"
#include "proto_constants.h"
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
 
namespace esphome {
namespace home_io_control {
 
// Each dump_config() keeps its own log tag as a `static` function-local constant: the ESPHome
// LOG_SENSOR / LOG_TEXT_SENSOR macros expand to a bare `TAG` identifier, so one shared file-scope
// constant could not carry a different value per sensor. Values are unchanged from the former per-sensor
// files. (`static` so the name resolves as a StaticConstant, i.e. UPPER_CASE, under clang-tidy's
// identifier-naming check rather than as a lower_case local.)
 
namespace {
 
constexpr float MS_PER_SECOND = 1000.0F;
// How often the Last Contact heartbeat re-publishes the age while the device stays quiet.
// Frame-driven updates alone would freeze the entity's value at whatever it was the moment
// traffic stopped; without this it can't count up in Home Assistant between frames.
constexpr uint32_t HEARTBEAT_INTERVAL_MS = 60000;
 
/// What a device's execution state adds to the Active Issue, or nullptr when it is no issue (waiting
/// for its turn, running and done are the normal course of a move).
const char *execution_state_issue(ExecutionState state) {
  switch (state) {
    case ExecutionState::WAITING_FOR_POWER:
      return command_result_name(RESULT_NODE_WAITING_FOR_POWER);
    case ExecutionState::NON_EXECUTING:
      return ACTIVE_ISSUE_NOT_EXECUTING;
    case ExecutionState::EXECUTION_ERROR:
      return ACTIVE_ISSUE_EXECUTION_ERROR;
    default:
      return nullptr;
  }
}
 
}  // namespace
 
void IOHomeRssiSensor::setup() {
  this->register_companion_binding_([this](const IoDevice &dev) {
    if (const int16_t ema_dbm = device_rssi_ema_dbm(dev); ema_dbm != RSSI_UNKNOWN_DBM)
      this->publish_state(ema_dbm);
  });
}
 
void IOHomeRssiSensor::dump_config() {
  static const char *const TAG = "home_io_control.rssi";
  LOG_SENSOR("", "IO-Homecontrol RSSI", this);
  ESP_LOGCONFIG(TAG, "  Device ID: %s", this->device_id_.c_str());
}
 
void IOHomeLastContactSensor::setup() {
  this->register_companion_binding_([this](const IoDevice &dev) { this->publish_age_(dev); });
 
  this->set_interval("heartbeat", HEARTBEAT_INTERVAL_MS, [this]() {
    if (this->parent_ == nullptr)
      return;
    if (const auto *dev = this->parent_->get_device(this->device_id_); dev != nullptr)
      this->publish_age_(*dev);
  });
}
 
void IOHomeLastContactSensor::publish_age_(const IoDevice &dev) {
  if (dev.last_seen_ms != 0)
    this->publish_state(static_cast<float>(millis() - dev.last_seen_ms) / MS_PER_SECOND);
}
 
void IOHomeLastContactSensor::dump_config() {
  static const char *const TAG = "home_io_control.last_contact";
  LOG_SENSOR("", "IO-Homecontrol Last Contact", this);
  ESP_LOGCONFIG(TAG, "  Device ID: %s", this->device_id_.c_str());
}
 
void IOHomeDeviceCounterSensor::setup() {
  this->register_companion_binding_(
      [this](const IoDevice &dev) { this->publish_state(static_cast<float>(this->counter_value(dev))); });
}
 
void IOHomeExchangeFailuresSensor::dump_config() {
  static const char *const TAG = "home_io_control.exchange_failures";
  LOG_SENSOR("", "IO-Homecontrol Exchange Failures", this);
  ESP_LOGCONFIG(TAG, "  Device ID: %s", this->device_id_.c_str());
}
 
void IOHomeUnconfirmedExchangesSensor::dump_config() {
  static const char *const TAG = "home_io_control.unconfirmed_exchanges";
  LOG_SENSOR("", "IO-Homecontrol Unconfirmed Exchanges", this);
  ESP_LOGCONFIG(TAG, "  Device ID: %s", this->device_id_.c_str());
}
 
void IOHomeDeviceNameTextSensor::setup() {
  if (this->parent_ == nullptr)
    return;
 
  this->register_companion_binding_([this](const IoDevice &dev) { this->publish_state(dev.name); });
 
  this->set_timeout("init_name", INITIAL_STATUS_REQUEST_DELAY_MS,
                    [this]() { this->parent_->queue_request_device_name(this->device_id_); });
}
 
void IOHomeDeviceNameTextSensor::dump_config() {
  static const char *const TAG = "home_io_control.device_name";
  LOG_TEXT_SENSOR("", "IO-Homecontrol Device Name", this);
  ESP_LOGCONFIG(TAG, "  Device ID: %s", this->device_id_.c_str());
}
 
void IOHomeActiveIssueTextSensor::setup() {
  this->register_companion_binding_([this](const IoDevice &dev) {
    // A radio that stopped responding wins: nothing reaches any device until a reboot. Then an
    // explicit CMD_ERROR_RESP result; otherwise the rain limitation the hub derived from the
    // window's own status replies; otherwise what the device's execution state says (waiting for
    // power, unable to run, error during the last move); otherwise empty. A result about one
    // exchange only (command_result_is_transient()) is not an issue of the device.
    if (this->parent_->radio_stopped_responding()) {
      this->publish_state(ACTIVE_ISSUE_RADIO_STOPPED_RESPONDING);
    } else if (dev.last_result_code != 0 && !command_result_is_transient(dev.last_result_code)) {
      this->publish_state(command_result_name(dev.last_result_code));
    } else if (dev.limited_by_rain) {
      this->publish_state(command_result_name(RESULT_LIMITATION_BY_RAIN));
    } else if (const char *issue = execution_state_issue(dev.execution_state)) {
      this->publish_state(issue);
    } else {
      this->publish_state("");
    }
  });
}
 
void IOHomeActiveIssueTextSensor::dump_config() {
  static const char *const TAG = "home_io_control.active_issue";
  LOG_TEXT_SENSOR("", "IO-Homecontrol Active Issue", this);
  ESP_LOGCONFIG(TAG, "  Device ID: %s", this->device_id_.c_str());
}
 
void IOHomeLastCommandedByTextSensor::setup() {
  // No parent_ == nullptr guard needed here (unlike IOHomeDeviceNameTextSensor, which dereferences
  // parent_ a second time outside the binding, in a set_timeout lambda): register_companion_binding_()
  // already no-ops on a null parent before this lambda is ever invoked, so parent_ is guaranteed
  // non-null every time it runs.
  this->register_companion_binding_(
      [this](const IoDevice &dev) { this->publish_state(this->parent_->describe_last_commander(dev)); });
}
 
void IOHomeLastCommandedByTextSensor::dump_config() {
  static const char *const TAG = "home_io_control.last_commanded_by";
  LOG_TEXT_SENSOR("", "IO-Homecontrol Last Commanded By", this);
  ESP_LOGCONFIG(TAG, "  Device ID: %s", this->device_id_.c_str());
}
 
void IOHomeLastCommandSourceTextSensor::setup() {
  this->register_companion_binding_(
      [this](const IoDevice &dev) { this->publish_state(detail::describe_last_command_source(dev)); });
}
 
void IOHomeLastCommandSourceTextSensor::dump_config() {
  static const char *const TAG = "home_io_control.last_command_source";
  LOG_TEXT_SENSOR("", "IO-Homecontrol Last Command Source", this);
  ESP_LOGCONFIG(TAG, "  Device ID: %s", this->device_id_.c_str());
}
 
}  // namespace home_io_control
}  // namespace esphome