ESP-01 con Arduino: comandi AT, programmazione e relè

L'ESP-01 è un modulo minuscolo (24,8 × 14,3 mm) ed economicissimo basato sul chip Wi-Fi ESP8266. Collegando l'ESP-01 ad Arduino puoi aggiungere il Wi-Fi con pochi fili a una scheda senza connessione wireless, come Uno o Nano. Il modulo arriva di fabbrica con un firmware a comandi AT: Arduino invia sulla seriale brevi comandi di testo come "AT+CWJAP" e l'ESP-01 si collega alla rete, invia e riceve dati. Se preferisci, puoi anche programmare l'ESP-01 come microcontrollore autonomo, senza alcun Arduino; il suo processore è molto più veloce di quello della Uno.

In questa guida imparerai gli 8 pin dell'ESP-01 e perché ha assolutamente bisogno di un'alimentazione a 3,3 V robusta. Poi vedrai passo passo i comandi AT con Arduino Uno, una pagina web che accende un LED dallo smartphone, la programmazione diretta con un adattatore USB-TTL (il metodo GPIO0 a GND), il controllo di una lampada con il modulo relè ESP-01S e l'uso con il Raspberry Pi Pico. Alla fine troverai le soluzioni agli errori più comuni e quando conviene di più un NodeMCU o un ESP32.

Cos'è l'ESP-01 e come funziona?

L'ESP-01 è il primo e il più piccolo modulo progettato da Ai-Thinker attorno al chip ESP8266EX. Sulla scheda ci sono il chip, un quarzo da 26 MHz, la memoria flash che conserva programma e impostazioni e un'antenna a serpentina stampata sul PCB; mancano porta USB, regolatore di tensione e pulsanti. Per questo l'ESP-01 non si collega direttamente al computer: alimentazione e collegamento seriale devi realizzarli tu. Puoi usare il modulo in due modi: come modem Wi-Fi (con il firmware AT installato, Arduino invia i comandi) oppure come microcontrollore autonomo (carichi il tuo programma dall'Arduino IDE e il firmware AT viene cancellato). La maggior parte dei moduli venduti oggi è la versione nera ESP-01S.

Differenze tra ESP-01 ed ESP-01S

Pinout dell'ESP-01: a cosa servono gli 8 pin

L'ESP-01 ha 8 pin su un connettore 2×4 e solo quattro si possono usare come ingressi e uscite. Non tutte le schede riportano i nomi dei pin; prima di cablarlo confronta il modulo con lo schema del venditore, perché invertire VCC e GND brucia il modulo in pochi secondi. Ecco la funzione di ogni pin e il suo collegamento nel funzionamento normale:

Consumo di corrente: perché il pin 3,3 V di Arduino non basta

Quasi tutti i problemi che bruciano l'ESP-01 o lo fanno riavviare di continuo dipendono dall'alimentazione. Connesso al Wi-Fi, il modulo assorbe in media 70–80 mA e circa 170 mA in trasmissione; all'avvio e durante la connessione alla rete brevi picchi possono superare i 300 mA. Il pin 3,3 V di Arduino Uno, invece, fornisce ufficialmente solo 50 mA. Un ESP-01 alimentato da questo pin spesso risponde al comando "AT", ma appena prova a collegarsi alla rete la tensione crolla e il modulo si riavvia, cosa che sembra un errore software. La soluzione è un regolatore AMS1117-3.3 (1 A) alimentato a 5 V, più un condensatore elettrolitico da 100–470 µF tra VCC e GND del modulo. Trovi il funzionamento dei regolatori nell'articolo sul regolatore di tensione 7805.

Collegare l'ESP-01 ad Arduino Uno (per i comandi AT)

L'unica seriale hardware di Arduino Uno (D0 e D1) è condivisa con la connessione USB. Per questo la soluzione più pratica è collegare l'ESP-01 ai pin D2 e D3 con la libreria SoftwareSerial: non devi scollegare l'ESP-01 quando carichi lo sketch sulla Uno e il Monitor seriale resta libero per il debug. Il Raspberry Pi Pico funziona già a 3,3 V, quindi non ha bisogno del partitore:

Per abbassare il segnale a 5 V che esce dal pin D3 della Uno, collega una resistenza da 1 kΩ tra D3 e l'RX dell'ESP-01 e una da 2 kΩ tra l'RX dell'ESP-01 e GND. La tensione in uscita è 5 × 2 / (1 + 2) = 3,33 V; con 2,2 kΩ al posto di 2 kΩ ottieni 3,44 V, ed entrambe sono sicure. Puoi calcolare altri valori con il calcolatore del partitore di tensione. Nell'altro verso il partitore non serve: i 3,3 V del pin TX dell'ESP-01 superano la soglia di 3 V oltre la quale la Uno legge HIGH. Spieghiamo in dettaglio le basi della comunicazione seriale nell'articolo sulla comunicazione seriale UART.

Primo test: inviare comandi AT dal Monitor seriale

1. Carica sulla Uno lo sketch ponte qui sotto; al primo tentativo imposta ESP_BAUD a 115200, perché la maggior parte dei moduli arriva a questa velocità (quelli vecchi possono essere a 9600).
2. Apri il Monitor seriale a 115200 baud e imposta il fine riga su Both NL & CR; senza questa impostazione il modulo non capisce che il comando è finito.
3. Scrivi AT e invialo: dovresti vedere OK. Se compaiono caratteri strani, le velocità non coincidono.
4. SoftwareSerial non legge in modo affidabile a 115200, quindi porta la velocità del modulo a 9600 in modo permanente con AT+UART_DEF=9600,8,1,0,0. Anche se la risposta appare illeggibile, di solito il comando arriva.
5. Imposta ESP_BAUD a 9600 nello sketch, ricaricalo e ripeti il comando AT; ora la risposta OK dovrebbe essere pulita.
6. Verifica che il modulo funzioni bene leggendo la versione del firmware con AT+GMR e l'elenco delle reti Wi-Fi vicine 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}

I comandi AT più usati dell'ESP-01

Comandare un LED dallo smartphone con Arduino Uno ed ESP-01

Ora trasformiamo i comandi AT in un programma. Lo sketch qui sotto collega l'ESP-01 alla tua rete, apre un piccolo web server sulla porta 80 e scrive l'indirizzo IP nel Monitor seriale. Se digiti quell'indirizzo nel browser di uno smartphone collegato allo stesso Wi-Fi, si apre una pagina con due pulsanti che accendono e spengono il LED integrato sul pin 13 della Uno. Collegando un modulo relè al posto del LED, comandi una lampada nello stesso modo. Prima di caricarlo, assicurati di aver impostato la velocità del modulo a 9600 nel passo precedente.

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}

Ecco la logica del codice: quando un browser si collega, l'ESP-01 passa la richiesta ad Arduino nel formato +IPD,0,384:GET /on HTTP/1.1, dove 0 è il numero della connessione e 384 il numero di byte ricevuti. Arduino cerca "GET /on" o "GET /off" in quella riga e imposta il LED. Quando arriva la riga vuota che segna la fine della richiesta, annuncia con AT+CIPSEND=0,lunghezza quanti byte invierà, manda la pagina appena il modulo mostra il simbolo ">" e chiude la connessione con AT+CIPCLOSE dopo la risposta "SEND OK". Abbiamo tenuto la pagina corta di proposito: i 2 KB di RAM della Uno non bastano per testi HTML lunghi e un singolo CIPSEND invia al massimo 2048 byte. Nei progetti più complessi, una libreria come WiFiEspAT ti evita di gestire i comandi AT a mano.

Programmare l'ESP-01 direttamente: il metodo GPIO0 a GND

L'ESP8266 dentro l'ESP-01, con il suo processore a 32 bit da 80 MHz, è molto più potente di un Arduino Uno. Se il tuo progetto ha solo un relè, un sensore o un LED, Arduino non serve affatto: carichi il programma direttamente sull'ESP-01. All'avvio l'ESP8266 controlla il livello dei pin GPIO0, GPIO2 e GPIO15 per decidere cosa fare. Sulla scheda ESP-01 il GPIO15 è già collegato a GND e il GPIO2 deve restare HIGH, quindi la modalità di avvio dipende solo dal GPIO0:

1. Nell'Arduino IDE apri File > Impostazioni e aggiungi https://arduino.esp8266.com/stable/package_esp8266com_index.json nel campo "URL aggiuntive per il Gestore schede".
2. Nel Gestore schede cerca esp8266 e installa il pacchetto di ESP8266 Community.
3. Da Strumenti > Scheda scegli Generic ESP8266 Module. Imposta Flash Size su 1MB (FS:64KB OTA:~470KB) per l'ESP-01S, o su una delle opzioni da 512KB per il vecchio ESP-01 blu.
4. Sposta il jumper dell'adattatore USB-TTL su 3,3 V, collega il modulo secondo la tabella qui sopra e lascia il GPIO0 collegato a GND.
5. Togli e ridai alimentazione al modulo, oppure tocca per un istante RST con GND; il modulo ora si avvia in modalità programmazione.
6. Scegli la porta dell'USB-TTL da Strumenti > Porta e carica lo sketch. Per la prima prova va bene File > Esempi > ESP8266 > Blink; sull'ESP-01S il LED blu è su GPIO2.
7. Quando compare "Hard resetting via RTS pin...", scollega il GPIO0 da GND e riavvia il modulo. Se il GPIO0 resta a GND il tuo programma non parte e il modulo si riavvia di nuovo in modalità programmazione.

Controllo di un relè con GPIO0 e GPIO2: il modulo relè ESP-01S

I pin di uso generale dell'ESP-01 sono GPIO0 e GPIO2, ma entrambi devono essere HIGH durante l'avvio. Ciò che colleghi non deve quindi portare il pin a LOW mentre la scheda si avvia. La soluzione più sicura è un comando attivo basso: all'avvio il pin è HIGH e il relè resta spento, quando il programma porta il pin a LOW il relè si attiva. Il modulo relè ESP-01S già pronto è progettato proprio così: si alimenta a 5 V, il suo regolatore genera i 3,3 V per l'ESP-01S e il GPIO0 pilota, tramite un transistor, un relè con contatti da 10 A 250 V AC. Sulle schede v4.0 e successive il relè si attiva quando GPIO0 è LOW; le vecchie v1.0 possono richiedere una piccola modifica per funzionare con l'ESP-01S, quindi controlla la versione della tua scheda.

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}

Dopo aver caricato lo sketch sull'ESP-01S con il metodo visto sopra, inserisci il modulo nella scheda relè e alimentala a 5 V. Puoi leggere l'indirizzo IP nel Monitor seriale con l'USB-TTL collegato oppure trovarlo nell'elenco dei dispositivi connessi del router; da un computer che supporta mDNS funziona anche http://esp01.local. Se vuoi aggiungere un ingresso come un pulsante, il pin migliore è GPIO3 (RX), perché il suo livello all'avvio non conta. In questo caso usa Serial.begin(115200, SERIAL_8N1, SERIAL_TX_ONLY) per aprire la seriale solo in trasmissione.

ESP-01 con il Raspberry Pi Pico (MicroPython)

Con l'ESP-01 puoi dare la connessione wireless anche a un Raspberry Pi Pico senza Wi-Fi. Poiché il Pico funziona a 3,3 V, non serve il partitore di tensione: l'RX dell'ESP-01 va su GP0 (UART0 TX) e il TX su GP1 (UART0 RX). La UART hardware del Pico legge 115200 baud senza problemi, quindi non devi nemmeno cambiare la velocità del modulo; se l'hai già abbassata a 9600 nella sezione dedicata alla Uno, imposta anche baudrate a 9600 nel codice. Esegui il codice MicroPython qui sotto con Thonny; il modulo si collega alla rete, scrive il suo indirizzo IP ed elenca le reti vicine ogni 30 secondi. Se hai un Pico W, è più semplice usare il suo Wi-Fi integrato; dai un'occhiata all'articolo sul web server 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?

I grandi vantaggi dell'ESP-01 sono dimensioni e prezzo; è ideale per aggiungere il Wi-Fi a un progetto Arduino esistente o per rendere wireless un singolo relè o sensore. Però, non avendo USB, cambiare fili, montare un regolatore e mettere GPIO0 a GND a ogni caricamento diventa noioso. Non ha ingressi analogici e, siccome il GPIO16 non è accessibile, il risveglio temporizzato dal deep sleep non funziona se non saldi un filo sottile su un piedino del chip. Se stai pensando a un progetto a batteria, inserisci il consumo medio nel calcolatore di durata della batteria per vedere quanti giorni durerà. Se stai ancora imparando o ti servono più di tre pin, il NodeMCU ESP8266 offre lo stesso chip con USB e regolatore. Se ti servono Bluetooth, più pin e più potenza, l'ESP32 è la scelta giusta; confrontiamo le schede in Arduino o ESP32?

Idee di progetti con l'ESP-01

• Presa smart Wi-Fi: accendi e spegni una lampada dallo smartphone con il modulo relè ESP-01S e lo sketch qui sopra; aggiungi un timer perché si accenda da sola la sera.
• Sensore di temperatura wireless: collega un sensore DS18B20 al GPIO2; la resistenza di pull-up da 4,7 kΩ sulla linea dati fornisce anche il livello HIGH richiesto all'avvio.
• Monitor di umidità e temperatura: mostra le misure di un DHT11 su una pagina web che apri dallo smartphone.
• Avviso di movimento: collega un sensore PIR al GPIO3 e invia un messaggio Telegram quando rileva un movimento; il metodo è molto simile a quello dell'articolo sul bot Telegram con ESP32.
• Wi-Fi per un progetto Arduino: invia con i comandi AT le misure di una stazione meteo realizzata con la Uno a un programma sul tuo computer o a un server.
• Telecomando per il garage: collega i contatti del relè in parallelo al pulsante del motore del cancello e aprilo dallo smartphone.

Errori comuni e soluzioni

Nonostante le dimensioni ridotte, l'ESP-01 è un ottimo modulo per imparare tutti i concetti base del Wi-Fi: indirizzi IP, connessioni TCP, web server e comunicazione seriale. Se qualcosa non funziona, controlla prima l'alimentazione, poi le linee TX-RX e il livello del GPIO0; la grande maggioranza dei problemi si trova in questi tre punti. Nell'app BlueGrays trovi progetti come connessione Wi-Fi, web server, mDNS, aggiornamento wireless (OTA) e illuminazione intelligente con relè, con schemi e codice passo passo.