WiFi.mode für AP und STA richtig anwenden

MDNSResponder mdns;
ESP8266WebServer server(80);

const char* ssid = "MyWLan";
const char* password = "MyPassword";
const char* MDNSName="ESP8266";
String ssidAP="WebSchalter";
const char* MDNSName="ESP8266";
IPAddress apIP(192, 168, 1, 50);          //Adresse im AP Modus (im WLAN weist Router zu)


char passwort[64] = "APPassword";    //Passwort im AP Modus

void setup(void){


  WiFi.persistent(false);         //Permanentes Schreiben im Flash abschalten http://www.forum-raspberrypi.de/Thread-esp8266-achtung-flash-speicher-schreibzugriff-bei-jedem-aufruf-von-u-a-wifi-begin
  WiFi.begin(ssid, password);                                   //Server SSID Und Passwort...
  int intRetry = 0;
  while ((WiFi.status() != WL_CONNECTED) && (intRetry < 50)){
    intRetry++;
    delay(500);
  }
 
  if (WiFi.status() != WL_CONNECTED)
  { //Eigenartigerweise muss dieser Teil nicht ausgeführt werden? AP funktioniert aber trotzdem, auch wenn WLAN Verbindung Erfolg hat!?
    //Wird dieser Teil ausgeführt, funktioniert wLAN nicht mehr!?
    //WiFi.mode(WIFI_AP);                                           // access point modus
    //WiFi.softAPConfig(apIP, apIP, IPAddress(255, 255, 255, 0));   //AP konfigurieren: MyIPAdress, MyGateway, MySubnet
    //WiFi.softAP(&ssidAP[0], &passwort[0]);                        //AP Name und Passwort des AP Wi-Fi Netzes
    //AP = 1;                                                       //Access Point aktiv setzen...
  }
 
  /*
 
  if (mdns.begin(MDNSName, WiFi.localIP())) {
    //Sollte eigentlich anstatt der IP Adresse einen Namen (EPS8266.local) ermöglichen - funktioniert aber nicht...
    Hier habe ich noch eine Debugausgabe, die auch ausgegeben wird...
  }
  ...
}

void loop(void){
  server.handleClient();
}

#include <ESP8266WiFi.h>

class FallBack;

class FallBack {
  private:
    bool _STA                               = false;
    bool _AP                                = false;
    bool _scan_STA();
    const char* _STA_ssid                   = "Eingeben";
    const char* _STA_pass                   = "Eingeben";
    const char* _AP_ssid                    = "";
    const char* _AP_pass                    = "";
    IPAddress                               _AP_ip;
    IPAddress                               _AP_gateway;
    IPAddress                               _AP_subnet;
    int _AP_channel;
    int _AP_ssid_hidden;
    int _AP_max_connection;
    IPAddress                                _STA_ip;
    IPAddress                                _STA_dns1;
    IPAddress                                _STA_dns2;
    IPAddress                                _STA_gateway;
    IPAddress                                _STA_subnet;
    int32_t _STA_channel;
    const uint8_t* _STA_bssid;
    unsigned long STA_verrbingung_zeit;
    int STA_COUNTER                          = 0;
    unsigned long AP_verrbingung_zeit;
    
    int STA();
    int AP();

  public:
    FallBack();
    bool Server_Run = false;
    unsigned long STA_verrbingung_max_zeit   =  10000;
    unsigned long AP_verrbingung_max_zeit    =  60000;
    int STA_MAX_Versuche= 3;
    int wifi_status();

    bool set_softAP(const char* ssid, const char* passphrase = NULL, int channel = 1, int ssid_hidden = 0);
    bool set_softAPConfig(IPAddress local_ip, IPAddress gateway, IPAddress subnet);

    void set_STA_config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1, IPAddress dns2);
    void set_STA_begin(const char* ssid, const char *passphrase = NULL, int32_t channel = 0, const uint8_t* bssid = NULL);
    void set_STA_begin(char* ssid, char *passphrase = NULL, int32_t channel = 0, const uint8_t* bssid = NULL);


};

#include "fallback.h"


FallBack::FallBack() {
  STA_verrbingung_zeit=360000;
  AP_verrbingung_zeit =360000;
  }



int FallBack::wifi_status() {
  if (_STA == false && _AP == false)
  {
    Serial.println("Suche!");
    if (_scan_STA()) _STA = true; else _AP = true;
  }

  if (_STA == true)
  {
    if (WiFi.status() != WL_CONNECTED)
    {
      if (Server_Run == true)
      {
        Server_Run = false;
      }
      if ( millis() - STA_verrbingung_zeit >= STA_verrbingung_max_zeit )
      {
        if (STA_COUNTER <= STA_MAX_Versuche)
        {
          Serial.print("STA Verbindungsversuch! :");
          Serial.println(STA_COUNTER);
          STA();
          STA_verrbingung_zeit = millis();
          STA_COUNTER++;
        } else
        {
          _STA = false;
          _AP = true;
          STA_COUNTER = 0;
        }
      }
    } else
    {
      if (Server_Run == false)
      {
        Serial.println("STA Verbunden!");
        Serial.print("Start WebServer STA, IP : ");
        Serial.println(WiFi.localIP());
        Server_Run = true;
      }
    }
  }

  if (_AP == true)
  {
    if (WiFi.getMode() != WIFI_AP) WiFi.mode(WIFI_AP);
    if (Server_Run == false)
    {
      AP();
      Serial.println("AP gestart!");
      Serial.print("Start WebServer AP, IP : ");
      Serial.println(WiFi.softAPIP());
      Server_Run=true;
    }
    if (Server_Run == true)
    {
      if ( millis() - AP_verrbingung_zeit >= AP_verrbingung_max_zeit )
      {
        Serial.println("Suche STA nach!");
        WiFi.softAPdisconnect(true);
        WiFi.disconnect(true);
        Server_Run = false;
        _STA = false;
        _AP = false;
      }
    }
  }

  return -1;
}





int FallBack::AP() {
  WiFi.disconnect(true);
  WiFi.softAPdisconnect(true);
  if (WiFi.getMode() != WIFI_AP) WiFi.mode(WIFI_AP);
  WiFi.softAPConfig(_AP_ip, _AP_gateway, _AP_subnet);
  WiFi.softAP(_AP_ssid, _AP_pass , _AP_channel , _AP_ssid_hidden );
  AP_verrbingung_zeit = millis();
  return -1;
}

int FallBack::STA() {
  WiFi.disconnect(true);
  WiFi.softAPdisconnect(true);
  if (WiFi.getMode() != WIFI_STA) WiFi.mode(WIFI_STA);
  WiFi.config(_STA_ip, _STA_gateway, _STA_subnet, _STA_dns1, _STA_dns2);
  WiFi.begin ( _STA_ssid, _STA_pass, _STA_channel, _STA_bssid, true);
  return -1;
}

bool FallBack::_scan_STA()
{
  if (WiFi.getMode() != WIFI_STA) WiFi.mode(WIFI_STA);
  int n = WiFi.scanNetworks();
  if (n == 0) return false;
  for (int i = 0; i < n; ++i)
    if (WiFi.SSID(i).equals(_STA_ssid)) return true;
  return false;
}

bool FallBack::set_softAP(const char* ssid, const char* passphrase , int channel , int ssid_hidden ) {
  _AP_ssid = ssid;
  _AP_pass = passphrase;
  _AP_channel = channel;
  _AP_ssid_hidden = ssid_hidden;
}
bool FallBack::set_softAPConfig(IPAddress local_ip, IPAddress gateway, IPAddress subnet) {
  _AP_ip = local_ip;
  _AP_gateway = gateway;
  _AP_subnet = subnet;
}

void FallBack::set_STA_begin(const char* ssid, const char *passphrase, int32_t channel, const uint8_t* bssid) {
  _STA_ssid = ssid;
  _STA_pass = passphrase;
  _STA_channel = channel;
  _STA_bssid = bssid;
}

void FallBack::set_STA_begin(char* ssid, char *passphrase, int32_t channel, const uint8_t* bssid) {
  return set_STA_begin((const char*) ssid, (const char*) passphrase, channel, bssid);
}

void FallBack::set_STA_config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1 = (uint32_t)0x00000000, IPAddress dns2 = (uint32_t)0x00000000)
{
  _STA_ip = local_ip;
  _STA_dns1 = dns1;
  _STA_dns2 = dns2;
  _STA_gateway = gateway;
  _STA_subnet = subnet;
}

const char* STA_ssid = "MyWLan";
const char* STA_pass = "MyPassword";

const char* AP_ssid  = "WebSchalter";
const char* AP_pass =  "MyPassword";

IPAddress AP_ip(192, 168, 4, 1);
IPAddress AP_gateway(192, 168, 4, 1);
IPAddress AP_subnet(255, 255, 255, 0);

const char* MDNSName = "ESP8266";

FallBack fallback = FallBack();
bool runner = false;

void setup()
{
  WiFi.softAPdisconnect(true); // AP  sollte noch verbunden sein
  WiFi.disconnect(true);       // STA sollte noch verbunden sein
  WiFi.mode(WIFI_STA);         // zum scan nach STA mode WIFI_STA
}  fallback.set_STA_begin(STA_ssid, STA_pass);
  fallback.set_softAPConfig(AP_ip, AP_gateway, AP_subnet);
  fallback.set_softAP(AP_ssid, AP_pass);
  fallback.STA_verrbingung_max_zeit = 10000; //standart 10sec zum verbinden
  fallback.STA_MAX_Versuche = 3;           //standart max 3 versuche zum AP zuverbinden alle versuch fehlschlagen AP Modus
  fallback.AP_verrbingung_max_zeit = 60000; //standart 60sec im AP modus

  server.on ( "/", handleRoot );
  if (mdns.begin(MDNSName)) Serial.println("Error setting up MDNS responder!");
  mdns.addService("http", "tcp", 80);

}

void loop()
{
  fallback.wifi_status();  // prüfe auf verbindung STA und AP jenach den Verbindet zum STA oder Start AP für bestimmte zeit
  if (fallback.Server_Run == true && runner == false)
  {
    mdns.begin(MDNSName);
    mdns.update();
    server.begin(); // webserver Start
    runner = true;
  }
  if (fallback.Server_Run == false && runner == true) {
    server.close(); // webserver stop
    runner = false;
  }

  if (runner)
    server.handleClient();
}

IPAddress AP_ip(192, 168, 4, 1);

0.void loop()
1.{
2.  int intRetry = 0;
3.  while ((WiFi.status() != WL_CONNECTED) && (intRetry < 50)){
4.    intRetry++;
5.    delay(500);
6.  }
7.}

vor loop und setup;
unsigned long neuverbindung=0;

void loop(){
if (WiFi.status() != WL_CONNECTED ){        abfrage ob verbunden 
	if (intRetry>50){                   abfrage ob intRetry grösser ist als 50
		intRetry=0                  setzt intRetry auf 0
		WiFi.begin(ssid, password); neu verbinden!
		neuverbindung =millis();    wann wurde Neuverbingungsversuch gestartet
	}else
	{
	if (millis()-neuverbindung> 500){ wenn millis() zeit seid dem Start des ESP8266 MINUS neuverbindung ist der höher ist als 5000/0,5sec früher dein delay(500) 
		intRetry++;                 erhöhe um 1
	}
//hier kann dann was anders gemacht werden
//Sensoren auslesen etwas ansteuere
//und wieder hoch zum loop anfang
}