ESP-01 Arduino-gids: AT-commando's, programmeren en relais
Sluit de ESP-01 (ESP8266) aan op Arduino: 8 pinnen, 3,3 V-voeding, Wi-Fi met AT-commando's, flashen met GPIO0 naar GND, de ESP-01S-relaismodule en veelvoorkomende fouten.
De ESP-01 is een piepkleine (24,8 × 14,3 mm), zeer goedkope module rond de ESP8266 Wi-Fi-chip. Door de ESP-01 aan te sluiten op een Arduino kun je met een paar draden Wi-Fi toevoegen aan een board zonder draadloze verbinding, zoals een Uno of Nano. De module wordt geleverd met AT-commandofirmware: de Arduino stuurt korte tekstcommando's zoals "AT+CWJAP" over de seriële verbinding en de ESP-01 maakt verbinding met het netwerk en verstuurt en ontvangt gegevens. Wil je dat liever, dan kun je de ESP-01 ook als zelfstandige microcontroller programmeren zonder Arduino; de processor is veel sneller dan die van de Uno.
In deze gids leer je de 8 pinnen van de ESP-01 kennen, waarom hij absoluut een krachtige 3,3 V-voeding nodig heeft, hoe je AT-commando's gebruikt met een Arduino Uno, hoe je een webpagina bouwt die een LED vanaf je telefoon schakelt, hoe je de module rechtstreeks programmeert met een USB-TTL-adapter (de GPIO0-naar-GND-methode), hoe je een lamp bedient met de ESP-01S-relaismodule en hoe je hem gebruikt met een Raspberry Pi Pico. Aan het eind vind je oplossingen voor de meest voorkomende fouten en lees je wanneer een NodeMCU of een ESP32 de betere keuze is.

Wat is de ESP-01 en hoe werkt hij?
De ESP-01 is de eerste en kleinste module die Ai-Thinker rond de ESP8266EX-chip ontwierp. Op het board zitten de chip, een kristal van 26 MHz, het flashgeheugen waarin het programma en de instellingen staan en een meanderende printantenne; er is geen USB-poort, spanningsregelaar of knop. Daarom kun je de ESP-01 niet rechtstreeks op een computer aansluiten: je moet zelf voor voeding en seriële verbinding zorgen. Je kunt de module op twee manieren gebruiken: als Wi-Fi-modem (de AT-firmware staat erop en de Arduino stuurt commando's) of als zelfstandige microcontroller (je uploadt je eigen programma vanuit de Arduino IDE en de AT-firmware wordt gewist). De meeste modules die nu worden verkocht, zijn de zwarte ESP-01S-versie.
| Eigenschap | Waarde |
|---|---|
| Chip | ESP8266EX (Tensilica L106, 32-bit) |
| Kloksnelheid | 80 MHz (kan worden verhoogd naar 160 MHz) |
| Flashgeheugen | ESP-01: 512 KB, ESP-01S: 1 MB |
| RAM | Ongeveer 80 KB data-RAM; ~50 KB over voor je programma met Wi-Fi verbonden |
| Wi-Fi | 802.11 b/g/n, alleen 2,4 GHz, printantenne |
| Bedrijfsspanning | 3,0–3,6 V (3,3 V aanbevolen) |
| Stroom | 70–80 mA gemiddeld tijdens verbinding, ~170 mA bij verzenden, pieken boven 300 mA |
| Stroom in deep sleep | Ongeveer 20 µA (chip) |
| Bruikbare GPIO | 4: GPIO0, GPIO2, GPIO1 (TX), GPIO3 (RX) |
| Analoge ingang | Geen (de ADC-pin is niet uitgevoerd) |
| Afmetingen | 24,8 × 14,3 mm |
| Fabrieksfirmware | AT-commandofirmware (meestal 115200 baud) |
ESP-01 versus ESP-01S
| Eigenschap | ESP-01 | ESP-01S |
|---|---|---|
| Kleur van het board | Meestal blauw | Zwart |
| Flashgeheugen | 512 KB (1 MB bij latere zwarte versies) | 1 MB |
| Voedingsled | Rood, altijd aan | Geen |
| Blauwe led | Op de TX-lijn (GPIO1), knippert bij het versturen van data | Op GPIO2, brandt als de pin LOW is |
| Pinout | 8 pinnen | Dezelfde 8 pinnen, volledig compatibel |
| Stroomverbruik | Een paar mA meer door de voedingsled | Lager, beter voor batterijprojecten |
ESP-01-pinout: wat de 8 pinnen doen
De ESP-01 heeft 8 pinnen in een 2×4-header en slechts vier ervan kun je als in- en uitgang gebruiken. Niet elk board heeft de pinnamen erop gedrukt, vergelijk je module dus met de pinout van de verkoper voordat je gaat bedraden: als je VCC en GND omwisselt, is de module binnen seconden kapot. Dit doet elke pin en zo sluit je hem aan bij normaal gebruik:
| Pin | Functie | Aansluiting bij normaal gebruik |
|---|---|---|
| VCC | Ingang voor 3,3 V-voeding | Een krachtige 3,3 V-bron (minstens 300 mA) |
| GND | Massa | Gemeenschappelijke GND met de Arduino en de voeding |
| TX (GPIO1) | Seriële data-uitgang | Naar de RX-lijn van de Arduino |
| RX (GPIO3) | Seriële data-ingang | Naar de TX-lijn van de Arduino (via een spanningsdeler bij 5 V-boards) |
| EN (CH_PD) | Activeert de chip | Naar 3,3 V (rechtstreeks of via 10 kΩ) |
| RST | Herstart de chip als de pin LOW is | Zwevend of via 10 kΩ naar 3,3 V getrokken |
| GPIO0 | Kiest de opstartmodus, daarna algemene I/O | HIGH (zwevend) bij het opstarten; GND tijdens het flashen |
| GPIO2 | Algemene I/O (blauwe led op de ESP-01S) | Moet bij het opstarten HIGH blijven |
Stroomverbruik: waarom de 3,3 V-pin van de Arduino niet genoeg is
De meeste problemen waardoor de ESP-01 kapotgaat of steeds herstart, komen door de voeding. Verbonden met Wi-Fi gebruikt de module gemiddeld 70–80 mA en rond 170 mA bij het verzenden; korte pieken bij het opstarten en bij het verbinden met het netwerk kunnen boven 300 mA komen. De 3,3 V-pin van de Arduino Uno is officieel echter maar goed voor 50 mA. Een ESP-01 die via deze pin wordt gevoed, antwoordt vaak wel op het commando "AT", maar zodra hij met een netwerk probeert te verbinden, zakt de spanning in en reset de module, wat op een softwarefout lijkt. De oplossing is een AMS1117-3.3-regelaar (1 A) die op 5 V wordt gevoed, plus een elco van 100–470 µF over de VCC- en GND-pinnen van de module. Hoe spanningsregelaars werken lees je in het artikel over de 7805-spanningsregelaar.
| Voedingsbron | Geschikt? | Opmerking |
|---|---|---|
| 3,3 V-pin van de Arduino Uno | Nee | Officieel 50 mA; de module reset tijdens het verbinden met Wi-Fi |
| 3,3 V-pin van een USB-TTL-adapter | Meestal niet | De interne regelaar van de chip levert doorgaans 50–100 mA |
| AMS1117-3.3-regelaar (5 V-ingang) | Ja | Tot 1 A; 10 µF op de uitgang, 100–470 µF naast de module |
| ESP-01 USB-adapter | Ja | Heeft een CH340 en een AMS1117; de module past er rechtstreeks in |
| 2 × AA-batterijen (3 V) | Grensgeval | Naarmate de cellen leeglopen daalt de spanning onder 3 V en wordt de module instabiel |
| Li-ion-accu met één cel (3,7–4,2 V) | Niet rechtstreeks | Overschrijdt de limiet van 3,6 V; vereist een low-dropout (LDO) 3,3 V-regelaar |
De ESP-01 aansluiten op een Arduino Uno (voor AT-commando's)
De enige hardware-seriële poort van de Arduino Uno (D0 en D1) wordt gedeeld met de USB-verbinding. Daarom is het het praktischst om de ESP-01 met de bibliotheek SoftwareSerial op pin D2 en D3 aan te sluiten: je hoeft de ESP-01 niet los te halen bij het uploaden naar de Uno en de Serial Monitor blijft vrij voor debuggen. De Raspberry Pi Pico werkt al op 3,3 V, dus daar is geen deler nodig:
| ESP-01-pin | Arduino Uno | Raspberry Pi Pico | Opmerking |
|---|---|---|---|
| VCC | Uitgang van de AMS1117-3.3 | AMS1117-3.3 of 3V3(OUT) | De 3,3 V-pin van de Uno is niet genoeg; bij de Pico wordt de 3V3-uitgang aanbevolen tot 300 mA |
| GND | GND | GND | Regelaar, board en module delen GND |
| TX | D2 | GP1 (UART0 RX) | Rechtstreeks aansluiten |
| RX | D3 (via een deler van 1 kΩ / 2 kΩ) | GP0 (UART0 TX) | Bij de Pico is geen deler nodig |
| EN (CH_PD) | 3,3 V | 3,3 V | Rechtstreeks of via 10 kΩ |
| RST | Niet aangesloten | Niet aangesloten | Eventueel via 10 kΩ naar 3,3 V trekken |
| GPIO0 | Niet aangesloten | Niet aangesloten | Verbind hem bij normaal gebruik niet met GND |
| GPIO2 | Niet aangesloten | Niet aangesloten | Moet bij het opstarten HIGH blijven |
Om het 5 V-signaal van pin D3 van de Uno te verlagen, sluit je een weerstand van 1 kΩ aan van D3 naar de RX van de ESP-01 en een weerstand van 2 kΩ van de RX van de ESP-01 naar GND. De uitgang is 5 × 2 / (1 + 2) = 3,33 V; met 2,2 kΩ in plaats van 2 kΩ krijg je 3,44 V en beide zijn veilig. Andere weerstandswaarden kun je uitrekenen met de spanningsdeler-tool. De andere richting heeft geen deler nodig: de 3,3 V van de TX-pin van de ESP-01 ligt boven de drempel van 3 V waarbij de Uno HIGH leest. De basis van seriële communicatie behandelen we uitgebreid in het artikel over seriële UART-communicatie.
Eerste test: AT-commando's sturen vanuit de Serial Monitor
- Upload de onderstaande bridge-sketch naar de Uno; zet ESP_BAUD bij de eerste poging op 115200, want de meeste modules worden met die snelheid geleverd (oudere gebruiken soms 9600).
- Open de Serial Monitor op 115200 baud en stel het regeleinde in op Both NL & CR; zonder dat weet de module nooit dat het commando is afgelopen.
- Typ AT en verstuur het; je zou OK moeten zien. Zie je onleesbare tekens, dan komen de snelheden niet overeen.
- SoftwareSerial kan bij 115200 niet betrouwbaar lezen, dus verlaag de snelheid van de module blijvend naar 9600 met AT+UART_DEF=9600,8,1,0,0. Ook als het antwoord er onleesbaar uitziet, komt het commando meestal wel aan.
- Verander ESP_BAUD in de sketch naar 9600, upload opnieuw en herhaal het AT-commando; het OK-antwoord zou er nu netjes uit moeten zien.
- Controleer of de module goed werkt door de firmwareversie uit te lezen met AT+GMR en Wi-Fi-netwerken in de buurt weer te geven met 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}De handigste AT-commando's voor de ESP-01
| Commando | Wat het doet | Voorbeeldantwoord |
|---|---|---|
| AT | Test de verbinding | OK |
| AT+RST | Herstart de module | OK ... ready |
| AT+GMR | Toont de firmwareversie | AT version:... SDK version:... OK |
| AT+UART_DEF=9600,8,1,0,0 | Wijzigt de baudrate blijvend | OK |
| AT+CWMODE=1 | Stationmodus; 2 = toegangspunt, 3 = beide | OK |
| AT+CWLAP | Toont Wi-Fi-netwerken in de buurt | +CWLAP:(3,"AgAdi",-58,...) |
| AT+CWJAP="AgAdi","Sifre123" | Maakt verbinding met een Wi-Fi-netwerk | WIFI CONNECTED, WIFI GOT IP, OK |
| AT+CIFSR | Toont het ontvangen IP-adres | +CIFSR:STAIP,"192.168.1.45" |
| AT+CIPMUX=1 | Schakelt meerdere verbindingen in (vereist voor een server) | OK |
| AT+CIPSERVER=1,80 | Start een TCP-server op poort 80 | OK |
| AT+CIPSTART=0,"TCP","192.168.1.10",80 | Maakt verbinding met een server op link 0 | 0,CONNECT en OK |
| AT+CIPSEND=0,20 | Verstuurt 20 bytes op link 0 | > ... SEND OK |
| AT+CIPCLOSE=0 | Sluit link 0 | 0,CLOSED en OK |
Een LED bedienen vanaf je telefoon met een Arduino Uno en ESP-01
Nu maken we van de AT-commando's een programma. De onderstaande sketch verbindt de ESP-01 met je netwerk, opent een kleine webserver op poort 80 en toont het IP-adres in de Serial Monitor. Als je dat adres intypt in de browser van een telefoon op hetzelfde Wi-Fi-netwerk, opent een pagina met twee knoppen; met de knoppen schakel je de ingebouwde led op pin 13 van de Uno aan en uit. Sluit een relaismodule aan in plaats van de led en dezelfde methode bedient een lamp. Zorg er voor het uploaden voor dat je de snelheid van de module in de vorige stap op 9600 hebt gezet.
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}Zo werkt de code: als een browser verbinding maakt, stuurt de ESP-01 het verzoek door naar de Arduino als +IPD,0,384:GET /on HTTP/1.1, waarbij 0 het linknummer is en 384 het aantal ontvangen bytes. De Arduino zoekt in die regel naar "GET /on" of "GET /off" en schakelt de led. Zodra de lege regel arriveert die het einde van het verzoek markeert, kondigt hij met AT+CIPSEND=0,lengte aan hoeveel bytes hij gaat versturen, stuurt de pagina zodra de module de prompt ">" toont en sluit de link met AT+CIPCLOSE na het antwoord "SEND OK". We hebben de pagina bewust kort gehouden: de 2 KB RAM van de Uno is niet genoeg voor lange HTML-tekst en één CIPSEND kan maximaal 2048 bytes versturen. Voor complexere projecten bespaart een bibliotheek zoals WiFiEspAT je het zelf beheren van AT-commando's.
De ESP-01 rechtstreeks programmeren: de GPIO0-naar-GND-methode
De ESP8266 in de ESP-01, met zijn 32-bit processor van 80 MHz, is veel krachtiger dan een Arduino Uno. Als je project alleen een relais, een sensor of een led heeft, heb je helemaal geen Arduino nodig: je uploadt het programma rechtstreeks naar de ESP-01. Bij het opstarten controleert de ESP8266 de niveaus van GPIO0, GPIO2 en GPIO15 om te bepalen wat hij moet doen. Op het ESP-01-board zit GPIO15 al vast aan GND en GPIO2 moet HIGH blijven, dus GPIO0 alleen bepaalt de opstartmodus:
| GPIO0 | GPIO2 | GPIO15 | Opstartmodus | Opstartmelding bij 74880 baud |
|---|---|---|---|---|
| HIGH (zwevend) | HIGH | LOW | Normaal bedrijf: het programma in flash start | boot mode:(3,x) |
| LOW (GND) | HIGH | LOW | Programmeermodus (UART-download) | boot mode:(1,x) and waiting for host |
| ESP-01-pin | Aansluiting | Opmerking |
|---|---|---|
| VCC | Uitgang van de 3,3 V-regelaar | De 3,3 V-pin van de USB-TTL-adapter is meestal niet genoeg |
| GND | GND van USB-TTL en GND van de regelaar | Alles op een gemeenschappelijke massa |
| TX | USB-TTL RXD | Gekruiste verbinding |
| RX | USB-TTL TXD | Jumper moet op 3,3 V staan |
| EN (CH_PD) | 3,3 V | Rechtstreeks of via 10 kΩ |
| RST | Niet aangesloten (kort naar GND om te resetten) | Eventueel via 10 kΩ naar 3,3 V trekken |
| GPIO0 | GND | Alleen tijdens het uploaden; daarna loskoppelen |
| GPIO2 | Niet aangesloten | Moet bij het opstarten HIGH blijven |
- Open in de Arduino IDE File > Preferences en voeg https://arduino.esp8266.com/stable/package_esp8266com_index.json toe aan het veld "Additional boards manager URLs".
- Zoek in de Boards Manager naar esp8266 en installeer het pakket ESP8266 Community.
- Kies Generic ESP8266 Module bij Tools > Board. Zet Flash Size op 1MB (FS:64KB OTA:~470KB) voor de ESP-01S, of op een van de 512KB-opties voor de oude blauwe ESP-01.
- Zet de jumper van de USB-TTL-adapter op 3,3 V, bedraad de module volgens de bovenstaande tabel en houd GPIO0 verbonden met GND.
- Haal de voeding van de module weg en sluit hem opnieuw aan, of raak RST kort aan met GND; de module start nu op in programmeermodus.
- Kies de poort van de USB-TTL-adapter bij Tools > Port en upload de sketch. File > Examples > ESP8266 > Blink is een goede eerste test; op de ESP-01S zit de blauwe led op GPIO2.
- Zie je "Hard resetting via RTS pin...", koppel dan GPIO0 los van GND en start de module opnieuw. Als GPIO0 op GND blijft, draait je programma niet en start de module opnieuw op in programmeermodus.
Relaisbesturing met GPIO0 en GPIO2: de ESP-01S-relaismodule
De algemene pinnen van de ESP-01 zijn GPIO0 en GPIO2, maar beide moeten tijdens het opstarten HIGH zijn. Wat je erop aansluit mag de pin dus niet LOW trekken terwijl het board opstart. De veiligste oplossing is een active-LOW-aansluiting: de pin is bij het opstarten HIGH, zodat het relais uit blijft, en als je programma de pin LOW stuurt, schakelt het relais in. De kant-en-klare ESP-01S-relaismodule is precies zo ontworpen: hij werkt op 5 V, zijn regelaar op het board maakt 3,3 V voor de ESP-01S en GPIO0 stuurt via een transistor een relais aan met 10 A 250 V AC-contacten. Bij boards v4.0 en later schakelt het relais in als GPIO0 LOW is; oudere v1.0-boards hebben mogelijk een kleine aanpassing nodig om met de ESP-01S te werken, controleer dus de versie van je board.

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}Plug de module na het uploaden van de sketch naar de ESP-01S met bovenstaande methode in het relaisboard en voed het board met 5 V. Je kunt het IP-adres in de Serial Monitor lezen terwijl de USB-TTL-adapter is aangesloten, of het vinden in de lijst met verbonden apparaten van je router; vanaf een computer die mDNS ondersteunt werkt ook http://esp01.local. Wil je een ingang toevoegen, zoals een knop, dan is GPIO3 (RX) de beste pin, omdat het niveau ervan bij het opstarten niet uitmaakt. Gebruik dan Serial.begin(115200, SERIAL_8N1, SERIAL_TX_ONLY) om de seriële poort alleen voor verzenden te openen.
ESP-01 met de Raspberry Pi Pico (MicroPython)
Je kunt ook draadloze verbinding toevoegen aan een Raspberry Pi Pico zonder Wi-Fi met een ESP-01. Omdat de Pico op 3,3 V werkt, is geen spanningsdeler nodig: de RX van de ESP-01 gaat naar GP0 (UART0 TX) en zijn TX naar GP1 (UART0 RX). De hardware-UART van de Pico leest 115200 baud zonder moeite, dus je hoeft de snelheid van de module ook niet te veranderen; als je hem in het Uno-gedeelte al naar 9600 hebt verlaagd, zet dan ook baudrate in de code op 9600. Voer de onderstaande MicroPython-code uit met Thonny; de module maakt verbinding met je netwerk, toont zijn IP-adres en geeft elke 30 seconden de netwerken in de buurt weer. Heb je een Pico W, dan is de ingebouwde Wi-Fi makkelijker te gebruiken; zie het artikel over de Pico W Wi-Fi-webserver.
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 of ESP32?
| Eigenschap | ESP-01 | NodeMCU (ESP8266) | ESP32 DevKit |
|---|---|---|---|
| Chip | ESP8266 | ESP8266 | ESP32 (dual-core) |
| Bruikbare GPIO | 4 (twee zijn TX/RX) | Ongeveer 11 | Ongeveer 25 |
| Analoge ingang | Geen | 1 (A0) | 18 kanalen, 12-bit |
| USB-programmering | Nee, vereist een USB-TTL-adapter | Ja | Ja |
| Voeding | Alleen 3,3 V | USB 5 V of VIN | USB 5 V of VIN |
| Bluetooth | Nee | Nee | Ja (Classic en BLE) |
| Afmetingen | 24,8 × 14,3 mm | Board geschikt voor breadboard | Board geschikt voor breadboard |
| Het beste voor | Wi-Fi toevoegen aan een Arduino, één relais of sensor | Beginnen met Wi-Fi, een paar sensoren | Projecten met veel pinnen en Bluetooth |
De grootste voordelen van de ESP-01 zijn zijn formaat en prijs; hij is ideaal om Wi-Fi toe te voegen aan een bestaand Arduino-project of om één relais of sensor draadloos te maken. Maar omdat hij geen USB heeft, wordt het bij elke upload vervelend om draden om te wisselen, een regelaar toe te voegen en GPIO0 met GND te verbinden. Hij heeft geen analoge ingang en omdat GPIO16 niet is uitgevoerd, werkt wakker worden uit deep sleep op een timer niet, tenzij je een dun draadje op een van de pinnen van de chip soldeert. Plan je een project op batterijen, vul dan de gemiddelde stroom in bij de batterijduurcalculator om te zien hoeveel dagen het meegaat. Ben je nog aan het leren of heb je meer dan drie pinnen nodig, dan geeft de NodeMCU ESP8266 je dezelfde chip met USB en een regelaar. Heb je Bluetooth, meer pinnen en meer rekenkracht nodig, dan is de ESP32 de juiste keuze; we vergelijken de boards in Arduino of ESP32?
Projectideeën met de ESP-01
- Slim Wi-Fi-stopcontact: schakel een lamp vanaf je telefoon met de ESP-01S-relaismodule en de bovenstaande sketch; voeg een timer toe zodat hij 's avonds automatisch aangaat.
- Draadloze temperatuursensor: sluit een DS18B20-sensor aan op GPIO2; de pull-up van 4,7 kΩ op de datalijn zorgt ook voor het HIGH-niveau dat bij het opstarten nodig is.
- Monitor voor vochtigheid en temperatuur: toon de metingen van een DHT11 op een webpagina die je op je telefoon opent.
- Bewegingsmelding: sluit een PIR-sensor aan op GPIO3 en stuur een Telegram-bericht als beweging wordt gedetecteerd; de methode lijkt sterk op het artikel over de ESP32 Telegram-bot.
- Wi-Fi voor een Arduino-project: stuur de metingen van een weerstation op basis van een Uno met AT-commando's naar een programma op je computer of naar een server.
- Afstandsbediening voor de garagedeur: sluit de relaiscontacten parallel aan op de knop van de deuropener en open de deur vanaf je telefoon.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| "Failed to connect to ESP8266: Timed out waiting for packet header" | De module staat niet in programmeermodus, of TX en RX zijn omgewisseld | Verbind GPIO0 met GND, haal de voeding van de module even weg, verbind TX met RXD en RX met TXD |
| Onleesbare tekens in de Serial Monitor | Baudrate komt niet overeen; opstartmeldingen komen met 74880 baud | Probeer 115200 en 9600; kies 74880 om de opstartmelding te zien |
| Helemaal geen antwoord op AT | Verkeerd regeleinde, TX en RX omgewisseld, of EN niet aangesloten | Kies Both NL & CR, kruis de lijnen, verbind EN met 3,3 V |
| Module blijft resetten, valt weg tijdens het verbinden met Wi-Fi | Niet genoeg stroom | Gebruik een aparte AMS1117-3.3 en een condensator van 100–470 µF, maak de draden korter |
| Antwoord "busy p..." | Er is een nieuw commando gestuurd voordat het vorige klaar was | Wacht na elk commando op OK of ERROR |
| +CWJAP:3 en FAIL | Netwerk niet gevonden (5 GHz-netwerk of verkeerde naam) | Gebruik een 2,4 GHz-netwerk en let op hoofdletters en kleine letters |
| Module wordt erg heet, led blijft uit | 5 V op VCC aangesloten, of VCC en GND omgedraaid | Haal meteen de voeding weg; de module is hoogstwaarschijnlijk beschadigd |
| Module start niet op met het relais eraan | De schakeling op GPIO0 of GPIO2 trekt de pin bij het opstarten LOW | Gebruik een active-LOW-aansluiting of verplaats de ingang naar GPIO3 |
| 5 V-relaismodule schakelt nooit uit | Een HIGH van 3,3 V schakelt de optocoupler van de 5 V-module niet volledig uit | Gebruik een relaismodule die geschikt is voor 3,3 V of een transistordriver |
| AT-commando's werken niet meer na het uploaden vanuit de Arduino IDE | Je programma heeft de AT-firmware vervangen | Flash de AT-firmware van Espressif opnieuw met esptool of de Flash Download Tool |
Ondanks zijn kleine formaat is de ESP-01 een geweldige module om alle basisbegrippen van Wi-Fi te leren: IP-adressen, TCP-verbindingen, webservers en seriële communicatie. Werkt iets niet, controleer dan eerst de voeding, daarna de TX-RX-lijnen en het niveau op GPIO0; verreweg de meeste problemen komen neer op deze drie punten. In de BlueGrays-app vind je projecten zoals Wi-Fi-verbinding, webserver, mDNS, over-the-air-updates (OTA) en slimme relaisverlichting, met stap-voor-stap-schakelschema's en code.
Veelgestelde vragen
Kan de ESP-01 op 5V werken?
Nee. De ESP-01 werkt tussen 3,0 en 3,6 V en 5 V op de VCC-pin kan hem blijvend beschadigen. Wil je hem voeden vanaf de 5 V van de Arduino, plaats er dan een regelaar zoals een AMS1117-3.3 tussen en verlaag het 5 V-signaal van de TX-lijn van de Uno met een spanningsdeler naar 3,3 V.
Kan ik de ESP-01 voeden vanaf de 3.3V-pin van de Arduino?
Dat wordt afgeraden. De 3,3 V-pin van de Uno is officieel goed voor 50 mA, terwijl de ESP-01 bij het verzenden 170 mA gebruikt en in korte pieken meer dan 300 mA. Ook al antwoordt de module op AT-commando's, hij reset tijdens het verbinden met het netwerk; gebruik een aparte 3,3 V-regelaar die minstens 300–500 mA kan leveren.
Waarom reageert mijn ESP-01 niet op AT-commando's?
De meest voorkomende oorzaken zijn een verkeerde baudrate, een regeleinde van de Serial Monitor dat niet op Both NL & CR staat, TX en RX die niet gekruist zijn en de EN-pin (CH_PD) die niet met 3,3 V is verbonden. Als er eerder een programma vanuit de Arduino IDE naar de module is geüpload, is de AT-firmware gewist en moet je hem opnieuw flashen.
Wist het uploaden van Arduino-code de AT-firmware van de ESP-01?
Ja. Het programma dat je vanuit de Arduino IDE uploadt, wordt in plaats van de AT-firmware naar flash geschreven en de module begrijpt geen AT-commando's meer. Om terug te gaan naar AT-modus flash je de ESP8266 AT-firmware van Espressif met esptool of de Flash Download Tool op de adressen die bij de flashgrootte van je module passen.
Wat is het verschil tussen ESP-01 en ESP-01S?
De chip en de pinout zijn hetzelfde. De ESP-01S is meestal zwart, heeft 1 MB flash, geen voedingsled en zijn blauwe led zit op GPIO2. De oude blauwe ESP-01 heeft 512 KB flash, een rode voedingsled die altijd aan is en een blauwe led op de TX-lijn.
Wat is de standaardbaudrate van de ESP-01?
De meeste modules met huidige AT-firmware worden geleverd op 115200 baud; oudere gebruiken soms 9600 of 57600. De eerste meldingen bij het opstarten komen echter met 74880 baud. Gebruik je SoftwareSerial op een Arduino Uno, dan maakt het blijvend verlagen van de snelheid naar 9600 met AT+UART_DEF=9600,8,1,0,0 de verbinding betrouwbaar.
Projecten om hierna te bouwen
Alle projecten bekijken
ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
In dit project verbinden we de ESP32 in Station-modus (STA) veilig en foutbestendig met het wifinetwerk thuis. We zetten de SSID en het wachtwoord in een apart bestand secrets.h zodat ze niet in Git lekken, bouwen een automatisch herverbindingsmechanisme en tonen het RSSI-signaalniveau en het IP-adres op een I2C-lcd-scherm. De ingebouwde led werkt als statusindicator. Het is een verbindingsmanager van productieniveau.

ESP32 asynchrone webserver (met IP-weergave op lcd)
In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

ESP32 mDNS: het apparaat bereiken via bluegrays-esp.local (met lcd-scherm)
In dit project voegen we een mDNS-service (Multicast DNS) toe aan de ESP32, zodat je het apparaat bereikt met een leesbare hostnaam zoals bluegrays-esp.local in plaats van een IP-adres. Ook als het IP-adres dat DHCP uitdeelt verandert, reageert het apparaat altijd op dezelfde naam. Met een kleine webserver op het board bedien je de LED vanuit je browser op http://bluegrays-esp.local/.

ESP32 OTA-update: firmware draadloos installeren (met lcd-scherm)
In dit project leer je nieuwe firmware naar de ESP32 te uploaden via wifi, zonder USB-kabel. Met de ArduinoOTA-bibliotheek wordt de ESP32 zichtbaar op het netwerk en verschijnt hij automatisch als bluegrays-ota onder "Network port" in de Arduino IDE. De eerste upload gaat via USB; daarna zijn alle updates draadloos, een belangrijke functie voor apparaten die op afstand hangen.

Echte tijd van internet met ESP32 en NTP
De ESP32 verbindt met Wi-Fi en haalt met milliseconde-precisie de echte tijd op bij NTP-servers (Network Time Protocol). configTzTime() past de Turkse tijdzone (TRT, UTC+3) automatisch toe, en in landen met zomertijd wordt de overgang naar zomertijd (DST) geregeld met een POSIX TZ-string. De tijd wordt zowel naar de Serial Monitor als naar een optioneel I2C-lcd gestuurd.

ESP32 slimme verlichting (PIR + LDR + relais + OLED)
Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.

230V-lamp laten branden met een knop (aan/uit)
Wil je een echte lamp uit huis met een klein knopje aan- en uitzetten? Elke keer dat je op de knop drukt, schakelt de Arduino een relais om en gaat de lamp aan; druk je nog een keer, dan gaat hij uit.

Eenrichtingscommunicatie tussen 2 Arduino's
Je laat twee Arduino's met elkaar praten via één draad: druk op de knop van de ene en de led van de andere gaat aan, druk nog een keer en hij gaat uit.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

