Arduino · Módulo 09 · Ej 01 — Conectar el ESP32 a una red WiFi y mostrar la IP asignada por Serial

Ejercicio 01 — Conectar el ESP32 a una red WiFi y mostrar la IP asignada por Serial

Dificultad: verde · Módulo 09 (Salto a ESP32 + WiFi)

Enunciado

Conectar el ESP32 a una red WiFi y mostrar la IP asignada por Serial.

Montaje (ESP32 DevKit)

Ninguno (solo la placa)

Cómo se resuelve

El primer programa con la placa nueva no enciende nada: se limita a entrar en una red y decir qué dirección le han dado. Parece poco, pero es el cimiento de todo lo que viene después, y contiene la única parte de WiFi que se repite en todos los sketches del módulo.

Lo primero es #include <WiFi.h>, la librería de red que trae el core del ESP32. No es una librería que se instale aparte: viene con la placa. Si el IDE se queja de que no encuentra WiFi.h, casi siempre significa que sigues con el Arduino UNO seleccionado, porque el UNO no tiene radio y por tanto no tiene esa cabecera.

Las credenciales van arriba, con nombre, en lugar de escritas dentro de la llamada:

const char* SSID     = "Wokwi-GUEST";
const char* PASSWORD = "";

const char* es la forma habitual en C++ de guardar un texto que no va a cambiar. Estos dos valores son los de Wokwi, el simulador: allí existe una red abierta llamada exactamente Wokwi-GUEST cuya contraseña es la cadena vacía "". No es un descuido ni un hueco por rellenar: es una red sin contraseña, y hay que dejar las comillas pegadas. Si vas a ejecutar esto en una placa física, estos dos valores hay que cambiarlos por el nombre y la contraseña de tu red real, respetando mayúsculas y minúsculas del SSID.

En setup() lo primero es Serial.begin(115200). Ojo con este número: en el UNO veníamos usando 9600, pero el ESP32 trabaja habitualmente a 115200 baudios, y el monitor serie tiene que estar puesto en esa misma velocidad. Si lo dejas en 9600 verás caracteres sin sentido y pensarás que el programa falla, cuando lo único que pasa es que los dos extremos hablan a ritmos distintos. El delay(100) que va justo detrás es un margen pequeño para que el puerto serie esté listo antes de imprimir; sin él, las primeras líneas a veces se pierden.

Después vienen las dos llamadas que hacen el trabajo:

WiFi.mode(WIFI_STA);
WiFi.begin(SSID, PASSWORD);

WIFI_STA es el modo estación: la placa se une a una red que ya existe, como haría un móvil. El otro modo posible sería crear su propia red, y no es el de este módulo. Declararlo explícitamente evita comportamientos raros si la placa quedó en otro modo de una ejecución anterior, porque el ESP32 recuerda parte de la configuración de red entre reinicios.

WiFi.begin() es la llamada que hay que entender bien: no espera a que la conexión se complete. Lanza el proceso y devuelve el control inmediatamente. Si la línea siguiente pidiera la IP, obtendrías 0.0.0.0, porque todavía no ha habido tiempo de negociar nada con el router. De ahí el bucle:

while (WiFi.status() != WL_CONNECTED) {
    delay(250);
    Serial.print(".");
}

WiFi.status() devuelve en qué punto está el proceso, y WL_CONNECTED es la constante que significa “ya estás dentro”. El bucle no hace nada útil salvo esperar: cada 250 ms comprueba de nuevo y imprime un punto. Ese punto no es decoración. Es la única señal visible de que la placa sigue intentándolo, y es lo que te permite distinguir “está tardando” de “se ha quedado colgada”. Sin él, una conexión que nunca llega y un programa muerto se ven exactamente igual desde el monitor.

Conviene ser consciente de una limitación de este patrón: si la red no existe o la contraseña está mal, el while no sale nunca. El programa se queda imprimiendo puntos para siempre. Es aceptable en un ejercicio de clase, donde ver los puntos es parte de lo que se quiere enseñar, pero en un aparato de verdad se le pondría un límite de intentos y un reintento o un reinicio. Esa es una de las preguntas de la teoría.

Cuando el bucle termina, ya hay conexión, y solo entonces tiene sentido preguntar la dirección:

Serial.println(WiFi.localIP());

Esa IP no la elige la placa: se la ha asignado el router por DHCP en el momento de aceptarla en la red. Es la dirección por la que el resto de la red puede hablar con el ESP32, y en el ejercicio 03 será la que escribas en el navegador. En Wokwi la red es simulada, así que la IP que verás es la que reparte el router virtual del simulador y solo existe dentro de esa simulación: no puedes abrirla desde el navegador de tu ordenador.

El loop() se queda vacío a propósito, con un comentario que lo explica. Todo el trabajo ocurre una sola vez, al arrancar, y una vez conectada la placa no hay nada que repetir. Es un caso poco frecuente en este curso, y merece la pena fijarse en por qué: conectarse a una red es una tarea de preparación, y la preparación vive en setup().

Para practicar — cópialo y complétalo

Pega este esqueleto y completa los TODO. Es la mejor forma de aprender: inténtalo antes de mirar la solución.

/*
 * Curso de Arduino — Módulo 09: ESP32 + WiFi
 * Ejercicio 01 — PRÁCTICA (rellena los TODO)
 * Enunciado: Conectar el ESP32 a una red WiFi y mostrar la IP asignada por Serial.
 * Dificultad: verde
 * Placa: ESP32 DevKit    Montaje: ninguno (solo la placa)
 * Correr: Arduino IDE / Wokwi (wokwi/ej01) / arduino-cli (ver README)
 * NOTA: en Wokwi la red es SSID "Wokwi-GUEST" SIN contraseña.
 */
// TODO: incluye la librería WiFi -> #include <WiFi.h>
 
const char* SSID     = "Wokwi-GUEST";
const char* PASSWORD = "";
 
void setup() {
    // TODO: arranca el Serial a 115200 -> Serial.begin(115200)
 
    // TODO: pon el modo estación -> WiFi.mode(WIFI_STA)
    // TODO: inicia la conexión -> WiFi.begin(SSID, PASSWORD)
 
    // TODO: espera en un while hasta que WiFi.status() == WL_CONNECTED
    //       (dentro: delay(250) y un Serial.print(".") para ver el progreso)
 
    // TODO: cuando conecte, imprime la IP -> Serial.println(WiFi.localIP())
}
 
void loop() {
    // nada en el bucle
}

Solución — cópiala y ejecútala

/*
 * Curso de Arduino — Módulo 09: ESP32 + WiFi
 * Ejercicio 01 — MODELO (resuelto)
 * Enunciado: Conectar el ESP32 a una red WiFi y mostrar la IP asignada por Serial.
 * Dificultad: verde
 * Placa: ESP32 DevKit    Montaje: ninguno (solo la placa)
 * Correr: Arduino IDE / Wokwi (wokwi/ej01) / arduino-cli (ver README)
 * NOTA: en Wokwi la red es SSID "Wokwi-GUEST" SIN contraseña.
 */
#include <WiFi.h>                         // librería WiFi del core ESP32
 
const char* SSID     = "Wokwi-GUEST";     // nombre de la red
const char* PASSWORD = "";                // Wokwi-GUEST no tiene contraseña
 
void setup() {
    Serial.begin(115200);                 // el ESP32 suele usar 115200 baudios
    delay(100);
 
    Serial.print("Conectando a ");
    Serial.println(SSID);
 
    WiFi.mode(WIFI_STA);                  // modo estación (nos unimos a una red existente)
    WiFi.begin(SSID, PASSWORD);           // arranca el intento de conexión
 
    while (WiFi.status() != WL_CONNECTED) {  // esperar hasta estar conectados
        delay(250);
        Serial.print(".");
    }
 
    Serial.println();
    Serial.println("WiFi conectado.");
    Serial.print("IP asignada: ");
    Serial.println(WiFi.localIP());       // la IP que nos dio el router (DHCP)
}
 
void loop() {
    // nada que hacer en bucle: la conexión ya está hecha en setup()
}

Cómo ejecutar la simulación

Sin instalar nada, en el navegador

1. Abre wokwi.com y crea un proyecto nuevo de la placa que pide el ejercicio.
2. Pega la solución (o tu intento) en la pestaña sketch.ino.
3. Abre la pestaña diagram.json, borra lo que haya y pega el circuito de aquí abajo.
4. Dale al play. Verás el circuito funcionando: LEDs, pantallas y monitor serie.

Circuito del ejercicio (diagram.json)

{
  "version": 1,
  "author": "ESIBot",
  "editor": "wokwi",
  "parts": [
    { "type": "board-esp32-devkit-c-v4", "id": "esp", "top": 0, "left": 0, "attrs": {} }
  ],
  "connections": [],
  "dependencies": {}
}

En VS Code, con el repo del curso

El paquete de simulación de este ejercicio está en practica/09-esp32-wifi/wokwi/ej01/. Con la extensión Wokwi instalada y la licencia activada (lo cuenta el onboarding del curso):

make sim EJ=09-esp32-wifi/ej01

y después, en VS Code, Ctrl+Shift+P → Wokwi: Start Simulator. La extensión no compila: simula un firmware ya compilado, y de compilarlo se encarga ese make.

Cómo usarlo

Con placa: abre el .ino en el Arduino IDE, elige placa y puerto y pulsa Subir. Sin placa: simulalo en Wokwi con cualquiera de las dos vias de arriba. Antes de mirar la solucion, intenta completar tu el esqueleto: es la mejor forma de aprender.

Conexiones

• Teoría del módulo
• Índice del curso