Zigbee Project Flow Sensor

[Guilhem-34]

Problem with assertion of zigbee stack

[Guilhem-34]

Hi everyone, i'm a student and i'm working on a zigbee project. I want to communicate data of flow sensor with zigbee protocol on HA and especially using ZigbeeMQTT. But i have a problem with an assertion error and i cant find anything on this forum to help me. I just drop my code and my configuration (.yaml) on Zigbee2Mqtt.

The log are looking like that :

I (27) boot: ESP-IDF v5.3.2-dirty 2nd stage bootloader
I (27) boot: compile time Jan 8 2025 18:28:16
I (29) boot: chip revision: v0.1
I (30) boot: efuse block revision: v0.1
I (35) boot.esp32h2: SPI Speed : 64MHz
I (40) boot.esp32h2: SPI Mode : DIO
I (44) boot.esp32h2: SPI Flash Size : 4MB
I (49) boot: Enabling RNG early entropy source...
I (55) boot: Partition Table:
I (58) boot: ## Label Usage Type ST Offset Length
I (65) boot: 0 nvs WiFi data 01 02 00009000 00006000
I (73) boot: 1 phy_init RF data 01 01 0000f000 00001000
I (80) boot: 2 factory factory app 00 00 00010000 00190000
I (88) boot: 3 zb_storage Unknown data 01 81 001a0000 00008000
I (95) boot: 4 zb_fct Unknown data 01 81 001a8000 00002000
I (103) boot: 5 ota_0 OTA app 00 10 001b0000 00190000
I (110) boot: End of partition table
I (114) esp_image: segment 0: paddr=00010020 vaddr=42090020 size=2ec1ch (191516) map
I (201) esp_image: segment 1: paddr=0003ec44 vaddr=40800000 size=013d4h ( 5076) load
I (205) esp_image: segment 2: paddr=00040020 vaddr=42000020 size=8ff78h (589688) map
I (447) esp_image: segment 3: paddr=000cffa0 vaddr=408013d4 size=0ae34h ( 44596) load
I (469) esp_image: segment 4: paddr=000daddc vaddr=4080c210 size=01c74h ( 7284) load
I (481) boot: Loaded app from partition at offset 0x10000
I (483) boot: Disabling RNG early entropy source...
I (494) cpu_start: Unicore app
I (503) cpu_start: Pro cpu start user code
I (503) cpu_start: cpu freq: 96000000 Hz
I (504) app_init: Application information:
I (506) app_init: Project name: temperature
I (511) app_init: App version: 1
I (515) app_init: Compile time: Jan 8 2025 18:26:51
I (521) app_init: ELF file SHA256: 7903860cb...
I (527) app_init: ESP-IDF: v5.3.2-dirty
I (532) efuse_init: Min chip rev: v0.0
I (537) efuse_init: Max chip rev: v0.99
I (542) efuse_init: Chip rev: v0.1
I (547) heap_init: Initializing. RAM available for dynamic allocation:
I (554) heap_init: At 408125D0 len 0003ADB0 (235 KiB): RAM
I (560) heap_init: At 4084D380 len 00002B60 (10 KiB): RAM
I (567) spi_flash: detected chip: generic
I (571) spi_flash: flash io: dio
I (575) sleep: Configure to isolate all GPIO pins in sleep state
I (582) sleep: Enable automatic switching of GPIO sleep configuration
I (589) main_task: Started on CPU0
I (609) main_task: Calling app_main()
I (619) ESP_ZIGBEE_CORE: SDK Version: v1.6.1-9d7f2d69f5-054ee942-e9475ff; esp32h2; 2024-12-06 04:21:15 UTC
I (639) phy: phy_version: 310,2, 463a420, Aug 15 2024, 18:52:11
I (639) phy: libbtbb version: a024da6, Aug 15 2024, 18:52:23
ZBOSS: common/zb_init_default.c:181 ED build
ZBOSS: common/zb_init_default.c:187 sizes: g_zb 7576 sched 224 bpool 16 nwk 912 aps 3040 addr 284 zdo 840
ZBOSS: common/zb_init_default.c:196 sec 2
ZBOSS: common/zb_init_default.c:198 zcl 768
ZBOSS: common/zb_init_default.c:201 zll 960
ZBOSS: common/zb_init_default.c:207 nvram 140
ZBOSS: common/zb_init_default.c:210 buttons 200
ZBOSS: common/zb_init_default.c:212 err_ind 4
ZBOSS: common/zb_init_default.c:218 scheduler q size 80
ZBOSS: common/zb_init_default.c:221 g_mac 816 g_imac 28
ZBOSS: common/zb_init_default.c:225 Configurable mem build, use ZBOSS lib defaults = 0
ZBOSS: common/zb_init_default.c:231 ZB_IOBUF_POOL_SIZE 80 ZB_NWK_IN_Q_SIZE 40 ZB_MAC_PENDING_QUEUE_SIZE 20 ZB_APS_DST_BINDING_TABLE_SIZE 16 ZB_APS_BIND_TRANS_TABLE_SIZE 20 ZB_N_APS_RETRANS_ENTRIES 27
ZBOSS: common/zb_init_default.c:261 ZB_N_APS_KEY_PAIR_ARR_MAX_SIZE 8 ZB_IEEE_ADDR_TABLE_SIZE 64 ZB_NEIGHBOR_TABLE_SIZE 64 ZB_NWK_ROUTING_TABLE_SIZE 0 ZB_APS_DUPS_TABLE_SIZE 32
ZBOSS: zdo/af_descriptor.c:357 ep_count 1
ZBOSS: zdo/zdo_app_prod_conf.c:144 no production config block found
ZBOSS: zdo/zdo_app_prod_conf.c:781 no valid production configuration found, signaling to application
I (749) main_task: Returned from app_main()
I (759) ESP_ZB_FLOW_SENSOR: ZDO signal: ZDO Config Ready (0x17), status: ESP_FAIL
I (759) ESP_ZB_FLOW_SENSOR: Zigbee stack initialized
ZBOSS: commissioning/bdb/zdo_commissioning_bdb.c:349 dev type 2, joined 1, ext_pan_id 1, authenticated 1, tclk_valid 1
ZBOSS: zdo/zdo_app_join.c:771 CONGRATULATIONS! joined status 0, addr 0xb46a, iface_id 0, ch 11, rejoin 1
ZBOSS: zdo/zdo_app_join.c:773 xpanid 38:bd:ff:97:f0:90:0a:4c
ZBOSS: commissioning/bdb/zdo_commissioning_bdb.c:549 COMMISSIONING_STOP: app signal 6 comm status 0
I (3169) ESP_ZB_FLOW_SENSOR: Start network steering
ZBOSS: commissioning/bdb/zdo_commissioning_bdb.c:549 COMMISSIONING_STOP: app signal 10 comm status 0
I (3179) ESP_ZB_FLOW_SENSOR: Joined network successfully (Extended PAN ID: 38:bd:ff:97:f0:90:0a:4c, PAN ID: 0x4b98, Channel:11)
I (4189) ESP_ZB_FLOW_SENSOR: Reported Flow Rate: 0.00 L/min
ZBOSS: common/zb_debug.c:64 Assertion failed /builds/thread_zigbee/esp-zboss/components/zboss_stack/zboss/zcl/zcl_general_commands.c:612
Zigbee stack assertion failed zcl/zcl_general_commands.c:612

abort() was called at PC 0x42023ec9 on core 0
--- 0x42023ec9: zb_assert at ??:?

Core 0 register dump:
MEPC : 0x40800800 RA : 0x4080606c SP : 0x40815440 GP : 0x4080ca14
--- 0x40800800: panic_abort at C:/Users/guilhem.asset/esp/v5.3.2/esp-idf/components/esp_system/panic.c:463
0x4080606c: __ubsan_include at C:/Users/guilhem.asset/esp/v5.3.2/esp-idf/components/esp_system/ubsan.c:311

TP : 0x408155a0 T0 : 0x37363534 T1 : 0x7271706f T2 : 0x33323130
S0/FP : 0x00000004 S1 : 0x408154a4 A0 : 0x4081546c A1 : 0x408154a2
A2 : 0x00000000 A3 : 0x40815499 A4 : 0x00000001 A5 : 0x40812000
A6 : 0x00000000 A7 : 0x76757473 S2 : 0x0000ffff S3 : 0x00000404
S4 : 0x00000002 S5 : 0x00000000 S6 : 0x00000000 S7 : 0x00000000
S8 : 0x00000000 S9 : 0x00000000 S10 : 0x00000000 S11 : 0x00000000
T3 : 0x6e6d6c6b T4 : 0x6a696867 T5 : 0x66656463 T6 : 0x62613938
MSTATUS : 0x00001881 MTVEC : 0x40800001 MCAUSE : 0x00000007 MTVAL : 0x00000000
--- 0x40800001: _vector_table at C:/Users/guilhem.asset/esp/v5.3.2/esp-idf/components/riscv/vectors_intc.S:54

MHARTID : 0x00000000

Stack memory:
40815440: 0x00000000 0x00000000 0x408154a0 0x4080b006 0x00000000 0x00000000 0x00000002 0x4080d19c
--- 0x4080b006: abort at C:/Users/guilhem.asset/esp/v5.3.2/esp-idf/components/newlib/abort.c:35

40815460: 0x408154a4 0x4080d1b8 0x408154a0 0x726f6261 0x20292874 0x20736177 0x6c6c6163 0x61206465
40815480: 0x43502074 0x34783020 0x33323032 0x20396365 0x63206e6f 0x2065726f 0x00000030 0x42020000
--- 0x42020000: zb_address_unlock_func at ??:?

408154a0: 0xa5a50030 0x32303234 0x39636533 0x00000000 0x0000002f 0x00000264 0x420a897d 0x42023ecc
--- 0x42023ecc: zb_aps_multi_pre_link_key_init at zb_init_common.c.obj:?

408154c0: 0x0000ffff 0x00000000 0x0000000a 0x4204e89e 0x00000000 0x00000000 0x00000000 0x4081553c
--- 0x4204e89e: zb_zcl_get_attr_desc_manuf_a at ??:?

[Guilhem-34]

I don't know if my code have been uploaded because the size of the .zip is too big, but i can just paste my main .c here :

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "nvs_flash.h"
#include "esp_check.h"
#include "esp_log.h"
#include "ha/esp_zigbee_ha_standard.h"
#include "main.h"
#include "string.h"

// Configuration des GPIO
#define FLOW_SENSOR_PIN GPIO_NUM_4 // Modifier selon votre configuration

#if !defined ZB_ED_ROLE
#error Define ZB_ED_ROLE in idf.py menuconfig to compile sensor (End Device) source code.
#endif

static const char *TAG = "ESP_ZB_FLOW_SENSOR";

// Variables globales
volatile uint32_t pulse_count = 0;

// Fonction ISR pour compter les impulsions
void IRAM_ATTR flow_sensor_isr_handler(void *arg) {
pulse_count++;
}

// Fonction pour calculer le débit
float calculate_flow_rate(uint32_t pulses, uint32_t duration_ms) {
// Calcul de la fréquence en Hz
float frequency = (pulses / (float)duration_ms) * 1000.0;
// Conversion en litres/minute (facteur 0.1 pour YF-S201)
float flow_rate = frequency * 0.1;
return flow_rate;
}

#define DEFINE_PSTRING(var, str)
const struct
{
unsigned char len;
char content[sizeof(str)];
}(var) = {sizeof(str) - 1, (str)}

void reportAttribute(uint8_t endpoint, uint16_t clusterID, uint16_t attributeID, void *value, uint8_t value_length)
{
esp_zb_zcl_report_attr_cmd_t cmd = {
.zcl_basic_cmd = {
.dst_addr_u.addr_short = 0x0000,
.dst_endpoint = endpoint,
.src_endpoint = endpoint,
},
.address_mode = ESP_ZB_APS_ADDR_MODE_16_ENDP_PRESENT,
.clusterID = clusterID,
.attributeID = attributeID,
//.cluster_role = ESP_ZB_ZCL_CLUSTER_SERVER_ROLE,
};
esp_zb_zcl_attr_t *value_r = esp_zb_zcl_get_attribute(endpoint, clusterID, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, attributeID);
memcpy(value_r->data_p, value, value_length);
esp_zb_zcl_report_attr_cmd_req(&cmd);
}

void debitmetre_task(void *pvParameters)
{

while (1)
{
    pulse_count = 0; // Réinitialiser le compteur
    vTaskDelay(pdMS_TO_TICKS(1000)); // Mesurer pendant 1 seconde

    // Calculer le débit
    float flow_rate = calculate_flow_rate(pulse_count, 1000); // Durée = 1000 ms
    

    //printf("Débit : %.2f L/min\n", flow_rate);
    ESP_LOGI(TAG, "Reported Flow Rate: %.f L/min", flow_rate);
    reportAttribute(HA_ESP_FLOW_ENDPOINT, ESP_ZB_ZCL_CLUSTER_ID_FLOW_MEASUREMENT,ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_VALUE_ID, &flow_rate, 4);
    // Pause pour la prochaine mesure
    vTaskDelay(pdMS_TO_TICKS(1000));
}

}

static void bdb_start_top_level_commissioning_cb(uint8_t mode_mask)
{
ESP_ERROR_CHECK(esp_zb_bdb_start_top_level_commissioning(mode_mask));
}

static esp_err_t zb_attribute_handler(const esp_zb_zcl_set_attr_value_message_t *message)
{
esp_err_t ret = ESP_OK;
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(0x%x), cluster(0x%x), attribute(0x%x), data size(%d)", message->info.dst_endpoint, message->info.cluster,
message->attribute.id, message->attribute.data.size);
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;
}

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, "Zigbee stack initialized");
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, "Start network steering");
esp_zb_bdb_start_top_level_commissioning(ESP_ZB_BDB_MODE_NETWORK_STEERING);
}
else
{
/ commissioning failed */
ESP_LOGW(TAG, "Failed to initialize Zigbee stack (status: %s)", esp_err_to_name(err_status));
}
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)",
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());
xTaskCreate(debitmetre_task, "debitmetre_task", 4096, NULL, 5, NULL);
}
else
{
ESP_LOGI(TAG, "Network steering was not successful (status: %s)", esp_err_to_name(err_status));
esp_zb_scheduler_alarm((esp_zb_callback_t)bdb_start_top_level_commissioning_cb, ESP_ZB_BDB_MODE_NETWORK_STEERING, 1000);
}
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 void esp_zb_task(void *pvParameters)
{
esp_zb_cfg_t zb_nwk_cfg = ESP_ZB_ZED_CONFIG();
esp_zb_init(&zb_nwk_cfg);

// ------------------------------ Cluster BASIC ------------------------------
esp_zb_basic_cluster_cfg_t basic_cluster_cfg = {
    .zcl_version = ESP_ZB_ZCL_BASIC_ZCL_VERSION_DEFAULT_VALUE,
    .power_source = 0x03,
};
uint32_t ApplicationVersion = 0x0001;
uint32_t StackVersion = 0x0002;
uint32_t HWVersion = 0x0002;
DEFINE_PSTRING(ManufacturerName, "Guilhem");
DEFINE_PSTRING(ModelIdentifier, "ESP32-H2 FLOW");
DEFINE_PSTRING(DateCode, "20250108");
// You can also use the following code to define strings:  {length, 'string'}
// uint8_t ModelIdentifier[] = {13, 'E', 'S', 'P', '3', '2', '-', 'H', '2', ' ', 'D', 'e', 'm', 'o'};

esp_zb_attribute_list_t *esp_zb_basic_cluster = esp_zb_basic_cluster_create(&basic_cluster_cfg);
esp_zb_basic_cluster_add_attr(esp_zb_basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_APPLICATION_VERSION_ID, &ApplicationVersion);
esp_zb_basic_cluster_add_attr(esp_zb_basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_STACK_VERSION_ID, &StackVersion);
esp_zb_basic_cluster_add_attr(esp_zb_basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_HW_VERSION_ID, &HWVersion);
esp_zb_basic_cluster_add_attr(esp_zb_basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID, (void *)&ManufacturerName);
esp_zb_basic_cluster_add_attr(esp_zb_basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MODEL_IDENTIFIER_ID, (void *)&ModelIdentifier);
esp_zb_basic_cluster_add_attr(esp_zb_basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_DATE_CODE_ID, (void *)&DateCode);

// ------------------------------ Cluster IDENTIFY ------------------------------
esp_zb_identify_cluster_cfg_t identify_cluster_cfg = {
    .identify_time = 0,
};
esp_zb_attribute_list_t *esp_zb_identify_cluster = esp_zb_identify_cluster_create(&identify_cluster_cfg);

// ------------------------------ Cluster FLOW ------------------------------
esp_zb_flow_meas_cluster_cfg_t flow_meas_cfg = {
.measured_value = 0xFFFF,
.min_value = -1,
.max_value = 1000,
};
esp_zb_attribute_list_t *esp_zb_flow_meas_cluster = esp_zb_flow_meas_cluster_create(&flow_meas_cfg);

// ------------------------------ Create cluster list ------------------------------
esp_zb_cluster_list_t *esp_zb_cluster_list = esp_zb_zcl_cluster_list_create();
esp_zb_cluster_list_add_basic_cluster(esp_zb_cluster_list, esp_zb_basic_cluster, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
esp_zb_cluster_list_add_identify_cluster(esp_zb_cluster_list, esp_zb_identify_cluster, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
esp_zb_cluster_list_add_flow_meas_cluster(esp_zb_cluster_list, esp_zb_flow_meas_cluster, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);

// ------------------------------ Create endpoint list ------------------------------
esp_zb_ep_list_t *esp_zb_ep_list = esp_zb_ep_list_create();
esp_zb_endpoint_config_t endpoint_config = {
.endpoint = HA_ESP_FLOW_ENDPOINT,
.app_profile_id = ESP_ZB_AF_HA_PROFILE_ID,
.app_device_id = ESP_ZB_HA_SIMPLE_SENSOR_DEVICE_ID ,
};

esp_zb_ep_list_add_ep(esp_zb_ep_list, esp_zb_cluster_list, endpoint_config);

// ------------------------------ Register Device ------------------------------
esp_zb_device_register(esp_zb_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)
{

esp_zb_platform_config_t config = {
.radio_config = ESP_ZB_DEFAULT_RADIO_CONFIG(),
.host_config = ESP_ZB_DEFAULT_HOST_CONFIG(),
};
// Initialize NVS
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
ESP_ERROR_CHECK( nvs_flash_erase() );
ret = nvs_flash_init();
}
ESP_ERROR_CHECK( ret );
//ESP_ERROR_CHECK(nvs_flash_init());
/* load Zigbee light_bulb platform config to initialization /
ESP_ERROR_CHECK(esp_zb_platform_config(&config));
/ hardware related and device init */
xTaskCreate(esp_zb_task, "Zigbee_main", 4096, NULL, 5, NULL);

gpio_set_direction(GPIO_NUM_4, GPIO_MODE_INPUT);

}

[MatAtBread]

I have the same problem. The key is the "ZDO signal: ZDO Config Ready" message.

This indicates the "zb_fct" doesn't contain valid basic zigbee configuration data. I came across this issue whilst searching for a fix. I think there's some kind of python utility for writing this partition data (from the docs....as far as I can read them).

If I find a fix, I'll let you know