Light sleep example crashing with custom cluster esp_zb_zcl_report_attr_cmd_t (TZ-1917)

[user857382915]

Hey,

Setup:

IDF v5.4.1, zboss-lib v1.6.4, zigbee-lib v1.6.5
im working on a ESP32C6 end device based on light sleep example connected to Zigbee2Mqtt coordinator. As it is necessary to transmit strings from the end device to the coordinator I want to add a manufacturerer specific cluster to the end device, which I tried with replacing the example projects code in esp_zb_task with code from custom cluster example.

Problem:

The custom cluster is correctly recognized by Z2M, but trying to issue an esp_zb_zcl_report_attr_cmd_req fails (no log in Z2M) and frequent crashes caused by watchdog.

Question:

I assume I am missing something. Maybe some settings in the cmd need other configuration?

I appreaciate any help

Additional context.

Serial log:

I (10467) ESP_ZB_SLEEP: Zigbee can sleep
--- Error: ClearCommError failed (PermissionError(13, 'Das Gerät erkennt den Befehl nicht.', None, 22))
--- Waiting for the device to reconnect
I (12810) ESP_ZB_SLEEP: Zigbee can sleep
--- Error: ClearCommError failed (PermissionError(13, 'Das Gerät erkennt den Befehl nicht.', None, 22))
--- Waiting for the device to reconnect.
E (18650) task_wdt: Task watchdog got triggered. The following tasks/users did not reset the watchdog in time:
E (18650) task_wdt:  - IDLE (CPU 0)
E (18650) task_wdt: Tasks currently running:
E (18650) task_wdt: CPU 0: Zigbee_main
E (18650) task_wdt: Print CPU 0 (current core) backtrace
esp_backtrace_print: Print CPU 0 (current core) registers

esp_zb_task:

static void esp_zb_task(void *pvParameters)
{
    /* initialize Zigbee stack with Zigbee end-device config */
    esp_zb_cfg_t zb_nwk_cfg = ESP_ZB_ZED_CONFIG();
    /* Enable zigbee light sleep */
    esp_zb_sleep_enable(true);
    esp_zb_init(&zb_nwk_cfg);

    //=================================

    esp_zb_ep_list_t *ep_list = esp_zb_ep_list_create();
    esp_zb_endpoint_config_t endpoint_config = {
        .endpoint = CUSTOM_SERVER_ENDPOINT,
        .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID,
        .app_device_id = ESP_ZB_HA_CUSTOM_ATTR_DEVICE_ID,
        .app_device_version = 0,
    };
    esp_zb_cluster_list_t *cluster_list = esp_zb_zcl_cluster_list_create();
    esp_zb_attribute_list_t *custom_cluster = esp_zb_zcl_attr_list_create(CUSTOM_CLUSTER_ID);
    uint16_t custom_attr1_id = 0x0000;
    uint8_t custom_attr1_value[] = "\x0b""hello world";
    uint16_t custom_attr2_id = 0x0001;
    uint16_t custom_attr2_value = 0x1234;
    esp_zb_custom_cluster_add_custom_attr(custom_cluster, custom_attr1_id, ESP_ZB_ZCL_ATTR_TYPE_CHAR_STRING,
                                        ESP_ZB_ZCL_ATTR_ACCESS_READ_WRITE | ESP_ZB_ZCL_ATTR_ACCESS_REPORTING, custom_attr1_value);
    esp_zb_custom_cluster_add_custom_attr(custom_cluster, custom_attr2_id, ESP_ZB_ZCL_ATTR_TYPE_U16, ESP_ZB_ZCL_ATTR_ACCESS_READ_WRITE | ESP_ZB_ZCL_ATTR_ACCESS_REPORTING,
                                        &custom_attr2_value);

    /* Mandatory clusters */
    esp_zb_cluster_list_add_basic_cluster(cluster_list, esp_zb_basic_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
    esp_zb_cluster_list_add_identify_cluster(cluster_list, esp_zb_identify_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
    /* Custom cluster */
    esp_zb_cluster_list_add_custom_cluster(cluster_list, custom_cluster, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);

    esp_zb_ep_list_add_ep(ep_list, cluster_list, endpoint_config);
    esp_zb_device_register(ep_list);

    //=================================

    esp_zb_core_action_handler_register(zb_action_handler);
    esp_zb_set_primary_network_channel_set(ESP_ZB_PRIMARY_CHANNEL_MASK);
    ESP_ERROR_CHECK(esp_zb_start(false));
    esp_zb_stack_main_loop();
}

zb_buttons_handler

static void zb_buttons_handler(switch_func_pair_t* button_func_pair)
{
    if (button_func_pair->func == SWITCH_ONOFF_TOGGLE_CONTROL) {
        ESP_LOGI(TAG, "Sensor Interrupt!");

        const TickType_t xDelay = 10000 / portTICK_PERIOD_MS;
        vTaskDelay(xDelay);

        esp_zb_zcl_report_attr_cmd_t cmd = { 0 };
        esp_zb_addr_u addr = { 0x0000 };
        cmd.zcl_basic_cmd.dst_addr_u = addr;
        cmd.zcl_basic_cmd.dst_endpoint = 0x01;
        cmd.zcl_basic_cmd.src_endpoint = CUSTOM_SERVER_ENDPOINT;
        cmd.address_mode = ESP_ZB_APS_ADDR_MODE_16_ENDP_PRESENT;
        cmd.clusterID = CUSTOM_CLUSTER_ID;
        cmd.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_CLI;
        cmd.manuf_code = 0x1234;

        cmd.attributeID = 0x0000;

        esp_zb_lock_acquire(portMAX_DELAY);
        esp_zb_zcl_report_attr_cmd_req(&cmd);
        esp_zb_lock_release();
    }
}

The other code is the similar to the example.

[xieqinan]

The custom cluster is correctly recognized by Z2M, but trying to issue an esp_zb_zcl_report_attr_cmd_req fails (no log in Z2M).

If you intend to report an attribute with manufacturer-specific information, you need to set cmd.manuf_specific = 1;. Additionally, ensure that the attribute is included in the data model using esp_zb_cluster_add_manufacturer_attr().

frequent crashes caused by watchdog.

The issue may be caused by a deadlock or an infinite loop. Please double-check your code. If possible, share a minimal reproducible example based on the latest esp-zigbee-sdk main branch.

[user857382915]

This is the complete code:

/*
 * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: CC0-1.0
 *
 * Zigbee Sleepy end device Example
 *
 * This example code is in the Public Domain (or CC0 licensed, at your option.)
 *
 * Unless required by applicable law or agreed to in writing, this
 * software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied.
 */
#include "esp_check.h"
#include "hal/gpio_types.h"
#include "nvs_flash.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "ha/esp_zigbee_ha_standard.h"
#include "esp_zb_sleepy_end_device.h"
#include "switch_driver.h"
#ifdef CONFIG_PM_ENABLE
#include "esp_pm.h"
#include "esp_private/esp_clk.h"
#include "esp_sleep.h"
#endif
#include "driver/rtc_io.h"
#include "driver/gpio.h"

/**
 * @note Make sure set idf.py menuconfig in zigbee component as zigbee end device!
*/
#if !defined ZB_ED_ROLE
#error Define ZB_ED_ROLE in idf.py menuconfig to compile light (End Device) source code.
#endif

#define CUSTOM_SERVER_ENDPOINT 0x01
#define CUSTOM_CLIENT_ENDPOINT 0x01
#define CUSTOM_CLUSTER_ID 0xFF11
#define CUSTOM_COMMAND_RESP 0x0001

static const char *TAG = "ESP_ZB_SLEEP";

static switch_func_pair_t button_func_pair[] = {{CONFIG_GPIO_EXT1_WAKEUP_SOURCE, SWITCH_ONOFF_TOGGLE_CONTROL}};

static void zb_buttons_handler(switch_func_pair_t* button_func_pair)
{
    if (button_func_pair->func == SWITCH_ONOFF_TOGGLE_CONTROL) {
        esp_zb_zcl_report_attr_cmd_t cmd = { 0 };
        esp_zb_addr_u addr = { 0x0000 };
        cmd.zcl_basic_cmd.dst_addr_u = addr;
        cmd.zcl_basic_cmd.dst_endpoint = 0x01;
        cmd.zcl_basic_cmd.src_endpoint = CUSTOM_SERVER_ENDPOINT;
        cmd.address_mode = ESP_ZB_APS_ADDR_MODE_16_ENDP_PRESENT;
        cmd.clusterID = CUSTOM_CLUSTER_ID;
        cmd.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_CLI;
        cmd.manuf_code = 0x1234;
        cmd.attributeID = 0x0000;
        cmd.manuf_specific = 1;

        esp_zb_lock_acquire(portMAX_DELAY);
        esp_zb_zcl_report_attr_cmd_req(&cmd);
        esp_zb_lock_release();
    }
}

static esp_err_t deferred_driver_init(void)
{
    static bool is_inited = false;
    if (!is_inited) {
        ESP_RETURN_ON_FALSE(switch_driver_init(button_func_pair, PAIR_SIZE(button_func_pair), zb_buttons_handler),
                            ESP_FAIL, TAG, "Failed to initialize switch driver");
        /* Configure RTC IO wake up:
        The configuration mode depends on your hardware design.
        Since the BOOT button is connected to a pull-up resistor, the wake-up mode is configured as LOW.
        */
        ESP_ERROR_CHECK(esp_sleep_enable_ext1_wakeup(BIT(CONFIG_GPIO_EXT1_WAKEUP_SOURCE), ESP_EXT1_WAKEUP_ANY_LOW));

#if SOC_RTCIO_INPUT_OUTPUT_SUPPORTED
        rtc_gpio_init(CONFIG_GPIO_EXT1_WAKEUP_SOURCE);
        rtc_gpio_pulldown_dis(CONFIG_GPIO_EXT1_WAKEUP_SOURCE);
        rtc_gpio_pullup_en(CONFIG_GPIO_EXT1_WAKEUP_SOURCE);
#else
        gpio_pulldown_dis(CONFIG_GPIO_EXT1_WAKEUP_SOURCE);
        gpio_pullup_en(CONFIG_GPIO_EXT1_WAKEUP_SOURCE);
#endif
        is_inited = true;
    }
    return is_inited ? ESP_OK : ESP_FAIL;
}

/********************* Define functions **************************/
static void bdb_start_top_level_commissioning_cb(uint8_t mode_mask)
{
    ESP_RETURN_ON_FALSE(esp_zb_bdb_start_top_level_commissioning(mode_mask) == ESP_OK, , TAG, "Failed to start Zigbee bdb commissioning");
}

void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct)
{
    uint32_t *p_sg_p       = signal_struct->p_app_signal;
    esp_err_t err_status = signal_struct->esp_err_status;
    esp_zb_app_signal_type_t sig_type = *p_sg_p;
    switch (sig_type) {
    case ESP_ZB_ZDO_SIGNAL_SKIP_STARTUP:
        ESP_LOGI(TAG, "Initialize Zigbee stack");
        esp_zb_bdb_start_top_level_commissioning(ESP_ZB_BDB_MODE_INITIALIZATION);
        break;
    case ESP_ZB_BDB_SIGNAL_DEVICE_FIRST_START:
    case ESP_ZB_BDB_SIGNAL_DEVICE_REBOOT:
        if (err_status == ESP_OK) {
            ESP_LOGI(TAG, "Deferred driver initialization %s", deferred_driver_init() ? "failed" : "successful");
            ESP_LOGI(TAG, "Device started up in%s factory-reset mode", esp_zb_bdb_is_factory_new() ? "" : " non");
            if (esp_zb_bdb_is_factory_new()) {
                ESP_LOGI(TAG, "Start network steering");
                esp_zb_bdb_start_top_level_commissioning(ESP_ZB_BDB_MODE_NETWORK_STEERING);
            } else {
                ESP_LOGI(TAG, "Device rebooted");
            }
        } else {
            ESP_LOGW(TAG, "%s failed with status: %s, retrying", esp_zb_zdo_signal_to_string(sig_type),
                     esp_err_to_name(err_status));
            esp_zb_scheduler_alarm((esp_zb_callback_t)bdb_start_top_level_commissioning_cb,
                                   ESP_ZB_BDB_MODE_INITIALIZATION, 1000);
        }
        break;
    case ESP_ZB_BDB_SIGNAL_STEERING:
        if (err_status == ESP_OK) {
            esp_zb_ieee_addr_t extended_pan_id;
            esp_zb_get_extended_pan_id(extended_pan_id);
            ESP_LOGI(TAG, "Joined network successfully (Extended PAN ID: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x, PAN ID: 0x%04hx, Channel:%d, Short Address: 0x%04hx)",
                     extended_pan_id[7], extended_pan_id[6], extended_pan_id[5], extended_pan_id[4],
                     extended_pan_id[3], extended_pan_id[2], extended_pan_id[1], extended_pan_id[0],
                     esp_zb_get_pan_id(), esp_zb_get_current_channel(), esp_zb_get_short_address());
        } else {
            ESP_LOGI(TAG, "Network steering was not successful (status: %d)", err_status);
            esp_zb_scheduler_alarm((esp_zb_callback_t)bdb_start_top_level_commissioning_cb, ESP_ZB_BDB_MODE_NETWORK_STEERING, 1000);
        }
        break;
      case ESP_ZB_COMMON_SIGNAL_CAN_SLEEP:
        ESP_LOGI(TAG, "Zigbee can sleep");
        esp_zb_sleep_now();
        break;
    default:
        ESP_LOGI(TAG, "ZDO signal: %s (0x%x), status: %s", esp_zb_zdo_signal_to_string(sig_type), sig_type, esp_err_to_name(err_status));
        break;
    }
}

static esp_err_t esp_zb_power_save_init(void)
{
    esp_err_t rc = ESP_OK;
#ifdef CONFIG_PM_ENABLE
    int cur_cpu_freq_mhz = CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ;
    esp_pm_config_t pm_config = {
        .max_freq_mhz = cur_cpu_freq_mhz,
        .min_freq_mhz = cur_cpu_freq_mhz,
#if CONFIG_FREERTOS_USE_TICKLESS_IDLE
        .light_sleep_enable = true
#endif
    };
    rc = esp_pm_configure(&pm_config);
#endif
    return rc;
}

static esp_err_t zb_attribute_handler(const esp_zb_zcl_set_attr_value_message_t *message)
{
    esp_err_t ret = ESP_OK;
    bool light_state = 0;

    ESP_RETURN_ON_FALSE(message, ESP_FAIL, TAG, "Empty message");
    ESP_RETURN_ON_FALSE(message->info.status == ESP_ZB_ZCL_STATUS_SUCCESS, ESP_ERR_INVALID_ARG, TAG, "Received message: error status(%d)",
                        message->info.status);
    ESP_LOGI(TAG, "Received message: endpoint(%d), cluster(0x%x), attribute(0x%x), data size(%d)", message->info.dst_endpoint, message->info.cluster,
             message->attribute.id, message->attribute.data.size);
    if (message->info.dst_endpoint == HA_ESP_LIGHT_ENDPOINT) {
        if (message->info.cluster == ESP_ZB_ZCL_CLUSTER_ID_ON_OFF) {
            if (message->attribute.id == ESP_ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID && message->attribute.data.type == ESP_ZB_ZCL_ATTR_TYPE_BOOL) {
                light_state = message->attribute.data.value ? *(bool *)message->attribute.data.value : light_state;
                ESP_LOGI(TAG, "Light sets to %s", light_state ? "On" : "Off");
            }
        }
    }
    return ret;
}

static esp_err_t zb_action_handler(esp_zb_core_action_callback_id_t callback_id, const void *message)
{
    esp_err_t ret = ESP_OK;
    switch (callback_id) {
    case ESP_ZB_CORE_SET_ATTR_VALUE_CB_ID:
        ret = zb_attribute_handler((esp_zb_zcl_set_attr_value_message_t *)message);
        break;
    default:
        ESP_LOGW(TAG, "Receive Zigbee action(0x%x) callback", callback_id);
        break;
    }
    return ret;
}

static void esp_zb_task(void *pvParameters)
{
    /* initialize Zigbee stack with Zigbee end-device config */
    esp_zb_cfg_t zb_nwk_cfg = ESP_ZB_ZED_CONFIG();
    /* Enable zigbee light sleep */
    esp_zb_sleep_enable(true);
    esp_zb_init(&zb_nwk_cfg);


    //==============================================================================================================

    esp_zb_ep_list_t *ep_list = esp_zb_ep_list_create();
    esp_zb_endpoint_config_t endpoint_config = {
        .endpoint = CUSTOM_SERVER_ENDPOINT,
        .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID,
        .app_device_id = ESP_ZB_HA_CUSTOM_ATTR_DEVICE_ID,
        .app_device_version = 0,
    };
    esp_zb_cluster_list_t *cluster_list = esp_zb_zcl_cluster_list_create();
    esp_zb_attribute_list_t *custom_cluster = esp_zb_zcl_attr_list_create(CUSTOM_CLUSTER_ID);
    uint16_t custom_attr1_id = 0x0000;
    uint8_t custom_attr1_value[] = "\x0b""hello world";
    //esp_zb_custom_cluster_add_custom_attr(custom_cluster, custom_attr1_id, ESP_ZB_ZCL_ATTR_TYPE_CHAR_STRING,ESP_ZB_ZCL_ATTR_ACCESS_READ_WRITE | ESP_ZB_ZCL_ATTR_ACCESS_REPORTING, custom_attr1_value);
    esp_zb_cluster_add_manufacturer_attr(custom_cluster, 0xFF11, custom_attr1_id, 0x1234, ESP_ZB_ZCL_ATTR_TYPE_CHAR_STRING, ESP_ZB_ZCL_ATTR_ACCESS_READ_WRITE | ESP_ZB_ZCL_ATTR_ACCESS_REPORTING, custom_attr1_value);

    /* Mandatory clusters */
    esp_zb_cluster_list_add_basic_cluster(cluster_list, esp_zb_basic_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
    esp_zb_cluster_list_add_identify_cluster(cluster_list, esp_zb_identify_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
    /* Custom cluster */
    esp_zb_cluster_list_add_custom_cluster(cluster_list, custom_cluster, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);

    esp_zb_ep_list_add_ep(ep_list, cluster_list, endpoint_config);
    esp_zb_device_register(ep_list);

    //==============================================================================================================


    esp_zb_core_action_handler_register(zb_action_handler);
    esp_zb_set_primary_network_channel_set(ESP_ZB_PRIMARY_CHANNEL_MASK);
    ESP_ERROR_CHECK(esp_zb_start(false));
    esp_zb_stack_main_loop();
}

void app_main(void)
{

    const TickType_t xDelay = 10000 / portTICK_PERIOD_MS;
    vTaskDelay(xDelay);

    esp_zb_platform_config_t config = {
        .radio_config = ESP_ZB_DEFAULT_RADIO_CONFIG(),
        .host_config = ESP_ZB_DEFAULT_HOST_CONFIG(),
    };
    ESP_ERROR_CHECK(nvs_flash_init());
    /* esp zigbee light sleep initialization*/
    ESP_ERROR_CHECK(esp_zb_power_save_init());
    /* load Zigbee platform config to initialization */
    ESP_ERROR_CHECK(esp_zb_platform_config(&config));

    xTaskCreate(esp_zb_task, "Zigbee_main", 4096, NULL, 5, NULL);
}

This version causes the Brownout Detector to trigger on boot or when interrupt is triggered to report attribute command. In Zigbee2Mqtt, no message is received. On esp, Receive Zigbee action(0x1005) callback (default response) is printed.

[xieqinan]

This version causes the Brownout Detector to trigger on boot or when interrupt is triggered to report attribute command.

I used the above code without any modifications and allowed the device to join the coordinator created by the HA switch. It worked without any crashes.

In Zigbee2Mqtt, no message is received. On esp, Receive Zigbee action(0x1005) callback (default response) is printed.

Please ensure that Zigbee2MQTT can handle commands with the manufacturer code 0x1234, which is assigned to DSR Corporation.

[user857382915]

I can not find any information on how Zigbee2Mqtt handles manufacturer codes, nor any public information on how manufactuerer codes are assigned. This solution seems to become very complex compared to relatively small goal of transmitting a string.

My goal is still to simply report a string from a sleepy end-device to a zigbee2mqtt coordinator. Do you have any recommendations on how to structure a project to achieve this goal? Especially as there is little to no documentation on how to support custom devices in Zigbee2Mqtt.

[user857382915]

Any help?

[xieqinan]

Do you have any recommendations on how to structure a project to achieve this goal?

The behavior of Zigbee2MQTT is defined by yourself, so I don’t have a specific recommendation. You need to confirm whether Zigbee2MQTT supports and can handle the custom cluster, and then try sending the command without a manufacturer code.