7#include "freertos/FreeRTOS.h"
8#include "freertos/task.h"
17#include "esp_coexist.h"
24static constexpr uint32_t COMMISSIONING_RETRY_TIMEOUT_ID = 0;
25static constexpr uint32_t PARENT_LINK_TIMEOUT_ID = 1;
26static constexpr uint32_t PARENT_LINK_RETRY_TIMEOUT_ID = 2;
32static constexpr uint8_t PARENT_LINK_MISSED_POLLS = 4;
33static constexpr uint32_t PARENT_LINK_POLL_INTERVAL_MS = 3000;
34static constexpr uint32_t PARENT_LINK_MIN_SPAN_MS = 6000;
38uint8_t *
get_zcl_string(
const char *str, uint8_t max_size,
bool use_max_size) {
39 uint8_t str_len =
static_cast<uint8_t
>(strlen(str));
40 uint8_t zcl_str_size = use_max_size ? max_size : std::min(max_size, str_len);
41 uint8_t *zcl_str =
new uint8_t[zcl_str_size + 1];
42 zcl_str[0] = zcl_str_size;
45 memset(zcl_str + 1, 0, zcl_str_size);
46 uint8_t copy_len = std::min(zcl_str_size, str_len);
48 memcpy(zcl_str + 1, str, copy_len);
54 esp_zigbee_lock_acquire(portMAX_DELAY);
57 ezb_bdb_reset_via_local_action();
59 esp_zigbee_factory_reset();
61 esp_zigbee_lock_release();
65 for (
const auto &[_, attribute] : this->
attributes_) {
71 if (!esp_zigbee_lock_acquire(10 / portTICK_PERIOD_MS)) {
72 global_zigbee->
set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 100,
76 if (ezb_bdb_start_top_level_commissioning(
mode) != EZB_ERR_NONE) {
77 ESP_LOGE(TAG,
"Start top level commissioning failed!");
79 esp_zigbee_lock_release();
83 static uint8_t steering_retry_count = 0;
84 ezb_app_signal_type_t signal_type = ezb_app_signal_get_type(app_signal);
85 switch (signal_type) {
86 case EZB_ZDO_SIGNAL_SKIP_STARTUP:
87 ESP_LOGD(TAG,
"Zigbee stack initialized");
90 ezb_bdb_start_top_level_commissioning(EZB_BDB_MODE_INITIALIZATION);
92 case EZB_BDB_SIGNAL_DEVICE_FIRST_START:
93 case EZB_BDB_SIGNAL_DEVICE_REBOOT: {
94 ezb_bdb_comm_status_t
status = *((ezb_bdb_comm_status_t *) ezb_app_signal_get_params(app_signal));
95 if (
status == EZB_BDB_STATUS_SUCCESS) {
96 ESP_LOGD(TAG,
"Device started up in %sfactory-reset mode", ezb_bdb_is_factory_new() ?
"" :
"non ");
97 if (ezb_bdb_is_factory_new()) {
99 ESP_LOGD(TAG,
"Start network steering");
100 ezb_bdb_start_top_level_commissioning(EZB_BDB_MODE_NETWORK_STEERING);
102 ESP_LOGD(TAG,
"Device rebooted");
108 ESP_LOGW(TAG,
"The %s failed with status(0x%02x), please retry", ezb_app_signal_to_string(signal_type),
status);
109 global_zigbee->
set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 1000, []() {
114 case EZB_BDB_SIGNAL_STEERING: {
115 ezb_bdb_comm_status_t
status = *((ezb_bdb_comm_status_t *) ezb_app_signal_get_params(app_signal));
116 if (
status == EZB_BDB_STATUS_SUCCESS) {
117 steering_retry_count = 0;
118 ezb_extpanid_t extended_pan_id;
119 ezb_nwk_get_extended_panid(&extended_pan_id);
120 ESP_LOGD(TAG,
"Joined network successfully: PAN ID(0x%04hx, EXT: 0x%llx), Channel(%d), Short Address(0x%04hx)",
121 ezb_nwk_get_panid(), extended_pan_id.u64, ezb_nwk_get_current_channel(), ezb_nwk_get_short_address());
126 ESP_LOGD(TAG,
"Failed to join network with status(0x%02x)",
status);
127 if (steering_retry_count < 10) {
128 steering_retry_count++;
129 global_zigbee->
set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 1000, []() {
133 global_zigbee->
set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 600 * 1000, []() {
139 case EZB_ZDO_SIGNAL_LEAVE: {
140 const ezb_zdo_signal_leave_params_t *leave_params =
141 (
const ezb_zdo_signal_leave_params_t *) ezb_app_signal_get_params(app_signal);
142 if (leave_params->leave_type == EZB_ZDO_LEAVE_TYPE_RESET) {
143 esp_zigbee_factory_reset();
145 global_zigbee->
joined_ =
false;
149 case EZB_NWK_SIGNAL_NETWORK_STATUS: {
150 const ezb_nwk_signal_network_status_params_t *network_status_params =
151 (
const ezb_nwk_signal_network_status_params_t *) ezb_app_signal_get_params(app_signal);
152 if (network_status_params->status == EZB_NWK_NETWORK_STATUS_PARENT_LINK_FAILURE) {
157 ESP_LOGD(TAG,
"Zigbee APP Signal NETWORK_STATUS: 0x%02x", network_status_params->status);
161 ESP_LOGD(TAG,
"Zigbee APP Signal: %s(type: 0x%02x)", ezb_app_signal_to_string(signal_type), signal_type);
174 ezb_nwk_set_keepalive_interval(PARENT_LINK_POLL_INTERVAL_MS);
184 ESP_LOGV(TAG,
"Parent link failure (same poll)");
203 ESP_LOGW(TAG,
"Parent link failed in %u polls, attempting rejoin", this->
link_failures_);
207 ezb_zdo_nwk_mgmt_leave_req_t leave_req = {
208 .dst_nwk_addr = ezb_nwk_get_short_address(),
211 .remove_children =
false,
217 if (ezb_zdo_nwk_mgmt_leave_req(&leave_req) != EZB_ERR_NONE) {
218 ESP_LOGW(TAG,
"Leave request for rejoin failed");
225 if (!esp_zigbee_lock_acquire(10 / portTICK_PERIOD_MS)) {
235 esp_zigbee_lock_release();
237 ESP_LOGD(TAG,
"Parent link failures ended (%u)", failures);
249 ezb_nwk_get_keepalive_interval() == PARENT_LINK_POLL_INTERVAL_MS) {
255 event->load_set_attr_value_event(info, attribute);
261 if (event ==
nullptr) {
263 global_zigbee->
zb_events_.increment_dropped_count();
279static void zb_attribute_handler(ezb_zcl_set_attr_value_message_t *
message) {
280 ESP_RETURN_ON_FALSE(
message, , TAG,
"Empty message");
281 ESP_RETURN_ON_FALSE(
message->info.status == EZB_ZCL_STATUS_SUCCESS, , TAG,
"Received message: error status(%d)",
283 ESP_LOGD(TAG,
"ZCL SetAttributeValue message for endpoint(%d) cluster(0x%04x) %s with status(0x%02x)",
285 message->info.cluster_role == EZB_ZCL_CLUSTER_SERVER ?
"server" :
"client",
message->info.status);
289static void zb_action_handler(ezb_zcl_core_action_callback_id_t callback_id,
void *
message) {
290 switch (callback_id) {
291 case EZB_ZCL_CORE_SET_ATTR_VALUE_CB_ID:
292 zb_attribute_handler((ezb_zcl_set_attr_value_message_t *)
message);
294 case EZB_ZCL_CORE_DEFAULT_RSP_CB_ID: {
295#ifdef ESPHOME_LOG_HAS_VERBOSE
296 ezb_zcl_cmd_default_rsp_message_t *default_rsp = (ezb_zcl_cmd_default_rsp_message_t *)
message;
297 ESP_LOGV(TAG,
"Received ZCL Default Response: 0x%02x", default_rsp->in.status_code);
301 ESP_LOGD(TAG,
"Receive Zigbee action(0x%04x) callback",
static_cast<unsigned>(callback_id));
307 auto it = this->
attributes_.find({info.dst_ep, info.cluster_id, info.cluster_role, attribute.id});
309 it->second->on_value(attribute);
314 ezb_af_ep_desc_t ep_desc =
316 if (ezb_af_device_add_endpoint_desc(this->
dev_desc_, ep_desc) != EZB_ERR_NONE) {
317 ESP_LOGE(TAG,
"Could not create endpoint %u", endpoint_id);
322 this->
add_cluster(endpoint_id, EZB_ZCL_CLUSTER_ID_IDENTIFY, EZB_ZCL_CLUSTER_SERVER);
326 if (cluster_id == EZB_ZCL_CLUSTER_ID_BASIC) {
329 ezb_af_ep_desc_t ep_desc = ezb_af_device_get_endpoint_desc(this->
dev_desc_, endpoint_id);
330 if (ep_desc == NULL) {
331 ESP_LOGE(TAG,
"Endpoint %u does not exist, cannot add cluster 0x%04X", endpoint_id, cluster_id);
335 ESP_LOGD(TAG,
"Endpoint %u: Added cluster 0x%04X with role %u", endpoint_id, cluster_id, role);
339 const char *sw_build_id, uint8_t power_source, uint8_t app_version) {
342 struct tm *timeinfo =
localtime(&time_val);
343 strftime(date_buf,
sizeof(date_buf),
"%Y%m%d %H%M%S", timeinfo);
356 ezb_zcl_cluster_desc_t cluster_desc =
357 ezb_af_endpoint_get_cluster_desc(ep_desc, EZB_ZCL_CLUSTER_ID_BASIC, EZB_ZCL_CLUSTER_SERVER);
358 if (cluster_desc == NULL) {
359 ezb_zcl_basic_cluster_config_t basic_cluster_cfg = {
360 .zcl_version = EZB_ZCL_BASIC_ZCL_VERSION_DEFAULT_VALUE,
363 cluster_desc = ezb_zcl_basic_create_cluster_desc(&basic_cluster_cfg, EZB_ZCL_CLUSTER_SERVER);
364 ezb_af_endpoint_add_cluster_desc(ep_desc, cluster_desc);
366 ezb_zcl_basic_cluster_desc_add_attr(cluster_desc, EZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID,
368 ezb_zcl_basic_cluster_desc_add_attr(cluster_desc, EZB_ZCL_ATTR_BASIC_MODEL_IDENTIFIER_ID,
370 ezb_zcl_basic_cluster_desc_add_attr(cluster_desc, EZB_ZCL_ATTR_BASIC_DATE_CODE_ID, this->
basic_cluster_data_.date);
371 ezb_zcl_basic_cluster_desc_add_attr(cluster_desc, EZB_ZCL_ATTR_BASIC_APPLICATION_VERSION_ID,
373 uint8_t stack_version = 0;
374 uint8_t hw_version = 0;
375 ezb_zcl_basic_cluster_desc_add_attr(cluster_desc, EZB_ZCL_ATTR_BASIC_STACK_VERSION_ID, &stack_version);
376 ezb_zcl_basic_cluster_desc_add_attr(cluster_desc, EZB_ZCL_ATTR_BASIC_HW_VERSION_ID, &hw_version);
377 ezb_zcl_basic_cluster_desc_add_attr(cluster_desc, EZB_ZCL_ATTR_BASIC_LOCATION_DESCRIPTION_ID,
379 ezb_zcl_basic_cluster_desc_add_attr(cluster_desc, EZB_ZCL_ATTR_BASIC_SW_BUILD_ID_ID,
384 if (ezb_af_device_desc_register(this->
dev_desc_) != EZB_ERR_NONE) {
385 ESP_LOGE(TAG,
"Could not register the endpoint list");
392static void ezb_task(
void *pv_parameters) {
397 if (esp_zigbee_start(
false) != ESP_OK) {
398 ESP_LOGE(TAG,
"Could not setup Zigbee");
405 vTaskPrioritySet(NULL, 5);
407 esp_zigbee_launch_mainloop();
415 global_zigbee =
this;
417 esp_zigbee_platform_config_t platform_config = {
418 .storage_partition_name =
"nvs",
419 .radio_config = EZB_DEFAULT_RADIO_CONFIG(),
421 esp_zigbee_device_config_t device_config = {
423 .install_code_policy =
false,
426 esp_zigbee_zczr_config_s zb_zczr_cfg = {
427 .max_children = MAX_CHILDREN,
429 device_config.zczr_config = zb_zczr_cfg;
431 esp_zigbee_zed_config_s zb_zed_cfg = {
432 .ed_timeout = EZB_NWK_ED_TIMEOUT_64MIN,
435 device_config.zed_config = zb_zed_cfg;
437 esp_zigbee_config_t config = {.device_config = device_config, .platform_config = platform_config};
438 if (esp_zigbee_init(&config) != ESP_OK) {
439 ESP_LOGE(TAG,
"Could not initialize Zigbee");
445 if (esp_coex_wifi_i154_enable() != ESP_OK) {
452 ezb_bdb_set_router_rejoin_required(
true);
454 ezb_nwk_set_rx_on_when_idle(!this->
sleepy_);
457 ezb_aps_secur_enable_distributed_security(
false);
458 ezb_nwk_set_min_join_lqi(32);
460 ESP_LOGE(TAG,
"Could not set application signal handler");
465 ezb_zcl_core_action_handler_register(zb_action_handler);
467 if (ezb_bdb_set_primary_channel_set(EZB_PRIMARY_CHANNEL_MASK) != ESP_OK) {
468 ESP_LOGE(TAG,
"Could not setup Zigbee");
474 : EZB_AF_NODE_POWER_SOURCE_CONSTANT_POWER);
475 ezb_af_node_power_desc_t desc = {
476 .current_power_mode = EZB_AF_NODE_POWER_MODE_SYNC_ON_WHEN_IDLE,
479 .current_power_source_level = EZB_AF_NODE_POWER_SOURCE_LEVEL_100_PERCENT,
481 ezb_af_set_node_power_desc(&desc);
484 xTaskCreate(ezb_task,
"Zigbee_main", 4096, NULL, 1, NULL);
491 while (event !=
nullptr) {
494 case EZB_ZCL_CORE_SET_ATTR_VALUE_CB_ID:
498 ESP_LOGW(TAG,
"Received event with unhandled callback id: 0x%x",
static_cast<unsigned>(event->
callback_id_));
508 uint16_t dropped = this->
zb_events_.get_and_reset_dropped_count();
510 ESP_LOGW(TAG,
"Dropped %u Zigbee events due to buffer overflow", dropped);
528 " Manufacturer: %.*s\n"
532 " Sleepy end device: %s\n"
533 " Poll interval: %" PRIu32
" ms\n"
536 this->
basic_cluster_data_.model[0],
reinterpret_cast<const char *
>(this->basic_cluster_data_.model + 1),
537 this->basic_cluster_data_.manufacturer[0],
538 reinterpret_cast<const char *
>(this->basic_cluster_data_.manufacturer + 1),
540 YESNO(this->
device_role_ == EZB_NWK_DEVICE_TYPE_ROUTER),
545 if (esp_zigbee_lock_acquire(10 / portTICK_PERIOD_MS)) {
547 " Device is joined to the network: %s\n"
548 " Current channel: %d\n"
549 " Short addr: 0x%04X\n"
550 " Short pan id: 0x%04X",
551 YESNO(ezb_bdb_dev_joined()), ezb_nwk_get_current_channel(), ezb_nwk_get_short_address(),
552 ezb_nwk_get_panid());
553 esp_zigbee_lock_release();
BedjetMode mode
BedJet operating mode.
time_t get_build_time()
Get the build time as a Unix timestamp.
void mark_failed()
Mark this component as failed.
void enable_loop_soon_any_context()
Thread and ISR-safe version of enable_loop() that can be called from any context.
bool cancel_timeout(const char *name)
Cancel a timeout function.
void set_timeout(const char *name, uint32_t timeout, std::function< void()> &&f)
Set a timeout function with a const char* name.
void disable_loop()
Disable this component's loop.
ezb_zcl_core_action_callback_id_t callback_id_
union esphome::zigbee::ZBEvent::@210 event_
struct esphome::zigbee::ZBEvent::@210::set_attr_event set_attr
CallbackManager< void(bool)> join_cb_
bool is_battery_powered()
void create_default_cluster(uint8_t endpoint_id, uint16_t device_id)
std::atomic< bool > factory_new_
void handle_attribute_(ezb_zcl_message_info_t info, ezb_zcl_attribute_t attribute)
esphome::LockFreeQueue< ZBEvent, MAX_ZB_QUEUE_SIZE > zb_events_
std::map< std::tuple< uint8_t, uint16_t, uint8_t, uint16_t >, ZigbeeAttribute * > attributes_
void update_basic_cluster_(ezb_af_ep_desc_t ep_desc)
void add_cluster(uint8_t endpoint_id, uint16_t cluster_id, uint8_t role)
static void esp_zigbee_alarm_bdb_commissioning(ezb_bdb_comm_mode_mask_t mode)
LazyCallbackManager< void()> start_cb_
void on_parent_link_failure_()
static bool app_signal_handler(const ezb_app_signal_t *app_signal)
std::atomic< bool > joined_
std::atomic< bool > started_
std::atomic< bool > join_pending_
ezb_nwk_device_type_t device_role_
uint32_t last_link_failure_ms_
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 dump_config() override
uint32_t first_link_failure_ms_
void end_parent_link_failures_(uint8_t seq)
esphome::EventPool< ZBEvent, MAX_ZB_QUEUE_SIZE - 1 > zb_event_pool_
struct esphome::zigbee::ZigbeeComponent::@209 basic_cluster_data_
uint8_t link_failure_seq_
ezb_af_device_desc_t dev_desc_
void reset_parent_link_failures_()
uint32_t saved_keep_alive_
const LogString * message
void load_zb_event(ZBEvent *event, ezb_zcl_message_info_t info, ezb_zcl_attribute_t attribute)
uint8_t * get_zcl_string(const char *str, uint8_t max_size, bool use_max_size)
ESPHOME_LOG_TAG(TAG, "zigbee.time")
void enqueue_zb_event(Args... args)
uint32_t IRAM_ATTR HOT millis()
Application App
Global storage of Application pointer - only one Application can exist.
struct tm * localtime(const time_t *timer)
ezb_err_t esphome_zb_add_or_update_cluster(uint16_t cluster_id, ezb_af_ep_desc_t ep_desc, uint8_t role_mask)
ezb_af_ep_desc_t esphome_zb_zha_default_ep_desc_create(uint8_t ep_id, uint16_t device_id, uint8_t power_source)