Cómo configurar una IP estática en ESP32

Una IP estática permite que un ESP32 o ESP8266 use siempre la misma dirección dentro de la red local.

Esto resulta muy útil cuando el dispositivo actúa como servidor, cuando queremos acceder a él desde otro equipo, o simplemente cuando no queremos estar buscando qué IP le ha asignado el router cada vez que reinicia.

En las dos entradas anteriores hemos visto cómo conectarnos con una red WiFI existente en modo STA y cómo generar nuestra propia red WiFi con modo AP.

Ahora que tenemos nuestra placa conectada a la red WiFi, la siguiente necesidad va a ser conectarnos al dispositivo, para lo cuál vamos a tener que poder encontrarlo dentro de la red. O, dicho de otra forma, necesitamos saber su dirección IP local.

Hasta ahora, habíamos mostrado por puerto serie la dirección IP nada más conectar. Pero no resulta muy práctico tener que tener un ordenador o una pantalla al dispositivo para ver que IP nos ha asignado el DHCP del router ¿verdad?.

Tenemos varias opciones disponibles para encontrar nuestro dispositivo. Una es usar un escáner de dispositivos, otra es usar mDNS pero, la más segura y robusta es configurar una IP estática.

Afortunadamente, es muy sencillo configurar una IP estática en ESP32 con la función WiFi.config().

bool config(IPAddress local_ip,
      IPAddress gateway,
      IPAddress subnet,
      IPAddress dns1 = (uint32_t)0x00000000,
      IPAddress dns2 = (uint32_t)0x00000000);

Esta función debe ser llamada inmediatamente después de WiFi.begin(), que inicia la conexión con el DHCP activado. Con WiFi.config() podemos configurar la IP, gateway, subnet y, opcionalmente las dns.

Ejemplo en modo STA

Vamos a ver un ejemplo de cómo configurar una IP estática en modo STA, es decir, conectándonos a una WiFi existente. El siguiente ejemplo se conectaría a la red, y fijaría la IP a 192.168.1.200.

// Conectar
#include <WiFi.h>

// Configurar WiFi generada
const char *ssid = "SSID";
const char *password = "PASSWORD";

IPAddress ip(192,168,1,200);
IPAddress gateway(192,168,1,1);
IPAddress subnet(255,255,255,0);

void setup()
{
  Serial.begin(115200);
  delay(10);
  Serial.println();

  WiFi.mode(WIFI_STA);
  WiFi.config(ip, gateway, subnet);
  WiFi.begin(ssid, password);
  Serial.print("Conectando a:\t");
  Serial.println(ssid);

  // Esperar a que nos conectemos
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(200);
  Serial.print('.');
  }

  // Mostrar mensaje de exito y dirección IP asignada
  Serial.println("Conexión establecida");
  Serial.print("IP address:\t");
  Serial.println(WiFi.localIP());
}

void loop()
{
}

Hay que tener en cuenta que el router tiene que estar configurado para asignarnos la IP deseada. Típicamente, esto significa que debe estar fuera del rango de IP designadas para DHCP.

Ejemplo en modo AP

En modo AP la configuración de la IP estática es menos crítica que en modo STA. A fin de cuentas, estamos generando nuestra propia WiFi y nos ponemos la IP que queremos.

Aun así, la función WiFi.softAPConfig() permite cambiar los parámetros dentro de la red WiFi generada. El siguiente ejemplo muestra la configuración, donde también cambiamos la dirección del ESP8266 a 192.168.1.200.

#include <WiFi.h>

const char *ssid = "ESP8266_AP";
const char *password = "0123456789";

IPAddress ip(192, 168, 1, 200);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

void setup()
{
  Serial.begin(115200);
  delay(10);
  Serial.println();

  WiFi.softAP(ssid, password);
  WiFi.softAPConfig(ip, gateway, subnet);
  Serial.print("Iniciado AP:\t");
  Serial.println(ssid);

  Serial.print("IP address:\t");
  Serial.println(WiFi.softAPIP());
}

void loop() { }

Ejemplo resumido

Como hicimos en las entradas anteriores, si dividimos el código en distintos ficheros, el código queda resumido y más sencillo de mantener,

#include <WiFi.h>

#include "config.h"  // Sustituir con datos de vuestra red
#include "ESP32_Utils.hpp"

void setup()
{
  Serial.begin(115200);

  // Para modo STA
  ConnectWiFi_STA(true);

  // Para modo AP
  //ConnectWiFi_AP(true);
}

void loop()
{
}

void ConnectWiFi_STA(bool useStaticIP = false)
{
   Serial.println("");
   WiFi.mode(WIFI_STA);
   WiFi.begin(ssid, password);
   if(useStaticIP) WiFi.config(ip, gateway, subnet);
   while (WiFi.status() != WL_CONNECTED)
   {
     delay(100);
     Serial.print('.');
   }

   Serial.println("");
   Serial.print("Iniciado STA:\t");
   Serial.println(ssid);
   Serial.print("IP address:\t");
   Serial.println(WiFi.localIP());
}

void ConnectWiFi_AP(bool useStaticIP = false)
{
   Serial.println("");
   WiFi.mode(WIFI_AP);
   while(!WiFi.softAP(ssid, password))
   {
     Serial.println(".");
     delay(100);
   }
   if(useStaticIP) WiFi.softAPConfig(ip, gateway, subnet);

   Serial.println("");
   Serial.print("Iniciado AP:\t");
   Serial.println(ssid);
   Serial.print("IP address:\t");
   Serial.println(WiFi.softAPIP());
}

const char* ssid     = "ssid";
const char* password = "password";

¡Así de sencillo! Con esto nuestra placa usará siempre la misma dirección IP dentro de la red, que es justo lo que queremos cuando vamos a conectarnos a ella de forma habitual.

Descarga el código

Todo el código de esta entrada está disponible para su descarga en Github.

Versión para el ESP8266: https://github.com/luisllamasbinaburo/ESP8266-Examples

Versión para el ESP32: https://github.com/luisllamasbinaburo/ESP32-Examples