ci(pre-commit): Apply automatic fixes

Author: pre-commit-ci-lite[bot]

libraries/Zigbee/examples/Zigbee_OTA_Client/Zigbee_OTA_Client.ino

@@ -38,9 +38,9 @@ uint8_t led = RGB_BUILTIN;
 uint8_t button = BOOT_PIN;
 
 /* Zigbee OTA configuration */
-#define OTA_UPGRADE_RUNNING_FILE_VERSION 0x01010100 // Increment this value when the running image is updated
-#define OTA_UPGRADE_DOWNLOADED_FILE_VERSION 0x01010101 // Increment this value when the downloaded image is updated
-#define OTA_UPGRADE_HW_VERSION 0x0101 // The hardware version, this can be used to differentiate between different hardware versions
+#define OTA_UPGRADE_RUNNING_FILE_VERSION    0x01010100  // Increment this value when the running image is updated
+#define OTA_UPGRADE_DOWNLOADED_FILE_VERSION 0x01010101  // Increment this value when the downloaded image is updated
+#define OTA_UPGRADE_HW_VERSION              0x0101      // The hardware version, this can be used to differentiate between different hardware versions
 
 ZigbeeLight zbLight = ZigbeeLight(ZIGBEE_LIGHT_ENDPOINT);
 

libraries/Zigbee/src/ZigbeeEP.cpp

@@ -376,57 +376,59 @@ void ZigbeeEP::zbReadTimeCluster(const esp_zb_zcl_attribute_t *attribute) {
 //     uint8_t max_data_size; /*!< The maximum size of OTA data */
 // } esp_zb_zcl_ota_upgrade_client_variable_t;
 
-void ZigbeeEP::addOTAClient(uint32_t file_version, uint32_t downloaded_file_ver, uint16_t hw_version, uint16_t manufacturer, uint16_t image_type, uint8_t max_data_size) {
+void ZigbeeEP::addOTAClient(
+  uint32_t file_version, uint32_t downloaded_file_ver, uint16_t hw_version, uint16_t manufacturer, uint16_t image_type, uint8_t max_data_size
+) {
 
   esp_zb_ota_cluster_cfg_t ota_cluster_cfg = {};
-  ota_cluster_cfg.ota_upgrade_file_version = file_version;//OTA_UPGRADE_RUNNING_FILE_VERSION;
-  ota_cluster_cfg.ota_upgrade_downloaded_file_ver = downloaded_file_ver;//OTA_UPGRADE_DOWNLOADED_FILE_VERSION;
-  ota_cluster_cfg.ota_upgrade_manufacturer = manufacturer;//OTA_UPGRADE_MANUFACTURER;
-  ota_cluster_cfg.ota_upgrade_image_type = image_type;//OTA_UPGRADE_IMAGE_TYPE;
-  
+  ota_cluster_cfg.ota_upgrade_file_version = file_version;                //OTA_UPGRADE_RUNNING_FILE_VERSION;
+  ota_cluster_cfg.ota_upgrade_downloaded_file_ver = downloaded_file_ver;  //OTA_UPGRADE_DOWNLOADED_FILE_VERSION;
+  ota_cluster_cfg.ota_upgrade_manufacturer = manufacturer;                //OTA_UPGRADE_MANUFACTURER;
+  ota_cluster_cfg.ota_upgrade_image_type = image_type;                    //OTA_UPGRADE_IMAGE_TYPE;
+
   esp_zb_attribute_list_t *ota_cluster = esp_zb_ota_cluster_create(&ota_cluster_cfg);
 
   esp_zb_zcl_ota_upgrade_client_variable_t variable_config = {};
   variable_config.timer_query = ESP_ZB_ZCL_OTA_UPGRADE_QUERY_TIMER_COUNT_DEF;
-  variable_config.hw_version = hw_version;//OTA_UPGRADE_HW_VERSION;
-  variable_config.max_data_size = max_data_size;//OTA_UPGRADE_MAX_DATA_SIZE;
+  variable_config.hw_version = hw_version;        //OTA_UPGRADE_HW_VERSION;
+  variable_config.max_data_size = max_data_size;  //OTA_UPGRADE_MAX_DATA_SIZE;
 
   uint16_t ota_upgrade_server_addr = 0xffff;
   uint8_t ota_upgrade_server_ep = 0xff;
 
   ESP_ERROR_CHECK(esp_zb_ota_cluster_add_attr(ota_cluster, ESP_ZB_ZCL_ATTR_OTA_UPGRADE_CLIENT_DATA_ID, (void *)&variable_config));
   ESP_ERROR_CHECK(esp_zb_ota_cluster_add_attr(ota_cluster, ESP_ZB_ZCL_ATTR_OTA_UPGRADE_SERVER_ADDR_ID, (void *)&ota_upgrade_server_addr));
   ESP_ERROR_CHECK(esp_zb_ota_cluster_add_attr(ota_cluster, ESP_ZB_ZCL_ATTR_OTA_UPGRADE_SERVER_ENDPOINT_ID, (void *)&ota_upgrade_server_ep));
-  
+
   ESP_ERROR_CHECK(esp_zb_cluster_list_add_ota_cluster(_cluster_list, ota_cluster, ESP_ZB_ZCL_CLUSTER_CLIENT_ROLE));
 }
 
 static void findOTAServer(esp_zb_zdp_status_t zdo_status, uint16_t addr, uint8_t endpoint, void *user_ctx) {
   if (zdo_status == ESP_ZB_ZDP_STATUS_SUCCESS) {
-      esp_zb_ota_upgrade_client_query_interval_set(*((uint8_t *)user_ctx), OTA_UPGRADE_QUERY_INTERVAL);
-      esp_zb_ota_upgrade_client_query_image_req(addr, endpoint);
-      log_i("Query OTA upgrade from server endpoint: %d after %d seconds", endpoint, OTA_UPGRADE_QUERY_INTERVAL);
+    esp_zb_ota_upgrade_client_query_interval_set(*((uint8_t *)user_ctx), OTA_UPGRADE_QUERY_INTERVAL);
+    esp_zb_ota_upgrade_client_query_image_req(addr, endpoint);
+    log_i("Query OTA upgrade from server endpoint: %d after %d seconds", endpoint, OTA_UPGRADE_QUERY_INTERVAL);
   } else {
-      log_w("No OTA Server found");
+    log_w("No OTA Server found");
   }
 }
 
 void ZigbeeEP::requestOTAUpdate() {
-    esp_zb_zdo_match_desc_req_param_t req;
-    uint16_t cluster_list[] = {ESP_ZB_ZCL_CLUSTER_ID_OTA_UPGRADE};
-
-    /* Match the OTA server of coordinator */
-    req.addr_of_interest = 0x0000;
-    req.dst_nwk_addr = 0x0000;
-    req.num_in_clusters = 1;
-    req.num_out_clusters = 0;
-    req.profile_id = ESP_ZB_AF_HA_PROFILE_ID;
-    req.cluster_list = cluster_list;
-    esp_zb_lock_acquire(portMAX_DELAY);
-    if (esp_zb_bdb_dev_joined()) {
-        esp_zb_zdo_match_cluster(&req, findOTAServer, &_endpoint);
-    }
-    esp_zb_lock_release();
+  esp_zb_zdo_match_desc_req_param_t req;
+  uint16_t cluster_list[] = {ESP_ZB_ZCL_CLUSTER_ID_OTA_UPGRADE};
+
+  /* Match the OTA server of coordinator */
+  req.addr_of_interest = 0x0000;
+  req.dst_nwk_addr = 0x0000;
+  req.num_in_clusters = 1;
+  req.num_out_clusters = 0;
+  req.profile_id = ESP_ZB_AF_HA_PROFILE_ID;
+  req.cluster_list = cluster_list;
+  esp_zb_lock_acquire(portMAX_DELAY);
+  if (esp_zb_bdb_dev_joined()) {
+    esp_zb_zdo_match_cluster(&req, findOTAServer, &_endpoint);
+  }
+  esp_zb_lock_release();
 }
 
 #endif  //SOC_IEEE802154_SUPPORTED && CONFIG_ZB_ENABLED

libraries/Zigbee/src/ZigbeeEP.h

@@ -8,8 +8,8 @@
 #include <Arduino.h>
 
 /* Useful defines */
-#define ZB_CMD_TIMEOUT 10000  // 10 seconds
-#define OTA_UPGRADE_QUERY_INTERVAL (1 * 60) // 1 hour = 60 minutes
+#define ZB_CMD_TIMEOUT             10000     // 10 seconds
+#define OTA_UPGRADE_QUERY_INTERVAL (1 * 60)  // 1 hour = 60 minutes
 
 #define ZB_ARRAY_LENTH(arr) (sizeof(arr) / sizeof(arr[0]))
 #define XYZ_TO_RGB(X, Y, Z, r, g, b)                                \
@@ -119,8 +119,11 @@ class ZigbeeEP {
    * @param image_type The image type code (default: 0x1011).
    * @param max_data_size The maximum data size for OTA transfer (default and recommended: 223).
    */
-  void addOTAClient(uint32_t file_version, uint32_t downloaded_file_ver, uint16_t hw_version, uint16_t manufacturer = 0x1001, uint16_t image_type = 0x1011, uint8_t max_data_size = 223);
-  /** 
+  void addOTAClient(
+    uint32_t file_version, uint32_t downloaded_file_ver, uint16_t hw_version, uint16_t manufacturer = 0x1001, uint16_t image_type = 0x1011,
+    uint8_t max_data_size = 223
+  );
+  /**
    * @brief Request OTA update from the server, first request is within a minute and the next requests are sent every hour automatically.
   */
   void requestOTAUpdate();

libraries/Zigbee/src/ZigbeeHandlers.cpp

@@ -5,19 +5,19 @@
 #if SOC_IEEE802154_SUPPORTED && CONFIG_ZB_ENABLED
 
 #include "esp_ota_ops.h"
-#if CONFIG_ZB_DELTA_OTA // Delta OTA, code is prepared for this feature but not enabled by default
+#if CONFIG_ZB_DELTA_OTA  // Delta OTA, code is prepared for this feature but not enabled by default
 #include "esp_delta_ota_ops.h"
 #endif
 
 //OTA Upgrade defines and variables
-#define OTA_ELEMENT_HEADER_LEN              6       /* OTA element format header size include tag identifier and length field */
+#define OTA_ELEMENT_HEADER_LEN 6 /* OTA element format header size include tag identifier and length field */
 
 /**
  * @name Enumeration for the tag identifier denotes the type and format of the data within the element
  * @anchor esp_ota_element_tag_id_t
  */
 typedef enum esp_ota_element_tag_id_e {
-    UPGRADE_IMAGE                               = 0x0000,           /*!< Upgrade image */
+  UPGRADE_IMAGE = 0x0000, /*!< Upgrade image */
 } esp_ota_element_tag_id_t;
 
 static const esp_partition_t *s_ota_partition = NULL;
@@ -36,7 +36,6 @@ static esp_err_t zb_window_covering_movement_resp_handler(const esp_zb_zcl_windo
 static esp_err_t zb_ota_upgrade_status_handler(const esp_zb_zcl_ota_upgrade_value_message_t *message);
 static esp_err_t zb_ota_upgrade_query_image_resp_handler(const esp_zb_zcl_ota_upgrade_query_image_resp_message_t *message);
 
-
 // Zigbee action handlers
 [[maybe_unused]]
 static esp_err_t zb_action_handler(esp_zb_core_action_callback_id_t callback_id, const void *message) {
@@ -55,9 +54,7 @@ static esp_err_t zb_action_handler(esp_zb_core_action_callback_id_t callback_id,
     case ESP_ZB_CORE_WINDOW_COVERING_MOVEMENT_CB_ID:
       ret = zb_window_covering_movement_resp_handler((esp_zb_zcl_window_covering_movement_message_t *)message);
       break;
-    case ESP_ZB_CORE_OTA_UPGRADE_VALUE_CB_ID:
-      ret = zb_ota_upgrade_status_handler((esp_zb_zcl_ota_upgrade_value_message_t *)message);
-      break;
+    case ESP_ZB_CORE_OTA_UPGRADE_VALUE_CB_ID: ret = zb_ota_upgrade_status_handler((esp_zb_zcl_ota_upgrade_value_message_t *)message); break;
     case ESP_ZB_CORE_OTA_UPGRADE_QUERY_IMAGE_RESP_CB_ID:
       ret = zb_ota_upgrade_query_image_resp_handler((esp_zb_zcl_ota_upgrade_query_image_resp_message_t *)message);
       break;
@@ -237,21 +234,20 @@ static esp_err_t zb_window_covering_movement_resp_handler(const esp_zb_zcl_windo
   return ESP_OK;
 }
 
-static esp_err_t esp_element_ota_data(uint32_t total_size, const void *payload, uint16_t payload_size, void **outbuf, uint16_t *outlen)
-{
+static esp_err_t esp_element_ota_data(uint32_t total_size, const void *payload, uint16_t payload_size, void **outbuf, uint16_t *outlen) {
   static uint16_t tagid = 0;
   void *data_buf = NULL;
   uint16_t data_len;
 
   if (!s_tagid_received) {
     uint32_t length = 0;
     if (!payload || payload_size <= OTA_ELEMENT_HEADER_LEN) {
-        log_e("Invalid element format");
-        return ESP_ERR_INVALID_ARG;
+      log_e("Invalid element format");
+      return ESP_ERR_INVALID_ARG;
     }
 
     const uint8_t *payload_ptr = (const uint8_t *)payload;
-    tagid  = *(const uint16_t *)payload_ptr;
+    tagid = *(const uint16_t *)payload_ptr;
     length = *(const uint32_t *)(payload_ptr + sizeof(tagid));
     if ((length + OTA_ELEMENT_HEADER_LEN) != total_size) {
       log_e("Invalid element length [%ld/%ld]", length, total_size);
@@ -281,8 +277,7 @@ static esp_err_t esp_element_ota_data(uint32_t total_size, const void *payload,
   return ESP_OK;
 }
 
-static esp_err_t zb_ota_upgrade_status_handler(const esp_zb_zcl_ota_upgrade_value_message_t *message)
-{
+static esp_err_t zb_ota_upgrade_status_handler(const esp_zb_zcl_ota_upgrade_value_message_t *message) {
   static uint32_t total_size = 0;
   static uint32_t offset = 0;
   [[maybe_unused]]
@@ -291,94 +286,91 @@ static esp_err_t zb_ota_upgrade_status_handler(const esp_zb_zcl_ota_upgrade_valu
 
   if (message->info.status == ESP_ZB_ZCL_STATUS_SUCCESS) {
     switch (message->upgrade_status) {
-    case ESP_ZB_ZCL_OTA_UPGRADE_STATUS_START:
-      log_i("Zigbee - OTA upgrade start");
-      start_time = esp_timer_get_time();
-      s_ota_partition = esp_ota_get_next_update_partition(NULL);
-      assert(s_ota_partition);
+      case ESP_ZB_ZCL_OTA_UPGRADE_STATUS_START:
+        log_i("Zigbee - OTA upgrade start");
+        start_time = esp_timer_get_time();
+        s_ota_partition = esp_ota_get_next_update_partition(NULL);
+        assert(s_ota_partition);
 #if CONFIG_ZB_DELTA_OTA
-      ret = esp_delta_ota_begin(s_ota_partition, 0, &s_ota_handle);
+        ret = esp_delta_ota_begin(s_ota_partition, 0, &s_ota_handle);
 #else
-      ret = esp_ota_begin(s_ota_partition, 0, &s_ota_handle);
+        ret = esp_ota_begin(s_ota_partition, 0, &s_ota_handle);
 #endif
-      if(ret != ESP_OK) {
-        log_e("Zigbee - Failed to begin OTA partition, status: %s", esp_err_to_name(ret));
-        return ret;
-      }
-      break;
-    case ESP_ZB_ZCL_OTA_UPGRADE_STATUS_RECEIVE:
-      total_size = message->ota_header.image_size;
-      offset += message->payload_size;
-      log_i("Zigbee - OTA Client receives data: progress [%ld/%ld]", offset, total_size);
-      if (message->payload_size && message->payload) {
-        uint16_t payload_size = 0;
-        void    *payload = NULL;
-        ret = esp_element_ota_data(total_size, message->payload, message->payload_size, &payload, &payload_size);
-        if(ret != ESP_OK) {
-          log_e("Zigbee - Failed to element OTA data, status: %s", esp_err_to_name(ret));
+        if (ret != ESP_OK) {
+          log_e("Zigbee - Failed to begin OTA partition, status: %s", esp_err_to_name(ret));
           return ret;
         }
+        break;
+      case ESP_ZB_ZCL_OTA_UPGRADE_STATUS_RECEIVE:
+        total_size = message->ota_header.image_size;
+        offset += message->payload_size;
+        log_i("Zigbee - OTA Client receives data: progress [%ld/%ld]", offset, total_size);
+        if (message->payload_size && message->payload) {
+          uint16_t payload_size = 0;
+          void *payload = NULL;
+          ret = esp_element_ota_data(total_size, message->payload, message->payload_size, &payload, &payload_size);
+          if (ret != ESP_OK) {
+            log_e("Zigbee - Failed to element OTA data, status: %s", esp_err_to_name(ret));
+            return ret;
+          }
 #if CONFIG_ZB_DELTA_OTA
-        ret = esp_delta_ota_write(s_ota_handle, payload, payload_size);
+          ret = esp_delta_ota_write(s_ota_handle, payload, payload_size);
 #else
-        ret = esp_ota_write(s_ota_handle, (const void *)payload, payload_size);
+          ret = esp_ota_write(s_ota_handle, (const void *)payload, payload_size);
 #endif
-        if(ret != ESP_OK) {
-          log_e("Zigbee - Failed to write OTA data to partition, status: %s", esp_err_to_name(ret));
-          return ret;
+          if (ret != ESP_OK) {
+            log_e("Zigbee - Failed to write OTA data to partition, status: %s", esp_err_to_name(ret));
+            return ret;
+          }
         }
-      }
-      break;
-    case ESP_ZB_ZCL_OTA_UPGRADE_STATUS_APPLY:
-      log_i("Zigbee - OTA upgrade apply");
-      break;
-    case ESP_ZB_ZCL_OTA_UPGRADE_STATUS_CHECK:
-      ret = offset == total_size ? ESP_OK : ESP_FAIL;
-      offset = 0;
-      total_size = 0;
-      s_tagid_received = false;
-      log_i("Zigbee - OTA upgrade check status: %s", esp_err_to_name(ret));
-      break;
-    case ESP_ZB_ZCL_OTA_UPGRADE_STATUS_FINISH:
-      log_i("Zigbee - OTA Finish");
-      log_i("Zigbee - OTA Information: version: 0x%lx, manufacturer code: 0x%x, image type: 0x%x, total size: %ld bytes, cost time: %lld ms,",
-                message->ota_header.file_version, message->ota_header.manufacturer_code, message->ota_header.image_type,
-                message->ota_header.image_size, (esp_timer_get_time() - start_time) / 1000);
+        break;
+      case ESP_ZB_ZCL_OTA_UPGRADE_STATUS_APPLY: log_i("Zigbee - OTA upgrade apply"); break;
+      case ESP_ZB_ZCL_OTA_UPGRADE_STATUS_CHECK:
+        ret = offset == total_size ? ESP_OK : ESP_FAIL;
+        offset = 0;
+        total_size = 0;
+        s_tagid_received = false;
+        log_i("Zigbee - OTA upgrade check status: %s", esp_err_to_name(ret));
+        break;
+      case ESP_ZB_ZCL_OTA_UPGRADE_STATUS_FINISH:
+        log_i("Zigbee - OTA Finish");
+        log_i(
+          "Zigbee - OTA Information: version: 0x%lx, manufacturer code: 0x%x, image type: 0x%x, total size: %ld bytes, cost time: %lld ms,",
+          message->ota_header.file_version, message->ota_header.manufacturer_code, message->ota_header.image_type, message->ota_header.image_size,
+          (esp_timer_get_time() - start_time) / 1000
+        );
 #if CONFIG_ZB_DELTA_OTA
-      ret = esp_delta_ota_end(s_ota_handle);
+        ret = esp_delta_ota_end(s_ota_handle);
 #else
-      ret = esp_ota_end(s_ota_handle);
+        ret = esp_ota_end(s_ota_handle);
 #endif
-      if(ret != ESP_OK) {
-        log_e("Zigbee - Failed to end OTA partition, status: %s", esp_err_to_name(ret));
-        return ret;
-      }
-      ret = esp_ota_set_boot_partition(s_ota_partition);
-      if(ret != ESP_OK) {
-        log_e("Zigbee - Failed to set OTA boot partition, status: %s", esp_err_to_name(ret));
-        return ret;
-      }
-      log_w("Zigbee - Prepare to restart system");
-      esp_restart();
-      break;
-    default:
-      log_i("Zigbee - OTA status: %d", message->upgrade_status);
-      break;
+        if (ret != ESP_OK) {
+          log_e("Zigbee - Failed to end OTA partition, status: %s", esp_err_to_name(ret));
+          return ret;
+        }
+        ret = esp_ota_set_boot_partition(s_ota_partition);
+        if (ret != ESP_OK) {
+          log_e("Zigbee - Failed to set OTA boot partition, status: %s", esp_err_to_name(ret));
+          return ret;
+        }
+        log_w("Zigbee - Prepare to restart system");
+        esp_restart();
+        break;
+      default: log_i("Zigbee - OTA status: %d", message->upgrade_status); break;
     }
   }
   return ret;
 }
 
-static esp_err_t zb_ota_upgrade_query_image_resp_handler(const esp_zb_zcl_ota_upgrade_query_image_resp_message_t *message)
-{
+static esp_err_t zb_ota_upgrade_query_image_resp_handler(const esp_zb_zcl_ota_upgrade_query_image_resp_message_t *message) {
   if (message->info.status == ESP_ZB_ZCL_STATUS_SUCCESS) {
     log_i("Zigbee - Queried OTA image from address: 0x%04hx, endpoint: %d", message->server_addr.u.short_addr, message->server_endpoint);
     log_i("Zigbee - Image version: 0x%lx, manufacturer code: 0x%x, image size: %ld", message->file_version, message->manufacturer_code, message->image_size);
-    if(message->image_size == 0) {
+    if (message->image_size == 0) {
       log_i("Zigbee - Rejecting OTA image upgrade, image size is 0");
       return ESP_FAIL;
     }
-    if(message->file_version == 0) {
+    if (message->file_version == 0) {
       log_i("Zigbee - Rejecting OTA image upgrade, file version is 0");
       return ESP_FAIL;
     }