Componenten · 13 min leestijd

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.

ESP-01 ESP8266 Wi-Fi-module
ESP-01 Wi-Fi-module: de ESP8266EX-chip, flashgeheugen, een printantenne en 8 pinnen in een 2×4-header, alles op één klein board.

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.

EigenschapWaarde
ChipESP8266EX (Tensilica L106, 32-bit)
Kloksnelheid80 MHz (kan worden verhoogd naar 160 MHz)
FlashgeheugenESP-01: 512 KB, ESP-01S: 1 MB
RAMOngeveer 80 KB data-RAM; ~50 KB over voor je programma met Wi-Fi verbonden
Wi-Fi802.11 b/g/n, alleen 2,4 GHz, printantenne
Bedrijfsspanning3,0–3,6 V (3,3 V aanbevolen)
Stroom70–80 mA gemiddeld tijdens verbinding, ~170 mA bij verzenden, pieken boven 300 mA
Stroom in deep sleepOngeveer 20 µA (chip)
Bruikbare GPIO4: GPIO0, GPIO2, GPIO1 (TX), GPIO3 (RX)
Analoge ingangGeen (de ADC-pin is niet uitgevoerd)
Afmetingen24,8 × 14,3 mm
FabrieksfirmwareAT-commandofirmware (meestal 115200 baud)

ESP-01 versus ESP-01S

EigenschapESP-01ESP-01S
Kleur van het boardMeestal blauwZwart
Flashgeheugen512 KB (1 MB bij latere zwarte versies)1 MB
VoedingsledRood, altijd aanGeen
Blauwe ledOp de TX-lijn (GPIO1), knippert bij het versturen van dataOp GPIO2, brandt als de pin LOW is
Pinout8 pinnenDezelfde 8 pinnen, volledig compatibel
StroomverbruikEen paar mA meer door de voedingsledLager, 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:

PinFunctieAansluiting bij normaal gebruik
VCCIngang voor 3,3 V-voedingEen krachtige 3,3 V-bron (minstens 300 mA)
GNDMassaGemeenschappelijke GND met de Arduino en de voeding
TX (GPIO1)Seriële data-uitgangNaar de RX-lijn van de Arduino
RX (GPIO3)Seriële data-ingangNaar de TX-lijn van de Arduino (via een spanningsdeler bij 5 V-boards)
EN (CH_PD)Activeert de chipNaar 3,3 V (rechtstreeks of via 10 kΩ)
RSTHerstart de chip als de pin LOW isZwevend of via 10 kΩ naar 3,3 V getrokken
GPIO0Kiest de opstartmodus, daarna algemene I/OHIGH (zwevend) bij het opstarten; GND tijdens het flashen
GPIO2Algemene I/O (blauwe led op de ESP-01S)Moet bij het opstarten HIGH blijven
De ESP-01 werkt alleen op 3,3 V; de bovengrens van de chip is 3,6 V. Als je de 5 V van de Arduino op de VCC-pin aansluit, kun je de module blijvend beschadigen. De TX-pin van de Arduino Uno geeft bovendien een 5 V-signaal af, sluit die dus niet rechtstreeks aan op de RX-pin van de ESP-01: gebruik een spanningsdeler of een niveauconverter.

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.

VoedingsbronGeschikt?Opmerking
3,3 V-pin van de Arduino UnoNeeOfficieel 50 mA; de module reset tijdens het verbinden met Wi-Fi
3,3 V-pin van een USB-TTL-adapterMeestal nietDe interne regelaar van de chip levert doorgaans 50–100 mA
AMS1117-3.3-regelaar (5 V-ingang)JaTot 1 A; 10 µF op de uitgang, 100–470 µF naast de module
ESP-01 USB-adapterJaHeeft een CH340 en een AMS1117; de module past er rechtstreeks in
2 × AA-batterijen (3 V)GrensgevalNaarmate 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 rechtstreeksOverschrijdt 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-pinArduino UnoRaspberry Pi PicoOpmerking
VCCUitgang van de AMS1117-3.3AMS1117-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
GNDGNDGNDRegelaar, board en module delen GND
TXD2GP1 (UART0 RX)Rechtstreeks aansluiten
RXD3 (via een deler van 1 kΩ / 2 kΩ)GP0 (UART0 TX)Bij de Pico is geen deler nodig
EN (CH_PD)3,3 V3,3 VRechtstreeks of via 10 kΩ
RSTNiet aangeslotenNiet aangeslotenEventueel via 10 kΩ naar 3,3 V trekken
GPIO0Niet aangeslotenNiet aangeslotenVerbind hem bij normaal gebruik niet met GND
GPIO2Niet aangeslotenNiet aangeslotenMoet 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

  1. 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).
  2. 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.
  3. Typ AT en verstuur het; je zou OK moeten zien. Zie je onleesbare tekens, dan komen de snelheden niet overeen.
  4. 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.
  5. 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.
  6. 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.
C++ (Arduino IDE)
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

CommandoWat het doetVoorbeeldantwoord
ATTest de verbindingOK
AT+RSTHerstart de moduleOK ... ready
AT+GMRToont de firmwareversieAT version:... SDK version:... OK
AT+UART_DEF=9600,8,1,0,0Wijzigt de baudrate blijvendOK
AT+CWMODE=1Stationmodus; 2 = toegangspunt, 3 = beideOK
AT+CWLAPToont Wi-Fi-netwerken in de buurt+CWLAP:(3,"AgAdi",-58,...)
AT+CWJAP="AgAdi","Sifre123"Maakt verbinding met een Wi-Fi-netwerkWIFI CONNECTED, WIFI GOT IP, OK
AT+CIFSRToont het ontvangen IP-adres+CIFSR:STAIP,"192.168.1.45"
AT+CIPMUX=1Schakelt meerdere verbindingen in (vereist voor een server)OK
AT+CIPSERVER=1,80Start een TCP-server op poort 80OK
AT+CIPSTART=0,"TCP","192.168.1.10",80Maakt verbinding met een server op link 00,CONNECT en OK
AT+CIPSEND=0,20Verstuurt 20 bytes op link 0> ... SEND OK
AT+CIPCLOSE=0Sluit link 00,CLOSED en OK
Als AT+CWJAP mislukt, geeft de module +CWJAP:1 (time-out), +CWJAP:2 (verkeerd wachtwoord), +CWJAP:3 (netwerk niet gevonden) of +CWJAP:4 (verbinding mislukt) weer, gevolgd door FAIL. De ESP8266 ziet alleen 2,4 GHz-netwerken. Wordt je netwerk niet gevonden, controleer dan of de 2,4 GHz-band op je router is ingeschakeld. Typ commando's in hoofdletters en zet de netwerknaam en het wachtwoord tussen dubbele aanhalingstekens.

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.

C++ (Arduino IDE)
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:

GPIO0GPIO2GPIO15OpstartmodusOpstartmelding bij 74880 baud
HIGH (zwevend)HIGHLOWNormaal bedrijf: het programma in flash startboot mode:(3,x)
LOW (GND)HIGHLOWProgrammeermodus (UART-download)boot mode:(1,x) and waiting for host
ESP-01-pinAansluitingOpmerking
VCCUitgang van de 3,3 V-regelaarDe 3,3 V-pin van de USB-TTL-adapter is meestal niet genoeg
GNDGND van USB-TTL en GND van de regelaarAlles op een gemeenschappelijke massa
TXUSB-TTL RXDGekruiste verbinding
RXUSB-TTL TXDJumper moet op 3,3 V staan
EN (CH_PD)3,3 VRechtstreeks of via 10 kΩ
RSTNiet aangesloten (kort naar GND om te resetten)Eventueel via 10 kΩ naar 3,3 V trekken
GPIO0GNDAlleen tijdens het uploaden; daarna loskoppelen
GPIO2Niet aangeslotenMoet bij het opstarten HIGH blijven
  1. 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".
  2. Zoek in de Boards Manager naar esp8266 en installeer het pakket ESP8266 Community.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
Om het flashen makkelijker te maken kun je een ESP-01 USB-adapter gebruiken met een CH340 en een AMS1117 aan boord; de module past er rechtstreeks in. Sommige van deze adapters hebben een UART/PROG-schakelaar; bij modellen zonder moet je een knop of een jumper tussen GPIO0 en GND solderen. Heb je geen USB-TTL-adapter, dan kun je de RESET-pin van de Arduino Uno met GND verbinden en de USB-chip van het board als brug gebruiken; in dat geval gaat TX naar TX en RX naar RX en moet het 5 V-niveau nog steeds worden verlaagd. Zie het artikel over de USB-TTL-adapter voor meer details.

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.

5 V-relaismodule
Met een relais kan een klein stuursignaal een lamp van 230 V in- en uitschakelen; op het ESP-01S-relaisboard is hetzelfde soort relais aangesloten op de GPIO0-pin van de ESP-01.
C++ (Arduino IDE)
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.

Als je netspanning op de relaiscontacten aansluit, bedraad dan alles terwijl de voeding uit staat, laat geen blootliggende contacten achter en plaats de schakeling in een geïsoleerde behuizing. Ook als op het relais 10 A staat, kunnen de koperbanen op kleine boards die stroom misschien niet aan; stuur met deze module geen belastingen aan van meer dan een paar honderd watt. Zie voor details Wat is een relaismodule?

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.

MicroPython
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?

EigenschapESP-01NodeMCU (ESP8266)ESP32 DevKit
ChipESP8266ESP8266ESP32 (dual-core)
Bruikbare GPIO4 (twee zijn TX/RX)Ongeveer 11Ongeveer 25
Analoge ingangGeen1 (A0)18 kanalen, 12-bit
USB-programmeringNee, vereist een USB-TTL-adapterJaJa
VoedingAlleen 3,3 VUSB 5 V of VINUSB 5 V of VIN
BluetoothNeeNeeJa (Classic en BLE)
Afmetingen24,8 × 14,3 mmBoard geschikt voor breadboardBoard geschikt voor breadboard
Het beste voorWi-Fi toevoegen aan een Arduino, één relais of sensorBeginnen met Wi-Fi, een paar sensorenProjecten 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

SymptoomWaarschijnlijke oorzaakOplossing
"Failed to connect to ESP8266: Timed out waiting for packet header"De module staat niet in programmeermodus, of TX en RX zijn omgewisseldVerbind GPIO0 met GND, haal de voeding van de module even weg, verbind TX met RXD en RX met TXD
Onleesbare tekens in de Serial MonitorBaudrate komt niet overeen; opstartmeldingen komen met 74880 baudProbeer 115200 en 9600; kies 74880 om de opstartmelding te zien
Helemaal geen antwoord op ATVerkeerd regeleinde, TX en RX omgewisseld, of EN niet aangeslotenKies Both NL & CR, kruis de lijnen, verbind EN met 3,3 V
Module blijft resetten, valt weg tijdens het verbinden met Wi-FiNiet genoeg stroomGebruik 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 wasWacht na elk commando op OK of ERROR
+CWJAP:3 en FAILNetwerk 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 uit5 V op VCC aangesloten, of VCC en GND omgedraaidHaal meteen de voeding weg; de module is hoogstwaarschijnlijk beschadigd
Module start niet op met het relais eraanDe schakeling op GPIO0 of GPIO2 trekt de pin bij het opstarten LOWGebruik een active-LOW-aansluiting of verplaats de ingang naar GPIO3
5 V-relaismodule schakelt nooit uitEen HIGH van 3,3 V schakelt de optocoupler van de 5 V-module niet volledig uitGebruik een relaismodule die geschikt is voor 3,3 V of een transistordriver
AT-commando's werken niet meer na het uploaden vanuit de Arduino IDEJe programma heeft de AT-firmware vervangenFlash de AT-firmware van Espressif opnieuw met esptool of de Flash Download Tool
Om te controleren of de module echt opstart, zet je de Serial Monitor op 74880 baud en reset je de module. Zie je boot mode:(3,x), dan is hij in normale modus gestart; boot mode:(1,x) betekent programmeermodus. Zie je helemaal niets, dan zit het probleem in de voeding, de EN-aansluiting of de TX-RX-lijnen.

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.

Alle projecten bekijken
ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
ES-25Gevorderd

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.

4.4(21)
38
ESP32 asynchrone webserver (met IP-weergave op lcd)
ES-27Gevorderd

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.

4.8(16)
26
ESP32 mDNS: het apparaat bereiken via bluegrays-esp.local (met lcd-scherm)
ES-29Gevorderd
Premium

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/.

4.8(14)
23
ESP32 OTA-update: firmware draadloos installeren (met lcd-scherm)
ES-30Gevorderd
Premium

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.

4.6(14)
22
Echte tijd van internet met ESP32 en NTP
ES-26Gevorderd
Premium

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.

4.5(13)
22
ESP32 slimme verlichting (PIR + LDR + relais + OLED)
ES-37Gevorderd
Premium

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.

4.3(6)
11
230V-lamp laten branden met een knop (aan/uit)
AR-20Gevorderd
Premium

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.

4.5(33)
44
Eenrichtingscommunicatie tussen 2 Arduino's
AR-57Gemiddeld
Premium

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.

4.4(37)
50