ESP-01 com Arduino: comandos AT, programação e relé

O ESP-01 é um módulo minúsculo (24,8 × 14,3 mm) e muito barato, construído em torno do chip Wi-Fi ESP8266. Ao ligar o ESP-01 a um Arduino, você adiciona Wi-Fi a uma placa sem conexão sem fio, como um Uno ou um Nano, com apenas alguns fios. O módulo vem de fábrica com o firmware de comandos AT: o Arduino envia pela serial comandos de texto curtos como “AT+CWJAP”, e o ESP-01 se conecta à rede, envia e recebe dados. Se preferir, você também pode programar o ESP-01 como um microcontrolador independente, sem Arduino nenhum; o processador dele é muito mais rápido que o do Uno.

Neste guia você vai aprender os 8 pinos do ESP-01, por que ele precisa obrigatoriamente de uma alimentação de 3,3 V forte, como usar comandos AT com um Arduino Uno, como criar uma página web que liga um LED pelo celular, como programar o módulo direto com um adaptador USB-TTL (o método do GPIO0 no GND), como controlar uma lâmpada com o módulo relé ESP-01S e como usá-lo com um Raspberry Pi Pico. No final, você encontra as soluções para os erros mais comuns e quando um NodeMCU ou um ESP32 é a melhor escolha.

O que é o ESP-01 e como ele funciona?

O ESP-01 é o primeiro e menor módulo que a Ai-Thinker projetou em torno do chip ESP8266EX. A placa traz o chip, um cristal de 26 MHz, a memória flash que guarda o programa e as configurações e uma antena de PCB em zigue-zague; não há porta USB, regulador de tensão nem botão. Por isso o ESP-01 não pode ser ligado direto ao computador: você mesmo precisa fornecer a alimentação e a conexão serial. Dá para usar o módulo de duas formas: como modem Wi-Fi (o firmware AT está instalado e o Arduino envia comandos) ou como microcontrolador independente (você carrega seu próprio programa pela Arduino IDE e o firmware AT é apagado). A maioria dos módulos vendidos hoje é a versão preta, o ESP-01S.

ESP-01 ou ESP-01S: as diferenças

Pinagem do ESP-01: a função dos 8 pinos

O ESP-01 tem 8 pinos em uma barra 2×4, e só quatro deles podem ser usados como entradas e saídas. Nem toda placa tem os nomes dos pinos impressos, então compare seu módulo com a pinagem do vendedor antes de ligá-lo: inverter VCC e GND queima o módulo em segundos. Veja a função de cada pino e como ele é ligado na operação normal:

Consumo de corrente: por que o pino 3,3 V do Arduino não basta

A maioria dos problemas que queimam o ESP-01 ou o deixam reiniciando sem parar vem da alimentação. Conectado ao Wi-Fi, o módulo consome em média 70–80 mA e cerca de 170 mA transmitindo; picos curtos na inicialização e na conexão à rede podem passar de 300 mA. Já o pino 3,3 V do Arduino Uno é especificado oficialmente para apenas 50 mA. Um ESP-01 alimentado por esse pino muitas vezes responde ao comando “AT”, mas no momento em que tenta se conectar a uma rede a tensão despenca e o módulo reinicia, o que parece um bug de software. A solução é um regulador AMS1117-3.3 (1 A) alimentado com 5 V, mais um capacitor eletrolítico de 100–470 µF entre os pinos VCC e GND do módulo. Você vê como os reguladores funcionam no artigo sobre o regulador de tensão 7805.

Ligando o ESP-01 ao Arduino Uno (para comandos AT)

A única porta serial de hardware do Arduino Uno (D0 e D1) é compartilhada com a conexão USB. Por isso o jeito mais prático é ligar o ESP-01 aos pinos D2 e D3 com a biblioteca SoftwareSerial: você não precisa desconectar o ESP-01 ao carregar código no Uno, e o Monitor Serial fica livre para depuração. O Raspberry Pi Pico já funciona com 3,3 V, então não precisa de divisor:

Para baixar o sinal de 5 V que sai do pino D3 do Uno, ligue um resistor de 1 kΩ do D3 ao RX do ESP-01 e um resistor de 2 kΩ do RX do ESP-01 ao GND. A saída fica em 5 × 2 / (1 + 2) = 3,33 V; com 2,2 kΩ no lugar de 2 kΩ você obtém 3,44 V, e as duas opções são seguras. Você pode calcular outros valores de resistor com a ferramenta Divisor de tensão. No sentido contrário não precisa de divisor: os 3,3 V do pino TX do ESP-01 ficam acima do limiar de 3 V que o Uno lê como HIGH. Explicamos os fundamentos da comunicação serial em detalhes no artigo sobre comunicação serial UART.

Primeiro teste: enviando comandos AT pelo Monitor Serial

1. Carregue no Uno o sketch de ponte abaixo; na primeira tentativa, defina ESP_BAUD como 115200, porque a maioria dos módulos vem com essa velocidade (os mais antigos podem usar 9600).
2. Abra o Monitor Serial em 115200 baud e defina o final de linha como Ambos, NL e CR; sem isso o módulo nunca sabe que o comando terminou.
3. Digite AT e envie; você deve ver OK. Se aparecerem caracteres estranhos, as velocidades não estão batendo.
4. A SoftwareSerial não consegue ler de forma confiável a 115200, então baixe a velocidade do módulo para 9600 de forma permanente com AT+UART_DEF=9600,8,1,0,0. Mesmo que a resposta pareça embaralhada, o comando costuma chegar.
5. Mude ESP_BAUD no sketch para 9600, carregue de novo e repita o comando AT; a resposta OK agora deve aparecer limpa.
6. Confirme que o módulo está funcionando bem lendo a versão do firmware com AT+GMR e listando as redes Wi-Fi próximas com 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}

Os comandos AT mais úteis do ESP-01

Controlando um LED pelo celular com Arduino Uno e ESP-01

Agora vamos transformar os comandos AT em um programa. O sketch abaixo conecta o ESP-01 à sua rede, abre um pequeno servidor web na porta 80 e mostra o endereço IP no Monitor Serial. Quando você digita esse endereço no navegador de um celular conectado ao mesmo Wi-Fi, abre uma página com dois botões; eles ligam e desligam o LED integrado no pino 13 do Uno. Ligue um módulo relé no lugar do LED e o mesmo método controla uma lâmpada. Antes de carregar, confira se você ajustou a velocidade do módulo para 9600 no passo 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}

Veja como o código funciona: quando um navegador se conecta, o ESP-01 repassa a requisição ao Arduino como +IPD,0,384:GET /on HTTP/1.1, em que 0 é o número da conexão e 384 é a quantidade de bytes recebidos. O Arduino procura “GET /on” ou “GET /off” nessa linha e ajusta o LED. Quando chega a linha em branco que marca o fim da requisição, ele informa quantos bytes vai enviar com AT+CIPSEND=0,tamanho, envia a página assim que o módulo mostra o sinal “>” e fecha a conexão com AT+CIPCLOSE depois da resposta “SEND OK”. Deixamos a página curta de propósito: os 2 KB de RAM do Uno não dão conta de textos HTML longos, e um único CIPSEND envia no máximo 2048 bytes. Em projetos mais complexos, uma biblioteca como a WiFiEspAT poupa você de gerenciar os comandos AT por conta própria.

Programando o ESP-01 diretamente: o método do GPIO0 no GND

O ESP8266 dentro do ESP-01, com seu processador de 32 bits a 80 MHz, é muito mais potente que um Arduino Uno. Se o seu projeto tem só um relé, um sensor ou um LED, você não precisa de Arduino nenhum: basta carregar o programa direto no ESP-01. Ao inicializar, o ESP8266 verifica os níveis de GPIO0, GPIO2 e GPIO15 para decidir o que fazer. Na placa do ESP-01, o GPIO15 já está ligado ao GND e o GPIO2 precisa ficar em HIGH, então só o GPIO0 define o modo de inicialização:

1. Na Arduino IDE, abra Arquivo > Preferências e adicione https://arduino.esp8266.com/stable/package_esp8266com_index.json ao campo “URLs do Gerenciador de Placas Adicionais”.
2. No Gerenciador de Placas, busque esp8266 e instale o pacote ESP8266 Community.
3. Escolha Generic ESP8266 Module em Ferramentas > Placa. Defina Flash Size como 1MB (FS:64KB OTA:~470KB) para o ESP-01S, ou uma das opções de 512KB para o antigo ESP-01 azul.
4. Coloque o jumper do adaptador USB-TTL em 3,3 V, ligue o módulo conforme a tabela acima e mantenha o GPIO0 conectado ao GND.
5. Corte a alimentação do módulo e ligue de novo, ou encoste rapidamente o RST no GND; agora o módulo inicializa no modo de programação.
6. Selecione a porta do adaptador USB-TTL em Ferramentas > Porta e carregue o sketch. Arquivo > Exemplos > ESP8266 > Blink é um bom primeiro teste; no ESP-01S o LED azul fica no GPIO2.
7. Quando aparecer “Hard resetting via RTS pin...”, desconecte o GPIO0 do GND e reinicie o módulo. Se o GPIO0 continuar no GND, seu programa não roda e o módulo inicializa de novo no modo de programação.

Controle de relé com GPIO0 e GPIO2: o módulo relé ESP-01S

Os pinos de uso geral do ESP-01 são o GPIO0 e o GPIO2, mas os dois precisam estar em HIGH durante a inicialização. Então, o que você ligar neles não pode puxar o pino para LOW enquanto a placa inicia. A solução mais segura é uma ligação ativa em LOW: o pino está em HIGH na inicialização, então o relé fica desligado, e quando seu programa coloca o pino em LOW o relé liga. O módulo relé ESP-01S pronto foi projetado exatamente assim: funciona com 5 V, o regulador da placa gera 3,3 V para o ESP-01S e o GPIO0 aciona, por meio de um transistor, um relé com contatos de 10 A 250 V AC. Nas placas v4.0 e posteriores, o relé liga quando o GPIO0 está em LOW; as placas antigas v1.0 podem precisar de uma pequena modificação para funcionar com o ESP-01S, então confira a versão da sua 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}

Depois de carregar o sketch no ESP-01S com o método acima, encaixe o módulo na placa de relé e alimente a placa com 5 V. Você pode ler o endereço IP no Monitor Serial enquanto o adaptador USB-TTL estiver conectado, ou encontrá-lo na lista de dispositivos conectados do roteador; em um computador com suporte a mDNS, http://esp01.local também funciona. Se quiser adicionar uma entrada, como um botão, o melhor pino é o GPIO3 (RX), porque o nível dele não importa na inicialização. Nesse caso, use Serial.begin(115200, SERIAL_8N1, SERIAL_TX_ONLY) para abrir a porta serial só no modo de transmissão.

ESP-01 com o Raspberry Pi Pico (MicroPython)

Você também pode adicionar conexão sem fio a um Raspberry Pi Pico sem Wi-Fi usando um ESP-01. Como o Pico funciona com 3,3 V, não precisa de divisor de tensão: o RX do ESP-01 vai no GP0 (UART0 TX) e o TX vai no GP1 (UART0 RX). A UART de hardware do Pico lê 115200 baud com tranquilidade, então você também não precisa mudar a velocidade do módulo; se já tiver baixado para 9600 na parte do Uno, defina baudrate como 9600 no código também. Rode o código MicroPython abaixo no Thonny; o módulo se conecta à sua rede, mostra o endereço IP e lista as redes próximas a cada 30 segundos. Se você tiver um Pico W, o Wi-Fi integrado é mais fácil de usar; veja o artigo sobre o servidor web Wi-Fi com 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 ou ESP32?

As maiores vantagens do ESP-01 são o tamanho e o preço; ele é ideal para adicionar Wi-Fi a um projeto Arduino que já existe ou deixar sem fio um único relé ou sensor. Mas, como não tem USB, trocar fios, montar um regulador e ligar o GPIO0 no GND a cada carregamento fica cansativo. Ele não tem entrada analógica e, como o GPIO16 não está disponível na barra, o despertar temporizado do deep sleep não funciona a menos que você solde um fio fino em um dos pinos do chip. Se estiver planejando um projeto alimentado por bateria, coloque a corrente média na calculadora Autonomia da bateria para ver quantos dias ela vai durar. Se você ainda está aprendendo ou precisa de mais de três pinos, o NodeMCU ESP8266 oferece o mesmo chip com USB e regulador. Se precisar de Bluetooth, mais pinos e mais poder de processamento, o ESP32 é a escolha certa; comparamos as placas em Arduino ou ESP32?

Ideias de projetos com o ESP-01

• Tomada inteligente Wi-Fi: ligue e desligue uma lâmpada pelo celular com o módulo relé ESP-01S e o sketch acima; adicione um temporizador para que ela acenda sozinha à noite.
• Sensor de temperatura sem fio: ligue um sensor DS18B20 ao GPIO2; o resistor de pull-up de 4,7 kΩ na linha de dados também garante o nível HIGH necessário na inicialização.
• Monitor de umidade e temperatura: mostre as leituras de um DHT11 em uma página web que você abre no celular.
• Alerta de movimento: ligue um sensor PIR ao GPIO3 e envie uma mensagem no Telegram quando houver movimento; o método é muito parecido com o do artigo sobre o bot do Telegram com ESP32.
• Wi-Fi para um projeto Arduino: envie as leituras de uma estação meteorológica feita com um Uno para um programa no seu computador ou para um servidor usando comandos AT.
• Controle de portão de garagem: ligue os contatos do relé em paralelo com o botão do motor do portão e abra o portão pelo celular.

Erros comuns e como resolvê-los

Apesar do tamanho pequeno, o ESP-01 é um ótimo módulo para aprender todos os conceitos básicos de Wi-Fi: endereços IP, conexões TCP, servidores web e comunicação serial. Se algo não funcionar, verifique primeiro a alimentação, depois as linhas TX-RX e o nível do GPIO0; a grande maioria dos problemas se resume a esses três pontos. No app BlueGrays você encontra projetos como conexão Wi-Fi, servidor web, mDNS, atualização sem fio (OTA) e iluminação inteligente com relé, com esquemas do circuito e códigos passo a passo.