From 508b6fab6cb90977e2f16ff8ab905304f9852705 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 20 Mar 2025 18:10:55 +0100 Subject: [PATCH 01/15] feat(zigbee): Add checks on setting attrs and commands --- libraries/Zigbee/src/ZigbeeEP.cpp | 64 ++++++--- libraries/Zigbee/src/ZigbeeEP.h | 10 +- libraries/Zigbee/src/ep/ZigbeeAnalog.cpp | 71 +++++++--- libraries/Zigbee/src/ep/ZigbeeAnalog.h | 14 +- .../src/ep/ZigbeeCarbonDioxideSensor.cpp | 47 +++++-- .../Zigbee/src/ep/ZigbeeCarbonDioxideSensor.h | 10 +- .../src/ep/ZigbeeColorDimmableLight.cpp | 40 +++--- .../Zigbee/src/ep/ZigbeeColorDimmableLight.h | 12 +- .../Zigbee/src/ep/ZigbeeContactSwitch.cpp | 31 ++-- libraries/Zigbee/src/ep/ZigbeeContactSwitch.h | 6 +- .../Zigbee/src/ep/ZigbeeDimmableLight.cpp | 21 +-- libraries/Zigbee/src/ep/ZigbeeDimmableLight.h | 7 +- .../Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp | 32 ++++- .../Zigbee/src/ep/ZigbeeDoorWindowHandle.h | 6 +- libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp | 64 +++++++-- libraries/Zigbee/src/ep/ZigbeeFlowSensor.h | 10 +- libraries/Zigbee/src/ep/ZigbeeLight.cpp | 11 +- libraries/Zigbee/src/ep/ZigbeeLight.h | 2 +- .../Zigbee/src/ep/ZigbeeOccupancySensor.cpp | 31 +++- .../Zigbee/src/ep/ZigbeeOccupancySensor.h | 6 +- .../Zigbee/src/ep/ZigbeePressureSensor.cpp | 48 +++++-- .../Zigbee/src/ep/ZigbeePressureSensor.h | 10 +- libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp | 81 ++++++++--- libraries/Zigbee/src/ep/ZigbeeTempSensor.h | 18 +-- .../Zigbee/src/ep/ZigbeeVibrationSensor.cpp | 11 +- .../Zigbee/src/ep/ZigbeeVibrationSensor.h | 2 +- .../Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp | 48 +++++-- .../Zigbee/src/ep/ZigbeeWindSpeedSensor.h | 10 +- .../Zigbee/src/ep/ZigbeeWindowCovering.cpp | 132 +++++++++++++----- .../Zigbee/src/ep/ZigbeeWindowCovering.h | 16 +-- 30 files changed, 614 insertions(+), 257 deletions(-) diff --git a/libraries/Zigbee/src/ZigbeeEP.cpp b/libraries/Zigbee/src/ZigbeeEP.cpp index 7052a558192..5a03993db91 100644 --- a/libraries/Zigbee/src/ZigbeeEP.cpp +++ b/libraries/Zigbee/src/ZigbeeEP.cpp @@ -32,12 +32,12 @@ void ZigbeeEP::setVersion(uint8_t version) { _ep_config.app_device_version = version; } -void ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) { +bool ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) { // Convert manufacturer to ZCL string size_t length = strlen(name); if (length > 32) { log_e("Manufacturer name is too long"); - return; + return false; } // Allocate a new array of size length + 2 (1 for the length, 1 for null terminator) char *zb_name = new char[length + 2]; @@ -53,7 +53,7 @@ void ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) { if (length > 32) { log_e("Model name is too long"); delete[] zb_name; - return; + return false; } char *zb_model = new char[length + 2]; zb_model[0] = static_cast(length); @@ -62,8 +62,13 @@ void ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) { // Get the basic cluster and update the manufacturer and model attributes esp_zb_attribute_list_t *basic_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_BASIC, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_basic_cluster_add_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID, (void *)zb_name); - esp_zb_basic_cluster_add_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MODEL_IDENTIFIER_ID, (void *)zb_model); + esp_err_t ret_manufacturer = esp_zb_basic_cluster_add_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID, (void *)zb_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_manufacturer != ESP_OK || ret_model != ESP_OK) { + log_e("Failed to set manufacturer and model"); + return false; + } + return true; } void ZigbeeEP::setPowerSource(zb_power_source_t power_source, uint8_t battery_percentage) { @@ -72,6 +77,9 @@ void ZigbeeEP::setPowerSource(zb_power_source_t power_source, uint8_t battery_pe if (power_source == ZB_POWER_SOURCE_BATTERY) { // Add power config cluster and battery percentage attribute + if (battery_percentage > 100) { + battery_percentage = 100; + } battery_percentage = battery_percentage * 2; esp_zb_attribute_list_t *power_config_cluster = esp_zb_zcl_attr_list_create(ESP_ZB_ZCL_CLUSTER_ID_POWER_CONFIG); esp_zb_power_config_cluster_add_attr(power_config_cluster, ESP_ZB_ZCL_ATTR_POWER_CONFIG_BATTERY_PERCENTAGE_REMAINING_ID, (void *)&battery_percentage); @@ -80,20 +88,26 @@ void ZigbeeEP::setPowerSource(zb_power_source_t power_source, uint8_t battery_pe _power_source = power_source; } -void ZigbeeEP::setBatteryPercentage(uint8_t percentage) { +bool ZigbeeEP::setBatteryPercentage(uint8_t percentage) { // 100% = 200 in decimal, 0% = 0 // Convert percentage to 0-200 range + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; if (percentage > 100) { percentage = 100; } percentage = percentage * 2; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_POWER_CONFIG, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_POWER_CONFIG_BATTERY_PERCENTAGE_REMAINING_ID, &percentage, false ); esp_zb_lock_release(); + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set battery percentage"); + return false; + } log_v("Battery percentage updated"); + return true; } void ZigbeeEP::reportBatteryPercentage() { @@ -107,9 +121,14 @@ void ZigbeeEP::reportBatteryPercentage() { report_attr_cmd.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd); + 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 report battery percentage"); + return false; + } log_v("Battery percentage reported"); + return true; } char *ZigbeeEP::readManufacturer(uint8_t endpoint, uint16_t short_addr, esp_zb_ieee_addr_t ieee_addr) { @@ -260,18 +279,31 @@ void ZigbeeEP::addTimeCluster(tm time, int32_t gmt_offset) { esp_zb_cluster_list_add_time_cluster(_cluster_list, time_cluster_client, ESP_ZB_ZCL_CLUSTER_CLIENT_ROLE); } -void ZigbeeEP::setTime(tm time) { +bool ZigbeeEP::setTime(tm time) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; time_t utc_time = mktime(&time); log_d("Setting time to %lld", utc_time); esp_zb_lock_acquire(portMAX_DELAY); - 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); + 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) { + log_e("Failed to set time"); + return false; + } + return true; } -void ZigbeeEP::setTimezone(int32_t gmt_offset) { +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); - 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) { + log_e("Failed to set timezone"); + return false; + } + return true; } tm ZigbeeEP::getTime(uint8_t endpoint, int32_t short_addr, esp_zb_ieee_addr_t ieee_addr) { @@ -410,11 +442,11 @@ void ZigbeeEP::addOTAClient( 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_zb_ota_cluster_add_attr(ota_cluster, ESP_ZB_ZCL_ATTR_OTA_UPGRADE_CLIENT_DATA_ID, (void *)&variable_config); + esp_zb_ota_cluster_add_attr(ota_cluster, ESP_ZB_ZCL_ATTR_OTA_UPGRADE_SERVER_ADDR_ID, (void *)&ota_upgrade_server_addr); + 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)); + 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) { diff --git a/libraries/Zigbee/src/ZigbeeEP.h b/libraries/Zigbee/src/ZigbeeEP.h index 0a4e3e9d252..32be6d9b49f 100644 --- a/libraries/Zigbee/src/ZigbeeEP.h +++ b/libraries/Zigbee/src/ZigbeeEP.h @@ -70,7 +70,7 @@ class ZigbeeEP { } // Set Manufacturer name and model - void setManufacturerAndModel(const char *name, const char *model); + bool setManufacturerAndModel(const char *name, const char *model); // Methods to read manufacturer and model name from selected endpoint and short address char *readManufacturer(uint8_t endpoint, uint16_t short_addr, esp_zb_ieee_addr_t ieee_addr); @@ -78,13 +78,13 @@ class ZigbeeEP { // Set Power source and battery percentage for battery powered devices void setPowerSource(zb_power_source_t power_source, uint8_t percentage = 255); - void setBatteryPercentage(uint8_t percentage); - void reportBatteryPercentage(); + bool setBatteryPercentage(uint8_t percentage); + bool reportBatteryPercentage(); // Set time void addTimeCluster(tm time = {}, int32_t gmt_offset = 0); // gmt offset in seconds - void setTime(tm time); - void setTimezone(int32_t gmt_offset); + bool setTime(tm time); + bool setTimezone(int32_t gmt_offset); // Get time from Coordinator or specific endpoint (blocking until response) struct tm getTime(uint8_t endpoint = 1, int32_t short_addr = 0x0000, esp_zb_ieee_addr_t ieee_addr = {0}); diff --git a/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp b/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp index 417eeb6d98c..9d085694624 100644 --- a/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp @@ -20,19 +20,34 @@ ZigbeeAnalog::ZigbeeAnalog(uint8_t endpoint) : ZigbeeEP(endpoint) { _ep_config = {.endpoint = _endpoint, .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID, .app_device_id = ESP_ZB_HA_SIMPLE_SENSOR_DEVICE_ID, .app_device_version = 0}; } -void ZigbeeAnalog::addAnalogValue() { - esp_zb_cluster_list_add_analog_value_cluster(_cluster_list, esp_zb_analog_value_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); +bool ZigbeeAnalog::addAnalogValue() { + esp_err_t ret = esp_zb_cluster_list_add_analog_value_cluster(_cluster_list, esp_zb_analog_value_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); + if (ret != ESP_OK) { + log_e("Failed to add Analog Value cluster"); + return false; + } _analog_clusters |= ANALOG_VALUE; + return true; } -void ZigbeeAnalog::addAnalogInput() { - esp_zb_cluster_list_add_analog_input_cluster(_cluster_list, esp_zb_analog_input_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); +bool ZigbeeAnalog::addAnalogInput() { + esp_err_t ret = esp_zb_cluster_list_add_analog_input_cluster(_cluster_list, esp_zb_analog_input_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); + if (ret != ESP_OK) { + log_e("Failed to add Analog Input cluster"); + return false; + } _analog_clusters |= ANALOG_INPUT; + return true; } -void ZigbeeAnalog::addAnalogOutput() { - esp_zb_cluster_list_add_analog_output_cluster(_cluster_list, esp_zb_analog_output_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); +bool ZigbeeAnalog::addAnalogOutput() { + esp_err_t ret = esp_zb_cluster_list_add_analog_output_cluster(_cluster_list, esp_zb_analog_output_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); + if (ret != ESP_OK) { + log_e("Failed to add Analog Output cluster"); + return false; + } _analog_clusters |= ANALOG_OUTPUT; + return true; } //set attribute method -> method overridden in child class @@ -57,35 +72,45 @@ void ZigbeeAnalog::analogOutputChanged(float analog_output) { } } -void ZigbeeAnalog::setAnalogValue(float analog) { +bool ZigbeeAnalog::setAnalogValue(float analog) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; if (!(_analog_clusters & ANALOG_VALUE)) { log_e("Analog Value cluster not added"); - return; + return false; } - // float zb_analog = analog; log_d("Setting analog value to %.1f", analog); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_ANALOG_VALUE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_ANALOG_VALUE_PRESENT_VALUE_ID, &analog, false ); esp_zb_lock_release(); + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set analog value"); + return false; + } + return true; } -void ZigbeeAnalog::setAnalogInput(float analog) { +bool ZigbeeAnalog::setAnalogInput(float analog) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; if (!(_analog_clusters & ANALOG_INPUT)) { log_e("Analog Input cluster not added"); - return; + return false; } - // float zb_analog = analog; log_d("Setting analog input to %.1f", analog); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_ANALOG_INPUT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_ANALOG_INPUT_PRESENT_VALUE_ID, &analog, false ); esp_zb_lock_release(); + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set analog input"); + return false; + } + return true; } -void ZigbeeAnalog::reportAnalogInput() { +bool ZigbeeAnalog::reportAnalogInput() { /* Send report attributes command */ esp_zb_zcl_report_attr_cmd_t report_attr_cmd; report_attr_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; @@ -96,12 +121,17 @@ void ZigbeeAnalog::reportAnalogInput() { report_attr_cmd.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd); + 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 Analog Input report"); + return false; + } log_v("Analog Input report sent"); + return true; } -void ZigbeeAnalog::setAnalogInputReporting(uint16_t min_interval, uint16_t max_interval, float delta) { +bool ZigbeeAnalog::setAnalogInputReporting(uint16_t min_interval, uint16_t max_interval, float delta) { esp_zb_zcl_reporting_info_t reporting_info; memset(&reporting_info, 0, sizeof(esp_zb_zcl_reporting_info_t)); reporting_info.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_SRV; @@ -118,8 +148,13 @@ void ZigbeeAnalog::setAnalogInputReporting(uint16_t min_interval, uint16_t max_i reporting_info.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_update_reporting_info(&reporting_info); + 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 Analog Input reporting"); + return false; + } + return true; } #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeAnalog.h b/libraries/Zigbee/src/ep/ZigbeeAnalog.h index 8993c6ea1a4..a009cd435fa 100644 --- a/libraries/Zigbee/src/ep/ZigbeeAnalog.h +++ b/libraries/Zigbee/src/ep/ZigbeeAnalog.h @@ -45,9 +45,9 @@ class ZigbeeAnalog : public ZigbeeEP { ~ZigbeeAnalog() {} // Add analog clusters - void addAnalogValue(); - void addAnalogInput(); - void addAnalogOutput(); + bool addAnalogValue(); + bool addAnalogInput(); + bool addAnalogOutput(); // Use to set a cb function to be called on analog output change void onAnalogOutputChange(void (*callback)(float analog)) { @@ -55,14 +55,14 @@ class ZigbeeAnalog : public ZigbeeEP { } // Set the analog value / input - void setAnalogValue(float analog); - void setAnalogInput(float analog); + bool setAnalogValue(float analog); + bool setAnalogInput(float analog); // Report Analog Input - void reportAnalogInput(); + bool reportAnalogInput(); // Set reporting for Analog Input - void setAnalogInputReporting(uint16_t min_interval, uint16_t max_interval, float delta); + bool setAnalogInputReporting(uint16_t min_interval, uint16_t max_interval, float delta); private: void zbAttributeSet(const esp_zb_zcl_set_attr_value_message_t *message) override; diff --git a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp index 2718d9275c2..599e2438210 100644 --- a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp @@ -24,25 +24,36 @@ ZigbeeCarbonDioxideSensor::ZigbeeCarbonDioxideSensor(uint8_t endpoint) : ZigbeeE _ep_config = {.endpoint = _endpoint, .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID, .app_device_id = ESP_ZB_HA_SIMPLE_SENSOR_DEVICE_ID, .app_device_version = 0}; } -void ZigbeeCarbonDioxideSensor::setMinMaxValue(float min, float max) { +bool ZigbeeCarbonDioxideSensor::setMinMaxValue(float min, float max) { float zb_min = min / 1000000.0f; float zb_max = max / 1000000.0f; 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_zb_cluster_update_attr(carbon_dioxide_measure_cluster, ESP_ZB_ZCL_ATTR_CARBON_DIOXIDE_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&zb_min); - esp_zb_cluster_update_attr(carbon_dioxide_measure_cluster, ESP_ZB_ZCL_ATTR_CARBON_DIOXIDE_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&zb_max); + esp_err_t ret_min = 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_min != ESP_OK) { + log_e("Failed to set min value"); + } + esp_err_t ret_max = 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_max != ESP_OK) { + log_e("Failed to set max value"); + } + return ret_min == ESP_OK && ret_max == ESP_OK; } -void ZigbeeCarbonDioxideSensor::setTolerance(float tolerance) { +bool ZigbeeCarbonDioxideSensor::setTolerance(float tolerance) { float zb_tolerance = tolerance / 1000000.0f; 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_zb_carbon_dioxide_measurement_cluster_add_attr( + 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) { + log_e("Failed to set tolerance"); + } + return ret == ESP_OK; } -void ZigbeeCarbonDioxideSensor::setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta) { +bool ZigbeeCarbonDioxideSensor::setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta) { esp_zb_zcl_reporting_info_t reporting_info; memset(&reporting_info, 0, sizeof(esp_zb_zcl_reporting_info_t)); reporting_info.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_SRV; @@ -60,24 +71,33 @@ void ZigbeeCarbonDioxideSensor::setReporting(uint16_t min_interval, uint16_t max memcpy(&reporting_info.u.send_info.delta.s32, &delta_f, sizeof(float)); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_update_reporting_info(&reporting_info); + 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"); + } + return ret == ESP_OK; } -void ZigbeeCarbonDioxideSensor::setCarbonDioxide(float carbon_dioxide) { +bool ZigbeeCarbonDioxideSensor::setCarbonDioxide(float carbon_dioxide) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; float zb_carbon_dioxide = carbon_dioxide / 1000000.0f; log_v("Updating carbon dioxide sensor value..."); /* Update carbon dioxide sensor measured value */ log_d("Setting carbon dioxide to %0.1f", carbon_dioxide); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_CARBON_DIOXIDE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_CARBON_DIOXIDE_MEASUREMENT_MEASURED_VALUE_ID, &zb_carbon_dioxide, false ); esp_zb_lock_release(); + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set carbon dioxide"); + } + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } -void ZigbeeCarbonDioxideSensor::report() { +bool ZigbeeCarbonDioxideSensor::report() { /* Send report attributes command */ esp_zb_zcl_report_attr_cmd_t report_attr_cmd; report_attr_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; @@ -88,9 +108,14 @@ void ZigbeeCarbonDioxideSensor::report() { report_attr_cmd.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd); + 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 carbon dioxide report"); + return false; + } log_v("Carbon dioxide report sent"); + return true; } #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.h b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.h index 41a9a4fb355..e0a6de48648 100644 --- a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.h +++ b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.h @@ -42,20 +42,20 @@ class ZigbeeCarbonDioxideSensor : public ZigbeeEP { ~ZigbeeCarbonDioxideSensor() {} // Set the carbon dioxide value in ppm - void setCarbonDioxide(float carbon_dioxide); + bool setCarbonDioxide(float carbon_dioxide); // Set the min and max value for the carbon dioxide sensor in ppm - void setMinMaxValue(float min, float max); + bool setMinMaxValue(float min, float max); // Set the tolerance value for the carbon dioxide sensor in ppm - void setTolerance(float tolerance); + bool setTolerance(float tolerance); // Set the reporting interval for carbon dioxide measurement in seconds and delta (carbon dioxide change in ppm) // NOTE: Delta reporting is currently not supported by the carbon dioxide sensor - void setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta); + bool setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta); // Report the carbon dioxide value - void report(); + bool report(); }; #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp index 585b1549816..9c741a3d0d6 100644 --- a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp @@ -117,7 +117,7 @@ void ZigbeeColorDimmableLight::lightChanged() { } } -void ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, uint8_t green, uint8_t blue) { +bool ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, uint8_t green, uint8_t blue) { //Update all attributes _current_state = state; _current_level = level; @@ -131,50 +131,56 @@ void ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, /* Update light clusters */ esp_zb_lock_acquire(portMAX_DELAY); //set on/off state - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_state = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_ON_OFF, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID, &_current_state, false ); //set level - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_level = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_LEVEL_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_LEVEL_CONTROL_CURRENT_LEVEL_ID, &_current_level, false ); //set xy color - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_xy = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_COLOR_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_COLOR_CONTROL_CURRENT_X_ID, &xy_color.x, false ); - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_y = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_COLOR_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_COLOR_CONTROL_CURRENT_Y_ID, &xy_color.y, false ); //set hsv color uint8_t hue = (uint8_t)hsv_color.h; - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_hue = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_COLOR_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_COLOR_CONTROL_CURRENT_HUE_ID, &hue, false ); - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_saturation = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_COLOR_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_COLOR_CONTROL_CURRENT_SATURATION_ID, &hsv_color.s, false ); esp_zb_lock_release(); + + if (ret_state != ESP_ZB_ZCL_STATUS_SUCCESS || ret_level != ESP_ZB_ZCL_STATUS_SUCCESS || ret_xy != ESP_ZB_ZCL_STATUS_SUCCESS || ret_y != ESP_ZB_ZCL_STATUS_SUCCESS || ret_hue != ESP_ZB_ZCL_STATUS_SUCCESS || ret_saturation != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set light attributes"); + return false; + } + return true; } -void ZigbeeColorDimmableLight::setLightState(bool state) { - setLight(state, _current_level, _current_color.r, _current_color.g, _current_color.b); +bool ZigbeeColorDimmableLight::setLightState(bool state) { + return setLight(state, _current_level, _current_color.r, _current_color.g, _current_color.b); } -void ZigbeeColorDimmableLight::setLightLevel(uint8_t level) { - setLight(_current_state, level, _current_color.r, _current_color.g, _current_color.b); +bool ZigbeeColorDimmableLight::setLightLevel(uint8_t level) { + return setLight(_current_state, level, _current_color.r, _current_color.g, _current_color.b); } -void ZigbeeColorDimmableLight::setLightColor(uint8_t red, uint8_t green, uint8_t blue) { - setLight(_current_state, _current_level, red, green, blue); +bool ZigbeeColorDimmableLight::setLightColor(uint8_t red, uint8_t green, uint8_t blue) { + return setLight(_current_state, _current_level, red, green, blue); } -void ZigbeeColorDimmableLight::setLightColor(espRgbColor_t rgb_color) { - setLight(_current_state, _current_level, rgb_color.r, rgb_color.g, rgb_color.b); +bool ZigbeeColorDimmableLight::setLightColor(espRgbColor_t rgb_color) { + return setLight(_current_state, _current_level, rgb_color.r, rgb_color.g, rgb_color.b); } -void ZigbeeColorDimmableLight::setLightColor(espHsvColor_t hsv_color) { +bool ZigbeeColorDimmableLight::setLightColor(espHsvColor_t hsv_color) { espRgbColor_t rgb_color = espHsvColorToRgbColor(hsv_color); - setLight(_current_state, _current_level, rgb_color.r, rgb_color.g, rgb_color.b); + return setLight(_current_state, _current_level, rgb_color.r, rgb_color.g, rgb_color.b); } #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.h b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.h index 64df3565793..6681f213ad0 100644 --- a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.h +++ b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.h @@ -62,12 +62,12 @@ class ZigbeeColorDimmableLight : public ZigbeeEP { lightChanged(); } - void setLightState(bool state); - void setLightLevel(uint8_t level); - void setLightColor(uint8_t red, uint8_t green, uint8_t blue); - void setLightColor(espRgbColor_t rgb_color); - void setLightColor(espHsvColor_t hsv_color); - void setLight(bool state, uint8_t level, uint8_t red, uint8_t green, uint8_t blue); + bool setLightState(bool state); + bool setLightLevel(uint8_t level); + bool setLightColor(uint8_t red, uint8_t green, uint8_t blue); + bool setLightColor(espRgbColor_t rgb_color); + bool setLightColor(espHsvColor_t hsv_color); + bool setLight(bool state, uint8_t level, uint8_t red, uint8_t green, uint8_t blue); bool getLightState() { return _current_state; diff --git a/libraries/Zigbee/src/ep/ZigbeeContactSwitch.cpp b/libraries/Zigbee/src/ep/ZigbeeContactSwitch.cpp index 6237315d5d9..31fafede4b1 100644 --- a/libraries/Zigbee/src/ep/ZigbeeContactSwitch.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeContactSwitch.cpp @@ -29,29 +29,39 @@ void ZigbeeContactSwitch::setIASClientEndpoint(uint8_t ep_number) { _ias_cie_endpoint = ep_number; } -void ZigbeeContactSwitch::setClosed() { +bool ZigbeeContactSwitch::setClosed() { log_v("Setting Contact switch to closed"); uint8_t closed = 0; // ALARM1 = 0, ALARM2 = 0 esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + esp_err_t ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_IAS_ZONE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_IAS_ZONE_ZONESTATUS_ID, &closed, false ); esp_zb_lock_release(); + if (ret != ESP_OK) { + log_e("Failed to set contact switch to closed"); + return false; + } _zone_status = closed; - report(); + return report(); } -void ZigbeeContactSwitch::setOpen() { +bool ZigbeeContactSwitch::setOpen() { log_v("Setting Contact switch to open"); uint8_t open = ESP_ZB_ZCL_IAS_ZONE_ZONE_STATUS_ALARM1 | ESP_ZB_ZCL_IAS_ZONE_ZONE_STATUS_ALARM2; // ALARM1 = 1, ALARM2 = 1 esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val(_endpoint, ESP_ZB_ZCL_CLUSTER_ID_IAS_ZONE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_IAS_ZONE_ZONESTATUS_ID, &open, false); + esp_err_t ret = esp_zb_zcl_set_attribute_val( + _endpoint, ESP_ZB_ZCL_CLUSTER_ID_IAS_ZONE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_IAS_ZONE_ZONESTATUS_ID, &open, false + ); esp_zb_lock_release(); + if (ret != ESP_OK) { + log_e("Failed to set contact switch to open"); + return false; + } _zone_status = open; - report(); + return report(); } -void ZigbeeContactSwitch::report() { +bool ZigbeeContactSwitch::report() { /* Send IAS Zone status changed notification command */ esp_zb_zcl_ias_zone_status_change_notif_cmd_t status_change_notif_cmd; @@ -66,9 +76,14 @@ void ZigbeeContactSwitch::report() { status_change_notif_cmd.delay = 0; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_ias_zone_status_change_notif_cmd_req(&status_change_notif_cmd); + esp_err_t ret = esp_zb_zcl_ias_zone_status_change_notif_cmd_req(&status_change_notif_cmd); esp_zb_lock_release(); + if (ret != ESP_OK) { + log_e("Failed to send IAS Zone status changed notification"); + return false; + } log_v("IAS Zone status changed notification sent"); + return true; } void ZigbeeContactSwitch::zbIASZoneEnrollResponse(const esp_zb_zcl_ias_zone_enroll_response_message_t *message) { diff --git a/libraries/Zigbee/src/ep/ZigbeeContactSwitch.h b/libraries/Zigbee/src/ep/ZigbeeContactSwitch.h index f44ce1cec40..b33effd8dfc 100644 --- a/libraries/Zigbee/src/ep/ZigbeeContactSwitch.h +++ b/libraries/Zigbee/src/ep/ZigbeeContactSwitch.h @@ -48,13 +48,13 @@ class ZigbeeContactSwitch : public ZigbeeEP { void setIASClientEndpoint(uint8_t ep_number); // Set the contact switch value to closed - void setClosed(); + bool setClosed(); // Set the contact switch value to open - void setOpen(); + bool setOpen(); // Report the contact switch value, done automatically after setting the position - void report(); + bool report(); private: void zbIASZoneEnrollResponse(const esp_zb_zcl_ias_zone_enroll_response_message_t *message) override; diff --git a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp index 34622d1d2db..9723e1045eb 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp @@ -1,4 +1,3 @@ - #include "ZigbeeDimmableLight.h" #if CONFIG_ZB_ENABLED @@ -52,7 +51,7 @@ void ZigbeeDimmableLight::lightChanged() { } } -void ZigbeeDimmableLight::setLight(bool state, uint8_t level) { +bool ZigbeeDimmableLight::setLight(bool state, uint8_t level) { // Update all attributes _current_state = state; _current_level = level; @@ -62,22 +61,28 @@ void ZigbeeDimmableLight::setLight(bool state, uint8_t level) { /* Update light clusters */ esp_zb_lock_acquire(portMAX_DELAY); // set on/off state - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_state = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_ON_OFF, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID, &_current_state, false ); // set level - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_level = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_LEVEL_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_LEVEL_CONTROL_CURRENT_LEVEL_ID, &_current_level, false ); esp_zb_lock_release(); + + if (ret_state != ESP_ZB_ZCL_STATUS_SUCCESS || ret_level != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set light state and level"); + return false; + } + return true; } -void ZigbeeDimmableLight::setLightState(bool state) { - setLight(state, _current_level); +bool ZigbeeDimmableLight::setLightState(bool state) { + return setLight(state, _current_level); } -void ZigbeeDimmableLight::setLightLevel(uint8_t level) { - setLight(_current_state, level); +bool ZigbeeDimmableLight::setLightLevel(uint8_t level) { + return setLight(_current_state, level); } esp_zb_cluster_list_t *ZigbeeDimmableLight::zigbee_dimmable_light_clusters_create(zigbee_dimmable_light_cfg_t *light_cfg) { diff --git a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.h b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.h index 45c3e97c00b..747fdbafaef 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.h +++ b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.h @@ -76,9 +76,9 @@ class ZigbeeDimmableLight : public ZigbeeEP { lightChanged(); } - void setLightState(bool state); - void setLightLevel(uint8_t level); - void setLight(bool state, uint8_t level); + bool setLightState(bool state); + bool setLightLevel(uint8_t level); + bool setLight(bool state, uint8_t level); bool getLightState() { return _current_state; @@ -89,7 +89,6 @@ class ZigbeeDimmableLight : public ZigbeeEP { private: void zbAttributeSet(const esp_zb_zcl_set_attr_value_message_t *message) override; - void lightChanged(); // callback function to be called on light change (State, Level) void (*_on_light_change)(bool, uint8_t); diff --git a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp index 70008fbab10..b298571a780 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp @@ -29,38 +29,58 @@ void ZigbeeDoorWindowHandle::setIASClientEndpoint(uint8_t ep_number) { _ias_cie_endpoint = ep_number; } -void ZigbeeDoorWindowHandle::setClosed() { +bool ZigbeeDoorWindowHandle::setClosed() { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; log_v("Setting Door/Window handle to closed"); uint8_t closed = 0; // ALARM1 = 0, ALARM2 = 0 esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_IAS_ZONE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_IAS_ZONE_ZONESTATUS_ID, &closed, false ); esp_zb_lock_release(); + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set door/window handle to closed"); + return false; + } _zone_status = closed; report(); + return true; } -void ZigbeeDoorWindowHandle::setOpen() { +bool ZigbeeDoorWindowHandle::setOpen() { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; log_v("Setting Door/Window handle to open"); uint8_t open = ESP_ZB_ZCL_IAS_ZONE_ZONE_STATUS_ALARM1 | ESP_ZB_ZCL_IAS_ZONE_ZONE_STATUS_ALARM2; // ALARM1 = 1, ALARM2 = 1 esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val(_endpoint, ESP_ZB_ZCL_CLUSTER_ID_IAS_ZONE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_IAS_ZONE_ZONESTATUS_ID, &open, false); + ret = esp_zb_zcl_set_attribute_val( + _endpoint, ESP_ZB_ZCL_CLUSTER_ID_IAS_ZONE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_IAS_ZONE_ZONESTATUS_ID, &open, false + ); esp_zb_lock_release(); + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set door/window handle to open"); + return false; + } _zone_status = open; report(); + return true; } -void ZigbeeDoorWindowHandle::setTilted() { +bool ZigbeeDoorWindowHandle::setTilted() { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; log_v("Setting Door/Window handle to tilted"); uint8_t tilted = ESP_ZB_ZCL_IAS_ZONE_ZONE_STATUS_ALARM1; // ALARM1 = 1, ALARM2 = 0 esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_IAS_ZONE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_IAS_ZONE_ZONESTATUS_ID, &tilted, false ); esp_zb_lock_release(); + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set door/window handle to tilted"); + return false; + } _zone_status = tilted; report(); + return true; } void ZigbeeDoorWindowHandle::report() { diff --git a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.h b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.h index 8d4eff9e45a..832fe2f4423 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.h +++ b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.h @@ -49,13 +49,13 @@ class ZigbeeDoorWindowHandle : public ZigbeeEP { void setIASClientEndpoint(uint8_t ep_number); // Set the door/window handle value to closed - void setClosed(); + bool setClosed(); // Set the door/window handle value to open - void setOpen(); + bool setOpen(); // Set the door/window handle value to tilted - void setTilted(); + bool setTilted(); // Report the door/window handle value, done automatically after setting the position void report(); diff --git a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp index 11fbf7c906b..51ed5d931a4 100644 --- a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp @@ -22,24 +22,43 @@ ZigbeeFlowSensor::ZigbeeFlowSensor(uint8_t endpoint) : ZigbeeEP(endpoint) { _ep_config = {.endpoint = _endpoint, .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID, .app_device_id = ESP_ZB_HA_SIMPLE_SENSOR_DEVICE_ID, .app_device_version = 0}; } -void ZigbeeFlowSensor::setMinMaxValue(float min, float max) { +bool ZigbeeFlowSensor::setMinMaxValue(float min, float max) { uint16_t zb_min = (uint16_t)(min * 10); uint16_t zb_max = (uint16_t)(max * 10); 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_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min); - esp_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max); + if (!flow_measure_cluster) { + log_e("Failed to get flow measurement cluster"); + return false; + } + esp_err_t ret_min = esp_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min); + if(ret_min != ESP_OK) { + log_e("Failed to set min value"); + } + esp_err_t ret_max = esp_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max); + if(ret_max != ESP_OK) { + log_e("Failed to set max value"); + } + return ret_min == ESP_OK && ret_max == ESP_OK; } -void ZigbeeFlowSensor::setTolerance(float tolerance) { - // Convert tolerance to ZCL uint16_t +bool ZigbeeFlowSensor::setTolerance(float tolerance) { uint16_t zb_tolerance = (uint16_t)(tolerance * 10); 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_zb_flow_meas_cluster_add_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance); + if (!flow_measure_cluster) { + log_e("Failed to get flow measurement cluster"); + return false; + } + esp_err_t ret = esp_zb_flow_meas_cluster_add_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance); + if (ret != ESP_OK) { + log_e("Failed to set tolerance"); + return false; + } + return true; } -void ZigbeeFlowSensor::setReporting(uint16_t min_interval, uint16_t max_interval, float delta) { +bool ZigbeeFlowSensor::setReporting(uint16_t min_interval, uint16_t max_interval, float delta) { esp_zb_zcl_reporting_info_t reporting_info; memset(&reporting_info, 0, sizeof(esp_zb_zcl_reporting_info_t)); reporting_info.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_SRV; @@ -54,24 +73,39 @@ void 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_zb_zcl_update_reporting_info(&reporting_info); + 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"); + return false; + } + return true; } -void ZigbeeFlowSensor::setFlow(float flow) { +bool ZigbeeFlowSensor::setFlow(float flow) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; uint16_t zb_flow = (uint16_t)(flow * 10); 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); - esp_zb_zcl_set_attribute_val( + 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"); + return false; + } + return true; } -void ZigbeeFlowSensor::report() { +bool ZigbeeFlowSensor::report() { /* Send report attributes command */ esp_zb_zcl_report_attr_cmd_t report_attr_cmd; report_attr_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; @@ -82,9 +116,15 @@ void ZigbeeFlowSensor::report() { report_attr_cmd.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd); + 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"); + return false; + } log_v("Flow report sent"); + return true; } #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.h b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.h index 5e9e20e4d1a..fa16b4a5636 100644 --- a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.h +++ b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.h @@ -42,19 +42,19 @@ class ZigbeeFlowSensor : public ZigbeeEP { ~ZigbeeFlowSensor() {} // Set the flow value in 0,1 m3/h - void setFlow(float value); + bool setFlow(float value); // Set the min and max value for the flow sensor in 0,1 m3/h - void setMinMaxValue(float min, float max); + bool setMinMaxValue(float min, float max); // Set the tolerance value for the flow sensor in 0,01 m3/h - void setTolerance(float tolerance); + bool setTolerance(float tolerance); // Set the reporting interval for flow measurement in seconds and delta (temp change in 0,1 m3/h) - void setReporting(uint16_t min_interval, uint16_t max_interval, float delta); + bool setReporting(uint16_t min_interval, uint16_t max_interval, float delta); // Report the flow value - void report(); + bool report(); }; #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeLight.cpp b/libraries/Zigbee/src/ep/ZigbeeLight.cpp index 2a87db71287..e5c5f7ec4ec 100644 --- a/libraries/Zigbee/src/ep/ZigbeeLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeLight.cpp @@ -33,17 +33,24 @@ void ZigbeeLight::lightChanged() { } } -void ZigbeeLight::setLight(bool state) { +bool ZigbeeLight::setLight(bool state) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; _current_state = state; lightChanged(); log_v("Updating on/off light state to %d", state); /* Update on/off light state */ esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_ON_OFF, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID, &_current_state, false ); esp_zb_lock_release(); + + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set light state"); + return false; + } + return true; } #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeLight.h b/libraries/Zigbee/src/ep/ZigbeeLight.h index 807802be9b3..773fbb14ec5 100644 --- a/libraries/Zigbee/src/ep/ZigbeeLight.h +++ b/libraries/Zigbee/src/ep/ZigbeeLight.h @@ -23,7 +23,7 @@ class ZigbeeLight : public ZigbeeEP { lightChanged(); } // Use to control light state - void setLight(bool state); + bool setLight(bool state); // Use to get light state bool getLightState() { return _current_state; diff --git a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp index 31a1f7e90e1..7d348eccae4 100644 --- a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp @@ -22,26 +22,38 @@ ZigbeeOccupancySensor::ZigbeeOccupancySensor(uint8_t endpoint) : ZigbeeEP(endpoi _ep_config = {.endpoint = _endpoint, .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID, .app_device_id = ESP_ZB_HA_SIMPLE_SENSOR_DEVICE_ID, .app_device_version = 0}; } -void ZigbeeOccupancySensor::setSensorType(uint8_t sensor_type) { +bool ZigbeeOccupancySensor::setSensorType(uint8_t sensor_type) { uint8_t sensor_type_bitmap = 1 << 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_zb_cluster_update_attr(occupancy_sens_cluster, ESP_ZB_ZCL_ATTR_OCCUPANCY_SENSING_OCCUPANCY_SENSOR_TYPE_ID, (void *)&sensor_type); - esp_zb_cluster_update_attr(occupancy_sens_cluster, ESP_ZB_ZCL_ATTR_OCCUPANCY_SENSING_OCCUPANCY_SENSOR_TYPE_BITMAP_ID, (void *)&sensor_type_bitmap); + esp_err_t ret_type = esp_zb_cluster_update_attr(occupancy_sens_cluster, ESP_ZB_ZCL_ATTR_OCCUPANCY_SENSING_OCCUPANCY_SENSOR_TYPE_ID, (void *)&sensor_type); + if(ret_type != ESP_OK) { + log_e("Failed to set sensor type"); + } + esp_err_t ret_bitmap = 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_bitmap != ESP_OK) { + log_e("Failed to set sensor type bitmap"); + } + return ret_type == ESP_OK && ret_bitmap == ESP_OK; } -void ZigbeeOccupancySensor::setOccupancy(bool occupied) { +bool ZigbeeOccupancySensor::setOccupancy(bool occupied) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; log_v("Updating occupancy sensor value..."); /* Update occupancy sensor value */ log_d("Setting occupancy to %d", occupied); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _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) { + log_e("Failed to set occupancy"); + } + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } -void ZigbeeOccupancySensor::report() { +bool ZigbeeOccupancySensor::report() { /* Send report attributes command */ esp_zb_zcl_report_attr_cmd_t report_attr_cmd; report_attr_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; @@ -52,9 +64,14 @@ void ZigbeeOccupancySensor::report() { report_attr_cmd.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd); + 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 occupancy report"); + return false; + } log_v("Occupancy report sent"); + return true; } #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.h b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.h index fa622d5a707..7408e10a76b 100644 --- a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.h +++ b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.h @@ -42,13 +42,13 @@ class ZigbeeOccupancySensor : public ZigbeeEP { ~ZigbeeOccupancySensor() {} // Set the occupancy value. True for occupied, false for unoccupied - void setOccupancy(bool occupied); + bool setOccupancy(bool occupied); // Set the sensor type, see esp_zb_zcl_occupancy_sensing_occupancy_sensor_type_t - void setSensorType(uint8_t sensor_type); + bool setSensorType(uint8_t sensor_type); // Report the occupancy value - void report(); + bool report(); }; #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp b/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp index 21456a51511..d8d453b0062 100644 --- a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp @@ -22,21 +22,31 @@ ZigbeePressureSensor::ZigbeePressureSensor(uint8_t endpoint) : ZigbeeEP(endpoint _ep_config = {.endpoint = _endpoint, .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID, .app_device_id = ESP_ZB_HA_SIMPLE_SENSOR_DEVICE_ID, .app_device_version = 0}; } -void ZigbeePressureSensor::setMinMaxValue(int16_t min, int16_t max) { - +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_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MIN_VALUE_ID, (void *)&min); - esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MAX_VALUE_ID, (void *)&max); + esp_err_t ret_min = esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MIN_VALUE_ID, (void *)&min); + if(ret_min != ESP_OK) { + log_e("Failed to set min value"); + } + esp_err_t ret_max = esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MAX_VALUE_ID, (void *)&max); + if(ret_max != ESP_OK) { + log_e("Failed to set max value"); + } + return ret_min == ESP_OK && ret_max == ESP_OK; } -void ZigbeePressureSensor::setTolerance(uint16_t tolerance) { +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_zb_pressure_meas_cluster_add_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_TOLERANCE_ID, (void *)&tolerance); + 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) { + log_e("Failed to set tolerance"); + } + return ret == ESP_OK; } -void ZigbeePressureSensor::setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta) { +bool ZigbeePressureSensor::setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta) { esp_zb_zcl_reporting_info_t reporting_info; memset(&reporting_info, 0, sizeof(esp_zb_zcl_reporting_info_t)); reporting_info.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_SRV; @@ -52,22 +62,31 @@ void ZigbeePressureSensor::setReporting(uint16_t min_interval, uint16_t max_inte 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_zb_zcl_update_reporting_info(&reporting_info); + 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"); + } + return ret == ESP_OK; } -void ZigbeePressureSensor::setPressure(int16_t pressure) { +bool ZigbeePressureSensor::setPressure(int16_t pressure) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; log_v("Updating pressure sensor value..."); /* Update pressure sensor measured value */ log_d("Setting pressure to %d hPa", pressure); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _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) { + log_e("Failed to set pressure"); + } + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } -void ZigbeePressureSensor::report() { +bool ZigbeePressureSensor::report() { /* Send report attributes command */ esp_zb_zcl_report_attr_cmd_t report_attr_cmd; report_attr_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; @@ -78,9 +97,14 @@ void ZigbeePressureSensor::report() { report_attr_cmd.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd); + 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 pressure report"); + return false; + } log_v("Pressure report sent"); + return true; } #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeePressureSensor.h b/libraries/Zigbee/src/ep/ZigbeePressureSensor.h index db14dd1c341..f93df7a7411 100644 --- a/libraries/Zigbee/src/ep/ZigbeePressureSensor.h +++ b/libraries/Zigbee/src/ep/ZigbeePressureSensor.h @@ -42,19 +42,19 @@ class ZigbeePressureSensor : public ZigbeeEP { ~ZigbeePressureSensor() {} // Set the pressure value in 1 hPa - void setPressure(int16_t value); + bool setPressure(int16_t value); // Set the min and max value for the pressure sensor in 1 hPa - void setMinMaxValue(int16_t min, int16_t max); + bool setMinMaxValue(int16_t min, int16_t max); // Set the tolerance value for the pressure sensor in 1 hPa - void setTolerance(uint16_t tolerance); + bool setTolerance(uint16_t tolerance); // Set the reporting interval for pressure measurement in seconds and delta (pressure change in 1 hPa) - void setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta); + bool setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta); // Report the pressure value - void report(); + bool report(); }; #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp index b3ff03f0a6b..304ec483884 100644 --- a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp @@ -17,24 +17,35 @@ static int16_t zb_float_to_s16(float temp) { return (int16_t)(temp * 100); } -void ZigbeeTempSensor::setMinMaxValue(float min, float max) { +bool ZigbeeTempSensor::setMinMaxValue(float min, float max) { int16_t zb_min = zb_float_to_s16(min); int16_t zb_max = zb_float_to_s16(max); esp_zb_attribute_list_t *temp_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min); - esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max); + esp_err_t ret_min = esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min); + if(ret_min != ESP_OK) { + log_e("Failed to set min value"); + } + esp_err_t ret_max = esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max); + if(ret_max != ESP_OK) { + log_e("Failed to set max value"); + } + return ret_min == ESP_OK && ret_max == ESP_OK; } -void ZigbeeTempSensor::setTolerance(float tolerance) { +bool ZigbeeTempSensor::setTolerance(float tolerance) { // Convert tolerance to ZCL uint16_t uint16_t zb_tolerance = (uint16_t)(tolerance * 100); esp_zb_attribute_list_t *temp_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_temperature_meas_cluster_add_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance); + 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); + if(ret != ESP_OK) { + log_e("Failed to set tolerance"); + } + return ret == ESP_OK; } -void ZigbeeTempSensor::setReporting(uint16_t min_interval, uint16_t max_interval, float delta) { +bool ZigbeeTempSensor::setReporting(uint16_t min_interval, uint16_t max_interval, float delta) { esp_zb_zcl_reporting_info_t reporting_info; memset(&reporting_info, 0, sizeof(esp_zb_zcl_reporting_info_t)); reporting_info.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_SRV; @@ -50,23 +61,32 @@ void ZigbeeTempSensor::setReporting(uint16_t min_interval, uint16_t max_interval 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_zb_zcl_update_reporting_info(&reporting_info); + 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"); + } + return ret == ESP_OK; } -void ZigbeeTempSensor::setTemperature(float temperature) { +bool ZigbeeTempSensor::setTemperature(float temperature) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; int16_t zb_temperature = zb_float_to_s16(temperature); log_v("Updating temperature sensor value..."); /* Update temperature sensor measured value */ log_d("Setting temperature to %d", zb_temperature); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _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 ); esp_zb_lock_release(); + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set temperature"); + } + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } -void ZigbeeTempSensor::reportTemperature() { +bool ZigbeeTempSensor::reportTemperature() { /* Send report attributes command */ esp_zb_zcl_report_attr_cmd_t report_attr_cmd; report_attr_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; @@ -77,9 +97,14 @@ void ZigbeeTempSensor::reportTemperature() { report_attr_cmd.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd); + 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 temperature report"); + return false; + } log_v("Temperature report sent"); + return true; } void ZigbeeTempSensor::addHumiditySensor(float min, float max, float tolerance) { @@ -96,20 +121,25 @@ void ZigbeeTempSensor::addHumiditySensor(float min, float max, float tolerance) _humidity_sensor = true; } -void ZigbeeTempSensor::setHumidity(float humidity) { +bool ZigbeeTempSensor::setHumidity(float humidity) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; int16_t zb_humidity = zb_float_to_s16(humidity); log_v("Updating humidity sensor value..."); /* Update humidity sensor measured value */ log_d("Setting humidity to %d", zb_humidity); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_VALUE_ID, &zb_humidity, false ); esp_zb_lock_release(); + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set humidity"); + } + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } -void ZigbeeTempSensor::reportHumidity() { +bool ZigbeeTempSensor::reportHumidity() { /* Send report attributes command */ esp_zb_zcl_report_attr_cmd_t report_attr_cmd; report_attr_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; @@ -120,12 +150,17 @@ void ZigbeeTempSensor::reportHumidity() { report_attr_cmd.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd); + 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 humidity report"); + return false; + } log_v("Humidity report sent"); + return true; } -void ZigbeeTempSensor::setHumidityReporting(uint16_t min_interval, uint16_t max_interval, float delta) { +bool ZigbeeTempSensor::setHumidityReporting(uint16_t min_interval, uint16_t max_interval, float delta) { esp_zb_zcl_reporting_info_t reporting_info; memset(&reporting_info, 0, sizeof(esp_zb_zcl_reporting_info_t)); reporting_info.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_SRV; @@ -141,15 +176,21 @@ void ZigbeeTempSensor::setHumidityReporting(uint16_t min_interval, uint16_t max_ 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_zb_zcl_update_reporting_info(&reporting_info); + 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 humidity reporting"); + } + return ret == ESP_OK; } -void ZigbeeTempSensor::report() { - reportTemperature(); +bool ZigbeeTempSensor::report() { + bool temp_ret = reportTemperature(); + bool hum_ret = true; if (_humidity_sensor) { - reportHumidity(); + hum_ret = reportHumidity(); } + return temp_ret && hum_ret; } #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeTempSensor.h b/libraries/Zigbee/src/ep/ZigbeeTempSensor.h index 41da03d9db8..bc769b32de6 100644 --- a/libraries/Zigbee/src/ep/ZigbeeTempSensor.h +++ b/libraries/Zigbee/src/ep/ZigbeeTempSensor.h @@ -15,34 +15,34 @@ class ZigbeeTempSensor : public ZigbeeEP { ~ZigbeeTempSensor() {} // Set the temperature value in 0,01°C - void setTemperature(float value); + bool setTemperature(float value); // Set the min and max value for the temperature sensor in 0,01°C - void setMinMaxValue(float min, float max); + bool setMinMaxValue(float min, float max); // Set the tolerance value for the temperature sensor in 0,01°C - void setTolerance(float tolerance); + bool setTolerance(float tolerance); // Set the reporting interval for temperature measurement in seconds and delta (temp change in 0,01 °C) - void setReporting(uint16_t min_interval, uint16_t max_interval, float delta); + bool setReporting(uint16_t min_interval, uint16_t max_interval, float delta); // Report the temperature value - void reportTemperature(); + bool reportTemperature(); // Add humidity cluster to the temperature sensor device void addHumiditySensor(float min, float max, float tolerance); // Set the humidity value in 0,01% - void setHumidity(float value); + bool setHumidity(float value); // Set the reporting interval for humidity measurement in seconds and delta (humidity change in 0,01%) - void setHumidityReporting(uint16_t min_interval, uint16_t max_interval, float delta); + bool setHumidityReporting(uint16_t min_interval, uint16_t max_interval, float delta); // Report the humidity value - void reportHumidity(); + bool reportHumidity(); // Report the temperature and humidity values if humidity sensor is added - void report(); + bool report(); private: bool _humidity_sensor; diff --git a/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp index 9fc75297262..1482386a0ce 100644 --- a/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp @@ -29,16 +29,22 @@ void ZigbeeVibrationSensor::setIASClientEndpoint(uint8_t ep_number) { _ias_cie_endpoint = ep_number; } -void ZigbeeVibrationSensor::setVibration(bool sensed) { +bool ZigbeeVibrationSensor::setVibration(bool sensed) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; log_v("Setting Vibration sensor to %s", sensed ? "sensed" : "not sensed"); uint8_t vibration = (uint8_t)sensed; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_IAS_ZONE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_IAS_ZONE_ZONESTATUS_ID, &vibration, false ); esp_zb_lock_release(); + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set vibration status"); + return false; + } _zone_status = vibration; report(); + return true; } void ZigbeeVibrationSensor::report() { @@ -49,7 +55,6 @@ void ZigbeeVibrationSensor::report() { status_change_notif_cmd.zcl_basic_cmd.src_endpoint = _endpoint; status_change_notif_cmd.zcl_basic_cmd.dst_endpoint = _ias_cie_endpoint; //default is 1 memcpy(status_change_notif_cmd.zcl_basic_cmd.dst_addr_u.addr_long, _ias_cie_addr, sizeof(esp_zb_ieee_addr_t)); - status_change_notif_cmd.zone_status = _zone_status; status_change_notif_cmd.extend_status = 0; status_change_notif_cmd.zone_id = _zone_id; diff --git a/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.h b/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.h index 1ee3740dcc3..2f67c7bb6b4 100644 --- a/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.h +++ b/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.h @@ -48,7 +48,7 @@ class ZigbeeVibrationSensor : public ZigbeeEP { void setIASClientEndpoint(uint8_t ep_number); // Set the vibration sensor value (true = sensed, false = not sensed) - void setVibration(bool sensed); + bool setVibration(bool sensed); // Report the vibration sensor value, done automatically after setting the sensed value void report(); diff --git a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp index d93b02adbc3..1754acb4a97 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp @@ -28,25 +28,35 @@ static uint16_t zb_windspeed_to_u16(float windspeed) { return (uint16_t)(windspeed * 100); } -void ZigbeeWindSpeedSensor::setMinMaxValue(float min, float max) { +bool ZigbeeWindSpeedSensor::setMinMaxValue(float min, float max) { uint16_t zb_min = zb_windspeed_to_u16(min); uint16_t zb_max = zb_windspeed_to_u16(max); esp_zb_attribute_list_t *windspeed_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - // - esp_zb_cluster_update_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&zb_min); - esp_zb_cluster_update_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&zb_max); + esp_err_t ret_min = esp_zb_cluster_update_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&zb_min); + if(ret_min != ESP_OK) { + log_e("Failed to set min value"); + } + esp_err_t ret_max = esp_zb_cluster_update_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&zb_max); + if(ret_max != ESP_OK) { + log_e("Failed to set max value"); + } + return ret_min == ESP_OK && ret_max == ESP_OK; } -void ZigbeeWindSpeedSensor::setTolerance(float tolerance) { +bool ZigbeeWindSpeedSensor::setTolerance(float tolerance) { // Convert tolerance to ZCL uint16_t uint16_t zb_tolerance = zb_windspeed_to_u16(tolerance); esp_zb_attribute_list_t *windspeed_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_wind_speed_measurement_cluster_add_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance); + 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); + if(ret != ESP_OK) { + log_e("Failed to set tolerance"); + } + return ret == ESP_OK; } -void ZigbeeWindSpeedSensor::setReporting(uint16_t min_interval, uint16_t max_interval, float delta) { +bool ZigbeeWindSpeedSensor::setReporting(uint16_t min_interval, uint16_t max_interval, float delta) { esp_zb_zcl_reporting_info_t reporting_info; memset(&reporting_info, 0, sizeof(esp_zb_zcl_reporting_info_t)); reporting_info.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_SRV; @@ -62,24 +72,33 @@ void ZigbeeWindSpeedSensor::setReporting(uint16_t min_interval, uint16_t max_int 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_zb_zcl_update_reporting_info(&reporting_info); + 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"); + } + return ret == ESP_OK; } -void ZigbeeWindSpeedSensor::setWindSpeed(float windspeed) { +bool ZigbeeWindSpeedSensor::setWindSpeed(float windspeed) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; uint16_t zb_windspeed = zb_windspeed_to_u16(windspeed); log_v("Updating windspeed sensor value..."); /* Update windspeed sensor measured value */ log_d("Setting windspeed to %d", zb_windspeed); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MEASURED_VALUE_ID, &zb_windspeed, false ); esp_zb_lock_release(); + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set wind speed"); + } + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } -void ZigbeeWindSpeedSensor::reportWindSpeed() { +bool ZigbeeWindSpeedSensor::reportWindSpeed() { /* Send report attributes command */ esp_zb_zcl_report_attr_cmd_t report_attr_cmd; report_attr_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; @@ -90,9 +109,14 @@ void ZigbeeWindSpeedSensor::reportWindSpeed() { report_attr_cmd.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd); + 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 wind speed report"); + return false; + } log_v("Wind speed measurement report sent"); + return true; } #endif //CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.h b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.h index e091d3ae548..641c1d84780 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.h +++ b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.h @@ -40,17 +40,17 @@ class ZigbeeWindSpeedSensor : public ZigbeeEP { ~ZigbeeWindSpeedSensor() {} // Set the WindSpeed value in 0,01 m/s - void setWindSpeed(float value); + bool setWindSpeed(float value); // Set the min and max value for the WindSpeed sensor - void setMinMaxValue(float min, float max); + bool setMinMaxValue(float min, float max); // Set the tolerance value for the WindSpeed sensor - void setTolerance(float tolerance); + bool setTolerance(float tolerance); // Set the reporting interval for WindSpeed measurement in seconds and delta - void setReporting(uint16_t min_interval, uint16_t max_interval, float delta); - void reportWindSpeed(); + bool setReporting(uint16_t min_interval, uint16_t max_interval, float delta); + bool reportWindSpeed(); }; #endif //CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp index f6d6ec268ea..f2ecbcc668f 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp @@ -1,4 +1,3 @@ - #include "ZigbeeWindowCovering.h" #if CONFIG_ZB_ENABLED @@ -72,13 +71,18 @@ ZigbeeWindowCovering::ZigbeeWindowCovering(uint8_t endpoint) : ZigbeeEP(endpoint } // Configuration methods for window covering -void ZigbeeWindowCovering::setCoveringType(ZigbeeWindowCoveringType covering_type) { +bool ZigbeeWindowCovering::setCoveringType(ZigbeeWindowCoveringType covering_type) { esp_zb_attribute_list_t *window_covering_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_WINDOW_COVERING_TYPE_ID, (void *)&covering_type); + esp_err_t ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_WINDOW_COVERING_TYPE_ID, (void *)&covering_type); + if (ret != ESP_OK) { + log_e("Failed to set covering type"); + return false; + } + return true; } -void ZigbeeWindowCovering::setConfigStatus( +bool ZigbeeWindowCovering::setConfigStatus( bool operational, bool online, bool commands_reversed, bool lift_closed_loop, bool tilt_closed_loop, bool lift_encoder_controlled, bool tilt_encoder_controlled ) { @@ -93,10 +97,15 @@ void ZigbeeWindowCovering::setConfigStatus( esp_zb_attribute_list_t *window_covering_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CONFIG_STATUS_ID, (void *)&config_status); + esp_err_t ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CONFIG_STATUS_ID, (void *)&config_status); + if (ret != ESP_OK) { + log_e("Failed to set config status"); + return false; + } + return true; } -void ZigbeeWindowCovering::setMode(bool motor_reversed, bool calibration_mode, bool maintenance_mode, bool leds_on) { +bool ZigbeeWindowCovering::setMode(bool motor_reversed, bool calibration_mode, bool maintenance_mode, bool leds_on) { uint8_t mode = (motor_reversed ? ESP_ZB_ZCL_ATTR_WINDOW_COVERING_TYPE_REVERSED_MOTOR_DIRECTION : 0) | (calibration_mode ? ESP_ZB_ZCL_ATTR_WINDOW_COVERING_TYPE_RUN_IN_CALIBRATION_MODE : 0) | (maintenance_mode ? ESP_ZB_ZCL_ATTR_WINDOW_COVERING_TYPE_MOTOR_IS_RUNNING_IN_MAINTENANCE_MODE : 0) @@ -106,10 +115,15 @@ void ZigbeeWindowCovering::setMode(bool motor_reversed, bool calibration_mode, b esp_zb_attribute_list_t *window_covering_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_MODE_ID, (void *)&mode); + esp_err_t ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_MODE_ID, (void *)&mode); + if (ret != ESP_OK) { + log_e("Failed to set mode"); + return false; + } + return true; } -void ZigbeeWindowCovering::setLimits( +bool ZigbeeWindowCovering::setLimits( uint16_t installed_open_limit_lift, uint16_t installed_closed_limit_lift, uint16_t installed_open_limit_tilt, uint16_t installed_closed_limit_tilt ) { _installed_open_limit_lift = installed_open_limit_lift; @@ -121,12 +135,38 @@ void ZigbeeWindowCovering::setLimits( esp_zb_attribute_list_t *window_covering_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_LIFT_ID, (void *)&_installed_open_limit_lift); - esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_LIFT_ID, (void *)&_installed_closed_limit_lift); - esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_TILT_ID, (void *)&_installed_open_limit_tilt); - esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_TILT_ID, (void *)&_installed_closed_limit_tilt); - esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_LIFT_ID, (void *)&_physical_closed_limit_lift); - esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_PHY_CLOSED_LIMIT_TILT_ID, (void *)&_physical_closed_limit_tilt); + esp_err_t ret; + 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); + if (ret != ESP_OK) { + log_e("Failed to set installed open limit lift"); + return false; + } + 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); + if (ret != ESP_OK) { + log_e("Failed to set installed closed limit lift"); + return false; + } + ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_TILT_ID, (void *)&_installed_open_limit_tilt); + if (ret != ESP_OK) { + log_e("Failed to set installed open limit tilt"); + return false; + } + 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); + if (ret != ESP_OK) { + log_e("Failed to set installed closed limit tilt"); + return false; + } + 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); + if (ret != ESP_OK) { + log_e("Failed to set physical closed limit lift"); + return false; + } + ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_PHY_CLOSED_LIMIT_TILT_ID, (void *)&_physical_closed_limit_tilt); + if (ret != ESP_OK) { + log_e("Failed to set physical closed limit tilt"); + return false; + } + return true; } // Callback for handling incoming messages and commands @@ -229,80 +269,102 @@ void ZigbeeWindowCovering::stop() { } // Methods to control window covering from user application -void ZigbeeWindowCovering::setLiftPosition(uint16_t lift_position) { +bool ZigbeeWindowCovering::setLiftPosition(uint16_t lift_position) { // Update both lift attributes _current_lift_position = lift_position; _current_lift_percentage = ((lift_position - _installed_open_limit_lift) * 100) / (_installed_closed_limit_lift - _installed_open_limit_lift); - log_v("Updating window covering lift position to %d (%d%)", _current_lift_position, _current_lift_percentage); - // set lift state + esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_lift_position = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_ID, &_current_lift_position, false ); - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_lift_percentage = esp_zb_zcl_set_attribute_val( _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, &_current_lift_percentage, false ); esp_zb_lock_release(); + + if (ret_lift_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_lift_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set lift position"); + return false; + } + return true; } -void ZigbeeWindowCovering::setLiftPercentage(uint8_t lift_percentage) { +bool ZigbeeWindowCovering::setLiftPercentage(uint8_t lift_percentage) { // Update both lift attributes _current_lift_percentage = lift_percentage; _current_lift_position = _installed_open_limit_lift + ((_installed_closed_limit_lift - _installed_open_limit_lift) * lift_percentage) / 100; - - log_v("Updating window covering lift position to %d (%d%)", _current_lift_position, _current_lift_percentage); - // set lift state + log_v("Updating window covering lift percentage to %d%% (%d)", _current_lift_percentage, _current_lift_position); + esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_lift_position = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_ID, &_current_lift_position, false ); - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_lift_percentage = esp_zb_zcl_set_attribute_val( _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, &_current_lift_percentage, false ); esp_zb_lock_release(); + + if (ret_lift_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_lift_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set lift percentage"); + return false; + } + return true; } -void ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) { +bool ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) { // Update both tilt attributes _current_tilt_position = tilt_position; _current_tilt_percentage = ((tilt_position - _installed_open_limit_tilt) * 100) / (_installed_closed_limit_tilt - _installed_open_limit_tilt); log_v("Updating window covering tilt position to %d (%d%)", _current_tilt_position, _current_tilt_percentage); - // set lift state + esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_tilt_position = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_ID, &_current_tilt_position, false ); - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_tilt_percentage = esp_zb_zcl_set_attribute_val( _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, &_current_tilt_percentage, false ); esp_zb_lock_release(); + + if (ret_tilt_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_tilt_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set tilt position"); + return false; + } + return true; } -void ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) { +bool ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) { // Update both tilt attributes _current_tilt_percentage = tilt_percentage; - _current_tilt_position = _installed_open_limit_lift + ((_installed_closed_limit_tilt - _installed_open_limit_tilt) * tilt_percentage) / 100; + _current_tilt_position = _installed_open_limit_tilt + ((_installed_closed_limit_tilt - _installed_open_limit_tilt) * tilt_percentage) / 100; - log_v("Updating window covering tilt position to %d (%d%)", _current_tilt_position, _current_tilt_percentage); - // set lift state + log_v("Updating window covering tilt percentage to %d%% (%d)", _current_tilt_percentage, _current_tilt_position); + esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_tilt_position = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_ID, &_current_tilt_position, false ); - esp_zb_zcl_set_attribute_val( + esp_zb_zcl_status_t ret_tilt_percentage = esp_zb_zcl_set_attribute_val( _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, &_current_tilt_percentage, false ); esp_zb_lock_release(); + + if (ret_tilt_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_tilt_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set tilt percentage"); + return false; + } + return true; } #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.h b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.h index f3a368370c4..288d92c5765 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.h +++ b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.h @@ -87,25 +87,25 @@ class ZigbeeWindowCovering : public ZigbeeEP { } // Set the window covering position in centimeters or percentage (0-100) - void setLiftPosition(uint16_t lift_position); - void setLiftPercentage(uint8_t lift_percentage); - void setTiltPosition(uint16_t tilt_position); - void setTiltPercentage(uint8_t tilt_percentage); + bool setLiftPosition(uint16_t lift_position); + bool setLiftPercentage(uint8_t lift_percentage); + bool setTiltPosition(uint16_t tilt_position); + bool setTiltPercentage(uint8_t tilt_percentage); // Set the window covering type (see ZigbeeWindowCoveringType) - void setCoveringType(ZigbeeWindowCoveringType covering_type); + bool setCoveringType(ZigbeeWindowCoveringType covering_type); // Set window covering config/status, for more info see esp_zb_zcl_window_covering_config_status_t - void setConfigStatus( + bool setConfigStatus( bool operational, bool online, bool commands_reversed, bool lift_closed_loop, bool tilt_closed_loop, bool lift_encoder_controlled, bool tilt_encoder_controlled ); // Set configuration mode of window covering, for more info see esp_zb_zcl_window_covering_mode_t - void setMode(bool motor_reversed, bool calibration_mode, bool maintenance_mode, bool leds_on); + bool setMode(bool motor_reversed, bool calibration_mode, bool maintenance_mode, bool leds_on); // Set limits of motion, for more info see esp_zb_zcl_window_covering_info_attr_t - void setLimits( + bool setLimits( uint16_t installed_open_limit_lift, uint16_t installed_closed_limit_lift, uint16_t installed_open_limit_tilt, uint16_t installed_closed_limit_tilt ); From 80eba948594e68195ee6639d101044c3d1239ad6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 20 Mar 2025 18:15:36 +0100 Subject: [PATCH 02/15] feat(zigbee): Add error info in the logs --- libraries/Zigbee/src/ZigbeeEP.cpp | 12 ++++---- libraries/Zigbee/src/ep/ZigbeeAnalog.cpp | 14 +++++----- .../src/ep/ZigbeeCarbonDioxideSensor.cpp | 12 ++++---- .../src/ep/ZigbeeColorDimmableLight.cpp | 2 +- .../Zigbee/src/ep/ZigbeeContactSwitch.cpp | 6 ++-- .../Zigbee/src/ep/ZigbeeDimmableLight.cpp | 2 +- .../Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp | 6 ++-- libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp | 12 ++++---- libraries/Zigbee/src/ep/ZigbeeLight.cpp | 2 +- .../Zigbee/src/ep/ZigbeeOccupancySensor.cpp | 8 +++--- .../Zigbee/src/ep/ZigbeePressureSensor.cpp | 12 ++++---- libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp | 18 ++++++------ .../Zigbee/src/ep/ZigbeeVibrationSensor.cpp | 2 +- .../Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp | 12 ++++---- .../Zigbee/src/ep/ZigbeeWindowCovering.cpp | 28 +++++++++---------- 15 files changed, 74 insertions(+), 74 deletions(-) diff --git a/libraries/Zigbee/src/ZigbeeEP.cpp b/libraries/Zigbee/src/ZigbeeEP.cpp index 5a03993db91..4b06464d54b 100644 --- a/libraries/Zigbee/src/ZigbeeEP.cpp +++ b/libraries/Zigbee/src/ZigbeeEP.cpp @@ -65,7 +65,7 @@ bool ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) { esp_err_t ret_manufacturer = esp_zb_basic_cluster_add_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID, (void *)zb_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_manufacturer != ESP_OK || ret_model != ESP_OK) { - log_e("Failed to set manufacturer and model"); + log_e("Failed to set manufacturer (0x%x) or model (0x%x)", ret_manufacturer, ret_model); return false; } return true; @@ -103,14 +103,14 @@ bool ZigbeeEP::setBatteryPercentage(uint8_t percentage) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set battery percentage"); + log_e("Failed to set battery percentage: 0x%x", ret); return false; } log_v("Battery percentage updated"); return true; } -void ZigbeeEP::reportBatteryPercentage() { +bool ZigbeeEP::reportBatteryPercentage() { /* Send report attributes command */ esp_zb_zcl_report_attr_cmd_t report_attr_cmd; report_attr_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; @@ -124,7 +124,7 @@ void ZigbeeEP::reportBatteryPercentage() { 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 report battery percentage"); + log_e("Failed to report battery percentage: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } log_v("Battery percentage reported"); @@ -287,7 +287,7 @@ bool ZigbeeEP::setTime(tm time) { 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) { - log_e("Failed to set time"); + log_e("Failed to set time: 0x%x", ret); return false; } return true; @@ -300,7 +300,7 @@ bool ZigbeeEP::setTimezone(int32_t gmt_offset) { 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) { - log_e("Failed to set timezone"); + log_e("Failed to set timezone: 0x%x", ret); return false; } return true; diff --git a/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp b/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp index 9d085694624..d7fd5a99f27 100644 --- a/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp @@ -23,7 +23,7 @@ ZigbeeAnalog::ZigbeeAnalog(uint8_t endpoint) : ZigbeeEP(endpoint) { bool ZigbeeAnalog::addAnalogValue() { esp_err_t ret = esp_zb_cluster_list_add_analog_value_cluster(_cluster_list, esp_zb_analog_value_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); if (ret != ESP_OK) { - log_e("Failed to add Analog Value cluster"); + log_e("Failed to add Analog Value cluster: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } _analog_clusters |= ANALOG_VALUE; @@ -33,7 +33,7 @@ bool ZigbeeAnalog::addAnalogValue() { bool ZigbeeAnalog::addAnalogInput() { esp_err_t ret = esp_zb_cluster_list_add_analog_input_cluster(_cluster_list, esp_zb_analog_input_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); if (ret != ESP_OK) { - log_e("Failed to add Analog Input cluster"); + log_e("Failed to add Analog Input cluster: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } _analog_clusters |= ANALOG_INPUT; @@ -43,7 +43,7 @@ bool ZigbeeAnalog::addAnalogInput() { bool ZigbeeAnalog::addAnalogOutput() { esp_err_t ret = esp_zb_cluster_list_add_analog_output_cluster(_cluster_list, esp_zb_analog_output_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); if (ret != ESP_OK) { - log_e("Failed to add Analog Output cluster"); + log_e("Failed to add Analog Output cluster: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } _analog_clusters |= ANALOG_OUTPUT; @@ -85,7 +85,7 @@ bool ZigbeeAnalog::setAnalogValue(float analog) { ); esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set analog value"); + log_e("Failed to set analog value: 0x%x", ret); return false; } return true; @@ -104,7 +104,7 @@ bool ZigbeeAnalog::setAnalogInput(float analog) { ); esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set analog input"); + log_e("Failed to set analog input: 0x%x", ret); return false; } return true; @@ -124,7 +124,7 @@ bool ZigbeeAnalog::reportAnalogInput() { 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 Analog Input report"); + log_e("Failed to send Analog Input report: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } log_v("Analog Input report sent"); @@ -151,7 +151,7 @@ bool ZigbeeAnalog::setAnalogInputReporting(uint16_t min_interval, uint16_t max_i 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 Analog Input reporting"); + log_e("Failed to set Analog Input reporting: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } return true; diff --git a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp index 599e2438210..1fc1b73d281 100644 --- a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp @@ -31,11 +31,11 @@ bool ZigbeeCarbonDioxideSensor::setMinMaxValue(float min, float max) { 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_min = 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_min != ESP_OK) { - log_e("Failed to set min value"); + log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); } esp_err_t ret_max = 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_max != ESP_OK) { - log_e("Failed to set max value"); + log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); } return ret_min == ESP_OK && ret_max == ESP_OK; } @@ -48,7 +48,7 @@ bool ZigbeeCarbonDioxideSensor::setTolerance(float tolerance) { carbon_dioxide_measure_cluster, ESP_ZB_ZCL_ATTR_CARBON_DIOXIDE_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance ); if(ret != ESP_OK) { - log_e("Failed to set tolerance"); + log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); } return ret == ESP_OK; } @@ -74,7 +74,7 @@ bool ZigbeeCarbonDioxideSensor::setReporting(uint16_t min_interval, uint16_t max 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"); + log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret)); } return ret == ESP_OK; } @@ -92,7 +92,7 @@ bool ZigbeeCarbonDioxideSensor::setCarbonDioxide(float carbon_dioxide) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set carbon dioxide"); + log_e("Failed to set carbon dioxide: 0x%x", ret); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } @@ -111,7 +111,7 @@ bool ZigbeeCarbonDioxideSensor::report() { 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 carbon dioxide report"); + log_e("Failed to send carbon dioxide report: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } log_v("Carbon dioxide report sent"); diff --git a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp index 9c741a3d0d6..0cef4215739 100644 --- a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp @@ -156,7 +156,7 @@ bool ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, esp_zb_lock_release(); if (ret_state != ESP_ZB_ZCL_STATUS_SUCCESS || ret_level != ESP_ZB_ZCL_STATUS_SUCCESS || ret_xy != ESP_ZB_ZCL_STATUS_SUCCESS || ret_y != ESP_ZB_ZCL_STATUS_SUCCESS || ret_hue != ESP_ZB_ZCL_STATUS_SUCCESS || ret_saturation != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set light attributes"); + log_e("Failed to set light state(0x%x), level(0x%x), xy(0x%x), y(0x%x), hue(0x%x), saturation(0x%x)", ret_state, ret_level, ret_xy, ret_y, ret_hue, ret_saturation); return false; } return true; diff --git a/libraries/Zigbee/src/ep/ZigbeeContactSwitch.cpp b/libraries/Zigbee/src/ep/ZigbeeContactSwitch.cpp index 31fafede4b1..ced8e43d6ea 100644 --- a/libraries/Zigbee/src/ep/ZigbeeContactSwitch.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeContactSwitch.cpp @@ -38,7 +38,7 @@ bool ZigbeeContactSwitch::setClosed() { ); esp_zb_lock_release(); if (ret != ESP_OK) { - log_e("Failed to set contact switch to closed"); + log_e("Failed to set contact switch to closed: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } _zone_status = closed; @@ -54,7 +54,7 @@ bool ZigbeeContactSwitch::setOpen() { ); esp_zb_lock_release(); if (ret != ESP_OK) { - log_e("Failed to set contact switch to open"); + log_e("Failed to set contact switch to open: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } _zone_status = open; @@ -79,7 +79,7 @@ bool ZigbeeContactSwitch::report() { esp_err_t ret = esp_zb_zcl_ias_zone_status_change_notif_cmd_req(&status_change_notif_cmd); esp_zb_lock_release(); if (ret != ESP_OK) { - log_e("Failed to send IAS Zone status changed notification"); + log_e("Failed to send IAS Zone status changed notification: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } log_v("IAS Zone status changed notification sent"); diff --git a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp index 9723e1045eb..be0941c0531 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp @@ -71,7 +71,7 @@ bool ZigbeeDimmableLight::setLight(bool state, uint8_t level) { esp_zb_lock_release(); if (ret_state != ESP_ZB_ZCL_STATUS_SUCCESS || ret_level != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set light state and level"); + log_e("Failed to set light state(0x%x) or level(0x%x)", ret_state, ret_level); return false; } return true; diff --git a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp index b298571a780..fcbd75f5325 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp @@ -39,7 +39,7 @@ bool ZigbeeDoorWindowHandle::setClosed() { ); esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set door/window handle to closed"); + log_e("Failed to set door/window handle to closed: 0x%x", ret); return false; } _zone_status = closed; @@ -57,7 +57,7 @@ bool ZigbeeDoorWindowHandle::setOpen() { ); esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set door/window handle to open"); + log_e("Failed to set door/window handle to open: 0x%x", ret); return false; } _zone_status = open; @@ -75,7 +75,7 @@ bool ZigbeeDoorWindowHandle::setTilted() { ); esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set door/window handle to tilted"); + log_e("Failed to set door/window handle to tilted: 0x%x", ret); return false; } _zone_status = tilted; diff --git a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp index 51ed5d931a4..1be94c98b97 100644 --- a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp @@ -33,11 +33,11 @@ bool ZigbeeFlowSensor::setMinMaxValue(float min, float max) { } esp_err_t ret_min = esp_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min); if(ret_min != ESP_OK) { - log_e("Failed to set min value"); + log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); } esp_err_t ret_max = esp_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max); if(ret_max != ESP_OK) { - log_e("Failed to set max value"); + log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); } return ret_min == ESP_OK && ret_max == ESP_OK; } @@ -52,7 +52,7 @@ bool ZigbeeFlowSensor::setTolerance(float tolerance) { } esp_err_t ret = esp_zb_flow_meas_cluster_add_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance); if (ret != ESP_OK) { - log_e("Failed to set tolerance"); + log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } return true; @@ -79,7 +79,7 @@ bool ZigbeeFlowSensor::setReporting(uint16_t min_interval, uint16_t max_interval esp_zb_lock_release(); if (ret != ESP_OK) { - log_e("Failed to set reporting"); + log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } return true; @@ -99,7 +99,7 @@ bool ZigbeeFlowSensor::setFlow(float flow) { esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set flow value"); + log_e("Failed to set flow value: 0x%x", ret); return false; } return true; @@ -120,7 +120,7 @@ bool ZigbeeFlowSensor::report() { esp_zb_lock_release(); if (ret != ESP_OK) { - log_e("Failed to send flow report"); + log_e("Failed to send flow report: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } log_v("Flow report sent"); diff --git a/libraries/Zigbee/src/ep/ZigbeeLight.cpp b/libraries/Zigbee/src/ep/ZigbeeLight.cpp index e5c5f7ec4ec..86045267d8c 100644 --- a/libraries/Zigbee/src/ep/ZigbeeLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeLight.cpp @@ -47,7 +47,7 @@ bool ZigbeeLight::setLight(bool state) { esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set light state"); + log_e("Failed to set light state: 0x%x", ret); return false; } return true; diff --git a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp index 7d348eccae4..d230bb5d994 100644 --- a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp @@ -28,11 +28,11 @@ bool ZigbeeOccupancySensor::setSensorType(uint8_t sensor_type) { 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_type = esp_zb_cluster_update_attr(occupancy_sens_cluster, ESP_ZB_ZCL_ATTR_OCCUPANCY_SENSING_OCCUPANCY_SENSOR_TYPE_ID, (void *)&sensor_type); if(ret_type != ESP_OK) { - log_e("Failed to set sensor type"); + log_e("Failed to set sensor type: 0x%x: %s", ret_type, esp_err_to_name(ret_type)); } esp_err_t ret_bitmap = 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_bitmap != ESP_OK) { - log_e("Failed to set sensor type bitmap"); + log_e("Failed to set sensor type bitmap: 0x%x: %s", ret_bitmap, esp_err_to_name(ret_bitmap)); } return ret_type == ESP_OK && ret_bitmap == ESP_OK; } @@ -48,7 +48,7 @@ bool ZigbeeOccupancySensor::setOccupancy(bool occupied) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set occupancy"); + log_e("Failed to set occupancy: 0x%x", ret); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } @@ -67,7 +67,7 @@ bool ZigbeeOccupancySensor::report() { 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 occupancy report"); + log_e("Failed to send occupancy report: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } log_v("Occupancy report sent"); diff --git a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp b/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp index d8d453b0062..86f86789791 100644 --- a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp @@ -27,11 +27,11 @@ bool ZigbeePressureSensor::setMinMaxValue(int16_t min, int16_t max) { 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_min = esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MIN_VALUE_ID, (void *)&min); if(ret_min != ESP_OK) { - log_e("Failed to set min value"); + log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); } esp_err_t ret_max = esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MAX_VALUE_ID, (void *)&max); if(ret_max != ESP_OK) { - log_e("Failed to set max value"); + log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); } return ret_min == ESP_OK && ret_max == ESP_OK; } @@ -41,7 +41,7 @@ bool ZigbeePressureSensor::setTolerance(uint16_t tolerance) { 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) { - log_e("Failed to set tolerance"); + log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); } return ret == ESP_OK; } @@ -65,7 +65,7 @@ bool ZigbeePressureSensor::setReporting(uint16_t min_interval, uint16_t max_inte 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"); + log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret)); } return ret == ESP_OK; } @@ -81,7 +81,7 @@ bool ZigbeePressureSensor::setPressure(int16_t pressure) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set pressure"); + log_e("Failed to set pressure: 0x%x", ret); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } @@ -100,7 +100,7 @@ bool ZigbeePressureSensor::report() { 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 pressure report"); + log_e("Failed to send pressure report: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } log_v("Pressure report sent"); diff --git a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp index 304ec483884..403d7590b6a 100644 --- a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp @@ -24,11 +24,11 @@ bool ZigbeeTempSensor::setMinMaxValue(float min, float max) { esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); esp_err_t ret_min = esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min); if(ret_min != ESP_OK) { - log_e("Failed to set min value"); + log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); } esp_err_t ret_max = esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max); if(ret_max != ESP_OK) { - log_e("Failed to set max value"); + log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); } return ret_min == ESP_OK && ret_max == ESP_OK; } @@ -40,7 +40,7 @@ bool ZigbeeTempSensor::setTolerance(float tolerance) { esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); 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); if(ret != ESP_OK) { - log_e("Failed to set tolerance"); + log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); } return ret == ESP_OK; } @@ -64,7 +64,7 @@ bool ZigbeeTempSensor::setReporting(uint16_t min_interval, uint16_t max_interval 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"); + log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret)); } return ret == ESP_OK; } @@ -81,7 +81,7 @@ bool ZigbeeTempSensor::setTemperature(float temperature) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set temperature"); + log_e("Failed to set temperature: 0x%x", ret); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } @@ -100,7 +100,7 @@ bool ZigbeeTempSensor::reportTemperature() { 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 temperature report"); + log_e("Failed to send temperature report: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } log_v("Temperature report sent"); @@ -134,7 +134,7 @@ bool ZigbeeTempSensor::setHumidity(float humidity) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set humidity"); + log_e("Failed to set humidity: 0x%x", ret); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } @@ -153,7 +153,7 @@ bool ZigbeeTempSensor::reportHumidity() { 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 humidity report"); + log_e("Failed to send humidity report: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } log_v("Humidity report sent"); @@ -179,7 +179,7 @@ bool ZigbeeTempSensor::setHumidityReporting(uint16_t min_interval, uint16_t max_ 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 humidity reporting"); + log_e("Failed to set humidity reporting: 0x%x: %s", ret, esp_err_to_name(ret) ); } return ret == ESP_OK; } diff --git a/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp index 1482386a0ce..4556dde57b0 100644 --- a/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp @@ -39,7 +39,7 @@ bool ZigbeeVibrationSensor::setVibration(bool sensed) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set vibration status"); + log_e("Failed to set vibration status: 0x%x", ret); return false; } _zone_status = vibration; diff --git a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp index 1754acb4a97..4e63237efbc 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp @@ -35,11 +35,11 @@ bool ZigbeeWindSpeedSensor::setMinMaxValue(float min, float max) { esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); esp_err_t ret_min = esp_zb_cluster_update_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&zb_min); if(ret_min != ESP_OK) { - log_e("Failed to set min value"); + log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); } esp_err_t ret_max = esp_zb_cluster_update_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&zb_max); if(ret_max != ESP_OK) { - log_e("Failed to set max value"); + log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); } return ret_min == ESP_OK && ret_max == ESP_OK; } @@ -51,7 +51,7 @@ bool ZigbeeWindSpeedSensor::setTolerance(float tolerance) { esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); 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); if(ret != ESP_OK) { - log_e("Failed to set tolerance"); + log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); } return ret == ESP_OK; } @@ -75,7 +75,7 @@ bool ZigbeeWindSpeedSensor::setReporting(uint16_t min_interval, uint16_t max_int 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"); + log_e("Failed to set reporting: 0x%x: %s", ret, esp_err_to_name(ret)); } return ret == ESP_OK; } @@ -93,7 +93,7 @@ bool ZigbeeWindSpeedSensor::setWindSpeed(float windspeed) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set wind speed"); + log_e("Failed to set wind speed: 0x%x", ret); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } @@ -112,7 +112,7 @@ bool ZigbeeWindSpeedSensor::reportWindSpeed() { 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 wind speed report"); + log_e("Failed to send wind speed report: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } log_v("Wind speed measurement report sent"); diff --git a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp index f2ecbcc668f..6652f9a0efd 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp @@ -76,7 +76,7 @@ bool ZigbeeWindowCovering::setCoveringType(ZigbeeWindowCoveringType covering_typ esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); esp_err_t ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_WINDOW_COVERING_TYPE_ID, (void *)&covering_type); if (ret != ESP_OK) { - log_e("Failed to set covering type"); + log_e("Failed to set covering type: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } return true; @@ -99,7 +99,7 @@ bool ZigbeeWindowCovering::setConfigStatus( esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); esp_err_t ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CONFIG_STATUS_ID, (void *)&config_status); if (ret != ESP_OK) { - log_e("Failed to set config status"); + log_e("Failed to set config status: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } return true; @@ -117,7 +117,7 @@ bool ZigbeeWindowCovering::setMode(bool motor_reversed, bool calibration_mode, b esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); esp_err_t ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_MODE_ID, (void *)&mode); if (ret != ESP_OK) { - log_e("Failed to set mode"); + log_e("Failed to set mode: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } return true; @@ -132,38 +132,38 @@ bool ZigbeeWindowCovering::setLimits( _installed_open_limit_tilt = installed_open_limit_tilt; _installed_closed_limit_tilt = installed_closed_limit_tilt; _physical_closed_limit_tilt = installed_closed_limit_tilt; + esp_err_t ret; esp_zb_attribute_list_t *window_covering_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_err_t ret; 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); if (ret != ESP_OK) { - log_e("Failed to set installed open limit lift"); + log_e("Failed to set installed open limit lift: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } 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); if (ret != ESP_OK) { - log_e("Failed to set installed closed limit lift"); + log_e("Failed to set installed closed limit lift: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_TILT_ID, (void *)&_installed_open_limit_tilt); if (ret != ESP_OK) { - log_e("Failed to set installed open limit tilt"); + log_e("Failed to set installed open limit tilt: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } 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); if (ret != ESP_OK) { - log_e("Failed to set installed closed limit tilt"); + log_e("Failed to set installed closed limit tilt: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } 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); if (ret != ESP_OK) { - log_e("Failed to set physical closed limit lift"); + log_e("Failed to set physical closed limit lift: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } ret = esp_zb_cluster_update_attr(window_covering_cluster, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_PHY_CLOSED_LIMIT_TILT_ID, (void *)&_physical_closed_limit_tilt); if (ret != ESP_OK) { - log_e("Failed to set physical closed limit tilt"); + log_e("Failed to set physical closed limit tilt: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } return true; @@ -287,7 +287,7 @@ bool ZigbeeWindowCovering::setLiftPosition(uint16_t lift_position) { esp_zb_lock_release(); if (ret_lift_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_lift_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set lift position"); + log_e("Failed to set lift position(0x%x) or lift percentage(0x%x)", ret_lift_position, ret_lift_percentage); return false; } return true; @@ -311,7 +311,7 @@ bool ZigbeeWindowCovering::setLiftPercentage(uint8_t lift_percentage) { esp_zb_lock_release(); if (ret_lift_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_lift_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set lift percentage"); + log_e("Failed to set lift position(0x%x) or lift percentage(0x%x)", ret_lift_position, ret_lift_percentage); return false; } return true; @@ -336,7 +336,7 @@ bool ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) { esp_zb_lock_release(); if (ret_tilt_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_tilt_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set tilt position"); + log_e("Failed to set tilt position(0x%x) or tilt percentage(0x%x)", ret_tilt_position, ret_tilt_percentage); return false; } return true; @@ -361,7 +361,7 @@ bool ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) { esp_zb_lock_release(); if (ret_tilt_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_tilt_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set tilt percentage"); + log_e("Failed to set tilt position(0x%x) or tilt percentage(0x%x)", ret_tilt_position, ret_tilt_percentage); return false; } return true; From 160e286db8002225a9d6634059e568c8aa42c809 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 15:07:37 +0100 Subject: [PATCH 03/15] fix(zigbee): Fix memory leak, print esp_zb_zcl_status_t error, remove analogValue from analog EP --- libraries/Zigbee/src/ZigbeeCore.cpp | 15 +- libraries/Zigbee/src/ZigbeeCore.h | 2 +- libraries/Zigbee/src/ZigbeeEP.cpp | 145 ++++++++++++++---- libraries/Zigbee/src/ZigbeeEP.h | 10 +- libraries/Zigbee/src/ep/ZigbeeAnalog.cpp | 47 +----- libraries/Zigbee/src/ep/ZigbeeAnalog.h | 27 +--- .../src/ep/ZigbeeCarbonDioxideSensor.cpp | 2 +- .../src/ep/ZigbeeColorDimmableLight.cpp | 2 +- .../Zigbee/src/ep/ZigbeeDimmableLight.cpp | 2 +- .../Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp | 6 +- libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp | 2 +- libraries/Zigbee/src/ep/ZigbeeLight.cpp | 2 +- .../Zigbee/src/ep/ZigbeeOccupancySensor.cpp | 2 +- .../Zigbee/src/ep/ZigbeePressureSensor.cpp | 2 +- libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp | 4 +- .../Zigbee/src/ep/ZigbeeVibrationSensor.cpp | 2 +- .../Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp | 2 +- .../Zigbee/src/ep/ZigbeeWindowCovering.cpp | 8 +- 18 files changed, 160 insertions(+), 122 deletions(-) diff --git a/libraries/Zigbee/src/ZigbeeCore.cpp b/libraries/Zigbee/src/ZigbeeCore.cpp index 2200aec2662..0bb2cb559cf 100644 --- a/libraries/Zigbee/src/ZigbeeCore.cpp +++ b/libraries/Zigbee/src/ZigbeeCore.cpp @@ -368,16 +368,23 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) { case ESP_ZB_ZDO_SIGNAL_LEAVE: // End Device + Router // Device was removed from the network, factory reset the device if ((zigbee_role_t)Zigbee.getRole() != ZIGBEE_COORDINATOR) { - Zigbee.factoryReset(); + Zigbee.factoryReset(true); } break; default: log_v("ZDO signal: %s (0x%x), status: %s", esp_zb_zdo_signal_to_string(sig_type), sig_type, esp_err_to_name(err_status)); break; } } -void ZigbeeCore::factoryReset() { - log_v("Factory resetting Zigbee stack, device will reboot"); - esp_zb_factory_reset(); +void ZigbeeCore::factoryReset(bool restart) { + if (restart) { + log_v("Factory resetting Zigbee stack, device will reboot"); + esp_zb_factory_reset(); + } + 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(); + } } void ZigbeeCore::scanCompleteCallback(esp_zb_zdp_status_t zdo_status, uint8_t count, esp_zb_network_descriptor_t *nwk_descriptor) { diff --git a/libraries/Zigbee/src/ZigbeeCore.h b/libraries/Zigbee/src/ZigbeeCore.h index 018f701d6e0..114808e2e46 100644 --- a/libraries/Zigbee/src/ZigbeeCore.h +++ b/libraries/Zigbee/src/ZigbeeCore.h @@ -164,7 +164,7 @@ class ZigbeeCore { zigbee_scan_result_t *getScanResult(); void scanDelete(); - void factoryReset(); + void factoryReset(bool restart = true); // Friend function declaration to allow access to private members friend void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct); diff --git a/libraries/Zigbee/src/ZigbeeEP.cpp b/libraries/Zigbee/src/ZigbeeEP.cpp index 4b06464d54b..c777f21b639 100644 --- a/libraries/Zigbee/src/ZigbeeEP.cpp +++ b/libraries/Zigbee/src/ZigbeeEP.cpp @@ -34,31 +34,24 @@ void ZigbeeEP::setVersion(uint8_t version) { bool ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) { // Convert manufacturer to ZCL string - size_t length = strlen(name); - if (length > 32) { - log_e("Manufacturer name is too long"); + size_t name_length = strlen(name); + size_t model_length = strlen(model); + if (name_length > 32 || model_length > 32) { + log_e("Manufacturer or model name is too long"); return false; } // Allocate a new array of size length + 2 (1 for the length, 1 for null terminator) - char *zb_name = new char[length + 2]; + char *zb_name = new char[name_length + 2]; + char *zb_model = new char[model_length + 2]; // Store the length as the first element - zb_name[0] = static_cast(length); // Cast size_t to char + zb_name[0] = static_cast(name_length); // Cast size_t to char + zb_model[0] = static_cast(model_length); // Use memcpy to copy the characters to the result array - memcpy(zb_name + 1, name, length); + memcpy(zb_name + 1, name, name_length); + memcpy(zb_model + 1, model, model_length); // Null-terminate the array - zb_name[length + 1] = '\0'; - - // Convert model to ZCL string - length = strlen(model); - if (length > 32) { - log_e("Model name is too long"); - delete[] zb_name; - return false; - } - char *zb_model = new char[length + 2]; - zb_model[0] = static_cast(length); - memcpy(zb_model + 1, model, length); - zb_model[length + 1] = '\0'; + zb_name[name_length + 1] = '\0'; + zb_model[model_length + 1] = '\0'; // Get the basic cluster and update the manufacturer and model attributes esp_zb_attribute_list_t *basic_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_BASIC, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); @@ -66,9 +59,11 @@ bool ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) { 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_manufacturer != ESP_OK || ret_model != ESP_OK) { log_e("Failed to set manufacturer (0x%x) or model (0x%x)", ret_manufacturer, ret_model); - return false; } - return true; + + delete[] zb_name; + delete[] zb_model; + return ret_manufacturer == ESP_OK && ret_model == ESP_OK; } void ZigbeeEP::setPowerSource(zb_power_source_t power_source, uint8_t battery_percentage) { @@ -103,7 +98,7 @@ bool ZigbeeEP::setBatteryPercentage(uint8_t percentage) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set battery percentage: 0x%x", ret); + log_e("Failed to set battery percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } log_v("Battery percentage updated"); @@ -153,7 +148,9 @@ char *ZigbeeEP::readManufacturer(uint8_t endpoint, uint16_t short_addr, esp_zb_i read_req.attr_number = ZB_ARRAY_LENTH(attributes); read_req.attr_field = attributes; - // clear read manufacturer + if (_read_manufacturer != nullptr) { + free(_read_manufacturer); + } _read_manufacturer = nullptr; esp_zb_lock_acquire(portMAX_DELAY); @@ -189,7 +186,9 @@ char *ZigbeeEP::readModel(uint8_t endpoint, uint16_t short_addr, esp_zb_ieee_add read_req.attr_number = ZB_ARRAY_LENTH(attributes); read_req.attr_field = attributes; - // clear read model + if (_read_model != nullptr) { + free(_read_model); + } _read_model = nullptr; esp_zb_lock_acquire(portMAX_DELAY); @@ -287,7 +286,7 @@ bool ZigbeeEP::setTime(tm time) { 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) { - log_e("Failed to set time: 0x%x", ret); + log_e("Failed to set time: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } return true; @@ -300,7 +299,7 @@ bool ZigbeeEP::setTimezone(int32_t gmt_offset) { 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) { - log_e("Failed to set timezone: 0x%x", ret); + log_e("Failed to set timezone: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } return true; @@ -422,7 +421,7 @@ 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( +bool 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 ) { @@ -442,11 +441,23 @@ void ZigbeeEP::addOTAClient( uint16_t ota_upgrade_server_addr = 0xffff; uint8_t ota_upgrade_server_ep = 0xff; - esp_zb_ota_cluster_add_attr(ota_cluster, ESP_ZB_ZCL_ATTR_OTA_UPGRADE_CLIENT_DATA_ID, (void *)&variable_config); - esp_zb_ota_cluster_add_attr(ota_cluster, ESP_ZB_ZCL_ATTR_OTA_UPGRADE_SERVER_ADDR_ID, (void *)&ota_upgrade_server_addr); - esp_zb_ota_cluster_add_attr(ota_cluster, ESP_ZB_ZCL_ATTR_OTA_UPGRADE_SERVER_ENDPOINT_ID, (void *)&ota_upgrade_server_ep); - + esp_err_t ret = esp_zb_ota_cluster_add_attr(ota_cluster, ESP_ZB_ZCL_ATTR_OTA_UPGRADE_CLIENT_DATA_ID, (void *)&variable_config); + if (ret != ESP_OK) { + log_e("Failed to add OTA client data: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } + ret = esp_zb_ota_cluster_add_attr(ota_cluster, ESP_ZB_ZCL_ATTR_OTA_UPGRADE_SERVER_ADDR_ID, (void *)&ota_upgrade_server_addr); + if (ret != ESP_OK) { + log_e("Failed to add OTA server address: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } + ret = esp_zb_ota_cluster_add_attr(ota_cluster, ESP_ZB_ZCL_ATTR_OTA_UPGRADE_SERVER_ENDPOINT_ID, (void *)&ota_upgrade_server_ep); + if (ret != ESP_OK) { + log_e("Failed to add OTA server endpoint: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } esp_zb_cluster_list_add_ota_cluster(_cluster_list, ota_cluster, ESP_ZB_ZCL_CLUSTER_CLIENT_ROLE); + return true; } static void findOTAServer(esp_zb_zdp_status_t zdo_status, uint16_t addr, uint8_t endpoint, void *user_ctx) { @@ -477,4 +488,76 @@ void ZigbeeEP::requestOTAUpdate() { esp_zb_lock_release(); } +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"; + } +} + + #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ZigbeeEP.h b/libraries/Zigbee/src/ZigbeeEP.h index 32be6d9b49f..9ee3446e836 100644 --- a/libraries/Zigbee/src/ZigbeeEP.h +++ b/libraries/Zigbee/src/ZigbeeEP.h @@ -104,8 +104,9 @@ class ZigbeeEP { * @param manufacturer The manufacturer code (default: 0x1001). * @param image_type The image type code (default: 0x1011). * @param max_data_size The maximum data size for OTA transfer (default and recommended: 223). + * @return true if the OTA client was added successfully, false otherwise. */ - void addOTAClient( + bool 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 ); @@ -114,10 +115,10 @@ class ZigbeeEP { */ void requestOTAUpdate(); - // findEndpoind may be implemented by EPs to find and bind devices + // findEndpoint may be implemented by EPs to find and bind devices virtual void findEndpoint(esp_zb_zdo_match_desc_req_param_t *cmd_req) {}; - //list of all handlers function calls, to be override by EPs implementation + // list of all handlers function calls, to be override by EPs implementation virtual void zbAttributeSet(const esp_zb_zcl_set_attr_value_message_t *message) {}; virtual void zbAttributeRead(uint16_t cluster_id, const esp_zb_zcl_attribute_t *attribute) {}; virtual void zbReadBasicCluster(const esp_zb_zcl_attribute_t *attribute); //already implemented @@ -144,6 +145,9 @@ class ZigbeeEP { int32_t _read_timezone; protected: + // Convert ZCL status to name + 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; diff --git a/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp b/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp index d7fd5a99f27..a95668b7afe 100644 --- a/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeAnalog.cpp @@ -1,35 +1,17 @@ #include "ZigbeeAnalog.h" #if CONFIG_ZB_ENABLED -esp_zb_cluster_list_t *zigbee_analog_clusters_create(zigbee_analog_cfg_t *analog_sensor) { - esp_zb_basic_cluster_cfg_t *basic_cfg = analog_sensor ? &(analog_sensor->basic_cfg) : NULL; - esp_zb_identify_cluster_cfg_t *identify_cfg = analog_sensor ? &(analog_sensor->identify_cfg) : NULL; - esp_zb_cluster_list_t *cluster_list = esp_zb_zcl_cluster_list_create(); - esp_zb_cluster_list_add_basic_cluster(cluster_list, esp_zb_basic_cluster_create(basic_cfg), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_cluster_list_add_identify_cluster(cluster_list, esp_zb_identify_cluster_create(identify_cfg), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - return cluster_list; -} - ZigbeeAnalog::ZigbeeAnalog(uint8_t endpoint) : ZigbeeEP(endpoint) { _device_id = ESP_ZB_HA_SIMPLE_SENSOR_DEVICE_ID; - //Create custom analog sensor configuration - zigbee_analog_cfg_t analog_cfg = ZIGBEE_DEFAULT_ANALOG_CONFIG(); - _cluster_list = zigbee_analog_clusters_create(&analog_cfg); + //Create basic analog sensor clusters without configuration + _cluster_list = esp_zb_zcl_cluster_list_create(); + esp_zb_cluster_list_add_basic_cluster(_cluster_list, esp_zb_basic_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); + esp_zb_cluster_list_add_identify_cluster(_cluster_list, esp_zb_identify_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); _ep_config = {.endpoint = _endpoint, .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID, .app_device_id = ESP_ZB_HA_SIMPLE_SENSOR_DEVICE_ID, .app_device_version = 0}; } -bool ZigbeeAnalog::addAnalogValue() { - esp_err_t ret = esp_zb_cluster_list_add_analog_value_cluster(_cluster_list, esp_zb_analog_value_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - if (ret != ESP_OK) { - log_e("Failed to add Analog Value cluster: 0x%x: %s", ret, esp_err_to_name(ret)); - return false; - } - _analog_clusters |= ANALOG_VALUE; - return true; -} - bool ZigbeeAnalog::addAnalogInput() { esp_err_t ret = esp_zb_cluster_list_add_analog_input_cluster(_cluster_list, esp_zb_analog_input_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); if (ret != ESP_OK) { @@ -72,25 +54,6 @@ void ZigbeeAnalog::analogOutputChanged(float analog_output) { } } -bool ZigbeeAnalog::setAnalogValue(float analog) { - esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; - if (!(_analog_clusters & ANALOG_VALUE)) { - log_e("Analog Value cluster not added"); - return false; - } - log_d("Setting analog value to %.1f", analog); - esp_zb_lock_acquire(portMAX_DELAY); - ret = esp_zb_zcl_set_attribute_val( - _endpoint, ESP_ZB_ZCL_CLUSTER_ID_ANALOG_VALUE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_ANALOG_VALUE_PRESENT_VALUE_ID, &analog, false - ); - esp_zb_lock_release(); - if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set analog value: 0x%x", ret); - return false; - } - return true; -} - bool ZigbeeAnalog::setAnalogInput(float analog) { esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; if (!(_analog_clusters & ANALOG_INPUT)) { @@ -104,7 +67,7 @@ bool ZigbeeAnalog::setAnalogInput(float analog) { ); esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set analog input: 0x%x", ret); + log_e("Failed to set analog input: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } return true; diff --git a/libraries/Zigbee/src/ep/ZigbeeAnalog.h b/libraries/Zigbee/src/ep/ZigbeeAnalog.h index a009cd435fa..03fbc678b6e 100644 --- a/libraries/Zigbee/src/ep/ZigbeeAnalog.h +++ b/libraries/Zigbee/src/ep/ZigbeeAnalog.h @@ -9,32 +9,15 @@ #include "ZigbeeEP.h" #include "ha/esp_zigbee_ha_standard.h" -// clang-format off -#define ZIGBEE_DEFAULT_ANALOG_CONFIG() \ - { \ - .basic_cfg = \ - { \ - .zcl_version = ESP_ZB_ZCL_BASIC_ZCL_VERSION_DEFAULT_VALUE, \ - .power_source = ESP_ZB_ZCL_BASIC_POWER_SOURCE_DEFAULT_VALUE, \ - }, \ - .identify_cfg = \ - { \ - .identify_time = ESP_ZB_ZCL_IDENTIFY_IDENTIFY_TIME_DEFAULT_VALUE, \ - }, \ - } -// clang-format on - //enum for bits set to check what analog cluster were added enum zigbee_analog_clusters { - ANALOG_VALUE = 1, - ANALOG_INPUT = 2, - ANALOG_OUTPUT = 4 + ANALOG_INPUT = 1, + ANALOG_OUTPUT = 2 }; typedef struct zigbee_analog_cfg_s { esp_zb_basic_cluster_cfg_t basic_cfg; esp_zb_identify_cluster_cfg_t identify_cfg; - esp_zb_analog_value_cluster_cfg_t analog_value_cfg; esp_zb_analog_output_cluster_cfg_t analog_output_cfg; esp_zb_analog_input_cluster_cfg_t analog_input_cfg; } zigbee_analog_cfg_t; @@ -45,7 +28,6 @@ class ZigbeeAnalog : public ZigbeeEP { ~ZigbeeAnalog() {} // Add analog clusters - bool addAnalogValue(); bool addAnalogInput(); bool addAnalogOutput(); @@ -54,11 +36,10 @@ class ZigbeeAnalog : public ZigbeeEP { _on_analog_output_change = callback; } - // Set the analog value / input - bool setAnalogValue(float analog); + // Set the analog input value bool setAnalogInput(float analog); - // Report Analog Input + // Report Analog Input value bool reportAnalogInput(); // Set reporting for Analog Input diff --git a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp index 1fc1b73d281..99ab3c34278 100644 --- a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp @@ -92,7 +92,7 @@ bool ZigbeeCarbonDioxideSensor::setCarbonDioxide(float carbon_dioxide) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set carbon dioxide: 0x%x", ret); + log_e("Failed to set carbon dioxide: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } diff --git a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp index 0cef4215739..f0e5a29982d 100644 --- a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp @@ -156,7 +156,7 @@ bool ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, esp_zb_lock_release(); if (ret_state != ESP_ZB_ZCL_STATUS_SUCCESS || ret_level != ESP_ZB_ZCL_STATUS_SUCCESS || ret_xy != ESP_ZB_ZCL_STATUS_SUCCESS || ret_y != ESP_ZB_ZCL_STATUS_SUCCESS || ret_hue != ESP_ZB_ZCL_STATUS_SUCCESS || ret_saturation != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set light state(0x%x), level(0x%x), xy(0x%x), y(0x%x), hue(0x%x), saturation(0x%x)", ret_state, ret_level, ret_xy, ret_y, ret_hue, ret_saturation); + log_e("Failed to set light state(0x%x: %s), level(0x%x: %s), xy(0x%x: %s), y(0x%x: %s), hue(0x%x: %s), saturation(0x%x: %s)", ret_state, esp_zb_zcl_status_to_name(ret_state), ret_level, esp_zb_zcl_status_to_name(ret_level), ret_xy, esp_zb_zcl_status_to_name(ret_xy), ret_y, esp_zb_zcl_status_to_name(ret_y), ret_hue, esp_zb_zcl_status_to_name(ret_hue), ret_saturation, esp_zb_zcl_status_to_name(ret_saturation)); return false; } return true; diff --git a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp index be0941c0531..2cc8152603b 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp @@ -71,7 +71,7 @@ bool ZigbeeDimmableLight::setLight(bool state, uint8_t level) { esp_zb_lock_release(); if (ret_state != ESP_ZB_ZCL_STATUS_SUCCESS || ret_level != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set light state(0x%x) or level(0x%x)", ret_state, ret_level); + log_e("Failed to set light state(0x%x: %s) or level(0x%x: %s)", ret_state, esp_zb_zcl_status_to_name(ret_state), ret_level, esp_zb_zcl_status_to_name(ret_level)); return false; } return true; diff --git a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp index fcbd75f5325..b392676506f 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp @@ -39,7 +39,7 @@ bool ZigbeeDoorWindowHandle::setClosed() { ); esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set door/window handle to closed: 0x%x", ret); + log_e("Failed to set door/window handle to closed: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } _zone_status = closed; @@ -57,7 +57,7 @@ bool ZigbeeDoorWindowHandle::setOpen() { ); esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set door/window handle to open: 0x%x", ret); + log_e("Failed to set door/window handle to open: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } _zone_status = open; @@ -75,7 +75,7 @@ bool ZigbeeDoorWindowHandle::setTilted() { ); esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set door/window handle to tilted: 0x%x", ret); + log_e("Failed to set door/window handle to tilted: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } _zone_status = tilted; diff --git a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp index 1be94c98b97..d56a441632e 100644 --- a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp @@ -99,7 +99,7 @@ bool ZigbeeFlowSensor::setFlow(float flow) { esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set flow value: 0x%x", ret); + log_e("Failed to set flow value: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } return true; diff --git a/libraries/Zigbee/src/ep/ZigbeeLight.cpp b/libraries/Zigbee/src/ep/ZigbeeLight.cpp index 86045267d8c..edfac04fcdf 100644 --- a/libraries/Zigbee/src/ep/ZigbeeLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeLight.cpp @@ -47,7 +47,7 @@ bool ZigbeeLight::setLight(bool state) { esp_zb_lock_release(); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set light state: 0x%x", ret); + log_e("Failed to set light state: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } return true; diff --git a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp index d230bb5d994..fd53471f02d 100644 --- a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp @@ -48,7 +48,7 @@ bool ZigbeeOccupancySensor::setOccupancy(bool occupied) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set occupancy: 0x%x", ret); + log_e("Failed to set occupancy: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } diff --git a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp b/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp index 86f86789791..948cb62d02f 100644 --- a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp @@ -81,7 +81,7 @@ bool ZigbeePressureSensor::setPressure(int16_t pressure) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set pressure: 0x%x", ret); + log_e("Failed to set pressure: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } diff --git a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp index 403d7590b6a..8484e99ace8 100644 --- a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp @@ -81,7 +81,7 @@ bool ZigbeeTempSensor::setTemperature(float temperature) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set temperature: 0x%x", ret); + log_e("Failed to set temperature: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } @@ -134,7 +134,7 @@ bool ZigbeeTempSensor::setHumidity(float humidity) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set humidity: 0x%x", ret); + log_e("Failed to set humidity: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } diff --git a/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp index 4556dde57b0..96c0fa242d4 100644 --- a/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp @@ -39,7 +39,7 @@ bool ZigbeeVibrationSensor::setVibration(bool sensed) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set vibration status: 0x%x", ret); + log_e("Failed to set vibration status: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } _zone_status = vibration; diff --git a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp index 4e63237efbc..6dbc55d7351 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp @@ -93,7 +93,7 @@ bool ZigbeeWindSpeedSensor::setWindSpeed(float windspeed) { ); esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set wind speed: 0x%x", ret); + log_e("Failed to set wind speed: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); } return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } diff --git a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp index 6652f9a0efd..aaa21e6a6bf 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp @@ -287,7 +287,7 @@ bool ZigbeeWindowCovering::setLiftPosition(uint16_t lift_position) { esp_zb_lock_release(); if (ret_lift_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_lift_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set lift position(0x%x) or lift percentage(0x%x)", ret_lift_position, ret_lift_percentage); + log_e("Failed to set lift position(0x%x: %s) or lift percentage(0x%x: %s)", ret_lift_position, esp_zb_zcl_status_to_name(ret_lift_position), ret_lift_percentage, esp_zb_zcl_status_to_name(ret_lift_percentage)); return false; } return true; @@ -311,7 +311,7 @@ bool ZigbeeWindowCovering::setLiftPercentage(uint8_t lift_percentage) { esp_zb_lock_release(); if (ret_lift_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_lift_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set lift position(0x%x) or lift percentage(0x%x)", ret_lift_position, ret_lift_percentage); + log_e("Failed to set lift position(0x%x: %s) or lift percentage(0x%x: %s)", ret_lift_position, esp_zb_zcl_status_to_name(ret_lift_position), ret_lift_percentage, esp_zb_zcl_status_to_name(ret_lift_percentage)); return false; } return true; @@ -336,7 +336,7 @@ bool ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) { esp_zb_lock_release(); if (ret_tilt_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_tilt_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set tilt position(0x%x) or tilt percentage(0x%x)", ret_tilt_position, ret_tilt_percentage); + log_e("Failed to set tilt position(0x%x: %s) or tilt percentage(0x%x: %s)", ret_tilt_position, esp_zb_zcl_status_to_name(ret_tilt_position), ret_tilt_percentage, esp_zb_zcl_status_to_name(ret_tilt_percentage)); return false; } return true; @@ -361,7 +361,7 @@ bool ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) { esp_zb_lock_release(); if (ret_tilt_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_tilt_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set tilt position(0x%x) or tilt percentage(0x%x)", ret_tilt_position, ret_tilt_percentage); + log_e("Failed to set tilt position(0x%x: %s) or tilt percentage(0x%x: %s)", ret_tilt_position, esp_zb_zcl_status_to_name(ret_tilt_position), ret_tilt_percentage, esp_zb_zcl_status_to_name(ret_tilt_percentage)); return false; } return true; From 8e55674b332b00bca8a511e9e7be9a5af73266b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 15:08:32 +0100 Subject: [PATCH 04/15] feat(example): Update factoryResetoption in sleepy example --- .../Zigbee_Temp_Hum_Sensor_Sleepy.ino | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino b/libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino index 0bfbad1fe95..5dbb3aff653 100644 --- a/libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino +++ b/libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino @@ -133,7 +133,11 @@ void loop() { // If key pressed for more than 10secs, factory reset Zigbee and reboot Serial.println("Resetting Zigbee to factory and rebooting in 1s."); delay(1000); - Zigbee.factoryReset(); + // 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_deep_sleep_start(); } } } From 65b938396774bfaf8b671b08326c026add21701b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 15:13:35 +0100 Subject: [PATCH 05/15] fix(zigbee): Add error checks to Illuminance EP --- .../Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp | 60 +++++++++++++++---- .../Zigbee/src/ep/ZigbeeIlluminanceSensor.h | 10 ++-- 2 files changed, 54 insertions(+), 16 deletions(-) diff --git a/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp index d38e9b1065f..563a8044458 100644 --- a/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp @@ -10,20 +10,40 @@ ZigbeeIlluminanceSensor::ZigbeeIlluminanceSensor(uint8_t endpoint) : ZigbeeEP(en _ep_config = {.endpoint = _endpoint, .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID, .app_device_id = ESP_ZB_HA_LIGHT_SENSOR_DEVICE_ID, .app_device_version = 0}; } -void ZigbeeIlluminanceSensor::setMinMaxValue(uint16_t min, uint16_t max) { +bool ZigbeeIlluminanceSensor::setMinMaxValue(uint16_t min, uint16_t max) { esp_zb_attribute_list_t *light_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_ILLUMINANCE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_cluster_update_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&min); - esp_zb_cluster_update_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&max); + if (!light_measure_cluster) { + log_e("Failed to get illuminance measurement cluster"); + return false; + } + esp_err_t ret_min = esp_zb_cluster_update_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&min); + if (ret_min != ESP_OK) { + log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); + } + esp_err_t ret_max = esp_zb_cluster_update_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&max); + if (ret_max != ESP_OK) { + log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); + } + return ret_min == ESP_OK && ret_max == ESP_OK; } -void ZigbeeIlluminanceSensor::setTolerance(uint16_t tolerance) { +bool ZigbeeIlluminanceSensor::setTolerance(uint16_t tolerance) { esp_zb_attribute_list_t *light_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_ILLUMINANCE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_illuminance_meas_cluster_add_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_TOLERANCE_ID, (void *)&tolerance); + if (!light_measure_cluster) { + log_e("Failed to get illuminance measurement cluster"); + return false; + } + esp_err_t ret = esp_zb_illuminance_meas_cluster_add_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_TOLERANCE_ID, (void *)&tolerance); + if (ret != ESP_OK) { + log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } + return true; } -void ZigbeeIlluminanceSensor::setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta) { +bool ZigbeeIlluminanceSensor::setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta) { esp_zb_zcl_reporting_info_t reporting_info; memset(&reporting_info, 0, sizeof(esp_zb_zcl_reporting_info_t)); reporting_info.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_SRV; @@ -38,24 +58,37 @@ void ZigbeeIlluminanceSensor::setReporting(uint16_t min_interval, uint16_t max_i reporting_info.u.send_info.delta.u16 = delta; 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_zb_zcl_update_reporting_info(&reporting_info); + 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; + } + return true; } -void ZigbeeIlluminanceSensor::setIlluminance(uint16_t illuminanceValue) { +bool ZigbeeIlluminanceSensor::setIlluminance(uint16_t illuminanceValue) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; log_v("Updating Illuminance..."); /* Update illuminance sensor measured illuminance */ log_d("Setting Illuminance to %d", illuminanceValue); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_ILLUMINANCE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_MEASURED_VALUE_ID, &illuminanceValue, false ); esp_zb_lock_release(); + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set illuminance: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; + } + return true; } -void ZigbeeIlluminanceSensor::report() { +bool ZigbeeIlluminanceSensor::report() { /* Send report attributes command */ esp_zb_zcl_report_attr_cmd_t report_attr_cmd; report_attr_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; @@ -66,9 +99,14 @@ void ZigbeeIlluminanceSensor::report() { report_attr_cmd.manuf_code = ESP_ZB_ZCL_ATTR_NON_MANUFACTURER_SPECIFIC; esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_report_attr_cmd_req(&report_attr_cmd); + 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 illuminance report: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } log_v("Illuminance report sent"); + return true; } #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.h b/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.h index 9c9d9e3fcaf..133dfc315db 100644 --- a/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.h +++ b/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.h @@ -33,19 +33,19 @@ class ZigbeeIlluminanceSensor : public ZigbeeEP { ~ZigbeeIlluminanceSensor() {} // Set the illuminance value - void setIlluminance(uint16_t value); + bool setIlluminance(uint16_t value); // Set the min and max value for the illuminance sensor - void setMinMaxValue(uint16_t min, uint16_t max); + bool setMinMaxValue(uint16_t min, uint16_t max); // Set the tolerance value for the illuminance sensor - void setTolerance(uint16_t tolerance); + bool setTolerance(uint16_t tolerance); // Set the reporting interval for illuminance measurement in seconds and delta - void setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta); + bool setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta); // Report the illuminance value - void report(); + bool report(); }; #endif // CONFIG_ZB_ENABLED From f5e28e121fc911ab636c12542a44d76c4edffd98 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 16:57:42 +0100 Subject: [PATCH 06/15] fix(zigbee): Return false on first error hit --- libraries/Zigbee/src/ZigbeeCore.cpp | 15 +++-- libraries/Zigbee/src/ZigbeeCore.h | 2 +- libraries/Zigbee/src/ZigbeeEP.cpp | 66 ++++++++++++++----- libraries/Zigbee/src/ZigbeeEP.h | 4 +- .../src/ep/ZigbeeCarbonDioxideSensor.cpp | 16 +++-- .../src/ep/ZigbeeColorDimmableLight.cpp | 46 +++++++++---- .../Zigbee/src/ep/ZigbeeDimmableLight.cpp | 16 +++-- libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp | 16 +++-- .../Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp | 16 +++-- .../Zigbee/src/ep/ZigbeeOccupancySensor.cpp | 16 +++-- .../Zigbee/src/ep/ZigbeePressureSensor.cpp | 16 +++-- libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp | 16 +++-- .../Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp | 16 +++-- .../Zigbee/src/ep/ZigbeeWindowCovering.cpp | 64 +++++++++++------- 14 files changed, 211 insertions(+), 114 deletions(-) diff --git a/libraries/Zigbee/src/ZigbeeCore.cpp b/libraries/Zigbee/src/ZigbeeCore.cpp index 0bb2cb559cf..c97632d4f71 100644 --- a/libraries/Zigbee/src/ZigbeeCore.cpp +++ b/libraries/Zigbee/src/ZigbeeCore.cpp @@ -91,21 +91,26 @@ bool ZigbeeCore::begin(zigbee_role_t role, bool erase_nvs) { return started(); } -void ZigbeeCore::addEndpoint(ZigbeeEP *ep) { +bool 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 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 ZigbeeCore's EP list"); - return; + return false; } - + esp_err_t ret = ESP_OK; if (ep->_device_id == ESP_ZB_HA_HOME_GATEWAY_DEVICE_ID) { - 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 { - esp_zb_ep_list_add_ep(_zb_ep_list, ep->_cluster_list, ep->_ep_config); + ret = esp_zb_ep_list_add_ep(_zb_ep_list, ep->_cluster_list, ep->_ep_config); } + if(ret != ESP_OK) { + log_e("Failed to add endpoint: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } + return true; } static void esp_zb_task(void *pvParameters) { diff --git a/libraries/Zigbee/src/ZigbeeCore.h b/libraries/Zigbee/src/ZigbeeCore.h index 114808e2e46..06c3ec4551a 100644 --- a/libraries/Zigbee/src/ZigbeeCore.h +++ b/libraries/Zigbee/src/ZigbeeCore.h @@ -129,7 +129,7 @@ class ZigbeeCore { return _role; } - void addEndpoint(ZigbeeEP *ep); + bool addEndpoint(ZigbeeEP *ep); //void removeEndpoint(ZigbeeEP *ep); void setRadioConfig(esp_zb_radio_config_t config); diff --git a/libraries/Zigbee/src/ZigbeeEP.cpp b/libraries/Zigbee/src/ZigbeeEP.cpp index c777f21b639..c1bbf7ead1b 100644 --- a/libraries/Zigbee/src/ZigbeeEP.cpp +++ b/libraries/Zigbee/src/ZigbeeEP.cpp @@ -55,20 +55,26 @@ bool ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) { // Get the basic cluster and update the manufacturer and model attributes esp_zb_attribute_list_t *basic_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_BASIC, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_err_t ret_manufacturer = esp_zb_basic_cluster_add_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID, (void *)zb_name); + esp_err_t ret_name = esp_zb_basic_cluster_add_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID, (void *)zb_name); + if (ret_name != ESP_OK) { + 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_manufacturer != ESP_OK || ret_model != ESP_OK) { - log_e("Failed to set manufacturer (0x%x) or model (0x%x)", ret_manufacturer, ret_model); + 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; delete[] zb_model; - return ret_manufacturer == ESP_OK && ret_model == ESP_OK; + return ret_name == ESP_OK && ret_model == ESP_OK; } -void ZigbeeEP::setPowerSource(zb_power_source_t power_source, uint8_t battery_percentage) { +bool ZigbeeEP::setPowerSource(zb_power_source_t power_source, uint8_t battery_percentage) { esp_zb_attribute_list_t *basic_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_BASIC, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_cluster_update_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_POWER_SOURCE_ID, (void *)&power_source); + esp_err_t ret = esp_zb_cluster_update_attr(basic_cluster, ESP_ZB_ZCL_ATTR_BASIC_POWER_SOURCE_ID, (void *)&power_source); + if (ret != ESP_OK) { + log_e("Failed to set power source: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } if (power_source == ZB_POWER_SOURCE_BATTERY) { // Add power config cluster and battery percentage attribute @@ -77,10 +83,19 @@ void ZigbeeEP::setPowerSource(zb_power_source_t power_source, uint8_t battery_pe } battery_percentage = battery_percentage * 2; esp_zb_attribute_list_t *power_config_cluster = esp_zb_zcl_attr_list_create(ESP_ZB_ZCL_CLUSTER_ID_POWER_CONFIG); - esp_zb_power_config_cluster_add_attr(power_config_cluster, ESP_ZB_ZCL_ATTR_POWER_CONFIG_BATTERY_PERCENTAGE_REMAINING_ID, (void *)&battery_percentage); - esp_zb_cluster_list_add_power_config_cluster(_cluster_list, power_config_cluster, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); + ret = esp_zb_power_config_cluster_add_attr(power_config_cluster, ESP_ZB_ZCL_ATTR_POWER_CONFIG_BATTERY_PERCENTAGE_REMAINING_ID, (void *)&battery_percentage); + if (ret != ESP_OK) { + log_e("Failed to add battery percentage attribute: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } + ret = esp_zb_cluster_list_add_power_config_cluster(_cluster_list, power_config_cluster, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); + if (ret != ESP_OK) { + log_e("Failed to add power config cluster: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } } _power_source = power_source; + return true; } bool ZigbeeEP::setBatteryPercentage(uint8_t percentage) { @@ -258,7 +273,7 @@ void ZigbeeEP::zbIdentify(const esp_zb_zcl_set_attr_value_message_t *message) { } } -void ZigbeeEP::addTimeCluster(tm time, int32_t gmt_offset) { +bool ZigbeeEP::addTimeCluster(tm time, int32_t gmt_offset) { time_t utc_time = 0; // Check if time is set if (time.tm_year > 0) { @@ -268,14 +283,35 @@ void ZigbeeEP::addTimeCluster(tm time, int32_t gmt_offset) { // Create time cluster server attributes esp_zb_attribute_list_t *time_cluster_server = esp_zb_zcl_attr_list_create(ESP_ZB_ZCL_CLUSTER_ID_TIME); - esp_zb_time_cluster_add_attr(time_cluster_server, ESP_ZB_ZCL_ATTR_TIME_TIME_ZONE_ID, (void *)&gmt_offset); - esp_zb_time_cluster_add_attr(time_cluster_server, ESP_ZB_ZCL_ATTR_TIME_TIME_ID, (void *)&utc_time); - esp_zb_time_cluster_add_attr(time_cluster_server, ESP_ZB_ZCL_ATTR_TIME_TIME_STATUS_ID, (void *)&_time_status); + esp_err_t ret = esp_zb_time_cluster_add_attr(time_cluster_server, ESP_ZB_ZCL_ATTR_TIME_TIME_ZONE_ID, (void *)&gmt_offset); + if (ret != ESP_OK) { + log_e("Failed to add time zone attribute: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } + ret = esp_zb_time_cluster_add_attr(time_cluster_server, ESP_ZB_ZCL_ATTR_TIME_TIME_ID, (void *)&utc_time); + if (ret != ESP_OK) { + log_e("Failed to add time attribute: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } + ret = esp_zb_time_cluster_add_attr(time_cluster_server, ESP_ZB_ZCL_ATTR_TIME_TIME_STATUS_ID, (void *)&_time_status); + if (ret != ESP_OK) { + log_e("Failed to add time status attribute: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } // Create time cluster client attributes esp_zb_attribute_list_t *time_cluster_client = esp_zb_zcl_attr_list_create(ESP_ZB_ZCL_CLUSTER_ID_TIME); // Add time clusters to cluster list - esp_zb_cluster_list_add_time_cluster(_cluster_list, time_cluster_server, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_zb_cluster_list_add_time_cluster(_cluster_list, time_cluster_client, ESP_ZB_ZCL_CLUSTER_CLIENT_ROLE); + ret = esp_zb_cluster_list_add_time_cluster(_cluster_list, time_cluster_server, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); + if (ret != ESP_OK) { + log_e("Failed to add time cluster (server role): 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } + ret = esp_zb_cluster_list_add_time_cluster(_cluster_list, time_cluster_client, ESP_ZB_ZCL_CLUSTER_CLIENT_ROLE); + if (ret != ESP_OK) { + log_e("Failed to add time cluster (client role): 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } + return true; } bool ZigbeeEP::setTime(tm time) { diff --git a/libraries/Zigbee/src/ZigbeeEP.h b/libraries/Zigbee/src/ZigbeeEP.h index 9ee3446e836..5b3e9e7ef44 100644 --- a/libraries/Zigbee/src/ZigbeeEP.h +++ b/libraries/Zigbee/src/ZigbeeEP.h @@ -77,12 +77,12 @@ class ZigbeeEP { char *readModel(uint8_t endpoint, uint16_t short_addr, esp_zb_ieee_addr_t ieee_addr); // Set Power source and battery percentage for battery powered devices - void setPowerSource(zb_power_source_t power_source, uint8_t percentage = 255); + bool setPowerSource(zb_power_source_t power_source, uint8_t percentage = 255); bool setBatteryPercentage(uint8_t percentage); bool reportBatteryPercentage(); // Set time - void addTimeCluster(tm time = {}, int32_t gmt_offset = 0); // gmt offset in seconds + bool addTimeCluster(tm time = {}, int32_t gmt_offset = 0); // gmt offset in seconds bool setTime(tm time); bool setTimezone(int32_t gmt_offset); diff --git a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp index 99ab3c34278..d00283725d0 100644 --- a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp @@ -29,15 +29,17 @@ bool ZigbeeCarbonDioxideSensor::setMinMaxValue(float min, float max) { float zb_max = max / 1000000.0f; 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_min = 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_min != ESP_OK) { - log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); + 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) { + log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - esp_err_t ret_max = 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_max != ESP_OK) { - log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); + 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) { + log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - return ret_min == ESP_OK && ret_max == ESP_OK; + return true; } bool ZigbeeCarbonDioxideSensor::setTolerance(float tolerance) { diff --git a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp index f0e5a29982d..582a3a4f4e4 100644 --- a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp @@ -118,6 +118,7 @@ void ZigbeeColorDimmableLight::lightChanged() { } bool ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, uint8_t green, uint8_t blue) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; //Update all attributes _current_state = state; _current_level = level; @@ -131,34 +132,55 @@ bool ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, /* Update light clusters */ esp_zb_lock_acquire(portMAX_DELAY); //set on/off state - esp_zb_zcl_status_t ret_state = esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_ON_OFF, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID, &_current_state, false ); + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set light state: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; + } //set level - esp_zb_zcl_status_t ret_level = esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_LEVEL_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_LEVEL_CONTROL_CURRENT_LEVEL_ID, &_current_level, false ); - //set xy color - esp_zb_zcl_status_t ret_xy = esp_zb_zcl_set_attribute_val( + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set light level: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; + } + //set x color + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_COLOR_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_COLOR_CONTROL_CURRENT_X_ID, &xy_color.x, false ); - esp_zb_zcl_status_t ret_y = esp_zb_zcl_set_attribute_val( + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set light xy color: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; + } + //set y color + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_COLOR_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_COLOR_CONTROL_CURRENT_Y_ID, &xy_color.y, false ); - //set hsv color + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set light y color: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; + } + //set hue uint8_t hue = (uint8_t)hsv_color.h; - esp_zb_zcl_status_t ret_hue = esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_COLOR_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_COLOR_CONTROL_CURRENT_HUE_ID, &hue, false ); - esp_zb_zcl_status_t ret_saturation = esp_zb_zcl_set_attribute_val( + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set light hue: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; + } + //set saturation + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_COLOR_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_COLOR_CONTROL_CURRENT_SATURATION_ID, &hsv_color.s, false ); - esp_zb_lock_release(); - - if (ret_state != ESP_ZB_ZCL_STATUS_SUCCESS || ret_level != ESP_ZB_ZCL_STATUS_SUCCESS || ret_xy != ESP_ZB_ZCL_STATUS_SUCCESS || ret_y != ESP_ZB_ZCL_STATUS_SUCCESS || ret_hue != ESP_ZB_ZCL_STATUS_SUCCESS || ret_saturation != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set light state(0x%x: %s), level(0x%x: %s), xy(0x%x: %s), y(0x%x: %s), hue(0x%x: %s), saturation(0x%x: %s)", ret_state, esp_zb_zcl_status_to_name(ret_state), ret_level, esp_zb_zcl_status_to_name(ret_level), ret_xy, esp_zb_zcl_status_to_name(ret_xy), ret_y, esp_zb_zcl_status_to_name(ret_y), ret_hue, esp_zb_zcl_status_to_name(ret_hue), ret_saturation, esp_zb_zcl_status_to_name(ret_saturation)); + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set light saturation: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } + esp_zb_lock_release(); return true; } diff --git a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp index 2cc8152603b..3475b77ee24 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp @@ -52,6 +52,7 @@ void ZigbeeDimmableLight::lightChanged() { } bool ZigbeeDimmableLight::setLight(bool state, uint8_t level) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; // Update all attributes _current_state = state; _current_level = level; @@ -61,19 +62,22 @@ bool ZigbeeDimmableLight::setLight(bool state, uint8_t level) { /* Update light clusters */ esp_zb_lock_acquire(portMAX_DELAY); // set on/off state - esp_zb_zcl_status_t ret_state = esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_ON_OFF, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID, &_current_state, false ); + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set light state: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; + } // set level - esp_zb_zcl_status_t ret_level = esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_LEVEL_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_LEVEL_CONTROL_CURRENT_LEVEL_ID, &_current_level, false ); - esp_zb_lock_release(); - - if (ret_state != ESP_ZB_ZCL_STATUS_SUCCESS || ret_level != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set light state(0x%x: %s) or level(0x%x: %s)", ret_state, esp_zb_zcl_status_to_name(ret_state), ret_level, esp_zb_zcl_status_to_name(ret_level)); + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set light level: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } + esp_zb_lock_release(); return true; } diff --git a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp index d56a441632e..4b5a6b56fab 100644 --- a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp @@ -31,15 +31,17 @@ bool ZigbeeFlowSensor::setMinMaxValue(float min, float max) { log_e("Failed to get flow measurement cluster"); return false; } - esp_err_t ret_min = esp_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min); - if(ret_min != ESP_OK) { - log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); + 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) { + log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - esp_err_t ret_max = esp_zb_cluster_update_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max); - if(ret_max != ESP_OK) { - log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); + 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) { + log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - return ret_min == ESP_OK && ret_max == ESP_OK; + return true; } bool ZigbeeFlowSensor::setTolerance(float tolerance) { diff --git a/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp index 563a8044458..231f404dfcc 100644 --- a/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp @@ -17,15 +17,17 @@ bool ZigbeeIlluminanceSensor::setMinMaxValue(uint16_t min, uint16_t max) { log_e("Failed to get illuminance measurement cluster"); return false; } - esp_err_t ret_min = esp_zb_cluster_update_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&min); - if (ret_min != ESP_OK) { - log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); + esp_err_t ret = esp_zb_cluster_update_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&min); + if (ret != ESP_OK) { + log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - esp_err_t ret_max = esp_zb_cluster_update_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&max); - if (ret_max != ESP_OK) { - log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); + ret = esp_zb_cluster_update_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&max); + if (ret != ESP_OK) { + log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - return ret_min == ESP_OK && ret_max == ESP_OK; + return true; } bool ZigbeeIlluminanceSensor::setTolerance(uint16_t tolerance) { diff --git a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp index fd53471f02d..a538bf2f105 100644 --- a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp @@ -26,15 +26,17 @@ bool ZigbeeOccupancySensor::setSensorType(uint8_t sensor_type) { uint8_t sensor_type_bitmap = 1 << 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_type = esp_zb_cluster_update_attr(occupancy_sens_cluster, ESP_ZB_ZCL_ATTR_OCCUPANCY_SENSING_OCCUPANCY_SENSOR_TYPE_ID, (void *)&sensor_type); - if(ret_type != ESP_OK) { - log_e("Failed to set sensor type: 0x%x: %s", ret_type, esp_err_to_name(ret_type)); + 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) { + log_e("Failed to set sensor type: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - esp_err_t ret_bitmap = 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_bitmap != ESP_OK) { - log_e("Failed to set sensor type bitmap: 0x%x: %s", ret_bitmap, esp_err_to_name(ret_bitmap)); + 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) { + log_e("Failed to set sensor type bitmap: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - return ret_type == ESP_OK && ret_bitmap == ESP_OK; + return true; } bool ZigbeeOccupancySensor::setOccupancy(bool occupied) { diff --git a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp b/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp index 948cb62d02f..eb88bde67c4 100644 --- a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp @@ -25,15 +25,17 @@ ZigbeePressureSensor::ZigbeePressureSensor(uint8_t endpoint) : ZigbeeEP(endpoint 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_min = esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MIN_VALUE_ID, (void *)&min); - if(ret_min != ESP_OK) { - log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); + 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) { + log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - esp_err_t ret_max = esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MAX_VALUE_ID, (void *)&max); - if(ret_max != ESP_OK) { - log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); + ret = esp_zb_cluster_update_attr(pressure_measure_cluster, ESP_ZB_ZCL_ATTR_PRESSURE_MEASUREMENT_MAX_VALUE_ID, (void *)&max); + if(ret != ESP_OK) { + log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - return ret_min == ESP_OK && ret_max == ESP_OK; + return true; } bool ZigbeePressureSensor::setTolerance(uint16_t tolerance) { diff --git a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp index 8484e99ace8..ae1901f06b4 100644 --- a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp @@ -22,15 +22,17 @@ bool ZigbeeTempSensor::setMinMaxValue(float min, float max) { int16_t zb_max = zb_float_to_s16(max); esp_zb_attribute_list_t *temp_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_err_t ret_min = esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min); - if(ret_min != ESP_OK) { - log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); + esp_err_t ret = esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MIN_VALUE_ID, (void *)&zb_min); + if(ret != ESP_OK) { + log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - esp_err_t ret_max = esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max); - if(ret_max != ESP_OK) { - log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); + ret = esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_MAX_VALUE_ID, (void *)&zb_max); + if(ret != ESP_OK) { + log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - return ret_min == ESP_OK && ret_max == ESP_OK; + return true; } bool ZigbeeTempSensor::setTolerance(float tolerance) { diff --git a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp index 6dbc55d7351..1cb18158611 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp @@ -33,15 +33,17 @@ bool ZigbeeWindSpeedSensor::setMinMaxValue(float min, float max) { uint16_t zb_max = zb_windspeed_to_u16(max); esp_zb_attribute_list_t *windspeed_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - esp_err_t ret_min = esp_zb_cluster_update_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&zb_min); - if(ret_min != ESP_OK) { - log_e("Failed to set min value: 0x%x: %s", ret_min, esp_err_to_name(ret_min)); + 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); + if(ret != ESP_OK) { + log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - esp_err_t ret_max = esp_zb_cluster_update_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&zb_max); - if(ret_max != ESP_OK) { - log_e("Failed to set max value: 0x%x: %s", ret_max, esp_err_to_name(ret_max)); + ret = esp_zb_cluster_update_attr(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE_ID, (void *)&zb_max); + if(ret != ESP_OK) { + log_e("Failed to set max value: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - return ret_min == ESP_OK && ret_max == ESP_OK; + return true; } bool ZigbeeWindSpeedSensor::setTolerance(float tolerance) { diff --git a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp index aaa21e6a6bf..893e24c922e 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp @@ -270,54 +270,63 @@ void ZigbeeWindowCovering::stop() { // Methods to control window covering from user application bool ZigbeeWindowCovering::setLiftPosition(uint16_t lift_position) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; // Update both lift attributes _current_lift_position = lift_position; _current_lift_percentage = ((lift_position - _installed_open_limit_lift) * 100) / (_installed_closed_limit_lift - _installed_open_limit_lift); log_v("Updating window covering lift position to %d (%d%)", _current_lift_position, _current_lift_percentage); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_status_t ret_lift_position = esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_ID, &_current_lift_position, false ); - esp_zb_zcl_status_t ret_lift_percentage = esp_zb_zcl_set_attribute_val( + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set lift position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; + } + ret = esp_zb_zcl_set_attribute_val( _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, &_current_lift_percentage, false ); - esp_zb_lock_release(); - - if (ret_lift_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_lift_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set lift position(0x%x: %s) or lift percentage(0x%x: %s)", ret_lift_position, esp_zb_zcl_status_to_name(ret_lift_position), ret_lift_percentage, esp_zb_zcl_status_to_name(ret_lift_percentage)); + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set lift percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } + esp_zb_lock_release(); return true; } bool ZigbeeWindowCovering::setLiftPercentage(uint8_t lift_percentage) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; // Update both lift attributes _current_lift_percentage = lift_percentage; _current_lift_position = _installed_open_limit_lift + ((_installed_closed_limit_lift - _installed_open_limit_lift) * lift_percentage) / 100; log_v("Updating window covering lift percentage to %d%% (%d)", _current_lift_percentage, _current_lift_position); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_status_t ret_lift_position = esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_ID, &_current_lift_position, false ); - esp_zb_zcl_status_t ret_lift_percentage = esp_zb_zcl_set_attribute_val( + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set lift position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; + } + ret = esp_zb_zcl_set_attribute_val( _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, &_current_lift_percentage, false ); - esp_zb_lock_release(); - - if (ret_lift_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_lift_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set lift position(0x%x: %s) or lift percentage(0x%x: %s)", ret_lift_position, esp_zb_zcl_status_to_name(ret_lift_position), ret_lift_percentage, esp_zb_zcl_status_to_name(ret_lift_percentage)); + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set lift percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } + esp_zb_lock_release(); return true; } bool ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; // Update both tilt attributes _current_tilt_position = tilt_position; _current_tilt_percentage = ((tilt_position - _installed_open_limit_tilt) * 100) / (_installed_closed_limit_tilt - _installed_open_limit_tilt); @@ -325,24 +334,28 @@ bool ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) { log_v("Updating window covering tilt position to %d (%d%)", _current_tilt_position, _current_tilt_percentage); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_status_t ret_tilt_position = esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_ID, &_current_tilt_position, false ); - esp_zb_zcl_status_t ret_tilt_percentage = esp_zb_zcl_set_attribute_val( + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set tilt position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; + } + ret = esp_zb_zcl_set_attribute_val( _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, &_current_tilt_percentage, false ); - esp_zb_lock_release(); - - if (ret_tilt_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_tilt_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set tilt position(0x%x: %s) or tilt percentage(0x%x: %s)", ret_tilt_position, esp_zb_zcl_status_to_name(ret_tilt_position), ret_tilt_percentage, esp_zb_zcl_status_to_name(ret_tilt_percentage)); + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set tilt percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } + esp_zb_lock_release(); return true; } bool ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) { + esp_zb_zcl_status_t ret = ESP_ZB_ZCL_STATUS_SUCCESS; // Update both tilt attributes _current_tilt_percentage = tilt_percentage; _current_tilt_position = _installed_open_limit_tilt + ((_installed_closed_limit_tilt - _installed_open_limit_tilt) * tilt_percentage) / 100; @@ -350,20 +363,23 @@ bool ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) { log_v("Updating window covering tilt percentage to %d%% (%d)", _current_tilt_percentage, _current_tilt_position); esp_zb_lock_acquire(portMAX_DELAY); - esp_zb_zcl_status_t ret_tilt_position = esp_zb_zcl_set_attribute_val( + ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_ID, &_current_tilt_position, false ); - esp_zb_zcl_status_t ret_tilt_percentage = esp_zb_zcl_set_attribute_val( + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set tilt position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; + } + ret = esp_zb_zcl_set_attribute_val( _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, &_current_tilt_percentage, false ); - esp_zb_lock_release(); - - if (ret_tilt_position != ESP_ZB_ZCL_STATUS_SUCCESS || ret_tilt_percentage != ESP_ZB_ZCL_STATUS_SUCCESS) { - log_e("Failed to set tilt position(0x%x: %s) or tilt percentage(0x%x: %s)", ret_tilt_position, esp_zb_zcl_status_to_name(ret_tilt_position), ret_tilt_percentage, esp_zb_zcl_status_to_name(ret_tilt_percentage)); + if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + log_e("Failed to set tilt percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } + esp_zb_lock_release(); return true; } From 51f14541037d9078bcef2aa6ac8b62f717c71f06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 17:17:59 +0100 Subject: [PATCH 07/15] fix(zigbee): Apply same formatting on all returns --- .../Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp | 9 ++++++--- libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp | 8 -------- .../Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp | 8 -------- libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp | 3 ++- libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp | 6 ++++-- libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp | 15 ++++++++++----- libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp | 9 ++++++--- libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp | 3 +-- 8 files changed, 29 insertions(+), 32 deletions(-) diff --git a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp index d00283725d0..231bed83f4f 100644 --- a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp @@ -51,8 +51,9 @@ bool ZigbeeCarbonDioxideSensor::setTolerance(float tolerance) { ); if(ret != ESP_OK) { log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - return ret == ESP_OK; + return true; } bool ZigbeeCarbonDioxideSensor::setReporting(uint16_t min_interval, uint16_t max_interval, uint16_t delta) { @@ -77,8 +78,9 @@ bool ZigbeeCarbonDioxideSensor::setReporting(uint16_t min_interval, uint16_t max 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; } - return ret == ESP_OK; + return true; } bool ZigbeeCarbonDioxideSensor::setCarbonDioxide(float carbon_dioxide) { @@ -95,8 +97,9 @@ bool ZigbeeCarbonDioxideSensor::setCarbonDioxide(float carbon_dioxide) { esp_zb_lock_release(); 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; } - return ret == ESP_ZB_ZCL_STATUS_SUCCESS; + return true; } bool ZigbeeCarbonDioxideSensor::report() { diff --git a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp index 4b5a6b56fab..8cca56fbb41 100644 --- a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp @@ -27,10 +27,6 @@ bool ZigbeeFlowSensor::setMinMaxValue(float min, float max) { uint16_t zb_max = (uint16_t)(max * 10); 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); - if (!flow_measure_cluster) { - log_e("Failed to get flow measurement cluster"); - return false; - } 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) { log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret)); @@ -48,10 +44,6 @@ bool ZigbeeFlowSensor::setTolerance(float tolerance) { uint16_t zb_tolerance = (uint16_t)(tolerance * 10); 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); - if (!flow_measure_cluster) { - log_e("Failed to get flow measurement cluster"); - return false; - } esp_err_t ret = esp_zb_flow_meas_cluster_add_attr(flow_measure_cluster, ESP_ZB_ZCL_ATTR_FLOW_MEASUREMENT_TOLERANCE_ID, (void *)&zb_tolerance); if (ret != ESP_OK) { log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); diff --git a/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp index 231f404dfcc..f1661c3a026 100644 --- a/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeIlluminanceSensor.cpp @@ -13,10 +13,6 @@ ZigbeeIlluminanceSensor::ZigbeeIlluminanceSensor(uint8_t endpoint) : ZigbeeEP(en bool ZigbeeIlluminanceSensor::setMinMaxValue(uint16_t min, uint16_t max) { esp_zb_attribute_list_t *light_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_ILLUMINANCE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - if (!light_measure_cluster) { - log_e("Failed to get illuminance measurement cluster"); - return false; - } esp_err_t ret = esp_zb_cluster_update_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_MIN_MEASURED_VALUE_ID, (void *)&min); if (ret != ESP_OK) { log_e("Failed to set min value: 0x%x: %s", ret, esp_err_to_name(ret)); @@ -33,10 +29,6 @@ bool ZigbeeIlluminanceSensor::setMinMaxValue(uint16_t min, uint16_t max) { bool ZigbeeIlluminanceSensor::setTolerance(uint16_t tolerance) { esp_zb_attribute_list_t *light_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_ILLUMINANCE_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - if (!light_measure_cluster) { - log_e("Failed to get illuminance measurement cluster"); - return false; - } esp_err_t ret = esp_zb_illuminance_meas_cluster_add_attr(light_measure_cluster, ESP_ZB_ZCL_ATTR_ILLUMINANCE_MEASUREMENT_TOLERANCE_ID, (void *)&tolerance); if (ret != ESP_OK) { log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); diff --git a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp index a538bf2f105..ed19525237b 100644 --- a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp @@ -51,8 +51,9 @@ bool ZigbeeOccupancySensor::setOccupancy(bool occupied) { esp_zb_lock_release(); 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; } - return ret == ESP_ZB_ZCL_STATUS_SUCCESS; + return true; } bool ZigbeeOccupancySensor::report() { diff --git a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp b/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp index eb88bde67c4..7f37aed83d8 100644 --- a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp @@ -68,8 +68,9 @@ bool ZigbeePressureSensor::setReporting(uint16_t min_interval, uint16_t max_inte 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; } - return ret == ESP_OK; + return true; } bool ZigbeePressureSensor::setPressure(int16_t pressure) { @@ -84,8 +85,9 @@ bool ZigbeePressureSensor::setPressure(int16_t pressure) { esp_zb_lock_release(); 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; } - return ret == ESP_ZB_ZCL_STATUS_SUCCESS; + return true; } bool ZigbeePressureSensor::report() { diff --git a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp index ae1901f06b4..65d7c4122f0 100644 --- a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp @@ -43,8 +43,9 @@ bool ZigbeeTempSensor::setTolerance(float tolerance) { 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); if(ret != ESP_OK) { log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - return ret == ESP_OK; + return true; } bool ZigbeeTempSensor::setReporting(uint16_t min_interval, uint16_t max_interval, float delta) { @@ -67,8 +68,9 @@ bool ZigbeeTempSensor::setReporting(uint16_t min_interval, uint16_t max_interval 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; } - return ret == ESP_OK; + return true; } bool ZigbeeTempSensor::setTemperature(float temperature) { @@ -84,8 +86,9 @@ bool ZigbeeTempSensor::setTemperature(float temperature) { esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set temperature: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; } - return ret == ESP_ZB_ZCL_STATUS_SUCCESS; + return true; } bool ZigbeeTempSensor::reportTemperature() { @@ -137,8 +140,9 @@ bool ZigbeeTempSensor::setHumidity(float humidity) { esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set humidity: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; } - return ret == ESP_ZB_ZCL_STATUS_SUCCESS; + return true; } bool ZigbeeTempSensor::reportHumidity() { @@ -182,8 +186,9 @@ bool ZigbeeTempSensor::setHumidityReporting(uint16_t min_interval, uint16_t max_ esp_zb_lock_release(); if(ret != ESP_OK) { log_e("Failed to set humidity reporting: 0x%x: %s", ret, esp_err_to_name(ret) ); + return false; } - return ret == ESP_OK; + return true; } bool ZigbeeTempSensor::report() { diff --git a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp index 1cb18158611..4fe2efae6d8 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp @@ -54,8 +54,9 @@ bool ZigbeeWindSpeedSensor::setTolerance(float tolerance) { 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); if(ret != ESP_OK) { log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; } - return ret == ESP_OK; + return true; } bool ZigbeeWindSpeedSensor::setReporting(uint16_t min_interval, uint16_t max_interval, float delta) { @@ -78,8 +79,9 @@ bool ZigbeeWindSpeedSensor::setReporting(uint16_t min_interval, uint16_t max_int 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; } - return ret == ESP_OK; + return true; } bool ZigbeeWindSpeedSensor::setWindSpeed(float windspeed) { @@ -96,8 +98,9 @@ bool ZigbeeWindSpeedSensor::setWindSpeed(float windspeed) { esp_zb_lock_release(); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set wind speed: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); + return false; } - return ret == ESP_ZB_ZCL_STATUS_SUCCESS; + return true; } bool ZigbeeWindSpeedSensor::reportWindSpeed() { diff --git a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp index 893e24c922e..ebd9e1de7e2 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp @@ -132,11 +132,10 @@ bool ZigbeeWindowCovering::setLimits( _installed_open_limit_tilt = installed_open_limit_tilt; _installed_closed_limit_tilt = installed_closed_limit_tilt; _physical_closed_limit_tilt = installed_closed_limit_tilt; - esp_err_t ret; esp_zb_attribute_list_t *window_covering_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - 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); + 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); if (ret != ESP_OK) { log_e("Failed to set installed open limit lift: 0x%x: %s", ret, esp_err_to_name(ret)); return false; From 282ccc5841cc1ca54905961e9852c4d1274d4d97 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 17:28:36 +0100 Subject: [PATCH 08/15] fix(zigbee): Add check when adding a OTA cluster --- libraries/Zigbee/src/ZigbeeEP.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/libraries/Zigbee/src/ZigbeeEP.cpp b/libraries/Zigbee/src/ZigbeeEP.cpp index c1bbf7ead1b..fc1f7af0d52 100644 --- a/libraries/Zigbee/src/ZigbeeEP.cpp +++ b/libraries/Zigbee/src/ZigbeeEP.cpp @@ -492,7 +492,11 @@ bool ZigbeeEP::addOTAClient( log_e("Failed to add OTA server endpoint: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } - esp_zb_cluster_list_add_ota_cluster(_cluster_list, ota_cluster, ESP_ZB_ZCL_CLUSTER_CLIENT_ROLE); + ret = esp_zb_cluster_list_add_ota_cluster(_cluster_list, ota_cluster, ESP_ZB_ZCL_CLUSTER_CLIENT_ROLE); + if (ret != ESP_OK) { + log_e("Failed to add OTA cluster: 0x%x: %s", ret, esp_err_to_name(ret)); + return false; + } return true; } From b6bf3c21cf17ac8e43e555ac71b157a0c1e51282 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 19:16:44 +0100 Subject: [PATCH 09/15] fix(zigbee): release locks before returning --- .../src/ep/ZigbeeColorDimmableLight.cpp | 17 +++++------ .../Zigbee/src/ep/ZigbeeDimmableLight.cpp | 7 +++-- .../Zigbee/src/ep/ZigbeeWindowCovering.cpp | 28 +++++++++++-------- 3 files changed, 29 insertions(+), 23 deletions(-) diff --git a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp index 582a3a4f4e4..caac73b5c68 100644 --- a/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeColorDimmableLight.cpp @@ -127,6 +127,7 @@ bool ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, espXyColor_t xy_color = espRgbColorToXYColor(_current_color); espHsvColor_t hsv_color = espRgbColorToHsvColor(_current_color); + uint8_t hue = (uint8_t)hsv_color.h; log_v("Updating light state: %d, level: %d, color: %d, %d, %d", state, level, red, green, blue); /* Update light clusters */ @@ -137,7 +138,7 @@ bool ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, ); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set light state: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } //set level ret = esp_zb_zcl_set_attribute_val( @@ -145,7 +146,7 @@ bool ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, ); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set light level: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } //set x color ret = esp_zb_zcl_set_attribute_val( @@ -153,7 +154,7 @@ bool ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, ); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set light xy color: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } //set y color ret = esp_zb_zcl_set_attribute_val( @@ -161,16 +162,15 @@ bool ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, ); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set light y color: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } //set hue - uint8_t hue = (uint8_t)hsv_color.h; ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_COLOR_CONTROL, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_COLOR_CONTROL_CURRENT_HUE_ID, &hue, false ); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set light hue: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } //set saturation ret = esp_zb_zcl_set_attribute_val( @@ -178,10 +178,11 @@ bool ZigbeeColorDimmableLight::setLight(bool state, uint8_t level, uint8_t red, ); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set light saturation: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } +unlock_and_return: esp_zb_lock_release(); - return true; + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } bool ZigbeeColorDimmableLight::setLightState(bool state) { diff --git a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp index 3475b77ee24..05a7e5ad6c1 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDimmableLight.cpp @@ -67,7 +67,7 @@ bool ZigbeeDimmableLight::setLight(bool state, uint8_t level) { ); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set light state: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } // set level ret = esp_zb_zcl_set_attribute_val( @@ -75,10 +75,11 @@ bool ZigbeeDimmableLight::setLight(bool state, uint8_t level) { ); if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set light level: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } +unlock_and_return: esp_zb_lock_release(); - return true; + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } bool ZigbeeDimmableLight::setLightState(bool state) { diff --git a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp index ebd9e1de7e2..79c5c8105c4 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp @@ -282,7 +282,7 @@ bool ZigbeeWindowCovering::setLiftPosition(uint16_t lift_position) { ); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set lift position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } ret = esp_zb_zcl_set_attribute_val( _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, @@ -290,10 +290,11 @@ bool ZigbeeWindowCovering::setLiftPosition(uint16_t lift_position) { ); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set lift percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } +unlock_and_return: esp_zb_lock_release(); - return true; + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } bool ZigbeeWindowCovering::setLiftPercentage(uint8_t lift_percentage) { @@ -310,7 +311,7 @@ bool ZigbeeWindowCovering::setLiftPercentage(uint8_t lift_percentage) { ); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set lift position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } ret = esp_zb_zcl_set_attribute_val( _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, @@ -318,10 +319,11 @@ bool ZigbeeWindowCovering::setLiftPercentage(uint8_t lift_percentage) { ); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set lift percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } +unlock_and_return: esp_zb_lock_release(); - return true; + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } bool ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) { @@ -339,7 +341,7 @@ bool ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) { ); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set tilt position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } ret = esp_zb_zcl_set_attribute_val( _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, @@ -347,10 +349,11 @@ bool ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) { ); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set tilt percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } +unlock_and_return: esp_zb_lock_release(); - return true; + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } bool ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) { @@ -368,7 +371,7 @@ bool ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) { ); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set tilt position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } ret = esp_zb_zcl_set_attribute_val( _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, @@ -376,10 +379,11 @@ bool ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) { ); if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set tilt percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); - return false; + goto unlock_and_return; } +unlock_and_return: esp_zb_lock_release(); - return true; + return ret == ESP_ZB_ZCL_STATUS_SUCCESS; } #endif // CONFIG_ZB_ENABLED From 8cf38c5f1145718228aedd747fcb684814f72849 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 20:27:17 +0100 Subject: [PATCH 10/15] fix(zigbee): use correct return in doorWindowHandle --- libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp index b392676506f..d45cc521ed4 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp @@ -43,8 +43,7 @@ bool ZigbeeDoorWindowHandle::setClosed() { return false; } _zone_status = closed; - report(); - return true; + return report(); } bool ZigbeeDoorWindowHandle::setOpen() { @@ -61,8 +60,7 @@ bool ZigbeeDoorWindowHandle::setOpen() { return false; } _zone_status = open; - report(); - return true; + return report(); } bool ZigbeeDoorWindowHandle::setTilted() { @@ -79,8 +77,7 @@ bool ZigbeeDoorWindowHandle::setTilted() { return false; } _zone_status = tilted; - report(); - return true; + return report(); } void ZigbeeDoorWindowHandle::report() { From 253066cd76b80f6a1e05b4a47b0ef8138dc86ab8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 20:29:19 +0100 Subject: [PATCH 11/15] fix/zigbee): Add missing return in WindowCovering --- libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp index 79c5c8105c4..46a2b15a805 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp @@ -222,12 +222,13 @@ void ZigbeeWindowCovering::zbWindowCoveringMovementCmd(const esp_zb_zcl_window_c if (_current_lift_percentage != message->payload.percentage_lift_value) { _current_lift_percentage = message->payload.percentage_lift_value; goToLiftPercentage(_current_lift_percentage); + return; } - return; } else if (message->command == ESP_ZB_ZCL_CMD_WINDOW_COVERING_GO_TO_TILT_PERCENTAGE) { if (_current_tilt_percentage != message->payload.percentage_tilt_value) { _current_tilt_percentage = message->payload.percentage_tilt_value; goToTiltPercentage(_current_tilt_percentage); + return; } } else { log_w("Received message ignored. Command: %d not supported for Window Covering", message->command); From cdd131b2018d8524d59ebc31f1873acff1555a60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 20:40:30 +0100 Subject: [PATCH 12/15] Revert "fix(zigbee): use correct return in doorWindowHandle" This reverts commit 8cf38c5f1145718228aedd747fcb684814f72849. --- libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp index d45cc521ed4..b392676506f 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp @@ -43,7 +43,8 @@ bool ZigbeeDoorWindowHandle::setClosed() { return false; } _zone_status = closed; - return report(); + report(); + return true; } bool ZigbeeDoorWindowHandle::setOpen() { @@ -60,7 +61,8 @@ bool ZigbeeDoorWindowHandle::setOpen() { return false; } _zone_status = open; - return report(); + report(); + return true; } bool ZigbeeDoorWindowHandle::setTilted() { @@ -77,7 +79,8 @@ bool ZigbeeDoorWindowHandle::setTilted() { return false; } _zone_status = tilted; - return report(); + report(); + return true; } void ZigbeeDoorWindowHandle::report() { From 1f60c928ff6e3df5afb19985c0b1b7d508fedbd4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 20:42:15 +0100 Subject: [PATCH 13/15] fix(zigbee): Added a note of future task --- libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp index b392676506f..0ae5238997e 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp @@ -83,6 +83,7 @@ bool ZigbeeDoorWindowHandle::setTilted() { return true; } +//NOTE: Change to return bool as a result of esp_zb_zcl_ias_zone_status_change_notif_cmd_req() void ZigbeeDoorWindowHandle::report() { /* Send IAS Zone status changed notification command */ From 8560ff3f91a9571943bf50cb350458b04a0eb696 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Thu, 27 Mar 2025 20:49:20 +0100 Subject: [PATCH 14/15] fix(zigbee): Hope its finished now.. --- libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp | 14 ++++++-------- libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.h | 2 +- 2 files changed, 7 insertions(+), 9 deletions(-) diff --git a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp index 0ae5238997e..c5b62ee2b75 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.cpp @@ -43,8 +43,7 @@ bool ZigbeeDoorWindowHandle::setClosed() { return false; } _zone_status = closed; - report(); - return true; + return report(); } bool ZigbeeDoorWindowHandle::setOpen() { @@ -61,8 +60,7 @@ bool ZigbeeDoorWindowHandle::setOpen() { return false; } _zone_status = open; - report(); - return true; + return report(); } bool ZigbeeDoorWindowHandle::setTilted() { @@ -79,12 +77,10 @@ bool ZigbeeDoorWindowHandle::setTilted() { return false; } _zone_status = tilted; - report(); - return true; + return report(); } -//NOTE: Change to return bool as a result of esp_zb_zcl_ias_zone_status_change_notif_cmd_req() -void ZigbeeDoorWindowHandle::report() { +bool ZigbeeDoorWindowHandle::report() { /* Send IAS Zone status changed notification command */ esp_zb_zcl_ias_zone_status_change_notif_cmd_t status_change_notif_cmd; @@ -98,10 +94,12 @@ void ZigbeeDoorWindowHandle::report() { status_change_notif_cmd.zone_id = _zone_id; status_change_notif_cmd.delay = 0; + //NOTE: Check result of esp_zb_zcl_ias_zone_status_change_notif_cmd_req() and return true if success, false if failure esp_zb_lock_acquire(portMAX_DELAY); esp_zb_zcl_ias_zone_status_change_notif_cmd_req(&status_change_notif_cmd); esp_zb_lock_release(); log_v("IAS Zone status changed notification sent"); + return true; } void ZigbeeDoorWindowHandle::zbIASZoneEnrollResponse(const esp_zb_zcl_ias_zone_enroll_response_message_t *message) { diff --git a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.h b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.h index 832fe2f4423..efffd34b12f 100644 --- a/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.h +++ b/libraries/Zigbee/src/ep/ZigbeeDoorWindowHandle.h @@ -58,7 +58,7 @@ class ZigbeeDoorWindowHandle : public ZigbeeEP { bool setTilted(); // Report the door/window handle value, done automatically after setting the position - void report(); + bool report(); private: void zbIASZoneEnrollResponse(const esp_zb_zcl_ias_zone_enroll_response_message_t *message) override; From 3bebb79824a4795e33a5bcc151797c293dbb0c60 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci-lite[bot]" <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com> Date: Thu, 27 Mar 2025 20:02:16 +0000 Subject: [PATCH 15/15] ci(pre-commit): Apply automatic fixes --- .../Zigbee_Temp_Hum_Sensor_Sleepy.ino | 2 +- libraries/Zigbee/src/ZigbeeCore.cpp | 7 +- libraries/Zigbee/src/ZigbeeEP.cpp | 115 +++++++----------- libraries/Zigbee/src/ZigbeeEP.h | 4 +- .../src/ep/ZigbeeCarbonDioxideSensor.cpp | 12 +- libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp | 14 +-- .../Zigbee/src/ep/ZigbeeOccupancySensor.cpp | 8 +- .../Zigbee/src/ep/ZigbeePressureSensor.cpp | 12 +- libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp | 20 +-- .../Zigbee/src/ep/ZigbeeVibrationSensor.cpp | 2 +- .../Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp | 15 +-- .../Zigbee/src/ep/ZigbeeWindowCovering.cpp | 34 +++--- 12 files changed, 108 insertions(+), 137 deletions(-) diff --git a/libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino b/libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino index 5dbb3aff653..3eefd973dd2 100644 --- a/libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino +++ b/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(); } } diff --git a/libraries/Zigbee/src/ZigbeeCore.cpp b/libraries/Zigbee/src/ZigbeeCore.cpp index c97632d4f71..b93542159a6 100644 --- a/libraries/Zigbee/src/ZigbeeCore.cpp +++ b/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(); diff --git a/libraries/Zigbee/src/ZigbeeEP.cpp b/libraries/Zigbee/src/ZigbeeEP.cpp index fc1f7af0d52..e7d507dc441 100644 --- a/libraries/Zigbee/src/ZigbeeEP.cpp +++ b/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 diff --git a/libraries/Zigbee/src/ZigbeeEP.h b/libraries/Zigbee/src/ZigbeeEP.h index 5b3e9e7ef44..bd142344929 100644 --- a/libraries/Zigbee/src/ZigbeeEP.h +++ b/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; diff --git a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp index 231bed83f4f..2b8271f09a9 100644 --- a/libraries/Zigbee/src/ep/ZigbeeCarbonDioxideSensor.cpp +++ b/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; } diff --git a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp index 8cca56fbb41..8a60af5a8e1 100644 --- a/libraries/Zigbee/src/ep/ZigbeeFlowSensor.cpp +++ b/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; diff --git a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp b/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp index ed19525237b..b8f88fed4a4 100644 --- a/libraries/Zigbee/src/ep/ZigbeeOccupancySensor.cpp +++ b/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; } diff --git a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp b/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp index 7f37aed83d8..bca06a35d0c 100644 --- a/libraries/Zigbee/src/ep/ZigbeePressureSensor.cpp +++ b/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; } diff --git a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp index 65d7c4122f0..7126dae15cf 100644 --- a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp @@ -23,12 +23,12 @@ bool ZigbeeTempSensor::setMinMaxValue(float min, float max) { esp_zb_attribute_list_t *temp_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); esp_err_t ret = esp_zb_cluster_update_attr(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_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(temp_measure_cluster, ESP_ZB_ZCL_ATTR_TEMP_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; } @@ -41,7 +41,7 @@ bool ZigbeeTempSensor::setTolerance(float tolerance) { esp_zb_attribute_list_t *temp_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); 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); - 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; } @@ -66,7 +66,7 @@ bool ZigbeeTempSensor::setReporting(uint16_t min_interval, uint16_t max_interval 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; } @@ -84,7 +84,7 @@ bool ZigbeeTempSensor::setTemperature(float temperature) { _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 ); esp_zb_lock_release(); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set temperature: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } @@ -104,7 +104,7 @@ bool ZigbeeTempSensor::reportTemperature() { 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 temperature report: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } @@ -138,7 +138,7 @@ bool ZigbeeTempSensor::setHumidity(float humidity) { false ); esp_zb_lock_release(); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set humidity: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } @@ -158,7 +158,7 @@ bool ZigbeeTempSensor::reportHumidity() { 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 humidity report: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } @@ -184,8 +184,8 @@ bool ZigbeeTempSensor::setHumidityReporting(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) { - log_e("Failed to set humidity reporting: 0x%x: %s", ret, esp_err_to_name(ret) ); + if (ret != ESP_OK) { + log_e("Failed to set humidity reporting: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } return true; diff --git a/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp index 96c0fa242d4..6be457c389a 100644 --- a/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeVibrationSensor.cpp @@ -38,7 +38,7 @@ bool ZigbeeVibrationSensor::setVibration(bool sensed) { _endpoint, ESP_ZB_ZCL_CLUSTER_ID_IAS_ZONE, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_IAS_ZONE_ZONESTATUS_ID, &vibration, false ); esp_zb_lock_release(); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set vibration status: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } diff --git a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp index 4fe2efae6d8..72184927d4d 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindSpeedSensor.cpp @@ -34,12 +34,12 @@ bool ZigbeeWindSpeedSensor::setMinMaxValue(float min, float max) { esp_zb_attribute_list_t *windspeed_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); 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); - 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(windspeed_measure_cluster, ESP_ZB_ZCL_ATTR_WIND_SPEED_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; } @@ -51,8 +51,9 @@ bool ZigbeeWindSpeedSensor::setTolerance(float tolerance) { uint16_t zb_tolerance = zb_windspeed_to_u16(tolerance); esp_zb_attribute_list_t *windspeed_measure_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WIND_SPEED_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - 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); - if(ret != ESP_OK) { + 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); + if (ret != ESP_OK) { log_e("Failed to set tolerance: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } @@ -77,7 +78,7 @@ bool ZigbeeWindSpeedSensor::setReporting(uint16_t min_interval, uint16_t max_int 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; } @@ -96,7 +97,7 @@ bool ZigbeeWindSpeedSensor::setWindSpeed(float windspeed) { &zb_windspeed, false ); esp_zb_lock_release(); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set wind speed: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); return false; } @@ -116,7 +117,7 @@ bool ZigbeeWindSpeedSensor::reportWindSpeed() { 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 wind speed report: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } diff --git a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp index 46a2b15a805..7c7889dbbf7 100644 --- a/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeWindowCovering.cpp @@ -135,12 +135,14 @@ bool ZigbeeWindowCovering::setLimits( esp_zb_attribute_list_t *window_covering_cluster = esp_zb_cluster_list_get_cluster(_cluster_list, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); - 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); + 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); if (ret != ESP_OK) { log_e("Failed to set installed open limit lift: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } - 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); + 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); if (ret != ESP_OK) { log_e("Failed to set installed closed limit lift: 0x%x: %s", ret, esp_err_to_name(ret)); return false; @@ -150,12 +152,14 @@ bool ZigbeeWindowCovering::setLimits( log_e("Failed to set installed open limit tilt: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } - 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); + 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); if (ret != ESP_OK) { log_e("Failed to set installed closed limit tilt: 0x%x: %s", ret, esp_err_to_name(ret)); return false; } - 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); + 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); if (ret != ESP_OK) { log_e("Failed to set physical closed limit lift: 0x%x: %s", ret, esp_err_to_name(ret)); return false; @@ -281,7 +285,7 @@ bool ZigbeeWindowCovering::setLiftPosition(uint16_t lift_position) { _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_ID, &_current_lift_position, false ); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set lift position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); goto unlock_and_return; } @@ -289,7 +293,7 @@ bool ZigbeeWindowCovering::setLiftPosition(uint16_t lift_position) { _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, &_current_lift_percentage, false ); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set lift percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); goto unlock_and_return; } @@ -304,13 +308,13 @@ bool ZigbeeWindowCovering::setLiftPercentage(uint8_t lift_percentage) { _current_lift_percentage = lift_percentage; _current_lift_position = _installed_open_limit_lift + ((_installed_closed_limit_lift - _installed_open_limit_lift) * lift_percentage) / 100; log_v("Updating window covering lift percentage to %d%% (%d)", _current_lift_percentage, _current_lift_position); - + esp_zb_lock_acquire(portMAX_DELAY); ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_ID, &_current_lift_position, false ); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set lift position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); goto unlock_and_return; } @@ -318,7 +322,7 @@ bool ZigbeeWindowCovering::setLiftPercentage(uint8_t lift_percentage) { _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, &_current_lift_percentage, false ); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set lift percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); goto unlock_and_return; } @@ -334,13 +338,13 @@ bool ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) { _current_tilt_percentage = ((tilt_position - _installed_open_limit_tilt) * 100) / (_installed_closed_limit_tilt - _installed_open_limit_tilt); log_v("Updating window covering tilt position to %d (%d%)", _current_tilt_position, _current_tilt_percentage); - + esp_zb_lock_acquire(portMAX_DELAY); ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_ID, &_current_tilt_position, false ); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set tilt position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); goto unlock_and_return; } @@ -348,7 +352,7 @@ bool ZigbeeWindowCovering::setTiltPosition(uint16_t tilt_position) { _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, &_current_tilt_percentage, false ); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set tilt percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); goto unlock_and_return; } @@ -364,13 +368,13 @@ bool ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) { _current_tilt_position = _installed_open_limit_tilt + ((_installed_closed_limit_tilt - _installed_open_limit_tilt) * tilt_percentage) / 100; log_v("Updating window covering tilt percentage to %d%% (%d)", _current_tilt_percentage, _current_tilt_position); - + esp_zb_lock_acquire(portMAX_DELAY); ret = esp_zb_zcl_set_attribute_val( _endpoint, ESP_ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ESP_ZB_ZCL_CLUSTER_SERVER_ROLE, ESP_ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_ID, &_current_tilt_position, false ); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set tilt position: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); goto unlock_and_return; } @@ -378,7 +382,7 @@ bool ZigbeeWindowCovering::setTiltPercentage(uint8_t tilt_percentage) { _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, &_current_tilt_percentage, false ); - if(ret != ESP_ZB_ZCL_STATUS_SUCCESS) { + if (ret != ESP_ZB_ZCL_STATUS_SUCCESS) { log_e("Failed to set tilt percentage: 0x%x: %s", ret, esp_zb_zcl_status_to_name(ret)); goto unlock_and_return; }