Dev update: implement on/off light and switch methods

Implemented basic function calls of switch commands to on/off light:
  lightToggle, lightOn, lightOff, ...
Implemented virtual methods for on/off light that have to be override in user code:
  setOnOff, sceneControl, setOnOffTime, setOffWaitTime
APIs can be changed, still early development.

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

libraries/Zigbee/examples/Zigbee_Light_Bulb/Zigbee_Light_Bulb.ino

@@ -1,4 +1,4 @@
-// Copyright 2023 Espressif Systems (Shanghai) PTE LTD
+// Copyright 2024 Espressif Systems (Shanghai) PTE LTD
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -22,6 +22,8 @@
  * and also the correct partition scheme must be selected in Tools->Partition Scheme.
  *
  * Please check the README.md for instructions and more detailed description.
+ * 
+ * Created by Jan Procházka (https://github.com/P-R-O-C-H-Y/)
  */
 
 #ifndef ZIGBEE_MODE_ED
@@ -45,7 +47,7 @@ public:
     MyZigbeeLight(uint8_t endpoint) : ZigbeeLight(endpoint) {}
 
     // Override the set_on_off function
-    void set_on_off(bool value) override {
+    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
     }

libraries/Zigbee/examples/Zigbee_Light_Switch/Zigbee_Light_Switch.ino

@@ -1,9 +1,9 @@
-// Copyright 2023 Espressif Systems (Shanghai) PTE LTD
+// Copyright 2024 Espressif Systems (Shanghai) PTE LTD
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
-
+//
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
@@ -16,13 +16,15 @@
  * @brief This example demonstrates simple Zigbee light switch.
  *
  * The example demonstrates how to use ESP Zigbee stack to control a light bulb.
- * The light bulb is a Zigbee end device, which is controlled by a Zigbee coordinator.
+ * The light bulb is a Zigbee end device, which is controlled by a Zigbee coordinator (Switch).
  * Button switch and Zigbee runs in separate tasks.
  *
  * Proper Zigbee mode must be selected in Tools->Zigbee mode
  * and also the correct partition scheme must be selected in Tools->Partition Scheme.
  *
  * Please check the README.md for instructions and more detailed description.
+ * 
+ * Created by Jan Procházka (https://github.com/P-R-O-C-H-Y/)
  */
 
 #ifndef ZIGBEE_MODE_ZCZR
@@ -68,16 +70,14 @@ 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);
+
 /********************* Zigbee functions **************************/
 static void esp_zb_buttons_handler(switch_func_pair_t *button_func_pair) {
   if (button_func_pair->func == SWITCH_ONOFF_TOGGLE_CONTROL) {
-    /* implemented light switch toggle functionality */
-    esp_zb_zcl_on_off_cmd_t cmd_req;
-    cmd_req.zcl_basic_cmd.src_endpoint = SWITCH_ENDPOINT_NUMBER;
-    cmd_req.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT;
-    cmd_req.on_off_cmd_id = ESP_ZB_ZCL_CMD_ON_OFF_TOGGLE_ID;
-    log_i("Send 'on_off toggle' command");
-    esp_zb_zcl_on_off_cmd_req(&cmd_req);
+    // Send toggle command to the light
+    zbSwitch.lightToggle();
   }
 }
 
@@ -98,8 +98,6 @@ static void switch_gpios_intr_enabled(bool enabled) {
   }
 }
 
-ZigbeeSwitch zbSwitch = ZigbeeSwitch(SWITCH_ENDPOINT_NUMBER);
-
 /********************* Arduino functions **************************/
 void setup() {
 

libraries/Zigbee/src/Zigbee_ep.h

@@ -14,7 +14,8 @@ class Zigbee_EP {
     Zigbee_EP(uint8_t endpoint = 10);
     ~Zigbee_EP();
 
-    virtual void find_endpoint(esp_zb_zdo_match_desc_req_param_t *cmd_req) = 0;
+    // Find endpoint may be implemented by EPs
+    virtual void find_endpoint(esp_zb_zdo_match_desc_req_param_t *cmd_req) {};
 
     static uint8_t _endpoint;
     esp_zb_ha_standard_devices_t _device_id; //type of device

libraries/Zigbee/src/ep/ep_on_off_light.cpp

@@ -14,35 +14,51 @@ ZigbeeLight::ZigbeeLight(uint8_t endpoint) : Zigbee_EP(endpoint) {
     };
 }
 
-void ZigbeeLight::find_endpoint(esp_zb_zdo_match_desc_req_param_t *cmd_req) {
-    //NOTE: Light is looking for switch?
-    return;
-}
-
 //set attribude method -> methon overriden in child class
 void ZigbeeLight::attribute_set(const esp_zb_zcl_set_attr_value_message_t *message) {
     //check the data and call right method
     if (message->info.cluster == ESP_ZB_ZCL_CLUSTER_ID_ON_OFF) {
-        bool light_state = 0;
         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;
-            set_on_off(light_state);
+            setOnOff(*(bool *)message->attribute.data.value);
+        }
+        else if(message->attribute.id == ESP_ZB_ZCL_ATTR_ON_OFF_GLOBAL_SCENE_CONTROL && message->attribute.data.type == ESP_ZB_ZCL_ATTR_TYPE_BOOL) {
+            sceneControl(*(bool *)message->attribute.data.value);
+        }
+        else if(message->attribute.id == ESP_ZB_ZCL_ATTR_ON_OFF_ON_TIME && message->attribute.data.type == ESP_ZB_ZCL_ATTR_TYPE_U16) {
+            setOnOffTime(*(uint16_t *)message->attribute.data.value);
+        }
+        else if(message->attribute.id == ESP_ZB_ZCL_ATTR_ON_OFF_OFF_WAIT_TIME && message->attribute.data.type == ESP_ZB_ZCL_ATTR_TYPE_U16) {
+            setOffWaitTime(*(uint16_t *)message->attribute.data.value);
+        }
+        // else if(message->attribute.id == ESP_ZB_ZCL_ATTR_ON_OFF_START_UP_ON_OFF && message->attribute.data.type == ESP_ZB_ZCL_ATTR_TYPE_BOOL) {
+        //     //TODO: more info needed, not implemented for now
+        // }
+        else {
+            log_w("Recieved message ignored. Attribute ID: %d not supported for On/Off Light", message->attribute.id);
         }
     }
-    // if (message->attr_id == ESP_ZB_ON_OFF_LIGHT_ATTR_ON_OFF) {
-    //     //call method to set on/off
-    //     set_on_off(message->attribute.data[0]);
-    // }
-    // else if (message->attr_id == ESP_ZB_ON_OFF_LIGHT_ATTR_LEVEL) {
-    //     //call method to set level
-    // }
     else {
-        //unknown attribute
+        log_w("Recieved message ignored. Cluster ID: %d not supported for On/Off Light", message->info.cluster);
     }
 }
 
 //default method to set on/off
-void ZigbeeLight::set_on_off(bool value) {
+void ZigbeeLight::setOnOff(bool value) {
     //set on/off
     log_v("Function not overwritten, set on/off: %d", value);
-}
+}
+
+void ZigbeeLight::sceneControl(bool value) {
+    //set scene control
+    log_v("Function not overwritten, set scene control: %d", value);
+}
+
+void ZigbeeLight::setOnOffTime(uint16_t value) {
+    //set on/off time
+    log_v("Function not overwritten, set on/off time: %d", value);
+}
+
+void ZigbeeLight::setOffWaitTime(uint16_t value) {
+    //set off wait time
+    log_v("Function not overwritten, set off wait time: %d", value);
+}

libraries/Zigbee/src/ep/ep_on_off_light.h

@@ -11,11 +11,12 @@ class ZigbeeLight : public Zigbee_EP {
     ~ZigbeeLight();
 
     // methods to be implemented by the user by overwritting them
-    virtual void set_on_off(bool value);
+    virtual void setOnOff(bool value);
+    virtual void sceneControl(bool value);
+    virtual void setOnOffTime(uint16_t value);
+    virtual void setOffWaitTime(uint16_t value);
 
   private:
-    void find_endpoint(esp_zb_zdo_match_desc_req_param_t *cmd_req);
-
     void attribute_set(const esp_zb_zcl_set_attr_value_message_t *message) override;
 
 };

libraries/Zigbee/src/ep/ep_on_off_switch.cpp

@@ -69,3 +69,84 @@ void ZigbeeSwitch::find_endpoint(esp_zb_zdo_match_desc_req_param_t *cmd_req) {
 
     esp_zb_zdo_match_cluster(&on_off_req, find_cb, NULL);
 }
+
+// Call to control the light
+void ZigbeeSwitch::lightToggle() {
+    if (_is_bound) {
+        esp_zb_zcl_on_off_cmd_t cmd_req;
+        cmd_req.zcl_basic_cmd.src_endpoint = _endpoint;
+        cmd_req.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT;
+        cmd_req.on_off_cmd_id = ESP_ZB_ZCL_CMD_ON_OFF_TOGGLE_ID;
+        log_i("Sending 'light toggle' command");
+        esp_zb_zcl_on_off_cmd_req(&cmd_req);
+    } else {
+        log_e("Light not bound");
+    }
+}
+
+void ZigbeeSwitch::lightOn() {
+    if (_is_bound) {
+        esp_zb_zcl_on_off_cmd_t cmd_req;
+        cmd_req.zcl_basic_cmd.src_endpoint = _endpoint;
+        cmd_req.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT;
+        cmd_req.on_off_cmd_id = ESP_ZB_ZCL_CMD_ON_OFF_ON_ID;
+        log_i("Sending 'light on' command");
+        esp_zb_zcl_on_off_cmd_req(&cmd_req);
+    } else {
+        log_e("Light not bound");
+    }
+}
+
+void ZigbeeSwitch::lightOff() {
+    if (_is_bound) {
+        esp_zb_zcl_on_off_cmd_t cmd_req;
+        cmd_req.zcl_basic_cmd.src_endpoint = _endpoint;
+        cmd_req.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT;
+        cmd_req.on_off_cmd_id = ESP_ZB_ZCL_CMD_ON_OFF_OFF_ID;
+        log_i("Sending 'light off' command");
+        esp_zb_zcl_on_off_cmd_req(&cmd_req);
+    } else {
+        log_e("Light not bound");
+    }
+}
+
+void ZigbeeSwitch::lightOffWithEffect(uint8_t effect_id, uint8_t effect_variant) {
+    if (_is_bound) {
+        esp_zb_zcl_on_off_off_with_effect_cmd_t cmd_req;
+        cmd_req.zcl_basic_cmd.src_endpoint = _endpoint;
+        cmd_req.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT;
+        cmd_req.effect_id = effect_id;
+        cmd_req.effect_variant = effect_variant;
+        log_i("Sending 'light off with effect' command");
+        esp_zb_zcl_on_off_off_with_effect_cmd_req(&cmd_req);
+    } else {
+        log_e("Light not bound");
+    }
+}
+
+void ZigbeeSwitch::lightOnWithSceneRecall() {
+    if (_is_bound) {
+        esp_zb_zcl_on_off_on_with_recall_global_scene_cmd_t cmd_req;
+        cmd_req.zcl_basic_cmd.src_endpoint = _endpoint;
+        cmd_req.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT;
+        log_i("Sending 'light on with scene recall' command");
+        esp_zb_zcl_on_off_on_with_recall_global_scene_cmd_req(&cmd_req);
+    } else {
+        log_e("Light not bound");
+    }
+}
+void ZigbeeSwitch::lightOnWithTimedOff(uint8_t on_off_control, uint16_t time_on, uint16_t time_off) {
+    if (_is_bound) {
+        esp_zb_zcl_on_off_on_with_timed_off_cmd_t cmd_req;
+        cmd_req.zcl_basic_cmd.src_endpoint = _endpoint;
+        cmd_req.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT;
+        cmd_req.on_off_control = on_off_control; //TODO: Test how it works, then maybe change API
+        cmd_req.on_time = time_on;
+        cmd_req.off_wait_time = time_off;
+        log_i("Sending 'light on with time off' command");
+        esp_zb_zcl_on_off_on_with_timed_off_cmd_req(&cmd_req);
+    } else {
+        log_e("Light not bound");
+    }
+}
+

libraries/Zigbee/src/ep/ep_on_off_switch.h

@@ -1,4 +1,4 @@
-/* Class of Zigbee On/Off Light endpoint inherited from common EP class */
+/* Class of Zigbee On/Off Switch endpoint inherited from common EP class */
 
 #pragma once
 
@@ -10,10 +10,30 @@ class ZigbeeSwitch : public Zigbee_EP {
     ZigbeeSwitch(uint8_t endpoint);
     ~ZigbeeSwitch();
 
+    // methods to control the on/off light
+    void lightToggle();
+    void lightOn();
+    void lightOff();
+    void lightOffWithEffect(uint8_t effect_id, uint8_t effect_variant);
+    void lightOnWithTimedOff(uint8_t on_off_control, uint16_t time_on, uint16_t time_off);
+    void lightOnWithSceneRecall();
+
+  private:
     void find_endpoint(esp_zb_zdo_match_desc_req_param_t *cmd_req);
     static void bind_cb(esp_zb_zdp_status_t zdo_status, void *user_ctx);
     static void find_cb(esp_zb_zdp_status_t zdo_status, uint16_t addr, uint8_t endpoint, void *user_ctx);
 
     static uint8_t get_endpoint() { return _endpoint; }
 
-};
+};
+
+//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;