feat(zigbee) Add humidity optional cluster + fixes

Author: P-R-O-C-H-Y

libraries/Zigbee/examples/Zigbee_Temperature_Sensor_Sleepy/README.md renamed to libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/README.md

@@ -1,6 +1,6 @@
-# Arduino-ESP32 Zigbee Temperature Sensor Example
+# Arduino-ESP32 Zigbee Temperature and Humidity Sensor Sleepy Device Example
 
-This example shows how to configure the Zigbee end device and use it as a Home Automation (HA) temperature sensor.
+This example demonstrates how to use the Zigbee library to create an end device temperature/humidity sensor and use it as a Home Automation (HA) extended temperature sensor.
 
 # Supported Targets
 
@@ -11,23 +11,19 @@ Currently, this example supports the following targets.
 
 ## Temperature Sensor Functions
 
-Note:
- * This board means the board (e.g. ESP32-H2 / C6) loaded with `Zigbee_Temperature_Sensor` example.
- * The remote board means the board (e.g. ESP32-H2 / C6) loaded with `Zigbee_Thermostat` example.
-
-Functions:
- * After this board first starts up, it would be configured locally to report the temperature on 1 degree change and no periodic reporting to the remote board.
- * By clicking the button (BOOT) on this board, this board will immediately send a report of the current measured temperature to the remote board.
+1. Initialize a Zigbee temperature and humidity sensor.
+2. Measure temperature and humidity values.
+3. Report the measured values to the Zigbee network.
+4. Put the device to sleep to save power.
 
 ## Hardware Required
 
-* One development board (ESP32-H2 or ESP32-C6) acting as Zigbee coordinator (loaded with `Zigbee_Thermostat` example)
+* ESP32-H2 or ESP32-C6 development board
 * A USB cable for power supply and programming
-* Choose another board (ESP32-H2 or ESP32-C6) as Zigbee end device and upload the `Zigbee_Temperature_Sensor` example
 
 ### Configure the Project
 
-In this example, the internal temperature sensor task is reading the chip temperature.
+In this example, to demonstrate the funcionality the chip temperature is used and reported as temperature and humidity.
 Set the Button GPIO by changing the `BUTTON_PIN` definition. By default, it's the pin `9` (BOOT button on ESP32-C6 and ESP32-H2).
 
 #### Using Arduino IDE

libraries/Zigbee/examples/Zigbee_Temperature_Sensor_Sleepy/Zigbee_Temperature_Sensor_Sleepy.ino renamed to libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino

@@ -13,10 +13,10 @@
 // limitations under the License.
 
 /**
- * @brief This example demonstrates Zigbee temperature sensor Sleepy device.
+ * @brief This example demonstrates Zigbee temperature and humidity sensor Sleepy device.
  *
- * The example demonstrates how to use Zigbee library to create a end device temperature sensor.
- * The temperature sensor is a Zigbee end device, which is controlled by a Zigbee coordinator.
+ * The example demonstrates how to use Zigbee library to create an end device temperature and humidity sensor.
+ * The sensor is a Zigbee end device, which is reporting data to the Zigbee network.
  *
  * Proper Zigbee mode must be selected in Tools->Zigbee mode
  * and also the correct partition scheme must be selected in Tools->Partition Scheme.
@@ -32,42 +32,32 @@
 
 #include "ZigbeeCore.h"
 #include "ep/ZigbeeTempSensor.h"
-#include <ctime>
 
 #define BUTTON_PIN                  9  //Boot button for C6/H2
 #define TEMP_SENSOR_ENDPOINT_NUMBER 10
 
 #define uS_TO_S_FACTOR 1000000ULL /* Conversion factor for micro seconds to seconds */
-#define TIME_TO_SLEEP  30         /* Time ESP32 will go to sleep (in seconds) */
+#define TIME_TO_SLEEP  55         /* Sleep for 55s will + 5s delay for establishing connection => data reported every 1 minute */
 
 ZigbeeTempSensor zbTempSensor = ZigbeeTempSensor(TEMP_SENSOR_ENDPOINT_NUMBER);
 
 /************************ Temp sensor *****************************/
 void meausureAndSleep(){
   // Measure temperature sensor value
-  float tsens_value = temperatureRead();
+  float temperature = temperatureRead();
 
-  // Initialize random seed
-  std::srand(static_cast<unsigned int>(std::time(0)));
+  // Use temparture value as humidity value to demonstrate both temperature and humidity
+  float humidity = temperature;
 
-  // Calculate the 1% fluctuation range
-  float fluctuation = tsens_value * 0.01f;
+  // Update temperature and humidity values in Temperature sensor EP
+  zbTempSensor.setTemperature(temperature);
+  zbTempSensor.setHumidity(humidity);
 
-  // Generate a random number between -1% and +1%
-  float randomFactor = (static_cast<float>(std::rand()) / RAND_MAX) * 2.0f - 1.0f;
-
-  // Apply the fluctuation to the original temperature
-  tsens_value = tsens_value + randomFactor * fluctuation;
-
-  // Update temperature value in Temperature sensor EP
-  zbTempSensor.setTemperature(tsens_value);
-
-  // Report temperature value
+  // Report temperature and humidity values
   zbTempSensor.reportTemperature();
+  zbTempSensor.reportHumidity();
 
-  // Set battery percentage to 80% and report it
-  zbTempSensor.setBatteryPercentage(80);
-  zbTempSensor.reportBatteryPercentage();
+  log_d("Temperature: %.2f°C, Humidity: %.2f%", temperature, humidity);
 
   // Put device to deep sleep
   esp_deep_sleep_start();
@@ -78,25 +68,29 @@ void setup() {
   // Init button switch
   pinMode(BUTTON_PIN, INPUT_PULLUP);
 
+  // Configure the wake up source and set to wake up every 5 seconds
+  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
+
   // Optional: set Zigbee device name and model
-  zbTempSensor.setManufacturerAndModel("Espressif", "SleepyZigbeeTempSensor");
+  zbTempSensor.setManufacturerAndModel("Espressif", "SleepyZigbeeTempSensorTest");
 
   // Set minimum and maximum temperature measurement value (10-50°C is default range for chip temperature measurement)
   zbTempSensor.setMinMaxValue(10, 50);
 
   // Set tolerance for temperature measurement in °C (lowest possible value is 0.01°C)
   zbTempSensor.setTolerance(1);
 
-  // Set power source to battery and battery percentage to 100%
+  // Set power source to battery and set battery percentage to measured value (now 100% for demonstration)
+  // The value can be also updated by calling zbTempSensor.setBatteryPercentage(percentage) anytime
   zbTempSensor.setPowerSource(ZB_POWER_SOURCE_BATTERY, 100);
 
+  // Add humidity cluster to the temperature sensor device with min, max and tolerance values
+  zbTempSensor.addHumiditySensor(0,100,1);
+
   // Add endpoint to Zigbee Core
   Zigbee.addEndpoint(&zbTempSensor);
 
-  // Configure the wake up source and set to wake up every 5 seconds
-  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
-
-  // Create a custom Zigbee configuration for End Device
+  // Create a custom Zigbee configuration for End Device with keep alive 10s to avoid interference with reporting data
   esp_zb_cfg_t zigbeeConfig = ZIGBEE_DEFAULT_ED_CONFIG();
   zigbeeConfig.nwk_cfg.zed_cfg.keep_alive = 10000;
 

libraries/Zigbee/examples/Zigbee_Temperature_Sensor_Sleepy/ci.json renamed to libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/ci.json

@@ -6,6 +6,9 @@
 #include "ZigbeeHandlers.cpp"
 #include "Arduino.h"
 
+extern "C" void zb_set_ed_node_descriptor(bool power_src, bool rx_on_when_idle, bool alloc_addr);
+static bool edBatteryPowered = false;
+
 ZigbeeCore::ZigbeeCore() {
   _radio_config.radio_mode = ZB_RADIO_MODE_NATIVE;                   // Use the native 15.4 radio
   _host_config.host_connection_mode = ZB_HOST_CONNECTION_MODE_NONE;  // Disable host connection
@@ -73,6 +76,12 @@ void ZigbeeCore::addEndpoint(ZigbeeEP *ep) {
 static void esp_zb_task(void *pvParameters) {
   /* initialize Zigbee stack */
   ESP_ERROR_CHECK(esp_zb_start(false));
+
+  //NOTE: This is a workaround to make battery powered devices to be discovered as battery powered
+  if(((zigbee_role_t)Zigbee.getRole() == ZIGBEE_END_DEVICE) && edBatteryPowered ) {
+    zb_set_ed_node_descriptor(0,0,0);
+  }
+
   esp_zb_stack_main_loop();
 }
 
@@ -109,6 +118,9 @@ bool ZigbeeCore::zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs) {
     log_i("List of registered Zigbee EPs:");
     for (std::list<ZigbeeEP *>::iterator it = ep_objects.begin(); it != ep_objects.end(); ++it) {
       log_i("Device type: %s, Endpoint: %d, Device ID: 0x%04x", getDeviceTypeString((*it)->_device_id), (*it)->_endpoint, (*it)->_device_id);
+      if((*it)->_power_source == ZB_POWER_SOURCE_BATTERY) {
+        edBatteryPowered = true;
+      }
     }
   }
   // Register Zigbee action handler

libraries/Zigbee/src/ZigbeeCore.cpp

@@ -7,15 +7,27 @@
 #include "esp_zigbee_cluster.h"
 #include "zcl/esp_zigbee_zcl_power_config.h"
 
-uint8_t ZigbeeEP::_endpoint = 0;
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern void zb_set_ed_node_descriptor(bool power_src, bool rx_on_when_idle, bool alloc_addr);
+
+#ifdef __cplusplus
+}
+#endif
+
+// uint8_t ZigbeeEP::_endpoint = 0;
 bool ZigbeeEP::_is_bound = false;
 bool ZigbeeEP::_allow_multiple_binding = false;
 
-extern void zb_set_ed_node_descriptor(bool power_src, bool rx_on_when_idle, bool alloc_addr);
+//TODO: is_bound and allow_multiple_binding to make not static
 
 /* Zigbee End Device Class */
 ZigbeeEP::ZigbeeEP(uint8_t endpoint) {
   _endpoint = endpoint;
+  log_v("Endpoint: %d", _endpoint);
   _ep_config.endpoint = 0;
   _cluster_list = nullptr;
   _on_identify = nullptr;
@@ -69,23 +81,27 @@ void ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) {
   esp_zb_basic_cluster_add_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MODEL_IDENTIFIER_ID, (void *)zb_model);
 }
 
-void ZigbeeEP::setPowerSource(zb_power_source_t power_source, uint8_t percentage) {
+void ZigbeeEP::setPowerSource(zb_power_source_t power_source, uint8_t battery_percentage) {
   esp_zb_attribute_list_t *basic_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_BASIC, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
   esp_zb_cluster_update_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_POWER_SOURCE_ID, (void *)&power_source);
 
   if(power_source == ZB_POWER_SOURCE_BATTERY){
-    //TODO:
-      //UPDATE MAC CAPABILITIES TO SET POWER SOURCE TO BATTERY
-      //currently its not possible to update mac capabilities
-    zb_set_ed_node_descriptor(0,0,0);
     // Add power config cluster and battery percentage attribute
+    battery_percentage = battery_percentage * 2;
     esp_zb_attribute_list_t *power_config_cluster = esp_zb_zcl_attr_list_create(ESP_ZB_ZCL_CLUSTER_ID_POWER_CONFIG);
-    esp_zb_power_config_cluster_add_attr(power_config_cluster, ESP_ZB_ZCL_ATTR_POWER_CONFIG_BATTERY_PERCENTAGE_REMAINING_ID, (void *)&percentage);
+    esp_zb_power_config_cluster_add_attr(power_config_cluster, ESP_ZB_ZCL_ATTR_POWER_CONFIG_BATTERY_PERCENTAGE_REMAINING_ID, (void *)&battery_percentage);
     esp_zb_cluster_list_add_power_config_cluster(_cluster_list, power_config_cluster, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
   }
+  _power_source = power_source;
 }
 
 void ZigbeeEP::setBatteryPercentage(uint8_t percentage) {
+  // 100% = 200 in decimal, 0% = 0
+  // Convert percentage to 0-200 range
+  if (percentage > 100) {
+    percentage = 100;
+  }
+  percentage = percentage * 2;
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_zb_zcl_set_attribute_val(
     _endpoint, ESP_ZB_ZCL_CLUSTER_ID_POWER_CONFIG, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_POWER_CONFIG_BATTERY_PERCENTAGE_REMAINING_ID, &percentage, false

libraries/Zigbee/src/ZigbeeEP.cpp

@@ -114,13 +114,14 @@ class ZigbeeEP {
   void (*_on_identify)(uint16_t time);
 
 protected:
-  static uint8_t _endpoint;
+  uint8_t _endpoint;
   esp_zb_ha_standard_devices_t _device_id;
   esp_zb_endpoint_config_t _ep_config;
   esp_zb_cluster_list_t *_cluster_list;
   static bool _is_bound;
   std::list<zb_device_params_t *> _bound_devices;
   SemaphoreHandle_t lock;
+  zb_power_source_t _power_source;
 
   friend class ZigbeeCore;
 };

libraries/Zigbee/src/ZigbeeEP.h

@@ -57,7 +57,7 @@ void ZigbeeColorDimmerSwitch::findCb(esp_zb_zdp_status_t zdo_status, uint16_t ad
     light->short_addr = addr;
     esp_zb_ieee_address_by_short(light->short_addr, light->ieee_addr);
     esp_zb_get_long_address(bind_req.src_address);
-    bind_req.src_endp = _endpoint;
+    bind_req.src_endp = *((uint8_t*)user_ctx); //_endpoint;
     bind_req.cluster_id = ESP_ZB_ZCL_CLUSTER_ID_ON_OFF;
     bind_req.dst_addr_mode = ESP_ZB_ZDO_BIND_DST_ADDR_MODE_64_BIT_EXTENDED;
     memcpy(bind_req.dst_address_u.addr_long, light->ieee_addr, sizeof(esp_zb_ieee_addr_t));
@@ -88,7 +88,7 @@ void ZigbeeColorDimmerSwitch::findEndpoint(esp_zb_zdo_match_desc_req_param_t *cm
     .num_out_clusters = 3,
     .cluster_list = cluster_list,
   };
-  esp_zb_zdo_match_cluster(&color_dimmable_light_req, findCb, NULL);
+  esp_zb_zdo_match_cluster(&color_dimmable_light_req, findCb, &_endpoint);
 }
 
 // Methods to control the light

libraries/Zigbee/src/ep/ZigbeeColorDimmerSwitch.cpp

@@ -6,7 +6,8 @@ ZigbeeLight::ZigbeeLight(uint8_t endpoint) : ZigbeeEP(endpoint) {
 
   esp_zb_on_off_light_cfg_t light_cfg = ESP_ZB_DEFAULT_ON_OFF_LIGHT_CONFIG();
   _cluster_list = esp_zb_on_off_light_clusters_create(&light_cfg);  // use esp_zb_zcl_cluster_list_create() instead of esp_zb_on_off_light_clusters_create()
-  _ep_config = {.endpoint = _endpoint, .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID, .app_device_id = ESP_ZB_HA_ON_OFF_LIGHT_DEVICE_ID, .app_device_version = 0};
+  _ep_config = {.endpoint = endpoint, .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID, .app_device_id = ESP_ZB_HA_ON_OFF_LIGHT_DEVICE_ID, .app_device_version = 0};
+  log_v("Light endpoint created %d", _endpoint);
 }
 
 //set attribute method -> method overridden in child class

libraries/Zigbee/src/ep/ZigbeeLight.cpp

@@ -35,7 +35,7 @@ void ZigbeeSwitch::findCb(esp_zb_zdp_status_t zdo_status, uint16_t addr, uint8_t
     light->short_addr = addr;
     esp_zb_ieee_address_by_short(light->short_addr, light->ieee_addr);
     esp_zb_get_long_address(bind_req.src_address);
-    bind_req.src_endp = _endpoint;  //_dev_endpoint;
+    bind_req.src_endp = *((uint8_t*)user_ctx); //_endpoint;
     bind_req.cluster_id = ESP_ZB_ZCL_CLUSTER_ID_ON_OFF;
     bind_req.dst_addr_mode = ESP_ZB_ZDO_BIND_DST_ADDR_MODE_64_BIT_EXTENDED;
     memcpy(bind_req.dst_address_u.addr_long, light->ieee_addr, sizeof(esp_zb_ieee_addr_t));
@@ -60,7 +60,7 @@ void ZigbeeSwitch::findEndpoint(esp_zb_zdo_match_desc_req_param_t *cmd_req) {
     .cluster_list = cluster_list,
   };
 
-  esp_zb_zdo_match_cluster(&on_off_req, findCb, NULL);
+  esp_zb_zdo_match_cluster(&on_off_req, findCb, &_endpoint);
 }
 
 // Methods to control the light