diff --git a/cores/esp32/esp32-hal-gpio.c b/cores/esp32/esp32-hal-gpio.c index 981593d3d7e83d7dd320f4bfd09bf7a8fadfe53e..78163463bd2e4fe985163bfa4c8f28c5c0300b89 100644 --- a/cores/esp32/esp32-hal-gpio.c +++ b/cores/esp32/esp32-hal-gpio.c @@ -190,7 +190,7 @@ extern void IRAM_ATTR __pinMode(uint8_t pin, uint8_t mode) } //RTC pins PULL settings - if(rtc_reg) { + if(esp32_gpioMux[pin].rtc != -1) { ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_io_desc[pin].mux); if(mode & PULLUP) { ESP_REG(rtc_reg) = (ESP_REG(rtc_reg) | rtc_io_desc[pin].pullup) & ~(rtc_io_desc[pin].pulldown); diff --git a/libraries/WiFi/examples/ETH_LAN8720/ETH_LAN8720.ino b/libraries/WiFi/examples/ETH_LAN8720/ETH_LAN8720.ino index 44bd1f965a037109f98cbf8828eb831fa2e1af10..a3651d9ef98b60de35dc9531145771abdc56f019 100644 --- a/libraries/WiFi/examples/ETH_LAN8720/ETH_LAN8720.ino +++ b/libraries/WiFi/examples/ETH_LAN8720/ETH_LAN8720.ino @@ -10,15 +10,15 @@ static bool eth_connected = false; void WiFiEvent(WiFiEvent_t event) { switch (event) { - case SYSTEM_EVENT_ETH_START: + case ARDUINO_EVENT_ETH_START: Serial.println("ETH Started"); //set eth hostname here ETH.setHostname("esp32-ethernet"); break; - case SYSTEM_EVENT_ETH_CONNECTED: + case ARDUINO_EVENT_ETH_CONNECTED: Serial.println("ETH Connected"); break; - case SYSTEM_EVENT_ETH_GOT_IP: + case ARDUINO_EVENT_ETH_GOT_IP: Serial.print("ETH MAC: "); Serial.print(ETH.macAddress()); Serial.print(", IPv4: "); @@ -31,11 +31,11 @@ void WiFiEvent(WiFiEvent_t event) Serial.println("Mbps"); eth_connected = true; break; - case SYSTEM_EVENT_ETH_DISCONNECTED: + case ARDUINO_EVENT_ETH_DISCONNECTED: Serial.println("ETH Disconnected"); eth_connected = false; break; - case SYSTEM_EVENT_ETH_STOP: + case ARDUINO_EVENT_ETH_STOP: Serial.println("ETH Stopped"); eth_connected = false; break; diff --git a/libraries/WiFi/examples/ETH_TLK110/ETH_TLK110.ino b/libraries/WiFi/examples/ETH_TLK110/ETH_TLK110.ino index f2c127945ade87efac26b26b54966f4bd43fe9a7..c144b6eeb00ae9f59ff191b1e2ab12857356d00e 100644 --- a/libraries/WiFi/examples/ETH_TLK110/ETH_TLK110.ino +++ b/libraries/WiFi/examples/ETH_TLK110/ETH_TLK110.ino @@ -16,15 +16,15 @@ static bool eth_connected = false; void WiFiEvent(WiFiEvent_t event) { switch (event) { - case SYSTEM_EVENT_ETH_START: + case ARDUINO_EVENT_ETH_START: Serial.println("ETH Started"); //set eth hostname here ETH.setHostname("esp32-ethernet"); break; - case SYSTEM_EVENT_ETH_CONNECTED: + case ARDUINO_EVENT_ETH_CONNECTED: Serial.println("ETH Connected"); break; - case SYSTEM_EVENT_ETH_GOT_IP: + case ARDUINO_EVENT_ETH_GOT_IP: Serial.print("ETH MAC: "); Serial.print(ETH.macAddress()); Serial.print(", IPv4: "); @@ -37,11 +37,11 @@ void WiFiEvent(WiFiEvent_t event) Serial.println("Mbps"); eth_connected = true; break; - case SYSTEM_EVENT_ETH_DISCONNECTED: + case ARDUINO_EVENT_ETH_DISCONNECTED: Serial.println("ETH Disconnected"); eth_connected = false; break; - case SYSTEM_EVENT_ETH_STOP: + case ARDUINO_EVENT_ETH_STOP: Serial.println("ETH Stopped"); eth_connected = false; break; diff --git a/libraries/WiFi/examples/WPS/WPS.ino b/libraries/WiFi/examples/WPS/WPS.ino index f0675df4217ba8115fefb1d3cbd4ba7e80b3d8a0..84c461aeb001b888d7a62f951c02e803625216ed 100644 --- a/libraries/WiFi/examples/WPS/WPS.ino +++ b/libraries/WiFi/examples/WPS/WPS.ino @@ -47,39 +47,39 @@ String wpspin2string(uint8_t a[]){ return (String)wps_pin; } -void WiFiEvent(WiFiEvent_t event, system_event_info_t info){ +void WiFiEvent(WiFiEvent_t event, arduino_event_info_t info){ switch(event){ - case SYSTEM_EVENT_STA_START: + case ARDUINO_EVENT_WIFI_STA_START: Serial.println("Station Mode Started"); break; - case SYSTEM_EVENT_STA_GOT_IP: + case ARDUINO_EVENT_WIFI_STA_GOT_IP: Serial.println("Connected to :" + String(WiFi.SSID())); Serial.print("Got IP: "); Serial.println(WiFi.localIP()); break; - case SYSTEM_EVENT_STA_DISCONNECTED: + case ARDUINO_EVENT_WIFI_STA_DISCONNECTED: Serial.println("Disconnected from station, attempting reconnection"); WiFi.reconnect(); break; - case SYSTEM_EVENT_STA_WPS_ER_SUCCESS: - Serial.println("WPS Successful, stopping WPS and connecting to: " + String(WiFi.SSID())); + case ARDUINO_EVENT_WPS_ER_SUCCESS: + Serial.println("WPS Successfull, stopping WPS and connecting to: " + String(WiFi.SSID())); esp_wifi_wps_disable(); delay(10); WiFi.begin(); break; - case SYSTEM_EVENT_STA_WPS_ER_FAILED: + case ARDUINO_EVENT_WPS_ER_FAILED: Serial.println("WPS Failed, retrying"); esp_wifi_wps_disable(); esp_wifi_wps_enable(&config); esp_wifi_wps_start(0); break; - case SYSTEM_EVENT_STA_WPS_ER_TIMEOUT: - Serial.println("WPS Timeout, retrying"); + case ARDUINO_EVENT_WPS_ER_TIMEOUT: + Serial.println("WPS Timedout, retrying"); esp_wifi_wps_disable(); esp_wifi_wps_enable(&config); esp_wifi_wps_start(0); break; - case SYSTEM_EVENT_STA_WPS_ER_PIN: + case ARDUINO_EVENT_WPS_ER_PIN: Serial.println("WPS_PIN = " + wpspin2string(info.sta_er_pin.pin_code)); break; default: diff --git a/libraries/WiFi/examples/WiFiBlueToothSwitch/WiFiBlueToothSwitch.ino b/libraries/WiFi/examples/WiFiBlueToothSwitch/WiFiBlueToothSwitch.ino index e795bad83d670110aaadbdebe8b4bb531ec3b6fd..2019c8982d9c747c604890e9ae09152c3f4bc6a4 100644 --- a/libraries/WiFi/examples/WiFiBlueToothSwitch/WiFiBlueToothSwitch.ino +++ b/libraries/WiFi/examples/WiFiBlueToothSwitch/WiFiBlueToothSwitch.ino @@ -75,33 +75,33 @@ void onButton(){ void WiFiEvent(WiFiEvent_t event){ switch(event) { - case SYSTEM_EVENT_AP_START: + case ARDUINO_EVENT_WIFI_AP_START: Serial.println("AP Started"); WiFi.softAPsetHostname(AP_SSID); break; - case SYSTEM_EVENT_AP_STOP: + case ARDUINO_EVENT_WIFI_AP_STOP: Serial.println("AP Stopped"); break; - case SYSTEM_EVENT_STA_START: + case ARDUINO_EVENT_WIFI_STA_START: Serial.println("STA Started"); WiFi.setHostname(AP_SSID); break; - case SYSTEM_EVENT_STA_CONNECTED: + case ARDUINO_EVENT_WIFI_STA_CONNECTED: Serial.println("STA Connected"); WiFi.enableIpV6(); break; - case SYSTEM_EVENT_AP_STA_GOT_IP6: + case ARDUINO_EVENT_WIFI_AP_STA_GOT_IP6: Serial.print("STA IPv6: "); Serial.println(WiFi.localIPv6()); break; - case SYSTEM_EVENT_STA_GOT_IP: + case ARDUINO_EVENT_WIFI_STA_GOT_IP: Serial.print("STA IPv4: "); Serial.println(WiFi.localIP()); break; - case SYSTEM_EVENT_STA_DISCONNECTED: + case ARDUINO_EVENT_WIFI_STA_DISCONNECTED: Serial.println("STA Disconnected"); break; - case SYSTEM_EVENT_STA_STOP: + case ARDUINO_EVENT_WIFI_STA_STOP: Serial.println("STA Stopped"); break; default: diff --git a/libraries/WiFi/examples/WiFiClientEvents/WiFiClientEvents.ino b/libraries/WiFi/examples/WiFiClientEvents/WiFiClientEvents.ino index a7b029481e518fbed060200b5fbdce2a8674f3d1..08b4cb9ed6def37d3626c53dc92d6463c0915042 100644 --- a/libraries/WiFi/examples/WiFiClientEvents/WiFiClientEvents.ino +++ b/libraries/WiFi/examples/WiFiClientEvents/WiFiClientEvents.ino @@ -6,32 +6,34 @@ /* * WiFi Events -0 SYSTEM_EVENT_WIFI_READY < ESP32 WiFi ready -1 SYSTEM_EVENT_SCAN_DONE < ESP32 finish scanning AP -2 SYSTEM_EVENT_STA_START < ESP32 station start -3 SYSTEM_EVENT_STA_STOP < ESP32 station stop -4 SYSTEM_EVENT_STA_CONNECTED < ESP32 station connected to AP -5 SYSTEM_EVENT_STA_DISCONNECTED < ESP32 station disconnected from AP -6 SYSTEM_EVENT_STA_AUTHMODE_CHANGE < the auth mode of AP connected by ESP32 station changed -7 SYSTEM_EVENT_STA_GOT_IP < ESP32 station got IP from connected AP -8 SYSTEM_EVENT_STA_LOST_IP < ESP32 station lost IP and the IP is reset to 0 -9 SYSTEM_EVENT_STA_WPS_ER_SUCCESS < ESP32 station wps succeeds in enrollee mode -10 SYSTEM_EVENT_STA_WPS_ER_FAILED < ESP32 station wps fails in enrollee mode -11 SYSTEM_EVENT_STA_WPS_ER_TIMEOUT < ESP32 station wps timeout in enrollee mode -12 SYSTEM_EVENT_STA_WPS_ER_PIN < ESP32 station wps pin code in enrollee mode -13 SYSTEM_EVENT_AP_START < ESP32 soft-AP start -14 SYSTEM_EVENT_AP_STOP < ESP32 soft-AP stop -15 SYSTEM_EVENT_AP_STACONNECTED < a station connected to ESP32 soft-AP -16 SYSTEM_EVENT_AP_STADISCONNECTED < a station disconnected from ESP32 soft-AP -17 SYSTEM_EVENT_AP_STAIPASSIGNED < ESP32 soft-AP assign an IP to a connected station -18 SYSTEM_EVENT_AP_PROBEREQRECVED < Receive probe request packet in soft-AP interface -19 SYSTEM_EVENT_GOT_IP6 < ESP32 station or ap or ethernet interface v6IP addr is preferred -20 SYSTEM_EVENT_ETH_START < ESP32 ethernet start -21 SYSTEM_EVENT_ETH_STOP < ESP32 ethernet stop -22 SYSTEM_EVENT_ETH_CONNECTED < ESP32 ethernet phy link up -23 SYSTEM_EVENT_ETH_DISCONNECTED < ESP32 ethernet phy link down -24 SYSTEM_EVENT_ETH_GOT_IP < ESP32 ethernet got IP from connected AP -25 SYSTEM_EVENT_MAX +0 ARDUINO_EVENT_WIFI_READY < ESP32 WiFi ready +1 ARDUINO_EVENT_WIFI_SCAN_DONE < ESP32 finish scanning AP +2 ARDUINO_EVENT_WIFI_STA_START < ESP32 station start +3 ARDUINO_EVENT_WIFI_STA_STOP < ESP32 station stop +4 ARDUINO_EVENT_WIFI_STA_CONNECTED < ESP32 station connected to AP +5 ARDUINO_EVENT_WIFI_STA_DISCONNECTED < ESP32 station disconnected from AP +6 ARDUINO_EVENT_WIFI_STA_AUTHMODE_CHANGE < the auth mode of AP connected by ESP32 station changed +7 ARDUINO_EVENT_WIFI_STA_GOT_IP < ESP32 station got IP from connected AP +8 ARDUINO_EVENT_WIFI_STA_LOST_IP < ESP32 station lost IP and the IP is reset to 0 +9 ARDUINO_EVENT_WPS_ER_SUCCESS < ESP32 station wps succeeds in enrollee mode +10 ARDUINO_EVENT_WPS_ER_FAILED < ESP32 station wps fails in enrollee mode +11 ARDUINO_EVENT_WPS_ER_TIMEOUT < ESP32 station wps timeout in enrollee mode +12 ARDUINO_EVENT_WPS_ER_PIN < ESP32 station wps pin code in enrollee mode +13 ARDUINO_EVENT_WIFI_AP_START < ESP32 soft-AP start +14 ARDUINO_EVENT_WIFI_AP_STOP < ESP32 soft-AP stop +15 ARDUINO_EVENT_WIFI_AP_STACONNECTED < a station connected to ESP32 soft-AP +16 ARDUINO_EVENT_WIFI_AP_STADISCONNECTED < a station disconnected from ESP32 soft-AP +17 ARDUINO_EVENT_WIFI_AP_STAIPASSIGNED < ESP32 soft-AP assign an IP to a connected station +18 ARDUINO_EVENT_WIFI_AP_PROBEREQRECVED < Receive probe request packet in soft-AP interface +19 ARDUINO_EVENT_WIFI_AP_GOT_IP6 < ESP32 ap interface v6IP addr is preferred +19 ARDUINO_EVENT_WIFI_STA_GOT_IP6 < ESP32 station interface v6IP addr is preferred +20 ARDUINO_EVENT_ETH_START < ESP32 ethernet start +21 ARDUINO_EVENT_ETH_STOP < ESP32 ethernet stop +22 ARDUINO_EVENT_ETH_CONNECTED < ESP32 ethernet phy link up +23 ARDUINO_EVENT_ETH_DISCONNECTED < ESP32 ethernet phy link down +24 ARDUINO_EVENT_ETH_GOT_IP < ESP32 ethernet got IP from connected AP +19 ARDUINO_EVENT_ETH_GOT_IP6 < ESP32 ethernet interface v6IP addr is preferred +25 ARDUINO_EVENT_MAX */ #include @@ -45,80 +47,86 @@ void WiFiEvent(WiFiEvent_t event) Serial.printf("[WiFi-event] event: %d\n", event); switch (event) { - case SYSTEM_EVENT_WIFI_READY: + case ARDUINO_EVENT_WIFI_READY: Serial.println("WiFi interface ready"); break; - case SYSTEM_EVENT_SCAN_DONE: + case ARDUINO_EVENT_WIFI_SCAN_DONE: Serial.println("Completed scan for access points"); break; - case SYSTEM_EVENT_STA_START: + case ARDUINO_EVENT_WIFI_STA_START: Serial.println("WiFi client started"); break; - case SYSTEM_EVENT_STA_STOP: + case ARDUINO_EVENT_WIFI_STA_STOP: Serial.println("WiFi clients stopped"); break; - case SYSTEM_EVENT_STA_CONNECTED: + case ARDUINO_EVENT_WIFI_STA_CONNECTED: Serial.println("Connected to access point"); break; - case SYSTEM_EVENT_STA_DISCONNECTED: + case ARDUINO_EVENT_WIFI_STA_DISCONNECTED: Serial.println("Disconnected from WiFi access point"); break; - case SYSTEM_EVENT_STA_AUTHMODE_CHANGE: + case ARDUINO_EVENT_WIFI_STA_AUTHMODE_CHANGE: Serial.println("Authentication mode of access point has changed"); break; - case SYSTEM_EVENT_STA_GOT_IP: + case ARDUINO_EVENT_WIFI_STA_GOT_IP: Serial.print("Obtained IP address: "); Serial.println(WiFi.localIP()); break; - case SYSTEM_EVENT_STA_LOST_IP: + case ARDUINO_EVENT_WIFI_STA_LOST_IP: Serial.println("Lost IP address and IP address is reset to 0"); break; - case SYSTEM_EVENT_STA_WPS_ER_SUCCESS: + case ARDUINO_EVENT_WPS_ER_SUCCESS: Serial.println("WiFi Protected Setup (WPS): succeeded in enrollee mode"); break; - case SYSTEM_EVENT_STA_WPS_ER_FAILED: + case ARDUINO_EVENT_WPS_ER_FAILED: Serial.println("WiFi Protected Setup (WPS): failed in enrollee mode"); break; - case SYSTEM_EVENT_STA_WPS_ER_TIMEOUT: + case ARDUINO_EVENT_WPS_ER_TIMEOUT: Serial.println("WiFi Protected Setup (WPS): timeout in enrollee mode"); break; - case SYSTEM_EVENT_STA_WPS_ER_PIN: + case ARDUINO_EVENT_WPS_ER_PIN: Serial.println("WiFi Protected Setup (WPS): pin code in enrollee mode"); break; - case SYSTEM_EVENT_AP_START: + case ARDUINO_EVENT_WIFI_AP_START: Serial.println("WiFi access point started"); break; - case SYSTEM_EVENT_AP_STOP: + case ARDUINO_EVENT_WIFI_AP_STOP: Serial.println("WiFi access point stopped"); break; - case SYSTEM_EVENT_AP_STACONNECTED: + case ARDUINO_EVENT_WIFI_AP_STACONNECTED: Serial.println("Client connected"); break; - case SYSTEM_EVENT_AP_STADISCONNECTED: + case ARDUINO_EVENT_WIFI_AP_STADISCONNECTED: Serial.println("Client disconnected"); break; - case SYSTEM_EVENT_AP_STAIPASSIGNED: + case ARDUINO_EVENT_WIFI_AP_STAIPASSIGNED: Serial.println("Assigned IP address to client"); break; - case SYSTEM_EVENT_AP_PROBEREQRECVED: + case ARDUINO_EVENT_WIFI_AP_PROBEREQRECVED: Serial.println("Received probe request"); break; - case SYSTEM_EVENT_GOT_IP6: - Serial.println("IPv6 is preferred"); + case ARDUINO_EVENT_WIFI_AP_GOT_IP6: + Serial.println("AP IPv6 is preferred"); break; - case SYSTEM_EVENT_ETH_START: + case ARDUINO_EVENT_WIFI_STA_GOT_IP6: + Serial.println("STA IPv6 is preferred"); + break; + case ARDUINO_EVENT_ETH_GOT_IP6: + Serial.println("Ethernet IPv6 is preferred"); + break; + case ARDUINO_EVENT_ETH_START: Serial.println("Ethernet started"); break; - case SYSTEM_EVENT_ETH_STOP: + case ARDUINO_EVENT_ETH_STOP: Serial.println("Ethernet stopped"); break; - case SYSTEM_EVENT_ETH_CONNECTED: + case ARDUINO_EVENT_ETH_CONNECTED: Serial.println("Ethernet connected"); break; - case SYSTEM_EVENT_ETH_DISCONNECTED: + case ARDUINO_EVENT_ETH_DISCONNECTED: Serial.println("Ethernet disconnected"); break; - case SYSTEM_EVENT_ETH_GOT_IP: + case ARDUINO_EVENT_ETH_GOT_IP: Serial.println("Obtained IP address"); break; default: break; @@ -142,11 +150,11 @@ void setup() // Examples of different ways to register wifi events WiFi.onEvent(WiFiEvent); - WiFi.onEvent(WiFiGotIP, WiFiEvent_t::SYSTEM_EVENT_STA_GOT_IP); + WiFi.onEvent(WiFiGotIP, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_GOT_IP); WiFiEventId_t eventID = WiFi.onEvent([](WiFiEvent_t event, WiFiEventInfo_t info){ Serial.print("WiFi lost connection. Reason: "); Serial.println(info.disconnected.reason); - }, WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED); + }, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_DISCONNECTED); // Remove WiFi event Serial.print("WiFi Event ID: "); diff --git a/libraries/WiFi/examples/WiFiIPv6/WiFiIPv6.ino b/libraries/WiFi/examples/WiFiIPv6/WiFiIPv6.ino index 2d3b69789a4873d3cfa82c1b82a0ce471d231aa5..6be60fc258189ae33845bb12c4051616e7a02185 100644 --- a/libraries/WiFi/examples/WiFiIPv6/WiFiIPv6.ino +++ b/libraries/WiFi/examples/WiFiIPv6/WiFiIPv6.ino @@ -67,33 +67,34 @@ void wifiConnectedLoop(){ void WiFiEvent(WiFiEvent_t event){ switch(event) { - case SYSTEM_EVENT_AP_START: + case ARDUINO_EVENT_WIFI_AP_START: //can set ap hostname here WiFi.softAPsetHostname(AP_SSID); //enable ap ipv6 here WiFi.softAPenableIpV6(); break; - case SYSTEM_EVENT_STA_START: + case ARDUINO_EVENT_WIFI_STA_START: //set sta hostname here WiFi.setHostname(AP_SSID); break; - case SYSTEM_EVENT_STA_CONNECTED: + case ARDUINO_EVENT_WIFI_STA_CONNECTED: //enable sta ipv6 here WiFi.enableIpV6(); break; - case SYSTEM_EVENT_AP_STA_GOT_IP6: - //both interfaces get the same event + case ARDUINO_EVENT_WIFI_STA_GOT_IP6: Serial.print("STA IPv6: "); Serial.println(WiFi.localIPv6()); + break; + case ARDUINO_EVENT_WIFI_AP_GOT_IP6: Serial.print("AP IPv6: "); Serial.println(WiFi.softAPIPv6()); break; - case SYSTEM_EVENT_STA_GOT_IP: + case ARDUINO_EVENT_WIFI_STA_GOT_IP: wifiOnConnect(); wifi_connected = true; break; - case SYSTEM_EVENT_STA_DISCONNECTED: + case ARDUINO_EVENT_WIFI_STA_DISCONNECTED: wifi_connected = false; wifiOnDisconnect(); break; diff --git a/libraries/WiFi/examples/WiFiUDPClient/WiFiUDPClient.ino b/libraries/WiFi/examples/WiFiUDPClient/WiFiUDPClient.ino index 310989f0c1f2b27c57046f2bb2fb351c6d45bb83..6fd07caf44ee4cf6bb595db417b7f5f6d14ff008 100644 --- a/libraries/WiFi/examples/WiFiUDPClient/WiFiUDPClient.ino +++ b/libraries/WiFi/examples/WiFiUDPClient/WiFiUDPClient.ino @@ -58,7 +58,7 @@ void connectToWiFi(const char * ssid, const char * pwd){ //wifi event handler void WiFiEvent(WiFiEvent_t event){ switch(event) { - case SYSTEM_EVENT_STA_GOT_IP: + case ARDUINO_EVENT_WIFI_STA_GOT_IP: //When connected set Serial.print("WiFi connected! IP address: "); Serial.println(WiFi.localIP()); @@ -67,7 +67,7 @@ void WiFiEvent(WiFiEvent_t event){ udp.begin(WiFi.localIP(),udpPort); connected = true; break; - case SYSTEM_EVENT_STA_DISCONNECTED: + case ARDUINO_EVENT_WIFI_STA_DISCONNECTED: Serial.println("WiFi lost connection"); connected = false; break; diff --git a/libraries/WiFi/src/ETH.cpp b/libraries/WiFi/src/ETH.cpp index 79699698a9065aa135211e35ffbd5f27a1bfd86f..c7fea695471f00aa5229a0f7048ed39b44577e67 100644 --- a/libraries/WiFi/src/ETH.cpp +++ b/libraries/WiFi/src/ETH.cpp @@ -70,34 +70,6 @@ extern void tcpipInit(); -// Event handler for Ethernet -void ETHClass::eth_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data) -{ - system_event_t event; - switch (event_id) { - case ETHERNET_EVENT_CONNECTED: - event.event_id = SYSTEM_EVENT_ETH_CONNECTED; - ((ETHClass*)(arg))->eth_link = ETH_LINK_UP; - break; - case ETHERNET_EVENT_DISCONNECTED: - event.event_id = SYSTEM_EVENT_ETH_DISCONNECTED; - ((ETHClass*)(arg))->eth_link = ETH_LINK_DOWN; - break; - case ETHERNET_EVENT_START: - event.event_id = SYSTEM_EVENT_ETH_START; - ((ETHClass*)(arg))->started = true; - break; - case ETHERNET_EVENT_STOP: - event.event_id = SYSTEM_EVENT_ETH_STOP; - ((ETHClass*)(arg))->started = false; - break; - default: - break; - } - WiFi._eventCallback(arg, &event); -} - - #else static int _eth_phy_mdc_pin = -1; static int _eth_phy_mdio_pin = -1; @@ -144,9 +116,6 @@ bool ETHClass::begin(uint8_t phy_addr, int power, int mdc, int mdio, eth_phy_typ tcpipInit(); tcpip_adapter_set_default_eth_handlers(); - esp_event_handler_register(ETH_EVENT, ESP_EVENT_ANY_ID, eth_event_handler, this); - //ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_ETH_GOT_IP, &got_ip_event_handler, NULL)); - esp_eth_mac_t *eth_mac = NULL; #if CONFIG_ETH_SPI_ETHERNET_DM9051 if(type == ETH_PHY_DM9051){ diff --git a/libraries/WiFi/src/WiFiAP.cpp b/libraries/WiFi/src/WiFiAP.cpp index 71b00f6322d03aa22f57c097d9b42caddddf439d..3f3dde9a2ce8ef6e88da7fb07c1606c12c6b2901 100644 --- a/libraries/WiFi/src/WiFiAP.cpp +++ b/libraries/WiFi/src/WiFiAP.cpp @@ -46,6 +46,8 @@ extern "C" { // ---------------------------------------------------- Private functions ------------------------------------------------ // ----------------------------------------------------------------------------------------------------------------------- +esp_netif_t* get_esp_interface_netif(esp_interface_t interface); +esp_err_t set_esp_interface_ip(esp_interface_t interface, IPAddress local_ip=IPAddress(), IPAddress gateway=IPAddress(), IPAddress subnet=IPAddress()); static bool softap_config_equal(const wifi_config_t& lhs, const wifi_config_t& rhs); @@ -76,6 +78,25 @@ static bool softap_config_equal(const wifi_config_t& lhs, const wifi_config_t& r return true; } +void wifi_softap_config(wifi_config_t *wifi_config, const char * ssid=NULL, const char * password=NULL, uint8_t channel=6, wifi_auth_mode_t authmode=WIFI_AUTH_WPA_WPA2_PSK, uint8_t ssid_hidden=0, uint8_t max_connections=4, uint16_t beacon_interval=100){ + wifi_config->ap.channel = channel; + wifi_config->ap.max_connection = max_connections; + wifi_config->ap.beacon_interval = beacon_interval; + wifi_config->ap.ssid_hidden = ssid_hidden; + wifi_config->ap.authmode = WIFI_AUTH_OPEN; + wifi_config->ap.ssid_len = 0; + wifi_config->ap.ssid[0] = 0; + wifi_config->ap.password[0] = 0; + if(ssid != NULL && ssid[0] != 0){ + snprintf((char*)wifi_config->ap.ssid, 32, ssid); + wifi_config->ap.ssid_len = strlen(ssid); + if(password != NULL && password[0] != 0){ + wifi_config->ap.authmode = authmode; + snprintf((char*)wifi_config->ap.password, 64, password); + } + } +} + // ----------------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------- AP function ----------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------------- @@ -110,29 +131,21 @@ bool WiFiAPClass::softAP(const char* ssid, const char* passphrase, int channel, return false; } - esp_wifi_start(); - wifi_config_t conf; - strlcpy(reinterpret_cast(conf.ap.ssid), ssid, sizeof(conf.ap.ssid)); - conf.ap.channel = channel; - conf.ap.ssid_len = strlen(reinterpret_cast(conf.ap.ssid)); - conf.ap.ssid_hidden = ssid_hidden; - conf.ap.max_connection = max_connection; - conf.ap.beacon_interval = 100; - - if(!passphrase || strlen(passphrase) == 0) { - conf.ap.authmode = WIFI_AUTH_OPEN; - *conf.ap.password = 0; - } else { - conf.ap.authmode = WIFI_AUTH_WPA2_PSK; - strlcpy(reinterpret_cast(conf.ap.password), passphrase, sizeof(conf.ap.password)); - } - wifi_config_t conf_current; - esp_wifi_get_config(WIFI_IF_AP, &conf_current); - if(!softap_config_equal(conf, conf_current) && esp_wifi_set_config(WIFI_IF_AP, &conf) != ESP_OK) { + wifi_softap_config(&conf, ssid, passphrase, channel, WIFI_AUTH_WPA_WPA2_PSK, ssid_hidden, max_connection); + esp_err_t err = esp_wifi_get_config(WIFI_IF_AP, &conf_current); + if(err){ + log_e("get AP config failed"); return false; } + if(!softap_config_equal(conf, conf_current)) { + err = esp_wifi_set_config(WIFI_IF_AP, &conf); + if(err){ + log_e("set AP config failed"); + return false; + } + } return true; } @@ -161,34 +174,15 @@ String WiFiAPClass::softAPSSID() const */ bool WiFiAPClass::softAPConfig(IPAddress local_ip, IPAddress gateway, IPAddress subnet) { + esp_err_t err = ESP_OK; if(!WiFi.enableAP(true)) { // enable AP failed return false; } - esp_wifi_start(); - - tcpip_adapter_ip_info_t info; - info.ip.addr = static_cast(local_ip); - info.gw.addr = static_cast(gateway); - info.netmask.addr = static_cast(subnet); - tcpip_adapter_dhcps_stop(TCPIP_ADAPTER_IF_AP); - if(tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_AP, &info) == ESP_OK) { - dhcps_lease_t lease; - lease.enable = true; - lease.start_ip.addr = static_cast(local_ip) + (1 << 24); - lease.end_ip.addr = static_cast(local_ip) + (11 << 24); - - tcpip_adapter_dhcps_option( - (tcpip_adapter_dhcp_option_mode_t)TCPIP_ADAPTER_OP_SET, - (tcpip_adapter_dhcp_option_id_t)REQUESTED_IP_ADDRESS, - (void*)&lease, sizeof(dhcps_lease_t) - ); - - return tcpip_adapter_dhcps_start(TCPIP_ADAPTER_IF_AP) == ESP_OK; - } - return false; + err = set_esp_interface_ip(ESP_IF_WIFI_AP, local_ip, gateway, subnet); + return err == ESP_OK; } @@ -202,17 +196,15 @@ bool WiFiAPClass::softAPdisconnect(bool wifioff) { bool ret; wifi_config_t conf; + wifi_softap_config(&conf); if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return false; } - *conf.ap.ssid = 0; - *conf.ap.password = 0; - conf.ap.authmode = WIFI_AUTH_OPEN; // auth must be open if pass=0 ret = esp_wifi_set_config(WIFI_IF_AP, &conf) == ESP_OK; - if(wifioff) { + if(ret && wifioff) { ret = WiFi.enableAP(false) == ESP_OK; } @@ -242,11 +234,14 @@ uint8_t WiFiAPClass::softAPgetStationNum() */ IPAddress WiFiAPClass::softAPIP() { - tcpip_adapter_ip_info_t ip; if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return IPAddress(); } - tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_AP, &ip); + esp_netif_ip_info_t ip; + if(esp_netif_get_ip_info(get_esp_interface_netif(ESP_IF_WIFI_AP), &ip) != ESP_OK){ + log_e("Netif Get IP Failed!"); + return IPAddress(); + } return IPAddress(ip.ip.addr); } @@ -256,11 +251,14 @@ IPAddress WiFiAPClass::softAPIP() */ IPAddress WiFiAPClass::softAPBroadcastIP() { - tcpip_adapter_ip_info_t ip; + esp_netif_ip_info_t ip; if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return IPAddress(); } - tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_AP, &ip); + if(esp_netif_get_ip_info(get_esp_interface_netif(ESP_IF_WIFI_AP), &ip) != ESP_OK){ + log_e("Netif Get IP Failed!"); + return IPAddress(); + } return WiFiGenericClass::calculateBroadcast(IPAddress(ip.gw.addr), IPAddress(ip.netmask.addr)); } @@ -270,11 +268,14 @@ IPAddress WiFiAPClass::softAPBroadcastIP() */ IPAddress WiFiAPClass::softAPNetworkID() { - tcpip_adapter_ip_info_t ip; + esp_netif_ip_info_t ip; if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return IPAddress(); } - tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_AP, &ip); + if(esp_netif_get_ip_info(get_esp_interface_netif(ESP_IF_WIFI_AP), &ip) != ESP_OK){ + log_e("Netif Get IP Failed!"); + return IPAddress(); + } return WiFiGenericClass::calculateNetworkID(IPAddress(ip.gw.addr), IPAddress(ip.netmask.addr)); } @@ -284,11 +285,14 @@ IPAddress WiFiAPClass::softAPNetworkID() */ uint8_t WiFiAPClass::softAPSubnetCIDR() { - tcpip_adapter_ip_info_t ip; + esp_netif_ip_info_t ip; if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ - return (uint8_t)0; + return IPAddress(); + } + if(esp_netif_get_ip_info(get_esp_interface_netif(ESP_IF_WIFI_AP), &ip) != ESP_OK){ + log_e("Netif Get IP Failed!"); + return IPAddress(); } - tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_AP, &ip); return WiFiGenericClass::calculateSubnetCIDR(IPAddress(ip.netmask.addr)); } @@ -332,8 +336,8 @@ const char * WiFiAPClass::softAPgetHostname() if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return hostname; } - if(tcpip_adapter_get_hostname(TCPIP_ADAPTER_IF_AP, &hostname)) { - return hostname; + if(esp_netif_get_hostname(get_esp_interface_netif(ESP_IF_WIFI_AP), &hostname) != ESP_OK){ + log_e("Netif Get Hostname Failed!"); } return hostname; } @@ -348,7 +352,7 @@ bool WiFiAPClass::softAPsetHostname(const char * hostname) if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return false; } - return tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_AP, hostname) == ESP_OK; + return esp_netif_set_hostname(get_esp_interface_netif(ESP_IF_WIFI_AP), hostname) == ESP_OK; } /** @@ -360,7 +364,7 @@ bool WiFiAPClass::softAPenableIpV6() if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return false; } - return tcpip_adapter_create_ip6_linklocal(TCPIP_ADAPTER_IF_AP) == ESP_OK; + return esp_netif_create_ip6_linklocal(get_esp_interface_netif(ESP_IF_WIFI_AP)) == ESP_OK; } /** @@ -369,11 +373,11 @@ bool WiFiAPClass::softAPenableIpV6() */ IPv6Address WiFiAPClass::softAPIPv6() { - static ip6_addr_t addr; + esp_ip6_addr_t addr; if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return IPv6Address(); } - if(tcpip_adapter_get_ip6_linklocal(TCPIP_ADAPTER_IF_AP, &addr)) { + if(esp_netif_get_ip6_linklocal(get_esp_interface_netif(ESP_IF_WIFI_AP), &addr)) { return IPv6Address(); } return IPv6Address(addr.addr); diff --git a/libraries/WiFi/src/WiFiGeneric.cpp b/libraries/WiFi/src/WiFiGeneric.cpp index b39bbb4ee42194543f20ff126e81933231b77f78..3a270c818ad1c1f3851afece7b642cb812eebecc 100644 --- a/libraries/WiFi/src/WiFiGeneric.cpp +++ b/libraries/WiFi/src/WiFiGeneric.cpp @@ -40,6 +40,7 @@ extern "C" { #include "lwip/opt.h" #include "lwip/err.h" #include "lwip/dns.h" +#include "dhcpserver/dhcpserver_options.h" #include "esp_ipc.h" } //extern "C" @@ -48,135 +49,519 @@ extern "C" { #include #include "sdkconfig.h" -static xQueueHandle _network_event_queue; -static TaskHandle_t _network_event_task_handle = NULL; -static EventGroupHandle_t _network_event_group = NULL; +ESP_EVENT_DEFINE_BASE(ARDUINO_EVENTS); +/* + * Private (exposable) methods + * */ +static esp_netif_t* esp_netifs[ESP_IF_MAX] = {NULL, NULL, NULL}; +esp_interface_t get_esp_netif_interface(esp_netif_t* esp_netif){ + for(int i=0; i(local_ip); + info.gw.addr = static_cast(gateway); + info.netmask.addr = static_cast(subnet); + + esp_err_t err = ESP_OK; + if(interface != ESP_IF_WIFI_AP){ + err = esp_netif_dhcpc_get_status(esp_netif, &status); + if(err){ + log_e("DHCPC Get Status Failed! 0x%04x", err); + return err; + } + err = esp_netif_dhcpc_stop(esp_netif); + if(err){ + log_e("DHCPC Stop Failed! 0x%04x", err); + return err; + } + err = esp_netif_set_ip_info(esp_netif, &info); + if(err){ + log_e("Netif Set IP Failed! 0x%04x", err); + return err; + } + if(info.ip.addr == 0){ + err = esp_netif_dhcpc_start(esp_netif); + if(err){ + log_e("DHCPC Start Failed! 0x%04x", err); + return err; + } + } + } else { + err = esp_netif_dhcps_get_status(esp_netif, &status); + if(err){ + log_e("DHCPS Get Status Failed! 0x%04x", err); + return err; + } + err = esp_netif_dhcps_stop(esp_netif); + if(err){ + log_e("DHCPS Stop Failed! 0x%04x", err); + return err; + } + err = esp_netif_set_ip_info(esp_netif, &info); + if(err){ + log_e("Netif Set IP Failed! 0x%04x", err); + return err; + } + + dhcps_lease_t lease; + lease.enable = true; + lease.start_ip.addr = static_cast(local_ip) + (1 << 24); + lease.end_ip.addr = static_cast(local_ip) + (11 << 24); + + err = tcpip_adapter_dhcps_option( + (tcpip_adapter_dhcp_option_mode_t)TCPIP_ADAPTER_OP_SET, + (tcpip_adapter_dhcp_option_id_t)REQUESTED_IP_ADDRESS, + (void*)&lease, sizeof(dhcps_lease_t) + ); + if(err){ + log_e("DHCPS Set Lease Failed! 0x%04x", err); + return err; + } + + err = esp_netif_dhcps_start(esp_netif); + if(err){ + log_e("DHCPS Start Failed! 0x%04x", err); + return err; + } + } + return err; +} + +esp_err_t set_esp_interface_dns(esp_interface_t interface, IPAddress main_dns=IPAddress(), IPAddress backup_dns=IPAddress(), IPAddress fallback_dns=IPAddress()){ + esp_netif_t *esp_netif = esp_netifs[interface]; + esp_netif_dns_info_t dns; + dns.ip.type = ESP_IPADDR_TYPE_V4; + dns.ip.u_addr.ip4.addr = static_cast(main_dns); + if(dns.ip.u_addr.ip4.addr && esp_netif_set_dns_info(esp_netif, ESP_NETIF_DNS_MAIN, &dns) != ESP_OK){ + log_e("Set Main DNS Failed!"); + return ESP_FAIL; + } + if(interface != ESP_IF_WIFI_AP){ + dns.ip.u_addr.ip4.addr = static_cast(backup_dns); + if(dns.ip.u_addr.ip4.addr && esp_netif_set_dns_info(esp_netif, ESP_NETIF_DNS_BACKUP, &dns) != ESP_OK){ + log_e("Set Backup DNS Failed!"); + return ESP_FAIL; + } + dns.ip.u_addr.ip4.addr = static_cast(fallback_dns); + if(dns.ip.u_addr.ip4.addr && esp_netif_set_dns_info(esp_netif, ESP_NETIF_DNS_FALLBACK, &dns) != ESP_OK){ + log_e("Set Fallback DNS Failed!"); + return ESP_FAIL; + } + } + return ESP_OK; +} -esp_err_t postToSysQueue(system_prov_event_t *data) +static const char * auth_mode_str(int authmode) { - if (xQueueSend(_network_event_queue, &data, portMAX_DELAY) != pdPASS) { - log_w("Network Event Queue Send Failed!"); - return ESP_FAIL; + switch (authmode) { + case WIFI_AUTH_OPEN: + return ("OPEN"); + break; + case WIFI_AUTH_WEP: + return ("WEP"); + break; + case WIFI_AUTH_WPA_PSK: + return ("PSK"); + break; + case WIFI_AUTH_WPA2_PSK: + return ("WPA2_PSK"); + break; + case WIFI_AUTH_WPA_WPA2_PSK: + return ("WPA_WPA2_PSK"); + break; + case WIFI_AUTH_WPA2_ENTERPRISE: + return ("WPA2_ENTERPRISE"); + break; + default: + break; } - return ESP_OK; + return ("UNKNOWN"); } -static void _network_event_task(void * arg){ - system_prov_event_t *data; +static char default_hostname[32] = {0,}; +static const char * get_esp_netif_hostname(){ + if(default_hostname[0] == 0){ + uint8_t eth_mac[6]; + esp_wifi_get_mac(WIFI_IF_STA, eth_mac); + snprintf(default_hostname, 32, "%s%02X%02X%02X", CONFIG_IDF_TARGET "-", eth_mac[3], eth_mac[4], eth_mac[5]); + } + return (const char *)default_hostname; +} +static void set_esp_netif_hostname(const char * name){ + if(name){ + snprintf(default_hostname, 32, "%s", name); + } +} + +static xQueueHandle _arduino_event_queue; +static TaskHandle_t _arduino_event_task_handle = NULL; +static EventGroupHandle_t _arduino_event_group = NULL; + +static void _arduino_event_task(void * arg){ + arduino_event_t *data = NULL; for (;;) { - if(xQueueReceive(_network_event_queue, &data, portMAX_DELAY) == pdTRUE){ - if(data->prov_event != NULL){ - WiFiGenericClass::_eventCallback(arg, data->sys_event, data->prov_event); - free(data->sys_event); - free(data->prov_event); - } else { - WiFiGenericClass::_eventCallback(arg, data->sys_event, NULL); - } + if(xQueueReceive(_arduino_event_queue, &data, portMAX_DELAY) == pdTRUE){ + WiFiGenericClass::_eventCallback(data); free(data); - } + data = NULL; + } } vTaskDelete(NULL); - _network_event_task_handle = NULL; + _arduino_event_task_handle = NULL; } -static esp_err_t _network_event_cb(void* arg, system_event_t *event) { - system_prov_event_t *sys_prov_data = (system_prov_event_t *)malloc(sizeof(system_prov_event_t)); - if(sys_prov_data == NULL) { +esp_err_t postArduinoEvent(arduino_event_t *data) +{ + if(data == NULL){ return ESP_FAIL; - } - sys_prov_data->sys_event = event; - sys_prov_data->prov_event = NULL; - if (postToSysQueue(sys_prov_data) != ESP_OK){ - free(sys_prov_data); + } + arduino_event_t * event = (arduino_event_t*)malloc(sizeof(arduino_event_t)); + if(event == NULL){ + log_e("Arduino Event Malloc Failed!"); + return ESP_FAIL; + } + memcpy(event, data, sizeof(arduino_event_t)); + if (xQueueSend(_arduino_event_queue, &event, portMAX_DELAY) != pdPASS) { + log_e("Arduino Event Send Failed!"); return ESP_FAIL; } return ESP_OK; } -static void _network_event_cb(void* arg, esp_event_base_t base, int32_t id, void* data) { - system_event_t *event = (system_event_t *)data; - if(_network_event_cb(arg, event) != ESP_OK){ - log_e("event dispatch failed"); +static void _arduino_event_cb(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) { + arduino_event_t arduino_event; + arduino_event.event_id = ARDUINO_EVENT_MAX; + + /* + * STA + * */ + if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) { + log_v("STA Started"); + arduino_event.event_id = ARDUINO_EVENT_WIFI_STA_START; + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_STOP) { + log_v("STA Stopped"); + arduino_event.event_id = ARDUINO_EVENT_WIFI_STA_STOP; + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_AUTHMODE_CHANGE) { + wifi_event_sta_authmode_change_t * event = (wifi_event_sta_authmode_change_t*)event_data; + log_v("STA Auth Mode Changed: From: %s, To: %s", auth_mode_str(event->old_mode), auth_mode_str(event->new_mode)); + arduino_event.event_id = ARDUINO_EVENT_WIFI_STA_AUTHMODE_CHANGE; + memcpy(&arduino_event.event_info.wifi_sta_authmode_change, event_data, sizeof(wifi_event_sta_authmode_change_t)); + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_CONNECTED) { + wifi_event_sta_connected_t * event = (wifi_event_sta_connected_t*)event_data; + log_v("STA Connected: SSID: %s, BSSID: " MACSTR ", Channel: %u, Auth: %s", event->ssid, MAC2STR(event->bssid), event->channel, auth_mode_str(event->authmode)); + arduino_event.event_id = ARDUINO_EVENT_WIFI_STA_CONNECTED; + memcpy(&arduino_event.event_info.wifi_sta_connected, event_data, sizeof(wifi_event_sta_connected_t)); + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) { + wifi_event_sta_disconnected_t * event = (wifi_event_sta_disconnected_t*)event_data; + log_v("STA Disconnected: SSID: %s, BSSID: " MACSTR ", Reason: %u", event->ssid, MAC2STR(event->bssid), event->reason); + arduino_event.event_id = ARDUINO_EVENT_WIFI_STA_DISCONNECTED; + memcpy(&arduino_event.event_info.wifi_sta_disconnected, event_data, sizeof(wifi_event_sta_disconnected_t)); + } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) { + ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data; + log_v("STA Got %sIP:" IPSTR, event->ip_changed?"New ":"Same ", IP2STR(&event->ip_info.ip)); + arduino_event.event_id = ARDUINO_EVENT_WIFI_STA_GOT_IP; + memcpy(&arduino_event.event_info.got_ip, event_data, sizeof(ip_event_got_ip_t)); + } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_LOST_IP) { + log_v("STA IP Lost"); + arduino_event.event_id = ARDUINO_EVENT_WIFI_STA_LOST_IP; + + /* + * SCAN + * */ + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_SCAN_DONE) { + wifi_event_sta_scan_done_t * event = (wifi_event_sta_scan_done_t*)event_data; + log_v("SCAN Done: ID: %u, Status: %u, Results: %u", event->scan_id, event->status, event->number); + arduino_event.event_id = ARDUINO_EVENT_WIFI_SCAN_DONE; + memcpy(&arduino_event.event_info.wifi_scan_done, event_data, sizeof(wifi_event_sta_scan_done_t)); + + /* + * AP + * */ + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_START) { + log_v("AP Started"); + arduino_event.event_id = ARDUINO_EVENT_WIFI_AP_START; + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STOP) { + log_v("AP Stopped"); + arduino_event.event_id = ARDUINO_EVENT_WIFI_AP_STOP; + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_PROBEREQRECVED) { + wifi_event_ap_probe_req_rx_t * event = (wifi_event_ap_probe_req_rx_t*)event_data; + log_v("AP Probe Request: RSSI: %d, MAC: " MACSTR, event->rssi, MAC2STR(event->mac)); + arduino_event.event_id = ARDUINO_EVENT_WIFI_AP_PROBEREQRECVED; + memcpy(&arduino_event.event_info.wifi_ap_probereqrecved, event_data, sizeof(wifi_event_ap_probe_req_rx_t)); + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STACONNECTED) { + wifi_event_ap_staconnected_t* event = (wifi_event_ap_staconnected_t*) event_data; + log_v("AP Station Connected: MAC: " MACSTR ", AID: %d", MAC2STR(event->mac), event->aid); + arduino_event.event_id = ARDUINO_EVENT_WIFI_AP_STACONNECTED; + memcpy(&arduino_event.event_info.wifi_ap_staconnected, event_data, sizeof(wifi_event_ap_staconnected_t)); + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STADISCONNECTED) { + wifi_event_ap_stadisconnected_t* event = (wifi_event_ap_stadisconnected_t*) event_data; + log_v("AP Station Disconnected: MAC: " MACSTR ", AID: %d", MAC2STR(event->mac), event->aid); + arduino_event.event_id = ARDUINO_EVENT_WIFI_AP_STADISCONNECTED; + memcpy(&arduino_event.event_info.wifi_ap_stadisconnected, event_data, sizeof(wifi_event_ap_stadisconnected_t)); + } else if (event_base == IP_EVENT && event_id == IP_EVENT_AP_STAIPASSIGNED) { + ip_event_ap_staipassigned_t * event = (ip_event_ap_staipassigned_t*)event_data; + log_v("AP Station IP Assigned:" IPSTR, IP2STR(&event->ip)); + arduino_event.event_id = ARDUINO_EVENT_WIFI_AP_STAIPASSIGNED; + memcpy(&arduino_event.event_info.wifi_ap_staipassigned, event_data, sizeof(ip_event_ap_staipassigned_t)); + + /* + * ETH + * */ + } else if (event_base == ETH_EVENT && event_id == ETHERNET_EVENT_CONNECTED) { + log_v("Ethernet Link Up"); + esp_eth_handle_t eth_handle = *(esp_eth_handle_t *)event_data; + arduino_event.event_id = ARDUINO_EVENT_ETH_CONNECTED; + memcpy(&arduino_event.event_info.eth_connected, event_data, sizeof(esp_eth_handle_t)); + } else if (event_base == ETH_EVENT && event_id == ETHERNET_EVENT_DISCONNECTED) { + log_v("Ethernet Link Down"); + arduino_event.event_id = ARDUINO_EVENT_ETH_DISCONNECTED; + } else if (event_base == ETH_EVENT && event_id == ETHERNET_EVENT_START) { + log_v("Ethernet Started"); + arduino_event.event_id = ARDUINO_EVENT_ETH_START; + } else if (event_base == ETH_EVENT && event_id == ETHERNET_EVENT_STOP) { + log_v("Ethernet Stopped"); + arduino_event.event_id = ARDUINO_EVENT_ETH_STOP; + } else if (event_base == IP_EVENT && event_id == IP_EVENT_ETH_GOT_IP) { + ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data; + log_v("Ethernet got %sip:" IPSTR, event->ip_changed?"new":"", IP2STR(&event->ip_info.ip)); + arduino_event.event_id = ARDUINO_EVENT_ETH_GOT_IP; + memcpy(&arduino_event.event_info.got_ip, event_data, sizeof(ip_event_got_ip_t)); + + /* + * IPv6 + * */ + } else if (event_base == IP_EVENT && event_id == IP_EVENT_GOT_IP6) { + ip_event_got_ip6_t * event = (ip_event_got_ip6_t*)event_data; + esp_interface_t iface = get_esp_netif_interface(event->esp_netif); + log_v("IF[%d] Got IPv6: IP Index: %d, Zone: %d, " IPV6STR, iface, event->ip_index, event->ip6_info.ip.zone, IPV62STR(event->ip6_info.ip)); + memcpy(&arduino_event.event_info.got_ip6, event_data, sizeof(ip_event_got_ip6_t)); + if(iface == ESP_IF_WIFI_STA){ + arduino_event.event_id = ARDUINO_EVENT_WIFI_STA_GOT_IP6; + } else if(iface == ESP_IF_WIFI_AP){ + arduino_event.event_id = ARDUINO_EVENT_WIFI_AP_GOT_IP6; + } else if(iface == ESP_IF_ETH){ + arduino_event.event_id = ARDUINO_EVENT_ETH_GOT_IP6; + } + + /* + * WPS + * */ + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_WPS_ER_SUCCESS) { + arduino_event.event_id = ARDUINO_EVENT_WPS_ER_SUCCESS; + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_WPS_ER_FAILED) { + wifi_event_sta_wps_fail_reason_t * event = (wifi_event_sta_wps_fail_reason_t*)event_data; + arduino_event.event_id = ARDUINO_EVENT_WPS_ER_FAILED; + memcpy(&arduino_event.event_info.wps_fail_reason, event_data, sizeof(wifi_event_sta_wps_fail_reason_t)); + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_WPS_ER_TIMEOUT) { + arduino_event.event_id = ARDUINO_EVENT_WPS_ER_TIMEOUT; + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_WPS_ER_PIN) { + wifi_event_sta_wps_er_pin_t * event = (wifi_event_sta_wps_er_pin_t*)event_data; + arduino_event.event_id = ARDUINO_EVENT_WPS_ER_PIN; + memcpy(&arduino_event.event_info.wps_er_pin, event_data, sizeof(wifi_event_sta_wps_er_pin_t)); + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_WPS_ER_PBC_OVERLAP) { + arduino_event.event_id = ARDUINO_EVENT_WPS_ER_PBC_OVERLAP; + + + /* + * SMART CONFIG + * */ + } else if (event_base == SC_EVENT && event_id == SC_EVENT_SCAN_DONE) { + log_v("SC Scan Done"); + arduino_event.event_id = ARDUINO_EVENT_SC_SCAN_DONE; + } else if (event_base == SC_EVENT && event_id == SC_EVENT_FOUND_CHANNEL) { + log_v("SC Found Channel"); + arduino_event.event_id = ARDUINO_EVENT_SC_FOUND_CHANNEL; + } else if (event_base == SC_EVENT && event_id == SC_EVENT_GOT_SSID_PSWD) { + smartconfig_event_got_ssid_pswd_t *event = (smartconfig_event_got_ssid_pswd_t *)event_data; + log_v("SC: SSID: %s, Password: %s", (const char *)event->ssid, (const char *)event->password); + arduino_event.event_id = ARDUINO_EVENT_SC_GOT_SSID_PSWD; + memcpy(&arduino_event.event_info.sc_got_ssid_pswd, event_data, sizeof(smartconfig_event_got_ssid_pswd_t)); + + } else if (event_base == SC_EVENT && event_id == SC_EVENT_SEND_ACK_DONE) { + log_v("SC Send Ack Done"); + arduino_event.event_id = ARDUINO_EVENT_SC_SEND_ACK_DONE; + + /* + * Provisioning + * */ + } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_INIT) { + log_v("Provisioning Initialized!"); + arduino_event.event_id = ARDUINO_EVENT_PROV_INIT; + } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_DEINIT) { + log_v("Provisioning Uninitialized!"); + arduino_event.event_id = ARDUINO_EVENT_PROV_DEINIT; + } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_START) { + log_v("Provisioning Start!"); + arduino_event.event_id = ARDUINO_EVENT_PROV_START; + } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_END) { + log_v("Provisioning End!"); + wifi_prov_mgr_deinit(); + arduino_event.event_id = ARDUINO_EVENT_PROV_END; + } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_CRED_RECV) { + wifi_sta_config_t *event = (wifi_sta_config_t *)event_data; + log_v("Provisioned Credentials: SSID: %s, Password: %s", (const char *) event->ssid, (const char *) event->password); + arduino_event.event_id = ARDUINO_EVENT_PROV_CRED_RECV; + memcpy(&arduino_event.event_info.prov_cred_recv, event_data, sizeof(wifi_sta_config_t)); + } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_CRED_FAIL) { + wifi_prov_sta_fail_reason_t *reason = (wifi_prov_sta_fail_reason_t *)event_data; + log_e("Provisioning Failed: Reason : %s", (*reason == WIFI_PROV_STA_AUTH_ERROR)?"Authentication Failed":"AP Not Found"); + arduino_event.event_id = ARDUINO_EVENT_PROV_CRED_FAIL; + memcpy(&arduino_event.event_info.prov_fail_reason, event_data, sizeof(wifi_prov_sta_fail_reason_t)); + } else if (event_base == WIFI_PROV_EVENT && event_id == WIFI_PROV_CRED_SUCCESS) { + log_v("Provisioning Success!"); + arduino_event.event_id = ARDUINO_EVENT_PROV_CRED_SUCCESS; } + + if(arduino_event.event_id < ARDUINO_EVENT_MAX){ + postArduinoEvent(&arduino_event); + } } -// static esp_err_t _network_event_cb(void *arg, system_event_t *event){ -// if (xQueueSend(_network_event_queue, event, portMAX_DELAY) != pdPASS) { -// log_w("Network Event Queue Send Failed!"); -// return ESP_FAIL; -// } -// return ESP_OK; -// } -ESP_EVENT_DEFINE_BASE(SYSTEM_EVENT); static bool _start_network_event_task(){ - if(!_network_event_group){ - _network_event_group = xEventGroupCreate(); - if(!_network_event_group){ + if(!_arduino_event_group){ + _arduino_event_group = xEventGroupCreate(); + if(!_arduino_event_group){ log_e("Network Event Group Create Failed!"); return false; } - xEventGroupSetBits(_network_event_group, WIFI_DNS_IDLE_BIT); + xEventGroupSetBits(_arduino_event_group, WIFI_DNS_IDLE_BIT); } - if(!_network_event_queue){ - _network_event_queue = xQueueCreate(32, sizeof(system_prov_event_t)); - if(!_network_event_queue){ + if(!_arduino_event_queue){ + _arduino_event_queue = xQueueCreate(32, sizeof(arduino_event_t*)); + if(!_arduino_event_queue){ log_e("Network Event Queue Create Failed!"); return false; } } - if(!_network_event_task_handle){ - xTaskCreateUniversal(_network_event_task, "network_event", 4096, NULL, ESP_TASKD_EVENT_PRIO - 1, &_network_event_task_handle, CONFIG_ARDUINO_EVENT_RUNNING_CORE); - if(!_network_event_task_handle){ + + esp_err_t err = esp_event_loop_create_default(); + if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) { + log_e("esp_event_loop_create_default failed!"); + return err; + } + + if(!_arduino_event_task_handle){ + xTaskCreateUniversal(_arduino_event_task, "arduino_events", 4096, NULL, ESP_TASKD_EVENT_PRIO - 1, &_arduino_event_task_handle, CONFIG_ARDUINO_EVENT_RUNNING_CORE); + if(!_arduino_event_task_handle){ log_e("Network Event Task Start Failed!"); return false; } } - esp_err_t err = esp_event_loop_create_default(); - if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) { - return err; + if(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &_arduino_event_cb, NULL, NULL)){ + log_e("event_handler_instance_register for WIFI_EVENT Failed!"); + return false; } - return esp_event_handler_register(SYSTEM_EVENT, ESP_EVENT_ANY_ID, _network_event_cb, NULL) == ESP_OK; - //return esp_event_loop_init(&_network_event_cb, NULL) == ESP_OK; + if(esp_event_handler_instance_register(IP_EVENT, ESP_EVENT_ANY_ID, &_arduino_event_cb, NULL, NULL)){ + log_e("event_handler_instance_register for IP_EVENT Failed!"); + return false; + } + + if(esp_event_handler_instance_register(SC_EVENT, ESP_EVENT_ANY_ID, &_arduino_event_cb, NULL, NULL)){ + log_e("event_handler_instance_register for SC_EVENT Failed!"); + return false; + } + + if(esp_event_handler_instance_register(ETH_EVENT, ESP_EVENT_ANY_ID, &_arduino_event_cb, NULL, NULL)){ + log_e("event_handler_instance_register for ETH_EVENT Failed!"); + return false; + } + + if(esp_event_handler_instance_register(WIFI_PROV_EVENT, ESP_EVENT_ANY_ID, &_arduino_event_cb, NULL, NULL)){ + log_e("event_handler_instance_register for WIFI_PROV_EVENT Failed!"); + return false; + } + + return true; } -void tcpipInit(){ +bool tcpipInit(){ static bool initialized = false; - if(!initialized && _start_network_event_task()){ + if(!initialized){ initialized = true; -#ifdef ESP_IDF_VERSION_MAJOR +#if CONFIG_IDF_TARGET_ESP32 uint8_t mac[8]; if(esp_efuse_mac_get_default(mac) == ESP_OK){ esp_base_mac_addr_set(mac); } - esp_event_loop_create_default(); #endif - esp_netif_init(); + initialized = esp_netif_init() == ESP_OK; + if(initialized){ + initialized = _start_network_event_task(); + } else { + log_e("esp_netif_init failed!"); + } } + return initialized; } +/* + * WiFi INIT + * */ + static bool lowLevelInitDone = false; -static bool wifiLowLevelInit(bool persistent){ +bool wifiLowLevelInit(bool persistent){ if(!lowLevelInitDone){ - tcpipInit(); + lowLevelInitDone = true; + if(!tcpipInit()){ + lowLevelInitDone = false; + return lowLevelInitDone; + } + if(esp_netifs[ESP_IF_WIFI_AP] == NULL){ + esp_netifs[ESP_IF_WIFI_AP] = esp_netif_create_default_wifi_ap(); + } + if(esp_netifs[ESP_IF_WIFI_STA] == NULL){ + esp_netifs[ESP_IF_WIFI_STA] = esp_netif_create_default_wifi_sta(); + } + wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); esp_err_t err = esp_wifi_init(&cfg); if(err){ log_e("esp_wifi_init %d", err); - return false; + lowLevelInitDone = false; + return lowLevelInitDone; } if(!persistent){ - esp_wifi_set_storage(WIFI_STORAGE_RAM); + lowLevelInitDone = esp_wifi_set_storage(WIFI_STORAGE_RAM) == ESP_OK; } - lowLevelInitDone = true; } - return true; + return lowLevelInitDone; } static bool wifiLowLevelDeinit(){ - //deinit not working yet! - //esp_wifi_deinit(); + if(lowLevelInitDone){ + lowLevelInitDone = esp_wifi_deinit() == ESP_OK; + } return true; } @@ -186,16 +571,14 @@ static bool espWiFiStart(){ if(_esp_wifi_started){ return true; } + _esp_wifi_started = true; esp_err_t err = esp_wifi_start(); if (err != ESP_OK) { + _esp_wifi_started = false; log_e("esp_wifi_start %d", err); - return false; + return _esp_wifi_started; } - _esp_wifi_started = true; - system_event_t event; - event.event_id = SYSTEM_EVENT_WIFI_READY; - WiFiGenericClass::_eventCallback(nullptr, &event, NULL); - return true; + return _esp_wifi_started; } static bool espWiFiStop(){ @@ -223,10 +606,9 @@ typedef struct WiFiEventCbList { WiFiEventCb cb; WiFiEventFuncCb fcb; WiFiEventSysCb scb; - WiFiProvEventCb provcb; - system_event_id_t event; + arduino_event_id_t event; - WiFiEventCbList() : id(current_id++), cb(NULL), fcb(NULL), scb(NULL), provcb(NULL), event(SYSTEM_EVENT_WIFI_READY) {} + WiFiEventCbList() : id(current_id++), cb(NULL), fcb(NULL), scb(NULL), event(ARDUINO_EVENT_WIFI_READY) {} } WiFiEventCbList_t; wifi_event_id_t WiFiEventCbList::current_id = 1; @@ -243,33 +625,43 @@ WiFiGenericClass::WiFiGenericClass() } +const char * WiFiGenericClass::getHostname() +{ + return get_esp_netif_hostname(); +} + +void WiFiGenericClass::setHostname(const char * hostname) +{ + return set_esp_netif_hostname(hostname); +} + int WiFiGenericClass::setStatusBits(int bits){ - if(!_network_event_group){ + if(!_arduino_event_group){ return 0; } - return xEventGroupSetBits(_network_event_group, bits); + return xEventGroupSetBits(_arduino_event_group, bits); } int WiFiGenericClass::clearStatusBits(int bits){ - if(!_network_event_group){ + if(!_arduino_event_group){ return 0; } - return xEventGroupClearBits(_network_event_group, bits); + return xEventGroupClearBits(_arduino_event_group, bits); } int WiFiGenericClass::getStatusBits(){ - if(!_network_event_group){ + if(!_arduino_event_group){ return 0; } - return xEventGroupGetBits(_network_event_group); + return xEventGroupGetBits(_arduino_event_group); } int WiFiGenericClass::waitStatusBits(int bits, uint32_t timeout_ms){ - if(!_network_event_group){ + if(!_arduino_event_group){ return 0; } return xEventGroupWaitBits( - _network_event_group, // The event group being tested. + _arduino_event_group, // The event group being tested. bits, // The bits within the event group to wait for. pdFALSE, // BIT_0 and BIT_4 should be cleared before returning. pdTRUE, // Don't wait for both bits, either bit will do. @@ -281,21 +673,7 @@ int WiFiGenericClass::waitStatusBits(int bits, uint32_t timeout_ms){ * @param cbEvent WiFiEventCb * @param event optional filter (WIFI_EVENT_MAX is all events) */ -wifi_event_id_t WiFiGenericClass::onEvent(WiFiProvEventCb cbEvent, system_event_id_t event) -{ - if(!cbEvent){ - return 0; - } - WiFiEventCbList_t newEventHandler; - newEventHandler.cb = NULL; - newEventHandler.fcb = NULL; - newEventHandler.scb = NULL; - newEventHandler.provcb = cbEvent; - newEventHandler.event = event; - cbEventList.push_back(newEventHandler); - return newEventHandler.id; -} -wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventCb cbEvent, system_event_id_t event) +wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventCb cbEvent, arduino_event_id_t event) { if(!cbEvent) { return 0; @@ -304,13 +682,12 @@ wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventCb cbEvent, system_event_id_t newEventHandler.cb = cbEvent; newEventHandler.fcb = NULL; newEventHandler.scb = NULL; - newEventHandler.provcb = NULL; newEventHandler.event = event; cbEventList.push_back(newEventHandler); return newEventHandler.id; } -wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventFuncCb cbEvent, system_event_id_t event) +wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventFuncCb cbEvent, arduino_event_id_t event) { if(!cbEvent) { return 0; @@ -319,13 +696,12 @@ wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventFuncCb cbEvent, system_event_ newEventHandler.cb = NULL; newEventHandler.fcb = cbEvent; newEventHandler.scb = NULL; - newEventHandler.provcb = NULL; newEventHandler.event = event; cbEventList.push_back(newEventHandler); return newEventHandler.id; } -wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventSysCb cbEvent, system_event_id_t event) +wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventSysCb cbEvent, arduino_event_id_t event) { if(!cbEvent) { return 0; @@ -334,7 +710,6 @@ wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventSysCb cbEvent, system_event_i newEventHandler.cb = NULL; newEventHandler.fcb = NULL; newEventHandler.scb = cbEvent; - newEventHandler.provcb = NULL; newEventHandler.event = event; cbEventList.push_back(newEventHandler); return newEventHandler.id; @@ -345,7 +720,7 @@ wifi_event_id_t WiFiGenericClass::onEvent(WiFiEventSysCb cbEvent, system_event_i * @param cbEvent WiFiEventCb * @param event optional filter (WIFI_EVENT_MAX is all events) */ -void WiFiGenericClass::removeEvent(WiFiEventCb cbEvent, system_event_id_t event) +void WiFiGenericClass::removeEvent(WiFiEventCb cbEvent, arduino_event_id_t event) { if(!cbEvent) { return; @@ -359,7 +734,7 @@ void WiFiGenericClass::removeEvent(WiFiEventCb cbEvent, system_event_id_t event) } } -void WiFiGenericClass::removeEvent(WiFiEventSysCb cbEvent, system_event_id_t event) +void WiFiGenericClass::removeEvent(WiFiEventSysCb cbEvent, arduino_event_id_t event) { if(!cbEvent) { return; @@ -388,35 +763,43 @@ void WiFiGenericClass::removeEvent(wifi_event_id_t id) * @param arg */ #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG -const char * system_event_names[] = { "WIFI_READY", "SCAN_DONE", "STA_START", "STA_STOP", "STA_CONNECTED", "STA_DISCONNECTED", "STA_AUTHMODE_CHANGE", "STA_GOT_IP", "STA_LOST_IP", "STA_WPS_ER_SUCCESS", "STA_WPS_ER_FAILED", "STA_WPS_ER_TIMEOUT", "STA_WPS_ER_PIN", "STA_WPS_ER_PBC_OVERLAP", "AP_START", "AP_STOP", "AP_STACONNECTED", "AP_STADISCONNECTED", "AP_STAIPASSIGNED", "AP_PROBEREQRECVED", "GOT_IP6", "ETH_START", "ETH_STOP", "ETH_CONNECTED", "ETH_DISCONNECTED", "ETH_GOT_IP", "MAX"}; +const char * arduino_event_names[] = { + "WIFI_READY", + "SCAN_DONE", + "STA_START", "STA_STOP", "STA_CONNECTED", "STA_DISCONNECTED", "STA_AUTHMODE_CHANGE", "STA_GOT_IP", "STA_GOT_IP6", "STA_LOST_IP", + "AP_START", "AP_STOP", "AP_STACONNECTED", "AP_STADISCONNECTED", "AP_STAIPASSIGNED", "AP_PROBEREQRECVED", "AP_GOT_IP6", + "ETH_START", "ETH_STOP", "ETH_CONNECTED", "ETH_DISCONNECTED", "ETH_GOT_IP", "ETH_GOT_IP6", + "WPS_ER_SUCCESS", "WPS_ER_FAILED", "WPS_ER_TIMEOUT", "WPS_ER_PIN", "WPS_ER_PBC_OVERLAP", + "SC_SCAN_DONE", "SC_FOUND_CHANNEL", "SC_GOT_SSID_PSWD", "SC_SEND_ACK_DONE", + "PROV_INIT", "PROV_DEINIT", "PROV_START", "PROV_END", "PROV_CRED_RECV", "PROV_CRED_FAIL", "PROV_CRED_SUCCESS" +}; #endif #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_WARN const char * system_event_reasons[] = { "UNSPECIFIED", "AUTH_EXPIRE", "AUTH_LEAVE", "ASSOC_EXPIRE", "ASSOC_TOOMANY", "NOT_AUTHED", "NOT_ASSOCED", "ASSOC_LEAVE", "ASSOC_NOT_AUTHED", "DISASSOC_PWRCAP_BAD", "DISASSOC_SUPCHAN_BAD", "UNSPECIFIED", "IE_INVALID", "MIC_FAILURE", "4WAY_HANDSHAKE_TIMEOUT", "GROUP_KEY_UPDATE_TIMEOUT", "IE_IN_4WAY_DIFFERS", "GROUP_CIPHER_INVALID", "PAIRWISE_CIPHER_INVALID", "AKMP_INVALID", "UNSUPP_RSN_IE_VERSION", "INVALID_RSN_IE_CAP", "802_1X_AUTH_FAILED", "CIPHER_SUITE_REJECTED", "BEACON_TIMEOUT", "NO_AP_FOUND", "AUTH_FAIL", "ASSOC_FAIL", "HANDSHAKE_TIMEOUT", "CONNECTION_FAIL" }; #define reason2str(r) ((r>176)?system_event_reasons[r-176]:system_event_reasons[r-1]) #endif -esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event, wifi_prov_event_t *prov_event) +esp_err_t WiFiGenericClass::_eventCallback(arduino_event_t *event) { - if(WiFi.isProvEnabled()) { - wifi_prov_mgr_event_handler(arg,event); + if(event->event_id < ARDUINO_EVENT_MAX) { + log_d("Arduino Event: %d - %s", event->event_id, arduino_event_names[event->event_id]); } - if(event->event_id < 26) { - log_d("Event: %d - %s", event->event_id, system_event_names[event->event_id]); - } - if(event->event_id == SYSTEM_EVENT_SCAN_DONE) { + if(event->event_id == ARDUINO_EVENT_WIFI_SCAN_DONE) { WiFiScanClass::_scanDone(); - } else if(event->event_id == SYSTEM_EVENT_STA_START) { + } else if(event->event_id == ARDUINO_EVENT_WIFI_STA_START) { WiFiSTAClass::_setStatus(WL_DISCONNECTED); setStatusBits(STA_STARTED_BIT); tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_STA, WiFiSTAClass::_hostname.c_str()); - } else if(event->event_id == SYSTEM_EVENT_STA_STOP) { + } else if(event->event_id == ARDUINO_EVENT_WIFI_STA_STOP) { WiFiSTAClass::_setStatus(WL_NO_SHIELD); clearStatusBits(STA_STARTED_BIT | STA_CONNECTED_BIT | STA_HAS_IP_BIT | STA_HAS_IP6_BIT); - } else if(event->event_id == SYSTEM_EVENT_STA_CONNECTED) { + } else if(event->event_id == ARDUINO_EVENT_WIFI_STA_CONNECTED) { WiFiSTAClass::_setStatus(WL_IDLE_STATUS); setStatusBits(STA_CONNECTED_BIT); - } else if(event->event_id == SYSTEM_EVENT_STA_DISCONNECTED) { - uint8_t reason = event->event_info.disconnected.reason; + + //esp_netif_create_ip6_linklocal(esp_netifs[ESP_IF_WIFI_STA]); + } else if(event->event_id == ARDUINO_EVENT_WIFI_STA_DISCONNECTED) { + uint8_t reason = event->event_info.wifi_sta_disconnected.reason; log_w("Reason: %u - %s", reason, reason2str(reason)); if(reason == WIFI_REASON_NO_AP_FOUND) { WiFiSTAClass::_setStatus(WL_NO_SSID_AVAIL); @@ -437,7 +820,7 @@ esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event, wif WiFi.disconnect(); WiFi.begin(); } - } else if(event->event_id == SYSTEM_EVENT_STA_GOT_IP) { + } else if(event->event_id == ARDUINO_EVENT_WIFI_STA_GOT_IP) { #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG uint8_t * ip = (uint8_t *)&(event->event_info.got_ip.ip_info.ip.addr); uint8_t * mask = (uint8_t *)&(event->event_info.got_ip.ip_info.netmask.addr); @@ -449,31 +832,31 @@ esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event, wif #endif WiFiSTAClass::_setStatus(WL_CONNECTED); setStatusBits(STA_HAS_IP_BIT | STA_CONNECTED_BIT); - } else if(event->event_id == SYSTEM_EVENT_STA_LOST_IP) { + } else if(event->event_id == ARDUINO_EVENT_WIFI_STA_LOST_IP) { WiFiSTAClass::_setStatus(WL_IDLE_STATUS); clearStatusBits(STA_HAS_IP_BIT); - } else if(event->event_id == SYSTEM_EVENT_AP_START) { + } else if(event->event_id == ARDUINO_EVENT_WIFI_AP_START) { setStatusBits(AP_STARTED_BIT); - } else if(event->event_id == SYSTEM_EVENT_AP_STOP) { + } else if(event->event_id == ARDUINO_EVENT_WIFI_AP_STOP) { clearStatusBits(AP_STARTED_BIT | AP_HAS_CLIENT_BIT); - } else if(event->event_id == SYSTEM_EVENT_AP_STACONNECTED) { + } else if(event->event_id == ARDUINO_EVENT_WIFI_AP_STACONNECTED) { setStatusBits(AP_HAS_CLIENT_BIT); - } else if(event->event_id == SYSTEM_EVENT_AP_STADISCONNECTED) { + } else if(event->event_id == ARDUINO_EVENT_WIFI_AP_STADISCONNECTED) { wifi_sta_list_t clients; if(esp_wifi_ap_get_sta_list(&clients) != ESP_OK || !clients.num){ clearStatusBits(AP_HAS_CLIENT_BIT); } - } else if(event->event_id == SYSTEM_EVENT_ETH_START) { + } else if(event->event_id == ARDUINO_EVENT_ETH_START) { setStatusBits(ETH_STARTED_BIT); - } else if(event->event_id == SYSTEM_EVENT_ETH_STOP) { + } else if(event->event_id == ARDUINO_EVENT_ETH_STOP) { clearStatusBits(ETH_STARTED_BIT | ETH_CONNECTED_BIT | ETH_HAS_IP_BIT | ETH_HAS_IP6_BIT); - } else if(event->event_id == SYSTEM_EVENT_ETH_CONNECTED) { + } else if(event->event_id == ARDUINO_EVENT_ETH_CONNECTED) { setStatusBits(ETH_CONNECTED_BIT); - } else if(event->event_id == SYSTEM_EVENT_ETH_DISCONNECTED) { + } else if(event->event_id == ARDUINO_EVENT_ETH_DISCONNECTED) { clearStatusBits(ETH_CONNECTED_BIT | ETH_HAS_IP_BIT | ETH_HAS_IP6_BIT); - } else if(event->event_id == SYSTEM_EVENT_ETH_GOT_IP) { + } else if(event->event_id == ARDUINO_EVENT_ETH_GOT_IP) { #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG uint8_t * ip = (uint8_t *)&(event->event_info.got_ip.ip_info.ip.addr); uint8_t * mask = (uint8_t *)&(event->event_info.got_ip.ip_info.netmask.addr); @@ -485,33 +868,37 @@ esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event, wif #endif setStatusBits(ETH_CONNECTED_BIT | ETH_HAS_IP_BIT); - } else if(event->event_id == SYSTEM_EVENT_GOT_IP6) { - if(event->event_info.got_ip6.if_index == TCPIP_ADAPTER_IF_AP){ - setStatusBits(AP_HAS_IP6_BIT); - } else if(event->event_info.got_ip6.if_index == TCPIP_ADAPTER_IF_STA){ - setStatusBits(STA_CONNECTED_BIT | STA_HAS_IP6_BIT); - } else if(event->event_info.got_ip6.if_index == TCPIP_ADAPTER_IF_ETH){ - setStatusBits(ETH_CONNECTED_BIT | ETH_HAS_IP6_BIT); - } + } else if(event->event_id == ARDUINO_EVENT_WIFI_STA_GOT_IP6) { + setStatusBits(STA_CONNECTED_BIT | STA_HAS_IP6_BIT); + } else if(event->event_id == ARDUINO_EVENT_WIFI_AP_GOT_IP6) { + setStatusBits(AP_HAS_IP6_BIT); + } else if(event->event_id == ARDUINO_EVENT_ETH_GOT_IP6) { + setStatusBits(ETH_CONNECTED_BIT | ETH_HAS_IP6_BIT); + } else if(event->event_id == ARDUINO_EVENT_SC_GOT_SSID_PSWD) { + WiFi.begin( + (const char *)event->event_info.sc_got_ssid_pswd.ssid, + (const char *)event->event_info.sc_got_ssid_pswd.password, + 0, + ((event->event_info.sc_got_ssid_pswd.bssid_set == true)?event->event_info.sc_got_ssid_pswd.bssid:NULL) + ); + } else if(event->event_id == ARDUINO_EVENT_SC_SEND_ACK_DONE) { + esp_smartconfig_stop(); + WiFiSTAClass::_smartConfigDone = true; } - + for(uint32_t i = 0; i < cbEventList.size(); i++) { WiFiEventCbList_t entry = cbEventList[i]; if(entry.cb || entry.fcb || entry.scb) { - if(entry.event == (system_event_id_t) event->event_id || entry.event == SYSTEM_EVENT_MAX) { + if(entry.event == (arduino_event_id_t) event->event_id || entry.event == ARDUINO_EVENT_MAX) { if(entry.cb) { - entry.cb((system_event_id_t) event->event_id); + entry.cb((arduino_event_id_t) event->event_id); } else if(entry.fcb) { - entry.fcb((system_event_id_t) event->event_id, (system_event_info_t) event->event_info); + entry.fcb((arduino_event_id_t) event->event_id, (arduino_event_info_t) event->event_info); } else { entry.scb(event); } } } - - if(entry.provcb) { - entry.provcb(event,prov_event); - } } return ESP_OK; } @@ -571,6 +958,13 @@ bool WiFiGenericClass::mode(wifi_mode_t m) } esp_err_t err; + if(m & WIFI_MODE_STA){ + err = set_esp_interface_hostname(ESP_IF_WIFI_STA, get_esp_netif_hostname()); + if(err){ + log_e("Could not set hostname! %d", err); + return false; + } + } err = esp_wifi_set_mode(m); if(err){ log_e("Could not set mode! %d", err); @@ -608,7 +1002,7 @@ wifi_mode_t WiFiGenericClass::getMode() return WIFI_MODE_NULL; } wifi_mode_t mode; - if(esp_wifi_get_mode(&mode) == ESP_ERR_WIFI_NOT_INIT){ + if(esp_wifi_get_mode(&mode) != ESP_OK){ log_w("WiFi not started"); return WIFI_MODE_NULL; } @@ -740,7 +1134,7 @@ static void wifi_dns_found_callback(const char *name, const ip_addr_t *ipaddr, v if(ipaddr) { (*reinterpret_cast(callback_arg)) = ipaddr->u_addr.ip4.addr; } - xEventGroupSetBits(_network_event_group, WIFI_DNS_DONE_BIT); + xEventGroupSetBits(_arduino_event_group, WIFI_DNS_DONE_BIT); } /** diff --git a/libraries/WiFi/src/WiFiGeneric.h b/libraries/WiFi/src/WiFiGeneric.h index ccab20d73be40a829002289b75041d6dce29a24e..d9e69d4d2c46e41d882edea11c6a75789af2764c 100644 --- a/libraries/WiFi/src/WiFiGeneric.h +++ b/libraries/WiFi/src/WiFiGeneric.h @@ -23,29 +23,86 @@ #ifndef ESP32WIFIGENERIC_H_ #define ESP32WIFIGENERIC_H_ -#include -#include +#include "esp_err.h" +#include "esp_event.h" #include #include "WiFiType.h" #include "IPAddress.h" -#include +#include "esp_smartconfig.h" +#include "wifi_provisioning/manager.h" -typedef struct -{ - wifi_prov_cb_event_t event; - void *event_data; -}wifi_prov_event_t; - -typedef struct -{ - wifi_prov_event_t *prov_event; - system_event_t *sys_event; -}system_prov_event_t; +ESP_EVENT_DECLARE_BASE(ARDUINO_EVENTS); -typedef void (*WiFiEventCb)(system_event_id_t event); -typedef std::function WiFiEventFuncCb; -typedef void (*WiFiEventSysCb)(system_event_t *event); -typedef void (*WiFiProvEventCb)(system_event_t *sys_event, wifi_prov_event_t *prov_event); +typedef enum { + ARDUINO_EVENT_WIFI_READY = 0, + ARDUINO_EVENT_WIFI_SCAN_DONE, + ARDUINO_EVENT_WIFI_STA_START, + ARDUINO_EVENT_WIFI_STA_STOP, + ARDUINO_EVENT_WIFI_STA_CONNECTED, + ARDUINO_EVENT_WIFI_STA_DISCONNECTED, + ARDUINO_EVENT_WIFI_STA_AUTHMODE_CHANGE, + ARDUINO_EVENT_WIFI_STA_GOT_IP, + ARDUINO_EVENT_WIFI_STA_GOT_IP6, + ARDUINO_EVENT_WIFI_STA_LOST_IP, + ARDUINO_EVENT_WIFI_AP_START, + ARDUINO_EVENT_WIFI_AP_STOP, + ARDUINO_EVENT_WIFI_AP_STACONNECTED, + ARDUINO_EVENT_WIFI_AP_STADISCONNECTED, + ARDUINO_EVENT_WIFI_AP_STAIPASSIGNED, + ARDUINO_EVENT_WIFI_AP_PROBEREQRECVED, + ARDUINO_EVENT_WIFI_AP_GOT_IP6, + ARDUINO_EVENT_ETH_START, + ARDUINO_EVENT_ETH_STOP, + ARDUINO_EVENT_ETH_CONNECTED, + ARDUINO_EVENT_ETH_DISCONNECTED, + ARDUINO_EVENT_ETH_GOT_IP, + ARDUINO_EVENT_ETH_GOT_IP6, + ARDUINO_EVENT_WPS_ER_SUCCESS, + ARDUINO_EVENT_WPS_ER_FAILED, + ARDUINO_EVENT_WPS_ER_TIMEOUT, + ARDUINO_EVENT_WPS_ER_PIN, + ARDUINO_EVENT_WPS_ER_PBC_OVERLAP, + ARDUINO_EVENT_SC_SCAN_DONE, + ARDUINO_EVENT_SC_FOUND_CHANNEL, + ARDUINO_EVENT_SC_GOT_SSID_PSWD, + ARDUINO_EVENT_SC_SEND_ACK_DONE, + ARDUINO_EVENT_PROV_INIT, + ARDUINO_EVENT_PROV_DEINIT, + ARDUINO_EVENT_PROV_START, + ARDUINO_EVENT_PROV_END, + ARDUINO_EVENT_PROV_CRED_RECV, + ARDUINO_EVENT_PROV_CRED_FAIL, + ARDUINO_EVENT_PROV_CRED_SUCCESS, + ARDUINO_EVENT_MAX +} arduino_event_id_t; + +typedef union { + wifi_event_sta_scan_done_t wifi_scan_done; + wifi_event_sta_authmode_change_t wifi_sta_authmode_change; + wifi_event_sta_connected_t wifi_sta_connected; + wifi_event_sta_disconnected_t wifi_sta_disconnected; + wifi_event_sta_wps_er_pin_t wps_er_pin; + wifi_event_sta_wps_fail_reason_t wps_fail_reason; + wifi_event_ap_probe_req_rx_t wifi_ap_probereqrecved; + wifi_event_ap_staconnected_t wifi_ap_staconnected; + wifi_event_ap_stadisconnected_t wifi_ap_stadisconnected; + ip_event_ap_staipassigned_t wifi_ap_staipassigned; + ip_event_got_ip_t got_ip; + ip_event_got_ip6_t got_ip6; + smartconfig_event_got_ssid_pswd_t sc_got_ssid_pswd; + esp_eth_handle_t eth_connected; + wifi_sta_config_t prov_cred_recv; + wifi_prov_sta_fail_reason_t prov_fail_reason; +} arduino_event_info_t; + +typedef struct{ + arduino_event_id_t event_id; + arduino_event_info_t event_info; +} arduino_event_t; + +typedef void (*WiFiEventCb)(arduino_event_id_t event); +typedef std::function WiFiEventFuncCb; +typedef void (*WiFiEventSysCb)(arduino_event_t *event); typedef size_t wifi_event_id_t; @@ -85,12 +142,11 @@ class WiFiGenericClass public: WiFiGenericClass(); - wifi_event_id_t onEvent(WiFiEventCb cbEvent, system_event_id_t event = SYSTEM_EVENT_MAX); - wifi_event_id_t onEvent(WiFiEventFuncCb cbEvent, system_event_id_t event = SYSTEM_EVENT_MAX); - wifi_event_id_t onEvent(WiFiEventSysCb cbEvent, system_event_id_t event = SYSTEM_EVENT_MAX); - wifi_event_id_t onEvent(WiFiProvEventCb cbEvent, system_event_id_t event = SYSTEM_EVENT_MAX); - void removeEvent(WiFiEventCb cbEvent, system_event_id_t event = SYSTEM_EVENT_MAX); - void removeEvent(WiFiEventSysCb cbEvent, system_event_id_t event = SYSTEM_EVENT_MAX); + wifi_event_id_t onEvent(WiFiEventCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX); + wifi_event_id_t onEvent(WiFiEventFuncCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX); + wifi_event_id_t onEvent(WiFiEventSysCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX); + void removeEvent(WiFiEventCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX); + void removeEvent(WiFiEventSysCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX); void removeEvent(wifi_event_id_t id); static int getStatusBits(); @@ -114,7 +170,10 @@ class WiFiGenericClass bool setTxPower(wifi_power_t power); wifi_power_t getTxPower(); - static esp_err_t _eventCallback(void *arg, system_event_t *event, wifi_prov_event_t *prov_event=NULL); + static const char * getHostname(); + static void setHostname(const char * hostname); + + static esp_err_t _eventCallback(arduino_event_t *event); protected: static bool _persistent; diff --git a/libraries/WiFi/src/WiFiSTA.cpp b/libraries/WiFi/src/WiFiSTA.cpp index 183cb6f6ad3dc2f22dde822bf29d1cb7c11df31b..a3cab0a0e5791d306a45cca67a0654f36a5bdb3a 100644 --- a/libraries/WiFi/src/WiFiSTA.cpp +++ b/libraries/WiFi/src/WiFiSTA.cpp @@ -48,6 +48,9 @@ extern "C" { // ---------------------------------------------------- Private functions ------------------------------------------------ // ----------------------------------------------------------------------------------------------------------------------- +esp_netif_t* get_esp_interface_netif(esp_interface_t interface); +esp_err_t set_esp_interface_dns(esp_interface_t interface, IPAddress main_dns=IPAddress(), IPAddress backup_dns=IPAddress(), IPAddress fallback_dns=IPAddress()); +esp_err_t set_esp_interface_ip(esp_interface_t interface, IPAddress local_ip=IPAddress(), IPAddress gateway=IPAddress(), IPAddress subnet=IPAddress()); static bool sta_config_equal(const wifi_config_t& lhs, const wifi_config_t& rhs); @@ -65,6 +68,36 @@ static bool sta_config_equal(const wifi_config_t& lhs, const wifi_config_t& rhs) return true; } +static void wifi_sta_config(wifi_config_t * wifi_config, const char * ssid=NULL, const char * password=NULL, const uint8_t * bssid=NULL, uint8_t channel=0, wifi_scan_method_t scan_method=WIFI_ALL_CHANNEL_SCAN, wifi_sort_method_t sort_method=WIFI_CONNECT_AP_BY_SIGNAL, uint16_t listen_interval=0, bool pmf_required=false){ + wifi_config->sta.channel = channel; + wifi_config->sta.listen_interval = listen_interval; + wifi_config->sta.scan_method = scan_method;//WIFI_ALL_CHANNEL_SCAN or WIFI_FAST_SCAN + wifi_config->sta.sort_method = sort_method;//WIFI_CONNECT_AP_BY_SIGNAL or WIFI_CONNECT_AP_BY_SECURITY + wifi_config->sta.threshold.rssi = -75; + wifi_config->sta.pmf_cfg.capable = true; + wifi_config->sta.pmf_cfg.required = pmf_required; + wifi_config->sta.bssid_set = 0; + memset(wifi_config->sta.bssid, 0, 6); + wifi_config->sta.threshold.authmode = WIFI_AUTH_OPEN; + wifi_config->sta.ssid[0] = 0; + wifi_config->sta.password[0] = 0; + if(ssid != NULL && ssid[0] != 0){ + snprintf((char*)wifi_config->sta.ssid, 32, ssid); + if(password != NULL && password[0] != 0){ + wifi_config->sta.threshold.authmode = WIFI_AUTH_WEP; + if(strlen(password) == 64){ + memcpy((char*)wifi_config->sta.password, password, 64); + } else { + snprintf((char*)wifi_config->sta.password, 64, password); + } + } + if(bssid != NULL){ + wifi_config->sta.bssid_set = 1; + memcpy(wifi_config->sta.bssid, bssid, 6); + } + } +} + // ----------------------------------------------------------------------------------------------------------------------- // ---------------------------------------------------- STA function ----------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------------- @@ -144,42 +177,43 @@ wl_status_t WiFiSTAClass::begin(const char* ssid, const char *passphrase, int32_ } } - if(bssid) { - conf.sta.bssid_set = 1; - memcpy((void *) &conf.sta.bssid[0], (void *) bssid, 6); - } + wifi_config_t current_conf; + wifi_sta_config(&conf, ssid, passphrase, bssid, channel); - if(channel > 0 && channel <= 13) { - conf.sta.channel = channel; + if(esp_wifi_get_config(ESP_IF_WIFI_STA, ¤t_conf) != ESP_OK){ + log_e("get current config failed!"); + return WL_CONNECT_FAILED; } - - wifi_config_t current_conf; - esp_wifi_get_config(WIFI_IF_STA, ¤t_conf); if(!sta_config_equal(current_conf, conf)) { if(esp_wifi_disconnect()){ log_e("disconnect failed!"); return WL_CONNECT_FAILED; } - esp_wifi_set_config(WIFI_IF_STA, &conf); + if(esp_wifi_set_config(ESP_IF_WIFI_STA, &conf) != ESP_OK){ + log_e("set config failed!"); + return WL_CONNECT_FAILED; + } } else if(status() == WL_CONNECTED){ return WL_CONNECTED; } else { - esp_wifi_set_config(WIFI_IF_STA, &conf); + if(esp_wifi_set_config(ESP_IF_WIFI_STA, &conf) != ESP_OK){ + log_e("set config failed!"); + return WL_CONNECT_FAILED; + } } - if(!_useStaticIp) { - if(tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA) == ESP_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED){ - log_e("dhcp client start failed!"); + if(!_useStaticIp){ + if(set_esp_interface_ip(ESP_IF_WIFI_STA) != ESP_OK) { return WL_CONNECT_FAILED; } - } else { - tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA); } - if(connect && esp_wifi_connect()) { - log_e("connect failed!"); - return WL_CONNECT_FAILED; + if(connect){ + if(esp_wifi_connect() != ESP_OK) { + log_e("connect failed!"); + return WL_CONNECT_FAILED; + } } return status(); @@ -203,23 +237,22 @@ wl_status_t WiFiSTAClass::begin() } wifi_config_t current_conf; - if(esp_wifi_get_config(WIFI_IF_STA, ¤t_conf) != ESP_OK || esp_wifi_set_config(WIFI_IF_STA, ¤t_conf) != ESP_OK) { + if(esp_wifi_get_config(ESP_IF_WIFI_STA, ¤t_conf) != ESP_OK || esp_wifi_set_config(ESP_IF_WIFI_STA, ¤t_conf) != ESP_OK) { log_e("config failed"); return WL_CONNECT_FAILED; } - if(!_useStaticIp) { - if(tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA) == ESP_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED){ - log_e("dhcp client start failed!"); - return WL_CONNECT_FAILED; - } - } else { - tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA); + if(!_useStaticIp && set_esp_interface_ip(ESP_IF_WIFI_STA) != ESP_OK) { + log_e("set ip failed!"); + return WL_CONNECT_FAILED; } - if(status() != WL_CONNECTED && esp_wifi_connect()){ - log_e("connect failed!"); - return WL_CONNECT_FAILED; + if(status() != WL_CONNECTED){ + esp_err_t err = esp_wifi_connect(); + if(err){ + log_e("connect failed! 0x%x", err); + return WL_CONNECT_FAILED; + } } return status(); @@ -247,11 +280,11 @@ bool WiFiSTAClass::reconnect() bool WiFiSTAClass::disconnect(bool wifioff, bool eraseap) { wifi_config_t conf; + wifi_sta_config(&conf); if(WiFi.getMode() & WIFI_MODE_STA){ if(eraseap){ - memset(&conf, 0, sizeof(wifi_config_t)); - if(esp_wifi_set_config(WIFI_IF_STA, &conf)){ + if(esp_wifi_set_config(ESP_IF_WIFI_STA, &conf)){ log_e("clear config failed!"); } } @@ -283,58 +316,11 @@ bool WiFiSTAClass::config(IPAddress local_ip, IPAddress gateway, IPAddress subne if(!WiFi.enableSTA(true)) { return false; } - - tcpip_adapter_ip_info_t info; - - if(local_ip != (uint32_t)0x00000000 && local_ip != INADDR_NONE){ - info.ip.addr = static_cast(local_ip); - info.gw.addr = static_cast(gateway); - info.netmask.addr = static_cast(subnet); - } else { - info.ip.addr = 0; - info.gw.addr = 0; - info.netmask.addr = 0; - } - - err = tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA); - if(err != ESP_OK && err != ESP_ERR_TCPIP_ADAPTER_DHCP_ALREADY_STOPPED){ - log_e("DHCP could not be stopped! Error: %d", err); - return false; - } - - err = tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_STA, &info); - if(err != ERR_OK){ - log_e("STA IP could not be configured! Error: %d", err); - return false; - } - - if(info.ip.addr){ - _useStaticIp = true; - } else { - err = tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA); - if(err == ESP_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED){ - log_e("dhcp client start failed!"); - return false; - } - _useStaticIp = false; - } - - ip_addr_t d; - d.type = IPADDR_TYPE_V4; - - if(dns1 != (uint32_t)0x00000000 && dns1 != INADDR_NONE) { - // Set DNS1-Server - d.u_addr.ip4.addr = static_cast(dns1); - dns_setserver(0, &d); - } - - if(dns2 != (uint32_t)0x00000000 && dns2 != INADDR_NONE) { - // Set DNS2-Server - d.u_addr.ip4.addr = static_cast(dns2); - dns_setserver(1, &d); + err = set_esp_interface_ip(ESP_IF_WIFI_STA, local_ip, gateway, subnet); + if(err == ESP_OK){ + err = set_esp_interface_dns(ESP_IF_WIFI_STA, dns1, dns2); } - - return true; + return err == ESP_OK; } /** @@ -355,9 +341,6 @@ bool WiFiSTAClass::isConnected() */ bool WiFiSTAClass::setAutoConnect(bool autoConnect) { - /*bool ret; - ret = esp_wifi_set_auto_connect(autoConnect); - return ret;*/ return false;//now deprecated } @@ -368,9 +351,6 @@ bool WiFiSTAClass::setAutoConnect(bool autoConnect) */ bool WiFiSTAClass::getAutoConnect() { - /*bool autoConnect; - esp_wifi_get_auto_connect(&autoConnect); - return autoConnect;*/ return false;//now deprecated } @@ -412,8 +392,11 @@ IPAddress WiFiSTAClass::localIP() if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return IPAddress(); } - tcpip_adapter_ip_info_t ip; - tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &ip); + esp_netif_ip_info_t ip; + if(esp_netif_get_ip_info(get_esp_interface_netif(ESP_IF_WIFI_STA), &ip) != ESP_OK){ + log_e("Netif Get IP Failed!"); + return IPAddress(); + } return IPAddress(ip.ip.addr); } @@ -426,7 +409,7 @@ IPAddress WiFiSTAClass::localIP() uint8_t* WiFiSTAClass::macAddress(uint8_t* mac) { if(WiFiGenericClass::getMode() != WIFI_MODE_NULL){ - esp_wifi_get_mac(WIFI_IF_STA, mac); + esp_wifi_get_mac(ESP_IF_WIFI_STA, mac); } else{ esp_read_mac(mac, ESP_MAC_WIFI_STA); @@ -446,7 +429,7 @@ String WiFiSTAClass::macAddress(void) esp_read_mac(mac, ESP_MAC_WIFI_STA); } else{ - esp_wifi_get_mac(WIFI_IF_STA, mac); + esp_wifi_get_mac(ESP_IF_WIFI_STA, mac); } sprintf(macStr, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); return String(macStr); @@ -461,8 +444,11 @@ IPAddress WiFiSTAClass::subnetMask() if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return IPAddress(); } - tcpip_adapter_ip_info_t ip; - tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &ip); + esp_netif_ip_info_t ip; + if(esp_netif_get_ip_info(get_esp_interface_netif(ESP_IF_WIFI_STA), &ip) != ESP_OK){ + log_e("Netif Get IP Failed!"); + return IPAddress(); + } return IPAddress(ip.netmask.addr); } @@ -475,8 +461,11 @@ IPAddress WiFiSTAClass::gatewayIP() if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return IPAddress(); } - tcpip_adapter_ip_info_t ip; - tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &ip); + esp_netif_ip_info_t ip; + if(esp_netif_get_ip_info(get_esp_interface_netif(ESP_IF_WIFI_STA), &ip) != ESP_OK){ + log_e("Netif Get IP Failed!"); + return IPAddress(); + } return IPAddress(ip.gw.addr); } @@ -503,8 +492,11 @@ IPAddress WiFiSTAClass::broadcastIP() if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return IPAddress(); } - tcpip_adapter_ip_info_t ip; - tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &ip); + esp_netif_ip_info_t ip; + if(esp_netif_get_ip_info(get_esp_interface_netif(ESP_IF_WIFI_STA), &ip) != ESP_OK){ + log_e("Netif Get IP Failed!"); + return IPAddress(); + } return WiFiGenericClass::calculateBroadcast(IPAddress(ip.gw.addr), IPAddress(ip.netmask.addr)); } @@ -517,8 +509,11 @@ IPAddress WiFiSTAClass::networkID() if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return IPAddress(); } - tcpip_adapter_ip_info_t ip; - tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &ip); + esp_netif_ip_info_t ip; + if(esp_netif_get_ip_info(get_esp_interface_netif(ESP_IF_WIFI_STA), &ip) != ESP_OK){ + log_e("Netif Get IP Failed!"); + return IPAddress(); + } return WiFiGenericClass::calculateNetworkID(IPAddress(ip.gw.addr), IPAddress(ip.netmask.addr)); } @@ -531,8 +526,11 @@ uint8_t WiFiSTAClass::subnetCIDR() if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return (uint8_t)0; } - tcpip_adapter_ip_info_t ip; - tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &ip); + esp_netif_ip_info_t ip; + if(esp_netif_get_ip_info(get_esp_interface_netif(ESP_IF_WIFI_STA), &ip) != ESP_OK){ + log_e("Netif Get IP Failed!"); + return IPAddress(); + } return WiFiGenericClass::calculateSubnetCIDR(IPAddress(ip.netmask.addr)); } @@ -562,7 +560,7 @@ String WiFiSTAClass::psk() const return String(); } wifi_config_t conf; - esp_wifi_get_config(WIFI_IF_STA, &conf); + esp_wifi_get_config(ESP_IF_WIFI_STA, &conf); return String(reinterpret_cast(conf.sta.password)); } @@ -654,7 +652,7 @@ bool WiFiSTAClass::enableIpV6() if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return false; } - return tcpip_adapter_create_ip6_linklocal(TCPIP_ADAPTER_IF_STA) == 0; + return esp_netif_create_ip6_linklocal(get_esp_interface_netif(ESP_IF_WIFI_STA)) == ESP_OK; } /** @@ -663,11 +661,11 @@ bool WiFiSTAClass::enableIpV6() */ IPv6Address WiFiSTAClass::localIPv6() { - static ip6_addr_t addr; + esp_ip6_addr_t addr; if(WiFiGenericClass::getMode() == WIFI_MODE_NULL){ return IPv6Address(); } - if(tcpip_adapter_get_ip6_linklocal(TCPIP_ADAPTER_IF_STA, &addr)){ + if(esp_netif_get_ip6_linklocal(get_esp_interface_netif(ESP_IF_WIFI_STA), &addr)) { return IPv6Address(); } return IPv6Address(addr.addr); @@ -679,6 +677,7 @@ bool WiFiSTAClass::_smartConfigDone = false; bool WiFiSTAClass::beginSmartConfig() { + esp_err_t err; if (_smartConfigStarted) { return false; } @@ -686,23 +685,22 @@ bool WiFiSTAClass::beginSmartConfig() { if (!WiFi.mode(WIFI_STA)) { return false; } - esp_wifi_disconnect(); - esp_err_t err; -#ifdef ESP_IDF_VERSION_MAJOR - esp_event_handler_register(SC_EVENT, ESP_EVENT_ANY_ID, _smartConfigCallback, this); smartconfig_start_config_t conf = SMARTCONFIG_START_CONFIG_DEFAULT(); + err = esp_smartconfig_set_type(SC_TYPE_ESPTOUCH); + if (err != ESP_OK) { + log_e("SmartConfig Set Type Failed!"); + return false; + } err = esp_smartconfig_start(&conf); -#else - err = esp_smartconfig_start(reinterpret_cast(&WiFiSTAClass::_smartConfigCallback), 1); -#endif - if (err == ESP_OK) { - _smartConfigStarted = true; - _smartConfigDone = false; - return true; + if (err != ESP_OK) { + log_e("SmartConfig Start Failed!"); + return false; } - return false; + _smartConfigStarted = true; + _smartConfigDone = false; + return true; } bool WiFiSTAClass::stopSmartConfig() { @@ -725,79 +723,3 @@ bool WiFiSTAClass::smartConfigDone() { return _smartConfigDone; } - -#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG -const char * sc_type_strings[] = { - "ESPTOUCH", - "AIRKISS", - "ESPTOUCH_AIRKISS" -}; -#endif - - -#ifdef ESP_IDF_VERSION_MAJOR //todo -void WiFiSTAClass::_smartConfigCallback(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data){ - smartconfig_event_t event = (smartconfig_event_t)event_id; - switch(event){ - case SC_EVENT_SCAN_DONE: - log_d("smartconfig has finished to scan for APs"); - break; - case SC_EVENT_FOUND_CHANNEL: - log_d("smartconfig has found the channel of the target AP"); - break; - case SC_EVENT_GOT_SSID_PSWD: - { - log_d("smartconfig got the SSID and password"); - smartconfig_event_got_ssid_pswd_t * data = (smartconfig_event_got_ssid_pswd_t*)event_data; - log_d("Type: %s", sc_type_strings[data->type]); - log_d("SSID: %s", (const char *)data->ssid); - log_d("Password: %s", (const char *)data->password); - log_d("Sender IP: " IPSTR, data->cellphone_ip[3], data->cellphone_ip[2], data->cellphone_ip[1], data->cellphone_ip[0]); - WiFi.begin((const char *)data->ssid, (const char *)data->password); - } - break; - case SC_EVENT_SEND_ACK_DONE: - log_d("smartconfig has sent ACK to the sender"); - WiFi.stopSmartConfig(); - break; - default: break; - } -} -#else - -#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG -const char * sc_status_strings[] = { - "WAIT", - "FIND_CHANNEL", - "GETTING_SSID_PSWD", - "LINK", - "LINK_OVER" -}; -#endif - -void WiFiSTAClass::_smartConfigCallback(uint32_t st, void* result) { - smartconfig_status_t status = (smartconfig_status_t) st; - log_d("Status: %s", sc_status_strings[st % 5]); - if (status == SC_STATUS_GETTING_SSID_PSWD) { -#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG - smartconfig_type_t * type = (smartconfig_type_t *)result; - log_d("Type: %s", sc_type_strings[*type % 3]); -#endif - } else if (status == SC_STATUS_LINK) { - wifi_sta_config_t *sta_conf = reinterpret_cast(result); - log_d("SSID: %s", (char *)(sta_conf->ssid)); - sta_conf->bssid_set = 0; - esp_wifi_set_config(WIFI_IF_STA, (wifi_config_t *)sta_conf); - esp_wifi_connect(); - _smartConfigDone = true; - } else if (status == SC_STATUS_LINK_OVER) { - if(result){ -#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG - ip4_addr_t * ip = (ip4_addr_t *)result; - log_d("Sender IP: " IPSTR, IP2STR(ip)); -#endif - } - WiFi.stopSmartConfig(); - } -} -#endif diff --git a/libraries/WiFi/src/WiFiSTA.h b/libraries/WiFi/src/WiFiSTA.h index c8065bab1aff4e08275f003ccabd8f95bca6fc3f..e9f000805730b9601e2051a0244e36d69275fff6 100644 --- a/libraries/WiFi/src/WiFiSTA.h +++ b/libraries/WiFi/src/WiFiSTA.h @@ -100,14 +100,9 @@ public: bool stopSmartConfig(); bool smartConfigDone(); + static bool _smartConfigDone; protected: static bool _smartConfigStarted; - static bool _smartConfigDone; -#ifdef ESP_IDF_VERSION_MAJOR //todo - static void _smartConfigCallback(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data); -#else - static void _smartConfigCallback(uint32_t status, void* result); -#endif }; diff --git a/libraries/WiFi/src/WiFiScan.cpp b/libraries/WiFi/src/WiFiScan.cpp index af897996051059130be6763dec3ea8b9d20ce0af..f34badb16dce4ede718252ff556e80b0572c91cf 100644 --- a/libraries/WiFi/src/WiFiScan.cpp +++ b/libraries/WiFi/src/WiFiScan.cpp @@ -42,6 +42,33 @@ extern "C" { #include "lwip/err.h" } +static const char * cipher_str(int cipher) +{ + switch (cipher) { + case WIFI_CIPHER_TYPE_NONE: + return ("NONE"); + break; + case WIFI_CIPHER_TYPE_WEP40: + return ("WEP40"); + break; + case WIFI_CIPHER_TYPE_WEP104: + return ("WEP104"); + break; + case WIFI_CIPHER_TYPE_TKIP: + return ("TKIP"); + break; + case WIFI_CIPHER_TYPE_CCMP: + return ("CCMP"); + break; + case WIFI_CIPHER_TYPE_TKIP_CCMP: + return ("TKIP_CCMP"); + break; + default: + break; + } + return ("UNKNOWN"); +} + bool WiFiScanClass::_scanAsync = false; uint32_t WiFiScanClass::_scanStarted = 0; uint32_t WiFiScanClass::_scanTimeout = 10000; diff --git a/libraries/WiFiProv/examples/WiFiProv/WiFiProv.ino b/libraries/WiFiProv/examples/WiFiProv/WiFiProv.ino index f118316c0c2e5ca87cd5a38d6772ef2dcdce449a..5fe3268cb9dc3316ca86604089ad0590bb901b44 100644 --- a/libraries/WiFiProv/examples/WiFiProv/WiFiProv.ino +++ b/libraries/WiFiProv/examples/WiFiProv/WiFiProv.ino @@ -1,52 +1,41 @@ -#include "WiFiProv.h" -void SysProvEvent(system_event_t *sys_event,wifi_prov_event_t *prov_event) +#include "WiFi.h" +void SysProvEvent(arduino_event_t *sys_event) { - if(sys_event) { - switch (sys_event->event_id) { - case SYSTEM_EVENT_STA_GOT_IP: - Serial.print("\nConnected IP address : "); - Serial.println(IPAddress(sys_event->event_info.got_ip.ip_info.ip.addr)); - break; - case SYSTEM_EVENT_STA_DISCONNECTED: - Serial.println("\nDisconnected. Connecting to the AP again... "); - break; - default: - break; - } + switch (sys_event->event_id) { + case ARDUINO_EVENT_WIFI_STA_GOT_IP: + Serial.print("\nConnected IP address : "); + Serial.println(IPAddress(sys_event->event_info.got_ip.ip_info.ip.addr)); + break; + case ARDUINO_EVENT_WIFI_STA_DISCONNECTED: + Serial.println("\nDisconnected. Connecting to the AP again... "); + break; + case ARDUINO_EVENT_PROV_START: + Serial.println("\nProvisioning started\nGive Credentials of your access point using \" Android app \""); + break; + case ARDUINO_EVENT_PROV_CRED_RECV: { + Serial.println("\nReceived Wi-Fi credentials"); + Serial.print("\tSSID : "); + Serial.println((const char *) sys_event->event_info.prov_cred_recv.ssid); + Serial.print("\tPassword : "); + Serial.println((char const *) sys_event->event_info.prov_cred_recv.password); + break; } - - if(prov_event) { - switch (prov_event->event) { - case WIFI_PROV_START: - Serial.println("\nProvisioning started\nGive Credentials of your access point using \" Android app \""); - break; - case WIFI_PROV_CRED_RECV: { - Serial.println("\nReceived Wi-Fi credentials"); - wifi_sta_config_t *wifi_sta_cfg = (wifi_sta_config_t *)prov_event->event_data; - Serial.print("\tSSID : "); - Serial.println((const char *) wifi_sta_cfg->ssid); - Serial.print("\tPassword : "); - Serial.println((char const *) wifi_sta_cfg->password); - break; - } - case WIFI_PROV_CRED_FAIL: { - wifi_prov_sta_fail_reason_t *reason = (wifi_prov_sta_fail_reason_t *)prov_event->event_data; - Serial.println("\nProvisioning failed!\nPlease reset to factory and retry provisioning\n"); - if(*reason == WIFI_PROV_STA_AUTH_ERROR) - Serial.println("\nWi-Fi AP password incorrect"); - else - Serial.println("\nWi-Fi AP not found....Add API \" nvs_flash_erase() \" before beginProvision()"); - break; - } - case WIFI_PROV_CRED_SUCCESS: - Serial.println("\nProvisioning Successful"); - break; - case WIFI_PROV_END: - Serial.println("\nProvisioning Ends"); - break; - default: - break; - } + case ARDUINO_EVENT_PROV_CRED_FAIL: { + Serial.println("\nProvisioning failed!\nPlease reset to factory and retry provisioning\n"); + if(sys_event->event_info.prov_fail_reason == WIFI_PROV_STA_AUTH_ERROR) + Serial.println("\nWi-Fi AP password incorrect"); + else + Serial.println("\nWi-Fi AP not found....Add API \" nvs_flash_erase() \" before beginProvision()"); + break; + } + case ARDUINO_EVENT_PROV_CRED_SUCCESS: + Serial.println("\nProvisioning Successful"); + break; + case ARDUINO_EVENT_PROV_END: + Serial.println("\nProvisioning Ends"); + break; + default: + break; } } @@ -56,8 +45,8 @@ void setup() { /* uint8_t uuid[16] = {0xb4, 0xdf, 0x5a, 0x1c, 0x3f, 0x6b, 0xf4, 0xbf, 0xea, 0x4a, 0x82, 0x03, 0x04, 0x90, 0x1a, 0x02 };*/ WiFi.onEvent(SysProvEvent); - //WiFi.beginProvision(provSchemeBLE, WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BTDM, WIFI_PROV_SECURITY_1, "abcd1234", "PROV_XXX", NULL, NULL); - WiFi.beginProvision(provSchemeSoftAP, WIFI_PROV_EVENT_HANDLER_NONE, WIFI_PROV_SECURITY_1, "abcd1234", "SOFTAP_XXX", NULL, NULL); + //WiFi.beginProvision(WIFI_PROV_SCHEME_BLE, WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BTDM, WIFI_PROV_SECURITY_1, "abcd1234", "PROV_XXX", NULL, NULL); + WiFi.beginProvision(WIFI_PROV_SCHEME_SOFTAP, WIFI_PROV_EVENT_HANDLER_NONE, WIFI_PROV_SECURITY_1, "abcd1234", "SOFTAP_XXX", NULL, NULL); } void loop() { diff --git a/libraries/WiFiProv/src/WiFiProv.cpp b/libraries/WiFiProv/src/WiFiProv.cpp index cf43ad1fd044bb80aba523453fe2eef6abfc3a3c..acf76270d89fa8030f77608e59b14c9828cb5255 100644 --- a/libraries/WiFiProv/src/WiFiProv.cpp +++ b/libraries/WiFiProv/src/WiFiProv.cpp @@ -24,115 +24,107 @@ #include #include #include -#include +#include #include -#include +#include +#if CONFIG_IDF_TARGET_ESP32 +#include "wifi_provisioning/scheme_ble.h" +#endif #include #include #undef IPADDR_NONE -#include "WiFiProv.h" -#include "SimpleBLE.h" +#include "WiFi.h" -extern esp_err_t postToSysQueue(system_prov_event_t *); +bool wifiLowLevelInit(bool persistent); -static wifi_prov_mgr_config_t config; -static scheme_t prov_scheme; +#if CONFIG_IDF_TARGET_ESP32 static const uint8_t custom_service_uuid[16] = { 0xb4, 0xdf, 0x5a, 0x1c, 0x3f, 0x6b, 0xf4, 0xbf, 0xea, 0x4a, 0x82, 0x03, 0x04, 0x90, 0x1a, 0x02, }; +#endif #define SERV_NAME_PREFIX_PROV "PROV_" -void provSchemeBLE() -{ - prov_scheme = WIFI_PROV_SCHEME_BLE; - config.scheme = wifi_prov_scheme_ble; -} +bool WiFiProvClass::prov_enable = true; -void provSchemeSoftAP() +bool WiFiProvClass::isProvEnabled() { - prov_scheme = WIFI_PROV_SCHEME_SOFTAP; - config.scheme = wifi_prov_scheme_softap; + return prov_enable; } -static void prov_event_handler(void *user_data, wifi_prov_cb_event_t event, void *event_data) +static void get_device_service_name(prov_scheme_t prov_scheme, char *service_name, size_t max) { - if (!event) { - return; - } - - system_prov_event_t *sys_prov = (system_prov_event_t *)malloc(sizeof(system_prov_event_t)); - if(sys_prov == NULL) { - log_e("Malloc Failed"); - return; - } - - sys_prov->prov_event = (wifi_prov_event_t *)malloc(sizeof(wifi_prov_event_t)); - if(sys_prov->prov_event == NULL) { - log_e("Malloc Failed"); - free(sys_prov); - return; - } - - sys_prov->sys_event = (system_event_t *)malloc(sizeof(system_event_t)); - if(sys_prov->sys_event == NULL) { - log_e("Malloc Failed"); - free(sys_prov->prov_event); - free(sys_prov); - return; - } - - sys_prov->prov_event->event = event; - sys_prov->prov_event->event_data = event_data; - sys_prov->sys_event->event_id = SYSTEM_EVENT_MAX; - esp_err_t check = postToSysQueue(sys_prov); - if(check == ESP_FAIL) { - log_e("Provisioning event not send to queue"); - free(sys_prov->sys_event); - free(sys_prov->prov_event); - free(sys_prov); - } -} - -static void get_device_service_name(char *service_name, size_t max) -{ - uint8_t eth_mac[6]; - WiFi.macAddress(eth_mac); + uint8_t eth_mac[6] = {0,0,0,0,0,0}; + if(esp_wifi_get_mac(WIFI_IF_STA, eth_mac) != ESP_OK){ + log_e("esp_wifi_get_mac failed!"); + return; + } #if CONFIG_IDF_TARGET_ESP32 if(prov_scheme == WIFI_PROV_SCHEME_BLE) { snprintf(service_name, max, "%s%02X%02X%02X",SERV_NAME_PREFIX_BLE, eth_mac[3], eth_mac[4], eth_mac[5]); } else { #endif - snprintf(service_name, max, "%s%02X%02X%02X",SERV_NAME_PREFIX_WIFI, eth_mac[3], eth_mac[4], eth_mac[5]); + snprintf(service_name, max, "%s%02X%02X%02X",SERV_NAME_PREFIX_WIFI, eth_mac[3], eth_mac[4], eth_mac[5]); #if CONFIG_IDF_TARGET_ESP32 } #endif } -void WiFiProvClass :: beginProvision(void (*scheme_cb)(), wifi_prov_event_handler_t scheme_event_handler, wifi_prov_security_t security, const char * pop, const char *service_name, const char *service_key, uint8_t * uuid) +static esp_err_t custom_prov_data_handler(uint32_t session_id, const uint8_t *inbuf, ssize_t inlen, uint8_t **outbuf, ssize_t *outlen, void *priv_data){ + if (inbuf) { + log_d("Received data: %.*s", inlen, (char *)inbuf); + } + *outbuf = NULL; + *outlen = 0; + return ESP_OK; +} + +void WiFiProvClass :: beginProvision(prov_scheme_t prov_scheme, scheme_handler_t scheme_handler, wifi_prov_security_t security, const char * pop, const char *service_name, const char *service_key, uint8_t * uuid) { - WiFi.enableProv(true); + prov_enable = true; bool provisioned = false; - scheme_cb(); - config.scheme_event_handler = scheme_event_handler; - config.app_event_handler = { - .event_cb = prov_event_handler, - .user_data = NULL - }; + static char service_name_temp[32]; + wifi_prov_mgr_config_t config; #if CONFIG_IDF_TARGET_ESP32 if(prov_scheme == WIFI_PROV_SCHEME_BLE) { - config.scheme = wifi_prov_scheme_ble; + config.scheme = wifi_prov_scheme_ble; } else { #endif config.scheme = wifi_prov_scheme_softap; #if CONFIG_IDF_TARGET_ESP32 } + + if(scheme_handler == WIFI_PROV_SCHEME_HANDLER_NONE){ #endif - - wifi_prov_mgr_init(config); - WiFi.mode(WIFI_MODE_AP); - wifi_prov_mgr_is_provisioned(&provisioned); + wifi_prov_event_handler_t scheme_event_handler = WIFI_PROV_EVENT_HANDLER_NONE; + memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(wifi_prov_event_handler_t)); +#if CONFIG_IDF_TARGET_ESP32 + } else if(scheme_handler == WIFI_PROV_SCHEME_HANDLER_FREE_BTDM){ + wifi_prov_event_handler_t scheme_event_handler = WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BTDM; + memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(wifi_prov_event_handler_t)); + } else if(scheme_handler == WIFI_PROV_SCHEME_HANDLER_FREE_BT){ + wifi_prov_event_handler_t scheme_event_handler = WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BT; + memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(wifi_prov_event_handler_t)); + } else if(scheme_handler == WIFI_PROV_SCHEME_HANDLER_FREE_BLE){ + wifi_prov_event_handler_t scheme_event_handler = WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BLE; + memcpy(&config.scheme_event_handler, &scheme_event_handler, sizeof(wifi_prov_event_handler_t)); + } else { + log_e("Unknown scheme handler!"); + return; + } +#endif + + wifiLowLevelInit(true); + if(wifi_prov_mgr_init(config) != ESP_OK){ + log_e("wifi_prov_mgr_init failed!"); + return; + } + if(wifi_prov_mgr_is_provisioned(&provisioned) != ESP_OK){ + log_e("wifi_prov_mgr_is_provisioned failed!"); + wifi_prov_mgr_deinit(); + return; + } if(provisioned == false) { #if CONFIG_IDF_TARGET_ESP32 if(prov_scheme == WIFI_PROV_SCHEME_BLE) { @@ -145,38 +137,46 @@ void WiFiProvClass :: beginProvision(void (*scheme_cb)(), wifi_prov_event_handle #endif if(service_name == NULL) { - char service_name_temp[12]; - get_device_service_name(service_name_temp,sizeof(service_name_temp)); + get_device_service_name(prov_scheme, service_name_temp, 32); service_name = (const char *)service_name_temp; } #if CONFIG_IDF_TARGET_ESP32 if(prov_scheme == WIFI_PROV_SCHEME_BLE) { - log_i("Starting AP using BLE\n service_name : %s\n pop : %s",service_name,pop); + log_i("Starting AP using BLE. service_name : %s, pop : %s",service_name,pop); } else { #endif if(service_key == NULL) { - log_i("Starting AP using SOFTAP\n service_name : %s\n pop : %s",service_name,pop); - } else { - log_i("Starting AP using SOFTAP\n service_name : %s\n password : %s\n pop : %s",service_name,service_key,pop); + log_i("Starting provisioning AP using SOFTAP. service_name : %s, pop : %s",service_name,pop); + } else { + log_i("Starting provisioning AP using SOFTAP. service_name : %s, password : %s, pop : %s",service_name,service_key,pop); } #if CONFIG_IDF_TARGET_ESP32 } #endif - - wifi_prov_mgr_start_provisioning(security,pop,service_name,service_key); + if(wifi_prov_mgr_endpoint_create("custom-data") != ESP_OK){ + log_e("wifi_prov_mgr_endpoint_create failed!"); + return; + } + if(wifi_prov_mgr_start_provisioning(security, pop, service_name, service_key) != ESP_OK){ + log_e("wifi_prov_mgr_start_provisioning failed!"); + return; + } + if(wifi_prov_mgr_endpoint_register("custom-data", custom_prov_data_handler, NULL) != ESP_OK){ + log_e("wifi_prov_mgr_endpoint_register failed!"); + return; + } } else { wifi_prov_mgr_deinit(); - WiFi.mode(WIFI_MODE_STA); - log_i("Already Provisioned, starting Wi-Fi STA"); + log_i("Aleardy Provisioned"); #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO - wifi_config_t conf; + static wifi_config_t conf; esp_wifi_get_config(WIFI_IF_STA,&conf); - log_i("SSID : %s\n",conf.sta.ssid); + log_i("Attempting connect to AP: %s\n",conf.sta.ssid); #endif - log_i("CONNECTING TO THE ACCESS POINT : "); - WiFi.begin(); + esp_wifi_start(); + WiFi.begin(); } } -WiFiProvClass WiFiProv; + diff --git a/libraries/WiFiProv/src/WiFiProv.h b/libraries/WiFiProv/src/WiFiProv.h index 89b6315ed67eb7bec1665f30998450c2e33e40b7..c3c7dabfae81f190285cb47cf5317f15c73c3a24 100644 --- a/libraries/WiFiProv/src/WiFiProv.h +++ b/libraries/WiFiProv/src/WiFiProv.h @@ -1,4 +1,4 @@ -/* + /* WiFiProv.h - Base class for provisioning support All right reserved. @@ -19,30 +19,38 @@ #include "WiFi.h" #include "wifi_provisioning/manager.h" -#include "wifi_provisioning/scheme_ble.h" + //Select the scheme using which you want to provision -typedef enum -{ +typedef enum { + WIFI_PROV_SCHEME_SOFTAP, +#if CONFIG_IDF_TARGET_ESP32 WIFI_PROV_SCHEME_BLE, - WIFI_PROV_SCHEME_SOFTAP -}scheme_t; +#endif + WIFI_PROV_SCHEME_MAX +} prov_scheme_t; -extern void provSchemeSoftAP(); -extern void provSchemeBLE(); +typedef enum { + WIFI_PROV_SCHEME_HANDLER_NONE, +#if CONFIG_IDF_TARGET_ESP32 + WIFI_PROV_SCHEME_HANDLER_FREE_BTDM, + WIFI_PROV_SCHEME_HANDLER_FREE_BLE, + WIFI_PROV_SCHEME_HANDLER_FREE_BT, +#endif + WIFI_PROV_SCHEME_HANDLER_MAX +} scheme_handler_t; //Provisioning class class WiFiProvClass { + protected: + static bool prov_enable; + public: + WiFiProvClass() { + prov_enable = false; + } - void beginProvision(void (*scheme_cb)() = provSchemeSoftAP, wifi_prov_event_handler_t scheme_event_handler = WIFI_PROV_EVENT_HANDLER_NONE, wifi_prov_security_t security = WIFI_PROV_SECURITY_1, const char * pop = "abcd1234", const char * service_name = NULL, const char * service_key = NULL, uint8_t *uuid = NULL); + bool isProvEnabled(); + void beginProvision(prov_scheme_t prov_scheme = WIFI_PROV_SCHEME_SOFTAP, scheme_handler_t scheme_handler = WIFI_PROV_SCHEME_HANDLER_NONE, + wifi_prov_security_t security = WIFI_PROV_SECURITY_1, const char * pop = "abcd1234", const char * service_name = NULL, const char * service_key = NULL, uint8_t *uuid = NULL); }; -extern WiFiProvClass WiFiProv; -/* - Event Handler for BLE - - WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BTDM - - WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BLE - - WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BT -Event Handler for SOFTAP - - WIFI_PROV_EVENT_HANDLER_NONE -*/