Merge branch 'master' into idf-release/v5.4

Author: me-no-dev

libraries/Ethernet/src/ETH.cpp

@@ -271,8 +271,8 @@ bool ETHClass::begin(eth_phy_type_t type, int32_t phy_addr, int mdc, int mdio, i
   eth_mac_config.sw_reset_timeout_ms = 1000;
   eth_mac_config.rx_task_stack_size = _task_stack_size;
 
-  esp_eth_mac_t *mac = esp_eth_mac_new_esp32(&mac_config, &eth_mac_config);
-  if (mac == NULL) {
+  _mac = esp_eth_mac_new_esp32(&mac_config, &eth_mac_config);
+  if (_mac == NULL) {
     log_e("esp_eth_mac_new_esp32 failed");
     return false;
   }
@@ -281,26 +281,25 @@ bool ETHClass::begin(eth_phy_type_t type, int32_t phy_addr, int mdc, int mdio, i
   phy_config.phy_addr = phy_addr;
   phy_config.reset_gpio_num = _pin_power;
 
-  esp_eth_phy_t *phy = NULL;
   switch (type) {
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 0)
-    case ETH_PHY_GENERIC: phy = esp_eth_phy_new_generic(&phy_config); break;
+    case ETH_PHY_GENERIC: _phy = esp_eth_phy_new_generic(&phy_config); break;
 #endif
-    case ETH_PHY_LAN8720: phy = esp_eth_phy_new_lan87xx(&phy_config); break;
-    case ETH_PHY_TLK110:  phy = esp_eth_phy_new_ip101(&phy_config); break;
-    case ETH_PHY_RTL8201: phy = esp_eth_phy_new_rtl8201(&phy_config); break;
-    case ETH_PHY_DP83848: phy = esp_eth_phy_new_dp83848(&phy_config); break;
-    case ETH_PHY_KSZ8041: phy = esp_eth_phy_new_ksz80xx(&phy_config); break;
-    case ETH_PHY_KSZ8081: phy = esp_eth_phy_new_ksz80xx(&phy_config); break;
+    case ETH_PHY_LAN8720: _phy = esp_eth_phy_new_lan87xx(&phy_config); break;
+    case ETH_PHY_TLK110:  _phy = esp_eth_phy_new_ip101(&phy_config); break;
+    case ETH_PHY_RTL8201: _phy = esp_eth_phy_new_rtl8201(&phy_config); break;
+    case ETH_PHY_DP83848: _phy = esp_eth_phy_new_dp83848(&phy_config); break;
+    case ETH_PHY_KSZ8041: _phy = esp_eth_phy_new_ksz80xx(&phy_config); break;
+    case ETH_PHY_KSZ8081: _phy = esp_eth_phy_new_ksz80xx(&phy_config); break;
     default:              log_e("Unsupported PHY %d", type); break;
   }
-  if (phy == NULL) {
+  if (_phy == NULL) {
     log_e("esp_eth_phy_new failed");
     return false;
   }
 
   _eth_handle = NULL;
-  esp_eth_config_t eth_config = ETH_DEFAULT_CONFIG(mac, phy);
+  esp_eth_config_t eth_config = ETH_DEFAULT_CONFIG(_mac, _phy);
   ret = esp_eth_driver_install(&eth_config, &_eth_handle);
   if (ret != ESP_OK) {
     log_e("Ethernet driver install failed: %d", ret);
@@ -1010,6 +1009,18 @@ bool ETHClass::fullDuplex() const {
   return (link_duplex == ETH_DUPLEX_FULL);
 }
 
+bool ETHClass::setFullDuplex(bool on) {
+  if (_eth_handle == NULL) {
+    return false;
+  }
+  eth_duplex_t link_duplex = on ? ETH_DUPLEX_FULL : ETH_DUPLEX_HALF;
+  esp_err_t err = esp_eth_ioctl(_eth_handle, ETH_CMD_S_DUPLEX_MODE, &link_duplex);
+  if (err != ESP_OK) {
+    log_e("Failed to set duplex mode: 0x%x: %s", err, esp_err_to_name(err));
+  }
+  return err == ESP_OK;
+}
+
 bool ETHClass::autoNegotiation() const {
   if (_eth_handle == NULL) {
     return false;
@@ -1019,6 +1030,17 @@ bool ETHClass::autoNegotiation() const {
   return auto_nego;
 }
 
+bool ETHClass::setAutoNegotiation(bool on) {
+  if (_eth_handle == NULL) {
+    return false;
+  }
+  esp_err_t err = esp_eth_ioctl(_eth_handle, ETH_CMD_S_AUTONEGO, &on);
+  if (err != ESP_OK) {
+    log_e("Failed to set auto negotiation: 0x%x: %s", err, esp_err_to_name(err));
+  }
+  return err == ESP_OK;
+}
+
 uint32_t ETHClass::phyAddr() const {
   if (_eth_handle == NULL) {
     return 0;
@@ -1028,7 +1050,7 @@ uint32_t ETHClass::phyAddr() const {
   return phy_addr;
 }
 
-uint8_t ETHClass::linkSpeed() const {
+uint16_t ETHClass::linkSpeed() const {
   if (_eth_handle == NULL) {
     return 0;
   }
@@ -1037,6 +1059,18 @@ uint8_t ETHClass::linkSpeed() const {
   return (link_speed == ETH_SPEED_10M) ? 10 : 100;
 }
 
+bool ETHClass::setLinkSpeed(uint16_t speed) {
+  if (_eth_handle == NULL) {
+    return false;
+  }
+  eth_speed_t link_speed = (speed == 10) ? ETH_SPEED_10M : ETH_SPEED_100M;
+  esp_err_t err = esp_eth_ioctl(_eth_handle, ETH_CMD_S_SPEED, &link_speed);
+  if (err != ESP_OK) {
+    log_e("Failed to set link speed: 0x%x: %s", err, esp_err_to_name(err));
+  }
+  return err == ESP_OK;
+}
+
 // void ETHClass::getMac(uint8_t* mac)
 // {
 //     if(_eth_handle != NULL && mac != NULL){

libraries/Ethernet/src/ETH.h

@@ -192,8 +192,14 @@ class ETHClass : public NetworkInterface {
 
   // ETH Handle APIs
   bool fullDuplex() const;
-  uint8_t linkSpeed() const;
+  bool setFullDuplex(bool on);
+
+  uint16_t linkSpeed() const;
+  bool setLinkSpeed(uint16_t speed);  //10 or 100
+
   bool autoNegotiation() const;
+  bool setAutoNegotiation(bool on);
+
   uint32_t phyAddr() const;
 
   esp_eth_handle_t handle() const;

libraries/Matter/examples/MatterColorLight/MatterColorLight.ino

@@ -60,6 +60,10 @@ bool setLightState(bool state, espHsvColor_t colorHSV) {
     analogWrite(ledPin, colorHSV.v);
 #endif
   } else {
+#ifndef RGB_BUILTIN
+    // after analogWrite(), it is necessary to set the GPIO to digital mode first
+    pinMode(ledPin, OUTPUT);
+#endif
     digitalWrite(ledPin, LOW);
   }
   // store last HSV Color and OnOff state for when the Light is restarted / power goes off

libraries/Matter/examples/MatterDimmableLight/MatterDimmableLight.ino

@@ -56,6 +56,10 @@ bool setLightState(bool state, uint8_t brightness) {
     analogWrite(ledPin, brightness);
 #endif
   } else {
+#ifndef RGB_BUILTIN
+    // after analogWrite(), it is necessary to set the GPIO to digital mode first
+    pinMode(ledPin, OUTPUT);
+#endif
     digitalWrite(ledPin, LOW);
   }
   // store last Brightness and OnOff state for when the Light is restarted / power goes off

libraries/Matter/examples/MatterEnhancedColorLight/MatterEnhancedColorLight.ino

@@ -64,6 +64,10 @@ bool setLightState(bool state, espHsvColor_t colorHSV, uint8_t brighteness, uint
     analogWrite(ledPin, colorHSV.v);
 #endif
   } else {
+#ifndef RGB_BUILTIN
+    // after analogWrite(), it is necessary to set the GPIO to digital mode first
+    pinMode(ledPin, OUTPUT);
+#endif
     digitalWrite(ledPin, LOW);
   }
   // store last HSV Color and OnOff state for when the Light is restarted / power goes off

libraries/Matter/examples/MatterFan/MatterFan.ino

@@ -49,6 +49,10 @@ void fanDCMotorDrive(bool fanState, uint8_t speedPercent) {
   // drive the Fan DC motor
   if (fanState == false) {
     // turn off the Fan
+#ifndef RGB_BUILTIN
+    // after analogWrite(), it is necessary to set the GPIO to digital mode first
+    pinMode(dcMotorPin, OUTPUT);
+#endif
     digitalWrite(dcMotorPin, LOW);
   } else {
     // set the Fan speed

libraries/Matter/examples/MatterTemperatureLight/MatterTemperatureLight.ino

@@ -66,6 +66,10 @@ bool setLightState(bool state, uint8_t brightness, uint16_t temperature_Mireds)
     analogWrite(ledPin, brightness);
 #endif
   } else {
+#ifndef RGB_BUILTIN
+    // after analogWrite(), it is necessary to set the GPIO to digital mode first
+    pinMode(ledPin, OUTPUT);
+#endif
     digitalWrite(ledPin, LOW);
   }
   // store last Brightness and OnOff state for when the Light is restarted / power goes off

libraries/Matter/src/MatterEndpoints/MatterColorLight.h

@@ -66,8 +66,8 @@ class MatterColorLight : public MatterEndPoint {
 
 protected:
   bool started = false;
-  bool onOffState = false;       // default initial state is off, but it can be changed by begin(bool)
-  espHsvColor_t colorHSV = {0};  // default initial color HSV is black, but it can be changed by begin(bool, espHsvColor_t)
+  bool onOffState = false;             // default initial state is off, but it can be changed by begin(bool)
+  espHsvColor_t colorHSV = {0, 0, 0};  // default initial color HSV is black, but it can be changed by begin(bool, espHsvColor_t)
   EndPointOnOffCB _onChangeOnOffCB = NULL;
   EndPointRGBColorCB _onChangeColorCB = NULL;
   EndPointCB _onChangeCB = NULL;

libraries/Matter/src/MatterEndpoints/MatterEnhancedColorLight.h

@@ -91,7 +91,7 @@ class MatterEnhancedColorLight : public MatterEndPoint {
   bool started = false;
   bool onOffState = false;             // default initial state is off, but it can be changed by begin(bool)
   uint8_t brightnessLevel = 0;         // default initial brightness is 0, but it can be changed by begin(bool, uint8_t)
-  espHsvColor_t colorHSV = {0};        // default initial color HSV is black, but it can be changed by begin(bool, uint8_t, espHsvColor_t)
+  espHsvColor_t colorHSV = {0, 0, 0};  // default initial color HSV is black, but it can be changed by begin(bool, uint8_t, espHsvColor_t)
   uint16_t colorTemperatureLevel = 0;  // default initial color temperature is 0, but it can be changed by begin(bool, uint8_t, espHsvColor_t, uint16_t)
   EndPointOnOffCB _onChangeOnOffCB = NULL;
   EndPointBrightnessCB _onChangeBrightnessCB = NULL;

libraries/Network/src/NetworkClient.cpp

@@ -23,7 +23,11 @@
 #include <lwip/netdb.h>
 #include <errno.h>
 
-#define IN6_IS_ADDR_V4MAPPED(a) ((((__const uint32_t *)(a))[0] == 0) && (((__const uint32_t *)(a))[1] == 0) && (((__const uint32_t *)(a))[2] == htonl(0xffff)))
+// It is already defined in IDF as:
+//#define IN6_IS_ADDR_V4MAPPED(a)     ip6_addr_isipv4mappedipv6((ip6_addr_t*)(a))
+//#define ip6_addr_isipv4mappedipv6(ip6addr) (((ip6addr)->addr[0] == 0) && ((ip6addr)->addr[1] == 0) && (((ip6addr)->addr[2]) == PP_HTONL(0x0000FFFFUL)))
+// Keeping as a memory of the change.
+//#define _IN6_IS_ADDR_V4MAPPED(a) ((((__const uint32_t *)(a))[0] == 0) && (((__const uint32_t *)(a))[1] == 0) && (((__const uint32_t *)(a))[2] == htonl(0xffff)))
 
 #define WIFI_CLIENT_DEF_CONN_TIMEOUT_MS (3000)
 #define WIFI_CLIENT_MAX_WRITE_RETRY     (10)

libraries/WiFi/src/WiFiGeneric.cpp

@@ -308,7 +308,7 @@ bool wifiLowLevelInit(bool persistent) {
 
     esp_err_t err = esp_wifi_init(&cfg);
     if (err) {
-      log_e("esp_wifi_init %d", err);
+      log_e("esp_wifi_init 0x%x: %s", err, esp_err_to_name(err));
       lowLevelInitDone = false;
       return lowLevelInitDone;
     }
@@ -375,7 +375,7 @@ static bool espWiFiStart() {
   esp_err_t err = esp_wifi_start();
   if (err != ESP_OK) {
     _esp_wifi_started = false;
-    log_e("esp_wifi_start %d", err);
+    log_e("esp_wifi_start 0x%x: %s", err, esp_err_to_name(err));
     return _esp_wifi_started;
   }
   return _esp_wifi_started;
@@ -389,7 +389,7 @@ static bool espWiFiStop() {
   _esp_wifi_started = false;
   err = esp_wifi_stop();
   if (err) {
-    log_e("Could not stop WiFi! %d", err);
+    log_e("Could not stop WiFi! 0x%x: %s", err, esp_err_to_name(err));
     _esp_wifi_started = true;
     return false;
   }
@@ -478,7 +478,7 @@ int WiFiGenericClass::setChannel(uint8_t primary, wifi_second_chan_t secondary)
 
   ret = esp_wifi_get_country(&country);
   if (ret != ESP_OK) {
-    log_e("Failed to get country info");
+    log_e("Failed to get country info 0x%x: %s", ret, esp_err_to_name(ret));
     return ret;
   }
 
@@ -492,7 +492,7 @@ int WiFiGenericClass::setChannel(uint8_t primary, wifi_second_chan_t secondary)
 
   ret = esp_wifi_set_channel(primary, secondary);
   if (ret != ESP_OK) {
-    log_e("Failed to set channel");
+    log_e("Failed to set channel 0x%x: %s", ret, esp_err_to_name(ret));
     return ret;
   }
 
@@ -562,13 +562,13 @@ bool WiFiGenericClass::mode(wifi_mode_t m) {
   if (((m & WIFI_MODE_STA) != 0) && ((cm & WIFI_MODE_STA) == 0)) {
     err = esp_netif_set_hostname(esp_netifs[ESP_IF_WIFI_STA], NetworkManager::getHostname());
     if (err) {
-      log_e("Could not set hostname! %d", err);
+      log_e("Could not set hostname! 0x%x: %s", err, esp_err_to_name(err));
       return false;
     }
   }
   err = esp_wifi_set_mode(m);
   if (err) {
-    log_e("Could not set mode! %d", err);
+    log_e("Could not set mode! 0x%x: %s", err, esp_err_to_name(err));
     return false;
   }
 
@@ -585,17 +585,44 @@ bool WiFiGenericClass::mode(wifi_mode_t m) {
     if (m & WIFI_MODE_STA) {
       err = esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_LR);
       if (err != ESP_OK) {
-        log_e("Could not enable long range on STA! %d", err);
+        log_e("Could not enable long range on STA! 0x%x: %s", err, esp_err_to_name(err));
         return false;
       }
     }
     if (m & WIFI_MODE_AP) {
       err = esp_wifi_set_protocol(WIFI_IF_AP, WIFI_PROTOCOL_LR);
       if (err != ESP_OK) {
-        log_e("Could not enable long range on AP! %d", err);
+        log_e("Could not enable long range on AP! 0x%x: %s", err, esp_err_to_name(err));
         return false;
       }
     }
+  } else {
+#if CONFIG_SOC_WIFI_HE_SUPPORT
+#define WIFI_PROTOCOL_DEFAULT (WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G | WIFI_PROTOCOL_11N | WIFI_PROTOCOL_11AX)
+#else
+#define WIFI_PROTOCOL_DEFAULT (WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G | WIFI_PROTOCOL_11N)
+#endif
+    uint8_t current_protocol = 0;
+    if (m & WIFI_MODE_STA) {
+      err = esp_wifi_get_protocol(WIFI_IF_STA, &current_protocol);
+      if (err == ESP_OK && current_protocol == WIFI_PROTOCOL_LR) {
+        log_v("Disabling long range on STA");
+        err = esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_DEFAULT);
+        if (err != ESP_OK) {
+          log_e("Could not disable long range on STA! 0x%x: %s", err, esp_err_to_name(err));
+        }
+      }
+    }
+    if (m & WIFI_MODE_AP) {
+      err = esp_wifi_get_protocol(WIFI_IF_AP, &current_protocol);
+      if (err == ESP_OK && current_protocol == WIFI_PROTOCOL_LR) {
+        log_v("Disabling long range on AP");
+        err = esp_wifi_set_protocol(WIFI_IF_AP, WIFI_PROTOCOL_DEFAULT);
+        if (err != ESP_OK) {
+          log_e("Could not disable long range on AP! 0x%x: %s", err, esp_err_to_name(err));
+        }
+      }
+    }
   }
   if (!espWiFiStart()) {
     return false;
@@ -683,8 +710,9 @@ bool WiFiGenericClass::setSleep(wifi_ps_type_t sleepType) {
   if (sleepType != _sleepEnabled) {
     _sleepEnabled = sleepType;
     if (WiFi.STA.started()) {
-      if (esp_wifi_set_ps(_sleepEnabled) != ESP_OK) {
-        log_e("esp_wifi_set_ps failed!");
+      esp_err_t err = esp_wifi_set_ps(_sleepEnabled);
+      if (err != ESP_OK) {
+        log_e("esp_wifi_set_ps failed!: 0x%x: %s", err, esp_err_to_name(err));
         return false;
       }
     }
@@ -748,8 +776,9 @@ bool WiFiGenericClass::initiateFTM(uint8_t frm_count, uint16_t burst_period, uin
     memcpy(ftmi_cfg.resp_mac, mac, 6);
   }
   // Request FTM session with the Responder
-  if (ESP_OK != esp_wifi_ftm_initiate_session(&ftmi_cfg)) {
-    log_e("Failed to initiate FTM session");
+  esp_err_t err = esp_wifi_ftm_initiate_session(&ftmi_cfg);
+  if (ESP_OK != err) {
+    log_e("Failed to initiate FTM session: 0x%x: %s", err, esp_err_to_name(err));
     return false;
   }
   return true;
@@ -768,8 +797,9 @@ bool WiFiGenericClass::setDualAntennaConfig(uint8_t gpio_ant1, uint8_t gpio_ant2
 
   esp_phy_ant_gpio_config_t wifi_ant_io;
 
-  if (ESP_OK != esp_phy_get_ant_gpio(&wifi_ant_io)) {
-    log_e("Failed to get antenna configuration");
+  esp_err_t err = esp_phy_get_ant_gpio(&wifi_ant_io);
+  if (ESP_OK != err) {
+    log_e("Failed to get antenna configuration: 0x%x: %s", err, esp_err_to_name(err));
     return false;
   }
 
@@ -778,8 +808,9 @@ bool WiFiGenericClass::setDualAntennaConfig(uint8_t gpio_ant1, uint8_t gpio_ant2
   wifi_ant_io.gpio_cfg[1].gpio_num = gpio_ant2;
   wifi_ant_io.gpio_cfg[1].gpio_select = 1;
 
-  if (ESP_OK != esp_phy_set_ant_gpio(&wifi_ant_io)) {
-    log_e("Failed to set antenna GPIO configuration");
+  err = esp_phy_set_ant_gpio(&wifi_ant_io);
+  if (ESP_OK != err) {
+    log_e("Failed to set antenna GPIO configuration: 0x%x: %s", err, esp_err_to_name(err));
     return false;
   }
 
@@ -827,8 +858,9 @@ bool WiFiGenericClass::setDualAntennaConfig(uint8_t gpio_ant1, uint8_t gpio_ant2
   }
 
 set_ant:
-  if (ESP_OK != esp_phy_set_ant(&ant_config)) {
-    log_e("Failed to set antenna configuration");
+  err = esp_phy_set_ant(&ant_config);
+  if (ESP_OK != err) {
+    log_e("Failed to set antenna configuration: 0x%x: %s", err, esp_err_to_name(err));
     return false;
   }
 #endif

libraries/Zigbee/examples/Zigbee_Temp_Hum_Sensor_Sleepy/Zigbee_Temp_Hum_Sensor_Sleepy.ino

@@ -125,8 +125,8 @@ void loop() {
     int startTime = millis();
     while (digitalRead(button) == LOW) {
       delay(50);
-      if ((millis() - startTime) > 3000) {
-        // If key pressed for more than 3secs, factory reset Zigbee and reboot
+      if ((millis() - startTime) > 10000) {
+        // 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();