ci(pre-commit): Apply automatic fixes

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

libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino

@@ -136,7 +136,7 @@ void loop() {
         // Optional set reset in factoryReset to false, to not restart device after erasing nvram, but set it to endless sleep manually instead
         Zigbee.factoryReset(false);
         Serial.println("Going to endless sleep, press RESET button or power off/on the device to wake up");
-        esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER); 
+        esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);
         esp_deep_sleep_start();
       }
     }

libraries/Zigbee/src/ZigbeeCore.cpp

@@ -102,11 +102,11 @@ bool ZigbeeCore::addEndpoint(ZigbeeEP *ep) {
   }
   esp_err_t ret = ESP_OK;
   if (ep->_device_id == ESP_ZB_HA_HOME_GATEWAY_DEVICE_ID) {
-    ret  = esp_zb_ep_list_add_gateway_ep(_zb_ep_list, ep->_cluster_list, ep->_ep_config);
+    ret = esp_zb_ep_list_add_gateway_ep(_zb_ep_list, ep->_cluster_list, ep->_ep_config);
   } else {
     ret = esp_zb_ep_list_add_ep(_zb_ep_list, ep->_cluster_list, ep->_ep_config);
   }
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to add endpoint: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
@@ -384,8 +384,7 @@ void ZigbeeCore::factoryReset(bool restart) {
   if (restart) {
     log_v("Factory resetting Zigbee stack, device will reboot");
     esp_zb_factory_reset();
-  }
-  else {
+  } else {
     log_v("Factory resetting Zigbee NVRAM to factory default");
     log_w("The device will not reboot, to take effect please reboot the device manually");
     esp_zb_zcl_reset_nvram_to_factory_default();

libraries/Zigbee/src/ZigbeeEP.cpp

@@ -60,7 +60,7 @@ bool ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) {
     log_e("Failed to set manufacturer: 0x%x: %s", ret_name, esp_err_to_name(ret_name));
   }
   esp_err_t ret_model = esp_zb_basic_cluster_add_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MODEL_IDENTIFIER_ID, (void *)zb_model);
-  if(ret_model != ESP_OK) {
+  if (ret_model != ESP_OK) {
     log_e("Failed to set model: 0x%x: %s", ret_model, esp_err_to_name(ret_model));
   }
   delete[] zb_name;
@@ -112,7 +112,7 @@ bool ZigbeeEP::setBatteryPercentage(uint8_t percentage) {
     false
   );
   esp_zb_lock_release();
-  if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
+  if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
     log_e("Failed to set battery percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
     return false;
   }
@@ -133,7 +133,7 @@ bool ZigbeeEP::reportBatteryPercentage() {
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
   esp_zb_lock_release();
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to report battery percentage: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
@@ -321,7 +321,7 @@ bool ZigbeeEP::setTime(tm time) {
   esp_zb_lock_acquire(portMAX_DELAY);
   ret = esp_zb_zcl_set_attribute_val(_endpoint, ESP_ZB_ZCL_CLUSTER_ID_TIME, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_TIME_TIME_ID, &utc_time, false);
   esp_zb_lock_release();
-  if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
+  if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
     log_e("Failed to set time: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
     return false;
   }
@@ -332,9 +332,10 @@ bool ZigbeeEP::setTimezone(int32_t gmt_offset) {
   esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS;
   log_d("Setting timezone to %d", gmt_offset);
   esp_zb_lock_acquire(portMAX_DELAY);
-  ret = esp_zb_zcl_set_attribute_val(_endpoint, ESP_ZB_ZCL_CLUSTER_ID_TIME, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_TIME_TIME_ZONE_ID, &gmt_offset, false);
+  ret =
+    esp_zb_zcl_set_attribute_val(_endpoint, ESP_ZB_ZCL_CLUSTER_ID_TIME, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_TIME_TIME_ZONE_ID, &gmt_offset, false);
   esp_zb_lock_release();
-  if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
+  if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
     log_e("Failed to set timezone: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
     return false;
   }
@@ -528,76 +529,42 @@ void ZigbeeEP::requestOTAUpdate() {
   esp_zb_lock_release();
 }
 
-const char* ZigbeeEP::esp_zb_zcl_status_to_name(esp_zb_zcl_status_t status) {
+const char *ZigbeeEP::esp_zb_zcl_status_to_name(esp_zb_zcl_status_t status) {
   switch (status) {
-    case ESP_ZB_ZCL_STATUS_SUCCESS:
-      return "Success";
-    case ESP_ZB_ZCL_STATUS_FAIL:
-      return "Fail"; 
-    case ESP_ZB_ZCL_STATUS_NOT_AUTHORIZED:
-      return "Not authorized";
-    case ESP_ZB_ZCL_STATUS_MALFORMED_CMD:
-      return "Malformed command";
-    case ESP_ZB_ZCL_STATUS_UNSUP_CLUST_CMD:
-      return "Unsupported cluster command";
-    case ESP_ZB_ZCL_STATUS_UNSUP_GEN_CMD:
-      return "Unsupported general command";
-    case ESP_ZB_ZCL_STATUS_UNSUP_MANUF_CLUST_CMD:
-      return "Unsupported manufacturer cluster command";
-    case ESP_ZB_ZCL_STATUS_UNSUP_MANUF_GEN_CMD:
-      return "Unsupported manufacturer general command";
-    case ESP_ZB_ZCL_STATUS_INVALID_FIELD:
-      return "Invalid field";
-    case ESP_ZB_ZCL_STATUS_UNSUP_ATTRIB:
-      return "Unsupported attribute";
-    case ESP_ZB_ZCL_STATUS_INVALID_VALUE:
-      return "Invalid value";
-    case ESP_ZB_ZCL_STATUS_READ_ONLY:
-      return "Read only";
-    case ESP_ZB_ZCL_STATUS_INSUFF_SPACE:
-      return "Insufficient space";
-    case ESP_ZB_ZCL_STATUS_DUPE_EXISTS:
-      return "Duplicate exists";
-    case ESP_ZB_ZCL_STATUS_NOT_FOUND:
-      return "Not found";
-    case ESP_ZB_ZCL_STATUS_UNREPORTABLE_ATTRIB:
-      return "Unreportable attribute";
-    case ESP_ZB_ZCL_STATUS_INVALID_TYPE:
-      return "Invalid type";
-    case ESP_ZB_ZCL_STATUS_WRITE_ONLY:
-      return "Write only";
-    case ESP_ZB_ZCL_STATUS_INCONSISTENT:
-      return "Inconsistent";
-    case ESP_ZB_ZCL_STATUS_ACTION_DENIED:
-      return "Action denied";
-    case ESP_ZB_ZCL_STATUS_TIMEOUT:
-      return "Timeout";
-    case ESP_ZB_ZCL_STATUS_ABORT:
-      return "Abort";
-    case ESP_ZB_ZCL_STATUS_INVALID_IMAGE:
-      return "Invalid OTA upgrade image";
-    case ESP_ZB_ZCL_STATUS_WAIT_FOR_DATA:
-      return "Server does not have data block available yet";
-    case ESP_ZB_ZCL_STATUS_NO_IMAGE_AVAILABLE:
-      return "No image available";
-    case ESP_ZB_ZCL_STATUS_REQUIRE_MORE_IMAGE:
-      return "Require more image";
-    case ESP_ZB_ZCL_STATUS_NOTIFICATION_PENDING:
-      return "Notification pending";
-    case ESP_ZB_ZCL_STATUS_HW_FAIL:
-      return "Hardware failure";
-    case ESP_ZB_ZCL_STATUS_SW_FAIL:
-      return "Software failure";
-    case ESP_ZB_ZCL_STATUS_CALIB_ERR:
-      return "Calibration error";
-    case ESP_ZB_ZCL_STATUS_UNSUP_CLUST:
-      return "Cluster is not found on the target endpoint";
-    case ESP_ZB_ZCL_STATUS_LIMIT_REACHED:
-      return "Limit reached";
-    default:
-      return "Unknown status";
+    case ESP_ZB_ZCL_STATUS_SUCCESS:               return "Success";
+    case ESP_ZB_ZCL_STATUS_FAIL:                  return "Fail";
+    case ESP_ZB_ZCL_STATUS_NOT_AUTHORIZED:        return "Not authorized";
+    case ESP_ZB_ZCL_STATUS_MALFORMED_CMD:         return "Malformed command";
+    case ESP_ZB_ZCL_STATUS_UNSUP_CLUST_CMD:       return "Unsupported cluster command";
+    case ESP_ZB_ZCL_STATUS_UNSUP_GEN_CMD:         return "Unsupported general command";
+    case ESP_ZB_ZCL_STATUS_UNSUP_MANUF_CLUST_CMD: return "Unsupported manufacturer cluster command";
+    case ESP_ZB_ZCL_STATUS_UNSUP_MANUF_GEN_CMD:   return "Unsupported manufacturer general command";
+    case ESP_ZB_ZCL_STATUS_INVALID_FIELD:         return "Invalid field";
+    case ESP_ZB_ZCL_STATUS_UNSUP_ATTRIB:          return "Unsupported attribute";
+    case ESP_ZB_ZCL_STATUS_INVALID_VALUE:         return "Invalid value";
+    case ESP_ZB_ZCL_STATUS_READ_ONLY:             return "Read only";
+    case ESP_ZB_ZCL_STATUS_INSUFF_SPACE:          return "Insufficient space";
+    case ESP_ZB_ZCL_STATUS_DUPE_EXISTS:           return "Duplicate exists";
+    case ESP_ZB_ZCL_STATUS_NOT_FOUND:             return "Not found";
+    case ESP_ZB_ZCL_STATUS_UNREPORTABLE_ATTRIB:   return "Unreportable attribute";
+    case ESP_ZB_ZCL_STATUS_INVALID_TYPE:          return "Invalid type";
+    case ESP_ZB_ZCL_STATUS_WRITE_ONLY:            return "Write only";
+    case ESP_ZB_ZCL_STATUS_INCONSISTENT:          return "Inconsistent";
+    case ESP_ZB_ZCL_STATUS_ACTION_DENIED:         return "Action denied";
+    case ESP_ZB_ZCL_STATUS_TIMEOUT:               return "Timeout";
+    case ESP_ZB_ZCL_STATUS_ABORT:                 return "Abort";
+    case ESP_ZB_ZCL_STATUS_INVALID_IMAGE:         return "Invalid OTA upgrade image";
+    case ESP_ZB_ZCL_STATUS_WAIT_FOR_DATA:         return "Server does not have data block available yet";
+    case ESP_ZB_ZCL_STATUS_NO_IMAGE_AVAILABLE:    return "No image available";
+    case ESP_ZB_ZCL_STATUS_REQUIRE_MORE_IMAGE:    return "Require more image";
+    case ESP_ZB_ZCL_STATUS_NOTIFICATION_PENDING:  return "Notification pending";
+    case ESP_ZB_ZCL_STATUS_HW_FAIL:               return "Hardware failure";
+    case ESP_ZB_ZCL_STATUS_SW_FAIL:               return "Software failure";
+    case ESP_ZB_ZCL_STATUS_CALIB_ERR:             return "Calibration error";
+    case ESP_ZB_ZCL_STATUS_UNSUP_CLUST:           return "Cluster is not found on the target endpoint";
+    case ESP_ZB_ZCL_STATUS_LIMIT_REACHED:         return "Limit reached";
+    default:                                      return "Unknown status";
   }
 }
 
-
 #endif  // CONFIG_ZB_ENABLED

libraries/Zigbee/src/ZigbeeEP.h

@@ -146,8 +146,8 @@ class ZigbeeEP {
 
 protected:
   // Convert ZCL status to name
-  const char *esp_zb_zcl_status_to_name(esp_zb_zcl_status_t status); 
-  
+  const char *esp_zb_zcl_status_to_name(esp_zb_zcl_status_t status);
+
   uint8_t _endpoint;
   esp_zb_ha_standard_devices_t _device_id;
   esp_zb_endpoint_config_t _ep_config;

libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp

@@ -30,12 +30,12 @@ bool ZigbeeCarbonDioxideSensor::setMinMaxValue(float min, float max) {
   esp_zb_attribute_list_t *carbon_dioxide_measure_cluster =
     esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_CARBON_DIOXIDE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
   esp_err_t ret = esp_zb_cluster_update_attr(carbon_dioxide_measure_cluster, ESP_ZB_ZCL_ATTR_CARBON_DIOXIDE_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&zb_min);
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
   ret = esp_zb_cluster_update_attr(carbon_dioxide_measure_cluster, ESP_ZB_ZCL_ATTR_CARBON_DIOXIDE_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&zb_max);
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
@@ -49,7 +49,7 @@ bool ZigbeeCarbonDioxideSensor::setTolerance(float tolerance) {
   esp_err_t ret = esp_zb_carbon_dioxide_measurement_cluster_add_attr(
     carbon_dioxide_measure_cluster, ESP_ZB_ZCL_ATTR_CARBON_DIOXIDE_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance
   );
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
@@ -76,7 +76,7 @@ bool ZigbeeCarbonDioxideSensor::setReporting(uint16_t min_interval, uint16_t max
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_err_t ret = esp_zb_zcl_update_reporting_info(&reporting_info);
   esp_zb_lock_release();
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
@@ -95,7 +95,7 @@ bool ZigbeeCarbonDioxideSensor::setCarbonDioxide(float carbon_dioxide) {
     &zb_carbon_dioxide, false
   );
   esp_zb_lock_release();
-  if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
+  if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
     log_e("Failed to set carbon dioxide: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
     return false;
   }
@@ -115,7 +115,7 @@ bool ZigbeeCarbonDioxideSensor::report() {
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
   esp_zb_lock_release();
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to send carbon dioxide report: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }

libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp

@@ -28,12 +28,12 @@ bool ZigbeeFlowSensor::setMinMaxValue(float min, float max) {
   esp_zb_attribute_list_t *flow_measure_cluster =
     esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_FLOW_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
   esp_err_t ret = esp_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min);
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
   ret = esp_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max);
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
@@ -67,11 +67,11 @@ bool ZigbeeFlowSensor::setReporting(uint16_t min_interval, uint16_t max_interval
   reporting_info.u.send_info.delta.u16 = (uint16_t)(delta * 10);  // Convert delta to ZCL uint16_t
   reporting_info.dst.profile_id = ESP_ZB_AF_HA_PROFILE_ID;
   reporting_info.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC;
-  
+
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_err_t ret = esp_zb_zcl_update_reporting_info(&reporting_info);
   esp_zb_lock_release();
-  
+
   if (ret != ESP_OK) {
     log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
@@ -85,13 +85,13 @@ bool ZigbeeFlowSensor::setFlow(float flow) {
   log_v("Updating flow sensor value...");
   /* Update temperature sensor measured value */
   log_d("Setting flow to %d", zb_flow);
-  
+
   esp_zb_lock_acquire(portMAX_DELAY);
   ret = esp_zb_zcl_set_attribute_val(
     _endpoint, ESP_ZB_ZCL_CLUSTER_ID_FLOW_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_VALUE_ID, &zb_flow, false
   );
   esp_zb_lock_release();
-  
+
   if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
     log_e("Failed to set flow value: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
     return false;
@@ -112,7 +112,7 @@ bool ZigbeeFlowSensor::report() {
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
   esp_zb_lock_release();
-  
+
   if (ret != ESP_OK) {
     log_e("Failed to send flow report: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;

libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp

@@ -27,12 +27,12 @@ bool ZigbeeOccupancySensor::setSensorType(uint8_t sensor_type) {
   esp_zb_attribute_list_t *occupancy_sens_cluster =
     esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_OCCUPANCY_SENSING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
   esp_err_t ret = esp_zb_cluster_update_attr(occupancy_sens_cluster, ESP_ZB_ZCL_ATTR_OCCUPANCY_SENSING_OCCUPANCY_SENSOR_TYPE_ID, (void *)&sensor_type);
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set sensor type: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
   ret = esp_zb_cluster_update_attr(occupancy_sens_cluster, ESP_ZB_ZCL_ATTR_OCCUPANCY_SENSING_OCCUPANCY_SENSOR_TYPE_BITMAP_ID, (void *)&sensor_type_bitmap);
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set sensor type bitmap: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
@@ -49,7 +49,7 @@ bool ZigbeeOccupancySensor::setOccupancy(bool occupied) {
     _endpoint, ESP_ZB_ZCL_CLUSTER_ID_OCCUPANCY_SENSING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_OCCUPANCY_SENSING_OCCUPANCY_ID, &occupied, false
   );
   esp_zb_lock_release();
-  if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
+  if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
     log_e("Failed to set occupancy: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
     return false;
   }
@@ -69,7 +69,7 @@ bool ZigbeeOccupancySensor::report() {
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
   esp_zb_lock_release();
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to send occupancy report: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }

libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp

@@ -26,12 +26,12 @@ bool ZigbeePressureSensor::setMinMaxValue(int16_t min, int16_t max) {
   esp_zb_attribute_list_t *pressure_measure_cluster =
     esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_PRESSURE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
   esp_err_t ret = esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MIN_VALUE_ID, (void *)&min);
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
   ret = esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MAX_VALUE_ID, (void *)&max);
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
@@ -42,7 +42,7 @@ bool ZigbeePressureSensor::setTolerance(uint16_t tolerance) {
   esp_zb_attribute_list_t *pressure_measure_cluster =
     esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_PRESSURE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
   esp_err_t ret = esp_zb_pressure_meas_cluster_add_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_TOLERANCE_ID, (void *)&tolerance);
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret));
   }
   return ret == ESP_OK;
@@ -66,7 +66,7 @@ bool ZigbeePressureSensor::setReporting(uint16_t min_interval, uint16_t max_inte
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_err_t ret = esp_zb_zcl_update_reporting_info(&reporting_info);
   esp_zb_lock_release();
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }
@@ -83,7 +83,7 @@ bool ZigbeePressureSensor::setPressure(int16_t pressure) {
     _endpoint, ESP_ZB_ZCL_CLUSTER_ID_PRESSURE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_VALUE_ID, &pressure, false
   );
   esp_zb_lock_release();
-  if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
+  if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
     log_e("Failed to set pressure: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
     return false;
   }
@@ -103,7 +103,7 @@ bool ZigbeePressureSensor::report() {
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
   esp_zb_lock_release();
-  if(ret != ESP_OK) {
+  if (ret != ESP_OK) {
     log_e("Failed to send pressure report: 0x%x: %s", ret, esp_err_to_name(ret));
     return false;
   }