Dev update: roles, cb removal, handlers

Fixed ep_thermostat to compile successfully
Removed cb from all EP, as it have been removed, virtual methods will be used instead.
Moved zigbee handlers out of Zigbee_core to Zigbee_handlers for better readability.
Fixed zigbeeInit to be bool and return status of initialization for begin function.
Updated examples with edited roles and custom method for on_off light

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

libraries/Zigbee/examples/Zigbee_Light_Bulb/Zigbee_Light_Bulb.ino

@@ -39,22 +39,19 @@
 #define LED_PIN RGB_BUILTIN
 #define ZIGBEE_LIGHT_ENDPOINT       10                                   /* esp light bulb device endpoint, used to process light controlling commands */
 
-/* Handle the light attribute */
-// User callback for Zigbee actions to handle turning on/off the light called by Zigbee stack in zb_attribute_handler()
+class MyZigbeeLight : public ZigbeeLight {
+public:
+    // Constructor that passes parameters to the base class constructor
+    MyZigbeeLight(uint8_t endpoint) : ZigbeeLight(endpoint) {}
 
-static void light_cb(const esp_zb_zcl_set_attr_value_message_t *message) {
-  bool light_state = 0;
-  if (message->info.cluster == ESP_ZB_ZCL_CLUSTER_ID_ON_OFF) {
-    if (message->attribute.id == ESP_ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID && message->attribute.data.type == ESP_ZB_ZCL_ATTR_TYPE_BOOL) {
-      light_state = message->attribute.data.value ? *(bool *)message->attribute.data.value : light_state;
-      log_i("Light sets to %s", light_state ? "On" : "Off");
-      neopixelWrite(LED_PIN, 255 * light_state, 255 * light_state, 255 * light_state);  // Toggle light
+    // Override the set_on_off function
+    void set_on_off(bool value) override {
+      log_v("Overwritten method, set on/off: %d", value);
+      neopixelWrite(LED_PIN, 255 * value, 255 * value, 255 * value);  // Toggle light
     }
-  }
-  return;
-}
+};
 
-ZigbeeLight zbLight = ZigbeeLight(ZIGBEE_LIGHT_ENDPOINT, light_cb);
+MyZigbeeLight zbLight = MyZigbeeLight(ZIGBEE_LIGHT_ENDPOINT);
 
 /********************* Arduino functions **************************/
 void setup() {
@@ -65,7 +62,7 @@ void setup() {
   log_d("Adding ZigbeeLight endpoint to Zigbee Core");
   Zigbee.addEndpoint(&zbLight);
 
-  // When all EPs are registered, start Zigbee. By default acts as Zigbee_End_Device
+  // When all EPs are registered, start Zigbee. By default acts as ZIGBEE_END_DEVICE
   log_d("Calling Zigbee.begin()");
   Zigbee.begin();
 }

libraries/Zigbee/examples/Zigbee_Light_Switch/Zigbee_Light_Switch.ino

@@ -98,7 +98,7 @@ static void switch_gpios_intr_enabled(bool enabled) {
   }
 }
 
-ZigbeeSwitch zbSwitch = ZigbeeSwitch(SWITCH_ENDPOINT_NUMBER,NULL);
+ZigbeeSwitch zbSwitch = ZigbeeSwitch(SWITCH_ENDPOINT_NUMBER);
 
 /********************* Arduino functions **************************/
 void setup() {
@@ -108,6 +108,9 @@ void setup() {
   //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++) {
@@ -121,9 +124,9 @@ void setup() {
     attachInterruptArg(button_func_pair[i].pin, gpio_isr_handler, (void *)(button_func_pair + i), FALLING);
   }
 
-  // When all EPs are registered, start Zigbee. By default acts as Zigbee_End_Device
+  // When all EPs are registered, start Zigbee with ZIGBEE_COORDINATOR mode
   log_d("Calling Zigbee.begin()");
-  Zigbee.begin(Zigbee_Coordinator);
+  Zigbee.begin(ZIGBEE_COORDINATOR);
 
   Serial.println("Waiting for Light to bound to the switch");
   //Wait for switch to bound to a light:

libraries/Zigbee/src/Zigbee_core.cpp

@@ -1,5 +1,6 @@
 /* Zigbee Common Functions */
 #include "Zigbee_core.h"
+#include "Zigbee_handlers.cpp"
 #include "Arduino.h"
 
 Zigbee_Core::Zigbee_Core() {
@@ -11,37 +12,44 @@ Zigbee_Core::Zigbee_Core() {
 }
 Zigbee_Core::~Zigbee_Core() {}
 
+//forward declaration
+static esp_err_t zb_action_handler(esp_zb_core_action_callback_id_t callback_id, const void *message);
+
 bool Zigbee_Core::begin(esp_zb_cfg_t *role_cfg, bool erase_nvs) {
-  zigbeeInit(role_cfg, erase_nvs);
+  if (!zigbeeInit(role_cfg, erase_nvs)){
+    return false;
+  }
   _role = (zigbee_role_t)role_cfg->esp_zb_role;
+  return true;
 }
 
 bool Zigbee_Core::begin(zigbee_role_t role, bool erase_nvs) {
+  bool status = true;
   switch (role)
   {
-    case Zigbee_Coordinator: {
-      _role = Zigbee_Coordinator;
+    case ZIGBEE_COORDINATOR: {
+      _role = ZIGBEE_COORDINATOR;
       esp_zb_cfg_t zb_nwk_cfg = ZIGBEE_DEFAULT_COORDINATOR_CONFIG();
-      zigbeeInit(&zb_nwk_cfg, erase_nvs);
+      status = zigbeeInit(&zb_nwk_cfg, erase_nvs);
       break;
     }
-    case Zigbee_Router: {
-      _role = Zigbee_Router;
+    case ZIGBEE_ROUTER: {
+      _role = ZIGBEE_ROUTER;
       esp_zb_cfg_t zb_nwk_cfg = ZIGBEE_DEFAULT_ROUTER_CONFIG();
-      zigbeeInit(&zb_nwk_cfg, erase_nvs);
+      status = zigbeeInit(&zb_nwk_cfg, erase_nvs);
       break;
     }
-    case Zigbee_End_Device: {
-      _role = Zigbee_End_Device;
+    case ZIGBEE_END_DEVICE: {
+      _role = ZIGBEE_END_DEVICE;
       esp_zb_cfg_t zb_nwk_cfg = ZIGBEE_DEFAULT_ED_CONFIG();
-      zigbeeInit(&zb_nwk_cfg, erase_nvs);
+      status = zigbeeInit(&zb_nwk_cfg, erase_nvs);
       break;
     }
     default:
       log_e("Invalid Zigbee Role");
       return false;
   }
-  return true;
+  return status;
 }
 
 void Zigbee_Core::addEndpoint(Zigbee_EP *ep) {
@@ -57,74 +65,37 @@ void Zigbee_Core::addEndpoint(Zigbee_EP *ep) {
   esp_zb_ep_list_add_ep(_zb_ep_list, ep->_cluster_list, ep->_ep_config);
 }
 
-static esp_err_t zb_attribute_handler(const esp_zb_zcl_set_attr_value_message_t *message) {
-  esp_err_t ret = ESP_OK;
-  bool light_state = 0;
-
-  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);
-      // }
-    }
-  }
-  return ret;
-}
-
-
-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)
-  */
-  switch (callback_id) {
-    case ESP_ZB_CORE_SET_ATTR_VALUE_CB_ID:   ret = zb_attribute_handler((esp_zb_zcl_set_attr_value_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;
-  }
-  return ret;
-}
-
 static void esp_zb_task(void *pvParameters) {
   /* initialize Zigbee stack */
   ESP_ERROR_CHECK(esp_zb_start(false));
   esp_zb_main_loop_iteration();
 }
 
 // Zigbee core init function
-void Zigbee_Core::zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs) {
+bool Zigbee_Core::zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs) {
   // Zigbee platform configuration
   esp_zb_platform_config_t platform_config = {
     .radio_config = _radio_config,
     .host_config = _host_config,
   };
-  ESP_ERROR_CHECK(esp_zb_platform_config(&platform_config));
+
+  esp_err_t err  = esp_zb_platform_config(&platform_config);
+  if (err != ESP_OK) {
+    log_e("Failed to configure Zigbee platform");
+    return false;
+  }
 
   // Initialize Zigbee stack
   log_d("Initialize Zigbee stack");
   esp_zb_init(zb_cfg);
 
   // Register all Zigbee EPs in list 
   log_d("Register all Zigbee EPs in list");
-  esp_zb_device_register(_zb_ep_list);
+  err = esp_zb_device_register(_zb_ep_list);
+  if (err != ESP_OK) {
+    log_e("Failed to register Zigbee EPs");
+    return false;
+  }
 
   //print the list of Zigbee EPs from ep_objects
   log_i("List of registered Zigbee EPs:");
@@ -134,7 +105,11 @@ void Zigbee_Core::zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs) {
 
   // Register Zigbee action handler
   esp_zb_core_action_handler_register(zb_action_handler);
-  esp_zb_set_primary_network_channel_set(_primary_channel_mask);
+  err = esp_zb_set_primary_network_channel_set(_primary_channel_mask);
+  if (err != ESP_OK) {
+    log_e("Failed to set primary network channel mask");
+    return false;
+  }
 
   //Erase NVRAM before creating connection to new Coordinator
   if (erase_nvs) {
@@ -143,6 +118,8 @@ void Zigbee_Core::zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs) {
 
   // Create Zigbee task and start Zigbee stack
   xTaskCreate(esp_zb_task, "Zigbee_main", 4096, NULL, 5, NULL);
+
+  return true;
 }
 
 void Zigbee_Core::setRadioConfig(esp_zb_radio_config_t config) {
@@ -300,6 +277,89 @@ 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;
+// }
+
+
+
 // TODO: Implement scanning network
 // /**
 //  * @brief   Active scan available network.

libraries/Zigbee/src/Zigbee_core.h

@@ -20,8 +20,8 @@ typedef struct {
 
 // enum of Zigbee Roles
 typedef enum {
-    ZIGBEE_COORDINATOR = 0,
-    ZIGBEE_ROUTER = 1,
+    ZIGBEE_COORDINATOR = 0, 
+    ZIGBEE_ROUTER = 1, 
     ZIGBEE_END_DEVICE = 2
 } zigbee_role_t;
 
@@ -82,7 +82,7 @@ class Zigbee_Core {
         esp_zb_host_config_t _host_config;
         uint32_t _primary_channel_mask;
 
-        void zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs);
+        bool zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs);
 
     public:
         esp_zb_ep_list_t *_zb_ep_list;
@@ -93,7 +93,7 @@ class Zigbee_Core {
         Zigbee_Core();
         ~Zigbee_Core();
 
-        bool begin(zigbee_role_t role = Zigbee_End_Device, bool erase_nvs = false);
+        bool begin(zigbee_role_t role = ZIGBEE_END_DEVICE, bool erase_nvs = false);
         bool begin(esp_zb_cfg_t *role_cfg, bool erase_nvs = false);
         // bool end();
 

libraries/Zigbee/src/Zigbee_ep.cpp

@@ -1,15 +1,13 @@
 /* Common Class for Zigbee End Point */
 
 #include "Zigbee_ep.h"
-#include "Arduino.h"
 
 uint8_t Zigbee_EP::_endpoint = 0;
 bool Zigbee_EP::_is_bound = false;
 
 /* Zigbee End Device Class */
-Zigbee_EP::Zigbee_EP(uint8_t endpoint, void (*cb)(const esp_zb_zcl_set_attr_value_message_t *message)) {
+Zigbee_EP::Zigbee_EP(uint8_t endpoint) {
     _endpoint = endpoint;
-    _cb = cb;
     _ep_config.endpoint = 0;
     _cluster_list = nullptr;
 }