diff --git a/docs/en/zigbee/ep_thermostat.rst b/docs/en/zigbee/ep_thermostat.rst index b7c79254d0f..49b91945d45 100644 --- a/docs/en/zigbee/ep_thermostat.rst +++ b/docs/en/zigbee/ep_thermostat.rst @@ -5,13 +5,14 @@ ZigbeeThermostat About ----- -The ``ZigbeeThermostat`` class provides a thermostat endpoint for Zigbee networks that receives temperature data from temperature sensors. This endpoint implements the Zigbee Home Automation (HA) standard for thermostats that can bind to temperature sensors and receive temperature readings. +The ``ZigbeeThermostat`` class provides a thermostat endpoint for Zigbee networks. +This endpoint implements the Zigbee Home Automation (HA) standard for thermostats that can bind to temperature and humidity sensors and receive temperature and humidity readings. **Features:** * Automatic discovery and binding to temperature sensors -* Temperature data reception from bound sensors -* Configurable temperature reporting intervals -* Sensor settings retrieval (min/max temperature, tolerance) +* Temperature and humidity data reception from bound sensors +* Configurable temperature and humidity reporting intervals +* Sensor settings retrieval (min/max/tolerance for temperature and humidity) * Multiple addressing modes (group, specific endpoint, IEEE address) API Reference @@ -60,20 +61,60 @@ Sets a callback function for receiving temperature data with source information. * ``src_endpoint`` - Source endpoint that sent the temperature data * ``src_address`` - Source address information -onConfigReceive -^^^^^^^^^^^^^^^ +onTempConfigReceive +^^^^^^^^^^^^^^^^^^^ Sets a callback function for receiving sensor configuration data. .. code-block:: arduino - void onConfigReceive(void (*callback)(float min_temp, float max_temp, float tolerance)); + void onTempConfigReceive(void (*callback)(float min_temp, float max_temp, float tolerance)); * ``callback`` - Function to call when sensor configuration is received * ``min_temp`` - Minimum temperature supported by the sensor * ``max_temp`` - Maximum temperature supported by the sensor * ``tolerance`` - Temperature tolerance of the sensor +onHumidityReceive +^^^^^^^^^^^^^^^^^ + +Sets a callback function for receiving humidity data. + +.. code-block:: arduino + + void onHumidityReceive(void (*callback)(float humidity)); + +* ``callback`` - Function to call when humidity data is received +* ``humidity`` - Humidity value in percentage + +onHumidityReceiveWithSource +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Sets a callback function for receiving humidity data with source information. + +.. code-block:: arduino + + void onHumidityReceiveWithSource(void (*callback)(float humidity, uint8_t src_endpoint, esp_zb_zcl_addr_t src_address)); + +* ``callback`` - Function to call when humidity data is received +* ``humidity`` - Humidity value in percentage +* ``src_endpoint`` - Source endpoint that sent the humidity data +* ``src_address`` - Source address information + +onHumidityConfigReceive +^^^^^^^^^^^^^^^^^^^^^^^ + +Sets a callback function for receiving humidity sensor configuration data. + +.. code-block:: arduino + + void onHumidityConfigReceive(void (*callback)(float min_humidity, float max_humidity, float tolerance)); + +* ``callback`` - Function to call when humidity sensor configuration is received +* ``min_humidity`` - Minimum humidity supported by the sensor +* ``max_humidity`` - Maximum humidity supported by the sensor +* ``tolerance`` - Humidity tolerance of the sensor + Temperature Data Retrieval ************************** @@ -98,7 +139,7 @@ Requests temperature data from a specific group. * ``group_addr`` - Group address to send the request to getTemperature (Endpoint + Short Address) -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Requests temperature data from a specific endpoint using short address. @@ -110,7 +151,7 @@ Requests temperature data from a specific endpoint using short address. * ``short_addr`` - Short address of the target device getTemperature (Endpoint + IEEE Address) -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Requests temperature data from a specific endpoint using IEEE address. @@ -121,49 +162,143 @@ Requests temperature data from a specific endpoint using IEEE address. * ``endpoint`` - Target endpoint number * ``ieee_addr`` - IEEE address of the target device -Sensor Settings Retrieval -************************* +Humidity Data Retrieval +*********************** -getSensorSettings -^^^^^^^^^^^^^^^^^ +getHumidity +^^^^^^^^^^^ + +Requests humidity data from all bound sensors. + +.. code-block:: arduino + + void getHumidity(); + +getHumidity (Group) +^^^^^^^^^^^^^^^^^^^ + +Requests humidity data from a specific group. + +.. code-block:: arduino + + void getHumidity(uint16_t group_addr); + +* ``group_addr`` - Group address to send the request to + +getHumidity (Endpoint + Short Address) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Requests humidity data from a specific endpoint using short address. + +.. code-block:: arduino + + void getHumidity(uint8_t endpoint, uint16_t short_addr); + +* ``endpoint`` - Target endpoint number +* ``short_addr`` - Short address of the target device + +getHumidity (Endpoint + IEEE Address) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Requests humidity data from a specific endpoint using IEEE address. + +.. code-block:: arduino + + void getHumidity(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr); + +* ``endpoint`` - Target endpoint number +* ``ieee_addr`` - IEEE address of the target device + +Temperature Settings Retrieval +****************************** + +getTemperatureSettings +^^^^^^^^^^^^^^^^^^^^^^ + +Requests temperature sensor settings from all bound sensors. + +.. code-block:: arduino + + void getTemperatureSettings(); + +getTemperatureSettings (Group) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Requests temperature sensor settings from a specific group. -Requests sensor settings from all bound sensors. +.. code-block:: arduino + + void getTemperatureSettings(uint16_t group_addr); + +* ``group_addr`` - Group address to send the request to + +getTemperatureSettings (Endpoint + Short Address) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Requests temperature sensor settings from a specific endpoint using short address. .. code-block:: arduino - void getSensorSettings(); + void getTemperatureSettings(uint8_t endpoint, uint16_t short_addr); + +* ``endpoint`` - Target endpoint number +* ``short_addr`` - Short address of the target device + +getTemperatureSettings (Endpoint + IEEE Address) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Requests temperature sensor settings from a specific endpoint using IEEE address. + +.. code-block:: arduino + + void getTemperatureSettings(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr); + +* ``endpoint`` - Target endpoint number +* ``ieee_addr`` - IEEE address of the target device + +Humidity Settings Retrieval +*************************** + +getHumiditySettings +^^^^^^^^^^^^^^^^^^^ -getSensorSettings (Group) -^^^^^^^^^^^^^^^^^^^^^^^^^ +Requests humidity sensor settings from all bound sensors. -Requests sensor settings from a specific group. +.. code-block:: arduino + + void getHumiditySettings(); + +getHumiditySettings (Group) +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Requests humidity sensor settings from a specific group. .. code-block:: arduino - void getSensorSettings(uint16_t group_addr); + void getHumiditySettings(uint16_t group_addr); * ``group_addr`` - Group address to send the request to -getSensorSettings (Endpoint + Short Address) -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +getHumiditySettings (Endpoint + Short Address) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Requests sensor settings from a specific endpoint using short address. +Requests humidity sensor settings from a specific endpoint using short address. .. code-block:: arduino - void getSensorSettings(uint8_t endpoint, uint16_t short_addr); + void getHumiditySettings(uint8_t endpoint, uint16_t short_addr); * ``endpoint`` - Target endpoint number * ``short_addr`` - Short address of the target device -getSensorSettings (Endpoint + IEEE Address) -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +getHumiditySettings (Endpoint + IEEE Address) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Requests sensor settings from a specific endpoint using IEEE address. +Requests humidity sensor settings from a specific endpoint using IEEE address. .. code-block:: arduino - void getSensorSettings(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr); + void getHumiditySettings(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr); * ``endpoint`` - Target endpoint number * ``ieee_addr`` - IEEE address of the target device @@ -228,6 +363,66 @@ Configures temperature reporting for a specific endpoint using IEEE address. * ``max_interval`` - Maximum reporting interval in seconds * ``delta`` - Minimum change in temperature to trigger a report +Humidity Reporting Configuration +******************************** + +setHumidityReporting +^^^^^^^^^^^^^^^^^^^^ + +Configures humidity reporting for all bound sensors. + +.. code-block:: arduino + + void setHumidityReporting(uint16_t min_interval, uint16_t max_interval, float delta); + +* ``min_interval`` - Minimum reporting interval in seconds +* ``max_interval`` - Maximum reporting interval in seconds +* ``delta`` - Minimum change in humidity to trigger a report + +setHumidityReporting (Group) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Configures humidity reporting for a specific group. + +.. code-block:: arduino + + void setHumidityReporting(uint16_t group_addr, uint16_t min_interval, uint16_t max_interval, float delta); + +* ``group_addr`` - Group address to configure +* ``min_interval`` - Minimum reporting interval in seconds +* ``max_interval`` - Maximum reporting interval in seconds +* ``delta`` - Minimum change in humidity to trigger a report + +setHumidityReporting (Endpoint + Short Address) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Configures humidity reporting for a specific endpoint using short address. + +.. code-block:: arduino + + void setHumidityReporting(uint8_t endpoint, uint16_t short_addr, uint16_t min_interval, uint16_t max_interval, float delta); + +* ``endpoint`` - Target endpoint number +* ``short_addr`` - Short address of the target device +* ``min_interval`` - Minimum reporting interval in seconds +* ``max_interval`` - Maximum reporting interval in seconds +* ``delta`` - Minimum change in humidity to trigger a report + +setHumidityReporting (Endpoint + IEEE Address) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Configures humidity reporting for a specific endpoint using IEEE address. + +.. code-block:: arduino + + void setHumidityReporting(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr, uint16_t min_interval, uint16_t max_interval, float delta); + +* ``endpoint`` - Target endpoint number +* ``ieee_addr`` - IEEE address of the target device +* ``min_interval`` - Minimum reporting interval in seconds +* ``max_interval`` - Maximum reporting interval in seconds +* ``delta`` - Minimum change in humidity to trigger a report + Example ------- diff --git a/libraries/Zigbee/examples/Zigbee_Thermostat/Zigbee_Thermostat.ino b/libraries/Zigbee/examples/Zigbee_Thermostat/Zigbee_Thermostat.ino index 6f5934f791d..73125cbf5dc 100644 --- a/libraries/Zigbee/examples/Zigbee_Thermostat/Zigbee_Thermostat.ino +++ b/libraries/Zigbee/examples/Zigbee_Thermostat/Zigbee_Thermostat.ino @@ -90,7 +90,7 @@ void setup() { #endif // Set callback function for receiving sensor configuration - zbThermostat.onConfigReceive(receiveSensorConfig); + zbThermostat.onTempConfigReceive(receiveSensorConfig); //Optional: set Zigbee device name and model zbThermostat.setManufacturerAndModel("Espressif", "ZigbeeThermostat"); @@ -138,10 +138,10 @@ void setup() { "Device on endpoint %d, IEEE Address: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\r\n", device->endpoint, device->ieee_addr[7], device->ieee_addr[6], device->ieee_addr[5], device->ieee_addr[4], device->ieee_addr[3], device->ieee_addr[2], device->ieee_addr[1], device->ieee_addr[0] ); - zbThermostat.getSensorSettings(device->endpoint, device->ieee_addr); + zbThermostat.getTemperatureSettings(device->endpoint, device->ieee_addr); } else { Serial.printf("Device on endpoint %d, short address: 0x%x\r\n", device->endpoint, device->short_addr); - zbThermostat.getSensorSettings(device->endpoint, device->short_addr); + zbThermostat.getTemperatureSettings(device->endpoint, device->short_addr); } } } diff --git a/libraries/Zigbee/keywords.txt b/libraries/Zigbee/keywords.txt index f203de96da6..44067fc4886 100644 --- a/libraries/Zigbee/keywords.txt +++ b/libraries/Zigbee/keywords.txt @@ -142,11 +142,17 @@ onLightColorChangeWithSource KEYWORD2 # ZigbeeThermostat onTempRecieve KEYWORD2 -onConfigRecieve KEYWORD2 onTempReceiveWithSource KEYWORD2 +onTempConfigReceive KEYWORD2 getTemperature KEYWORD2 -getSensorSettings KEYWORD2 +getTemperatureSettings KEYWORD2 setTemperatureReporting KEYWORD2 +onHumidityReceive KEYWORD2 +onHumidityReceiveWithSource KEYWORD2 +onHumidityConfigReceive KEYWORD2 +getHumidity KEYWORD2 +getHumiditySettings KEYWORD2 +setHumidityReporting KEYWORD2 # Common Zigbee Sensor setMinMaxValue KEYWORD2 diff --git a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp index 9159464b309..484506e139d 100644 --- a/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeTempSensor.cpp @@ -127,10 +127,10 @@ bool ZigbeeTempSensor::reportTemperature() { } void ZigbeeTempSensor::addHumiditySensor(float min, float max, float tolerance) { - int16_t zb_min = zb_float_to_s16(min); - int16_t zb_max = zb_float_to_s16(max); + uint16_t zb_min = (uint16_t)(min * 100); + uint16_t zb_max = (uint16_t)(max * 100); uint16_t zb_tolerance = (uint16_t)(tolerance * 100); - int16_t default_hum = ESP_ZB_ZCL_REL_HUMIDITY_MEASUREMENT_MEASURED_VALUE_DEFAULT; + uint16_t default_hum = ESP_ZB_ZCL_REL_HUMIDITY_MEASUREMENT_MEASURED_VALUE_DEFAULT; esp_zb_attribute_list_t *humidity_cluster = esp_zb_zcl_attr_list_create(ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT); esp_zb_humidity_meas_cluster_add_attr(humidity_cluster, ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_VALUE_ID, &default_hum); esp_zb_humidity_meas_cluster_add_attr(humidity_cluster, ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_MIN_VALUE_ID, &zb_min); @@ -142,7 +142,7 @@ void ZigbeeTempSensor::addHumiditySensor(float min, float max, float tolerance) 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); + uint16_t zb_humidity = (uint16_t)(humidity * 100); log_v("Updating humidity sensor value..."); /* Update humidity sensor measured value */ log_d("Setting humidity to %d", zb_humidity); diff --git a/libraries/Zigbee/src/ep/ZigbeeThermostat.cpp b/libraries/Zigbee/src/ep/ZigbeeThermostat.cpp index e076aff79f0..1a963a16e5f 100644 --- a/libraries/Zigbee/src/ep/ZigbeeThermostat.cpp +++ b/libraries/Zigbee/src/ep/ZigbeeThermostat.cpp @@ -39,6 +39,7 @@ ZigbeeThermostat::ZigbeeThermostat(uint8_t endpoint) : ZigbeeEP(endpoint) { esp_zb_cluster_list_add_thermostat_cluster(_cluster_list, esp_zb_thermostat_cluster_create(&(thermostat_cfg.thermostat_cfg)), ESP_ZB_ZCL_CLUSTER_SERVER_ROLE); /* Add temperature measurement cluster for attribute reporting */ esp_zb_cluster_list_add_temperature_meas_cluster(_cluster_list, esp_zb_temperature_meas_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_CLIENT_ROLE); + esp_zb_cluster_list_add_humidity_meas_cluster(_cluster_list, esp_zb_humidity_meas_cluster_create(NULL), ESP_ZB_ZCL_CLUSTER_CLIENT_ROLE); _ep_config = {.endpoint = _endpoint, .app_profile_id = ESP_ZB_AF_HA_PROFILE_ID, .app_device_id = ESP_ZB_HA_THERMOSTAT_DEVICE_ID, .app_device_version = 0}; } @@ -100,21 +101,28 @@ void ZigbeeThermostat::findCb(esp_zb_zdp_status_t zdo_status, uint16_t addr, uin log_i("Request temperature sensor to bind us"); esp_zb_zdo_device_bind_req(&bind_req, ZigbeeThermostat::bindCbWrapper, NULL); + log_i("Request humidity sensor to bind us"); + bind_req.cluster_id = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + esp_zb_zdo_device_bind_req(&bind_req, ZigbeeThermostat::bindCbWrapper, NULL); + /* 2. Send binding request to self */ bind_req.req_dst_addr = esp_zb_get_short_address(); + /* populate the src information of the binding */ esp_zb_get_long_address(bind_req.src_address); bind_req.src_endp = instance->_endpoint; - bind_req.cluster_id = ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT; + bind_req.cluster_id = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; bind_req.dst_addr_mode = ESP_ZB_ZDO_BIND_DST_ADDR_MODE_64_BIT_EXTENDED; memcpy(bind_req.dst_address_u.addr_long, sensor->ieee_addr, sizeof(esp_zb_ieee_addr_t)); bind_req.dst_endp = endpoint; - log_i("Try to bind Temperature Measurement"); - //save sensor params in the class + log_i("Try to bind Humidity Measurement"); // Optional cluster to bind, if fails, continue to bind the temperature measurement cluster + // save sensor params in the class instance->_device = sensor; - log_d("Find callback on EP %d", instance->_endpoint); + esp_zb_zdo_device_bind_req(&bind_req, ZigbeeThermostat::bindCbWrapper, NULL); + bind_req.cluster_id = ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT; + log_i("Try to bind Temperature Measurement"); // Mandatory cluster to bind esp_zb_zdo_device_bind_req(&bind_req, ZigbeeThermostat::bindCbWrapper, this); } else { log_d("No temperature sensor endpoint found"); @@ -122,9 +130,9 @@ void ZigbeeThermostat::findCb(esp_zb_zdp_status_t zdo_status, uint16_t addr, uin } void ZigbeeThermostat::findEndpoint(esp_zb_zdo_match_desc_req_param_t *param) { - uint16_t cluster_list[] = {ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT}; + uint16_t cluster_list[] = {ESP_ZB_ZCL_CLUSTER_ID_TEMP_MEASUREMENT, ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT}; param->profile_id = ESP_ZB_AF_HA_PROFILE_ID; - param->num_in_clusters = 1; + param->num_in_clusters = 2; param->num_out_clusters = 0; param->cluster_list = cluster_list; esp_zb_zdo_match_cluster(param, ZigbeeThermostat::findCbWrapper, this); @@ -156,18 +164,56 @@ void ZigbeeThermostat::zbAttributeRead(uint16_t cluster_id, const esp_zb_zcl_att } if (attribute->id == ESP_ZB_ZCL_ATTR_TEMP_MEASUREMENT_TOLERANCE_ID && attribute->data.type == ESP_ZB_ZCL_ATTR_TYPE_U16) { uint16_t tolerance = attribute->data.value ? *(uint16_t *)attribute->data.value : 0; - _tolerance = 1.0 * tolerance / 100; + _tolerance_temp = 1.0 * tolerance / 100; read_config++; - log_d("Received tolerance: %.2f°C from endpoint %d", _tolerance, src_endpoint); + log_d("Received tolerance: %.2f°C from endpoint %d", _tolerance_temp, src_endpoint); } if (read_config == 3) { - log_d("All config attributes processed"); + log_d("All temperature config attributes processed"); read_config = 0; xSemaphoreGive(lock); } } + static uint8_t read_humidity_config = 0; + if (cluster_id == ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT) { + if (attribute->id == ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_VALUE_ID && attribute->data.type == ESP_ZB_ZCL_ATTR_TYPE_U16) { + uint16_t value = attribute->data.value ? *(uint16_t *)attribute->data.value : 0; + float humidity = 1.0 * value / 100; + if (_on_humidity_receive) { + _on_humidity_receive(humidity); + } + if (_on_humidity_receive_with_source) { + _on_humidity_receive_with_source(humidity, src_endpoint, src_address); + } + } + if (attribute->id == ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_MIN_VALUE_ID && attribute->data.type == ESP_ZB_ZCL_ATTR_TYPE_U16) { + uint16_t min_value = attribute->data.value ? *(uint16_t *)attribute->data.value : 0; + _min_humidity = 1.0 * min_value / 100; + read_humidity_config++; + log_d("Received min humidity: %.2f% from endpoint %d", _min_humidity, src_endpoint); + } + if (attribute->id == ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_MAX_VALUE_ID && attribute->data.type == ESP_ZB_ZCL_ATTR_TYPE_U16) { + uint16_t max_value = attribute->data.value ? *(uint16_t *)attribute->data.value : 0; + _max_humidity = 1.0 * max_value / 100; + read_humidity_config++; + log_d("Received max humidity: %.2f% from endpoint %d", _max_humidity, src_endpoint); + } + if (attribute->id == ESP_ZB_ZCL_ATTR_REL_HUMIDITY_TOLERANCE_ID && attribute->data.type == ESP_ZB_ZCL_ATTR_TYPE_U16) { + uint16_t tolerance = attribute->data.value ? *(uint16_t *)attribute->data.value : 0; + _tolerance_humidity = 1.0 * tolerance / 100; + read_humidity_config++; + log_d("Received tolerance: %.2f% from endpoint %d", _tolerance_humidity, src_endpoint); + } + if (read_humidity_config == 3) { + log_d("All humidity config attributes processed"); + read_humidity_config = 0; + xSemaphoreGive(lock); + } + } } +// Temperature measuring methods + void ZigbeeThermostat::getTemperature() { /* Send "read attributes" command to all bound sensors */ esp_zb_zcl_read_attr_cmd_t read_req; @@ -248,7 +294,7 @@ void ZigbeeThermostat::getTemperature(uint8_t endpoint, esp_zb_ieee_addr_t ieee_ esp_zb_lock_release(); } -void ZigbeeThermostat::getSensorSettings() { +void ZigbeeThermostat::getTemperatureSettings() { /* Send "read attributes" command to all bound sensors */ esp_zb_zcl_read_attr_cmd_t read_req; memset(&read_req, 0, sizeof(read_req)); @@ -273,11 +319,11 @@ void ZigbeeThermostat::getSensorSettings() { return; } else { //Call the callback function when all attributes are read - _on_config_receive(_min_temp, _max_temp, _tolerance); + _on_temp_config_receive(_min_temp, _max_temp, _tolerance_temp); } } -void ZigbeeThermostat::getSensorSettings(uint16_t group_addr) { +void ZigbeeThermostat::getTemperatureSettings(uint16_t group_addr) { /* Send "read attributes" command to the group */ esp_zb_zcl_read_attr_cmd_t read_req; memset(&read_req, 0, sizeof(read_req)); @@ -303,11 +349,11 @@ void ZigbeeThermostat::getSensorSettings(uint16_t group_addr) { return; } else { //Call the callback function when all attributes are read - _on_config_receive(_min_temp, _max_temp, _tolerance); + _on_temp_config_receive(_min_temp, _max_temp, _tolerance_temp); } } -void ZigbeeThermostat::getSensorSettings(uint8_t endpoint, uint16_t short_addr) { +void ZigbeeThermostat::getTemperatureSettings(uint8_t endpoint, uint16_t short_addr) { /* Send "read attributes" command to specific endpoint */ esp_zb_zcl_read_attr_cmd_t read_req; memset(&read_req, 0, sizeof(read_req)); @@ -334,11 +380,11 @@ void ZigbeeThermostat::getSensorSettings(uint8_t endpoint, uint16_t short_addr) return; } else { //Call the callback function when all attributes are read - _on_config_receive(_min_temp, _max_temp, _tolerance); + _on_temp_config_receive(_min_temp, _max_temp, _tolerance_temp); } } -void ZigbeeThermostat::getSensorSettings(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr) { +void ZigbeeThermostat::getTemperatureSettings(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr) { /* Send "read attributes" command to specific endpoint */ esp_zb_zcl_read_attr_cmd_t read_req; memset(&read_req, 0, sizeof(read_req)); @@ -368,7 +414,7 @@ void ZigbeeThermostat::getSensorSettings(uint8_t endpoint, esp_zb_ieee_addr_t ie return; } else { //Call the callback function when all attributes are read - _on_config_receive(_min_temp, _max_temp, _tolerance); + _on_temp_config_receive(_min_temp, _max_temp, _tolerance_temp); } } @@ -394,7 +440,7 @@ void ZigbeeThermostat::setTemperatureReporting(uint16_t min_interval, uint16_t m report_cmd.record_number = ZB_ARRAY_LENGHT(records); report_cmd.record_field = records; - log_i("Sending 'configure reporting' command"); + log_i("Sending 'configure temperature reporting' command"); esp_zb_lock_acquire(portMAX_DELAY); esp_zb_zcl_config_report_cmd_req(&report_cmd); esp_zb_lock_release(); @@ -423,7 +469,7 @@ void ZigbeeThermostat::setTemperatureReporting(uint16_t group_addr, uint16_t min report_cmd.record_number = ZB_ARRAY_LENGHT(records); report_cmd.record_field = records; - log_i("Sending 'configure reporting' command to group address 0x%x", group_addr); + log_i("Sending 'configure temperature reporting' command to group address 0x%x", group_addr); esp_zb_lock_acquire(portMAX_DELAY); esp_zb_zcl_config_report_cmd_req(&report_cmd); esp_zb_lock_release(); @@ -453,7 +499,7 @@ void ZigbeeThermostat::setTemperatureReporting(uint8_t endpoint, uint16_t short_ report_cmd.record_number = ZB_ARRAY_LENGHT(records); report_cmd.record_field = records; - log_i("Sending 'configure reporting' command to endpoint %d, address 0x%x", endpoint, short_addr); + log_i("Sending 'configure temperature reporting' command to endpoint %d, address 0x%x", endpoint, short_addr); esp_zb_lock_acquire(portMAX_DELAY); esp_zb_zcl_config_report_cmd_req(&report_cmd); esp_zb_lock_release(); @@ -484,7 +530,7 @@ void ZigbeeThermostat::setTemperatureReporting(uint8_t endpoint, esp_zb_ieee_add report_cmd.record_field = records; log_i( - "Sending 'configure reporting' command to endpoint %d, ieee address %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", endpoint, ieee_addr[7], ieee_addr[6], + "Sending 'configure temperature reporting' command to endpoint %d, ieee address %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", endpoint, ieee_addr[7], ieee_addr[6], ieee_addr[5], ieee_addr[4], ieee_addr[3], ieee_addr[2], ieee_addr[1], ieee_addr[0] ); esp_zb_lock_acquire(portMAX_DELAY); @@ -492,4 +538,329 @@ void ZigbeeThermostat::setTemperatureReporting(uint8_t endpoint, esp_zb_ieee_add esp_zb_lock_release(); } +// Humidity measuring methods + +void ZigbeeThermostat::getHumidity() { + /* Send "read attributes" command to all bound sensors */ + esp_zb_zcl_read_attr_cmd_t read_req; + memset(&read_req, 0, sizeof(read_req)); + read_req.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; + read_req.zcl_basic_cmd.src_endpoint = _endpoint; + read_req.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + + uint16_t attributes[] = {ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_VALUE_ID}; + read_req.attr_number = ZB_ARRAY_LENGHT(attributes); + read_req.attr_field = attributes; + + log_i("Sending 'read humidity' command"); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_read_attr_cmd_req(&read_req); + esp_zb_lock_release(); +} + +void ZigbeeThermostat::getHumidity(uint16_t group_addr) { + /* Send "read attributes" command to the group */ + esp_zb_zcl_read_attr_cmd_t read_req; + memset(&read_req, 0, sizeof(read_req)); + read_req.address_mode = ESP_ZB_APS_ADDR_MODE_16_GROUP_ENDP_NOT_PRESENT; + read_req.zcl_basic_cmd.src_endpoint = _endpoint; + read_req.zcl_basic_cmd.dst_addr_u.addr_short = group_addr; + read_req.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + + uint16_t attributes[] = {ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_VALUE_ID}; + read_req.attr_number = ZB_ARRAY_LENGHT(attributes); + read_req.attr_field = attributes; + + log_i("Sending 'read humidity' command to group address 0x%x", group_addr); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_read_attr_cmd_req(&read_req); + esp_zb_lock_release(); +} + +void ZigbeeThermostat::getHumidity(uint8_t endpoint, uint16_t short_addr) { + /* Send "read attributes" command to specific endpoint */ + esp_zb_zcl_read_attr_cmd_t read_req; + memset(&read_req, 0, sizeof(read_req)); + read_req.address_mode = ESP_ZB_APS_ADDR_MODE_16_ENDP_PRESENT; + read_req.zcl_basic_cmd.src_endpoint = _endpoint; + read_req.zcl_basic_cmd.dst_endpoint = endpoint; + read_req.zcl_basic_cmd.dst_addr_u.addr_short = short_addr; + read_req.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + + uint16_t attributes[] = {ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_VALUE_ID}; + read_req.attr_number = ZB_ARRAY_LENGHT(attributes); + read_req.attr_field = attributes; + + log_i("Sending 'read humidity' command to endpoint %d, address 0x%x", endpoint, short_addr); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_read_attr_cmd_req(&read_req); + esp_zb_lock_release(); +} + +void ZigbeeThermostat::getHumidity(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr) { + /* Send "read attributes" command to specific endpoint */ + esp_zb_zcl_read_attr_cmd_t read_req; + memset(&read_req, 0, sizeof(read_req)); + read_req.address_mode = ESP_ZB_APS_ADDR_MODE_64_ENDP_PRESENT; + read_req.zcl_basic_cmd.src_endpoint = _endpoint; + read_req.zcl_basic_cmd.dst_endpoint = endpoint; + read_req.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + memcpy(read_req.zcl_basic_cmd.dst_addr_u.addr_long, ieee_addr, sizeof(esp_zb_ieee_addr_t)); + + uint16_t attributes[] = {ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_VALUE_ID}; + read_req.attr_number = ZB_ARRAY_LENGHT(attributes); + read_req.attr_field = attributes; + + log_i( + "Sending 'read humidity' command to endpoint %d, ieee address %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", endpoint, ieee_addr[7], ieee_addr[6], + ieee_addr[5], ieee_addr[4], ieee_addr[3], ieee_addr[2], ieee_addr[1], ieee_addr[0] + ); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_read_attr_cmd_req(&read_req); + esp_zb_lock_release(); +} + +void ZigbeeThermostat::getHumiditySettings() { + /* Send "read attributes" command to all bound sensors */ + esp_zb_zcl_read_attr_cmd_t read_req; + memset(&read_req, 0, sizeof(read_req)); + read_req.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; + read_req.zcl_basic_cmd.src_endpoint = _endpoint; + read_req.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + + uint16_t attributes[] = { + ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_MIN_VALUE_ID, ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_MAX_VALUE_ID, ESP_ZB_ZCL_ATTR_REL_HUMIDITY_TOLERANCE_ID + }; + read_req.attr_number = ZB_ARRAY_LENGHT(attributes); + read_req.attr_field = attributes; + + log_i("Sending 'read humidity settings' command"); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_read_attr_cmd_req(&read_req); + esp_zb_lock_release(); + + //Take semaphore to wait for response of all attributes + if (xSemaphoreTake(lock, ZB_CMD_TIMEOUT) != pdTRUE) { + log_e("Error while reading attributes"); + return; + } else { + //Call the callback function when all attributes are read + _on_humidity_config_receive(_min_humidity, _max_humidity, _tolerance_humidity); + } +} + +void ZigbeeThermostat::getHumiditySettings(uint16_t group_addr) { + /* Send "read attributes" command to the group */ + esp_zb_zcl_read_attr_cmd_t read_req; + memset(&read_req, 0, sizeof(read_req)); + read_req.address_mode = ESP_ZB_APS_ADDR_MODE_16_GROUP_ENDP_NOT_PRESENT; + read_req.zcl_basic_cmd.src_endpoint = _endpoint; + read_req.zcl_basic_cmd.dst_addr_u.addr_short = group_addr; + read_req.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + + uint16_t attributes[] = { + ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_MIN_VALUE_ID, ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_MAX_VALUE_ID, ESP_ZB_ZCL_ATTR_REL_HUMIDITY_TOLERANCE_ID + }; + read_req.attr_number = ZB_ARRAY_LENGHT(attributes); + read_req.attr_field = attributes; + + log_i("Sending 'read humidity settings' command to group address 0x%x", group_addr); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_read_attr_cmd_req(&read_req); + esp_zb_lock_release(); + + //Take semaphore to wait for response of all attributes + if (xSemaphoreTake(lock, ZB_CMD_TIMEOUT) != pdTRUE) { + log_e("Error while reading attributes"); + return; + } else { + //Call the callback function when all attributes are read + _on_humidity_config_receive(_min_humidity, _max_humidity, _tolerance_humidity); + } +} + +void ZigbeeThermostat::getHumiditySettings(uint8_t endpoint, uint16_t short_addr) { + /* Send "read attributes" command to specific endpoint */ + esp_zb_zcl_read_attr_cmd_t read_req; + memset(&read_req, 0, sizeof(read_req)); + read_req.address_mode = ESP_ZB_APS_ADDR_MODE_16_ENDP_PRESENT; + read_req.zcl_basic_cmd.src_endpoint = _endpoint; + read_req.zcl_basic_cmd.dst_endpoint = endpoint; + read_req.zcl_basic_cmd.dst_addr_u.addr_short = short_addr; + read_req.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + + uint16_t attributes[] = { + ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_MIN_VALUE_ID, ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_MAX_VALUE_ID, ESP_ZB_ZCL_ATTR_REL_HUMIDITY_TOLERANCE_ID + }; + read_req.attr_number = ZB_ARRAY_LENGHT(attributes); + read_req.attr_field = attributes; + + log_i("Sending 'read humidity settings' command to endpoint %d, address 0x%x", endpoint, short_addr); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_read_attr_cmd_req(&read_req); + esp_zb_lock_release(); + + //Take semaphore to wait for response of all attributes + if (xSemaphoreTake(lock, ZB_CMD_TIMEOUT) != pdTRUE) { + log_e("Error while reading attributes"); + return; + } else { + //Call the callback function when all attributes are read + _on_humidity_config_receive(_min_humidity, _max_humidity, _tolerance_humidity); + } +} + +void ZigbeeThermostat::getHumiditySettings(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr) { + /* Send "read attributes" command to specific endpoint */ + esp_zb_zcl_read_attr_cmd_t read_req; + memset(&read_req, 0, sizeof(read_req)); + read_req.address_mode = ESP_ZB_APS_ADDR_MODE_64_ENDP_PRESENT; + read_req.zcl_basic_cmd.src_endpoint = _endpoint; + read_req.zcl_basic_cmd.dst_endpoint = endpoint; + read_req.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + memcpy(read_req.zcl_basic_cmd.dst_addr_u.addr_long, ieee_addr, sizeof(esp_zb_ieee_addr_t)); + + uint16_t attributes[] = { + ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_MIN_VALUE_ID, ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_MAX_VALUE_ID, ESP_ZB_ZCL_ATTR_REL_HUMIDITY_TOLERANCE_ID + }; + read_req.attr_number = ZB_ARRAY_LENGHT(attributes); + read_req.attr_field = attributes; + + log_i( + "Sending 'read humidity settings' command to endpoint %d, ieee address %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", endpoint, ieee_addr[7], ieee_addr[6], + ieee_addr[5], ieee_addr[4], ieee_addr[3], ieee_addr[2], ieee_addr[1], ieee_addr[0] + ); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_read_attr_cmd_req(&read_req); + esp_zb_lock_release(); + + //Take semaphore to wait for response of all attributes + if (xSemaphoreTake(lock, ZB_CMD_TIMEOUT) != pdTRUE) { + log_e("Error while reading attributes"); + return; + } else { + //Call the callback function when all attributes are read + _on_humidity_config_receive(_min_humidity, _max_humidity, _tolerance_humidity); + } +} + +void ZigbeeThermostat::setHumidityReporting(uint16_t min_interval, uint16_t max_interval, float delta) { + /* Send "configure report attribute" command to all bound sensors */ + esp_zb_zcl_config_report_cmd_t report_cmd; + memset(&report_cmd, 0, sizeof(report_cmd)); + report_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_DST_ADDR_ENDP_NOT_PRESENT; + report_cmd.zcl_basic_cmd.src_endpoint = _endpoint; + report_cmd.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + + int16_t report_change = (int16_t)delta * 100; + esp_zb_zcl_config_report_record_t records[] = { + { + .direction = ESP_ZB_ZCL_REPORT_DIRECTION_SEND, + .attributeID = ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_VALUE_ID, + .attrType = ESP_ZB_ZCL_ATTR_TYPE_U16, + .min_interval = min_interval, + .max_interval = max_interval, + .reportable_change = (void *)&report_change, + }, + }; + report_cmd.record_number = ZB_ARRAY_LENGHT(records); + report_cmd.record_field = records; + + log_i("Sending 'configure humidity reporting' command"); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_config_report_cmd_req(&report_cmd); + esp_zb_lock_release(); +} + +void ZigbeeThermostat::setHumidityReporting(uint16_t group_addr, uint16_t min_interval, uint16_t max_interval, float delta) { + /* Send "configure report attribute" command to the group */ + esp_zb_zcl_config_report_cmd_t report_cmd; + memset(&report_cmd, 0, sizeof(report_cmd)); + report_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_16_GROUP_ENDP_NOT_PRESENT; + report_cmd.zcl_basic_cmd.src_endpoint = _endpoint; + report_cmd.zcl_basic_cmd.dst_addr_u.addr_short = group_addr; + report_cmd.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + + int16_t report_change = (int16_t)delta * 100; + esp_zb_zcl_config_report_record_t records[] = { + { + .direction = ESP_ZB_ZCL_REPORT_DIRECTION_SEND, + .attributeID = ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_VALUE_ID, + .attrType = ESP_ZB_ZCL_ATTR_TYPE_U16, + .min_interval = min_interval, + .max_interval = max_interval, + .reportable_change = (void *)&report_change, + }, + }; + report_cmd.record_number = ZB_ARRAY_LENGHT(records); + report_cmd.record_field = records; + + log_i("Sending 'configure humidity reporting' command to group address 0x%x", group_addr); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_config_report_cmd_req(&report_cmd); + esp_zb_lock_release(); +} + +void ZigbeeThermostat::setHumidityReporting(uint8_t endpoint, uint16_t short_addr, uint16_t min_interval, uint16_t max_interval, float delta) { + /* Send "configure report attribute" command to specific endpoint */ + esp_zb_zcl_config_report_cmd_t report_cmd; + memset(&report_cmd, 0, sizeof(report_cmd)); + report_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_16_ENDP_PRESENT; + report_cmd.zcl_basic_cmd.src_endpoint = _endpoint; + report_cmd.zcl_basic_cmd.dst_endpoint = endpoint; + report_cmd.zcl_basic_cmd.dst_addr_u.addr_short = short_addr; + report_cmd.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + + int16_t report_change = (int16_t)delta * 100; + esp_zb_zcl_config_report_record_t records[] = { + { + .direction = ESP_ZB_ZCL_REPORT_DIRECTION_SEND, + .attributeID = ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_VALUE_ID, + .attrType = ESP_ZB_ZCL_ATTR_TYPE_U16, + .min_interval = min_interval, + .max_interval = max_interval, + .reportable_change = (void *)&report_change, + }, + }; + report_cmd.record_number = ZB_ARRAY_LENGHT(records); + report_cmd.record_field = records; + + log_i("Sending 'configure humidity reporting' command to endpoint %d, address 0x%x", endpoint, short_addr); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_config_report_cmd_req(&report_cmd); + esp_zb_lock_release(); +} + +void ZigbeeThermostat::setHumidityReporting(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr, uint16_t min_interval, uint16_t max_interval, float delta) { + /* Send "configure report attribute" command to specific endpoint */ + esp_zb_zcl_config_report_cmd_t report_cmd; + memset(&report_cmd, 0, sizeof(report_cmd)); + report_cmd.address_mode = ESP_ZB_APS_ADDR_MODE_64_ENDP_PRESENT; + report_cmd.zcl_basic_cmd.src_endpoint = _endpoint; + report_cmd.zcl_basic_cmd.dst_endpoint = endpoint; + report_cmd.clusterID = ESP_ZB_ZCL_CLUSTER_ID_REL_HUMIDITY_MEASUREMENT; + memcpy(report_cmd.zcl_basic_cmd.dst_addr_u.addr_long, ieee_addr, sizeof(esp_zb_ieee_addr_t)); + + int16_t report_change = (int16_t)delta * 100; + esp_zb_zcl_config_report_record_t records[] = { + { + .direction = ESP_ZB_ZCL_REPORT_DIRECTION_SEND, + .attributeID = ESP_ZB_ZCL_ATTR_REL_HUMIDITY_MEASUREMENT_VALUE_ID, + .attrType = ESP_ZB_ZCL_ATTR_TYPE_U16, + .min_interval = min_interval, + .max_interval = max_interval, + .reportable_change = (void *)&report_change, + }, + }; + report_cmd.record_number = ZB_ARRAY_LENGHT(records); + report_cmd.record_field = records; + + log_i( + "Sending 'configure humidity reporting' command to endpoint %d, ieee address %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", endpoint, ieee_addr[7], ieee_addr[6], + ieee_addr[5], ieee_addr[4], ieee_addr[3], ieee_addr[2], ieee_addr[1], ieee_addr[0] + ); + esp_zb_lock_acquire(portMAX_DELAY); + esp_zb_zcl_config_report_cmd_req(&report_cmd); + esp_zb_lock_release(); +} #endif // CONFIG_ZB_ENABLED diff --git a/libraries/Zigbee/src/ep/ZigbeeThermostat.h b/libraries/Zigbee/src/ep/ZigbeeThermostat.h index 1f6aef485d6..0708f640492 100644 --- a/libraries/Zigbee/src/ep/ZigbeeThermostat.h +++ b/libraries/Zigbee/src/ep/ZigbeeThermostat.h @@ -48,14 +48,19 @@ class ZigbeeThermostat : public ZigbeeEP { ZigbeeThermostat(uint8_t endpoint); ~ZigbeeThermostat() {} + // Temperature measuring methods void onTempReceive(void (*callback)(float)) { _on_temp_receive = callback; } void onTempReceiveWithSource(void (*callback)(float, uint8_t, esp_zb_zcl_addr_t)) { _on_temp_receive_with_source = callback; } - void onConfigReceive(void (*callback)(float, float, float)) { - _on_config_receive = callback; + // For backward compatibility: keep onConfigReceive as an alias to onTempConfigReceive (deprecated). + [[deprecated("Use onTempConfigReceive instead.")]] void onConfigReceive(void (*callback)(float, float, float)) { + onTempConfigReceive(callback); + } + void onTempConfigReceive(void (*callback)(float, float, float)) { + _on_temp_config_receive = callback; } void getTemperature(); @@ -63,16 +68,48 @@ class ZigbeeThermostat : public ZigbeeEP { void getTemperature(uint8_t endpoint, uint16_t short_addr); void getTemperature(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr); - void getSensorSettings(); - void getSensorSettings(uint16_t group_addr); - void getSensorSettings(uint8_t endpoint, uint16_t short_addr); - void getSensorSettings(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr); + // For backward compatibility: keep getSensorSettings as an alias to getTemperatureSettings (deprecated). + [[deprecated("Use getTemperatureSettings instead.")]] void getSensorSettings() { getTemperatureSettings(); } + [[deprecated("Use getTemperatureSettings instead.")]] void getSensorSettings(uint16_t group_addr) { getTemperatureSettings(group_addr); } + [[deprecated("Use getTemperatureSettings instead.")]] void getSensorSettings(uint8_t endpoint, uint16_t short_addr) { getTemperatureSettings(endpoint, short_addr); } + [[deprecated("Use getTemperatureSettings instead.")]] void getSensorSettings(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr) { getTemperatureSettings(endpoint, ieee_addr); } + + void getTemperatureSettings(); + void getTemperatureSettings(uint16_t group_addr); + void getTemperatureSettings(uint8_t endpoint, uint16_t short_addr); + void getTemperatureSettings(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr); void setTemperatureReporting(uint16_t min_interval, uint16_t max_interval, float delta); void setTemperatureReporting(uint16_t group_addr, uint16_t min_interval, uint16_t max_interval, float delta); void setTemperatureReporting(uint8_t endpoint, uint16_t short_addr, uint16_t min_interval, uint16_t max_interval, float delta); void setTemperatureReporting(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr, uint16_t min_interval, uint16_t max_interval, float delta); + // Humidity measuring methods + void onHumidityReceive(void (*callback)(float)) { + _on_humidity_receive = callback; + } + void onHumidityReceiveWithSource(void (*callback)(float, uint8_t, esp_zb_zcl_addr_t)) { + _on_humidity_receive_with_source = callback; + } + void onHumidityConfigReceive(void (*callback)(float, float, float)) { + _on_humidity_config_receive = callback; + } + + void getHumidity(); + void getHumidity(uint16_t group_addr); + void getHumidity(uint8_t endpoint, uint16_t short_addr); + void getHumidity(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr); + + void getHumiditySettings(); + void getHumiditySettings(uint16_t group_addr); + void getHumiditySettings(uint8_t endpoint, uint16_t short_addr); + void getHumiditySettings(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr); + + void setHumidityReporting(uint16_t min_interval, uint16_t max_interval, float delta); + void setHumidityReporting(uint16_t group_addr, uint16_t min_interval, uint16_t max_interval, float delta); + void setHumidityReporting(uint8_t endpoint, uint16_t short_addr, uint16_t min_interval, uint16_t max_interval, float delta); + void setHumidityReporting(uint8_t endpoint, esp_zb_ieee_addr_t ieee_addr, uint16_t min_interval, uint16_t max_interval, float delta); + private: // save instance of the class in order to use it in static functions static ZigbeeThermostat *_instance; @@ -80,10 +117,17 @@ class ZigbeeThermostat : public ZigbeeEP { void (*_on_temp_receive)(float); void (*_on_temp_receive_with_source)(float, uint8_t, esp_zb_zcl_addr_t); - void (*_on_config_receive)(float, float, float); + void (*_on_temp_config_receive)(float, float, float); float _min_temp; float _max_temp; - float _tolerance; + float _tolerance_temp; + + void (*_on_humidity_receive)(float); + void (*_on_humidity_receive_with_source)(float, uint8_t, esp_zb_zcl_addr_t); + void (*_on_humidity_config_receive)(float, float, float); + float _min_humidity; + float _max_humidity; + float _tolerance_humidity; void findEndpoint(esp_zb_zdo_match_desc_req_param_t *cmd_req); void bindCb(esp_zb_zdp_status_t zdo_status, void *user_ctx);