|
@@ -1,1365 +0,0 @@
|
|
|
-/**************************************************************
|
|
|
- AsyncWiFiManager is a library for the ESP8266/Arduino platform
|
|
|
- (https://github.com/esp8266/Arduino) to enable easy
|
|
|
- configuration and reconfiguration of WiFi credentials using a Captive Portal
|
|
|
- inspired by:
|
|
|
- http://www.esp8266.com/viewtopic.php?f=29&t=2520
|
|
|
- https://github.com/chriscook8/esp-arduino-apboot
|
|
|
- https://github.com/esp8266/Arduino/tree/esp8266/hardware/esp8266com/esp8266/libraries/DNSServer/examples/CaptivePortalAdvanced
|
|
|
- Built by AlexT https://github.com/tzapu
|
|
|
- Ported to Async Web Server by https://github.com/alanswx
|
|
|
- Licensed under MIT license
|
|
|
- **************************************************************/
|
|
|
-
|
|
|
-#include "ESPAsyncWiFiManager.h"
|
|
|
-
|
|
|
-AsyncWiFiManagerParameter::AsyncWiFiManagerParameter(const char *custom)
|
|
|
-{
|
|
|
- _id = NULL;
|
|
|
- _placeholder = NULL;
|
|
|
- _length = 0;
|
|
|
- _value = NULL;
|
|
|
-
|
|
|
- _customHTML = custom;
|
|
|
-}
|
|
|
-
|
|
|
-AsyncWiFiManagerParameter::AsyncWiFiManagerParameter(const char *id,
|
|
|
- const char *placeholder,
|
|
|
- const char *defaultValue,
|
|
|
- unsigned int length)
|
|
|
-{
|
|
|
- init(id, placeholder, defaultValue, length, "");
|
|
|
-}
|
|
|
-
|
|
|
-AsyncWiFiManagerParameter::AsyncWiFiManagerParameter(const char *id,
|
|
|
- const char *placeholder,
|
|
|
- const char *defaultValue,
|
|
|
- unsigned int length,
|
|
|
- const char *custom)
|
|
|
-{
|
|
|
- init(id, placeholder, defaultValue, length, custom);
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManagerParameter::init(const char *id,
|
|
|
- const char *placeholder,
|
|
|
- const char *defaultValue,
|
|
|
- unsigned int length,
|
|
|
- const char *custom)
|
|
|
-{
|
|
|
- _id = id;
|
|
|
- _placeholder = placeholder;
|
|
|
- _length = length;
|
|
|
- _value = new char[length + 1];
|
|
|
-
|
|
|
- for (unsigned int i = 0; i < length; i++)
|
|
|
- {
|
|
|
- _value[i] = 0;
|
|
|
- }
|
|
|
- if (defaultValue != NULL)
|
|
|
- {
|
|
|
- strncpy(_value, defaultValue, length);
|
|
|
- }
|
|
|
-
|
|
|
- _customHTML = custom;
|
|
|
-}
|
|
|
-
|
|
|
-const char *AsyncWiFiManagerParameter::getValue()
|
|
|
-{
|
|
|
- return _value;
|
|
|
-}
|
|
|
-const char *AsyncWiFiManagerParameter::getID()
|
|
|
-{
|
|
|
- return _id;
|
|
|
-}
|
|
|
-const char *AsyncWiFiManagerParameter::getPlaceholder()
|
|
|
-{
|
|
|
- return _placeholder;
|
|
|
-}
|
|
|
-unsigned int AsyncWiFiManagerParameter::getValueLength()
|
|
|
-{
|
|
|
- return _length;
|
|
|
-}
|
|
|
-const char *AsyncWiFiManagerParameter::getCustomHTML()
|
|
|
-{
|
|
|
- return _customHTML;
|
|
|
-}
|
|
|
-
|
|
|
-#ifdef USE_EADNS
|
|
|
-AsyncWiFiManager::AsyncWiFiManager(AsyncWebServer *server,
|
|
|
- AsyncDNSServer *dns) : server(server), dnsServer(dns)
|
|
|
-{
|
|
|
-#else
|
|
|
-AsyncWiFiManager::AsyncWiFiManager(AsyncWebServer *server,
|
|
|
- DNSServer *dns) : server(server), dnsServer(dns)
|
|
|
-{
|
|
|
-#endif
|
|
|
- wifiSSIDs = NULL;
|
|
|
- wifiSSIDscan = true;
|
|
|
- _modeless = false;
|
|
|
- shouldscan = true;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::addParameter(AsyncWiFiManagerParameter *p)
|
|
|
-{
|
|
|
- _params[_paramsCount] = p;
|
|
|
- _paramsCount++;
|
|
|
- DEBUG_WM(F("Adding parameter"));
|
|
|
- DEBUG_WM(p->getID());
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::setupConfigPortal()
|
|
|
-{
|
|
|
- // dnsServer.reset(new DNSServer());
|
|
|
- // server.reset(new ESP8266WebServer(80));
|
|
|
- server->reset();
|
|
|
-
|
|
|
- DEBUG_WM(F(""));
|
|
|
- _configPortalStart = millis();
|
|
|
-
|
|
|
- DEBUG_WM(F("Configuring access point... "));
|
|
|
- DEBUG_WM(_apName);
|
|
|
- if (_apPassword != NULL)
|
|
|
- {
|
|
|
- if (strlen(_apPassword) < 8 || strlen(_apPassword) > 63)
|
|
|
- {
|
|
|
- // fail passphrase to short or long!
|
|
|
- DEBUG_WM(F("Invalid AccessPoint password. Ignoring"));
|
|
|
- _apPassword = NULL;
|
|
|
- }
|
|
|
- DEBUG_WM(_apPassword);
|
|
|
- }
|
|
|
-
|
|
|
- // optional soft ip config
|
|
|
- if (_ap_static_ip)
|
|
|
- {
|
|
|
- DEBUG_WM(F("Custom AP IP/GW/Subnet"));
|
|
|
- WiFi.softAPConfig(_ap_static_ip, _ap_static_gw, _ap_static_sn);
|
|
|
- }
|
|
|
-
|
|
|
- if (_apPassword != NULL)
|
|
|
- {
|
|
|
- WiFi.softAP(_apName, _apPassword); // password option
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- WiFi.softAP(_apName);
|
|
|
- }
|
|
|
-
|
|
|
- delay(500); // without delay I've seen the IP address blank
|
|
|
- DEBUG_WM(F("AP IP address: "));
|
|
|
- DEBUG_WM(WiFi.softAPIP());
|
|
|
-
|
|
|
-// setup the DNS server redirecting all the domains to the apIP
|
|
|
-#ifdef USE_EADNS
|
|
|
- dnsServer->setErrorReplyCode(AsyncDNSReplyCode::NoError);
|
|
|
-#else
|
|
|
- dnsServer->setErrorReplyCode(DNSReplyCode::NoError);
|
|
|
-#endif
|
|
|
- if (!dnsServer->start(DNS_PORT, "*", WiFi.softAPIP()))
|
|
|
- {
|
|
|
- DEBUG_WM(F("Could not start Captive DNS Server!"));
|
|
|
- }
|
|
|
-
|
|
|
- setInfo();
|
|
|
-
|
|
|
- // setup web pages: root, wifi config pages, SO captive portal detectors and not found
|
|
|
- server->on("/",
|
|
|
- std::bind(&AsyncWiFiManager::handleRoot, this, std::placeholders::_1))
|
|
|
- .setFilter(ON_AP_FILTER);
|
|
|
- server->on("/wifi",
|
|
|
- std::bind(&AsyncWiFiManager::handleWifi, this, std::placeholders::_1, true))
|
|
|
- .setFilter(ON_AP_FILTER);
|
|
|
- server->on("/0wifi",
|
|
|
- std::bind(&AsyncWiFiManager::handleWifi, this, std::placeholders::_1, false))
|
|
|
- .setFilter(ON_AP_FILTER);
|
|
|
- server->on("/wifisave",
|
|
|
- std::bind(&AsyncWiFiManager::handleWifiSave, this, std::placeholders::_1))
|
|
|
- .setFilter(ON_AP_FILTER);
|
|
|
- server->on("/i",
|
|
|
- std::bind(&AsyncWiFiManager::handleInfo, this, std::placeholders::_1))
|
|
|
- .setFilter(ON_AP_FILTER);
|
|
|
- server->on("/r",
|
|
|
- std::bind(&AsyncWiFiManager::handleReset, this, std::placeholders::_1))
|
|
|
- .setFilter(ON_AP_FILTER);
|
|
|
- server->on("/fwlink",
|
|
|
- std::bind(&AsyncWiFiManager::handleRoot, this, std::placeholders::_1))
|
|
|
- .setFilter(ON_AP_FILTER); // Microsoft captive portal. Maybe not needed. Might be handled by notFound handler.
|
|
|
- server->onNotFound(std::bind(&AsyncWiFiManager::handleNotFound, this, std::placeholders::_1));
|
|
|
- server->begin(); // web server start
|
|
|
- DEBUG_WM(F("HTTP server started"));
|
|
|
-}
|
|
|
-
|
|
|
-static const char HEX_CHAR_ARRAY[17] = "0123456789ABCDEF";
|
|
|
-
|
|
|
-#if !defined(ESP8266)
|
|
|
-/**
|
|
|
-* convert char array (hex values) to readable string by seperator
|
|
|
-* buf: buffer to convert
|
|
|
-* length: data length
|
|
|
-* strSeperator seperator between each hex value
|
|
|
-* return: formated value as String
|
|
|
-*/
|
|
|
-static String byteToHexString(uint8_t *buf, uint8_t length, String strSeperator = "-")
|
|
|
-{
|
|
|
- String dataString = "";
|
|
|
- for (uint8_t i = 0; i < length; i++)
|
|
|
- {
|
|
|
- byte v = buf[i] / 16;
|
|
|
- byte w = buf[i] % 16;
|
|
|
- if (i > 0)
|
|
|
- {
|
|
|
- dataString += strSeperator;
|
|
|
- }
|
|
|
- dataString += String(HEX_CHAR_ARRAY[v]);
|
|
|
- dataString += String(HEX_CHAR_ARRAY[w]);
|
|
|
- }
|
|
|
- dataString.toUpperCase();
|
|
|
- return dataString;
|
|
|
-} // byteToHexString
|
|
|
-
|
|
|
-String getESP32ChipID()
|
|
|
-{
|
|
|
- uint64_t chipid;
|
|
|
- chipid = ESP.getEfuseMac(); // the chip ID is essentially its MAC address (length: 6 bytes)
|
|
|
- uint8_t chipid_size = 6;
|
|
|
- uint8_t chipid_arr[chipid_size];
|
|
|
- for (uint8_t i = 0; i < chipid_size; i++)
|
|
|
- {
|
|
|
- chipid_arr[i] = (chipid >> (8 * i)) & 0xff;
|
|
|
- }
|
|
|
- return byteToHexString(chipid_arr, chipid_size, "");
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-boolean AsyncWiFiManager::autoConnect(unsigned long maxConnectRetries,
|
|
|
- unsigned long retryDelayMs)
|
|
|
-{
|
|
|
- String ssid = "ESP";
|
|
|
-#if defined(ESP8266)
|
|
|
- ssid += String(ESP.getChipId());
|
|
|
-#else
|
|
|
- ssid += getESP32ChipID();
|
|
|
-#endif
|
|
|
- return autoConnect(ssid.c_str(), NULL);
|
|
|
-}
|
|
|
-
|
|
|
-boolean AsyncWiFiManager::autoConnect(char const *apName,
|
|
|
- char const *apPassword,
|
|
|
- unsigned long maxConnectRetries,
|
|
|
- unsigned long retryDelayMs)
|
|
|
-{
|
|
|
- DEBUG_WM(F(""));
|
|
|
-
|
|
|
- // attempt to connect; should it fail, fall back to AP
|
|
|
- WiFi.mode(WIFI_STA);
|
|
|
-
|
|
|
- for (unsigned long tryNumber = 0; tryNumber < maxConnectRetries; tryNumber++)
|
|
|
- {
|
|
|
- DEBUG_WM(F("AutoConnect Try No.:"));
|
|
|
- DEBUG_WM(tryNumber);
|
|
|
-
|
|
|
- if (connectWifi("", "") == WL_CONNECTED)
|
|
|
- {
|
|
|
- DEBUG_WM(F("IP Address:"));
|
|
|
- DEBUG_WM(WiFi.localIP());
|
|
|
- if (_connectcallback!=NULL){
|
|
|
- _connectcallback();
|
|
|
- }
|
|
|
- // connected
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- if (tryNumber + 1 < maxConnectRetries)
|
|
|
- {
|
|
|
- // we might connect during the delay
|
|
|
- unsigned long restDelayMs = retryDelayMs;
|
|
|
- while (restDelayMs != 0)
|
|
|
- {
|
|
|
- if (WiFi.status() == WL_CONNECTED)
|
|
|
- {
|
|
|
- DEBUG_WM(F("IP Address (connected during delay):"));
|
|
|
- DEBUG_WM(WiFi.localIP());
|
|
|
- if (_connectcallback!=NULL){
|
|
|
- _connectcallback();
|
|
|
- }
|
|
|
- return true;
|
|
|
- }
|
|
|
- unsigned long thisDelay = std::min(restDelayMs, 100ul);
|
|
|
- delay(thisDelay);
|
|
|
- restDelayMs -= thisDelay;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return startConfigPortal(apName, apPassword);
|
|
|
-}
|
|
|
-
|
|
|
-String AsyncWiFiManager::networkListAsString()
|
|
|
-{
|
|
|
- String pager;
|
|
|
- // display networks in page
|
|
|
- for (int i = 0; i < wifiSSIDCount; i++)
|
|
|
- {
|
|
|
- if (wifiSSIDs[i].duplicate == true)
|
|
|
- {
|
|
|
- continue; // skip dups
|
|
|
- }
|
|
|
- unsigned int quality = getRSSIasQuality(wifiSSIDs[i].RSSI);
|
|
|
-
|
|
|
- if (_minimumQuality == 0 || _minimumQuality < quality)
|
|
|
- {
|
|
|
- String item = FPSTR(HTTP_ITEM);
|
|
|
- String rssiQ;
|
|
|
- rssiQ += quality;
|
|
|
- item.replace("{v}", wifiSSIDs[i].SSID);
|
|
|
- item.replace("{r}", rssiQ);
|
|
|
-#if defined(ESP8266)
|
|
|
- if (wifiSSIDs[i].encryptionType != ENC_TYPE_NONE)
|
|
|
- {
|
|
|
-#else
|
|
|
- if (wifiSSIDs[i].encryptionType != WIFI_AUTH_OPEN)
|
|
|
- {
|
|
|
-#endif
|
|
|
- item.replace("{i}", "l");
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- item.replace("{i}", "");
|
|
|
- }
|
|
|
- pager += item;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- DEBUG_WM(F("Skipping due to quality"));
|
|
|
- }
|
|
|
- }
|
|
|
- return pager;
|
|
|
-}
|
|
|
-
|
|
|
-String AsyncWiFiManager::scanModal()
|
|
|
-{
|
|
|
- shouldscan = true;
|
|
|
- scan();
|
|
|
- String pager = networkListAsString();
|
|
|
- return pager;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::scan(boolean async)
|
|
|
-{
|
|
|
- if (!shouldscan)
|
|
|
- {
|
|
|
- return;
|
|
|
- }
|
|
|
- DEBUG_WM(F("About to scan()"));
|
|
|
- if (wifiSSIDscan)
|
|
|
- {
|
|
|
- wifi_ssid_count_t n = WiFi.scanNetworks(async);
|
|
|
- copySSIDInfo(n);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::copySSIDInfo(wifi_ssid_count_t n)
|
|
|
-{
|
|
|
- if (n == WIFI_SCAN_FAILED)
|
|
|
- {
|
|
|
- DEBUG_WM(F("scanNetworks returned: WIFI_SCAN_FAILED!"));
|
|
|
- }
|
|
|
- else if (n == WIFI_SCAN_RUNNING)
|
|
|
- {
|
|
|
- DEBUG_WM(F("scanNetworks returned: WIFI_SCAN_RUNNING!"));
|
|
|
- }
|
|
|
- else if (n < 0)
|
|
|
- {
|
|
|
- DEBUG_WM(F("scanNetworks failed with unknown error code!"));
|
|
|
- }
|
|
|
- else if (n == 0)
|
|
|
- {
|
|
|
- DEBUG_WM(F("No networks found"));
|
|
|
- // page += F("No networks found. Refresh to scan again.");
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- DEBUG_WM(F("Scan done"));
|
|
|
- }
|
|
|
-
|
|
|
- if (n > 0)
|
|
|
- {
|
|
|
- // WE SHOULD MOVE THIS IN PLACE ATOMICALLY
|
|
|
- if (wifiSSIDs)
|
|
|
- {
|
|
|
- delete[] wifiSSIDs;
|
|
|
- }
|
|
|
- wifiSSIDs = new WiFiResult[n];
|
|
|
- wifiSSIDCount = n;
|
|
|
-
|
|
|
- if (n > 0)
|
|
|
- {
|
|
|
- shouldscan = false;
|
|
|
- }
|
|
|
- for (wifi_ssid_count_t i = 0; i < n; i++)
|
|
|
- {
|
|
|
- wifiSSIDs[i].duplicate = false;
|
|
|
-
|
|
|
-#if defined(ESP8266)
|
|
|
- WiFi.getNetworkInfo(i,
|
|
|
- wifiSSIDs[i].SSID,
|
|
|
- wifiSSIDs[i].encryptionType,
|
|
|
- wifiSSIDs[i].RSSI,
|
|
|
- wifiSSIDs[i].BSSID,
|
|
|
- wifiSSIDs[i].channel,
|
|
|
- wifiSSIDs[i].isHidden);
|
|
|
-#else
|
|
|
- WiFi.getNetworkInfo(i,
|
|
|
- wifiSSIDs[i].SSID,
|
|
|
- wifiSSIDs[i].encryptionType,
|
|
|
- wifiSSIDs[i].RSSI,
|
|
|
- wifiSSIDs[i].BSSID,
|
|
|
- wifiSSIDs[i].channel);
|
|
|
-#endif
|
|
|
- }
|
|
|
-
|
|
|
- // RSSI SORT
|
|
|
-
|
|
|
- // old sort
|
|
|
- for (int i = 0; i < n; i++)
|
|
|
- {
|
|
|
- for (int j = i + 1; j < n; j++)
|
|
|
- {
|
|
|
- if (wifiSSIDs[j].RSSI > wifiSSIDs[i].RSSI)
|
|
|
- {
|
|
|
- std::swap(wifiSSIDs[i], wifiSSIDs[j]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // remove duplicates ( must be RSSI sorted )
|
|
|
- if (_removeDuplicateAPs)
|
|
|
- {
|
|
|
- String cssid;
|
|
|
- for (int i = 0; i < n; i++)
|
|
|
- {
|
|
|
- if (wifiSSIDs[i].duplicate == true)
|
|
|
- {
|
|
|
- continue;
|
|
|
- }
|
|
|
- cssid = wifiSSIDs[i].SSID;
|
|
|
- for (int j = i + 1; j < n; j++)
|
|
|
- {
|
|
|
- if (cssid == wifiSSIDs[j].SSID)
|
|
|
- {
|
|
|
- DEBUG_WM("DUP AP: " + wifiSSIDs[j].SSID);
|
|
|
- wifiSSIDs[j].duplicate = true; // set dup aps to NULL
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::startConfigPortalModeless(char const *apName, char const *apPassword)
|
|
|
-{
|
|
|
- _modeless = true;
|
|
|
- _apName = apName;
|
|
|
- _apPassword = apPassword;
|
|
|
-
|
|
|
- /*
|
|
|
- AJS - do we want this?
|
|
|
- */
|
|
|
-
|
|
|
- // setup AP
|
|
|
- WiFi.mode(WIFI_AP_STA);
|
|
|
- DEBUG_WM(F("SET AP STA"));
|
|
|
-
|
|
|
- // try to connect
|
|
|
- if (connectWifi("", "") == WL_CONNECTED)
|
|
|
- {
|
|
|
- DEBUG_WM(F("IP Address:"));
|
|
|
- DEBUG_WM(WiFi.localIP());
|
|
|
- if (_connectcallback!=NULL){
|
|
|
- _connectcallback();
|
|
|
- }
|
|
|
- // connected
|
|
|
- // call the callback!
|
|
|
- if (_savecallback != NULL)
|
|
|
- {
|
|
|
- // TODO: check if any custom parameters actually exist, and check if they really changed maybe
|
|
|
- _savecallback();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // notify we entered AP mode
|
|
|
- if (_apcallback != NULL)
|
|
|
- {
|
|
|
- _apcallback(this);
|
|
|
- }
|
|
|
-
|
|
|
- connect = false;
|
|
|
- setupConfigPortal();
|
|
|
- scannow = 0;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::loop()
|
|
|
-{
|
|
|
- safeLoop();
|
|
|
- criticalLoop();
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::setInfo()
|
|
|
-{
|
|
|
- if (needInfo)
|
|
|
- {
|
|
|
- pager = infoAsString();
|
|
|
- wifiStatus = WiFi.status();
|
|
|
- needInfo = false;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-// anything that accesses WiFi, ESP or EEPROM goes here
|
|
|
-void AsyncWiFiManager::criticalLoop()
|
|
|
-{
|
|
|
- if (_modeless)
|
|
|
- {
|
|
|
- if (scannow == 0 || millis() - scannow >= 60000)
|
|
|
- {
|
|
|
- scannow = millis();
|
|
|
- scan(true);
|
|
|
- }
|
|
|
-
|
|
|
- wifi_ssid_count_t n = WiFi.scanComplete();
|
|
|
- if (n >= 0)
|
|
|
- {
|
|
|
- copySSIDInfo(n);
|
|
|
- WiFi.scanDelete();
|
|
|
- }
|
|
|
-
|
|
|
- if (connect)
|
|
|
- {
|
|
|
- connect = false;
|
|
|
- //delay(2000);
|
|
|
- DEBUG_WM(F("Connecting to new AP"));
|
|
|
-
|
|
|
- // using user-provided _ssid, _pass in place of system-stored ssid and pass
|
|
|
- if (connectWifi(_ssid, _pass) != WL_CONNECTED)
|
|
|
- {
|
|
|
- DEBUG_WM(F("Failed to connect"));
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- // connected
|
|
|
- // alanswx - should we have a config to decide if we should shut down AP?
|
|
|
- // WiFi.mode(WIFI_STA);
|
|
|
- // notify that configuration has changed and any optional parameters should be saved
|
|
|
- if (_savecallback != NULL)
|
|
|
- {
|
|
|
- // TODO: check if any custom parameters actually exist, and check if they really changed maybe
|
|
|
- _savecallback();
|
|
|
- }
|
|
|
-
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (_shouldBreakAfterConfig)
|
|
|
- {
|
|
|
- // flag set to exit after config after trying to connect
|
|
|
- // notify that configuration has changed and any optional parameters should be saved
|
|
|
- if (_savecallback != NULL)
|
|
|
- {
|
|
|
- // TODO: check if any custom parameters actually exist, and check if they really changed maybe
|
|
|
- _savecallback();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-// anything that doesn't access WiFi, ESP or EEPROM can go here
|
|
|
-void AsyncWiFiManager::safeLoop()
|
|
|
-{
|
|
|
-#ifndef USE_EADNS
|
|
|
- dnsServer->processNextRequest();
|
|
|
-#endif
|
|
|
-}
|
|
|
-
|
|
|
-boolean AsyncWiFiManager::startConfigPortal(char const *apName, char const *apPassword)
|
|
|
-{
|
|
|
- // setup AP
|
|
|
- WiFi.mode(WIFI_AP_STA);
|
|
|
- DEBUG_WM(F("SET AP STA"));
|
|
|
-
|
|
|
- _apName = apName;
|
|
|
- _apPassword = apPassword;
|
|
|
- bool connectedDuringConfigPortal = false;
|
|
|
-
|
|
|
- // notify we entered AP mode
|
|
|
- if (_apcallback != NULL)
|
|
|
- {
|
|
|
- _apcallback(this);
|
|
|
- }
|
|
|
-
|
|
|
- connect = false;
|
|
|
- setupConfigPortal();
|
|
|
- scannow = 0;
|
|
|
- while (_configPortalTimeout == 0 || millis() - _configPortalStart < _configPortalTimeout)
|
|
|
- {
|
|
|
-// DNS
|
|
|
-#ifndef USE_EADNS
|
|
|
- dnsServer->processNextRequest();
|
|
|
-#endif
|
|
|
- //
|
|
|
- // we should do a scan every so often here and
|
|
|
- // try to reconnect to AP while we are at it
|
|
|
- //
|
|
|
- if (scannow == 0 || millis() - scannow >= 10000)
|
|
|
- {
|
|
|
- DEBUG_WM(F("About to scan()"));
|
|
|
- shouldscan = true; // since we are modal, we can scan every time
|
|
|
-#if defined(ESP8266)
|
|
|
- // we might still be connecting, so that has to stop for scanning
|
|
|
- ETS_UART_INTR_DISABLE();
|
|
|
- wifi_station_disconnect();
|
|
|
- ETS_UART_INTR_ENABLE();
|
|
|
-#else
|
|
|
- WiFi.disconnect(false);
|
|
|
-#endif
|
|
|
- scanModal();
|
|
|
- if (_tryConnectDuringConfigPortal)
|
|
|
- {
|
|
|
- WiFi.begin(); // try to reconnect to AP
|
|
|
- connectedDuringConfigPortal = true;
|
|
|
- }
|
|
|
- scannow = millis();
|
|
|
- }
|
|
|
-
|
|
|
- // attempts to reconnect were successful
|
|
|
- if (WiFi.status() == WL_CONNECTED)
|
|
|
- {
|
|
|
- // connected
|
|
|
- WiFi.mode(WIFI_STA);
|
|
|
- // notify that configuration has changed and any optional parameters should be saved
|
|
|
- // configuraton should not be saved when just connected using stored ssid and password during config portal
|
|
|
- if (!connectedDuringConfigPortal && _savecallback != NULL)
|
|
|
- {
|
|
|
- // TODO: check if any custom parameters actually exist, and check if they really changed maybe
|
|
|
- _savecallback();
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- if (connect)
|
|
|
- {
|
|
|
- connect = false;
|
|
|
- delay(2000);
|
|
|
- DEBUG_WM(F("Connecting to new AP"));
|
|
|
-
|
|
|
- // using user-provided _ssid, _pass in place of system-stored ssid and pass
|
|
|
- if (_tryConnectDuringConfigPortal and connectWifi(_ssid, _pass) == WL_CONNECTED)
|
|
|
- {
|
|
|
- // connected
|
|
|
- WiFi.mode(WIFI_STA);
|
|
|
- // notify that configuration has changed and any optional parameters should be saved
|
|
|
- if (_savecallback != NULL)
|
|
|
- {
|
|
|
- // TODO: check if any custom parameters actually exist, and check if they really changed maybe
|
|
|
- _savecallback();
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- if(_tryConnectDuringConfigPortal)
|
|
|
- DEBUG_WM(F("Failed to connect"));
|
|
|
- }
|
|
|
-
|
|
|
- if (_shouldBreakAfterConfig)
|
|
|
- {
|
|
|
- // flag set to exit after config after trying to connect
|
|
|
- // notify that configuration has changed and any optional parameters should be saved
|
|
|
- if (_savecallback != NULL)
|
|
|
- {
|
|
|
- // TODO: check if any custom parameters actually exist, and check if they really changed maybe
|
|
|
- _savecallback();
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- yield();
|
|
|
- }
|
|
|
-
|
|
|
- server->reset();
|
|
|
- dnsServer->stop();
|
|
|
-
|
|
|
- return WiFi.status() == WL_CONNECTED;
|
|
|
-}
|
|
|
-
|
|
|
-uint8_t AsyncWiFiManager::connectWifi(String ssid, String pass)
|
|
|
-{
|
|
|
- DEBUG_WM(F("Connecting as wifi client..."));
|
|
|
-
|
|
|
- // check if we've got static_ip settings, if we do, use those
|
|
|
- if (_sta_static_ip)
|
|
|
- {
|
|
|
- DEBUG_WM(F("Custom STA IP/GW/Subnet/DNS"));
|
|
|
- WiFi.config(_sta_static_ip, _sta_static_gw, _sta_static_sn, _sta_static_dns1, _sta_static_dns2);
|
|
|
- DEBUG_WM(WiFi.localIP());
|
|
|
- }
|
|
|
- // fix for auto connect racing issue
|
|
|
- // if (WiFi.status() == WL_CONNECTED) {
|
|
|
- // DEBUG_WM("Already connected. Bailing out.");
|
|
|
- // return WL_CONNECTED;
|
|
|
- // }
|
|
|
- // check if we have ssid and pass and force those, if not, try with last saved values
|
|
|
- if (ssid != "")
|
|
|
- {
|
|
|
-#if defined(ESP8266)
|
|
|
- // trying to fix connection in progress hanging
|
|
|
- ETS_UART_INTR_DISABLE();
|
|
|
- wifi_station_disconnect();
|
|
|
- ETS_UART_INTR_ENABLE();
|
|
|
-#else
|
|
|
- WiFi.disconnect(false);
|
|
|
-#endif
|
|
|
- WiFi.begin(ssid.c_str(), pass.c_str());
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- if (WiFi.SSID().length() > 0)
|
|
|
- {
|
|
|
- DEBUG_WM(F("Using last saved values, should be faster"));
|
|
|
-#if defined(ESP8266)
|
|
|
- // trying to fix connection in progress hanging
|
|
|
- ETS_UART_INTR_DISABLE();
|
|
|
- wifi_station_disconnect();
|
|
|
- ETS_UART_INTR_ENABLE();
|
|
|
-#else
|
|
|
- WiFi.disconnect(false);
|
|
|
-#endif
|
|
|
- WiFi.begin();
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- DEBUG_WM(F("Try to connect with saved credentials"));
|
|
|
- WiFi.begin();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- uint8_t connRes = waitForConnectResult();
|
|
|
- DEBUG_WM(F("Connection result: "));
|
|
|
- DEBUG_WM(connRes);
|
|
|
- // not connected, WPS enabled, no pass - first attempt
|
|
|
-#ifdef NO_EXTRA_4K_HEAP
|
|
|
- if (_tryWPS && connRes != WL_CONNECTED && pass == "")
|
|
|
- {
|
|
|
- startWPS();
|
|
|
- // should be connected at the end of WPS
|
|
|
- connRes = waitForConnectResult();
|
|
|
- }
|
|
|
-#endif
|
|
|
- needInfo = true;
|
|
|
- setInfo();
|
|
|
- return connRes;
|
|
|
-}
|
|
|
-
|
|
|
-uint8_t AsyncWiFiManager::waitForConnectResult()
|
|
|
-{
|
|
|
- if (_connectTimeout == 0)
|
|
|
- {
|
|
|
- return WiFi.waitForConnectResult();
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- DEBUG_WM(F("Waiting for connection result with time out"));
|
|
|
- unsigned long start = millis();
|
|
|
- boolean keepConnecting = true;
|
|
|
- uint8_t status;
|
|
|
- while (keepConnecting)
|
|
|
- {
|
|
|
- status = WiFi.status();
|
|
|
- if (millis() > start + _connectTimeout)
|
|
|
- {
|
|
|
- keepConnecting = false;
|
|
|
- DEBUG_WM(F("Connection timed out"));
|
|
|
- }
|
|
|
- if (status == WL_CONNECTED || status == WL_CONNECT_FAILED)
|
|
|
- {
|
|
|
- keepConnecting = false;
|
|
|
- }
|
|
|
- delay(100);
|
|
|
- }
|
|
|
- return status;
|
|
|
- }
|
|
|
-}
|
|
|
-#ifdef NO_EXTRA_4K_HEAP
|
|
|
-void AsyncWiFiManager::startWPS()
|
|
|
-{
|
|
|
- DEBUG_WM(F("START WPS"));
|
|
|
-#if defined(ESP8266)
|
|
|
- WiFi.beginWPSConfig();
|
|
|
-#else
|
|
|
- //esp_wps_config_t config = WPS_CONFIG_INIT_DEFAULT(ESP_WPS_MODE);
|
|
|
- esp_wps_config_t config = {};
|
|
|
- config.wps_type = ESP_WPS_MODE;
|
|
|
- config.crypto_funcs = &g_wifi_default_wps_crypto_funcs;
|
|
|
- strcpy(config.factory_info.manufacturer, "ESPRESSIF");
|
|
|
- strcpy(config.factory_info.model_number, "ESP32");
|
|
|
- strcpy(config.factory_info.model_name, "ESPRESSIF IOT");
|
|
|
- strcpy(config.factory_info.device_name, "ESP STATION");
|
|
|
-
|
|
|
- esp_wifi_wps_enable(&config);
|
|
|
- esp_wifi_wps_start(0);
|
|
|
-#endif
|
|
|
- DEBUG_WM(F("END WPS"));
|
|
|
-}
|
|
|
-#endif
|
|
|
-String AsyncWiFiManager::getConfigPortalSSID()
|
|
|
-{
|
|
|
- return _apName;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::resetSettings()
|
|
|
-{
|
|
|
- DEBUG_WM(F("settings invalidated"));
|
|
|
- DEBUG_WM(F("THIS MAY CAUSE AP NOT TO START UP PROPERLY. YOU NEED TO COMMENT IT OUT AFTER ERASING THE DATA."));
|
|
|
-
|
|
|
- WiFi.mode(WIFI_AP_STA); // cannot erase if not in STA mode !
|
|
|
- WiFi.persistent(true);
|
|
|
-#if defined(ESP8266)
|
|
|
- WiFi.disconnect(true);
|
|
|
-#else
|
|
|
- WiFi.disconnect(true, true);
|
|
|
-#endif
|
|
|
- WiFi.persistent(false);
|
|
|
-
|
|
|
- //delay(200);
|
|
|
-}
|
|
|
-void AsyncWiFiManager::setTimeout(unsigned long seconds)
|
|
|
-{
|
|
|
- setConfigPortalTimeout(seconds);
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::setConfigPortalTimeout(unsigned long seconds)
|
|
|
-{
|
|
|
- _configPortalTimeout = seconds * 1000;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::setConnectTimeout(unsigned long seconds)
|
|
|
-{
|
|
|
- _connectTimeout = seconds * 1000;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::setTryConnectDuringConfigPortal(boolean v)
|
|
|
-{
|
|
|
- _tryConnectDuringConfigPortal = v;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::setDebugOutput(boolean debug)
|
|
|
-{
|
|
|
- _debug = debug;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::setAPStaticIPConfig(IPAddress ip,
|
|
|
- IPAddress gw,
|
|
|
- IPAddress sn)
|
|
|
-{
|
|
|
- _ap_static_ip = ip;
|
|
|
- _ap_static_gw = gw;
|
|
|
- _ap_static_sn = sn;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::setSTAStaticIPConfig(IPAddress ip,
|
|
|
- IPAddress gw,
|
|
|
- IPAddress sn,
|
|
|
- IPAddress dns1,
|
|
|
- IPAddress dns2)
|
|
|
-{
|
|
|
- _sta_static_ip = ip;
|
|
|
- _sta_static_gw = gw;
|
|
|
- _sta_static_sn = sn;
|
|
|
- _sta_static_dns1 = dns1;
|
|
|
- _sta_static_dns2 = dns2;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::setMinimumSignalQuality(unsigned int quality)
|
|
|
-{
|
|
|
- _minimumQuality = quality;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::setBreakAfterConfig(boolean shouldBreak)
|
|
|
-{
|
|
|
- _shouldBreakAfterConfig = shouldBreak;
|
|
|
-}
|
|
|
-
|
|
|
-// handle root or redirect to captive portal
|
|
|
-void AsyncWiFiManager::handleRoot(AsyncWebServerRequest *request)
|
|
|
-{
|
|
|
- // AJS - maybe we should set a scan when we get to the root???
|
|
|
- // and only scan on demand? timer + on demand? plus a link to make it happen?
|
|
|
-
|
|
|
- shouldscan = true;
|
|
|
- scannow = 0;
|
|
|
- DEBUG_WM(F("Handle root"));
|
|
|
-
|
|
|
- if (captivePortal(request))
|
|
|
- {
|
|
|
- // if captive portal redirect instead of displaying the page
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- DEBUG_WM(F("Sending Captive Portal"));
|
|
|
-
|
|
|
- String page = FPSTR(WFM_HTTP_HEAD);
|
|
|
- page.replace("{v}", "Options");
|
|
|
- page += FPSTR(HTTP_SCRIPT);
|
|
|
- page += FPSTR(HTTP_STYLE);
|
|
|
- page += _customHeadElement;
|
|
|
- page += FPSTR(HTTP_HEAD_END);
|
|
|
- page += "<h1>";
|
|
|
- page += _apName;
|
|
|
- page += "</h1>";
|
|
|
- page += F("<h3>AsyncWiFiManager</h3>");
|
|
|
- page += FPSTR(HTTP_PORTAL_OPTIONS);
|
|
|
- page += _customOptionsElement;
|
|
|
- page += FPSTR(HTTP_END);
|
|
|
-
|
|
|
- request->send(200, "text/html", page);
|
|
|
- DEBUG_WM(F("Sent..."));
|
|
|
-}
|
|
|
-
|
|
|
-// wifi config page handler
|
|
|
-void AsyncWiFiManager::handleWifi(AsyncWebServerRequest *request, boolean scan)
|
|
|
-{
|
|
|
- shouldscan = true;
|
|
|
- scannow = 0;
|
|
|
-
|
|
|
- DEBUG_WM(F("Handle wifi"));
|
|
|
-
|
|
|
- String page = FPSTR(WFM_HTTP_HEAD);
|
|
|
- page.replace("{v}", "Config ESP");
|
|
|
- page += FPSTR(HTTP_SCRIPT);
|
|
|
- page += FPSTR(HTTP_STYLE);
|
|
|
- page += _customHeadElement;
|
|
|
- page += FPSTR(HTTP_HEAD_END);
|
|
|
-
|
|
|
- if (scan)
|
|
|
- {
|
|
|
- wifiSSIDscan = false;
|
|
|
-
|
|
|
- DEBUG_WM(F("Scan done"));
|
|
|
- if (wifiSSIDCount == 0)
|
|
|
- {
|
|
|
- DEBUG_WM(F("No networks found"));
|
|
|
- page += F("No networks found. Refresh to scan again");
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- // display networks in page
|
|
|
- String pager = networkListAsString();
|
|
|
- page += pager;
|
|
|
- page += "<br/>";
|
|
|
- }
|
|
|
- }
|
|
|
- wifiSSIDscan = true;
|
|
|
-
|
|
|
- page += FPSTR(HTTP_FORM_START);
|
|
|
- char parLength[2];
|
|
|
-
|
|
|
- // add the extra parameters to the form
|
|
|
- for (unsigned int i = 0; i < _paramsCount; i++)
|
|
|
- {
|
|
|
- if (_params[i] == NULL)
|
|
|
- {
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- String pitem = FPSTR(HTTP_FORM_PARAM);
|
|
|
- if (_params[i]->getID() != NULL)
|
|
|
- {
|
|
|
- pitem.replace("{i}", _params[i]->getID());
|
|
|
- pitem.replace("{n}", _params[i]->getID());
|
|
|
- pitem.replace("{p}", _params[i]->getPlaceholder());
|
|
|
- snprintf(parLength, 2, "%d", _params[i]->getValueLength());
|
|
|
- pitem.replace("{l}", parLength);
|
|
|
- pitem.replace("{v}", _params[i]->getValue());
|
|
|
- pitem.replace("{c}", _params[i]->getCustomHTML());
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- pitem = _params[i]->getCustomHTML();
|
|
|
- }
|
|
|
-
|
|
|
- page += pitem;
|
|
|
- }
|
|
|
- if (_params[0] != NULL)
|
|
|
- {
|
|
|
- page += "<br/>";
|
|
|
- }
|
|
|
- if (_sta_static_ip)
|
|
|
- {
|
|
|
- String item = FPSTR(HTTP_FORM_PARAM);
|
|
|
- item.replace("{i}", "ip");
|
|
|
- item.replace("{n}", "ip");
|
|
|
- item.replace("{p}", "Static IP");
|
|
|
- item.replace("{l}", "15");
|
|
|
- item.replace("{v}", _sta_static_ip.toString());
|
|
|
-
|
|
|
- page += item;
|
|
|
-
|
|
|
- item = FPSTR(HTTP_FORM_PARAM);
|
|
|
- item.replace("{i}", "gw");
|
|
|
- item.replace("{n}", "gw");
|
|
|
- item.replace("{p}", "Static Gateway");
|
|
|
- item.replace("{l}", "15");
|
|
|
- item.replace("{v}", _sta_static_gw.toString());
|
|
|
-
|
|
|
- page += item;
|
|
|
-
|
|
|
- item = FPSTR(HTTP_FORM_PARAM);
|
|
|
- item.replace("{i}", "sn");
|
|
|
- item.replace("{n}", "sn");
|
|
|
- item.replace("{p}", "Subnet");
|
|
|
- item.replace("{l}", "15");
|
|
|
- item.replace("{v}", _sta_static_sn.toString());
|
|
|
-
|
|
|
- page += item;
|
|
|
-
|
|
|
- item = FPSTR(HTTP_FORM_PARAM);
|
|
|
- item.replace("{i}", "dns1");
|
|
|
- item.replace("{n}", "dns1");
|
|
|
- item.replace("{p}", "DNS1");
|
|
|
- item.replace("{l}", "15");
|
|
|
- item.replace("{v}", _sta_static_dns1.toString());
|
|
|
-
|
|
|
- page += item;
|
|
|
-
|
|
|
- item = FPSTR(HTTP_FORM_PARAM);
|
|
|
- item.replace("{i}", "dns2");
|
|
|
- item.replace("{n}", "dns2");
|
|
|
- item.replace("{p}", "DNS2");
|
|
|
- item.replace("{l}", "15");
|
|
|
- item.replace("{v}", _sta_static_dns2.toString());
|
|
|
-
|
|
|
- page += item;
|
|
|
- page += "<br/>";
|
|
|
- }
|
|
|
- page += FPSTR(HTTP_FORM_END);
|
|
|
- page += FPSTR(HTTP_SCAN_LINK);
|
|
|
- page += FPSTR(HTTP_END);
|
|
|
-
|
|
|
- request->send(200, "text/html", page);
|
|
|
-
|
|
|
- DEBUG_WM(F("Sent config page"));
|
|
|
-}
|
|
|
-
|
|
|
-// handle the WLAN save form and redirect to WLAN config page again
|
|
|
-void AsyncWiFiManager::handleWifiSave(AsyncWebServerRequest *request)
|
|
|
-{
|
|
|
- DEBUG_WM(F("WiFi save"));
|
|
|
-
|
|
|
- // SAVE/connect here
|
|
|
- needInfo = true;
|
|
|
- _ssid = request->arg("s").c_str();
|
|
|
- _pass = request->arg("p").c_str();
|
|
|
-
|
|
|
- // parameters
|
|
|
- for (unsigned int i = 0; i < _paramsCount; i++)
|
|
|
- {
|
|
|
- if (_params[i] == NULL)
|
|
|
- {
|
|
|
- break;
|
|
|
- }
|
|
|
- // read parameter
|
|
|
- String value = request->arg(_params[i]->getID()).c_str();
|
|
|
- // store it in array
|
|
|
- value.toCharArray(_params[i]->_value, _params[i]->_length);
|
|
|
-
|
|
|
- DEBUG_WM(F("Parameter"));
|
|
|
- DEBUG_WM(_params[i]->getID());
|
|
|
- DEBUG_WM(value);
|
|
|
- }
|
|
|
-
|
|
|
- if (request->hasArg("ip"))
|
|
|
- {
|
|
|
- DEBUG_WM(F("static ip"));
|
|
|
- DEBUG_WM(request->arg("ip"));
|
|
|
- //_sta_static_ip.fromString(request->arg("ip"));
|
|
|
- String ip = request->arg("ip");
|
|
|
- optionalIPFromString(&_sta_static_ip, ip.c_str());
|
|
|
- }
|
|
|
- if (request->hasArg("gw"))
|
|
|
- {
|
|
|
- DEBUG_WM(F("static gateway"));
|
|
|
- DEBUG_WM(request->arg("gw"));
|
|
|
- String gw = request->arg("gw");
|
|
|
- optionalIPFromString(&_sta_static_gw, gw.c_str());
|
|
|
- }
|
|
|
- if (request->hasArg("sn"))
|
|
|
- {
|
|
|
- DEBUG_WM(F("static netmask"));
|
|
|
- DEBUG_WM(request->arg("sn"));
|
|
|
- String sn = request->arg("sn");
|
|
|
- optionalIPFromString(&_sta_static_sn, sn.c_str());
|
|
|
- }
|
|
|
- if (request->hasArg("dns1"))
|
|
|
- {
|
|
|
- DEBUG_WM(F("static DNS 1"));
|
|
|
- DEBUG_WM(request->arg("dns1"));
|
|
|
- String dns1 = request->arg("dns1");
|
|
|
- optionalIPFromString(&_sta_static_dns1, dns1.c_str());
|
|
|
- }
|
|
|
- if (request->hasArg("dns2"))
|
|
|
- {
|
|
|
- DEBUG_WM(F("static DNS 2"));
|
|
|
- DEBUG_WM(request->arg("dns2"));
|
|
|
- String dns2 = request->arg("dns2");
|
|
|
- optionalIPFromString(&_sta_static_dns2, dns2.c_str());
|
|
|
- }
|
|
|
-
|
|
|
- String page = FPSTR(WFM_HTTP_HEAD);
|
|
|
- page.replace("{v}", "Credentials Saved");
|
|
|
- page += FPSTR(HTTP_SCRIPT);
|
|
|
- page += FPSTR(HTTP_STYLE);
|
|
|
- page += _customHeadElement;
|
|
|
- page += F("<meta http-equiv=\"refresh\" content=\"5; url=/i\">");
|
|
|
- page += FPSTR(HTTP_HEAD_END);
|
|
|
- page += FPSTR(HTTP_SAVED);
|
|
|
- page += FPSTR(HTTP_END);
|
|
|
-
|
|
|
- request->send(200, "text/html", page);
|
|
|
-
|
|
|
- DEBUG_WM(F("Sent wifi save page"));
|
|
|
-
|
|
|
- connect = true; // signal ready to connect/reset
|
|
|
-}
|
|
|
-
|
|
|
-// handle the info page
|
|
|
-String AsyncWiFiManager::infoAsString()
|
|
|
-{
|
|
|
- String page;
|
|
|
- page += F("<dt>Chip ID</dt><dd>");
|
|
|
-#if defined(ESP8266)
|
|
|
- page += ESP.getChipId();
|
|
|
-#else
|
|
|
- page += getESP32ChipID();
|
|
|
-#endif
|
|
|
- page += F("</dd>");
|
|
|
- page += F("<dt>Flash Chip ID</dt><dd>");
|
|
|
-#if defined(ESP8266)
|
|
|
- page += ESP.getFlashChipId();
|
|
|
-#else
|
|
|
- page += F("N/A for ESP32");
|
|
|
-#endif
|
|
|
- page += F("</dd>");
|
|
|
- page += F("<dt>IDE Flash Size</dt><dd>");
|
|
|
- page += ESP.getFlashChipSize();
|
|
|
- page += F(" bytes</dd>");
|
|
|
- page += F("<dt>Real Flash Size</dt><dd>");
|
|
|
-#if defined(ESP8266)
|
|
|
- page += ESP.getFlashChipRealSize();
|
|
|
-#else
|
|
|
- page += F("N/A for ESP32");
|
|
|
-#endif
|
|
|
- page += F(" bytes</dd>");
|
|
|
- page += F("<dt>Soft AP IP</dt><dd>");
|
|
|
- page += WiFi.softAPIP().toString();
|
|
|
- page += F("</dd>");
|
|
|
- page += F("<dt>Soft AP MAC</dt><dd>");
|
|
|
- page += WiFi.softAPmacAddress();
|
|
|
- page += F("</dd>");
|
|
|
- page += F("<dt>Station SSID</dt><dd>");
|
|
|
- page += WiFi.SSID();
|
|
|
- page += F("</dd>");
|
|
|
- page += F("<dt>Station IP</dt><dd>");
|
|
|
- page += WiFi.localIP().toString();
|
|
|
- page += F("</dd>");
|
|
|
- page += F("<dt>Station MAC</dt><dd>");
|
|
|
- page += WiFi.macAddress();
|
|
|
- page += F("</dd>");
|
|
|
- page += F("</dl>");
|
|
|
- return page;
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::handleInfo(AsyncWebServerRequest *request)
|
|
|
-{
|
|
|
- DEBUG_WM(F("Info"));
|
|
|
-
|
|
|
- String page = FPSTR(WFM_HTTP_HEAD);
|
|
|
- page.replace("{v}", "Info");
|
|
|
- page += FPSTR(HTTP_SCRIPT);
|
|
|
- page += FPSTR(HTTP_STYLE);
|
|
|
- page += _customHeadElement;
|
|
|
- if (connect == true)
|
|
|
- {
|
|
|
- page += F("<meta http-equiv=\"refresh\" content=\"5; url=/i\">");
|
|
|
- }
|
|
|
- page += FPSTR(HTTP_HEAD_END);
|
|
|
- page += F("<dl>");
|
|
|
- if (connect == true)
|
|
|
- {
|
|
|
- page += F("<dt>Trying to connect</dt><dd>");
|
|
|
- page += wifiStatus;
|
|
|
- page += F("</dd>");
|
|
|
- }
|
|
|
- page += pager;
|
|
|
- page += FPSTR(HTTP_END);
|
|
|
-
|
|
|
- request->send(200, "text/html", page);
|
|
|
-
|
|
|
- DEBUG_WM(F("Sent info page"));
|
|
|
-}
|
|
|
-
|
|
|
-// handle the reset page
|
|
|
-void AsyncWiFiManager::handleReset(AsyncWebServerRequest *request)
|
|
|
-{
|
|
|
- DEBUG_WM(F("Reset"));
|
|
|
-
|
|
|
- String page = FPSTR(WFM_HTTP_HEAD);
|
|
|
- page.replace("{v}", "Info");
|
|
|
- page += FPSTR(HTTP_SCRIPT);
|
|
|
- page += FPSTR(HTTP_STYLE);
|
|
|
- page += _customHeadElement;
|
|
|
- page += FPSTR(HTTP_HEAD_END);
|
|
|
- page += F("Module will reset in a few seconds");
|
|
|
- page += FPSTR(HTTP_END);
|
|
|
- request->send(200, "text/html", page);
|
|
|
-
|
|
|
- DEBUG_WM(F("Sent reset page"));
|
|
|
- delay(5000);
|
|
|
-#if defined(ESP8266)
|
|
|
- ESP.reset();
|
|
|
-#else
|
|
|
- ESP.restart();
|
|
|
-#endif
|
|
|
- delay(2000);
|
|
|
-}
|
|
|
-
|
|
|
-void AsyncWiFiManager::handleNotFound(AsyncWebServerRequest *request)
|
|
|
-{
|
|
|
- DEBUG_WM(F("Handle not found"));
|
|
|
- if (captivePortal(request))
|
|
|
- {
|
|
|
- // if captive portal redirect instead of displaying the error page
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- String message = "File Not Found\n\n";
|
|
|
- message += "URI: ";
|
|
|
- message += request->url();
|
|
|
- message += "\nMethod: ";
|
|
|
- message += (request->method() == HTTP_GET) ? "GET" : "POST";
|
|
|
- message += "\nArguments: ";
|
|
|
- message += request->args();
|
|
|
- message += "\n";
|
|
|
-
|
|
|
- for (unsigned int i = 0; i < request->args(); i++)
|
|
|
- {
|
|
|
- message += " " + request->argName(i) + ": " + request->arg(i) + "\n";
|
|
|
- }
|
|
|
- AsyncWebServerResponse *response = request->beginResponse(404, "text/plain", message);
|
|
|
- response->addHeader("Cache-Control", "no-cache, no-store, must-revalidate");
|
|
|
- response->addHeader("Pragma", "no-cache");
|
|
|
- response->addHeader("Expires", "-1");
|
|
|
- request->send(response);
|
|
|
-}
|
|
|
-
|
|
|
-/** Redirect to captive portal if we got a request for another domain.
|
|
|
- * Return true in that case so the page handler do not try to handle the request again. */
|
|
|
-boolean AsyncWiFiManager::captivePortal(AsyncWebServerRequest *request)
|
|
|
-{
|
|
|
- if (!isIp(request->host()))
|
|
|
- {
|
|
|
- DEBUG_WM(F("Request redirected to captive portal"));
|
|
|
- AsyncWebServerResponse *response = request->beginResponse(302, "text/plain", "");
|
|
|
- response->addHeader("Location", String("http://") + toStringIp(request->client()->localIP()));
|
|
|
- request->send(response);
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-// start up config portal callback
|
|
|
-void AsyncWiFiManager::setAPCallback(std::function<void(AsyncWiFiManager *)> func)
|
|
|
-{
|
|
|
- _apcallback = func;
|
|
|
-}
|
|
|
-
|
|
|
-// start up save config callback
|
|
|
-void AsyncWiFiManager::setSaveConfigCallback(std::function<void()> func)
|
|
|
-{
|
|
|
- _savecallback = func;
|
|
|
-}
|
|
|
-void AsyncWiFiManager::setConnectCallback(std::function<void()> func)
|
|
|
-{
|
|
|
- _connectcallback = func;
|
|
|
-}
|
|
|
-
|
|
|
-// sets a custom element to add to head, like a new style tag
|
|
|
-void AsyncWiFiManager::setCustomHeadElement(const char *element)
|
|
|
-{
|
|
|
- _customHeadElement = element;
|
|
|
-}
|
|
|
-
|
|
|
-// sets a custom element to add to options page
|
|
|
-void AsyncWiFiManager::setCustomOptionsElement(const char *element)
|
|
|
-{
|
|
|
- _customOptionsElement = element;
|
|
|
-}
|
|
|
-
|
|
|
-// if this is true, remove duplicated Access Points - defaut true
|
|
|
-void AsyncWiFiManager::setRemoveDuplicateAPs(boolean removeDuplicates)
|
|
|
-{
|
|
|
- _removeDuplicateAPs = removeDuplicates;
|
|
|
-}
|
|
|
-
|
|
|
-template <typename Generic>
|
|
|
-void AsyncWiFiManager::DEBUG_WM(Generic text)
|
|
|
-{
|
|
|
- if (_debug)
|
|
|
- {
|
|
|
- Serial.print(F("*WM: "));
|
|
|
- Serial.println(text);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-unsigned int AsyncWiFiManager::getRSSIasQuality(int RSSI)
|
|
|
-{
|
|
|
- unsigned int quality = 0;
|
|
|
-
|
|
|
- if (RSSI <= -100)
|
|
|
- {
|
|
|
- quality = 0;
|
|
|
- }
|
|
|
- else if (RSSI >= -50)
|
|
|
- {
|
|
|
- quality = 100;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- quality = 2 * (RSSI + 100);
|
|
|
- }
|
|
|
- return quality;
|
|
|
-}
|
|
|
-
|
|
|
-// is this an IP?
|
|
|
-boolean AsyncWiFiManager::isIp(String str)
|
|
|
-{
|
|
|
- for (unsigned int i = 0; i < str.length(); i++)
|
|
|
- {
|
|
|
- int c = str.charAt(i);
|
|
|
- if (c != '.' && (c < '0' || c > '9'))
|
|
|
- {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-// IP to String?
|
|
|
-String AsyncWiFiManager::toStringIp(IPAddress ip)
|
|
|
-{
|
|
|
- String res = "";
|
|
|
- for (int i = 0; i < 3; i++)
|
|
|
- {
|
|
|
- res += String((ip >> (8 * i)) & 0xFF) + ".";
|
|
|
- }
|
|
|
- res += String(((ip >> 8 * 3)) & 0xFF);
|
|
|
- return res;
|
|
|
-}
|