Cuestion sobre WiFi.config() esp8266

Buenos dias. tengo una pregunta, SI YA BUSQUE MUCHO en GOOGLE, y no encontre algo que me ayude directamente por eso recurro a este medio.

lo que tengo es un WEB SERVER que me pregunta con un formulario El SSID, EL PASS LA IPv4 y LA PUERTA DE ENLACE donde luego quiero dar ese parametro a WiFI.config(ip,puertaenlace,mascara) para que quede estatica mi ip y no este cambiando cuando se reinicie o cuando el router se reinicie y por DHCP le de otra ip, ya que esa la quiero direccionar hacia afuera.

EL TEMA es que cuando tomo ese dato del formulario lo meto en la eeprom, luego lo leo y lo que queria es convertirlo para poder meterlo en IPAdrres ipv4() , y IPAdrres puertaenlace() para tener la coneccion al AP , por supuesto ya el Esp en modo STA. Gracias. dejo el codigo que estoy probando.

 #include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <EEPROM.h>

//-------------------VARIABLES GLOBALES--------------------------
int contconexion = 0;
unsigned long previousMillis = 0;

char ssid[50];      
char pass[50];
char ip[50];
char gw[50];
char mask1[15];
 


const char *ssidConf = "esp8266";
const char *passConf = "admin123";

String mensaje = "";


/*if (WiFi.localIP().toString() != "IP unset") {

          IPAddress ip(WiFi.localIP());
          IPAddress gateway(WiFi.gatewayIP());
          IPAddress subnet(255, 255, 255, 0);
        // Static IP Setup Info Here...
          WiFi.config(ip, gateway, subnet);
        
        }*/




//-----------CODIGO HTML PAGINA DE CONFIGURACION---------------
String pagina = "<!DOCTYPE html>"
"<html>"
"<head>"
"<title>Si ve esta ventana es por que no conecto a su WIFI</title>"
"<meta charset='UTF-8'>"
"</head>"
"<body>"
"</form>"
"<form action='guardar_conf' method='get'>"
"Coloque Nombre su WIFI:

"
"<input class='input1' name='ssid' type='text'>
"
"
"
"PASSWORD de su WIFI:

"
"<input class='input1' name='pass' type='text'>

"
"
"
"Verifique su red y asigne una ip valida-->"
"IP para hacer statica separada con comas:

"
"<input class='input1' name='ip' type='text'>

"
"Puerta de Enlace para hacer statica separada con comas:

"
"<input class='input1' name='gw' type='text'>

"
"<input class='boton' type='submit' value='GUARDAR'/>

"
"</form>"
"<a href='escanear'><button class='boton'>ESCANEAR REDES CERCANAS</button></a>

";

String paginafin = "</body>"
"</html>";

//------------------------SETUP WIFI-----------------------------//////////////////////////////////////////////////////////////////////
void setup_wifi() {
// Conexión WIFI
  WiFi.mode(WIFI_STA); //para que no inicie el SoftAP en el modo normal
   
    
    Serial.println("el valor que trae de emprom");
    Serial.println(ip);
    Serial.print(mask1);
    delay(3000);


     
   
     
     IPAddress ip ;
    
     
    
     IPAddress gw;
     
     
     IPAddress mask1(255,255,255,0);
     
     Serial.println("ENTRANDO EN  STATION WIFI.....");
     Serial.println("*****************************************************");
     
     Serial.println("ip statica que queda");
     Serial.println(ip);
     
     Serial.println("Gtway statica que queda");
     Serial.println(gw);
     
     Serial.println("MASCARA statica que queda");
     
     Serial.println(mask1);
     
     Serial.println("SSID");
     Serial.println(ssid);
     
     Serial.println("password");
     Serial.println(pass);

     
     
  WiFi.config(ip, gw, mask1);
  
  WiFi.begin(ssid, pass);
  
  while (WiFi.status() != WL_CONNECTED and contconexion <20) { //Cuenta hasta 50 si no se puede conectar lo cancela
    ++contconexion;
    delay(250);
    Serial.print(".");
    digitalWrite(13, HIGH);
    delay(250);
    digitalWrite(13, LOW);
  }
  if (contconexion <20) {   
      
      delay(1000);
      Serial.println("");
      Serial.println("WiFi conectado.. el ip por dhcp es : ");
      Serial.println(WiFi.localIP());
      //digitalWrite(13, HIGH);
      Serial.println(WiFi.gatewayIP());
     

      
      
}
  else { 
      Serial.println("");
      Serial.println("Error de conexion");
      digitalWrite(13, LOW);
      modoconf();
  }
  
}

//--------------------------------------------------------------
WiFiClient espClient;
ESP8266WebServer server(80);
//--------------------------------------------------------------

//-------------------PAGINA DE CONFIGURACION--------------------
void paginaconf() {
  
  server.send(200, "text/html", pagina + mensaje + WiFi.localIP().toString() + paginafin); 
}

//--------------------MODO_CONFIGURACION------------------------
void modoconf() {
   
  delay(100);
  digitalWrite(13, HIGH);
  delay(100);
  digitalWrite(13, LOW);
  delay(100);
  digitalWrite(13, HIGH);
  delay(100);
  digitalWrite(13, LOW);

  WiFi.softAP(ssidConf, passConf);
  IPAddress myIP = WiFi.softAPIP(); 
  Serial.print("IP del acces point: ");
  Serial.println(myIP);
  Serial.println("WebServer iniciado...");

  server.on("/", paginaconf); //esta es la pagina de configuracion

  server.on("/guardar_conf", guardar_conf); //Graba en la eeprom la configuracion

  server.on("/escanear", escanear); //Escanean las redes wifi disponibles
  
  server.begin();

  while (true) {
      server.handleClient();
  }
}

//---------------------GUARDAR CONFIGURACION-------------------------
void guardar_conf() {


  Serial.println("GUARDANDO EN LA EPRROM ESTOS VALORES DE LA WEB");
  Serial.println("////////////////////////////////////////////////");
  Serial.println("");
  Serial.println("SSid");
  Serial.println(server.arg("ssid"));//Recibimos los valores que envia por GET el formulario web
  grabar(0,server.arg("ssid"));

  Serial.println("PASSWORD");
  Serial.println(server.arg("pass"));
  grabar(50,server.arg("pass"));
  
  Serial.println("ip colocada");
  Serial.println(server.arg("ip"));
  grabar(100,server.arg("ip"));
  
  Serial.println("gateway colocado");
  Serial.println(server.arg("gw"));
  grabar(150,server.arg("gw"));
  


  mensaje = "Configuracion Guardada...";
   
  //Serial.print("IP address:\t");

  delay(1000);
 paginaconf();
}

//----------------Función para grabar en la EEPROM-------------------
void grabar(int addr, String a) {
  int tamano = a.length(); 
  char inchar[50]; 
  a.toCharArray(inchar, tamano+1);
  for (int i = 0; i < tamano; i++) {
    EEPROM.write(addr+i, inchar[i]);
  }
  for (int i = tamano; i < 50; i++) {
    EEPROM.write(addr+i, 255);
  }
  EEPROM.commit();
}

//-----------------Función para leer la EEPROM------------------------
String leer(int addr) {
   byte lectura;
   String strlectura;
   for (int i = addr; i < addr+50; i++) {
      lectura = EEPROM.read(i);
      if (lectura != 255) {
        strlectura += (char)lectura;
      }
   }
   return strlectura;
}

//---------------------------ESCANEAR----------------------------
void escanear() {  
  int n = WiFi.scanNetworks(); //devuelve el número de redes encontradas
  Serial.println("escaneo terminado");
  if (n == 0) { //si no encuentra ninguna red
    Serial.println("no se encontraron redes");
    mensaje = "no se encontraron redes";
  }  
  else
  {
    Serial.print(n);
    Serial.println(" redes encontradas");
    mensaje = "";
    for (int i = 0; i < n; ++i)
    {
      // agrega al STRING "mensaje" la información de las redes encontradas 
      mensaje = (mensaje) + "<p>" + String(i + 1) + ": " + WiFi.SSID(i) + " (" + WiFi.RSSI(i) + ") Ch: " + WiFi.channel(i) + " Enc: " + WiFi.encryptionType(i) + " </p>\r\n";
      //WiFi.encryptionType 5:WEP 2:WPA/PSK 4:WPA2/PSK 7:open network 8:WPA/WPA2/PSK
      delay(10);
    }
    Serial.println(mensaje);
    paginaconf();
  }
}

//------------------------SETUP-----------------------------
void setup() {

 
  
  
  // Inicia Serial
  Serial.begin(115200);
  Serial.println("");

  EEPROM.begin(512);

  //modoconf();

  leer(0).toCharArray(ssid, 50);
  leer(50).toCharArray(pass, 50);
  leer(100).toCharArray(ip, 50);
  leer(150).toCharArray(gw, 50);

  

     Serial.println("SETUP y lo  que grabamos en  epr0mm ");
      Serial.println("<///////**************////////////> ");
     Serial.println("ip ipv4");
     Serial.println(ip);
     Serial.println("Puerta de enlace; ");
     Serial.println(gw);
     //Serial.println("mascara manual es 255.255.255.0 ");
    // Serial.println(mask1);
     Serial.println("nombre wifi scaneado ");
     Serial.println(ssid);
     Serial.println("password del wifi ");
     Serial.println(pass);
  
  setup_wifi();
}

//--------------------------LOOP--------------------------------
void loop() {
;
    Serial.println("dentro del loop...");
  }
}

Porque no usas el WIFIManager que lo tiene perfectamente implementado y te ahorrará todo este dolor de cabeza que tienes.
Es una interfaz muy bien lograda


que cuando arranca lo hacen en modo AP en 192.168.4.1 y tiene opciones para scannear las WIFI que lo rodean, luego eliges la tuya, colocas el password. Lo guardas, reinicias y el arranca con esos datos.

Te dejo link Wifimanager de Programar Facil

Y ves.. buscaste mucho pero .. jajaja no es facil a veces dar con lo que se quiere.
Mi consejo es que si buscas en español pierdes tu tiempo, pero hacerlo en inglés requiere conocer las palabras adecuadas y no siempre son las que nos vienen a la cabeza pero, estarás unos minutos pero una búsqueda suegerirá algo o un comentario de dicha búsqueda y terminarás encontrando lo que quieres.

Mira, te dejo un programa que gestiona un relé que depende de un sensor de temperatura. Aquí se usa el wifimanager y es una absoluta maravilla, tal y como te comentan por arriba...

#include <FS.h>
#include <ESP8266WiFi.h> 
#include "ThingSpeak.h" 
#include <DHT.h>
#include <WiFiManager.h>
#include <ArduinoJson.h>
#include <ESP8266mDNS.h>
#include <DNSServer.h>
#include <ESP8266WebServer.h>
#include <WiFiClient.h>
#include <WiFiServer.h>
#define DHTTYPE DHT11
#define DHTTYPE DHT22
#include <DoubleResetDetector.h>
#include <LiquidCrystal_I2C.h>
#include <Wire.h> 

#define DRD_TIMEOUT 10
#define DRD_ADDRESS 0

#define DHTPIN 5 //lectura datos GPI2/D4 

const int releCaldera = 16;
//const int DHTpin = D4;
float histeresis = 1;
static unsigned long last_loop;
unsigned long int anteriorRefreshDatos = 0;
float temp= 0;
float humi= 0;
float tempDeseada = 00;
int calderaHabilitada;
int estadoRele = 0;
int contconexion = 0;
bool shouldSaveConfig = false;
bool initialConfig = false;


DoubleResetDetector drd(DRD_TIMEOUT, DRD_ADDRESS);

LiquidCrystal_I2C lcd(0x27, 16, 2);

//DHT dht(DHTpin, DHTTYPE);
DHT dht(DHTPIN, DHT22);

WiFiClient client;
WiFiServer server(80);

//Parámetros de Thingspeak

const char* serverThingspeak = "api.thingspeak.com";
char  myWriteAPIKey[18] = "__________________________";
char  myChannelNumber[11] = "____________________________";


void saveConfigCallback () {
Serial.println("Should save config");
shouldSaveConfig = true;
  }


void setup() {

lcd.clear();
lcd.begin(16,2);
lcd.init();
lcd.backlight();
dht.begin();
delay(10);

Serial.begin(115200);
Serial.println();

pinMode(releCaldera, OUTPUT);
digitalWrite(releCaldera, LOW);
//pinMode(LED_BUILTIN, OUTPUT);
Serial.println();

if (WiFi.SSID()==""){
    Serial.println("We haven't got any access point credentials, so get them now");   
    initialConfig = true;
    }
    if (drd.detectDoubleReset()) {
    Serial.println("Doble reset detectado");
    initialConfig = true;
      }
      if (initialConfig) {
      Serial.println("Starting configuration portal.");
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("INTRODUCIR");
          lcd.setCursor(0,1);
          lcd.print("USUARIO Y PASS");
      WiFiManager wifiManager;
      wifiManager.resetSettings();
      }
    
  //Leer configuración de Jsona
  
  Serial.println("mounting FS...");

  if (SPIFFS.begin()) {
    Serial.println("mounted file system");
    if (SPIFFS.exists("/config.json")) {
      //file exists, reading and loading
      Serial.println("reading config file");
      File configFile = SPIFFS.open("/config.json", "r");
      if (configFile) {
        Serial.println("opened config file");
        size_t size = configFile.size();
        // Allocate a buffer to store contents of the file.
        std::unique_ptr<char[]> buf(new char[size]);

        configFile.readBytes(buf.get(), size);
        DynamicJsonBuffer jsonBuffer;
        JsonObject& json = jsonBuffer.parseObject(buf.get());
        json.printTo(Serial);
        if (json.success()) {
          Serial.println("\nparsed json");

          strcpy(myWriteAPIKey, json["myWriteAPIKey"]);
          } else {
          Serial.println("failed to load json config");
        }
      }
    }
  } 

WiFiManagerParameter custom_myWriteAPIKey("API-Key", "myWriteAPIKey", myWriteAPIKey, 17);

WiFiManager wifiManager;

//Establecer configuración guardada

wifiManager.setSaveConfigCallback(saveConfigCallback);

    IPAddress _ip = IPAddress(192, 168, 1, 30);
    IPAddress _gw = IPAddress(192, 168, 0, 1);
    IPAddress _sn = IPAddress(255, 255, 255, 0);
    wifiManager.setSTAStaticIPConfig(_ip, _gw, _sn);

    wifiManager.addParameter(&custom_myWriteAPIKey);
  
  if (!wifiManager.autoConnect()) {
      Serial.println("failed to connect and hit timeout");
      delay(10);
      
      ESP.reset();
      delay(5000);
      }

  //Si has llegado aquí estás conectado a una WIFI
  Serial.println("Conectado a una Wifi");
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("CONECTANDO...");
          delay(10);

  //Leer parámetros actualizados
  
  strcpy(myWriteAPIKey, custom_myWriteAPIKey.getValue());
  

  //Guardar los parámetros en FS
  
  if (shouldSaveConfig) {
      Serial.println("saving config");
      DynamicJsonBuffer jsonBuffer;
      JsonObject& json = jsonBuffer.createObject();
      json["myWriteAPIKey"] = myWriteAPIKey;
    
      File configFile = SPIFFS.open("/config.json", "w");
          if (!configFile) {
          Serial.println("failed to open config file for writing");
            }
      json.printTo(Serial);
      json.printTo(configFile);
      configFile.close();
    //Guardado finalizado
    }
  Serial.println();
  Serial.println("local ip");
  Serial.println(WiFi.localIP());
  delay(10);}
    
void refreshDatos(){

if (millis() > anteriorRefreshDatos + 20000){
    anteriorRefreshDatos = millis();
    float temp = dht.readTemperature();
    float humi = dht.readHumidity();
      if (isnan(temp) || isnan(humi)){ 
      Serial.println("Fallo en lectura de temperatura y humedad");
      return;}
        if (calderaHabilitada = 1){
          if (temp + histeresis >= tempDeseada && temp > 0)  digitalWrite(releCaldera, LOW);
        else if (temp < tempDeseada && temp > 0) digitalWrite(releCaldera, HIGH);
      else digitalWrite(releCaldera, LOW); 
      }              
      Serial.println();
      Serial.println("Leyendo datos....");
      Serial.print("Temperatura deseada: ");
      Serial.println(tempDeseada); 
      Serial.print("Temperatura: ");
      Serial.println(temp);
      Serial.print("Humedad: ");
      Serial.println(humi);
            lcd.clear();
            lcd.setCursor(0,0);
            lcd.print("Temp: ");
            lcd.print(temp);
            lcd.print(" ");
            lcd.print((char)223);
            lcd.print("C");
            lcd.setCursor(0,1);
            lcd.print("Hum:  ");
            lcd.print(humi);
            lcd.print(" %");
            int estadoRele = digitalRead(releCaldera);
      if (estadoRele == LOW){
          Serial.print("Estado relé caldera: ");  
          Serial.println("LOW");
          lcd.setCursor(15,0);
          lcd.print(" ");        
            } else {
                    Serial.print("Estado relé caldera: ");  
                    Serial.println("HIGH");
                    lcd.setCursor(15,0);
                    lcd.print("C");
                    } 
 // Start the server
    ThingSpeak.begin(client);
    Serial.println("Cliente thingspeak iniciado");
    server.begin();
    Serial.println("Server iniciado");
    Serial.println(myWriteAPIKey);
    Serial.println("local ip");
    Serial.println(WiFi.localIP());
    delay(10);
    ThingSpeak.setField(1, temp);
    ThingSpeak.setField(2, humi); 
    ThingSpeak.setField(3, estadoRele);
    ThingSpeak.setField(4, tempDeseada);
    ThingSpeak.writeFields(String(myChannelNumber).toInt(), myWriteAPIKey);   
    delay(15000);
    Serial.println("Enviando datos...");
    Serial.println();
            }
         }

void loop() {

  drd.loop();
  refreshDatos();
 
   WiFiClient client = server.available();
    if (!client) {
        return;    
        }
  
  // Read the first line of the request
  String req = client.readStringUntil('\r');
  Serial.println(req);
  client.flush();
  
      int  val;

      if (req.indexOf("/tempDeseada40") != -1){
      tempDeseada = 40;
      val = 1;
      } else if (req.indexOf("/tempDeseada22") != -1){
      tempDeseada = 22;
      val = 1;
      } else if (req.indexOf("/tempDeseada23") != -1){
      tempDeseada = 23;
      val = 1;
      } else if (req.indexOf("/tempDeseada24") != -1){
      tempDeseada = 24;
      val = 1;
      } else if (req.indexOf("/tempDeseada25") != -1){
      tempDeseada = 25;
      val = 1;
      } else if (req.indexOf("/tempDeseada26") != -1){
      tempDeseada = 26;
      val = 1;
      } else if (req.indexOf("/tempDeseada00") != -1){
      tempDeseada = 00;
      val = 0;
      } else {
      Serial.println("peticion invalida");
      client.stop();
      return;      
      }

  // Set GPIO2 according to the request
  calderaHabilitada = val;
  client.flush();

  // Prepare the response
  String s = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\nGPIO is now ";
  s += (val)?"high":"low";
  s += "</html>\n";

  // Send the response to the client
  client.print(s);
  delay(1);
  client.stop();
  Serial.println("Client disonnected");
  }