wificonfig.cpp

Go to the documentation of this file.

/*
  wificonfig.cpp -  wifi functions class
 
  Copyright (c) 2014 Luc Lebosse. All rights reserved.
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/
 
#ifdef ARDUINO_ARCH_ESP32
 
#include "esplibconfig.h"
 
#if ENABLED(ESP3D_WIFISUPPORT)
#include <WiFi.h>
#include <esp_wifi.h>
#include <ESPmDNS.h>
#include <FS.h>
#include <SPIFFS.h>
#include <Preferences.h>
#include "wificonfig.h"
#include "wifiservices.h"
 
#ifdef __cplusplus
extern "C" {
#endif
esp_err_t esp_task_wdt_reset();
#ifdef __cplusplus
}
#endif
 
WiFiConfig wifi_config;
 
bool WiFiConfig::restart_ESP_module = false;
 
WiFiConfig::WiFiConfig(){
}
    
WiFiConfig::~WiFiConfig(){
    end();
}
 
uint32_t WiFiConfig::IP_int_from_string(String & s){
    uint32_t ip_int = 0;
    IPAddress ipaddr;
    if (ipaddr.fromString(s)) ip_int = ipaddr;
    return ip_int;
}
 
String WiFiConfig::IP_string_from_int(uint32_t ip_int){
    IPAddress ipaddr(ip_int);
    return ipaddr.toString();
}
 
bool WiFiConfig::isHostnameValid (const char * hostname)
{
    //limited size
    char c;
    if (strlen (hostname) > MAX_HOSTNAME_LENGTH || strlen (hostname) < MIN_HOSTNAME_LENGTH) {
        return false;
    }
    //only letter and digit
    for (int i = 0; i < strlen (hostname); i++) {
        c = hostname[i];
        if (! (isdigit (c) || isalpha (c) || c == '_') ) {
            return false;
        }
        if (c == ' ') {
            return false;
        }
    }
    return true;
}
 
bool WiFiConfig::isSSIDValid (const char * ssid)
{
    //limited size
    //char c;
    if (strlen (ssid) > MAX_SSID_LENGTH || strlen (ssid) < MIN_SSID_LENGTH) {
        return false;
    }
    //only printable
    for (int i = 0; i < strlen (ssid); i++) {
        if (!isPrintable (ssid[i]) ) {
            return false;
        }
    }
    return true;
}
 
bool WiFiConfig::isPasswordValid (const char * password)
{
    if (strlen (password) == 0) return true; //open network
    //limited size
    if ((strlen (password) > MAX_PASSWORD_LENGTH) || (strlen (password) < MIN_PASSWORD_LENGTH)) {
        return false;
    }
    //no space allowed ?
  /*  for (int i = 0; i < strlen (password); i++)
        if (password[i] == ' ') {
            return false;
        }*/
    return true;
}
 
bool WiFiConfig::isValidIP(const char * string){
    IPAddress ip;
    return ip.fromString(string);
}
 
/*
 * delay is to avoid with asyncwebserver and may need to wait sometimes
 */
void WiFiConfig::wait(uint32_t milliseconds){
    uint32_t timeout = millis();
    vTaskDelay(1 / portTICK_RATE_MS);  // Yield to other tasks
    esp_task_wdt_reset(); //for a wait 0;
    //wait feeding WDT
    while ( (millis() - timeout) < milliseconds) {
       esp_task_wdt_reset();
       vTaskDelay(1 / portTICK_RATE_MS);  // Yield to other tasks
    }
}
 
void WiFiConfig::WiFiEvent(WiFiEvent_t event)
{
 switch (event)
    {
    case SYSTEM_EVENT_STA_GOT_IP:
        MYSERIAL0.println ("Connected");
        MYSERIAL0.println(WiFi.localIP());
        break;
    case SYSTEM_EVENT_STA_DISCONNECTED:
        MYSERIAL0.println("WiFi lost connection");
        break;
    default:
        break;
    }
}
 
/*
 * Get WiFi signal strength
 */
int32_t WiFiConfig::getSignal (int32_t RSSI)
{
    if (RSSI <= -100) {
        return 0;
    }
    if (RSSI >= -50) {
        return 100;
    }
    return (2 * (RSSI + 100) );
}
 
/*
 * Connect client to AP
 */
 
bool WiFiConfig::ConnectSTA2AP(){
    String msg, msg_out;
    uint8_t count = 0;
    uint8_t dot = 0;
    wl_status_t status = WiFi.status();
    while (status != WL_CONNECTED && count < 40) {
         
         switch (status) {
            case WL_NO_SSID_AVAIL:
                msg="No SSID";
                break;
            case WL_CONNECT_FAILED:
                msg="Connection failed";
                break;
            case WL_CONNECTED:
                break;
            default:
                if ((dot>3) || (dot==0) ){
                    dot=0;
                    msg_out = "Connecting";
                }
                msg_out+=".";
                msg= msg_out;
                dot++;
                break;
        }
        MYSERIAL0.println(msg.c_str());
        wait (500);
        count++;
        status = WiFi.status();
     }
    return (status == WL_CONNECTED);
}
 
/*
 * Start client mode (Station)
 */
 
bool WiFiConfig::StartSTA(){
    String defV;
    Preferences prefs;
    //stop active service
    wifi_services.end();
    //Sanity check
    if((WiFi.getMode() == WIFI_STA) || (WiFi.getMode() == WIFI_AP_STA))WiFi.disconnect();
    if((WiFi.getMode() == WIFI_AP) || (WiFi.getMode() == WIFI_AP_STA))WiFi.softAPdisconnect();
    WiFi.enableAP (false);
    WiFi.mode(WIFI_STA);
    //Get parameters for STA
    prefs.begin(NAMESPACE, true);
    defV = DEFAULT_HOSTNAME;
    String h = prefs.getString(HOSTNAME_ENTRY, defV);
    WiFi.setHostname(h.c_str());
    //SSID
    defV = DEFAULT_STA_SSID;
    String SSID = prefs.getString(STA_SSID_ENTRY, defV);
    if (SSID.length() == 0)SSID = DEFAULT_STA_SSID;
    //password
    defV = DEFAULT_STA_PWD;
    String password = prefs.getString(STA_PWD_ENTRY, defV);
    int8_t IP_mode = prefs.getChar(STA_IP_MODE_ENTRY, DHCP_MODE);
    //IP
    defV = DEFAULT_STA_IP;
    int32_t IP = prefs.getInt(STA_IP_ENTRY, IP_int_from_string(defV));
    //GW
    defV = DEFAULT_STA_GW;
    int32_t GW = prefs.getInt(STA_GW_ENTRY, IP_int_from_string(defV));
    //MK
    defV = DEFAULT_STA_MK;
    int32_t MK = prefs.getInt(STA_MK_ENTRY, IP_int_from_string(defV));
    prefs.end(); 
    //if not DHCP
    if (IP_mode != DHCP_MODE) {
        IPAddress ip(IP), mask(MK), gateway(GW);
        WiFi.config(ip, gateway,mask);
    }
    if (WiFi.begin(SSID.c_str(), (password.length() > 0)?password.c_str():NULL)){
        MYSERIAL0.print("\nClient Started\nConnecting ");
        MYSERIAL0.println(SSID.c_str());
        return ConnectSTA2AP();
    } else {
        MYSERIAL0.println("\nStarting client failed");
        return false;
    }
}
 
bool WiFiConfig::StartAP(){
    String defV;
    Preferences prefs;
    //stop active services
    wifi_services.end();
    //Sanity check
    if((WiFi.getMode() == WIFI_STA) || (WiFi.getMode() == WIFI_AP_STA))WiFi.disconnect();
    if((WiFi.getMode() == WIFI_AP) || (WiFi.getMode() == WIFI_AP_STA))WiFi.softAPdisconnect();
    WiFi.enableSTA (false);
    WiFi.mode(WIFI_AP);
    //Get parameters for AP
    prefs.begin(NAMESPACE, true);
    //SSID
    defV = DEFAULT_AP_SSID;
    String SSID = prefs.getString(AP_SSID_ENTRY, defV);
    if (SSID.length() == 0)SSID = DEFAULT_AP_SSID;
    //password
    defV = DEFAULT_AP_PWD;
    String password = prefs.getString(AP_PWD_ENTRY, defV);
    //channel
    int8_t channel = prefs.getChar(AP_CHANNEL_ENTRY, DEFAULT_AP_CHANNEL);
    if (channel == 0)channel = DEFAULT_AP_CHANNEL;
    //IP
    defV = DEFAULT_AP_IP;
    int32_t IP = prefs.getInt(AP_IP_ENTRY, IP_int_from_string(defV));
    if (IP==0){
        IP = IP_int_from_string(defV);
    } 
    prefs.end(); 
    IPAddress ip(IP);
    IPAddress mask;
    mask.fromString(DEFAULT_AP_MK);
    //Set static IP
    WiFi.softAPConfig(ip, ip, mask);
    //Start AP
    if(WiFi.softAP(SSID.c_str(), (password.length() > 0)?password.c_str():NULL, channel)) {
        MYSERIAL0.print("\nAP Started ");
        MYSERIAL0.println(WiFi.softAPIP().toString());
        return true;
    } else {
        MYSERIAL0.println("\nStarting AP failed");
        return false;
    }
}
 
void WiFiConfig::StopWiFi(){
    //Sanity check
    if((WiFi.getMode() == WIFI_STA) || (WiFi.getMode() == WIFI_AP_STA))WiFi.disconnect(true);
    if((WiFi.getMode() == WIFI_AP) || (WiFi.getMode() == WIFI_AP_STA))WiFi.softAPdisconnect(true);
    wifi_services.end();
    WiFi.mode(WIFI_OFF);
    MYSERIAL0.println("\nWiFi Off");
}
 
void WiFiConfig::begin() {
   Preferences prefs;
   //stop active services
    wifi_services.end();
   //setup events
   WiFi.onEvent(WiFiConfig::WiFiEvent);
   //open preferences as read-only
   prefs.begin(NAMESPACE, true);
   int8_t wifiMode = prefs.getChar(ESP_WIFI_MODE, DEFAULT_WIFI_MODE);
   prefs.end();
   if (wifiMode == ESP_WIFI_AP) {
       StartAP();
       //start services
       wifi_services.begin();
   } else if (wifiMode == ESP_WIFI_STA){
       if(!StartSTA()){
           MYSERIAL0.println("\nCannot connect to AP");
           StartAP();
       }
       //start services
       wifi_services.begin();
   }else WiFi.mode(WIFI_OFF);
}
 
void WiFiConfig::end() {
    StopWiFi();
}
 
void WiFiConfig::restart_ESP(){
    restart_ESP_module=true;
}
 
void WiFiConfig::handle() {
    //in case of restart requested
    if (restart_ESP_module) {
        end();
        ESP.restart();
        while (1) {};
    }
    
    //Services
    wifi_services.handle();
}
 
 
#endif // ENABLE_WIFI
 
#endif // ARDUINO_ARCH_ESP32