Update IDF to 1c3dd23

* Update mDNS and LEDC * update toolchain * Update IDF to 1c3dd23 * Advertise the board variant for Arduino OTA * Add generic variant definition for mDNS

Author: me-no-dev

cores/esp32/esp32-hal-bt.c

@@ -17,7 +17,7 @@
 #if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BLUEDROID_ENABLED)
 
 
-#include"bt.h"
+#include"esp_bt.h"
 #include"esp_bt_defs.h"
 #include"esp_bt_main.h"
 

cores/esp32/esp32-hal-ledc.c

@@ -68,8 +68,8 @@ static void _ledcSetupTimer(uint8_t chan, uint32_t div_num, uint8_t bit_num, boo
 #endif
  }
 LEDC_MUTEX_LOCK();
-LEDC_TIMER(group, timer).conf.div_num=div_num;//18 bit (10.8) This register is used to configure parameter for divider in timer the least significant eight bits represent the decimal part.
-LEDC_TIMER(group, timer).conf.bit_num=bit_num;//5 bit This register controls the range of the counter in timer. the counter range is [0 2**bit_num] the max bit width for counter is 20.
+LEDC_TIMER(group, timer).conf.clock_divider=div_num;//18 bit (10.8) This register is used to configure parameter for divider in timer the least significant eight bits represent the decimal part.
+LEDC_TIMER(group, timer).conf.duty_resolution=bit_num;//5 bit This register controls the range of the counter in timer. the counter range is [0 2**bit_num] the max bit width for counter is 20.
 LEDC_TIMER(group, timer).conf.tick_sel=apb_clk;//apb clock
 if(group){
 LEDC_TIMER(group, timer).conf.low_speed_update=1;//This bit is only useful for low speed timer channels, reserved for high speed timers
@@ -111,8 +111,8 @@ static double _ledcTimerRead(uint8_t chan)
 boolapb_clk;
 uint8_tgroup=(chan/8), timer=((chan/2)%4);
 LEDC_MUTEX_LOCK();
-div_num=LEDC_TIMER(group, timer).conf.div_num;//18 bit (10.8) This register is used to configure parameter for divider in timer the least significant eight bits represent the decimal part.
-bit_num=LEDC_TIMER(group, timer).conf.bit_num;//5 bit This register controls the range of the counter in timer. the counter range is [0 2**bit_num] the max bit width for counter is 20.
+div_num=LEDC_TIMER(group, timer).conf.clock_divider;//18 bit (10.8) This register is used to configure parameter for divider in timer the least significant eight bits represent the decimal part.
+bit_num=LEDC_TIMER(group, timer).conf.duty_resolution;//5 bit This register controls the range of the counter in timer. the counter range is [0 2**bit_num] the max bit width for counter is 20.
 apb_clk=LEDC_TIMER(group, timer).conf.tick_sel;//apb clock
 LEDC_MUTEX_UNLOCK();
 uint64_tclk_freq=1000000;

libraries/ESPmDNS/src/ESPmDNS.cpp

@@ -39,144 +39,210 @@ License (MIT license):
 #endif
 
 #include"ESPmDNS.h"
+#include"WiFi.h"
 #include<functional>
 #include"esp_wifi.h"
 
-MDNSResponder::MDNSResponder() : mdns(NULL), _if(TCPIP_ADAPTER_IF_STA){}
+staticvoid_on_sys_event(system_event_t *event){
+mdns_handle_system_event(NULL, event);
+}
+
+MDNSResponder::MDNSResponder() :results(NULL){}
 MDNSResponder::~MDNSResponder(){
 end();
 }
 
-boolMDNSResponder::begin(constchar* hostName, tcpip_adapter_if_t tcpip_if, uint32_t ttl){
- _if = tcpip_if;
-if(!mdns && mdns_init(_if, &mdns)){
+boolMDNSResponder::begin(constchar* hostName){
+if(mdns_init()){
 log_e("Failed starting MDNS");
 returnfalse;
  }
+ WiFi.onEvent(_on_sys_event);
  _hostname = hostName;
-if(mdns_set_hostname(mdns, hostName)){
+if(mdns_hostname_set(hostName)){
 log_e("Failed setting MDNS hostname");
 returnfalse;
  }
 returntrue;
 }
 
 voidMDNSResponder::end(){
-if(!mdns){
-return;
- }
-mdns_free(mdns);
- mdns = NULL;
+mdns_free();
 }
 
 voidMDNSResponder::setInstanceName(String name){
 if (name.length() > 63) return;
-if(mdns_set_instance(mdns, name.c_str())){
+if(mdns_instance_name_set(name.c_str())){
 log_e("Failed setting MDNS instance");
 return;
  }
 }
 
+
 voidMDNSResponder::enableArduino(uint16_t port, bool auth){
-constchar * arduTxtData[4] ={
-"board=" ARDUINO_BOARD,
-"tcp_check=no",
-"ssh_upload=no",
-"auth_upload=no"
+mdns_txt_item_t arduTxtData[4] ={
+{(char*)"board" ,(char*)ARDUINO_VARIANT},
+{(char*)"tcp_check" ,(char*)"no"},
+{(char*)"ssh_upload",(char*)"no"},
+{(char*)"auth_upload",(char*)"no"}
  };
-if(auth){
- arduTxtData[3] = "auth_upload=yes";
- }
 
-if(mdns_service_add(mdns, "_arduino", "_tcp", port)){
+if(mdns_service_add(NULL, "_arduino", "_tcp", port, arduTxtData, 4)){
 log_e("Failed adding Arduino service");
- } elseif(mdns_service_txt_set(mdns, "_arduino", "_tcp", 4, arduTxtData)){
-log_e("Failed setting Arduino service TXT");
+ }
+
+if(auth && mdns_service_txt_item_set("_arduino", "_tcp", "auth_upload", "yes")){
+log_e("Failed setting Arduino txt item");
  }
 }
 
 voidMDNSResponder::disableArduino(){
-if(mdns_service_remove(mdns, "_arduino", "_tcp")){
+if(mdns_service_remove("_arduino", "_tcp")){
 log_w("Failed removing Arduino service");
  }
 }
 
-voidMDNSResponder::enableWorkstation(){
+voidMDNSResponder::enableWorkstation(wifi_interface_t interface){
 char winstance[21+_hostname.length()];
 uint8_t mac[6];
-esp_wifi_get_mac((wifi_interface_t)_if, mac);
+esp_wifi_get_mac(interface, mac);
 sprintf(winstance, "%s [%02x:%02x:%02x:%02x:%02x:%02x]", _hostname.c_str(), mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
 
-if(mdns_service_add(mdns, "_workstation", "_tcp", 9)){
+if(mdns_service_add(NULL, "_workstation", "_tcp", 9, NULL, 0)){
 log_e("Failed adding Workstation service");
- } elseif(mdns_service_instance_set(mdns, "_workstation", "_tcp", winstance)){
+ } elseif(mdns_service_instance_name_set("_workstation", "_tcp", winstance)){
 log_e("Failed setting Workstation service instance name");
  }
 }
 
 voidMDNSResponder::disableWorkstation(){
-if(mdns_service_remove(mdns, "_workstation", "_tcp")){
+if(mdns_service_remove("_workstation", "_tcp")){
 log_w("Failed removing Workstation service");
  }
 }
 
 voidMDNSResponder::addService(char *name, char *proto, uint16_t port){
-if(mdns_service_add(mdns, name, proto, port)){
+if(mdns_service_add(NULL, name, proto, port, NULL, 0)){
 log_e("Failed adding service %s.%s.\n", name, proto);
  }
 }
 
 boolMDNSResponder::addServiceTxt(char *name, char *proto, char *key, char *value){
-//ToDo: implement it in IDF. This will set the TXT to one record currently
- String txt = String(key) + "=" + String(value);
-constchar * txt_chr[1] ={txt.c_str()};
-if(mdns_service_txt_set(mdns, name, proto, 1, txt_chr)){
+if(mdns_service_txt_item_set(name, proto, key, value)){
 log_e("Failed setting service TXT");
 returnfalse;
  }
 returntrue;
 }
 
-intMDNSResponder::queryService(char *service, char *proto){
-mdns_result_free(mdns);
-if(proto){
-char srv[strlen(service)+2];
-char prt[strlen(proto)+2];
-sprintf(srv, "_%s", service);
-sprintf(prt, "_%s", proto);
-returnmdns_query(mdns, srv, prt, 2000);
+IPAddress MDNSResponder::queryHost(char *host, uint32_t timeout){
+structip4_addr addr;
+ addr.addr = 0;
+
+esp_err_t err = mdns_query_a(host, timeout, &addr);
+if(err){
+if(err == ESP_ERR_NOT_FOUND){
+log_w("Host was not found!");
+returnIPAddress();
+ }
+log_e("Query Failed");
+returnIPAddress();
  }
-returnmdns_query(mdns, service, NULL, 2000);
+returnIPAddress(addr.addr);
 }
 
-IPAddress MDNSResponder::queryHost(char *host){
-mdns_result_free(mdns);
-if(!mdns_query(mdns, host, NULL, 2000)){
-returnIPAddress();
+
+intMDNSResponder::queryService(char *service, char *proto){
+if(!service || !service[0] || !proto || !proto[0]){
+log_e("Bad Parameters");
+return0;
+ }
+
+if(results){
+mdns_query_results_free(results);
+ results = NULL;
  }
-returnIP(0);
+
+char srv[strlen(service)+2];
+char prt[strlen(proto)+2];
+sprintf(srv, "_%s", service);
+sprintf(prt, "_%s", proto);
+
+esp_err_t err = mdns_query_ptr(srv, prt, 3000, 20, &results);
+if(err){
+log_e("Query Failed");
+return0;
+ }
+if(!results){
+log_w("No results found!");
+return0;
+ }
+
+mdns_result_t * r = results;
+int i = 0;
+while(r){
+ i++;
+ r = r->next;
+ }
+return i;
+}
+
+mdns_result_t * MDNSResponder::_getResult(int idx){
+mdns_result_t * result = results;
+int i = 0;
+while(result){
+if(i == idx){
+break;
+ }
+ i++;
+ result = result->next;
+ }
+return result;
 }
 
 String MDNSResponder::hostname(int idx){
-constmdns_result_t * result = mdns_result_get(mdns, idx);
+mdns_result_t * result = _getResult(idx);
 if(!result){
 log_e("Result %d not found", idx);
 returnString();
  }
-returnString(result->host);
+returnString(result->hostname);
 }
 
 IPAddress MDNSResponder::IP(int idx){
-constmdns_result_t * result = mdns_result_get(mdns, idx);
+mdns_result_t * result = _getResult(idx);
 if(!result){
 log_e("Result %d not found", idx);
 returnIPAddress();
  }
-returnIPAddress(result->addr.addr);
+mdns_ip_addr_t * addr = result->addr;
+while(addr){
+if(addr->addr.type == MDNS_IP_PROTOCOL_V4){
+returnIPAddress(addr->addr.u_addr.ip4.addr);
+ }
+ addr = addr->next;
+ }
+returnIPAddress();
+}
+
+IPv6Address MDNSResponder::IPv6(int idx){
+mdns_result_t * result = _getResult(idx);
+if(!result){
+log_e("Result %d not found", idx);
+returnIPv6Address();
+ }
+mdns_ip_addr_t * addr = result->addr;
+while(addr){
+if(addr->addr.type == MDNS_IP_PROTOCOL_V6){
+returnIPv6Address(addr->addr.u_addr.ip6.addr);
+ }
+ addr = addr->next;
+ }
+returnIPv6Address();
 }
 
 uint16_tMDNSResponder::port(int idx){
-constmdns_result_t * result = mdns_result_get(mdns, idx);
+mdns_result_t * result = _getResult(idx);
 if(!result){
 log_e("Result %d not found", idx);
 return0;

libraries/ESPmDNS/src/ESPmDNS.h

@@ -42,18 +42,19 @@ License (MIT license):
 #defineESP32MDNS_H
 
 #include"Arduino.h"
+#include"IPv6Address.h"
 #include"mdns.h"
 
 //this should be defined at build time
-#ifndefARDUINO_BOARD
-#defineARDUINO_BOARD"esp32"
+#ifndefARDUINO_VARIANT
+#defineARDUINO_VARIANT"esp32"
 #endif
 
 classMDNSResponder{
 public:
 MDNSResponder();
 ~MDNSResponder();
-boolbegin(constchar* hostName, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_STA, uint32_t ttl=120);
+boolbegin(constchar* hostName);
 voidend();
 
 voidsetInstanceName(String name);
@@ -83,15 +84,15 @@ class MDNSResponder{
 voidenableArduino(uint16_t port=3232, bool auth=false);
 voiddisableArduino();
 
-voidenableWorkstation();
+voidenableWorkstation(wifi_interface_t interface=ESP_IF_WIFI_STA);
 voiddisableWorkstation();
 
- IPAddress queryHost(char *host);
- IPAddress queryHost(constchar *host){
-returnqueryHost((char *)host);
+ IPAddress queryHost(char *host, uint32_t timeout=2000);
+ IPAddress queryHost(constchar *host, uint32_t timeout=2000){
+returnqueryHost((char *)host, timeout);
  }
- IPAddress queryHost(String host){
-returnqueryHost(host.c_str());
+ IPAddress queryHost(String host, uint32_t timeout=2000){
+returnqueryHost(host.c_str(), timeout);
  }
 
 intqueryService(char *service, char *proto);
@@ -104,12 +105,13 @@ class MDNSResponder{
 
  String hostname(int idx);
  IPAddress IP(int idx);
+ IPv6Address IPv6(int idx);
 uint16_tport(int idx);
 
 private:
-mdns_server_t * mdns;
-tcpip_adapter_if_t _if;
  String _hostname;
+mdns_result_t * results;
+mdns_result_t * _getResult(int idx);
 };
 
 extern MDNSResponder MDNS;

libraries/WiFi/src/ETH.cpp

@@ -30,7 +30,6 @@ extern void tcpipInit();
 staticint _eth_phy_mdc_pin = -1;
 staticint _eth_phy_mdio_pin = -1;
 staticint _eth_phy_power_pin = -1;
-staticeth_clock_mode_t _eth_clk_mode = ETH_CLOCK_GPIO0_IN;
 static eth_phy_power_enable_func _eth_phy_power_enable_orig = NULL;
 
 staticvoid_eth_phy_config_gpio(void)