Rename classes to have proper naming

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

CMakeLists.txt

@@ -242,15 +242,15 @@ set(ARDUINO_LIBRARY_WiFiProv_SRCS libraries/WiFiProv/src/WiFiProv.cpp)
 set(ARDUINO_LIBRARY_Wire_SRCS libraries/Wire/src/Wire.cpp)
 
 set(ARDUINO_LIBRARY_Zigbee_SRCS
-  libraries/Zigbee/src/Zigbee_core.cpp
-  libraries/Zigbee/src/Zigbee_ep.cpp
-  libraries/Zigbee/src/Zigbee_handlers.cpp
-  libraries/Zigbee/src/ep/ep_color_dimmable_light.cpp
-  libraries/Zigbee/src/ep/ep_color_dimmer_switch.cpp
-  libraries/Zigbee/src/ep/ep_on_off_light.cpp
-  libraries/Zigbee/src/ep/ep_on_off_switch.cpp
-  libraries/Zigbee/src/ep/ep_temperature_sensor.cpp
-  libraries/Zigbee/src/ep/ep_thermostat.cpp
+  libraries/Zigbee/src/ZigbeeCore.cpp
+  libraries/Zigbee/src/ZigbeeEP.cpp
+  libraries/Zigbee/src/ZigbeeHandlers.cpp
+  libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp
+  libraries/Zigbee/src/ep/ZigbeeColorDimmerSwitch.cpp
+  libraries/Zigbee/src/ep/ZigbeeLight.cpp
+  libraries/Zigbee/src/ep/ZigbeeSwitch.cpp
+  libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp
+  libraries/Zigbee/src/ep/ZigbeeThermostat.cpp
   )
 
 set(ARDUINO_LIBRARY_BLE_SRCS

libraries/Zigbee/examples/Zigbee_Color_Dimmable_Light/Zigbee_Color_Dimmable_Light.ino

@@ -31,8 +31,8 @@
 #error "Zigbee end device mode is not selected in Tools->Zigbee mode"
 #endif
 
-#include "Zigbee_core.h"
-#include "ep/ep_color_dimmable_light.h"
+#include "ZigbeeCore.h"
+#include "ep/ZigbeeColorDimmableLight.h"
 
 #define LED_PIN RGB_BUILTIN
 #define BUTTON_PIN 9  // C6/H2 Boot button

libraries/Zigbee/examples/Zigbee_Color_Dimmer_Switch/Zigbee_Color_Dimmer_Switch.ino

@@ -35,8 +35,8 @@
 #error "Zigbee coordinator mode is not selected in Tools->Zigbee mode"
 #endif
 
-#include "Zigbee_core.h"
-#include "ep/ep_color_dimmer_switch.h"
+#include "ZigbeeCore.h"
+#include "ep/ZigbeeColorDimmerSwitch.h"
 
 /* Switch configuration */
 #define SWITCH_PIN 9 //Boot button for C6/H2

libraries/Zigbee/examples/Zigbee_On_Off_Light/Zigbee_On_Off_Light.ino

@@ -30,8 +30,8 @@
 #error "Zigbee end device mode is not selected in Tools->Zigbee mode"
 #endif
 
-#include "Zigbee_core.h"
-#include "ep/ep_on_off_light.h"
+#include "ZigbeeCore.h"
+#include "ep/ZigbeeLight.h"
 
 #define LED_PIN RGB_BUILTIN
 #define BUTTON_PIN 9  // C6/H2 Boot button

libraries/Zigbee/examples/Zigbee_On_Off_Switch/Zigbee_On_Off_Switch.ino

@@ -31,8 +31,8 @@
 #error "Zigbee coordinator mode is not selected in Tools->Zigbee mode"
 #endif
 
-#include "Zigbee_core.h"
-#include "ep/ep_on_off_switch.h"
+#include "ZigbeeCore.h"
+#include "ep/ZigbeeSwitch.h"
 
 #define SWITCH_ENDPOINT_NUMBER 5
 

libraries/Zigbee/examples/Zigbee_Scan_Networks/Zigbee_Scan_Networks.ino

@@ -29,7 +29,7 @@
 #error "Zigbee device mode is not selected in Tools->Zigbee mode"
 #endif
 
-#include "Zigbee_core.h"
+#include "ZigbeeCore.h"
 
 #ifdef ZIGBEE_MODE_ZCZR
 zigbee_role_t role = ZIGBEE_ROUTER; // or can be ZIGBEE_COORDINATOR, but it wont scan itself

libraries/Zigbee/examples/Zigbee_Temperature_Sensor/Zigbee_Temperature_Sensor.ino

@@ -30,8 +30,8 @@
 #error "Zigbee coordinator mode is not selected in Tools->Zigbee mode"
 #endif
 
-#include "Zigbee_core.h"
-#include "ep/ep_temperature_sensor.h"
+#include "ZigbeeCore.h"
+#include "ep/ZigbeeTempSensor.h"
 
 #define BUTTON_PIN 9  //Boot button for C6/H2
 #define TEMP_SENSOR_ENDPOINT_NUMBER 10

libraries/Zigbee/examples/Zigbee_Thermostat/Zigbee_Thermostat.ino

@@ -31,8 +31,8 @@
 #error "Zigbee coordinator mode is not selected in Tools->Zigbee mode"
 #endif
 
-#include "Zigbee_core.h"
-#include "ep/ep_thermostat.h"
+#include "ZigbeeCore.h"
+#include "ep/ZigbeeThermostat.h"
 
 #define BUTTON_PIN 9 // Boot button for C6/H2
 #define THERMOSTAT_ENDPOINT_NUMBER 5

libraries/Zigbee/src/Zigbee_core.cpp renamed to libraries/Zigbee/src/ZigbeeCore.cpp

@@ -1,10 +1,12 @@
-/* Zigbee Common Functions */
-#include "Zigbee_core.h"
-#include "Zigbee_handlers.cpp"
-#include "Arduino.h"
+/* Zigbee Core Functions */
+
+#include "ZigbeeCore.h"
+#if SOC_IEEE802154_SUPPORTED
 
+#include "ZigbeeHandlers.cpp"
+#include "Arduino.h"
 
-Zigbee_Core::Zigbee_Core() {
+ZigbeeCore::ZigbeeCore() {
   _radio_config = ZIGBEE_DEFAULT_RADIO_CONFIG();
   _host_config = ZIGBEE_DEFAULT_HOST_CONFIG();
   _zb_ep_list = esp_zb_ep_list_create();
@@ -13,20 +15,20 @@ Zigbee_Core::Zigbee_Core() {
   _scan_status = ZB_SCAN_FAILED;
   _started = false;
 }
-Zigbee_Core::~Zigbee_Core() {}
+ZigbeeCore::~ZigbeeCore() {}
 
 //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) {
+bool ZigbeeCore::begin(esp_zb_cfg_t *role_cfg, bool 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 ZigbeeCore::begin(zigbee_role_t role, bool erase_nvs) {
   bool status = true;
   switch (role)
   {
@@ -55,13 +57,13 @@ bool Zigbee_Core::begin(zigbee_role_t role, bool erase_nvs) {
   return status;
 }
 
-void Zigbee_Core::addEndpoint(Zigbee_EP *ep) {
+void ZigbeeCore::addEndpoint(ZigbeeEP *ep) {
   ep_objects.push_back(ep);
 
   log_d("Endpoint: %d, Device ID: 0x%04x", ep->_endpoint, ep->_device_id);
-  //Register clusters and ep_list to the Zigbee_Core class's ep_list
+  //Register clusters and ep_list to the ZigbeeCore class's ep_list
   if (ep->_ep_config.endpoint == 0 || ep->_cluster_list == nullptr) {
-    log_e("Endpoint config or Cluster list is not initialized, EP not added to Zigbee_Core's EP list");
+    log_e("Endpoint config or Cluster list is not initialized, EP not added to ZigbeeCore's EP list");
     return;
   }
 
@@ -75,7 +77,7 @@ static void esp_zb_task(void *pvParameters) {
 }
 
 // Zigbee core init function
-bool Zigbee_Core::zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs) {
+bool ZigbeeCore::zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs) {
   // Zigbee platform configuration
   esp_zb_platform_config_t platform_config = {
     .radio_config = _radio_config,
@@ -105,7 +107,7 @@ bool Zigbee_Core::zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs) {
 
     //print the list of Zigbee EPs from ep_objects
     log_i("List of registered Zigbee EPs:");
-    for (std::list<Zigbee_EP*>::iterator it = ep_objects.begin(); it != ep_objects.end(); ++it) {
+    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);
     }
   }
@@ -128,27 +130,27 @@ bool Zigbee_Core::zigbeeInit(esp_zb_cfg_t *zb_cfg, bool erase_nvs) {
   return true;
 }
 
-void Zigbee_Core::setRadioConfig(esp_zb_radio_config_t config) {
+void ZigbeeCore::setRadioConfig(esp_zb_radio_config_t config) {
   _radio_config = config;
 }
 
-esp_zb_radio_config_t Zigbee_Core::getRadioConfig() {
+esp_zb_radio_config_t ZigbeeCore::getRadioConfig() {
   return _radio_config;
 }
 
-void Zigbee_Core::setHostConfig(esp_zb_host_config_t config) {
+void ZigbeeCore::setHostConfig(esp_zb_host_config_t config) {
   _host_config = config;
 }
 
-esp_zb_host_config_t Zigbee_Core::getHostConfig() {
+esp_zb_host_config_t ZigbeeCore::getHostConfig() {
   return _host_config;
 }
 
-void Zigbee_Core::setPrimaryChannelMask(uint32_t mask) {
+void ZigbeeCore::setPrimaryChannelMask(uint32_t mask) {
   _primary_channel_mask = mask;
 }
 
-void Zigbee_Core::setRebootOpenNetwork(uint8_t time) {
+void ZigbeeCore::setRebootOpenNetwork(uint8_t time) {
   _open_network = time;
 }
 
@@ -258,7 +260,7 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
         */
 
         // 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) {
+        for (std::list<ZigbeeEP*>::iterator it = Zigbee.ep_objects.begin(); it != Zigbee.ep_objects.end(); ++it) {
           if (!(*it)->_is_bound || (*it)->_allow_multiple_binding) {
             (*it)->find_endpoint(&cmd_req);
           }
@@ -280,16 +282,16 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
   }
 }
 
-void Zigbee_Core::factoryReset() {
+void ZigbeeCore::factoryReset() {
   log_v("Factory reseting Zigbee stack, device will reboot");
   esp_zb_factory_reset();
 }
 
-bool Zigbee_Core::isStarted() {
+bool ZigbeeCore::isStarted() {
   return _started;
 }
 
-void Zigbee_Core::scanCompleteCallback(esp_zb_zdp_status_t zdo_status, uint8_t count, esp_zb_network_descriptor_t *nwk_descriptor){
+void ZigbeeCore::scanCompleteCallback(esp_zb_zdp_status_t zdo_status, uint8_t count, esp_zb_network_descriptor_t *nwk_descriptor){
   log_v("Zigbee network scan complete");
   if(zdo_status == ESP_ZB_ZDP_STATUS_SUCCESS) {
     log_v("Found %d networks", count);
@@ -310,7 +312,7 @@ void Zigbee_Core::scanCompleteCallback(esp_zb_zdp_status_t zdo_status, uint8_t c
   }
 }
 
-void Zigbee_Core::scanNetworks(u_int32_t channel_mask, u_int8_t scan_duration) {
+void ZigbeeCore::scanNetworks(u_int32_t channel_mask, u_int8_t scan_duration) {
   if(!_started) {
     log_e("Zigbee stack is not started, cannot scan networks");
     return;
@@ -320,15 +322,15 @@ void Zigbee_Core::scanNetworks(u_int32_t channel_mask, u_int8_t scan_duration) {
   _scan_status = ZB_SCAN_RUNNING;
 }
 
-int16_t Zigbee_Core::scanComplete(){
+int16_t ZigbeeCore::scanComplete(){
   return _scan_status;
 }
 
-zigbee_scan_result_t* Zigbee_Core::getScanResult() {
+zigbee_scan_result_t* ZigbeeCore::getScanResult() {
   return _scan_result;
 }
 
-void Zigbee_Core::scanDelete() {
+void ZigbeeCore::scanDelete() {
   if (_scan_result != nullptr) {
     free(_scan_result);
     _scan_result = nullptr;
@@ -337,7 +339,7 @@ void Zigbee_Core::scanDelete() {
 }
 
 // Function to convert enum value to string
-const char* Zigbee_Core::getDeviceTypeString(esp_zb_ha_standard_devices_t deviceId) {
+const char* ZigbeeCore::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";
@@ -381,4 +383,6 @@ const char* Zigbee_Core::getDeviceTypeString(esp_zb_ha_standard_devices_t device
     }
 }
 
-Zigbee_Core Zigbee = Zigbee_Core();
+ZigbeeCore Zigbee = ZigbeeCore();
+
+#endif //SOC_IEEE802154_SUPPORTED

libraries/Zigbee/src/Zigbee_core.h renamed to libraries/Zigbee/src/ZigbeeCore.h

@@ -2,12 +2,15 @@
 
 #pragma once
 
+#include "soc/soc_caps.h"
+#if SOC_IEEE802154_SUPPORTED
+
 #include "esp_zigbee_core.h"
 #include "zdo/esp_zigbee_zdo_common.h"
 #include <esp32-hal-log.h>
 #include <list>
-#include "Zigbee_ep.h"
-class Zigbee_EP;
+#include "ZigbeeEP.h"
+class ZigbeeEP;
 
 typedef void (*voidFuncPtr)(void);
 typedef void (*voidFuncPtrArg)(void *);
@@ -28,10 +31,10 @@ typedef enum {
 } zigbee_role_t;
 
 // default Zigbee configuration for each role
-#define INSTALLCODE_POLICY_ENABLE   false /* enable the install code policy for security */
-#define ED_AGING_TIMEOUT            ESP_ZB_ED_AGING_TIMEOUT_64MIN
-#define ED_KEEP_ALIVE               3000 /* 3000 millisecond */
-#define MAX_CHILDREN                10
+#define INSTALLCODE_POLICY_ENABLE false /* enable the install code policy for security */
+#define ED_AGING_TIMEOUT ESP_ZB_ED_AGING_TIMEOUT_64MIN
+#define ED_KEEP_ALIVE 3000 /* 3000 millisecond */
+#define MAX_CHILDREN 10
 
 #define ZB_SCAN_RUNNING (-1)
 #define ZB_SCAN_FAILED  (-2)
@@ -51,7 +54,7 @@ typedef enum {
 
 #define ZIGBEE_DEFAULT_ROUTER_CONFIG()                     \
   {                                                        \
-    .esp_zb_role = ESP_ZB_DEVICE_TYPE_COORDINATOR,         \
+    .esp_zb_role = ESP_ZB_DEVICE_TYPE_ROUTER,              \
     .install_code_policy = INSTALLCODE_POLICY_ENABLE,      \
     .nwk_cfg = {                                           \
       .zczr_cfg =                                          \
@@ -81,7 +84,7 @@ typedef enum {
 #define ZIGBEE_DEFAULT_HOST_CONFIG() \
   { .host_connection_mode = ZB_HOST_CONNECTION_MODE_NONE, }
 
-class Zigbee_Core {
+class ZigbeeCore {
     private:
         esp_zb_radio_config_t _radio_config;
         esp_zb_host_config_t _host_config;
@@ -97,19 +100,19 @@ class Zigbee_Core {
         zigbee_role_t _role;
         bool _started;
         uint8_t _open_network;
-        std::list<Zigbee_EP*> ep_objects;
+        std::list<ZigbeeEP*> ep_objects;
         zigbee_scan_result_t *_scan_result;
 
-        Zigbee_Core();
-        ~Zigbee_Core();
+        ZigbeeCore();
+        ~ZigbeeCore();
 
         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 isStarted();
         // bool end();
 
-        void addEndpoint(Zigbee_EP *ep);
-        //void removeEndpoint(Zigbee_EP *ep);
+        void addEndpoint(ZigbeeEP *ep);
+        //void removeEndpoint(ZigbeeEP *ep);
 
         void setRadioConfig(esp_zb_radio_config_t config);
         esp_zb_radio_config_t getRadioConfig();
@@ -132,4 +135,6 @@ class Zigbee_Core {
         const char* getDeviceTypeString(esp_zb_ha_standard_devices_t deviceId);
 };
 
-extern Zigbee_Core Zigbee;
+extern ZigbeeCore Zigbee;
+
+#endif //SOC_IEEE802154_SUPPORTED