ESP-01 con Arduino: comandos AT, programación y control de relé

El ESP-01 es un módulo diminuto (24,8 × 14,3 mm) y muy barato que lleva el chip Wi-Fi ESP8266. Al conectar el ESP-01 a Arduino puedes añadir Wi-Fi con unos pocos cables a una placa sin conexión inalámbrica, como el Uno o el Nano. El módulo viene de fábrica con un firmware de comandos AT: el Arduino envía por el puerto serie comandos de texto cortos como "AT+CWJAP", y el ESP-01 se conecta a la red, envía y recibe datos. Si lo prefieres, también puedes programar el ESP-01 como un microcontrolador independiente, sin ningún Arduino; su procesador es mucho más rápido que el del Uno.

En esta guía aprenderás los 8 pines del ESP-01 y por qué necesita sí o sí una alimentación de 3,3 V potente. Después verás paso a paso los comandos AT con un Arduino Uno, una página web que enciende un LED desde el móvil, la programación directa con un adaptador USB-TTL (el método de GPIO0 a GND), el control de una lámpara con el módulo relé ESP-01S y su uso con una Raspberry Pi Pico. Al final encontrarás las soluciones a los errores más comunes y cuándo conviene más un NodeMCU o un ESP32.

¿Qué es el ESP-01 y cómo funciona?

El ESP-01 es el primer y más pequeño módulo que Ai-Thinker diseñó alrededor del chip ESP8266EX. La placa lleva el chip, un cristal de 26 MHz, la memoria flash donde se guardan el programa y la configuración, y una antena serpenteante impresa en la PCB; no tiene puerto USB, regulador de voltaje ni botones. Por eso el ESP-01 no se puede enchufar directamente al ordenador: la alimentación y la conexión serie las tienes que montar tú. Puedes usar el módulo de dos formas: como módem Wi-Fi (con el firmware AT instalado, el Arduino envía comandos) o como microcontrolador independiente (subes tu propio programa desde el Arduino IDE y el firmware AT se borra). La mayoría de los módulos que se venden hoy son la versión negra ESP-01S.

Diferencias entre ESP-01 y ESP-01S

Pines del ESP-01: para qué sirve cada uno

El ESP-01 tiene 8 pines en un conector de 2×4, y solo cuatro de ellos se pueden usar como entradas y salidas. No todas las placas llevan los nombres de los pines impresos, así que compara tu módulo con el esquema del vendedor antes de cablearlo: invertir VCC y GND quema el módulo en segundos. Estas son las funciones de los pines y su conexión en funcionamiento normal:

Consumo: por qué no basta el pin de 3,3 V del Arduino

La mayoría de los problemas que queman el ESP-01 o lo hacen reiniciarse sin parar vienen de la alimentación. Conectado al Wi-Fi, el módulo consume de media 70–80 mA y unos 170 mA al transmitir; en el arranque y al conectarse a la red puede haber picos breves de más de 300 mA. El pin de 3,3 V del Arduino Uno, en cambio, solo da oficialmente 50 mA. Un ESP-01 alimentado desde ese pin suele responder al comando "AT", pero en cuanto intenta conectarse a la red la tensión cae y el módulo se reinicia, algo que parece un fallo de software. La solución es un regulador AMS1117-3.3 (1 A) alimentado con 5 V y un condensador electrolítico de 100–470 µF entre VCC y GND del módulo. En el artículo del regulador de voltaje 7805 explicamos cómo funcionan los reguladores.

Cómo conectar el ESP-01 al Arduino Uno (para comandos AT)

El único puerto serie por hardware del Arduino Uno (D0 y D1) se comparte con la conexión USB. Por eso lo más práctico es conectar el ESP-01 a los pines D2 y D3 con la librería SoftwareSerial: no tienes que desconectar el ESP-01 al subir código al Uno y el Monitor Serie queda libre para depurar. La Raspberry Pi Pico ya funciona a 3,3 V, así que no necesita divisor:

Para bajar la señal de 5 V que sale del pin D3 del Uno, pon una resistencia de 1 kΩ entre D3 y el RX del ESP-01, y otra de 2 kΩ entre el RX del ESP-01 y GND. La tensión de salida es 5 × 2 / (1 + 2) = 3,33 V; con 2,2 kΩ en lugar de 2 kΩ obtienes 3,44 V, y ambas son seguras. Puedes calcular otros valores con la calculadora de divisor de tensión. En el sentido contrario no hace falta divisor: los 3,3 V del pin TX del ESP-01 superan el umbral de 3 V a partir del cual el Uno lee HIGH. Explicamos a fondo los fundamentos de la comunicación serie en el artículo de comunicación serie UART.

Primera prueba: enviar comandos AT desde el Monitor Serie

1. Sube al Uno el sketch puente de abajo; en el primer intento pon ESP_BAUD en 115200, porque la mayoría de los módulos vienen a esa velocidad (los antiguos pueden venir a 9600).
2. Abre el Monitor Serie a 115200 baudios y ajusta el fin de línea en Both NL & CR; sin este ajuste el módulo no sabe que el comando ha terminado.
3. Escribe AT y envíalo; deberías ver OK. Si aparecen caracteres raros, las velocidades no coinciden.
4. SoftwareSerial no lee bien a 115200, así que baja la velocidad del módulo de forma permanente a 9600 con AT+UART_DEF=9600,8,1,0,0. Aunque la respuesta salga corrupta, el comando suele llegar.
5. Cambia ESP_BAUD a 9600 en el sketch, vuelve a subirlo y repite el comando AT; ahora la respuesta OK debería verse limpia.
6. Comprueba que el módulo funciona bien consultando la versión del firmware con AT+GMR y las redes Wi-Fi cercanas con AT+CWLAP.

1#include <SoftwareSerial.h>
2
3SoftwareSerial esp(2, 3);          // D2 = RX, D3 = TX (bölücüyle ESP RX'e) / D3 to ESP RX via divider
4
5const long ESP_BAUD = 9600;        // ilk denemede 115200 yap / use 115200 on the first try
6
7void setup() {
8  Serial.begin(115200);            // Seri Monitör hızı / Serial Monitor speed
9  esp.begin(ESP_BAUD);
10  Serial.println("AT komutu yaz / type an AT command");
11}
12
13void loop() {
14  if (esp.available()) {           // ESP-01'den geleni ekrana yaz / ESP-01 -> screen
15    Serial.write(esp.read());
16  }
17  if (Serial.available()) {        // klavyeden yazılanı ESP-01'e gönder / keyboard -> ESP-01
18    esp.write(Serial.read());
19  }
20}

Los comandos AT más usados del ESP-01

Controlar un LED desde el móvil con Arduino Uno y ESP-01

Ahora convirtamos los comandos AT en un programa. El siguiente código conecta el ESP-01 a tu red, abre un pequeño servidor web en el puerto 80 y muestra la dirección IP en el Monitor Serie. Si escribes esa dirección en el navegador de un móvil conectado al mismo Wi-Fi, se abre una página con dos botones que encienden y apagan el LED integrado en el pin 13 del Uno. Si en lugar del LED conectas un módulo relé, controlarás una lámpara del mismo modo. Antes de subirlo, asegúrate de haber puesto la velocidad del módulo en 9600 en el paso anterior.

1#include <SoftwareSerial.h>
2
3SoftwareSerial esp(2, 3);              // D2 = RX, D3 = TX (bölücüyle) / D3 via divider
4const int LED_PIN = 13;                // Uno'nun dahili LED'i / Uno onboard LED
5
6const char* WIFI_SSID = "AgAdi";       // Wi-Fi adın / your Wi-Fi name
7const char* WIFI_PASS = "Sifre123";    // Wi-Fi şifren / your Wi-Fi password
8
9bool ledOn = false;
10bool pending = false;                  // cevap bekleyen istek var mı / request waiting for a reply
11int linkId = 0;                        // ESP-01'in bağlantı numarası (0-4) / connection id (0-4)
12char line[64];
13byte lineLen = 0;
14
15// Beklenen yazıyı süre dolana kadar ara / wait until the expected text arrives or time runs out
16bool waitFor(const char* expect, unsigned long timeout) {
17  unsigned long start = millis();
18  size_t idx = 0;
19  size_t len = strlen(expect);
20  while (millis() - start < timeout) {
21    if (esp.available()) {
22      char c = esp.read();
23      Serial.write(c);                 // gelen her şeyi göster / echo everything
24      if (c == expect[idx]) {
25        idx++;
26        if (idx == len) return true;
27      } else {
28        idx = (c == expect[0]) ? 1 : 0;
29      }
30    }
31  }
32  return false;
33}
34
35bool sendAT(const char* cmd, const char* expect, unsigned long timeout) {
36  esp.println(cmd);                    // println sonuna \r\n ekler / println adds \r\n
37  return waitFor(expect, timeout);
38}
39
40void sendPage(int id) {
41  char body[220];
42  snprintf(body, sizeof(body),
43           "<meta name='viewport' content='width=device-width'>"
44           "<h2>LED: %s</h2>"
45           "<a href='/on'><button>AC / ON</button></a> "
46           "<a href='/off'><button>KAPAT / OFF</button></a>",
47           ledOn ? "ACIK / ON" : "KAPALI / OFF");
48  char head[110];
49  snprintf(head, sizeof(head),
50           "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n"
51           "Content-Length: %d\r\nConnection: close\r\n\r\n",
52           (int)strlen(body));
53
54  esp.print("AT+CIPSEND=");            // önce kaç bayt gideceğini söyle / announce the length first
55  esp.print(id);
56  esp.print(',');
57  esp.println(strlen(head) + strlen(body));
58  if (waitFor(">", 2000)) {            // ">" gelince veriyi yolla / send data after ">"
59    esp.print(head);
60    esp.print(body);
61    waitFor("SEND OK", 5000);
62  }
63  esp.print("AT+CIPCLOSE=");           // bağlantıyı kapat / close the connection
64  esp.println(id);
65  waitFor("OK", 2000);
66}
67
68void handleLine() {
69  if (strncmp(line, "+IPD,", 5) == 0) {          // yeni istek / new request: +IPD,0,384:GET /on ...
70    linkId = line[5] - '0';
71    if (strstr(line, "GET /on ")) ledOn = true;
72    else if (strstr(line, "GET /off ")) ledOn = false;
73    digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
74    pending = true;
75  } else if (pending && lineLen == 0) {           // boş satır = isteğin sonu / empty line = end of request
76    pending = false;
77    sendPage(linkId);
78  }
79}
80
81void setup() {
82  pinMode(LED_PIN, OUTPUT);
83  Serial.begin(115200);
84  esp.begin(9600);                     // AT+UART_DEF=9600,8,1,0,0 ile ayarlanmış olmalı / set with AT+UART_DEF
85
86  sendAT("AT+RST", "ready", 5000);     // temiz başlangıç / clean restart
87  sendAT("AT+CWMODE=1", "OK", 2000);   // istemci modu / station mode
88
89  esp.print("AT+CWJAP=\"");            // AT+CWJAP="ad","şifre" / AT+CWJAP="ssid","password"
90  esp.print(WIFI_SSID);
91  esp.print("\",\"");
92  esp.print(WIFI_PASS);
93  esp.println("\"");
94  if (!waitFor("OK", 20000)) {
95    Serial.println(F("\nWi-Fi baglanamadi / Wi-Fi failed"));
96  }
97
98  sendAT("AT+CIPMUX=1", "OK", 2000);         // sunucu için çoklu bağlantı / multiple connections
99  sendAT("AT+CIPSERVER=1,80", "OK", 2000);   // 80 portunda sunucu / server on port 80
100  sendAT("AT+CIFSR", "OK", 2000);            // IP adresini yaz / print the IP address
101}
102
103void loop() {
104  while (esp.available()) {            // ESP-01'den gelenleri satır satır oku / read line by line
105    char c = esp.read();
106    if (c == '\n') {
107      line[lineLen] = '\0';
108      handleLine();
109      lineLen = 0;
110    } else if (c != '\r' && lineLen < sizeof(line) - 1) {
111      line[lineLen++] = c;
112    }
113  }
114}

Así funciona el código: cuando un navegador se conecta, el ESP-01 pasa la petición al Arduino con el formato +IPD,0,384:GET /on HTTP/1.1, donde 0 es el número de conexión y 384 la cantidad de bytes recibidos. El Arduino busca "GET /on" o "GET /off" en esa línea y ajusta el LED. Cuando llega la línea vacía que marca el final de la petición, anuncia con AT+CIPSEND=0,longitud cuántos bytes va a enviar, manda la página cuando el módulo muestra el signo ">" y cierra la conexión con AT+CIPCLOSE tras la respuesta "SEND OK". Hemos hecho la página corta a propósito: los 2 KB de RAM del Uno no dan para textos HTML largos y un solo CIPSEND puede enviar como mucho 2048 bytes. En proyectos más complejos, una librería como WiFiEspAT te evita gestionar los comandos AT a mano.

Programar el ESP-01 directamente: el método de GPIO0 a GND

El ESP8266 que hay dentro del ESP-01, con su procesador de 32 bits a 80 MHz, es mucho más potente que un Arduino Uno. Si tu proyecto solo tiene un relé, un sensor o un LED, no necesitas ningún Arduino: subes el programa directamente al ESP-01. Al arrancar, el ESP8266 mira el nivel de los pines GPIO0, GPIO2 y GPIO15 para decidir qué hacer. En la placa del ESP-01, GPIO15 ya está conectado a GND y GPIO2 debe quedar en HIGH, así que el modo de arranque lo decide solo GPIO0:

1. En el Arduino IDE abre Archivo > Preferencias y añade https://arduino.esp8266.com/stable/package_esp8266com_index.json en el campo "URLs adicionales de gestor de placas".
2. En el Gestor de placas busca esp8266 e instala el paquete de ESP8266 Community.
3. En Herramientas > Placa elige Generic ESP8266 Module. Pon Flash Size en 1MB (FS:64KB OTA:~470KB) para el ESP-01S, o en una de las opciones de 512KB para el antiguo ESP-01 azul.
4. Pon el jumper del adaptador USB-TTL en 3,3 V, cablea el módulo según la tabla de arriba y deja GPIO0 conectado a GND.
5. Quita y vuelve a dar alimentación al módulo, o toca un instante RST con GND; el módulo arranca ahora en modo programación.
6. Elige el puerto del USB-TTL en Herramientas > Puerto y sube el código. Para la primera prueba sirve Archivo > Ejemplos > ESP8266 > Blink; en el ESP-01S el LED azul está en GPIO2.
7. Cuando aparezca "Hard resetting via RTS pin...", desconecta GPIO0 de GND y reinicia el módulo. Si GPIO0 sigue en GND, tu programa no se ejecuta y el módulo vuelve a arrancar en modo programación.

Control de relé con GPIO0 y GPIO2: el módulo relé ESP-01S

Los pines de uso general del ESP-01 son GPIO0 y GPIO2, pero los dos deben estar en HIGH durante el arranque. Por eso, lo que conectes a ellos no debe tirar del pin a LOW mientras la placa arranca. La solución más segura es una conexión activa en LOW: al arrancar el pin está en HIGH y el relé sigue apagado, y cuando tu programa pone el pin en LOW el relé se activa. El módulo relé ESP-01S que se vende ya montado está diseñado justo así: se alimenta con 5 V, su regulador genera 3,3 V para el ESP-01S y GPIO0 maneja, a través de un transistor, un relé con contactos de 10 A 250 V AC. En las placas v4.0 y posteriores el relé se activa con GPIO0 en LOW; las antiguas v1.0 pueden necesitar una pequeña modificación para funcionar con el ESP-01S, así que comprueba la versión de tu placa.

1#include <ESP8266WiFi.h>
2#include <ESP8266WebServer.h>
3#include <ESP8266mDNS.h>
4
5const char* ssid = "AgAdi";            // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123";     // Wi-Fi şifren / your Wi-Fi password
7
8const int RELAY_PIN = 0;               // ESP-01S röle kartında GPIO0 / GPIO0 on the ESP-01S relay board
9const int RELAY_ON = LOW;              // çoğu kartta LOW = çeker; tersse değiştir / LOW = on, swap if yours is inverted
10const int RELAY_OFF = HIGH;
11
12ESP8266WebServer server(80);
13bool relayOn = false;
14
15void sendPage() {
16  String html = F("<!DOCTYPE html><html><head><meta charset='utf-8'>"
17                  "<meta name='viewport' content='width=device-width,initial-scale=1'>"
18                  "<title>ESP-01</title></head>"
19                  "<body style='font-family:sans-serif;text-align:center'>"
20                  "<h1>ESP-01 Röle / Relay</h1><p><b>");
21  html += relayOn ? "AÇIK / ON" : "KAPALI / OFF";
22  html += F("</b></p><p><a href='/on'><button>AÇ / ON</button></a> "
23            "<a href='/off'><button>KAPAT / OFF</button></a></p></body></html>");
24  server.send(200, "text/html", html);
25}
26
27void setRelay(bool on) {
28  relayOn = on;
29  digitalWrite(RELAY_PIN, on ? RELAY_ON : RELAY_OFF);
30  server.sendHeader("Location", "/");  // ana sayfaya dön / back to the main page
31  server.send(303, "text/plain", "");
32}
33
34void setup() {
35  digitalWrite(RELAY_PIN, RELAY_OFF);  // önce kapalı seviye / off level first
36  pinMode(RELAY_PIN, OUTPUT);
37  Serial.begin(115200);
38
39  WiFi.mode(WIFI_STA);
40  WiFi.begin(ssid, password);
41  while (WiFi.status() != WL_CONNECTED) {
42    delay(500);
43    Serial.print('.');
44  }
45  Serial.println();
46  Serial.println(WiFi.localIP());      // bu adresi tarayıcıda aç / open this address in a browser
47  MDNS.begin("esp01");                 // ya da http://esp01.local / or http://esp01.local
48
49  server.on("/", sendPage);
50  server.on("/on", []() { setRelay(true); });
51  server.on("/off", []() { setRelay(false); });
52  server.begin();
53}
54
55void loop() {
56  server.handleClient();
57  MDNS.update();
58}

Después de subir el código al ESP-01S con el método anterior, coloca el módulo en la placa de relé y aliméntala con 5 V. Puedes leer la dirección IP en el Monitor Serie con el USB-TTL conectado o buscarla en la lista de dispositivos de tu router; desde un ordenador compatible con mDNS también funciona http://esp01.local. Si quieres añadir una entrada, como un pulsador, el mejor pin es GPIO3 (RX), porque su nivel no importa en el arranque. En ese caso usa Serial.begin(115200, SERIAL_8N1, SERIAL_TX_ONLY) para abrir el puerto serie solo en modo transmisión.

ESP-01 con la Raspberry Pi Pico (MicroPython)

También puedes dar conexión inalámbrica a una Raspberry Pi Pico sin Wi-Fi con un ESP-01. Como la Pico funciona a 3,3 V, no hace falta divisor de tensión: el RX del ESP-01 va a GP0 (UART0 TX) y su TX a GP1 (UART0 RX). La UART por hardware de la Pico lee 115200 baudios sin problema, así que tampoco necesitas cambiar la velocidad del módulo; si ya la bajaste a 9600 en la sección del Uno, pon también baudrate a 9600 en el código. Ejecuta el código MicroPython de abajo con Thonny; el módulo se conecta a la red, muestra su dirección IP y lista las redes cercanas cada 30 segundos. Si tienes una Pico W, es más fácil usar su Wi-Fi integrado; mira el artículo del servidor web Wi-Fi con Pico W.

1from machine import UART, Pin
2import time
3
4# GP0 (TX) -> ESP-01 RX, GP1 (RX) <- ESP-01 TX
5uart = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1))
6
7def at(cmd, timeout=2000):
8    uart.write(cmd + "\r\n")                   # her komut \r\n ile biter / every command ends with \r\n
9    start = time.ticks_ms()
10    resp = b""
11    while time.ticks_diff(time.ticks_ms(), start) < timeout:
12        if uart.any():
13            resp += uart.read()
14            if b"OK" in resp or b"ERROR" in resp or b"FAIL" in resp:
15                break
16    print(cmd, "->", resp)                     # cevabı göster / show the reply
17    return resp
18
19at("ATE0")                                     # komut yankısını kapat / turn off echo
20at("AT")                                       # OK gelmeli / should answer OK
21at("AT+CWMODE=1")                              # istemci modu / station mode
22at('AT+CWJAP="AgAdi","Sifre123"', 20000)       # Wi-Fi'ye bağlan / join Wi-Fi
23at("AT+CIFSR")                                 # IP adresini sor / ask for the IP
24
25while True:
26    at("AT+CWLAP", 10000)                      # çevredeki ağları tara / scan nearby networks
27    time.sleep(30)

¿ESP-01, NodeMCU o ESP32?

Las grandes ventajas del ESP-01 son su tamaño y su precio; es ideal para añadir Wi-Fi a un proyecto Arduino que ya tienes o para hacer inalámbrico un relé o un sensor. Pero como no tiene USB, cambiar cables, montar un regulador y poner GPIO0 a GND en cada carga resulta pesado. No tiene entrada analógica y, como GPIO16 no está accesible, despertar del deep sleep por temporizador no funciona si no sueldas un cable fino a una patilla del chip. Si planeas un proyecto con pilas, introduce el consumo medio en la calculadora de duración de batería para ver cuántos días aguantará. Si estás aprendiendo o necesitas más de tres pines, el NodeMCU ESP8266 ofrece el mismo chip con USB y regulador. Si necesitas Bluetooth, más pines y más potencia, el ESP32 es la opción correcta; comparamos las placas en ¿Arduino o ESP32?

Ideas de proyectos con el ESP-01

• Enchufe inteligente Wi-Fi: enciende y apaga una lámpara desde el móvil con el módulo relé ESP-01S y el código de arriba; añade un temporizador para que se encienda sola por la tarde.
• Sensor de temperatura inalámbrico: conecta un sensor DS18B20 a GPIO2; la resistencia pull-up de 4,7 kΩ de la línea de datos también da el nivel HIGH que necesita el arranque.
• Monitor de humedad y temperatura: muestra las lecturas de un DHT11 en una página web que abres en el móvil.
• Aviso de movimiento: conecta un sensor PIR a GPIO3 y envía un mensaje de Telegram al detectar movimiento; el método es muy parecido al del artículo del bot de Telegram con ESP32.
• Wi-Fi para un proyecto Arduino: envía con comandos AT las lecturas de una estación meteorológica hecha con el Uno a un programa de tu ordenador o a un servidor.
• Mando de puerta de garaje: conecta los contactos del relé en paralelo con el pulsador del motor de la puerta y ábrela desde el móvil.

Errores comunes y cómo solucionarlos

A pesar de su pequeño tamaño, el ESP-01 es un módulo estupendo para aprender todos los conceptos básicos del Wi-Fi: direcciones IP, conexiones TCP, servidores web y comunicación serie. Si algo no funciona, revisa primero la alimentación, luego las líneas TX-RX y el nivel de GPIO0; la gran mayoría de los problemas están en esos tres puntos. En la app BlueGrays encontrarás proyectos como conexión Wi-Fi, servidor web, mDNS, actualización inalámbrica (OTA) e iluminación inteligente con relé, con esquemas y código paso a paso.