Dev update: Factory reset, names, multiple EPs

Implemented Factory reset of Zigbee device, in order to connect to new network without reflashing/erasing flash
Implemented optional setting for Manufacturer and Model names
Added option to allow endpoint to have multiple endpoint connected -> switch - 2 lights (tested)
Minor sketches update

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

libraries/Zigbee/examples/Zigbee_Light_Bulb/Zigbee_Light_Bulb.ino

@@ -39,6 +39,7 @@
 #include "ha/esp_zigbee_ha_standard.h"
 
 #define LED_PIN RGB_BUILTIN
+#define BUTTON_PIN 9  // C6/H2 Boot button
 #define ZIGBEE_LIGHT_ENDPOINT       10                                   /* esp light bulb device endpoint, used to process light controlling commands */
 
 class MyZigbeeLight : public ZigbeeLight {
@@ -48,7 +49,6 @@ public:
 
     // Override the set_on_off function
     void setOnOff(bool value) override {
-      log_v("Overwritten method, set on/off: %d", value);
       neopixelWrite(LED_PIN, 255 * value, 255 * value, 255 * value);  // Toggle light
     }
 };
@@ -60,6 +60,12 @@ void setup() {
   // Init RMT and leave light OFF
   neopixelWrite(LED_PIN, 0, 0, 0);
 
+  // Init button for factory reset
+  pinMode(BUTTON_PIN, INPUT);
+
+  //Optional: set Zigbee device name and model
+  zbLight.setManufacturerAndModel("Espressif", "ZBLightBulb");
+
   //Add endpoint to Zigbee Core
   log_d("Adding ZigbeeLight endpoint to Zigbee Core");
   Zigbee.addEndpoint(&zbLight);
@@ -70,5 +76,19 @@ void setup() {
 }
 
 void loop() {
-  //empty, zigbee running in task
+  // Cheking 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("Reseting Zigbee to factory settings, reboot.\n");
+        Zigbee.factoryReset();
+      }
+    }
+  }
+  delay(100);
 }

libraries/Zigbee/examples/Zigbee_Light_Switch/Zigbee_Light_Switch.ino

@@ -71,7 +71,23 @@ typedef enum {
 static switch_func_pair_t button_func_pair[] = {{GPIO_INPUT_IO_TOGGLE_SWITCH, SWITCH_ONOFF_TOGGLE_CONTROL}};
 
 /* Zigbee switch */
-ZigbeeSwitch zbSwitch = ZigbeeSwitch(SWITCH_ENDPOINT_NUMBER);
+class MyZigbeeSwitch : public ZigbeeSwitch {
+public:
+    // Constructor that passes parameters to the base class constructor
+    MyZigbeeSwitch(uint8_t endpoint) : ZigbeeSwitch(endpoint) {}
+
+    // Override the set_on_off function
+    void readManufacturer(char* manufacturer) override {
+      //Do what you want with the manufacturer string
+      Serial.printf("Manufacturer: %s\n", manufacturer);
+    }
+    void readModel(char* model) override {
+      //Do what you want with the model string
+      Serial.printf("Model: %s\n", model);
+    }
+};
+
+MyZigbeeSwitch zbSwitch = MyZigbeeSwitch(SWITCH_ENDPOINT_NUMBER);
 
 /********************* Zigbee functions **************************/
 static void esp_zb_buttons_handler(switch_func_pair_t *button_func_pair) {
@@ -103,13 +119,20 @@ void setup() {
 
   Serial.begin(115200);
 
+  //Optional: set Zigbee device name and model
+  zbSwitch.setManufacturerAndModel("Espressif", "ZigbeeSwitch");
+
+  //Optional to allow multiple light to bind to the switch
+  zbSwitch.allowMultipleBinding(true);
+
   //Add endpoint to Zigbee Core
   log_d("Adding ZigbeeSwitch endpoint to Zigbee Core");
   Zigbee.addEndpoint(&zbSwitch);
 
   //Open network for 180 seconds after boot
   Zigbee.setRebootOpenNetwork(180);
 
+
   // Init button switch
   for (int i = 0; i < PAIR_SIZE(button_func_pair); i++) {
     pinMode(button_func_pair[i].pin, INPUT_PULLUP);
@@ -169,4 +192,11 @@ void loop() {
     }
     vTaskDelay(10 / portTICK_PERIOD_MS);
   }
+
+  // print the bound lights every 10 seconds
+  static uint32_t last_print = 0;
+  if (millis() - last_print > 10000) {
+    last_print = millis();
+    zbSwitch.printBoundLights();
+  }
 }

libraries/Zigbee/src/Zigbee_core.cpp

@@ -3,6 +3,7 @@
 #include "Zigbee_handlers.cpp"
 #include "Arduino.h"
 
+
 Zigbee_Core::Zigbee_Core() {
   _radio_config = ZIGBEE_DEFAULT_RADIO_CONFIG();
   _host_config = ZIGBEE_DEFAULT_HOST_CONFIG();
@@ -254,9 +255,9 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
 
         //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
+        // 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) {
+          if (!(*it)->_is_bound || (*it)->_allow_multiple_binding) {
             (*it)->find_endpoint(&cmd_req);
           }
         }
@@ -277,87 +278,10 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
   }
 }
 
-// // Zigbee action handlers
-// static esp_err_t zb_action_handler(esp_zb_core_action_callback_id_t callback_id, const void *message) {
-//   esp_err_t ret = ESP_OK;
-//   /* TODO: 
-//     Implement handlers for different Zigbee actions (callback_id's)
-//   */
-//   // NOTE: Implement all Zigbee actions that can be handled by the Zigbee_Core class, or just call user defined callback function and let the user handle the action and read the message properly
-//   // NOTE: This may me harder for users, to know what callback_id's are available and what message type is received
-//   switch (callback_id) {
-//     case ESP_ZB_CORE_SET_ATTR_VALUE_CB_ID:          ret = zb_attribute_set_handler((esp_zb_zcl_set_attr_value_message_t *)message); break;
-//     case ESP_ZB_CORE_REPORT_ATTR_CB_ID:             ret = zb_attribute_reporting_handler((esp_zb_zcl_report_attr_message_t *)message); break;
-//     case ESP_ZB_CORE_CMD_READ_ATTR_RESP_CB_ID:      ret = zb_read_attr_resp_handler((esp_zb_zcl_cmd_read_attr_resp_message_t *)message); break;
-//     case ESP_ZB_CORE_CMD_REPORT_CONFIG_RESP_CB_ID:  ret = zb_configure_report_resp_handler((esp_zb_zcl_cmd_config_report_resp_message_t *)message); break;
-//     case ESP_ZB_CORE_CMD_DEFAULT_RESP_CB_ID:        log_i("Received default response"); break;
-//     default:                                 log_w("Receive unhandled Zigbee action(0x%x) callback", callback_id); break;
-//   }
-
-//   //TODO: get destination endpoint from the message:
-//   uint8_t dst_endpoint = ((esp_zb_zcl_set_attr_value_message_t *)message)->info.dst_endpoint;
-
-
-
-//   return ret;
-// }
-
-// static esp_err_t zb_attribute_set_handler(const esp_zb_zcl_set_attr_value_message_t *message) {
-//   if (!message) {
-//     log_e("Empty message");
-//   }
-//   if (message->info.status != ESP_ZB_ZCL_STATUS_SUCCESS) {
-//     log_e("Received message: error status(%d)", message->info.status);
-//   }
-
-//   log_i(
-//     "Received message: endpoint(%d), cluster(0x%x), attribute(0x%x), data size(%d)", message->info.dst_endpoint, message->info.cluster, message->attribute.id,
-//     message->attribute.data.size
-//   );
-
-//   // List through all Zigbee EPs and call the callback function, with the message
-//   for (std::list<Zigbee_EP*>::iterator it = Zigbee.ep_objects.begin(); it != Zigbee.ep_objects.end(); ++it) {
-//     if (message->info.dst_endpoint == (*it)->_endpoint) {
-//       //TODO: implement argument passing to the callback function
-//       //if Zigbee_EP argument is set, pass it to the callback function
-//       // if ((*it)->_arg) {
-//       //   (*it)->_cb(message, (*it)->_arg);
-//       // }
-//       // else {
-//       (*it)->_cb(message); //method zb_attribute_set_handler in the LIGHT EP
-//       // }
-//     }
-//   }
-//   return ESP_OK;
-// }
-
-// static esp_err_t zb_attribute_reporting_handler(const esp_zb_zcl_report_attr_message_t *message) {
-//   if (!message) {
-//     log_e("Empty message");
-//   }
-//   if (message->status != ESP_ZB_ZCL_STATUS_SUCCESS) {
-//     log_e("Received message: error status(%d)", message->status);
-//   }
-//   log_i(
-//     "Received report from address(0x%x) src endpoint(%d) to dst endpoint(%d) cluster(0x%x)", message->src_address.u.short_addr, message->src_endpoint,
-//     message->dst_endpoint, message->cluster
-//   );
-//     // List through all Zigbee EPs and call the callback function, with the message
-//   for (std::list<Zigbee_EP*>::iterator it = Zigbee.ep_objects.begin(); it != Zigbee.ep_objects.end(); ++it) {
-//     if (message->info.dst_endpoint == (*it)->_endpoint) {
-//       //TODO: implement argument passing to the callback function
-//       //if Zigbee_EP argument is set, pass it to the callback function
-//       // if ((*it)->_arg) {
-//       //   (*it)->_cb(message, (*it)->_arg);
-//       // }
-//       // else {
-//       (*it)->_cb(message);
-//       // }
-//     }
-//   }
-//   return ESP_OK;
-// }
-
+void Zigbee_Core::factoryReset() {
+  log_v("Factory reseting Zigbee stack, device will reboot");
+  esp_zb_factory_reset();
+}
 
 
 // TODO: Implement scanning network
@@ -394,4 +318,48 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
 //     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) {
+        case ESP_ZB_HA_ON_OFF_SWITCH_DEVICE_ID: return "General On/Off switch";
+        case ESP_ZB_HA_LEVEL_CONTROL_SWITCH_DEVICE_ID: return "Level Control Switch";
+        case ESP_ZB_HA_ON_OFF_OUTPUT_DEVICE_ID: return "General On/Off output";
+        case ESP_ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_DEVICE_ID: return "Level Controllable Output";
+        case ESP_ZB_HA_SCENE_SELECTOR_DEVICE_ID: return "Scene Selector";
+        case ESP_ZB_HA_CONFIGURATION_TOOL_DEVICE_ID: return "Configuration Tool";
+        case ESP_ZB_HA_REMOTE_CONTROL_DEVICE_ID: return "Remote Control";
+        case ESP_ZB_HA_COMBINED_INTERFACE_DEVICE_ID: return "Combined Interface";
+        case ESP_ZB_HA_RANGE_EXTENDER_DEVICE_ID: return "Range Extender";
+        case ESP_ZB_HA_MAINS_POWER_OUTLET_DEVICE_ID: return "Mains Power Outlet";
+        case ESP_ZB_HA_DOOR_LOCK_DEVICE_ID: return "Door lock client";
+        case ESP_ZB_HA_DOOR_LOCK_CONTROLLER_DEVICE_ID: return "Door lock controller";
+        case ESP_ZB_HA_SIMPLE_SENSOR_DEVICE_ID: return "Simple Sensor device";
+        case ESP_ZB_HA_CONSUMPTION_AWARENESS_DEVICE_ID: return "Consumption Awareness Device";
+        case ESP_ZB_HA_HOME_GATEWAY_DEVICE_ID: return "Home Gateway";
+        case ESP_ZB_HA_SMART_PLUG_DEVICE_ID: return "Smart plug";
+        case ESP_ZB_HA_WHITE_GOODS_DEVICE_ID: return "White Goods";
+        case ESP_ZB_HA_METER_INTERFACE_DEVICE_ID: return "Meter Interface";
+        case ESP_ZB_HA_ON_OFF_LIGHT_DEVICE_ID: return "On/Off Light Device";
+        case ESP_ZB_HA_DIMMABLE_LIGHT_DEVICE_ID: return "Dimmable Light 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_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";
+        case ESP_ZB_HA_WINDOW_COVERING_CONTROLLER_DEVICE_ID: return "Window Covering controller";
+        case ESP_ZB_HA_HEATING_COOLING_UNIT_DEVICE_ID: return "Heating/Cooling Unit device";
+        case ESP_ZB_HA_THERMOSTAT_DEVICE_ID: return "Thermostat Device";
+        case ESP_ZB_HA_TEMPERATURE_SENSOR_DEVICE_ID: return "Temperature Sensor";
+        case ESP_ZB_HA_IAS_CONTROL_INDICATING_EQUIPMENT_ID: return "IAS Control and Indicating Equipment";
+        case ESP_ZB_HA_IAS_ANCILLARY_CONTROL_EQUIPMENT_ID: return "IAS Ancillary Control Equipment";
+        case ESP_ZB_HA_IAS_ZONE_ID: return "IAS Zone";
+        case ESP_ZB_HA_IAS_WARNING_DEVICE_ID: return "IAS Warning Device";
+        case ESP_ZB_HA_TEST_DEVICE_ID: return "Custom HA device for test";
+        case ESP_ZB_HA_CUSTOM_TUNNEL_DEVICE_ID: return "Custom Tunnel device";
+        case ESP_ZB_HA_CUSTOM_ATTR_DEVICE_ID: return "Custom Attributes Device";
+        default: return "Unknown device type";
+    }
+}
+
 Zigbee_Core Zigbee = Zigbee_Core();

libraries/Zigbee/src/Zigbee_core.h

@@ -108,6 +108,8 @@ class Zigbee_Core {
 
         void setPrimaryChannelMask(uint32_t mask);
         void setRebootOpenNetwork(uint8_t time);
+
+        void factoryReset();
 };
 
 extern Zigbee_Core Zigbee;

libraries/Zigbee/src/Zigbee_ep.cpp

@@ -1,17 +1,99 @@
 /* Common Class for Zigbee End Point */
 
 #include "Zigbee_ep.h"
+#include "esp_zigbee_cluster.h"
 
 uint8_t Zigbee_EP::_endpoint = 0;
 bool Zigbee_EP::_is_bound = false;
+bool Zigbee_EP::_allow_multiple_binding = false;
 
 /* Zigbee End Device Class */
 Zigbee_EP::Zigbee_EP(uint8_t endpoint) {
     _endpoint = endpoint;
     _ep_config.endpoint = 0;
     _cluster_list = nullptr;
+    _attribute_cluster = nullptr;
 }
 
 Zigbee_EP::~Zigbee_EP() {
 
 }
+
+void Zigbee_EP::setManufacturerAndModel(const char *name, const char *model) {
+    // Convert manufacturer to ZCL string
+    size_t length = strlen(name);
+    if (length > 32) {
+        log_e("Manufacturer name is too long");
+        return;
+    }
+    // Allocate a new array of size length + 2 (1 for the length, 1 for null terminator)
+    char* zb_name = new char[length + 2];
+    // Store the length as the first element
+    zb_name[0] = static_cast<char>(length); // Cast size_t to char
+    // Use memcpy to copy the characters to the result array
+    memcpy(zb_name + 1, name, length);
+    // Null-terminate the array
+    zb_name[length + 1] = '\0';
+
+    // Convert model to ZCL string
+    length = strlen(model);
+    if (length > 32) {
+        log_e("Model name is too long");
+        delete[] zb_name;
+        return;
+    }
+    char* zb_model = new char[length + 2];
+    zb_model[0] = static_cast<char>(length);
+    memcpy(zb_model + 1, model, length);
+    zb_model[length + 1] = '\0';
+
+    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_basic_cluster_add_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID, (void *)zb_name);
+    esp_zb_basic_cluster_add_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MODEL_IDENTIFIER_ID, (void *)zb_model);
+
+}
+
+void Zigbee_EP::readManufacturerAndModel(uint8_t endpoint, uint16_t short_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;
+    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[] = {
+    ESP_ZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID,
+    ESP_ZB_ZCL_ATTR_BASIC_MODEL_IDENTIFIER_ID,
+    };
+    read_req.attr_number = ZB_ARRAY_LENTH(attributes);
+    read_req.attr_field = attributes;
+
+    esp_zb_zcl_read_attr_cmd_req(&read_req);
+}
+
+void Zigbee_EP::attribute_read_cmd(uint16_t cluster_id, const esp_zb_zcl_attribute_t *attribute) {
+    /* Basic cluster attributes */
+    if (cluster_id == ESP_ZB_ZCL_CLUSTER_ID_BASIC) {
+        if (attribute->id == ESP_ZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID && attribute->data.type == ESP_ZB_ZCL_ATTR_TYPE_CHAR_STRING && attribute->data.value) {
+            zbstring_t *zbstr = (zbstring_t *)attribute->data.value;
+            char *string = (char *)malloc(zbstr->len + 1);
+            memcpy(string, zbstr->data, zbstr->len);
+            string[zbstr->len] = '\0';
+            log_i("Peer Manufacturer is \"%s\"", string);
+            readManufacturer(string);
+            free(string);
+        }
+        if (attribute->id == ESP_ZB_ZCL_ATTR_BASIC_MODEL_IDENTIFIER_ID && attribute->data.type == ESP_ZB_ZCL_ATTR_TYPE_CHAR_STRING && attribute->data.value) {
+            zbstring_t *zbstr = (zbstring_t *)attribute->data.value;
+            char *string = (char *)malloc(zbstr->len + 1);
+            memcpy(string, zbstr->data, zbstr->len);
+            string[zbstr->len] = '\0';
+            log_i("Peer Model is \"%s\"", string);
+            readModel(string);
+            free(string);
+        }
+    }
+}
+//NOTE:
+// esp_zb_cluster_add_attr function