fix(zigbee): Return false on first error hit

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

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) {

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);

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) {

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);
 

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) {

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;
 }
 

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;
 }
 

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) {

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) {

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) {