Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 3bebb79

Browse files
pre-commit-ci-lite[bot]pre-commit-ci-lite[bot]
authoredMar 27, 2025··
ci(pre-commit): Apply automatic fixes
1 parent 8560ff3 commit 3bebb79

12 files changed

+108
-137
lines changed
 

‎libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -136,7 +136,7 @@ void loop() {
136136
// Optional set reset in factoryReset to false, to not restart device after erasing nvram, but set it to endless sleep manually instead
137137
Zigbee.factoryReset(false);
138138
Serial.println("Going to endless sleep, press RESET button or power off/on the device to wake up");
139-
esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);
139+
esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);
140140
esp_deep_sleep_start();
141141
}
142142
}

‎libraries/Zigbee/src/ZigbeeCore.cpp

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -102,11 +102,11 @@ bool ZigbeeCore::addEndpoint(ZigbeeEP *ep) {
102102
}
103103
esp_err_t ret = ESP_OK;
104104
if (ep->_device_id == ESP_ZB_HA_HOME_GATEWAY_DEVICE_ID) {
105-
ret = esp_zb_ep_list_add_gateway_ep(_zb_ep_list, ep->_cluster_list, ep->_ep_config);
105+
ret = esp_zb_ep_list_add_gateway_ep(_zb_ep_list, ep->_cluster_list, ep->_ep_config);
106106
} else {
107107
ret = esp_zb_ep_list_add_ep(_zb_ep_list, ep->_cluster_list, ep->_ep_config);
108108
}
109-
if(ret != ESP_OK) {
109+
if (ret != ESP_OK) {
110110
log_e("Failed to add endpoint: 0x%x: %s", ret, esp_err_to_name(ret));
111111
return false;
112112
}
@@ -384,8 +384,7 @@ void ZigbeeCore::factoryReset(bool restart) {
384384
if (restart) {
385385
log_v("Factory resetting Zigbee stack, device will reboot");
386386
esp_zb_factory_reset();
387-
}
388-
else {
387+
} else {
389388
log_v("Factory resetting Zigbee NVRAM to factory default");
390389
log_w("The device will not reboot, to take effect please reboot the device manually");
391390
esp_zb_zcl_reset_nvram_to_factory_default();

‎libraries/Zigbee/src/ZigbeeEP.cpp

Lines changed: 41 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,7 @@ bool ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) {
6060
log_e("Failed to set manufacturer: 0x%x: %s", ret_name, esp_err_to_name(ret_name));
6161
}
6262
esp_err_t ret_model = esp_zb_basic_cluster_add_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MODEL_IDENTIFIER_ID, (void *)zb_model);
63-
if(ret_model != ESP_OK) {
63+
if (ret_model != ESP_OK) {
6464
log_e("Failed to set model: 0x%x: %s", ret_model, esp_err_to_name(ret_model));
6565
}
6666
delete[] zb_name;
@@ -112,7 +112,7 @@ bool ZigbeeEP::setBatteryPercentage(uint8_t percentage) {
112112
false
113113
);
114114
esp_zb_lock_release();
115-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
115+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
116116
log_e("Failed to set battery percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
117117
return false;
118118
}
@@ -133,7 +133,7 @@ bool ZigbeeEP::reportBatteryPercentage() {
133133
esp_zb_lock_acquire(portMAX_DELAY);
134134
esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
135135
esp_zb_lock_release();
136-
if(ret != ESP_OK) {
136+
if (ret != ESP_OK) {
137137
log_e("Failed to report battery percentage: 0x%x: %s", ret, esp_err_to_name(ret));
138138
return false;
139139
}
@@ -321,7 +321,7 @@ bool ZigbeeEP::setTime(tm time) {
321321
esp_zb_lock_acquire(portMAX_DELAY);
322322
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);
323323
esp_zb_lock_release();
324-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
324+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
325325
log_e("Failed to set time: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
326326
return false;
327327
}
@@ -332,9 +332,10 @@ bool ZigbeeEP::setTimezone(int32_t gmt_offset) {
332332
esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS;
333333
log_d("Setting timezone to %d", gmt_offset);
334334
esp_zb_lock_acquire(portMAX_DELAY);
335-
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);
335+
ret =
336+
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);
336337
esp_zb_lock_release();
337-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
338+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
338339
log_e("Failed to set timezone: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
339340
return false;
340341
}
@@ -528,76 +529,42 @@ void ZigbeeEP::requestOTAUpdate() {
528529
esp_zb_lock_release();
529530
}
530531

531-
const char* ZigbeeEP::esp_zb_zcl_status_to_name(esp_zb_zcl_status_t status) {
532+
const char *ZigbeeEP::esp_zb_zcl_status_to_name(esp_zb_zcl_status_t status) {
532533
switch (status) {
533-
case ESP_ZB_ZCL_STATUS_SUCCESS:
534-
return "Success";
535-
case ESP_ZB_ZCL_STATUS_FAIL:
536-
return "Fail";
537-
case ESP_ZB_ZCL_STATUS_NOT_AUTHORIZED:
538-
return "Not authorized";
539-
case ESP_ZB_ZCL_STATUS_MALFORMED_CMD:
540-
return "Malformed command";
541-
case ESP_ZB_ZCL_STATUS_UNSUP_CLUST_CMD:
542-
return "Unsupported cluster command";
543-
case ESP_ZB_ZCL_STATUS_UNSUP_GEN_CMD:
544-
return "Unsupported general command";
545-
case ESP_ZB_ZCL_STATUS_UNSUP_MANUF_CLUST_CMD:
546-
return "Unsupported manufacturer cluster command";
547-
case ESP_ZB_ZCL_STATUS_UNSUP_MANUF_GEN_CMD:
548-
return "Unsupported manufacturer general command";
549-
case ESP_ZB_ZCL_STATUS_INVALID_FIELD:
550-
return "Invalid field";
551-
case ESP_ZB_ZCL_STATUS_UNSUP_ATTRIB:
552-
return "Unsupported attribute";
553-
case ESP_ZB_ZCL_STATUS_INVALID_VALUE:
554-
return "Invalid value";
555-
case ESP_ZB_ZCL_STATUS_READ_ONLY:
556-
return "Read only";
557-
case ESP_ZB_ZCL_STATUS_INSUFF_SPACE:
558-
return "Insufficient space";
559-
case ESP_ZB_ZCL_STATUS_DUPE_EXISTS:
560-
return "Duplicate exists";
561-
case ESP_ZB_ZCL_STATUS_NOT_FOUND:
562-
return "Not found";
563-
case ESP_ZB_ZCL_STATUS_UNREPORTABLE_ATTRIB:
564-
return "Unreportable attribute";
565-
case ESP_ZB_ZCL_STATUS_INVALID_TYPE:
566-
return "Invalid type";
567-
case ESP_ZB_ZCL_STATUS_WRITE_ONLY:
568-
return "Write only";
569-
case ESP_ZB_ZCL_STATUS_INCONSISTENT:
570-
return "Inconsistent";
571-
case ESP_ZB_ZCL_STATUS_ACTION_DENIED:
572-
return "Action denied";
573-
case ESP_ZB_ZCL_STATUS_TIMEOUT:
574-
return "Timeout";
575-
case ESP_ZB_ZCL_STATUS_ABORT:
576-
return "Abort";
577-
case ESP_ZB_ZCL_STATUS_INVALID_IMAGE:
578-
return "Invalid OTA upgrade image";
579-
case ESP_ZB_ZCL_STATUS_WAIT_FOR_DATA:
580-
return "Server does not have data block available yet";
581-
case ESP_ZB_ZCL_STATUS_NO_IMAGE_AVAILABLE:
582-
return "No image available";
583-
case ESP_ZB_ZCL_STATUS_REQUIRE_MORE_IMAGE:
584-
return "Require more image";
585-
case ESP_ZB_ZCL_STATUS_NOTIFICATION_PENDING:
586-
return "Notification pending";
587-
case ESP_ZB_ZCL_STATUS_HW_FAIL:
588-
return "Hardware failure";
589-
case ESP_ZB_ZCL_STATUS_SW_FAIL:
590-
return "Software failure";
591-
case ESP_ZB_ZCL_STATUS_CALIB_ERR:
592-
return "Calibration error";
593-
case ESP_ZB_ZCL_STATUS_UNSUP_CLUST:
594-
return "Cluster is not found on the target endpoint";
595-
case ESP_ZB_ZCL_STATUS_LIMIT_REACHED:
596-
return "Limit reached";
597-
default:
598-
return "Unknown status";
534+
case ESP_ZB_ZCL_STATUS_SUCCESS: return "Success";
535+
case ESP_ZB_ZCL_STATUS_FAIL: return "Fail";
536+
case ESP_ZB_ZCL_STATUS_NOT_AUTHORIZED: return "Not authorized";
537+
case ESP_ZB_ZCL_STATUS_MALFORMED_CMD: return "Malformed command";
538+
case ESP_ZB_ZCL_STATUS_UNSUP_CLUST_CMD: return "Unsupported cluster command";
539+
case ESP_ZB_ZCL_STATUS_UNSUP_GEN_CMD: return "Unsupported general command";
540+
case ESP_ZB_ZCL_STATUS_UNSUP_MANUF_CLUST_CMD: return "Unsupported manufacturer cluster command";
541+
case ESP_ZB_ZCL_STATUS_UNSUP_MANUF_GEN_CMD: return "Unsupported manufacturer general command";
542+
case ESP_ZB_ZCL_STATUS_INVALID_FIELD: return "Invalid field";
543+
case ESP_ZB_ZCL_STATUS_UNSUP_ATTRIB: return "Unsupported attribute";
544+
case ESP_ZB_ZCL_STATUS_INVALID_VALUE: return "Invalid value";
545+
case ESP_ZB_ZCL_STATUS_READ_ONLY: return "Read only";
546+
case ESP_ZB_ZCL_STATUS_INSUFF_SPACE: return "Insufficient space";
547+
case ESP_ZB_ZCL_STATUS_DUPE_EXISTS: return "Duplicate exists";
548+
case ESP_ZB_ZCL_STATUS_NOT_FOUND: return "Not found";
549+
case ESP_ZB_ZCL_STATUS_UNREPORTABLE_ATTRIB: return "Unreportable attribute";
550+
case ESP_ZB_ZCL_STATUS_INVALID_TYPE: return "Invalid type";
551+
case ESP_ZB_ZCL_STATUS_WRITE_ONLY: return "Write only";
552+
case ESP_ZB_ZCL_STATUS_INCONSISTENT: return "Inconsistent";
553+
case ESP_ZB_ZCL_STATUS_ACTION_DENIED: return "Action denied";
554+
case ESP_ZB_ZCL_STATUS_TIMEOUT: return "Timeout";
555+
case ESP_ZB_ZCL_STATUS_ABORT: return "Abort";
556+
case ESP_ZB_ZCL_STATUS_INVALID_IMAGE: return "Invalid OTA upgrade image";
557+
case ESP_ZB_ZCL_STATUS_WAIT_FOR_DATA: return "Server does not have data block available yet";
558+
case ESP_ZB_ZCL_STATUS_NO_IMAGE_AVAILABLE: return "No image available";
559+
case ESP_ZB_ZCL_STATUS_REQUIRE_MORE_IMAGE: return "Require more image";
560+
case ESP_ZB_ZCL_STATUS_NOTIFICATION_PENDING: return "Notification pending";
561+
case ESP_ZB_ZCL_STATUS_HW_FAIL: return "Hardware failure";
562+
case ESP_ZB_ZCL_STATUS_SW_FAIL: return "Software failure";
563+
case ESP_ZB_ZCL_STATUS_CALIB_ERR: return "Calibration error";
564+
case ESP_ZB_ZCL_STATUS_UNSUP_CLUST: return "Cluster is not found on the target endpoint";
565+
case ESP_ZB_ZCL_STATUS_LIMIT_REACHED: return "Limit reached";
566+
default: return "Unknown status";
599567
}
600568
}
601569

602-
603570
#endif // CONFIG_ZB_ENABLED

‎libraries/Zigbee/src/ZigbeeEP.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -146,8 +146,8 @@ class ZigbeeEP {
146146

147147
protected:
148148
// Convert ZCL status to name
149-
const char *esp_zb_zcl_status_to_name(esp_zb_zcl_status_t status);
150-
149+
const char *esp_zb_zcl_status_to_name(esp_zb_zcl_status_t status);
150+
151151
uint8_t _endpoint;
152152
esp_zb_ha_standard_devices_t _device_id;
153153
esp_zb_endpoint_config_t _ep_config;

‎libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -30,12 +30,12 @@ bool ZigbeeCarbonDioxideSensor::setMinMaxValue(float min, float max) {
3030
esp_zb_attribute_list_t *carbon_dioxide_measure_cluster =
3131
esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_CARBON_DIOXIDE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
3232
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);
33-
if(ret != ESP_OK) {
33+
if (ret != ESP_OK) {
3434
log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret));
3535
return false;
3636
}
3737
ret = esp_zb_cluster_update_attr(carbon_dioxide_measure_cluster, ESP_ZB_ZCL_ATTR_CARBON_DIOXIDE_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&zb_max);
38-
if(ret != ESP_OK) {
38+
if (ret != ESP_OK) {
3939
log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret));
4040
return false;
4141
}
@@ -49,7 +49,7 @@ bool ZigbeeCarbonDioxideSensor::setTolerance(float tolerance) {
4949
esp_err_t ret = esp_zb_carbon_dioxide_measurement_cluster_add_attr(
5050
carbon_dioxide_measure_cluster, ESP_ZB_ZCL_ATTR_CARBON_DIOXIDE_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance
5151
);
52-
if(ret != ESP_OK) {
52+
if (ret != ESP_OK) {
5353
log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret));
5454
return false;
5555
}
@@ -76,7 +76,7 @@ bool ZigbeeCarbonDioxideSensor::setReporting(uint16_t min_interval, uint16_t max
7676
esp_zb_lock_acquire(portMAX_DELAY);
7777
esp_err_t ret = esp_zb_zcl_update_reporting_info(&reporting_info);
7878
esp_zb_lock_release();
79-
if(ret != ESP_OK) {
79+
if (ret != ESP_OK) {
8080
log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret));
8181
return false;
8282
}
@@ -95,7 +95,7 @@ bool ZigbeeCarbonDioxideSensor::setCarbonDioxide(float carbon_dioxide) {
9595
&zb_carbon_dioxide, false
9696
);
9797
esp_zb_lock_release();
98-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
98+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
9999
log_e("Failed to set carbon dioxide: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
100100
return false;
101101
}
@@ -115,7 +115,7 @@ bool ZigbeeCarbonDioxideSensor::report() {
115115
esp_zb_lock_acquire(portMAX_DELAY);
116116
esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
117117
esp_zb_lock_release();
118-
if(ret != ESP_OK) {
118+
if (ret != ESP_OK) {
119119
log_e("Failed to send carbon dioxide report: 0x%x: %s", ret, esp_err_to_name(ret));
120120
return false;
121121
}

‎libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -28,12 +28,12 @@ bool ZigbeeFlowSensor::setMinMaxValue(float min, float max) {
2828
esp_zb_attribute_list_t *flow_measure_cluster =
2929
esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_FLOW_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
3030
esp_err_t ret = esp_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min);
31-
if(ret != ESP_OK) {
31+
if (ret != ESP_OK) {
3232
log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret));
3333
return false;
3434
}
3535
ret = esp_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max);
36-
if(ret != ESP_OK) {
36+
if (ret != ESP_OK) {
3737
log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret));
3838
return false;
3939
}
@@ -67,11 +67,11 @@ bool ZigbeeFlowSensor::setReporting(uint16_t min_interval, uint16_t max_interval
6767
reporting_info.u.send_info.delta.u16 = (uint16_t)(delta * 10); // Convert delta to ZCL uint16_t
6868
reporting_info.dst.profile_id = ESP_ZB_AF_HA_PROFILE_ID;
6969
reporting_info.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC;
70-
70+
7171
esp_zb_lock_acquire(portMAX_DELAY);
7272
esp_err_t ret = esp_zb_zcl_update_reporting_info(&reporting_info);
7373
esp_zb_lock_release();
74-
74+
7575
if (ret != ESP_OK) {
7676
log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret));
7777
return false;
@@ -85,13 +85,13 @@ bool ZigbeeFlowSensor::setFlow(float flow) {
8585
log_v("Updating flow sensor value...");
8686
/* Update temperature sensor measured value */
8787
log_d("Setting flow to %d", zb_flow);
88-
88+
8989
esp_zb_lock_acquire(portMAX_DELAY);
9090
ret = esp_zb_zcl_set_attribute_val(
9191
_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
9292
);
9393
esp_zb_lock_release();
94-
94+
9595
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
9696
log_e("Failed to set flow value: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
9797
return false;
@@ -112,7 +112,7 @@ bool ZigbeeFlowSensor::report() {
112112
esp_zb_lock_acquire(portMAX_DELAY);
113113
esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
114114
esp_zb_lock_release();
115-
115+
116116
if (ret != ESP_OK) {
117117
log_e("Failed to send flow report: 0x%x: %s", ret, esp_err_to_name(ret));
118118
return false;

‎libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -27,12 +27,12 @@ bool ZigbeeOccupancySensor::setSensorType(uint8_t sensor_type) {
2727
esp_zb_attribute_list_t *occupancy_sens_cluster =
2828
esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_OCCUPANCY_SENSING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
2929
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);
30-
if(ret != ESP_OK) {
30+
if (ret != ESP_OK) {
3131
log_e("Failed to set sensor type: 0x%x: %s", ret, esp_err_to_name(ret));
3232
return false;
3333
}
3434
ret = esp_zb_cluster_update_attr(occupancy_sens_cluster, ESP_ZB_ZCL_ATTR_OCCUPANCY_SENSING_OCCUPANCY_SENSOR_TYPE_BITMAP_ID, (void *)&sensor_type_bitmap);
35-
if(ret != ESP_OK) {
35+
if (ret != ESP_OK) {
3636
log_e("Failed to set sensor type bitmap: 0x%x: %s", ret, esp_err_to_name(ret));
3737
return false;
3838
}
@@ -49,7 +49,7 @@ bool ZigbeeOccupancySensor::setOccupancy(bool occupied) {
4949
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_OCCUPANCY_SENSING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_OCCUPANCY_SENSING_OCCUPANCY_ID, &occupied, false
5050
);
5151
esp_zb_lock_release();
52-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
52+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
5353
log_e("Failed to set occupancy: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
5454
return false;
5555
}
@@ -69,7 +69,7 @@ bool ZigbeeOccupancySensor::report() {
6969
esp_zb_lock_acquire(portMAX_DELAY);
7070
esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
7171
esp_zb_lock_release();
72-
if(ret != ESP_OK) {
72+
if (ret != ESP_OK) {
7373
log_e("Failed to send occupancy report: 0x%x: %s", ret, esp_err_to_name(ret));
7474
return false;
7575
}

‎libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -26,12 +26,12 @@ bool ZigbeePressureSensor::setMinMaxValue(int16_t min, int16_t max) {
2626
esp_zb_attribute_list_t *pressure_measure_cluster =
2727
esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_PRESSURE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
2828
esp_err_t ret = esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MIN_VALUE_ID, (void *)&min);
29-
if(ret != ESP_OK) {
29+
if (ret != ESP_OK) {
3030
log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret));
3131
return false;
3232
}
3333
ret = esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MAX_VALUE_ID, (void *)&max);
34-
if(ret != ESP_OK) {
34+
if (ret != ESP_OK) {
3535
log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret));
3636
return false;
3737
}
@@ -42,7 +42,7 @@ bool ZigbeePressureSensor::setTolerance(uint16_t tolerance) {
4242
esp_zb_attribute_list_t *pressure_measure_cluster =
4343
esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_PRESSURE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
4444
esp_err_t ret = esp_zb_pressure_meas_cluster_add_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_TOLERANCE_ID, (void *)&tolerance);
45-
if(ret != ESP_OK) {
45+
if (ret != ESP_OK) {
4646
log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret));
4747
}
4848
return ret == ESP_OK;
@@ -66,7 +66,7 @@ bool ZigbeePressureSensor::setReporting(uint16_t min_interval, uint16_t max_inte
6666
esp_zb_lock_acquire(portMAX_DELAY);
6767
esp_err_t ret = esp_zb_zcl_update_reporting_info(&reporting_info);
6868
esp_zb_lock_release();
69-
if(ret != ESP_OK) {
69+
if (ret != ESP_OK) {
7070
log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret));
7171
return false;
7272
}
@@ -83,7 +83,7 @@ bool ZigbeePressureSensor::setPressure(int16_t pressure) {
8383
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_PRESSURE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_VALUE_ID, &pressure, false
8484
);
8585
esp_zb_lock_release();
86-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
86+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
8787
log_e("Failed to set pressure: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
8888
return false;
8989
}
@@ -103,7 +103,7 @@ bool ZigbeePressureSensor::report() {
103103
esp_zb_lock_acquire(portMAX_DELAY);
104104
esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
105105
esp_zb_lock_release();
106-
if(ret != ESP_OK) {
106+
if (ret != ESP_OK) {
107107
log_e("Failed to send pressure report: 0x%x: %s", ret, esp_err_to_name(ret));
108108
return false;
109109
}

‎libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -23,12 +23,12 @@ bool ZigbeeTempSensor::setMinMaxValue(float min, float max) {
2323
esp_zb_attribute_list_t *temp_measure_cluster =
2424
esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
2525
esp_err_t ret = esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min);
26-
if(ret != ESP_OK) {
26+
if (ret != ESP_OK) {
2727
log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret));
2828
return false;
2929
}
3030
ret = esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max);
31-
if(ret != ESP_OK) {
31+
if (ret != ESP_OK) {
3232
log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret));
3333
return false;
3434
}
@@ -41,7 +41,7 @@ bool ZigbeeTempSensor::setTolerance(float tolerance) {
4141
esp_zb_attribute_list_t *temp_measure_cluster =
4242
esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
4343
esp_err_t ret = esp_zb_temperature_meas_cluster_add_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance);
44-
if(ret != ESP_OK) {
44+
if (ret != ESP_OK) {
4545
log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret));
4646
return false;
4747
}
@@ -66,7 +66,7 @@ bool ZigbeeTempSensor::setReporting(uint16_t min_interval, uint16_t max_interval
6666
esp_zb_lock_acquire(portMAX_DELAY);
6767
esp_err_t ret = esp_zb_zcl_update_reporting_info(&reporting_info);
6868
esp_zb_lock_release();
69-
if(ret != ESP_OK) {
69+
if (ret != ESP_OK) {
7070
log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret));
7171
return false;
7272
}
@@ -84,7 +84,7 @@ bool ZigbeeTempSensor::setTemperature(float temperature) {
8484
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_VALUE_ID, &zb_temperature, false
8585
);
8686
esp_zb_lock_release();
87-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
87+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
8888
log_e("Failed to set temperature: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
8989
return false;
9090
}
@@ -104,7 +104,7 @@ bool ZigbeeTempSensor::reportTemperature() {
104104
esp_zb_lock_acquire(portMAX_DELAY);
105105
esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
106106
esp_zb_lock_release();
107-
if(ret != ESP_OK) {
107+
if (ret != ESP_OK) {
108108
log_e("Failed to send temperature report: 0x%x: %s", ret, esp_err_to_name(ret));
109109
return false;
110110
}
@@ -138,7 +138,7 @@ bool ZigbeeTempSensor::setHumidity(float humidity) {
138138
false
139139
);
140140
esp_zb_lock_release();
141-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
141+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
142142
log_e("Failed to set humidity: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
143143
return false;
144144
}
@@ -158,7 +158,7 @@ bool ZigbeeTempSensor::reportHumidity() {
158158
esp_zb_lock_acquire(portMAX_DELAY);
159159
esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
160160
esp_zb_lock_release();
161-
if(ret != ESP_OK) {
161+
if (ret != ESP_OK) {
162162
log_e("Failed to send humidity report: 0x%x: %s", ret, esp_err_to_name(ret));
163163
return false;
164164
}
@@ -184,8 +184,8 @@ bool ZigbeeTempSensor::setHumidityReporting(uint16_t min_interval, uint16_t max_
184184
esp_zb_lock_acquire(portMAX_DELAY);
185185
esp_err_t ret = esp_zb_zcl_update_reporting_info(&reporting_info);
186186
esp_zb_lock_release();
187-
if(ret != ESP_OK) {
188-
log_e("Failed to set humidity reporting: 0x%x: %s", ret, esp_err_to_name(ret) );
187+
if (ret != ESP_OK) {
188+
log_e("Failed to set humidity reporting: 0x%x: %s", ret, esp_err_to_name(ret));
189189
return false;
190190
}
191191
return true;

‎libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ bool ZigbeeVibrationSensor::setVibration(bool sensed) {
3838
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_IAS_ZONE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_IAS_ZONE_ZONESTATUS_ID, &vibration, false
3939
);
4040
esp_zb_lock_release();
41-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
41+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
4242
log_e("Failed to set vibration status: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
4343
return false;
4444
}

‎libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -34,12 +34,12 @@ bool ZigbeeWindSpeedSensor::setMinMaxValue(float min, float max) {
3434
esp_zb_attribute_list_t *windspeed_measure_cluster =
3535
esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
3636
esp_err_t ret = esp_zb_cluster_update_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&zb_min);
37-
if(ret != ESP_OK) {
37+
if (ret != ESP_OK) {
3838
log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret));
3939
return false;
4040
}
4141
ret = esp_zb_cluster_update_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&zb_max);
42-
if(ret != ESP_OK) {
42+
if (ret != ESP_OK) {
4343
log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret));
4444
return false;
4545
}
@@ -51,8 +51,9 @@ bool ZigbeeWindSpeedSensor::setTolerance(float tolerance) {
5151
uint16_t zb_tolerance = zb_windspeed_to_u16(tolerance);
5252
esp_zb_attribute_list_t *windspeed_measure_cluster =
5353
esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
54-
esp_err_t ret = esp_zb_wind_speed_measurement_cluster_add_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance);
55-
if(ret != ESP_OK) {
54+
esp_err_t ret =
55+
esp_zb_wind_speed_measurement_cluster_add_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance);
56+
if (ret != ESP_OK) {
5657
log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret));
5758
return false;
5859
}
@@ -77,7 +78,7 @@ bool ZigbeeWindSpeedSensor::setReporting(uint16_t min_interval, uint16_t max_int
7778
esp_zb_lock_acquire(portMAX_DELAY);
7879
esp_err_t ret = esp_zb_zcl_update_reporting_info(&reporting_info);
7980
esp_zb_lock_release();
80-
if(ret != ESP_OK) {
81+
if (ret != ESP_OK) {
8182
log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret));
8283
return false;
8384
}
@@ -96,7 +97,7 @@ bool ZigbeeWindSpeedSensor::setWindSpeed(float windspeed) {
9697
&zb_windspeed, false
9798
);
9899
esp_zb_lock_release();
99-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
100+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
100101
log_e("Failed to set wind speed: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
101102
return false;
102103
}
@@ -116,7 +117,7 @@ bool ZigbeeWindSpeedSensor::reportWindSpeed() {
116117
esp_zb_lock_acquire(portMAX_DELAY);
117118
esp_err_t ret = esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd);
118119
esp_zb_lock_release();
119-
if(ret != ESP_OK) {
120+
if (ret != ESP_OK) {
120121
log_e("Failed to send wind speed report: 0x%x: %s", ret, esp_err_to_name(ret));
121122
return false;
122123
}

‎libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp

Lines changed: 19 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -135,12 +135,14 @@ bool ZigbeeWindowCovering::setLimits(
135135

136136
esp_zb_attribute_list_t *window_covering_cluster =
137137
esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE);
138-
esp_err_t ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_LIFT_ID, (void *)&_installed_open_limit_lift);
138+
esp_err_t ret =
139+
esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_LIFT_ID, (void *)&_installed_open_limit_lift);
139140
if (ret != ESP_OK) {
140141
log_e("Failed to set installed open limit lift: 0x%x: %s", ret, esp_err_to_name(ret));
141142
return false;
142143
}
143-
ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_LIFT_ID, (void *)&_installed_closed_limit_lift);
144+
ret =
145+
esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_LIFT_ID, (void *)&_installed_closed_limit_lift);
144146
if (ret != ESP_OK) {
145147
log_e("Failed to set installed closed limit lift: 0x%x: %s", ret, esp_err_to_name(ret));
146148
return false;
@@ -150,12 +152,14 @@ bool ZigbeeWindowCovering::setLimits(
150152
log_e("Failed to set installed open limit tilt: 0x%x: %s", ret, esp_err_to_name(ret));
151153
return false;
152154
}
153-
ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_TILT_ID, (void *)&_installed_closed_limit_tilt);
155+
ret =
156+
esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_TILT_ID, (void *)&_installed_closed_limit_tilt);
154157
if (ret != ESP_OK) {
155158
log_e("Failed to set installed closed limit tilt: 0x%x: %s", ret, esp_err_to_name(ret));
156159
return false;
157160
}
158-
ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_LIFT_ID, (void *)&_physical_closed_limit_lift);
161+
ret =
162+
esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_LIFT_ID, (void *)&_physical_closed_limit_lift);
159163
if (ret != ESP_OK) {
160164
log_e("Failed to set physical closed limit lift: 0x%x: %s", ret, esp_err_to_name(ret));
161165
return false;
@@ -281,15 +285,15 @@ bool ZigbeeWindowCovering::setLiftPosition(uint16_t lift_position) {
281285
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_ID,
282286
&_current_lift_position, false
283287
);
284-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
288+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
285289
log_e("Failed to set lift position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
286290
goto unlock_and_return;
287291
}
288292
ret = esp_zb_zcl_set_attribute_val(
289293
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE_ID,
290294
&_current_lift_percentage, false
291295
);
292-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
296+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
293297
log_e("Failed to set lift percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
294298
goto unlock_and_return;
295299
}
@@ -304,21 +308,21 @@ bool ZigbeeWindowCovering::setLiftPercentage(uint8_t lift_percentage) {
304308
_current_lift_percentage = lift_percentage;
305309
_current_lift_position = _installed_open_limit_lift + ((_installed_closed_limit_lift - _installed_open_limit_lift) * lift_percentage) / 100;
306310
log_v("Updating window covering lift percentage to %d%% (%d)", _current_lift_percentage, _current_lift_position);
307-
311+
308312
esp_zb_lock_acquire(portMAX_DELAY);
309313
ret = esp_zb_zcl_set_attribute_val(
310314
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_ID,
311315
&_current_lift_position, false
312316
);
313-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
317+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
314318
log_e("Failed to set lift position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
315319
goto unlock_and_return;
316320
}
317321
ret = esp_zb_zcl_set_attribute_val(
318322
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE_ID,
319323
&_current_lift_percentage, false
320324
);
321-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
325+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
322326
log_e("Failed to set lift percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
323327
goto unlock_and_return;
324328
}
@@ -334,21 +338,21 @@ bool ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) {
334338
_current_tilt_percentage = ((tilt_position - _installed_open_limit_tilt) * 100) / (_installed_closed_limit_tilt - _installed_open_limit_tilt);
335339

336340
log_v("Updating window covering tilt position to %d (%d%)", _current_tilt_position, _current_tilt_percentage);
337-
341+
338342
esp_zb_lock_acquire(portMAX_DELAY);
339343
ret = esp_zb_zcl_set_attribute_val(
340344
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_ID,
341345
&_current_tilt_position, false
342346
);
343-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
347+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
344348
log_e("Failed to set tilt position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
345349
goto unlock_and_return;
346350
}
347351
ret = esp_zb_zcl_set_attribute_val(
348352
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE_ID,
349353
&_current_tilt_percentage, false
350354
);
351-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
355+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
352356
log_e("Failed to set tilt percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
353357
goto unlock_and_return;
354358
}
@@ -364,21 +368,21 @@ bool ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) {
364368
_current_tilt_position = _installed_open_limit_tilt + ((_installed_closed_limit_tilt - _installed_open_limit_tilt) * tilt_percentage) / 100;
365369

366370
log_v("Updating window covering tilt percentage to %d%% (%d)", _current_tilt_percentage, _current_tilt_position);
367-
371+
368372
esp_zb_lock_acquire(portMAX_DELAY);
369373
ret = esp_zb_zcl_set_attribute_val(
370374
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_ID,
371375
&_current_tilt_position, false
372376
);
373-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
377+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
374378
log_e("Failed to set tilt position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
375379
goto unlock_and_return;
376380
}
377381
ret = esp_zb_zcl_set_attribute_val(
378382
_endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE_ID,
379383
&_current_tilt_percentage, false
380384
);
381-
if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
385+
if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) {
382386
log_e("Failed to set tilt percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret));
383387
goto unlock_and_return;
384388
}

0 commit comments

Comments
 (0)
Please sign in to comment.