zigbee_esp32.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/defines.h"
#ifdef USE_ESP32
#ifdef USE_ZIGBEE
 
#include <map>
#include <tuple>
#include <atomic>
 
#include "esp_zigbee.h"
#include "ezbee/zha.h"
#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/lock_free_queue.h"
#include "esphome/core/event_pool.h"
#include "zigbee_helpers_esp32.h"
#include "zigbee_event_esp32.h"
 
namespace esphome::zigbee {
 
/* Zigbee configuration */
static const uint8_t MAX_CHILDREN = 10;
static const uint32_t EZB_PRIMARY_CHANNEL_MASK = 0x07FFF800U; /* channels 11-26 */
static constexpr uint8_t MAX_ZB_QUEUE_SIZE = 32;
 
#define EZB_DEFAULT_RADIO_CONFIG() \
  { .radio_mode = ESP_ZIGBEE_RADIO_MODE_NATIVE, }
 
uint8_t *get_zcl_string(const char *str, uint8_t max_size, bool use_max_size = false);
 
struct AttrValue {
  ezb_zcl_attr_desc_t attr_desc;
  uint8_t value[4];
};
 
class ZigbeeAttribute;
 
class ZigbeeComponent final : public Component {
 public:
  void setup() override;
  void loop() override;
  void dump_config() override;
 
  void set_sleepy(bool sleepy) { this->sleepy_ = sleepy; }
  void set_keep_alive(uint32_t keep_alive) { this->keep_alive_ = keep_alive; }
  void set_basic_cluster(const char *model, const char *manufacturer, const char *location, const char *sw_build_id,
                         uint8_t power_source, uint8_t app_version);
  void add_cluster(uint8_t endpoint_id, uint16_t cluster_id, uint8_t role);
  void create_default_cluster(uint8_t endpoint_id, uint16_t device_id);
  bool register_device();
 
  template<typename T>
  void add_attr(ZigbeeAttribute *attr, uint8_t endpoint_id, uint16_t cluster_id, uint8_t role, uint16_t attr_id,
                uint8_t max_size, T value);
 
  template<typename T>
  void add_attr(uint8_t endpoint_id, uint16_t cluster_id, uint8_t role, uint16_t attr_id, uint8_t max_size, T value);
 
  static bool app_signal_handler(const ezb_app_signal_t *app_signal);
  static void esp_zigbee_alarm_bdb_commissioning(ezb_bdb_comm_mode_mask_t mode);
 
  void factory_reset();
  void report();
 
  template<typename F> void add_on_join_callback(F &&cb) { this->join_cb_.add(std::forward<F>(cb)); }
  template<typename F> void add_on_start_callback(F &&cb) { this->start_cb_.add(std::forward<F>(cb)); }
 
  bool is_battery_powered() { return this->basic_cluster_data_.power_source == EZB_ZCL_BASIC_POWER_SOURCE_BATTERY; }
 
  // True after the Zigbee stack has been initialized and the device has started up. Is set before the stack started
  // network commissioning or has joined a network and won't be reset until the device is rebooted.
  bool is_started() { return this->started_; }
 
  // True if the device has joined a network and is ready to send and receive messages.
  bool is_joined() { return this->joined_; }
 
 protected:
  bool sleepy_{false};
  uint32_t keep_alive_{3000};
  struct {
    uint8_t *model;
    uint8_t *manufacturer;
    uint8_t *date;
    uint8_t *location;
    uint8_t *sw_build_id;
    uint8_t power_source;
    uint8_t app_version;
  } basic_cluster_data_;
#ifdef CONFIG_ZB_ZED
  ezb_nwk_device_type_t device_role_ = EZB_NWK_DEVICE_TYPE_END_DEVICE;
#else
  ezb_nwk_device_type_t device_role_ = EZB_NWK_DEVICE_TYPE_ROUTER;
#endif
  void update_basic_cluster_(ezb_af_ep_desc_t ep_desc);
  template<typename T>
  void add_attr_(ZigbeeAttribute *attr, uint8_t endpoint_id, uint16_t cluster_id, uint8_t role, uint16_t attr_id,
                 T *value_p);
  void handle_attribute_(ezb_zcl_message_info_t info, ezb_zcl_attribute_t attribute);
  // attributes_ will be used during operation in zigbee callbacks to update the attribute values and trigger
  // automations
  // key tuple could be replaced by single 64 (48) bit int with bit fields for endpoint, cluster, role and attr_id
  std::map<std::tuple<uint8_t, uint16_t, uint8_t, uint16_t>, ZigbeeAttribute *> attributes_;
  std::vector<AttrValue> attr_values_;
  ezb_af_device_desc_t dev_desc_ = ezb_af_create_device_desc();
  CallbackManager<void(bool)> join_cb_{};
  template<typename... Args> friend void enqueue_zb_event(Args... args);
  esphome::LockFreeQueue<ZBEvent, MAX_ZB_QUEUE_SIZE> zb_events_;
  // Pool sized to queue capacity (SIZE-1) because LockFreeQueue<T,N> is a ring
  // buffer that holds N-1 elements (one slot distinguishes full from empty).
  // This guarantees allocate() returns nullptr before push() can fail, which:
  //  1. Prevents leaking a pool slot (the Nth allocate succeeds but push fails)
  //  2. Avoids needing release() on the producer path after a failed push(),
  //     preserving the SPSC contract on the pool's internal free list
  esphome::EventPool<ZBEvent, MAX_ZB_QUEUE_SIZE - 1> zb_event_pool_;
  LazyCallbackManager<void()> start_cb_{};
  bool start_reported_{false};
  std::atomic<bool> started_ = false;
  std::atomic<bool> joined_ = false;
  std::atomic<bool> join_pending_ = false;
  std::atomic<bool> factory_new_ = false;
  // TODO: remove when esp-zigbee-lib fixes set_value before init
  bool string_attr_exists_(uint8_t endpoint_id, uint16_t cluster_id, uint8_t role, uint16_t attr_id);
};
 
template<typename T>
void ZigbeeComponent::add_attr(uint8_t endpoint_id, uint16_t cluster_id, uint8_t role, uint16_t attr_id,
                               uint8_t max_size, T value) {
  this->add_attr<T>(nullptr, endpoint_id, cluster_id, role, attr_id, max_size, value);
}
 
template<typename T>
void ZigbeeComponent::add_attr(ZigbeeAttribute *attr, uint8_t endpoint_id, uint16_t cluster_id, uint8_t role,
                               uint16_t attr_id, uint8_t max_size, T value) {
  // The size byte of the zcl_str must be set to the maximum value,
  // even though the initial string may be shorter.
  if constexpr (std::is_same<T, std::string>::value) {
    if (this->string_attr_exists_(endpoint_id, cluster_id, role, attr_id)) {
      if (attr != nullptr) {
        this->attributes_[{endpoint_id, cluster_id, role, attr_id}] = attr;
      }
      return;
    }
    auto zcl_str = get_zcl_string(value.c_str(), max_size, true);
    add_attr_(attr, endpoint_id, cluster_id, role, attr_id, zcl_str);
    delete[] zcl_str;
  } else if constexpr (std::is_convertible<T, const char *>::value) {
    if (this->string_attr_exists_(endpoint_id, cluster_id, role, attr_id)) {
      if (attr != nullptr) {
        this->attributes_[{endpoint_id, cluster_id, role, attr_id}] = attr;
      }
      return;
    }
    auto zcl_str = get_zcl_string(value, max_size, true);
    add_attr_(attr, endpoint_id, cluster_id, role, attr_id, zcl_str);
    delete[] zcl_str;
  } else {
    add_attr_(attr, endpoint_id, cluster_id, role, attr_id, &value);
  }
}
 
template<typename T>
void ZigbeeComponent::add_attr_(ZigbeeAttribute *attr, uint8_t endpoint_id, uint16_t cluster_id, uint8_t role,
                                uint16_t attr_id, T *value_p) {
  ezb_af_ep_desc_t ep_desc = ezb_af_device_get_endpoint_desc(this->dev_desc_, endpoint_id);
  if (ep_desc == NULL) {
    return;
  }
  ezb_zcl_cluster_desc_t cluster_desc = ezb_af_endpoint_get_cluster_desc(ep_desc, cluster_id, role);
  if (cluster_desc == NULL) {
    return;
  }
  // TODO: revert when esp-zigbee-lib fixes set_value before init
  ezb_zcl_attr_desc_t attr_desc = ezb_zcl_cluster_get_attr_desc(cluster_desc, attr_id, EZB_ZCL_STD_MANUF_CODE);
 
  if (attr_desc != NULL) {
    static_assert(sizeof(*value_p) <= 4);
    AttrValue attr_value;
    attr_value.attr_desc = attr_desc;
    memcpy(&attr_value.value, value_p, sizeof(*value_p));
    attr_values_.push_back(attr_value);
  } else {
    esphome_zb_cluster_add_attr(cluster_id, cluster_desc, attr_id, value_p);
  }
 
  if (attr != nullptr) {
    this->attributes_[{endpoint_id, cluster_id, role, attr_id}] = attr;
  }
}
 
}  // namespace esphome::zigbee
 
#endif
#endif