feat(zigbee): Add windspeed sensor endpoint

P-R-O-C-H-Y · web-flow · commit 5dc5f7fd86f8 · 2025-03-11T11:21:42.000+01:00
diff --git a/libraries/Zigbee/examples/Zigbee_Wind_Speed_Sensor/Zigbee_Wind_Speed_Sensor.ino b/libraries/Zigbee/examples/Zigbee_Wind_Speed_Sensor/Zigbee_Wind_Speed_Sensor.ino
@@ -26,83 +26,96 @@
  * Created by Jan Procházka (https://github.com/P-R-O-C-H-Y/)
  */
 
-#ifndef ZIGBEE_MODE_ED
-#error "Zigbee coordinator mode is not selected in Tools->Zigbee mode"
-#endif
-
-#include "ZigbeeCore.h"
-#include "ep/ZigbeeWindSpeedSensor.h"
-
-#define BUTTON_PIN                  9  //Boot button for C6/H2
-#define WIND_SPEED_SENSOR_ENDPOINT_NUMBER 10
-
-ZigbeeWindSpeedSensor zbWindSpeedSensor = ZigbeeWindSpeedSensor(WIND_SPEED_SENSOR_ENDPOINT_NUMBER);
-
-/************************ WindSpeed sensor *****************************/
-static void windspeed_sensor_value_update(void *arg) {
-  for (;;) {
-    // Read wind speed sensor value
-    // float wssens_value = windspeedRead();
-    float wssens_value = 5.2;
-    log_v("Wind speed sensor value: %.2fm/s", wssens_value);
-    // Update windspeed value in Windspeed sensor EP
-    zbWindSpeedSensor.setWindSpeed(wssens_value);
-    delay(1000);
-  }
-}
-
-/********************* Arduino functions **************************/
-void setup() {
-
-  Serial.begin(115200);
-  while (!Serial) {
-    delay(10);
-  }
-
-  // Init button switch
-  pinMode(BUTTON_PIN, INPUT);
-
-  // Optional: set Zigbee device name and model
-  zbWindSpeedSensor.setManufacturerAndModel("Espressif", "ZigbeeWindSpeedSensor");
-
-  // Set minimum and maximum windspeed measurement value (10-50°C is default range for chip windspeed measurement)
-  zbWindSpeedSensor.setMinMaxValue(10, 50);
-
-  // Set tolerance for windspeed measurement in °C (lowest possible value is 0.01°C)
-  zbWindSpeedSensor.setTolerance(1);
-
-  // Add endpoint to Zigbee Core
-  Zigbee.addEndpoint(&zbWindSpeedSensor);
-
-  // When all EPs are registered, start Zigbee in End Device mode
-  Zigbee.begin();
-
-  // Start Wind speed sensor reading task
-  xTaskCreate(windspeed_sensor_value_update, "wind_speed_sensor_update", 2048, NULL, 10, NULL);
-
-  // Set reporting interval for windspeed measurement in seconds, must be called after Zigbee.begin()
-  // min_interval and max_interval in seconds, delta (WindSpeed change in °C)
-  // if min = 1 and max = 0, reporting is sent only when windspeed changes by delta
-  // if min = 0 and max = 10, reporting is sent every 10 seconds or windspeed changes by delta
-  // if min = 0, max = 10 and delta = 0, reporting is sent every 10 seconds regardless of windspeed change
-  zbWindSpeedSensor.setReporting(1, 0, 1);
-}
-
-void loop() {
-  // Checking button for factory reset
-  if (digitalRead(BUTTON_PIN) == LOW) {  // Push button pressed
-    // Key debounce handling
-    delay(100);
-    int startTime = millis();
-    while (digitalRead(BUTTON_PIN) == LOW) {
-      delay(50);
-      if ((millis() - startTime) > 3000) {
-        // If key pressed for more than 3secs, factory reset Zigbee and reboot
-        Serial.printf("Resetting Zigbee to factory settings, reboot.\n");
-        Zigbee.factoryReset();
-      }
-    }
-    zbWindSpeedSensor.reportWindSpeed();
-  }
-  delay(100);
-}
+ #ifndef ZIGBEE_MODE_ED
+ #error "Zigbee coordinator mode is not selected in Tools->Zigbee mode"
+ #endif
+ 
+ #include "ZigbeeCore.h"
+ #include "ep/ZigbeeWindSpeedSensor.h"
+ 
+ #define BUTTON_PIN                  9  //Boot button for C6/H2
+ #define WIND_SPEED_SENSOR_ENDPOINT_NUMBER 10
+ 
+ ZigbeeWindSpeedSensor zbWindSpeedSensor = ZigbeeWindSpeedSensor(WIND_SPEED_SENSOR_ENDPOINT_NUMBER);
+ 
+ /************************ WindSpeed sensor *****************************/
+ static void windspeed_sensor_value_update(void *arg) {
+   for (;;) {
+     // Read wind speed sensor value (simulated now by temperature sensor)
+     float windspeed = temperatureRead();
+     log_v("Wind speed sensor value: %.2fm/s", windspeed);
+     // Update windspeed value in Windspeed sensor EP
+     zbWindSpeedSensor.setWindSpeed(windspeed);
+     delay(1000);
+   }
+ }
+ 
+ /********************* Arduino functions **************************/
+ void setup() {
+   Serial.begin(115200);
+   while (!Serial) {
+     delay(10);
+   }
+ 
+   // Init button switch
+   pinMode(BUTTON_PIN, INPUT);
+ 
+   // Optional: set Zigbee device name and model
+   zbWindSpeedSensor.setManufacturerAndModel("Espressif", "ZigbeeWindSpeedSensor");
+ 
+   // Set minimum and maximum windspeed measurement value in m/s
+   zbWindSpeedSensor.setMinMaxValue(0, 50);
+ 
+   // Set tolerance for windspeed measurement in m/s (lowest possible value is 0.01 m/s)
+   zbWindSpeedSensor.setTolerance(1);
+ 
+   // Add endpoint to Zigbee Core
+   Zigbee.addEndpoint(&zbWindSpeedSensor);
+ 
+   Serial.println("Starting Zigbee...");
+   // When all EPs are registered, start Zigbee in End Device mode
+   if (!Zigbee.begin()) {
+     Serial.println("Zigbee failed to start!");
+     Serial.println("Rebooting...");
+     ESP.restart();
+   } else {
+     Serial.println("Zigbee started successfully!");
+   }
+   Serial.println("Connecting to network");
+   while (!Zigbee.connected()) {
+     Serial.print(".");
+     delay(100);
+   }
+   Serial.println();
+ 
+   // Start Wind speed sensor reading task
+   xTaskCreate(windspeed_sensor_value_update, "wind_speed_sensor_update", 2048, NULL, 10, NULL);
+ 
+   // Set reporting interval for windspeed measurement in seconds, must be called after Zigbee.begin()
+   // min_interval and max_interval in seconds, delta (WindSpeed change in m/s)
+   // if min = 1 and max = 0, reporting is sent only when windspeed changes by delta
+   // if min = 0 and max = 10, reporting is sent every 10 seconds or windspeed changes by delta
+   // if min = 0, max = 10 and delta = 0, reporting is sent every 10 seconds regardless of windspeed change
+   zbWindSpeedSensor.setReporting(1, 0, 1);
+ }
+ 
+ void loop() {
+   // Checking button for factory reset
+   if (digitalRead(BUTTON_PIN) == LOW) {  // Push button pressed
+     // Key debounce handling
+     delay(100);
+     int startTime = millis();
+     while (digitalRead(BUTTON_PIN) == LOW) {
+       delay(50);
+       if ((millis() - startTime) > 3000) {
+         // If key pressed for more than 3secs, factory reset Zigbee and reboot
+         Serial.println("Resetting Zigbee to factory and rebooting in 1s.");
+         delay(1000);
+         Zigbee.factoryReset();
+       }
+     }
+     zbWindSpeedSensor.reportWindSpeed();
+   }
+   delay(100);
+ }
+ 
diff --git a/libraries/Zigbee/examples/Zigbee_Wind_Speed_Sensor/ci.json b/libraries/Zigbee/examples/Zigbee_Wind_Speed_Sensor/ci.json
@@ -1,6 +1,7 @@
 {
   "fqbn_append": "PartitionScheme=zigbee,ZigbeeMode=ed",
   "requires": [
-    "CONFIG_SOC_IEEE802154_SUPPORTED=y"
+    "CONFIG_SOC_IEEE802154_SUPPORTED=y",
+    "CONFIG_ZB_ENABLED=y"
   ]
 }
diff --git a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp
@@ -1,33 +1,36 @@
 #include "ZigbeeWindSpeedSensor.h"
-#if SOC_IEEE802154_SUPPORTED
+#if CONFIG_ZB_ENABLED
+
+esp_zb_cluster_list_t *zigbee_wind_speed_sensor_clusters_create(zigbee_wind_speed_sensor_cfg_t *wind_speed_sensor) {
+  esp_zb_basic_cluster_cfg_t *basic_cfg = wind_speed_sensor ? &(wind_speed_sensor->basic_cfg) : NULL;
+  esp_zb_identify_cluster_cfg_t *identify_cfg = wind_speed_sensor ? &(wind_speed_sensor->identify_cfg) : NULL;
+  esp_zb_wind_speed_measurement_cluster_cfg_t *wind_speed_cfg = wind_speed_sensor ? &(wind_speed_sensor->wind_speed_meas_cfg) : NULL;
+  esp_zb_cluster_list_t *cluster_list = esp_zb_zcl_cluster_list_create();
+  esp_zb_cluster_list_add_basic_cluster(cluster_list, esp_zb_basic_cluster_create(basic_cfg), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
+  esp_zb_cluster_list_add_identify_cluster(cluster_list, esp_zb_identify_cluster_create(identify_cfg), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
+  esp_zb_cluster_list_add_wind_speed_measurement_cluster(cluster_list, esp_zb_wind_speed_measurement_cluster_create(wind_speed_cfg), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
+  return cluster_list;
+}
 
 // There is no device_id for wind speed sensor, we use a generic one
 ZigbeeWindSpeedSensor::ZigbeeWindSpeedSensor(uint8_t endpoint) : ZigbeeEP(endpoint) {
   _device_id = ESP_ZB_HA_SIMPLE_SENSOR_DEVICE_ID;
 
-  esp_zb_windspeed_sensor_cfg_t windspeed_sensor_cfg = ESP_ZB_DEFAULT_TEMPERATURE_SENSOR_CONFIG();
-  _cluster_list = esp_zb_windspeed_sensor_clusters_create(&windspeed_sensor_cfg);
+  zigbee_wind_speed_sensor_cfg_t windspeed_sensor_cfg = ZIGBEE_DEFAULT_WIND_SPEED_SENSOR_CONFIG();
+  _cluster_list = zigbee_wind_speed_sensor_clusters_create(&windspeed_sensor_cfg);
 
   _ep_config = {
     .endpoint = _endpoint, .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID, .app_device_id = ESP_ZB_HA_SIMPLE_SENSOR_DEVICE_ID, .app_device_version = 0
   };
 }
 
-static int16_t zb_windspeed_to_s16(float windspeed) {
-  return (int16_t)(windspeed * 100);
+static uint16_t zb_windspeed_to_u16(float windspeed) {
+  return (uint16_t)(windspeed * 100);
 }
 
-/** @brief Wind_Speed_Measurement cluster server attribute identifiers
-typedef enum {
-    ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MEASURED_VALUE_ID     = 0x0000, < MeasuredValue Attribute
-    ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE_ID = 0x0001, < MinMeasuredValue Attribute
-    ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE_ID = 0x0002, < MaxMeasuredValue Attribute 
-    ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_TOLERANCE_ID          = 0x0003, < Tolerance Attribute 
-} esp_zb_zcl_wind_speed_measurement_srv_attr_t;
-*/
 void ZigbeeWindSpeedSensor::setMinMaxValue(float min, float max) {
-  int16_t zb_min = zb_windspeed_to_s16(min);
-  int16_t zb_max = zb_windspeed_to_s16(max);
+  uint16_t zb_min = zb_windspeed_to_u16(min);
+  uint16_t zb_max = zb_windspeed_to_u16(max);
   esp_zb_attribute_list_t *windspeed_measure_cluster =
     esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
   // 
@@ -37,44 +40,34 @@ void ZigbeeWindSpeedSensor::setMinMaxValue(float min, float max) {
 
 void ZigbeeWindSpeedSensor::setTolerance(float tolerance) {
   // Convert tolerance to ZCL uint16_t
-  uint16_t zb_tolerance = (uint16_t)(tolerance * 100);
+  uint16_t zb_tolerance = zb_windspeed_to_u16(tolerance);
   esp_zb_attribute_list_t *windspeed_measure_cluster =
     esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
-  esp_zb_windspeed_meas_cluster_add_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance);
+  esp_zb_wind_speed_measurement_cluster_add_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance);
 }
 
 void ZigbeeWindSpeedSensor::setReporting(uint16_t min_interval, uint16_t max_interval, float delta) {
-  esp_zb_zcl_reporting_info_t reporting_info = {
-    .direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_SRV,
-    .ep = _endpoint,
-    .cluster_id = ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT,
-    .cluster_role = ESP_ZB_ZCL_CLUSTER_SERVER_ROLE,
-    .attr_id = ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MEASURED_VALUE_ID,
-    .u =
-      {
-        .send_info =
-          {
-            .min_interval = min_interval,
-            .max_interval = max_interval,
-            .delta =
-              {
-                .u16 = (uint16_t)(delta * 100),  // Convert delta to ZCL uint16_t
-              },
-            .def_min_interval = min_interval,
-            .def_max_interval = max_interval,
-          },
-      },
-    .dst =
-      {
-        .profile_id = ESP_ZB_AF_HA_PROFILE_ID,
-      },
-    .manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC,
-  };
+  esp_zb_zcl_reporting_info_t reporting_info;
+  memset(&reporting_info, 0, sizeof(esp_zb_zcl_reporting_info_t));
+  reporting_info.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_SRV;
+  reporting_info.ep = _endpoint;
+  reporting_info.cluster_id = ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT;
+  reporting_info.cluster_role = ESP_ZB_ZCL_CLUSTER_SERVER_ROLE;
+  reporting_info.attr_id = ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MEASURED_VALUE_ID;
+  reporting_info.u.send_info.min_interval = min_interval;
+  reporting_info.u.send_info.max_interval = max_interval;
+  reporting_info.u.send_info.def_min_interval = min_interval;
+  reporting_info.u.send_info.def_max_interval = max_interval;
+  reporting_info.u.send_info.delta.u16 = (uint16_t)(delta * 100);  // Convert delta to ZCL uint16_t
+  reporting_info.dst.profile_id = ESP_ZB_AF_HA_PROFILE_ID;
+  reporting_info.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC;
+  esp_zb_lock_acquire(portMAX_DELAY);
   esp_zb_zcl_update_reporting_info(&reporting_info);
+  esp_zb_lock_release();
 }
 
 void ZigbeeWindSpeedSensor::setWindSpeed(float windspeed) {
-  int16_t zb_windspeed = zb_windspeed_to_s16(windspeed);
+  uint16_t zb_windspeed = zb_windspeed_to_u16(windspeed);
   log_v("Updating windspeed sensor value...");
   /* Update windspeed sensor measured value */
   log_d("Setting windspeed to %d", zb_windspeed);
@@ -90,14 +83,15 @@ void ZigbeeWindSpeedSensor::reportWindSpeed() {
   esp_zb_zcl_report_attr_cmd_t report_attr_cmd;
   report_attr_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT;
   report_attr_cmd.attributeID = ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MEASURED_VALUE_ID;
-  report_attr_cmd.cluster_role = ESP_ZB_ZCL_CLUSTER_SERVER_ROLE;
+  report_attr_cmd.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_CLI;
   report_attr_cmd.clusterID = ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT;
   report_attr_cmd.zcl_basic_cmd.src_endpoint = _endpoint;
+  report_attr_cmd.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC;
 
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
   esp_zb_lock_release();
-  log_v("Temperature report sent");
+  log_v("Wind speed measurement report sent");
 }
 
-#endif  //SOC_IEEE802154_SUPPORTED
+#endif  //CONFIG_ZB_ENABLED
diff --git a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.h b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.h
@@ -3,17 +3,42 @@
 #pragma once
 
 #include "soc/soc_caps.h"
-#if SOC_IEEE802154_SUPPORTED
+#if CONFIG_ZB_ENABLED
 
 #include "ZigbeeEP.h"
 #include "ha/esp_zigbee_ha_standard.h"
 
+#define ZIGBEE_DEFAULT_WIND_SPEED_SENSOR_CONFIG()                                                     \
+     {                                                                                                \
+         .basic_cfg =                                                                                 \
+             {                                                                                        \
+                 .zcl_version = ESP_ZB_ZCL_BASIC_ZCL_VERSION_DEFAULT_VALUE,                           \
+                 .power_source = ESP_ZB_ZCL_BASIC_POWER_SOURCE_DEFAULT_VALUE,                         \
+             },                                                                                       \
+         .identify_cfg =                                                                              \
+             {                                                                                        \
+                 .identify_time = ESP_ZB_ZCL_IDENTIFY_IDENTIFY_TIME_DEFAULT_VALUE,                    \
+             },                                                                                       \
+         .wind_speed_meas_cfg =                                                                       \
+             {                                                                                        \
+                 .measured_value = ESP_ZB_ZCL_WIND_SPEED_MEASUREMENT_MEASURED_VALUE_DEFAULT,          \
+                 .min_measured_value = ESP_ZB_ZCL_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE_DEFAULT,  \
+                 .max_measured_value = ESP_ZB_ZCL_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE_DEFAULT,  \
+             },                                                                                       \
+     }
+
+typedef struct zigbee_wind_speed_sensor_cfg_s {
+  esp_zb_basic_cluster_cfg_t basic_cfg;                /*!<  Basic cluster configuration, @ref esp_zb_basic_cluster_cfg_s */
+  esp_zb_identify_cluster_cfg_t identify_cfg;          /*!<  Identify cluster configuration, @ref esp_zb_identify_cluster_cfg_s */
+  esp_zb_wind_speed_measurement_cluster_cfg_t wind_speed_meas_cfg; /*!<  Wind speed measurement cluster configuration, @ref esp_zb_wind_speed_measurement_cluster_cfg_s */
+} zigbee_wind_speed_sensor_cfg_t;
+
 class ZigbeeWindSpeedSensor : public ZigbeeEP {
 public:
   ZigbeeWindSpeedSensor(uint8_t endpoint);
-  ~ZigbeeWindSpeedSensor();
+  ~ZigbeeWindSpeedSensor() {}
 
-  // Set the WindSpeed value in 0,01°C
+  // Set the WindSpeed value in 0,01 m/s
   void setWindSpeed(float value);
 
   // Set the min and max value for the WindSpeed sensor
@@ -27,4 +52,4 @@ class ZigbeeWindSpeedSensor : public ZigbeeEP {
   void reportWindSpeed();
 };
 
-#endif  //SOC_IEEE802154_SUPPORTED
+#endif  //CONFIG_ZB_ENABLED

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"fqbn_append": "PartitionScheme=zigbee,ZigbeeMode=ed",`
`3`	`3`	`"requires": [`
`4`		`- "CONFIG_SOC_IEEE802154_SUPPORTED=y"`
	`4`	`+ "CONFIG_SOC_IEEE802154_SUPPORTED=y",`
	`5`	`+ "CONFIG_ZB_ENABLED=y"`
`5`	`6`	`]`
`6`	`7`	`}`