Merge branch 'master' into release/v3.3.x

Author: me-no-dev

Diff for: cores/esp32/esp32-hal-uart.c

@@ -769,7 +769,11 @@ bool uartSetRxTimeout(uart_t *uart, uint8_t numSymbTimeout) {
   if (uart == NULL) {
     return false;
   }
-
+  uint16_t maxRXTimeout = uart_get_max_rx_timeout(uart->num);
+  if (numSymbTimeout > maxRXTimeout) {
+    log_e("Invalid RX Timeout value, its limit is %d", maxRXTimeout);
+    return false;
+  }
   UART_MUTEX_LOCK();
   bool retCode = (ESP_OK == uart_set_rx_timeout(uart->num, numSymbTimeout));
   UART_MUTEX_UNLOCK();
@@ -1394,4 +1398,24 @@ int uart_send_msg_with_break(uint8_t uartNum, uint8_t *msg, size_t msgSize) {
   return uart_write_bytes_with_break(uartNum, (const void *)msg, msgSize, 12);
 }
 
+// returns the maximum valid uart RX Timeout based on the UART Source Clock and Baudrate
+uint16_t uart_get_max_rx_timeout(uint8_t uartNum) {
+  if (uartNum >= SOC_UART_NUM) {
+    log_e("UART%d is invalid. This device has %d UARTs, from 0 to %d.", uartNum, SOC_UART_NUM, SOC_UART_NUM - 1);
+    return (uint16_t)-1;
+  }
+  uint16_t tout_max_thresh = uart_ll_max_tout_thrd(UART_LL_GET_HW(uartNum));
+  uint8_t symbol_len = 1;  // number of bits per symbol including start
+  uart_parity_t parity_mode;
+  uart_stop_bits_t stop_bit;
+  uart_word_length_t data_bit;
+  uart_ll_get_data_bit_num(UART_LL_GET_HW(uartNum), &data_bit);
+  uart_ll_get_stop_bits(UART_LL_GET_HW(uartNum), &stop_bit);
+  uart_ll_get_parity(UART_LL_GET_HW(uartNum), &parity_mode);
+  symbol_len += (data_bit < UART_DATA_BITS_MAX) ? (uint8_t)data_bit + 5 : 8;
+  symbol_len += (stop_bit > UART_STOP_BITS_1) ? 2 : 1;
+  symbol_len += (parity_mode > UART_PARITY_DISABLE) ? 1 : 0;
+  return (uint16_t)(tout_max_thresh / symbol_len);
+}
+
 #endif /* SOC_UART_SUPPORTED */

Diff for: cores/esp32/esp32-hal-uart.h

@@ -116,6 +116,10 @@ void uart_send_break(uint8_t uartNum);
 // Sends a buffer and at the end of the stream, it generates BREAK in the line
 int uart_send_msg_with_break(uint8_t uartNum, uint8_t *msg, size_t msgSize);
 
+// UART RX Timeout (in UART Symbols) depends on the UART Clock Source and the SoC that is used
+// This is a helper function that calculates what is the maximum RX Timeout that a running UART IDF driver allows.
+uint16_t uart_get_max_rx_timeout(uint8_t uartNum);
+
 #ifdef __cplusplus
 }
 #endif

Diff for: libraries/ESP32/examples/Camera/CameraWebServer/camera_index.h

@@ -77,7 +77,7 @@ void setup() {
   esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
 
   // Optional: set Zigbee device name and model
-  zbTempSensor.setManufacturerAndModel("Espressif", "SleepyZigbeeTempSensorTest");
+  zbTempSensor.setManufacturerAndModel("Espressif", "SleepyZigbeeTempSensor");
 
   // Set minimum and maximum temperature measurement value (10-50°C is default range for chip temperature measurement)
   zbTempSensor.setMinMaxValue(10, 50);
@@ -99,11 +99,15 @@ void setup() {
   esp_zb_cfg_t zigbeeConfig = ZIGBEE_DEFAULT_ED_CONFIG();
   zigbeeConfig.nwk_cfg.zed_cfg.keep_alive = 10000;
 
+  // For battery powered devices, it can be better to set timeout for Zigbee Begin to lower value to save battery
+  // If the timeout has been reached, the network channel mask will be reset and the device will try to connect again after reset (scanning all channels)
+  Zigbee.setTimeout(10000);  // Set timeout for Zigbee Begin to 10s (default is 30s)
+
   // When all EPs are registered, start Zigbee in End Device mode
   if (!Zigbee.begin(&zigbeeConfig, false)) {
     Serial.println("Zigbee failed to start!");
     Serial.println("Rebooting...");
-    ESP.restart();
+    ESP.restart();  // If Zigbee failed to start, reboot the device and try again
   }
   Serial.println("Connecting to network");
   while (!Zigbee.connected()) {

Diff for: libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino

@@ -6,9 +6,16 @@
 #include "ZigbeeHandlers.cpp"
 #include "Arduino.h"
 
-#define ZB_INIT_TIMEOUT 30000  // 30 seconds
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "zboss_api.h"
+extern zb_ret_t zb_nvram_write_dataset(zb_nvram_dataset_types_t t);                            // rejoin scanning workaround
+extern void zb_set_ed_node_descriptor(bool power_src, bool rx_on_when_idle, bool alloc_addr);  // sleepy device power mode workaround
+#ifdef __cplusplus
+}
+#endif
 
-extern "C" void zb_set_ed_node_descriptor(bool power_src, bool rx_on_when_idle, bool alloc_addr);
 static bool edBatteryPowered = false;
 
 ZigbeeCore::ZigbeeCore() {
@@ -18,6 +25,7 @@ ZigbeeCore::ZigbeeCore() {
   _primary_channel_mask = ESP_ZB_TRANSCEIVER_ALL_CHANNELS_MASK;
   _open_network = 0;
   _scan_status = ZB_SCAN_FAILED;
+  _begin_timeout = ZB_BEGIN_TIMEOUT_DEFAULT;
   _started = false;
   _connected = false;
   _scan_duration = 3;  // default scan duration
@@ -39,8 +47,11 @@ bool ZigbeeCore::begin(esp_zb_cfg_t *role_cfg, bool erase_nvs) {
     return false;
   }
   _role = (zigbee_role_t)role_cfg->esp_zb_role;
-  if (xSemaphoreTake(lock, ZB_INIT_TIMEOUT) != pdTRUE) {
-    log_e("ZigbeeCore begin timeout");
+  if (xSemaphoreTake(lock, _begin_timeout) != pdTRUE) {
+    log_e("ZigbeeCore begin failed or timeout");
+    if (_role != ZIGBEE_COORDINATOR) {  // Only End Device and Router can rejoin
+      resetNVRAMChannelMask();
+    }
   }
   return started();
 }
@@ -71,8 +82,11 @@ bool ZigbeeCore::begin(zigbee_role_t role, bool erase_nvs) {
     }
     default: log_e("Invalid Zigbee Role"); return false;
   }
-  if (!status || xSemaphoreTake(lock, ZB_INIT_TIMEOUT) != pdTRUE) {
+  if (!status || xSemaphoreTake(lock, _begin_timeout) != pdTRUE) {
     log_e("ZigbeeCore begin failed or timeout");
+    if (_role != ZIGBEE_COORDINATOR) {  // Only End Device and Router can rejoin
+      resetNVRAMChannelMask();
+    }
   }
   return started();
 }
@@ -220,6 +234,7 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
   switch (sig_type) {
     case ESP_ZB_ZDO_SIGNAL_SKIP_STARTUP:  // Common
       log_i("Zigbee stack initialized");
+      log_d("Zigbee channel mask: 0x%08x", esp_zb_get_channel_mask());
       esp_zb_bdb_start_top_level_commissioning(ESP_ZB_BDB_MODE_INITIALIZATION);
       break;
     case ESP_ZB_BDB_SIGNAL_DEVICE_FIRST_START:  // Common
@@ -245,6 +260,8 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
             log_i("Opening network for joining for %d seconds", Zigbee._open_network);
             esp_zb_bdb_open_network(Zigbee._open_network);
           } else {
+            // Save the channel mask to NVRAM in case of reboot which may be on a different channel after a change in the network
+            Zigbee.setNVRAMChannelMask(1 << esp_zb_get_current_channel());
             Zigbee._connected = true;
           }
           Zigbee.searchBindings();
@@ -289,6 +306,8 @@ void esp_zb_app_signal_handler(esp_zb_app_signal_t *signal_struct) {
             extended_pan_id[0], esp_zb_get_pan_id(), esp_zb_get_current_channel(), esp_zb_get_short_address()
           );
           Zigbee._connected = true;
+          // Set channel mask and write to NVRAM, so that the device will re-join the network faster after reboot (scan only on the current channel)
+          Zigbee.setNVRAMChannelMask(1 << esp_zb_get_current_channel());
         } else {
           log_i("Network steering was not successful (status: %s)", esp_err_to_name(err_status));
           esp_zb_scheduler_alarm((esp_zb_callback_t)bdb_start_top_level_commissioning_cb, ESP_ZB_BDB_MODE_NETWORK_STEERING, 1000);
@@ -483,6 +502,20 @@ void ZigbeeCore::searchBindings() {
   esp_zb_zdo_binding_table_req(mb_req, bindingTableCb, (void *)mb_req);
 }
 
+void ZigbeeCore::resetNVRAMChannelMask() {
+  _primary_channel_mask = ESP_ZB_TRANSCEIVER_ALL_CHANNELS_MASK;
+  esp_zb_set_channel_mask(_primary_channel_mask);
+  zb_nvram_write_dataset(ZB_NVRAM_COMMON_DATA);
+  log_v("Channel mask reset to all channels");
+}
+
+void ZigbeeCore::setNVRAMChannelMask(uint32_t mask) {
+  _primary_channel_mask = mask;
+  esp_zb_set_channel_mask(_primary_channel_mask);
+  zb_nvram_write_dataset(ZB_NVRAM_COMMON_DATA);
+  log_v("Channel mask set to 0x%08x", mask);
+}
+
 // Function to convert enum value to string
 const char *ZigbeeCore::getDeviceTypeString(esp_zb_ha_standard_devices_t deviceId) {
   switch (deviceId) {

Diff for: libraries/Zigbee/src/ZigbeeCore.cpp

@@ -28,6 +28,8 @@ typedef enum {
 #define ZB_SCAN_RUNNING (-1)
 #define ZB_SCAN_FAILED  (-2)
 
+#define ZB_BEGIN_TIMEOUT_DEFAULT 30000  // 30 seconds
+
 #define ZIGBEE_DEFAULT_ED_CONFIG()                                      \
   {                                                                     \
     .esp_zb_role = ESP_ZB_DEVICE_TYPE_ED, .install_code_policy = false, \
@@ -85,6 +87,7 @@ class ZigbeeCore {
   esp_zb_radio_config_t _radio_config;
   esp_zb_host_config_t _host_config;
   uint32_t _primary_channel_mask;
+  uint32_t _begin_timeout;
   int16_t _scan_status;
   uint8_t _scan_duration;
   bool _rx_on_when_idle;
@@ -103,6 +106,8 @@ class ZigbeeCore {
   const char *getDeviceTypeString(esp_zb_ha_standard_devices_t deviceId);
   void searchBindings();
   static void bindingTableCb(const esp_zb_zdo_binding_table_info_t *table_info, void *user_ctx);
+  void resetNVRAMChannelMask();             // Reset to default mask also in NVRAM
+  void setNVRAMChannelMask(uint32_t mask);  // Set channel mask in NVRAM
 
 public:
   ZigbeeCore();
@@ -134,7 +139,8 @@ class ZigbeeCore {
   esp_zb_host_config_t getHostConfig();
 
   void setPrimaryChannelMask(uint32_t mask);  // By default all channels are scanned (11-26) -> mask 0x07FFF800
-  void setScanDuration(uint8_t duration);     // Can be set from 1 - 4. 1 is fastest, 4 is slowest
+
+  void setScanDuration(uint8_t duration);  // Can be set from 1 - 4. 1 is fastest, 4 is slowest
   uint8_t getScanDuration() {
     return _scan_duration;
   }
@@ -145,7 +151,9 @@ class ZigbeeCore {
   bool getRxOnWhenIdle() {
     return _rx_on_when_idle;
   }
-
+  void setTimeout(uint32_t timeout) {
+    _begin_timeout = timeout;
+  }
   void setRebootOpenNetwork(uint8_t time);
   void openNetwork(uint8_t time);
 

Diff for: libraries/Zigbee/src/ZigbeeCore.h

@@ -104,6 +104,7 @@ void ZigbeeEP::reportBatteryPercentage() {
   report_attr_cmd.direction = ESP_ZB_ZCL_CMD_DIRECTION_TO_CLI;
   report_attr_cmd.clusterID = ESP_ZB_ZCL_CLUSTER_ID_POWER_CONFIG;
   report_attr_cmd.zcl_basic_cmd.src_endpoint = _endpoint;
+  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);