ESP-01 avec Arduino : commandes AT, programmation et relais

L'ESP-01 est un module minuscule (24,8 × 14,3 mm) et très bon marché construit autour de la puce Wi-Fi ESP8266. En branchant l'ESP-01 sur un Arduino, tu ajoutes le Wi-Fi avec quelques fils à une carte sans liaison sans fil comme l'Uno ou la Nano. Le module est livré avec un firmware de commandes AT : l'Arduino envoie par la liaison série de courtes commandes texte comme "AT+CWJAP", et l'ESP-01 se connecte au réseau, envoie et reçoit des données. Si tu préfères, tu peux aussi programmer l'ESP-01 comme un microcontrôleur autonome, sans aucun Arduino ; son processeur est bien plus rapide que celui de l'Uno.

Dans ce guide, tu vas découvrir les 8 broches de l'ESP-01 et comprendre pourquoi il lui faut absolument une alimentation 3,3 V solide. Tu verras ensuite étape par étape les commandes AT avec un Arduino Uno, une page web qui allume une LED depuis ton téléphone, la programmation directe avec un adaptateur USB-TTL (la méthode GPIO0 à la masse), la commande d'une lampe avec le module relais ESP-01S et l'utilisation avec un Raspberry Pi Pico. À la fin, tu trouveras les solutions aux erreurs les plus fréquentes et quand un NodeMCU ou un ESP32 est un meilleur choix.

Qu'est-ce que l'ESP-01 et comment fonctionne-t-il ?

L'ESP-01 est le premier et le plus petit module conçu par Ai-Thinker autour de la puce ESP8266EX. La carte porte la puce, un quartz de 26 MHz, la mémoire flash qui stocke le programme et les réglages, et une antenne imprimée en méandres ; il n'y a ni port USB, ni régulateur de tension, ni bouton. C'est pourquoi l'ESP-01 ne se branche pas directement sur l'ordinateur : c'est à toi de fournir l'alimentation et la liaison série. Tu peux utiliser le module de deux façons : comme modem Wi-Fi (le firmware AT est installé, l'Arduino envoie des commandes) ou comme microcontrôleur autonome (tu téléverses ton propre programme depuis l'Arduino IDE et le firmware AT est effacé). La plupart des modules vendus aujourd'hui sont la version noire ESP-01S.

Différences entre ESP-01 et ESP-01S

Brochage de l'ESP-01 : le rôle des 8 broches

L'ESP-01 possède 8 broches en connecteur 2×4, et seules quatre d'entre elles servent d'entrées-sorties. Les noms des broches ne sont pas imprimés sur toutes les cartes ; compare ton module avec le brochage du vendeur avant de le câbler, car inverser VCC et GND détruit le module en quelques secondes. Voici le rôle de chaque broche et son branchement en fonctionnement normal :

Consommation : pourquoi la broche 3,3 V de l'Arduino ne suffit pas

La plupart des problèmes qui détruisent l'ESP-01 ou le font redémarrer sans cesse viennent de l'alimentation. Connecté au Wi-Fi, le module consomme en moyenne 70–80 mA et environ 170 mA en émission ; au démarrage et pendant la connexion au réseau, de brefs pics peuvent dépasser 300 mA. La broche 3,3 V de l'Arduino Uno, elle, ne fournit officiellement que 50 mA. Un ESP-01 alimenté par cette broche répond souvent à la commande "AT", mais dès qu'il tente de se connecter au réseau la tension s'effondre et le module redémarre, ce qui ressemble à un bug logiciel. La solution : un régulateur AMS1117-3.3 (1 A) alimenté en 5 V, plus un condensateur électrolytique de 100–470 µF entre VCC et GND du module. Tu trouveras le fonctionnement des régulateurs dans l'article sur le régulateur de tension 7805.

Brancher l'ESP-01 sur l'Arduino Uno (pour les commandes AT)

L'unique port série matériel de l'Arduino Uno (D0 et D1) est partagé avec la liaison USB. Le plus pratique est donc de relier l'ESP-01 aux broches D2 et D3 avec la bibliothèque SoftwareSerial : tu n'as pas à débrancher l'ESP-01 pour téléverser sur l'Uno, et le Moniteur série reste libre pour le débogage. Le Raspberry Pi Pico fonctionne déjà en 3,3 V, il n'a donc pas besoin de pont diviseur :

Pour abaisser le signal 5 V qui sort de la broche D3 de l'Uno, place une résistance de 1 kΩ entre D3 et le RX de l'ESP-01, et une de 2 kΩ entre le RX de l'ESP-01 et la masse. La tension obtenue vaut 5 × 2 / (1 + 2) = 3,33 V ; avec 2,2 kΩ au lieu de 2 kΩ tu obtiens 3,44 V, et les deux sont sûres. Tu peux calculer d'autres valeurs avec le calculateur de pont diviseur. Dans l'autre sens, pas besoin de pont : les 3,3 V de la broche TX de l'ESP-01 dépassent le seuil de 3 V à partir duquel l'Uno lit un HIGH. Nous expliquons en détail les bases de la communication série dans l'article sur la communication série UART.

Premier test : envoyer des commandes AT depuis le Moniteur série

1. Téléverse sur l'Uno le sketch passerelle ci-dessous ; pour le premier essai, mets ESP_BAUD à 115200, car la plupart des modules sont livrés à cette vitesse (les anciens peuvent être à 9600).
2. Ouvre le Moniteur série à 115200 bauds et règle la fin de ligne sur Both NL & CR ; sans ce réglage, le module ne sait pas que la commande est terminée.
3. Tape AT et envoie-le ; tu dois voir OK. Si des caractères incompréhensibles s'affichent, les vitesses ne correspondent pas.
4. SoftwareSerial ne lit pas de façon fiable à 115200, alors passe la vitesse du module à 9600 de façon permanente avec AT+UART_DEF=9600,8,1,0,0. Même si la réponse paraît brouillée, la commande arrive en général.
5. Mets ESP_BAUD à 9600 dans le sketch, téléverse-le à nouveau et refais la commande AT ; la réponse OK doit maintenant être propre.
6. Vérifie que le module fonctionne bien en lisant la version du firmware avec AT+GMR et la liste des réseaux Wi-Fi voisins avec 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}

Les commandes AT les plus utiles de l'ESP-01

Commander une LED depuis ton téléphone avec Arduino Uno et ESP-01

Transformons maintenant les commandes AT en programme. Le code ci-dessous connecte l'ESP-01 à ton réseau, ouvre un petit serveur web sur le port 80 et affiche l'adresse IP dans le Moniteur série. Si tu tapes cette adresse dans le navigateur d'un téléphone connecté au même Wi-Fi, une page à deux boutons s'ouvre ; les boutons allument et éteignent la LED intégrée sur la broche 13 de l'Uno. Branche un module relais à la place de la LED et tu commandes une lampe de la même façon. Avant de téléverser, assure-toi d'avoir réglé la vitesse du module à 9600 à l'étape précédente.

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}

Voici la logique du code : quand un navigateur se connecte, l'ESP-01 transmet la requête à l'Arduino sous la forme +IPD,0,384:GET /on HTTP/1.1, où 0 est le numéro de connexion et 384 le nombre d'octets reçus. L'Arduino cherche "GET /on" ou "GET /off" dans cette ligne et règle la LED. Quand arrive la ligne vide qui marque la fin de la requête, il annonce avec AT+CIPSEND=0,longueur combien d'octets il va envoyer, transmet la page dès que le module affiche le signe ">" et ferme la connexion avec AT+CIPCLOSE après la réponse "SEND OK". Nous avons volontairement gardé la page courte : les 2 Ko de RAM de l'Uno ne suffisent pas pour de longs textes HTML, et un seul CIPSEND envoie au maximum 2048 octets. Pour des projets plus complexes, une bibliothèque comme WiFiEspAT t'évite de gérer toi-même les commandes AT.

Programmer l'ESP-01 directement : la méthode GPIO0 à la masse

L'ESP8266 de l'ESP-01, avec son processeur 32 bits à 80 MHz, est bien plus puissant qu'un Arduino Uno. Si ton projet ne comporte qu'un relais, un capteur ou une LED, tu n'as pas besoin d'Arduino : tu téléverses le programme directement dans l'ESP-01. Au démarrage, l'ESP8266 lit les niveaux de GPIO0, GPIO2 et GPIO15 pour décider quoi faire. Sur la carte ESP-01, GPIO15 est déjà relié à la masse et GPIO2 doit rester à HIGH ; le mode de démarrage dépend donc uniquement de GPIO0 :

1. Dans l'Arduino IDE, ouvre Fichier > Préférences et ajoute https://arduino.esp8266.com/stable/package_esp8266com_index.json dans le champ "URL de gestionnaire de cartes supplémentaires".
2. Dans le Gestionnaire de cartes, cherche esp8266 et installe le paquet ESP8266 Community.
3. Choisis Generic ESP8266 Module dans Outils > Type de carte. Règle Flash Size sur 1MB (FS:64KB OTA:~470KB) pour l'ESP-01S, ou sur l'une des options 512KB pour l'ancien ESP-01 bleu.
4. Mets le cavalier de l'adaptateur USB-TTL sur 3,3 V, câble le module selon le tableau ci-dessus et garde GPIO0 relié à la masse.
5. Coupe puis rétablis l'alimentation du module, ou touche brièvement RST avec la masse ; le module démarre alors en mode programmation.
6. Choisis le port de l'USB-TTL dans Outils > Port et téléverse le code. Pour un premier essai, Fichier > Exemples > ESP8266 > Blink convient ; sur l'ESP-01S, la LED bleue est sur GPIO2.
7. Quand "Hard resetting via RTS pin..." s'affiche, débranche GPIO0 de la masse et redémarre le module. Si GPIO0 reste à la masse, ton programme ne tourne pas et le module redémarre en mode programmation.

Commander un relais avec GPIO0 et GPIO2 : le module relais ESP-01S

Les broches d'usage général de l'ESP-01 sont GPIO0 et GPIO2, mais toutes deux doivent être à HIGH au démarrage. Ce que tu y branches ne doit donc pas tirer la broche à LOW pendant que la carte démarre. La solution la plus sûre est une commande active à l'état bas : au démarrage, la broche est à HIGH et le relais reste au repos ; quand ton programme met la broche à LOW, le relais colle. Le module relais ESP-01S vendu tout fait est conçu exactement ainsi : il s'alimente en 5 V, son régulateur fournit le 3,3 V de l'ESP-01S et GPIO0 pilote, via un transistor, un relais aux contacts 10 A 250 V AC. Sur les cartes v4.0 et suivantes, le relais colle quand GPIO0 est à LOW ; les anciennes cartes v1.0 peuvent demander une petite modification pour fonctionner avec l'ESP-01S, vérifie donc la version de ta carte.

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}

Après avoir téléversé le code dans l'ESP-01S avec la méthode ci-dessus, enfiche le module sur la carte relais et alimente-la en 5 V. Tu peux lire l'adresse IP dans le Moniteur série tant que l'USB-TTL est branché, ou la trouver dans la liste des appareils connectés de ta box ; depuis un ordinateur compatible mDNS, http://esp01.local fonctionne aussi. Si tu veux ajouter une entrée comme un bouton, la meilleure broche est GPIO3 (RX), car son niveau n'a pas d'importance au démarrage. Dans ce cas, utilise Serial.begin(115200, SERIAL_8N1, SERIAL_TX_ONLY) pour ouvrir le port série en émission seule.

ESP-01 avec le Raspberry Pi Pico (MicroPython)

Tu peux aussi ajouter une liaison sans fil à un Raspberry Pi Pico sans Wi-Fi grâce à l'ESP-01. Comme le Pico fonctionne en 3,3 V, aucun pont diviseur n'est nécessaire : le RX de l'ESP-01 va sur GP0 (UART0 TX) et son TX sur GP1 (UART0 RX). L'UART matériel du Pico lit 115200 bauds sans difficulté, tu n'as donc pas non plus à changer la vitesse du module ; si tu l'as déjà passée à 9600 dans la partie Uno, mets aussi baudrate à 9600 dans le code. Lance le code MicroPython ci-dessous avec Thonny ; le module se connecte au réseau, affiche son adresse IP et liste les réseaux voisins toutes les 30 secondes. Si tu as un Pico W, son Wi-Fi intégré est plus simple à utiliser ; consulte l'article sur le serveur web Wi-Fi avec le 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 ?

Les grands atouts de l'ESP-01 sont sa taille et son prix ; il est idéal pour ajouter le Wi-Fi à un projet Arduino existant ou rendre sans fil un relais ou un capteur. Mais comme il n'a pas d'USB, changer les fils, ajouter un régulateur et mettre GPIO0 à la masse à chaque téléversement devient vite fastidieux. Il n'a pas d'entrée analogique et, comme GPIO16 n'est pas sortie, le réveil temporisé du deep sleep ne fonctionne qu'en soudant un fil fin sur une patte de la puce. Si tu prévois un projet sur batterie, entre la consommation moyenne dans le calculateur d'autonomie de batterie pour voir combien de jours il tiendra. Si tu apprends encore ou s'il te faut plus de trois broches, le NodeMCU ESP8266 offre la même puce avec USB et régulateur. S'il te faut le Bluetooth, plus de broches et plus de puissance, l'ESP32 est le bon choix ; nous comparons les cartes dans Arduino ou ESP32 ?

Idées de projets avec l'ESP-01

• Prise connectée Wi-Fi : allume et éteins une lampe depuis ton téléphone avec le module relais ESP-01S et le code ci-dessus ; ajoute une minuterie pour qu'elle s'allume seule le soir.
• Capteur de température sans fil : branche un capteur DS18B20 sur GPIO2 ; la résistance de tirage de 4,7 kΩ de la ligne de données fournit aussi le niveau HIGH nécessaire au démarrage.
• Suivi d'humidité et de température : affiche les mesures d'un DHT11 sur une page web que tu ouvres sur ton téléphone.
• Alerte de mouvement : branche un capteur PIR sur GPIO3 et envoie un message Telegram quand un mouvement est détecté ; la méthode ressemble beaucoup à celle de l'article sur le bot Telegram avec ESP32.
• Wi-Fi pour un projet Arduino : envoie avec les commandes AT les mesures d'une station météo réalisée avec l'Uno vers un programme sur ton ordinateur ou vers un serveur.
• Télécommande de porte de garage : branche les contacts du relais en parallèle sur le bouton du moteur de porte et ouvre-la depuis ton téléphone.

Erreurs fréquentes et solutions

Malgré sa petite taille, l'ESP-01 est un excellent module pour apprendre toutes les notions de base du Wi-Fi : adresses IP, connexions TCP, serveurs web et communication série. Si quelque chose ne marche pas, vérifie d'abord l'alimentation, puis les lignes TX-RX et le niveau de GPIO0 ; la grande majorité des problèmes se situent à ces trois endroits. Dans l'application BlueGrays, tu trouveras des projets comme la connexion Wi-Fi, le serveur web, le mDNS, la mise à jour sans fil (OTA) et l'éclairage intelligent avec relais, avec schémas et code étape par étape.