Dev Update: Version setting, Thermostat fix, ...

Simplified bounded device print as the structure is common for any EP type
Allowed setting custom app version for EP, default is 0
Small fixes and code updates

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

boards.txt

@@ -24,7 +24,7 @@ Set the Button Switch GPIO by changing the `GPIO_SWITCH` definition. By default,
 To get more information about the Espressif boards see [Espressif Development Kits](https://www.espressif.com/en/products/devkits).
 
 * Before Compile/Verify, select the correct board: `Tools -> Board`.
-* Select the Coordinator Zigbee mode: `Tools -> Zigbee mode: Zigbee ZCZR (coordinator)`.
+* Select the Coordinator Zigbee mode: `Tools -> Zigbee mode: Zigbee ZCZR (coordinator/router)`.
 * Select Partition Scheme for Zigbee: `Tools -> Partition Scheme: Zigbee 4MB with spiffs`.
 * Select the COM port: `Tools -> Port: xxx where the `xxx` is the detected COM port.
 * Optional: Set debug level to info to see logs from Zigbee stack: `Tools -> Core Debug Level: Info`.

libraries/Zigbee/examples/Zigbee_Color_Dimmer_Switch/README.md

@@ -17,14 +17,14 @@ Currently, this example supports the following targets.
 
 ### Configure the Project
 
-Set the Button Switch GPIO by changing the `GPIO_INPUT_IO_TOGGLE_SWITCH` definition. By default, the LED_PIN is `GPIO_NUM_9`.
+Set the Button Switch GPIO by changing the `GPIO_INPUT_IO_TOGGLE_SWITCH` definition. By default, it's the pin `9` (BOOT button on ESP32-C6 and ESP32-H2).
 
 #### Using Arduino IDE
 
 To get more information about the Espressif boards see [Espressif Development Kits](https://www.espressif.com/en/products/devkits).
 
 * Before Compile/Verify, select the correct board: `Tools -> Board`.
-* Select the Coordinator Zigbee mode: `Tools -> Zigbee mode: Zigbee ZCZR (coordinator)`.
+* Select the Coordinator Zigbee mode: `Tools -> Zigbee mode: Zigbee ZCZR (coordinator/router)`.
 * Select Partition Scheme for Zigbee: `Tools -> Partition Scheme: Zigbee 4MB with spiffs`.
 * Select the COM port: `Tools -> Port: xxx where the `xxx` is the detected COM port.
 * Optional: Set debug level to info to see logs from Zigbee stack: `Tools -> Core Debug Level: Info`.

libraries/Zigbee/examples/Zigbee_On_Off_Switch/README.md

@@ -35,7 +35,7 @@ Set the Button GPIO by changing the `BUTTON_PIN` definition. By default, it's th
 To get more information about the Espressif boards see [Espressif Development Kits](https://www.espressif.com/en/products/devkits).
 
 * Before Compile/Verify, select the correct board: `Tools -> Board`.
-* Select the Coordinator Zigbee mode: `Tools -> Zigbee mode: Zigbee ZCZR (coordinator)`.
+* Select the Coordinator Zigbee mode: `Tools -> Zigbee mode: Zigbee ZCZR (coordinator/router)`.
 * Select Partition Scheme for Zigbee: `Tools -> Partition Scheme: Zigbee 4MB with spiffs`.
 * Select the COM port: `Tools -> Port: xxx where the `xxx` is the detected COM port.
 * Optional: Set debug level to info to see logs from Zigbee stack: `Tools -> Core Debug Level: Info`.

libraries/Zigbee/examples/Zigbee_Thermostat/README.md

@@ -93,7 +93,7 @@ void setup() {
   // When all EPs are registered, start Zigbee with ZIGBEE_COORDINATOR mode
   Zigbee.begin(ZIGBEE_COORDINATOR);
 
-  Serial.println("Waiting for Light to bound to the switch");
+  Serial.println("Waiting for Temperature sensor to bound to the switch");
   //Wait for switch to bound to a light:
   while(!zbThermostat.is_bound()) 
   {

libraries/Zigbee/examples/Zigbee_Thermostat/Zigbee_Thermostat.ino

@@ -4,5 +4,6 @@ author=P-R-O-C-H-Y
 maintainer=Jan Procházka <[email protected]>
 sentence=Enables zigbee connection with the ESP32
 paragraph=With this library you can create zigbee end devices, routers, coordinators and connect them to the zigbee network.
+category=Communication
 url=
 architectures=esp32

libraries/Zigbee/library.properties

@@ -244,7 +244,7 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
         esp_zb_zdo_match_desc_req_param_t cmd_req;
         cmd_req.dst_nwk_addr = dev_annce_params->device_short_addr;
         cmd_req.addr_of_interest = dev_annce_params->device_short_addr;
-        log_i("Device capabilities: 0x%02x", dev_annce_params->capability);
+        log_v("Device capabilities: 0x%02x", dev_annce_params->capability);
         /*
             capability: 
             Bit 0 – Alternate PAN Coordinator
@@ -257,8 +257,6 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
             Bit 7 – Reserved
         */
 
-        //TODO: Save the device short address and endpoint to the list ????????
-
         // for each endpoint in the list call the find_endpoint function if not bounded or allowed to bind multiple devices
         for (std::list<Zigbee_EP*>::iterator it = Zigbee.ep_objects.begin(); it != Zigbee.ep_objects.end(); ++it) {
           if (!(*it)->_is_bound || (*it)->_allow_multiple_binding) {
@@ -278,7 +276,7 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
         }
       }
       break;
-    default: log_i("ZDO signal: %s (0x%x), status: %s", esp_zb_zdo_signal_to_string(sig_type), sig_type, esp_err_to_name(err_status)); break;
+    default: log_v("ZDO signal: %s (0x%x), status: %s", esp_zb_zdo_signal_to_string(sig_type), sig_type, esp_err_to_name(err_status)); break;
   }
 }
 
@@ -338,28 +336,6 @@ void Zigbee_Core::scanDelete() {
   _scan_status = ZB_SCAN_FAILED;
 }
 
-// NOTE: Binding functions to not forget
-// void esp_zb_zdo_device_bind_req(esp_zb_zdo_bind_req_param_t *cmd_req, esp_zb_zdo_bind_callback_t user_cb, void *user_ctx)
-// {
-//     uint8_t output = 0;
-//     uint16_t outlen = sizeof(uint8_t);
-
-//     typedef struct {
-//         esp_zb_zdo_bind_req_param_t bind_req;
-//         esp_zb_user_cb_t            bind_usr;
-//     } esp_zb_zdo_bind_req_t;
-
-//     esp_zb_zdo_bind_req_t zdo_data = {
-//         .bind_usr = {
-//             .user_ctx = (uint32_t)user_ctx,
-//             .user_cb = (uint32_t)user_cb,
-//         },
-//     };
-
-//     memcpy(&zdo_data.bind_req, cmd_req, sizeof(esp_zb_zdo_bind_req_param_t));
-//     esp_host_zb_output(ESP_ZNSP_ZDO_BIND_SET, &zdo_data, sizeof(esp_zb_zdo_bind_req_t), &output, &outlen);
-// }
-
 // Function to convert enum value to string
 const char* Zigbee_Core::getDeviceTypeString(esp_zb_ha_standard_devices_t deviceId) {
     switch (deviceId) {
@@ -386,6 +362,7 @@ const char* Zigbee_Core::getDeviceTypeString(esp_zb_ha_standard_devices_t device
         case ESP_ZB_HA_COLOR_DIMMABLE_LIGHT_DEVICE_ID: return "Color Dimmable Light Device";
         case ESP_ZB_HA_DIMMER_SWITCH_DEVICE_ID: return "Dimmer Switch Device";
         case ESP_ZB_HA_COLOR_DIMMER_SWITCH_DEVICE_ID: return "Color Dimmer Switch Device";
+        case ESP_ZB_HA_LIGHT_SENSOR_DEVICE_ID: return "Light Sensor";
         case ESP_ZB_HA_SHADE_DEVICE_ID: return "Shade";
         case ESP_ZB_HA_SHADE_CONTROLLER_DEVICE_ID: return "Shade controller";
         case ESP_ZB_HA_WINDOW_COVERING_DEVICE_ID: return "Window Covering client";

libraries/Zigbee/src/Zigbee_core.cpp

@@ -18,6 +18,10 @@ Zigbee_EP::~Zigbee_EP() {
 
 }
 
+void Zigbee_EP::setVersion(uint8_t version) {
+    _ep_config.app_device_version = version;
+}
+
 void Zigbee_EP::setManufacturerAndModel(const char *name, const char *model) {
     // Convert manufacturer to ZCL string
     size_t length = strlen(name);
@@ -74,6 +78,14 @@ void Zigbee_EP::readManufacturerAndModel(uint8_t endpoint, uint16_t short_addr)
     esp_zb_zcl_read_attr_cmd_req(&read_req);
 }
 
+void Zigbee_EP::printBoundDevices() {
+    log_i("Bound devices:");
+    for(const auto& device : _bound_devices) {
+        log_i("Device on endpoint %d, short address: 0x%x", device->endpoint, device->short_addr);
+        print_ieee_addr(device->ieee_addr);
+    }
+}
+
 void Zigbee_EP::readBasicCluster(uint16_t cluster_id, const esp_zb_zcl_attribute_t *attribute) {
     /* Basic cluster attributes */
     if (attribute->id == ESP_ZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID && attribute->data.type == ESP_ZB_ZCL_ATTR_TYPE_CHAR_STRING && attribute->data.value) {

libraries/Zigbee/src/Zigbee_ep.cpp

@@ -31,6 +31,12 @@ typedef struct zbstring_s {
 } ESP_ZB_PACKED_STRUCT
 zbstring_t;
 
+typedef struct zb_device_params_s {
+  esp_zb_ieee_addr_t ieee_addr;
+  uint8_t endpoint;
+  uint16_t short_addr;
+} zb_device_params_t;
+
 /* Zigbee End Device Class */
 class Zigbee_EP {
   public:
@@ -42,19 +48,23 @@ class Zigbee_EP {
 
     static uint8_t _endpoint;
     esp_zb_ha_standard_devices_t _device_id; //type of device
-    uint8_t _version;
 
     esp_zb_endpoint_config_t _ep_config;
     esp_zb_cluster_list_t *_cluster_list;
+    std::list<zb_device_params_t*> _bound_devices;
+
+    static bool _is_bound;
 
     // Set ep config and cluster list
     void set_ep_config(esp_zb_endpoint_config_t ep_config, esp_zb_cluster_list_t *cluster_list) {
         _ep_config = ep_config;
         _cluster_list = cluster_list;
     }
 
-    static bool _is_bound;
+    void setVersion(uint8_t version);
+
     static bool is_bound() { return _is_bound; }
+    void printBoundDevices();
 
     static bool _allow_multiple_binding;
     static void allowMultipleBinding(bool bind) { _allow_multiple_binding = bind; }
@@ -72,7 +82,4 @@ class Zigbee_EP {
     virtual void readBasicCluster(uint16_t cluster_id, const esp_zb_zcl_attribute_t *attribute); //already implemented
 
     friend class ZigbeeCore;
-
-    // List of Zigbee EP classes 
-    friend class ZigbeeLight;
 };

libraries/Zigbee/src/Zigbee_ep.h

@@ -2,15 +2,14 @@
 
 ZigbeeColorDimmableLight::ZigbeeColorDimmableLight(uint8_t endpoint) : Zigbee_EP(endpoint) {
     _device_id = ESP_ZB_HA_COLOR_DIMMABLE_LIGHT_DEVICE_ID;
-    _version = 0;
 
     esp_zb_color_dimmable_light_cfg_t light_cfg = ESP_ZB_DEFAULT_COLOR_DIMMABLE_LIGHT_CONFIG();
     _cluster_list = esp_zb_color_dimmable_light_clusters_create(&light_cfg);
     _ep_config = {       
         .endpoint = _endpoint,
         .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID,
         .app_device_id = ESP_ZB_HA_COLOR_DIMMABLE_LIGHT_DEVICE_ID,
-        .app_device_version = _version
+        .app_device_version = 0
     };
 }
 

libraries/Zigbee/src/ep/ep_color_dimmable_light.cpp

@@ -5,8 +5,6 @@ ZigbeeColorDimmerSwitch* ZigbeeColorDimmerSwitch::_instance = nullptr;
 
 ZigbeeColorDimmerSwitch::ZigbeeColorDimmerSwitch(uint8_t endpoint) : Zigbee_EP(endpoint) {
     _device_id = ESP_ZB_HA_COLOR_DIMMER_SWITCH_DEVICE_ID;
-    _version = 0;
-
     _instance = this; // Set the static pointer to this instance
 
     esp_zb_color_dimmable_switch_cfg_t switch_cfg = ESP_ZB_DEFAULT_COLOR_DIMMABLE_SWITCH_CONFIG();
@@ -16,7 +14,7 @@ ZigbeeColorDimmerSwitch::ZigbeeColorDimmerSwitch(uint8_t endpoint) : Zigbee_EP(e
         .endpoint = _endpoint,
         .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID,
         .app_device_id = ESP_ZB_HA_COLOR_DIMMER_SWITCH_DEVICE_ID,
-        .app_device_version = _version
+        .app_device_version = 0
     };
 }
 
@@ -42,27 +40,29 @@ void ZigbeeColorDimmerSwitch::bind_cb(esp_zb_zdp_status_t zdo_status, void *user
     if (zdo_status == ESP_ZB_ZDP_STATUS_SUCCESS) {
         log_i("Bound successfully!");
         if (user_ctx) {
-            light_bulb_device_params_t *light = (light_bulb_device_params_t *)user_ctx;
+            zb_device_params_t *light = (zb_device_params_t *)user_ctx;
             //Read manufacturer and model automatically after successful bind
             _instance->readManufacturerAndModel(light->endpoint, light->short_addr);
             log_i("The light originating from address(0x%x) on endpoint(%d)", light->short_addr, light->endpoint);
             //TODO: call user method to notify about the light and pass all the info ????
-            _instance->_bound_lights.push_back(light);
+            _instance->_bound_devices.push_back(light);
         }
         _is_bound = true;
+    } else {
+        log_e("Binding failed!");
     }
 }
 
 void ZigbeeColorDimmerSwitch::find_cb(esp_zb_zdp_status_t zdo_status, uint16_t addr, uint8_t endpoint, void *user_ctx) {
     if (zdo_status == ESP_ZB_ZDP_STATUS_SUCCESS) {
         log_d("Found light endpoint");
         esp_zb_zdo_bind_req_param_t bind_req;
-        light_bulb_device_params_t *light = (light_bulb_device_params_t *)malloc(sizeof(light_bulb_device_params_t));
+        zb_device_params_t *light = (zb_device_params_t *)malloc(sizeof(zb_device_params_t));
         light->endpoint = endpoint;
         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 = _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));
@@ -93,18 +93,9 @@ void ZigbeeColorDimmerSwitch::find_endpoint(esp_zb_zdo_match_desc_req_param_t *c
         .num_out_clusters = 3,
         .cluster_list = cluster_list,
     };
-    //esp_zb_zdo_find_color_dimmable_light(&cmd_req, user_find_cb, NULL);
     esp_zb_zdo_match_cluster(&color_dimmable_light_req, find_cb, NULL);
 }
 
-void ZigbeeColorDimmerSwitch::printBoundLights() {
-    log_i("Bound lights:");
-    for(const auto& light : _bound_lights) {
-        log_i("Light on endpoint %d, short address: 0x%x", light->endpoint, light->short_addr);
-        print_ieee_addr(light->ieee_addr);
-    }
-}
-
 // Methods to control the light
 void ZigbeeColorDimmerSwitch::lightToggle() {
     if (_is_bound) {

libraries/Zigbee/src/ep/ep_color_dimmer_switch.cpp

@@ -5,12 +5,6 @@
 #include "Zigbee_ep.h"
 #include "ha/esp_zigbee_ha_standard.h"
 
-typedef struct light_bulb_device_params_s {
-    esp_zb_ieee_addr_t ieee_addr;
-    uint8_t  endpoint;
-    uint16_t short_addr;
-} light_bulb_device_params_t;
-
 class ZigbeeColorDimmerSwitch : public Zigbee_EP {
   public:
     ZigbeeColorDimmerSwitch(uint8_t endpoint);
@@ -19,10 +13,6 @@ class ZigbeeColorDimmerSwitch : public Zigbee_EP {
     // save instance of the class in order to use it in static functions
     static ZigbeeColorDimmerSwitch* _instance;
 
-    // list of bounded lights
-    std::list<light_bulb_device_params_t*> _bound_lights;
-    void printBoundLights();
-
     void calculateXY(uint8_t red, uint8_t green, uint8_t blue, uint16_t &x, uint16_t &y);
 
     // methods to control the color dimmable light
@@ -64,14 +54,3 @@ class ZigbeeColorDimmerSwitch : public Zigbee_EP {
     static void find_cb(esp_zb_zdp_status_t zdo_status, uint16_t addr, uint8_t endpoint, void *user_ctx);
 
 };
-
-//NOTE:
-/* ON/OFF switch commands for light control */
-// typedef enum {
-//     ESP_ZB_ZCL_CMD_ON_OFF_OFF_ID                         = 0x00, /*!< "Turn off" command. */
-//     ESP_ZB_ZCL_CMD_ON_OFF_ON_ID                          = 0x01, /*!< "Turn on" command. */
-//     ESP_ZB_ZCL_CMD_ON_OFF_TOGGLE_ID                      = 0x02, /*!< "Toggle state" command. */
-//     ESP_ZB_ZCL_CMD_ON_OFF_OFF_WITH_EFFECT_ID             = 0x40, /*!< "Off with effect" command. */
-//     ESP_ZB_ZCL_CMD_ON_OFF_ON_WITH_RECALL_GLOBAL_SCENE_ID = 0x41, /*!< "On with recall global scene" command. */
-//     ESP_ZB_ZCL_CMD_ON_OFF_ON_WITH_TIMED_OFF_ID           = 0x42, /*!< "On with timed off" command. */
-// } esp_zb_zcl_on_off_cmd_id_t;

libraries/Zigbee/src/ep/ep_color_dimmer_switch.h

@@ -2,15 +2,14 @@
 
 ZigbeeLight::ZigbeeLight(uint8_t endpoint) : Zigbee_EP(endpoint) {
     _device_id = ESP_ZB_HA_ON_OFF_LIGHT_DEVICE_ID;
-    _version = 0;
 
     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 = _version
+        .app_device_version = 0
     };
 }