Arduino vs ESP32: de belangrijkste verschillen en welke je kiest
Arduino vs ESP32 vergeleken: snelheid, RAM, Wi-Fi, 5 V- vs 3,3V-logica, ADC, pins en batterijduur, plus een vergelijking met de Pico, gedeelde code en een gids per projecttype.
Arduino of ESP32? Het korte antwoord: heeft je project Wi-Fi, Bluetooth, internet of flinke rekenkracht nodig, kies dan de ESP32; leer je de basis van elektronica, wil je zonder gedoe 5 V-sensoren en -modules gebruiken en elke tutorial exact volgen, kies dan de Arduino Uno. Beide boards programmeer je in de Arduino IDE met dezelfde commando's digitalWrite, analogRead en Serial. Het echte verschil zit in de hardware: snelheid, geheugen, werkspanning, pins en draadloze verbindingen.
In deze gids vergelijken we de Arduino Uno R3 met het meest gebruikte ESP32-board, de ESP32 DevKit (met de ESP-WROOM-32-module), aan de hand van echte cijfers: wat betekenen de verschillen in CPU en geheugen in de praktijk, welke modules worden beïnvloed door 5 V tegenover 3,3 V, hoe veranderen analoge ingang en PWM, en hoeveel uur gaat elk board mee op een batterij? Daarna draaien we dezelfde sketch op beide boards, kijken we kort naar de Raspberry Pi Pico en vatten we in een tabel samen welk board bij welk type project past.

Kort antwoord: welk board, en wanneer?
| Jouw situatie | Aanbevolen board | Waarom? |
|---|---|---|
| Je begint met elektronica | Arduino Uno | 5 V, robuuste pins, de meeste voorbeelden en lessen |
| Je hebt Wi-Fi of internet nodig | ESP32 | Wi-Fi is ingebouwd, geen extra module nodig |
| Bluetooth-verbinding met een telefoon | ESP32 | Classic Bluetooth en BLE ingebouwd |
| Je gebruikt 5 V-modules en shields | Arduino Uno | Geen niveauconverter nodig |
| Displays, veel leds, grote hoeveelheden data | ESP32 | 520 KB RAM (de Uno heeft 2 KB) |
| Sensor die maandenlang op een batterij werkt | ESP32 (board met laag verbruik) | Ongeveer 10 µA in deepsleep |
| Programmeren in Python | Raspberry Pi Pico | Zeer volwassen MicroPython-ondersteuning |
| Laagste budget | ESP32 of Pico | Veel meer functies voor de prijs van een Uno-kloon |
Wat zijn de Arduino Uno en de ESP32?
De Arduino Uno R3 is het bekendste board van het Arduino-platform, dat in Italië is ontwikkeld. Het hart is de 8-bits ATmega328P-microcontroller op 16 MHz. Het board werkt op 5 V en de pinindeling is al jaren hetzelfde, dus honderden shields (uitbreidingsboards die je erbovenop steekt), boeken en cursussen zijn ermee compatibel. Door het eenvoudige ontwerp zie je precies wat er gebeurt: als je HIGH naar een pin schrijft, staat er echt 5 V op. De nieuwere Uno R4 heeft een 32-bits Arm-processor op 48 MHz en 32 KB RAM, en de R4 WiFi-versie voegt een ESP32-S3 toe voor draadloze verbindingen; in dit artikel bedoelen we met "Uno" de R3, die nog steeds het meest voorkomt. Wil je het platform beter leren kennen, lees dan Wat is Arduino?.

De ESP32 daarentegen is een 32-bits system-on-chip (SoC) die Espressif in 2016 uitbracht, met Wi-Fi en Bluetooth op dezelfde chip. Het board dat je in handen hebt, is een ontwikkelboard met deze chip: het heeft een USB-naar-serieel-converter, een 3,3 V-regelaar en EN- en BOOT-knoppen. Een belangrijk detail: de ESP32 is geen Arduino, maar dankzij de Arduino core van Espressif programmeer je hem in de Arduino IDE net als een Arduino. Voor de installatie en je eerste projecten is Wat is de ESP32? een goed startpunt.
De grote vergelijkingstabel: Arduino Uno, ESP32 en Raspberry Pi Pico
| Eigenschap | Arduino Uno R3 | ESP32 DevKit (WROOM-32) | Raspberry Pi Pico |
|---|---|---|---|
| Processor | ATmega328P, 8-bits AVR | Xtensa LX6, 32-bits, dualcore | RP2040, 32-bits Arm Cortex-M0+, dualcore |
| Kloksnelheid | 16 MHz | Tot 240 MHz | 133 MHz |
| RAM (SRAM) | 2 KB | 520 KB | 264 KB |
| Programmageheugen (flash) | 32 KB (0,5 KB gebruikt door de bootloader) | Meestal 4 MB | 2 MB |
| EEPROM | 1 KB | Geen (nagebootst in flash) | Geen (bestandssysteem in flash) |
| Logicaspanning | 5 V | 3,3 V (niet 5 V-tolerant) | 3,3 V (niet 5 V-tolerant) |
| Voeding | USB 5 V of 7–12 V (jack/VIN) | USB 5 V of 5 V op VIN | USB 5 V of 1,8–5,5 V op VSYS |
| Bruikbare GPIO | 20 (14 digitaal + 6 analoog) | Ongeveer 25 (zonder de beperkte pins) | 26 |
| Analoge ingangen (ADC) | 6 kanalen, 10-bits | 18 kanalen, 12-bits (alleen ADC1 als Wi-Fi aan staat) | 3 kanalen, 12-bits |
| Analoge uitgang (DAC) | Geen | 2 kanalen, 8-bits | Geen |
| PWM | 6 pins, 8-bits, 490/980 Hz | 16 kanalen, instelbare frequentie, op bijna elke pin | 16 kanalen, op alle GPIO's |
| Wi-Fi | Geen | 802.11 b/g/n, 2,4 GHz | Geen (de Pico W heeft het) |
| Bluetooth | Geen | Bluetooth 4.2: Classic + BLE | Geen (de Pico W heeft het) |
| UART / I2C / SPI | 1 / 1 / 1 | 3 / 2 / 2 (beschikbaar voor de gebruiker) | 2 / 2 / 2 |
| Stroom per pin | 20 mA aanbevolen (40 mA max.) | Ongeveer 20 mA aanbevolen | Standaard 4 mA (instelbaar tot 12 mA) |
| Typische stroom van het board | Ongeveer 45 mA | 50–130 mA gemiddeld met Wi-Fi, pieken van 240 mA | Ongeveer 25 mA |
| Laagste slaapstand | Chip onder 1 µA, board ongeveer 30 mA | Chip ongeveer 10 µA in deepsleep | Board ongeveer 1 mA in dormant-modus |
| Programmeren | Arduino C/C++ | Arduino C/C++, ESP-IDF, MicroPython | MicroPython, C/C++ SDK, Arduino |
| Prijs (circa) | Origineel $25–30, kloon $5–10 | Kloon-DevKit $4–8 | $4 (Pico W $6) |
CPU en geheugen: wat betekenen de cijfers in de praktijk?
De processor van de Uno voert ongeveer 16 miljoen instructies per seconde uit en rekent met telkens 8-bits getallen; een 32-bits long- of float-bewerking kost tientallen instructies en er is geen hardwarematige floating-point unit (FPU). De ESP32 draait op 240 MHz met 32-bits getallen en heeft een FPU met enkele precisie. Daarom kan de ESP32 bij zware float-berekeningen tientallen of zelfs honderden keren sneller zijn dan de Uno. Een led laten knipperen of een paar keer per seconde een sensor uitlezen merk je niet, maar bij filteren, audioverwerking, versleuteling of het berekenen van animaties voor honderden leds is het doorslaggevend. Een kleine tip: de FPU van de ESP32 verwerkt alleen float; double-bewerkingen draaien in software en zijn merkbaar trager.
Het verschil in geheugen merk je veel vaker. De 2 KB RAM van de Uno wordt gedeeld door je variabelen, de Serial-buffers en de ruimte die bibliotheken reserveren. Als het RAM op is, waarschuwt de compiler meestal niet; het programma loopt willekeurig vast of gedraagt zich vreemd. Typische situaties waarin de Uno snel zonder RAM zit:
- OLED-display: alleen al de framebuffer van een 128×64 SSD1306-display neemt 1 KB in beslag, de helft van het RAM (zie Een OLED-display gebruiken).
- Adresseerbare leds: elke WS2812B-led neemt 3 bytes in, dus een strip met 300 leds heeft 900 bytes nodig (zie WS2812B NeoPixel).
- Data van internet: de JSON die een weerdienst teruggeeft kan enkele KB groot zijn; die past niet op de Uno maar is op de ESP32 gemakkelijk te verwerken.
- String-concatenatie: String-objecten die in een lus steeds groter worden, fragmenteren het kleine RAM en kunnen uren later een crash veroorzaken.
- SD-kaart: de SD-bibliotheek reserveert een sectorbuffer van 512 bytes; samen met display- en sensorbibliotheken zit je snel aan de limiet.
Het spanningsverschil: 5 V vs 3,3 V
Dit is het meest over het hoofd gegegeziene verschil. De pins van de Uno gebruiken 5 V-logica: een HIGH-uitgang is 5 V en ingangen boven 3 V tellen als HIGH. De pins van de ESP32 gebruiken 3,3 V-logica en zijn niet 5 V-tolerant. Zet je 5 V op een pin, dan gaat de ESP32 misschien niet meteen kapot, maar de interne beschermingsdiodes worden belast en de chip kan na verloop van tijd of in één keer stukgaan. De andere richting is minder problematisch: het 3,3 V HIGH-signaal van de ESP32 komt maar net boven de drempel van 3 V van de Uno uit, dus wordt meestal als HIGH gelezen, maar een veilig ontwerp is dat ook niet. Zo gedragen gangbare modules zich met elk board:
| Module | Met de Arduino Uno | Met de ESP32 | Opmerking |
|---|---|---|---|
| HC-SR04-afstandssensor | Direct | Spanningsdeler op de ECHO-lijn | De ECHO-pin geeft 5 V af |
| 5V-relaismodule | Direct | De meeste werken, sommige schakelen niet uit | Bij active-low-modules laat een HIGH van 3,3 V het relais mogelijk niet volledig los |
| SG90 servo | Direct | Signaal direct, voeding via 5 V | Voed de servo niet vanaf de 3V3-pin van het board |
| DHT11 / DHT22 | Direct | Direct op 3,3 V | Werkt op beide spanningen |
| I2C LCD (16x2) | Direct | 5V-voeding, niveauconverter aanbevolen | De pull-upweerstanden van de module trekken de lijnen naar 5 V |
| SSD1306 OLED | Direct | Direct (3V3) | Heeft een regelaar aan boord |
| WS2812B-strip | Direct | Werkt meestal | Gebruik voor een gegarandeerd resultaat een niveauconverter zoals de 74AHCT125 |
| MPU6050 (GY-521) | Direct | Direct (3V3) | Heeft een 3,3 V-regelaar aan boord |
Pins, analoge ingang en PWM
Op de Uno gedragen alle 20 pins zich min of meer hetzelfde: elke pin kan ingang of uitgang zijn, levert makkelijk tot 20 mA en beïnvloedt het opstarten niet. De ESP32 DevKit heeft op papier meer pins, maar ze zijn niet allemaal gelijk: GPIO 6–11 zijn verbonden met de interne flash en onbruikbaar, GPIO 34–39 zijn alleen ingang, en GPIO 0, 2, 5, 12 en 15 moeten tijdens het opstarten op bepaalde niveaus staan. In de praktijk kun je rustig zo'n 20–25 pins gebruiken. De pinmap van jouw board vind je in de tool Pinout.
Bij analoge ingang verdeelt de 10-bits ADC van de Uno het bereik van 0–5 V in 1024 stappen; elke stap is ongeveer 4,9 mV en de metingen zijn redelijk lineair. De 12-bits ADC van de ESP32 geeft 4096 stappen, maar met de standaardinstelling kan hij waarden onder ongeveer 0,15 V of boven 3,1 V niet onderscheiden, hij is ruisgevoelig en de ADC2-pins werken helemaal niet als Wi-Fi aan staat. Heb je op de ESP32 een nauwkeurige spanning nodig, gebruik dan analogReadMilliVolts() en sluit de sensor aan op de ADC1-pins (GPIO 32–39). Bij PWM loopt de ESP32 voor: de Uno biedt 8-bits PWM op slechts 6 pins met 490 of 980 Hz, terwijl de ESP32 16 kanalen met instelbare frequentie en resolutie naar bijna elke uitgangspin kan sturen. Hij heeft ook 2 DAC's (GPIO 25 en 26) die een echte analoge spanning leveren. Voor de basis van PWM, zie Wat is PWM?.
Dezelfde sketch op beide boards: wat verandert er?
Goed nieuws: alles wat je op Arduino hebt geleerd, geldt ook voor de ESP32. De onderstaande sketch leest een potentiometer, toont de spanning in de Serial Monitor en zet de led op het board aan als de waarde over de helft gaat. De regel #if defined(ESP32) herkent voor welk board de code wordt gecompileerd en wijzigt alleen het pinnummer, de referentiespanning en de ADC-resolutie. Sluit de buitenste pootjes van de potentiometer aan op 5V en GND bij de Uno, of op 3V3 en GND bij de ESP32; sluit het middelste pootje aan op A0 bij de Uno of op GPIO 34 bij de ESP32 en open dan de Serial Monitor op 115200 baud. De belangrijkste verschillen buiten de code staan in de tabel.
1// Aynı kod Uno ve ESP32'de çalışır / The same sketch runs on Uno and ESP32
2#if defined(ESP32)
3const int LED_PIN = 2; // DevKit dahili LED / DevKit onboard LED
4const int POT_PIN = 34; // ADC1 pini, Wi-Fi ile de çalışır / ADC1 pin, works with Wi-Fi too
5const float VREF = 3.3; // ESP32 pinleri 3,3 V / ESP32 pins are 3.3 V
6const int ADC_MAX = 4095; // 12 bit
7#else
8const int LED_PIN = 13; // Uno dahili LED / Uno onboard LED
9const int POT_PIN = A0;
10const float VREF = 5.0; // Uno referansı 5 V / Uno reference is 5 V
11const int ADC_MAX = 1023; // 10 bit
12#endif
13
14void setup() {
15 Serial.begin(115200);
16 pinMode(LED_PIN, OUTPUT);
17}
18
19void loop() {
20 int raw = analogRead(POT_PIN);
21 float volts = raw * VREF / ADC_MAX;
22 Serial.print("Ham / raw: ");
23 Serial.print(raw);
24 Serial.print(" Gerilim / voltage: ");
25 Serial.println(volts, 2);
26 digitalWrite(LED_PIN, raw > ADC_MAX / 2 ? HIGH : LOW); // yarıdan fazlaysa LED yanar / LED on above half
27 delay(250);
28}| Onderwerp | Arduino Uno | ESP32 |
|---|---|---|
| Led op het board | Pin 13 | GPIO 2 op de meeste kloon-DevKits (geen op Espressifs DevKitC) |
| Bereik van analogRead | 0–1023 (10-bits) | 0–4095 (12-bits) |
| Externe interrupts (attachInterrupt) | Alleen pin 2 en 3 | Bijna alle pins (voeg IRAM_ATTR toe aan de interruptfunctie) |
| Tweede seriële poort | Heeft SoftwareSerial nodig | Hardware Serial2 (GPIO 16 en 17) |
| EEPROM | Echt EEPROM, 1 KB | In flash; EEPROM.commit() of Preferences |
| Uploaden | Eén klik | Sommige boards vragen om de BOOT-knop ingedrukt te houden |
| Compileertijd | Een paar seconden | De eerste build kan ongeveer een minuut duren |
Wi-Fi, Bluetooth en internet
Wat de ESP32 echt onderscheidt, is draadloze connectiviteit. Het board maakt verbinding met 2,4 GHz-wifinetwerken, kan een eigen access point maken, draait een webserver, stuurt data via MQTT naar een smarthomesysteem, haalt de tijd van internet via NTP en kan zijn firmware draadloos updaten (OTA). Aan de Bluetooth-kant worden zowel Classic Bluetooth (Serial Port Profile) als low-energy BLE ondersteund, en met ESP-NOW kunnen meerdere ESP32's met elkaar praten zonder router. Niets hiervan zit in de Uno: voor Bluetooth heb je een module nodig zoals de HC-05 en voor Wi-Fi een aparte chip zoals de ESP-01 plus AT-commando's. De onderstaande sketch leest dezelfde potentiometer, nu via Wi-Fi: open het adres dat in de Serial Monitor staat in de browser van een telefoon op hetzelfde netwerk en je ziet de spanning in millivolt, waarbij de pagina zichzelf elke twee seconden ververst.
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
5const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
6const int POT_PIN = 34; // ADC1 pini / ADC1 pin
7
8WebServer server(80);
9
10void handleRoot() {
11 uint32_t mv = analogReadMilliVolts(POT_PIN); // kalibre edilmiş mV / calibrated mV
12 String html = "<meta name='viewport' content='width=device-width'>"
13 "<meta http-equiv='refresh' content='2'>"
14 "<h1>ESP32</h1><p>Pot: ";
15 html += mv;
16 html += " mV</p>";
17 server.send(200, "text/html", html);
18}
19
20void setup() {
21 Serial.begin(115200);
22 WiFi.begin(ssid, password);
23 while (WiFi.status() != WL_CONNECTED) delay(500);
24 Serial.print("Telefonda aç / open on your phone: http://");
25 Serial.println(WiFi.localIP());
26 server.on("/", handleRoot);
27 server.begin();
28}
29
30void loop() {
31 server.handleClient();
32}Stroomverbruik en werken op batterijen
Op papier is de ESP32 tegelijk het meest veeleisende en het zuinigste board. Tijdens het versturen van data via Wi-Fi trekt hij pieken tot 240 mA, waardoor hij op een zwakke USB-poort opnieuw opstart met de fout "Brownout detector was triggered". In deepsleep gebruikt de chip daarentegen slechts ongeveer 10 µA. Het Uno-board trekt ongeveer 45 mA als het niets doet; zelfs met de ATmega328P in slaap blijven de USB-naar-serieel-chip, de regelaar en de voedingsled zo'n 30 mA gebruiken. Een rekenvoorbeeld: een batterij van 2000 mAh voedt een Uno die continu draait ongeveer 2000 / 45 ≈ 44 uur. Een ESP32 met Wi-Fi altijd aan (gemiddeld 100 mA) gaat ongeveer 20 uur mee. Maar als de ESP32 elke 10 minuten 3 seconden wakker wordt, een meting verstuurt met 120 mA en de resterende 597 seconden slaapt op 10 µA, is de gemiddelde stroom (3 × 120 + 597 × 0,01) / 600 ≈ 0,61 mA en gaat dezelfde batterij theoretisch meer dan 3000 uur mee, oftewel meer dan vier maanden. Dat resultaat vraagt een board met laag verbruik of een kale module; de regelaar en USB-chip op standaard DevKits trekken zelfs in slaap enkele mA. Je eigen scenario kun je berekenen met de tool batterijduur.
Waar past de Raspberry Pi Pico?
De derde sterke optie is de Raspberry Pi Pico. Zijn RP2040-chip heeft twee Cortex-M0+-kernen op 133 MHz, 264 KB RAM en 2 MB flash, en kost ongeveer $4. Net als de ESP32 werkt hij op 3,3 V en biedt hij 26 GPIO's, maar hij heeft maar 3 analoge ingangen. Zijn grootste sterke punten zijn de zeer volwassen MicroPython-ondersteuning, het gemakkelijk laden van firmware doordat hij op je computer verschijnt als een USB-stick, en eenheden genaamd PIO die nauwkeurig getimede protocollen genereren zonder de processor te belasten. Wil je draadloos, kies dan de Pico W (Wi-Fi en Bluetooth); voor meer kracht de Pico 2 met de RP2350-chip. Meer details in Wat is de Raspberry Pi Pico?. Dezelfde potentiometermeting ziet er op de Pico in MicroPython zo uit (middelste pootje naar GP26, buitenste pootjes naar 3V3 en GND):
1from machine import ADC, Pin
2import time
3
4pot = ADC(26) # GP26 = ADC0, potansiyometre orta ucu / pot wiper
5led = Pin("LED", Pin.OUT) # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
6
7while True:
8 raw = pot.read_u16() # 0–65535 (12 bit ölçüm ölçeklenir / 12-bit reading, scaled)
9 volts = raw * 3.3 / 65535
10 print("Ham / raw:", raw, " Gerilim / voltage: {:.2f}".format(volts))
11 led.value(raw > 32767) # yarıdan fazlaysa yanar / on above half
12 time.sleep(0.25)Prijs en leergemak
Prijs alleen beslist zelden. Een originele Uno R3 kost ongeveer $25–30, terwijl klonen met de CH340 USB-chip $5–10 kosten; kloon-ESP32-DevKits kosten $4–8 en de Pico $4. Tussen een ESP32 en een Uno-kloon zit dus nauwelijks prijsverschil; de echte kosten zitten in de extra's: 5 V-modules gebruiken met de ESP32 vraagt een paar weerstanden of een niveauconverter van $1–2, en Wi-Fi toevoegen aan de Uno vraagt een aparte module. Qua leren loopt de Uno voor: je kiest het board en klikt op Upload, de foutmeldingen en voorbeelden zijn al jaren hetzelfde en er zijn geen spanningsverschillen met 5 V-modules. Op de ESP32 installeer je eerst het Espressif-boardpakket en zo nodig het stuurprogramma voor de USB-chip (CP2102 of CH340), kies je het juiste boardmodel en moet je bij sommige boards tijdens het uploaden de BOOT-knop ingedrukt houden; ook zijn sommige voorbeelden online geschreven voor oudere core-versies en compileren ze mogelijk niet (in core 3.x vervangt ledcAttach bijvoorbeeld ledcSetup). Deze hindernissen kosten een paar uur, maar bouw je voor het eerst schakelingen, dan is het op de Uno makkelijker te zien of een probleem aan de code of aan de bedrading ligt.
Welk board voor welk project?
| Project | Beste board | Waarom? |
|---|---|---|
| Eerste lessen met leds, knoppen en een buzzer | Arduino Uno | Vergevingsgezind, 5 V, veel voorbeelden |
| Robotauto (L298N, HC-SR04) | Arduino Uno | Werkt direct met 5 V-modules |
| Wi-Fi-weerstation | ESP32 | Stuurt data naar je telefoon en het internet |
| Domotica met relais | ESP32 | Integratie met web, MQTT en spraakassistent |
| Bluetooth-afstandsbediening vanaf je telefoon | ESP32 | BLE en Classic Bluetooth ingebouwd |
| Sensor op afstand op batterijen | ESP32 (board met laag verbruik) | Deepsleep en korte Wi-Fi-uitbarstingen |
| Python leren | Raspberry Pi Pico | MicroPython is volwaardig ondersteund |
| Honderden adresseerbare leds | ESP32 of Pico | Veel RAM, snelle processor |
| Beelden streamen vanaf een camera | ESP32-CAM | Camera en microSD-slot op het board |
| Motorshields en 5 V-shields | Arduino Uno | Shields zijn gemaakt voor de pinindeling van de Uno |
Veelgemaakte fouten en misverstanden
- "De ESP32 is altijd beter": hij is krachtiger, maar zijn 3,3 V-pins, pins die gevoelig zijn bij het opstarten, de BOOT-knop en spanningsdips kunnen een beginner uitputten. Om de basis te leren heeft de Uno minder verrassingen.
- Een 5 V-sensor direct op de ESP32 aansluiten: 5 V-signalen zoals de ECHO-uitgang van de HC-SR04 zonder spanningsdeler aansluiten kan de pin beschadigen.
- Een ADC2-pin lezen terwijl Wi-Fi aan staat: GPIO 0, 2, 4, 12–15 en 25–27 lezen geen analoge waarden zolang Wi-Fi draait; verplaats de sensor naar GPIO 32–39.
- Het RAM van de Uno vergeten: compileert de code maar loopt het board willekeurig vast, dan is het RAM misschien op; zet vaste tekst binnen F("...") en vermijd het aan elkaar plakken van Strings in een lus.
- De ESP32 voeden via een zwakke USB-poort: als het board opnieuw opstart wanneer Wi-Fi start, gebruik dan een goede datakabel en een adapter die minstens 1 A levert.
- De Pico en de Pico W door elkaar halen: de gewone Pico heeft geen Wi-Fi; koop voor een draadloos project het model met een W in de naam.
Kort gezegd: de Arduino Uno is het board om te leren, de ESP32 het board om te verbinden en de Raspberry Pi Pico het board om met Python te experimenteren. Vraag je je af welk model uit de Arduino-familie bij je past, kijk dan eens naar Welke Arduino moet ik kopen?. In de BlueGrays-app vind je tientallen projecten voor Arduino, ESP32 en Pico, van een knipperende led tot een Wi-Fi-webserver en van een NTP-klok tot een weerdisplay, elk met een stapsgewijs schakelschema en code.
Veelgestelde vragen
Is de ESP32 beter dan Arduino?
Qua rekenkracht, geheugen en draadloze connectiviteit wel: de ESP32 draait op 240 MHz en heeft 520 KB RAM, Wi-Fi en Bluetooth. Maar door de 3,3 V-pins, beperkte GPIO's en het ingewikkeldere opstarten heeft de Arduino Uno minder verrassingen voor beginners. Welke beter is, hangt af van wat je project nodig heeft.
Kun je de ESP32 programmeren met de Arduino IDE?
Ja. Nadat je het esp32-boardpakket van Espressif aan de Arduino IDE hebt toegevoegd, kun je de ESP32 programmeren met Arduino-commando's. Functies als pinMode, digitalWrite, analogRead, Serial en Wire werken hetzelfde; wat verandert zijn vooral de pinnummers en spanningsniveaus.
Werkt Arduino-code op de ESP32?
De meeste code werkt met kleine aanpassingen. Je moet de pinnummers voor de ESP32 aanpassen, er rekening mee houden dat analogRead 0–4095 teruggeeft, en code die AVR-specifieke registers gebruikt of bibliotheken zoals SoftwareSerial vervangen door hun ESP32-equivalenten.
Kun je Wi-Fi toevoegen aan een Arduino Uno?
Ja: een module zoals de ESP-01 (ESP8266) kun je via de seriële poort met AT-commando's gebruiken, of je koopt de Uno R4 WiFi. De ESP-01 heeft echter een 3,3 V-voeding en niveauconversie nodig, en het 2 KB RAM van de Uno heeft het moeilijk met webtaken. Daarom is het direct gebruiken van een ESP32 in de meeste gevallen eenvoudiger en goedkoper.
Arduino of Raspberry Pi Pico?
Wil je in het Arduino-ecosysteem blijven met C/C++, met 5 V-modules werken en de meeste voorbeelden vinden, dan past de Arduino Uno beter; kies voor programmeren in Python, een lage prijs en nauwkeurige timing met PIO de Raspberry Pi Pico. Omdat de Pico op 3,3 V werkt, moet je net als bij de ESP32 voorzichtig zijn met 5 V-signalen.
Kan de ESP32 met 5 V-sensoren worden gebruikt?
Werkt de sensor ook op 3,3 V, dan is de eenvoudigste oplossing hem te voeden vanaf de 3V3-pin. Zet bij sensoren die alleen op 5 V werken en 5 V uitgeven een spanningsdeler of een niveauconverter op de uitgangslijn. 5 V rechtstreeks op de pins van de ESP32 zetten kan de chip beschadigen.
Projecten om hierna te bouwen
Alle projecten bekijken
LED laten knipperen
De allereerste hallo van de elektronica: één LED aan- en uitzetten. De Arduino zet de LED met korte tussenpozen aan en uit, zodat het licht snel knippert.

Led laten knipperen met ESP32
Leert je het basisgebruik van een GPIO-uitgang met de ESP32. Door een led via een digitale pin aan en uit te zetten krijgen we een knippereffect. Dit is de ESP32-versie van het klassieke blinkproject op de Arduino UNO; de basiscommando's in de Arduino-omgeving zijn hetzelfde, maar de pinindeling en de 3,3 V-GPIO-niveaus van de ESP32 verschillen van die van de Arduino UNO.

Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W)
Het openingsproject van de Raspberry Pi Pico-serie! We laten de groene ingebouwde led van de Pico knipperen om te controleren of het board werkt: het klassieke "Hello World" als eerste experiment. Je hebt geen externe onderdelen nodig, alleen de Pico en een USB-kabel. De code is geschreven in MicroPython, de taal die officieel door de Raspberry Pi Foundation wordt ondersteund.

Temperatuur en luchtvochtigheid met DHT11
Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

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 HTTPClient + weer-API (met lcd-scherm)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Het JSON-antwoord wordt verwerkt met ArduinoJson v7 en stad, temperatuur, luchtvochtigheid, weer en wind verschijnen op een I2C-LCD. wttr.in vraagt geen API-sleutel; typ gewoon de naam van een willekeurige stad.
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

