feat(zigbee): Add windspeed sensor endpoint

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);
+ }
+

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"
  ]
 }

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

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