wifi.esp

void setEnableWifi()
{
    doEnableWifi = true;
}

void onWifiConnect(WiFiEvent_t event, WiFiEventInfo_t inf0)
{
#ifdef DEBUG
    Serial.println(F("[ INFO ] WiFi STA Connected"));
#endif
    mqttReconnectTimer.detach();
    if (!wifiReconnectTimer.active() && !config.fallbackMode)
    {
        wifiReconnectTimer.once(300, setEnableWifi);
    }
    ledWifiOff();
}

void onWifiDisconnect(WiFiEvent_t event, WiFiEventInfo_t inf0)
{
    if (!WiFi.isConnected())
    {
        return;
    }
#ifdef DEBUG
    Serial.println(F("[ INFO ] WiFi STA Disconnected"));
#endif
    mqttReconnectTimer.detach();
    disconnectMqtt();
    if (!wifiReconnectTimer.active() && !config.fallbackMode)
    {
        wifiReconnectTimer.once(300, setEnableWifi);
    }
    ledWifiOff();
}

void onWifiGotIP(WiFiEvent_t event, WiFiEventInfo_t info)
{
#ifdef DEBUG
    Serial.print("[ INFO ] WiFi IP Connected: ");
    Serial.println(WiFi.localIP().toString());
#endif
    wifiReconnectTimer.detach();
    ledWifiOn();
    connectToMqtt();
}

bool startAP(IPAddress apip, IPAddress apsubnet, bool hidden, const char *ssid, const char *password = NULL)
{
#ifdef DEBUG
    Serial.println(F("[ INFO ] ESP32-ACTL is running in AP Mode "));
#endif
    WiFi.mode(WIFI_AP);
#ifdef DEBUG
    Serial.print(F("[ INFO ] Configuring access point... "));
#endif

    WiFi.softAPConfig(apip, apip, apsubnet);

    bool success;
    if (hidden)
    {
        success = WiFi.softAP(ssid, password, 3, true);
    }
    else
    {
        success = WiFi.softAP(ssid, password);
    }
#ifdef DEBUG
    Serial.println(success ? F("Ready") : F("Failed!"));
#endif

    if (success)
    {
        ledWifiOn();
    }

#ifdef DEBUG
    IPAddress myIP = WiFi.softAPIP();

    Serial.print(F("[ INFO ] AP IP address: "));
    Serial.println(myIP);
    Serial.printf("[ INFO ] AP SSID: %s\n", ssid);
#endif
    return success;
}

// Fallback to AP Mode, so we can connect to ESP if there is no Internet connection
void fallbacktoAPMode()
{
    config.accessPointMode = true;
#ifdef DEBUG
    Serial.println(F("[ INFO ] ESP32-ACTL is running in Fallback AP Mode"));
#endif
    WiFi.mode(WIFI_AP);
    uint8_t macAddr[6];
    WiFi.softAPmacAddress(macAddr);
    char ssid[18];
    sprintf(ssid, "ESP32-ACTL-%02x%02x%02x", macAddr[3], macAddr[4], macAddr[5]);
    if (WiFi.softAP(ssid))
    {
        ledWifiOn();
#ifdef DEBUG
        IPAddress myIP = WiFi.softAPIP();

        Serial.print(F("[ INFO ] AP IP address: "));
        Serial.println(myIP);
        Serial.printf("[ INFO ] AP SSID: %s\n", ssid);
#endif
    }
}

// Try to connect Wi-Fi
bool connectSTA(const char *ssid, const char *password, byte bssid[6])
{
    bool useBSSID = false;
    WiFi.mode(WIFI_STA);
    WiFi.persistent(false);

    if (!config.dhcpEnabled)
    {
        WiFi.config(config.ipAddress, config.gatewayIp, config.subnetIp, config.dnsIp);
    }
#ifdef DEBUG
    Serial.print(F("[ INFO ] Trying to connect WiFi: "));
    Serial.println(ssid);
    Serial.print(F("[ INFO ] WiFi BSSID: "));
#endif
    for (int i = 0; i < 6; i++)
    {
#ifdef DEBUG
        Serial.printf("%02X", bssid[i]);
        if (i < 5)
            Serial.print(F(":"));
        else
            Serial.println();
#endif
        if (bssid[i] != 0)
            useBSSID = true;
    }
    if (useBSSID)
    {
#ifdef DEBUG
        Serial.println(F("[ INFO ] BSSID locked"));
#endif
        WiFi.begin(ssid, password, 0, bssid);
    }
    else
    {
#ifdef DEBUG
        Serial.println(F("[ INFO ] any BSSID"));
#endif
        WiFi.begin(ssid, password);
    }
    unsigned long now = millis();
    uint8_t timeout = 15; // define when to time out in seconds
    do
    {
        ledWifiStatus();
        delay(500);
#ifdef DEBUG
        if (!WiFi.isConnected())
            Serial.print(F("."));
#endif
        if (WiFi.isConnected())
            break;
    } while (millis() - now < timeout * 1000);

    // We now out of the while loop, either time is out or we connected. check what happened
    if (WiFi.isConnected())
    {
        String data = ssid;
        data += " " + WiFi.localIP().toString();
        writeEvent("INFO", "wifi", "WiFi is connected", data);
#ifdef DEBUG
        Serial.println(F("[ INFO ] WiFi is connected"));
#endif
        return true;
    }
    else
    {
#ifdef DEBUG
        Serial.println();
        Serial.println(F("[ WARN ] Couldn't connect in time"));
#endif
        if (!config.fallbackMode)
        {
#ifdef DEBUG
            Serial.println();
            Serial.println(F("[ INFO ] trying to reconnect to WiFi"));
#endif
            wifiReconnectTimer.once(300, setEnableWifi);
        }
        return false;
    }
}

void disableWifi()
{
    wiFiUptimeMillis = 0;
    WiFi.disconnect(true);
    WiFi.softAPdisconnect(true);
#ifdef DEBUG
    Serial.println(F("Turn wifi off."));
#endif
}

void enableWifi()
{
    wiFiUptimeMillis = 0;
    if (config.accessPointMode)
    {
        startAP(config.accessPointIp, config.accessPointSubnetIp, config.networkHidden, config.ssid, config.wifiPassword);
    }
    else
    {
        bool connected = connectSTA(config.ssid, config.wifiPassword, config.bssid);
        if (!connected && config.fallbackMode)
        {
            fallbacktoAPMode();
        }
    }
}

void setupWifi(bool configured)
{
    if (!configured)
    {
        WiFi.hostname(config.deviceHostname);
        fallbacktoAPMode();
    }
    else
    {
        WiFi.onEvent(onWifiConnect, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_CONNECTED);
        WiFi.onEvent(onWifiDisconnect, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_DISCONNECTED);
        WiFi.onEvent(onWifiGotIP, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_GOT_IP);
        WiFi.hostname(config.deviceHostname);
        enableWifi();
    }
}