feat(zigbee): Recall bound devices after reboot

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

libraries/Zigbee/examples/Zigbee_On_Off_Switch/Zigbee_On_Off_Switch.ino

@@ -147,8 +147,8 @@ void setup() {
       "IEEE Address: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n", device->ieee_addr[0], device->ieee_addr[1], device->ieee_addr[2], device->ieee_addr[3],
       device->ieee_addr[4], device->ieee_addr[5], device->ieee_addr[6], device->ieee_addr[7]
     );
-    Serial.printf("Light manufacturer: %s", zbSwitch.readManufacturer(device->endpoint, device->short_addr));
-    Serial.printf("Light model: %s", zbSwitch.readModel(device->endpoint, device->short_addr));
+    Serial.printf("Light manufacturer: %s", zbSwitch.readManufacturer(device->endpoint, device->short_addr, device->ieee_addr));
+    Serial.printf("Light model: %s", zbSwitch.readModel(device->endpoint, device->short_addr, device->ieee_addr));
   }
 
   Serial.println();

libraries/Zigbee/src/ZigbeeCore.cpp

@@ -243,6 +243,7 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
           } else {
             Zigbee._connected = true;
           }
+          Zigbee.searchBindings();
         }
       } else {
         /* commissioning failed */
@@ -309,8 +310,7 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
             Bit 6 – Security capability
             Bit 7 – Reserved
         */
-
-        // for each endpoint in the list call the findEndpoint function if not bounded or allowed to bind multiple devices
+        // for each endpoint in the list call the findEndpoint function if not bounded or allowed to bind multiple devices        
         for (std::list<ZigbeeEP *>::iterator it = Zigbee.ep_objects.begin(); it != Zigbee.ep_objects.end(); ++it) {
           if (!(*it)->bound() || (*it)->epAllowMultipleBinding()) {
             (*it)->findEndpoint(&cmd_req);
@@ -391,6 +391,72 @@ void ZigbeeCore::scanDelete() {
   _scan_status = ZB_SCAN_FAILED;
 }
 
+// Recall bounded devices from the binding table after reboot
+void ZigbeeCore::bindingTableCb(const esp_zb_zdo_binding_table_info_t *table_info, void *user_ctx)
+{
+  bool done = true;
+  esp_zb_zdo_mgmt_bind_param_t *req = (esp_zb_zdo_mgmt_bind_param_t *)user_ctx;
+  esp_zb_zdp_status_t zdo_status = (esp_zb_zdp_status_t)table_info->status;
+  log_d("Binding table callback for address 0x%04x with status %d", req->dst_addr, zdo_status);
+  if (zdo_status == ESP_ZB_ZDP_STATUS_SUCCESS) {
+    // Print binding table log simple
+    log_d("Binding table info: total %d, index %d, count %d", table_info->total, table_info->index, table_info->count);
+
+    if(table_info->total == 0) {
+      log_d("No binding table entries found");
+      free(req);
+      return;
+    }
+
+    // Create a new device object and fill it with the binding table info
+    zb_device_params_t *device = (zb_device_params_t *)malloc(sizeof(zb_device_params_t));
+    device->endpoint = table_info->record->dst_endp;
+    
+    //log all tableinfo record
+    log_d("Binding table record: src_endp %d, dst_endp %d, cluster_id 0x%04x, dst_addr_mode %d", table_info->record->src_endp, table_info->record->dst_endp, table_info->record->cluster_id, table_info->record->dst_addr_mode);
+    log_d("Short address: 0x%04x", table_info->record->dst_address.addr_short);
+    log_d("ieee_address: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", table_info->record->dst_address.addr_long[7], table_info->record->dst_address.addr_long[6], table_info->record->dst_address.addr_long[5], table_info->record->dst_address.addr_long[4], table_info->record->dst_address.addr_long[3], table_info->record->dst_address.addr_long[2], table_info->record->dst_address.addr_long[1], table_info->record->dst_address.addr_long[0]); 
+
+    if(table_info->record->dst_addr_mode == ESP_ZB_APS_ADDR_MODE_16_ENDP_PRESENT ) {
+      device->short_addr = table_info->record->dst_address.addr_short;
+    } else { //ESP_ZB_APS_ADDR_MODE_64_ENDP_PRESENT
+      memcpy(device->ieee_addr, table_info->record->dst_address.addr_long, sizeof(esp_zb_ieee_addr_t));
+    }
+    
+    log_d("Bound device: endpoint %d, short address 0x%04x to endpoint %d", table_info->record->dst_endp, table_info->record->dst_address.addr_short, table_info->record->src_endp);
+    
+    // Add to list of bound devices of proper endpoint
+    for (std::list<ZigbeeEP *>::iterator it = Zigbee.ep_objects.begin(); it != Zigbee.ep_objects.end(); ++it) {
+      if ((*it)->getEndpoint() == table_info->record->src_endp) {
+        (*it)->addBoundDevice(device);
+      }
+    }
+
+    // Continue reading the binding table
+    if (table_info->index + table_info->count < table_info->total) {
+      /* There are unreported binding table entries, request for them. */
+      req->start_index = table_info->index + table_info->count;
+      esp_zb_zdo_binding_table_req(req, bindingTableCb, req);
+      done = false;
+  }
+  }
+
+  if (done) {
+    // Print bound devices
+    log_d("Filling bounded devices finished");
+    free(req);
+  }
+}
+
+
+void ZigbeeCore::searchBindings(){
+  esp_zb_zdo_mgmt_bind_param_t *mb_req = (esp_zb_zdo_mgmt_bind_param_t *)malloc(sizeof(esp_zb_zdo_mgmt_bind_param_t));
+  mb_req->dst_addr = esp_zb_get_short_address();
+  mb_req->start_index = 0;
+  log_d("Requesting binding table for address 0x%04x", mb_req->dst_addr);
+  esp_zb_zdo_binding_table_req(mb_req, bindingTableCb, (void *)mb_req);
+}
+
 // Function to convert enum value to string
 const char *ZigbeeCore::getDeviceTypeString(esp_zb_ha_standard_devices_t deviceId) {
   switch (deviceId) {

libraries/Zigbee/src/ZigbeeCore.h

@@ -80,6 +80,8 @@ class ZigbeeCore {
   bool zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs);
   static void scanCompleteCallback(esp_zb_zdp_status_t zdo_status, uint8_t count, esp_zb_network_descriptor_t *nwk_descriptor);
   const char *getDeviceTypeString(esp_zb_ha_standard_devices_t deviceId);
+  void searchBindings();
+  static void bindingTableCb(const esp_zb_zdo_binding_table_info_t *table_info, void *user_ctx);
 
 public:
   ZigbeeCore();

libraries/Zigbee/src/ZigbeeEP.cpp

@@ -112,13 +112,20 @@ void ZigbeeEP::reportBatteryPercentage() {
   log_v("Battery percentage reported");
 }
 
-char *ZigbeeEP::readManufacturer(uint8_t endpoint, uint16_t short_addr) {
+char *ZigbeeEP::readManufacturer(uint8_t endpoint, uint16_t short_addr, esp_zb_ieee_addr_t ieee_addr) {
   /* Read peer Manufacture Name & Model Identifier */
   esp_zb_zcl_read_attr_cmd_t read_req;
-  read_req.address_mode = ESP_ZB_APS_ADDR_MODE_16_ENDP_PRESENT;
+
+  if(short_addr != 0){
+    read_req.address_mode = ESP_ZB_APS_ADDR_MODE_16_ENDP_PRESENT;
+    read_req.zcl_basic_cmd.dst_addr_u.addr_short = short_addr;
+  } else {
+    read_req.address_mode = ESP_ZB_APS_ADDR_MODE_64_ENDP_PRESENT;
+    memcpy(read_req.zcl_basic_cmd.dst_addr_u.addr_long, ieee_addr, sizeof(esp_zb_ieee_addr_t));
+  }
+
   read_req.zcl_basic_cmd.src_endpoint = _endpoint;
   read_req.zcl_basic_cmd.dst_endpoint = endpoint;
-  read_req.zcl_basic_cmd.dst_addr_u.addr_short = short_addr;
   read_req.clusterID = ESP_ZB_ZCL_CLUSTER_ID_BASIC;
 
   uint16_t attributes[] = {
@@ -139,13 +146,20 @@ char *ZigbeeEP::readManufacturer(uint8_t endpoint, uint16_t short_addr) {
   return _read_manufacturer;
 }
 
-char *ZigbeeEP::readModel(uint8_t endpoint, uint16_t short_addr) {
+char *ZigbeeEP::readModel(uint8_t endpoint, uint16_t short_addr, esp_zb_ieee_addr_t ieee_addr) {
   /* Read peer Manufacture Name & Model Identifier */
   esp_zb_zcl_read_attr_cmd_t read_req;
-  read_req.address_mode = ESP_ZB_APS_ADDR_MODE_16_ENDP_PRESENT;
+
+  if(short_addr != 0){
+    read_req.address_mode = ESP_ZB_APS_ADDR_MODE_16_ENDP_PRESENT;
+    read_req.zcl_basic_cmd.dst_addr_u.addr_short = short_addr;
+  } else {
+    read_req.address_mode = ESP_ZB_APS_ADDR_MODE_64_ENDP_PRESENT;
+    memcpy(read_req.zcl_basic_cmd.dst_addr_u.addr_long, ieee_addr, sizeof(esp_zb_ieee_addr_t));
+  }
+
   read_req.zcl_basic_cmd.src_endpoint = _endpoint;
   read_req.zcl_basic_cmd.dst_endpoint = endpoint;
-  read_req.zcl_basic_cmd.dst_addr_u.addr_short = short_addr;
   read_req.clusterID = ESP_ZB_ZCL_CLUSTER_ID_BASIC;
 
   uint16_t attributes[] = {

libraries/Zigbee/src/ZigbeeEP.h

@@ -87,8 +87,8 @@ class ZigbeeEP {
   void reportBatteryPercentage();
 
   // Methods to read manufacturer and model name from selected endpoint and short address
-  char *readManufacturer(uint8_t endpoint, uint16_t short_addr);
-  char *readModel(uint8_t endpoint, uint16_t short_addr);
+  char *readManufacturer(uint8_t endpoint, uint16_t short_addr, esp_zb_ieee_addr_t ieee_addr);
+  char *readModel(uint8_t endpoint, uint16_t short_addr, esp_zb_ieee_addr_t ieee_addr);
 
   bool epAllowMultipleBinding() {
     return _allow_multiple_binding;
@@ -108,7 +108,7 @@ class ZigbeeEP {
   }
 
 private:
-  static bool _allow_multiple_binding;
+
   char *_read_manufacturer;
   char *_read_model;
   void (*_on_identify)(uint16_t time);
@@ -119,10 +119,16 @@ class ZigbeeEP {
   esp_zb_endpoint_config_t _ep_config;
   esp_zb_cluster_list_t *_cluster_list;
   static bool _is_bound;
+  static bool _allow_multiple_binding;
   std::list<zb_device_params_t *> _bound_devices;
   SemaphoreHandle_t lock;
   zb_power_source_t _power_source;
 
+  void addBoundDevice(zb_device_params_t *device) {
+    _bound_devices.push_back(device);
+    _is_bound = true;
+  }
+  
   friend class ZigbeeCore;
 };