ESP32

Wat het is

De ESP32 is een microcontroller die aanvoelt als een Arduino met een radio erop en de handrem eraf. Hij heeft een 32-bits processor met twee kernen die veel sneller werkt dan een Uno, veel meer geheugen en, het belangrijkste, ingebouwde Wi-Fi en Bluetooth. Die combinatie laat hem de hobbyrobotica en IoT domineren: één betaalbare chip kan een webpagina hosten om een robot te besturen, sensorgegevens naar je telefoon sturen of commando’s via Bluetooth ontvangen.

Cruciaal is dat je hem programmeert met dezelfde Arduino IDE en taal die je mogelijk al kent. Wat je op een Uno hebt geleerd gaat rechtstreeks over; je krijgt alleen connectiviteit en ruimte voor meer.

Hoe het werkt

De ESP32 heeft twee Xtensa-kernen met een kloksnelheid tot 240 MHz. Twee kernen zijn belangrijk voor robots: de ene kan je regellus met stabiele timing uitvoeren terwijl de andere Wi-Fi verwerkt, zodat de wielen niet door netwerkverkeer worden vertraagd. Rond de CPU zitten de gebruikelijke microcontrollerperiferieën, GPIO, PWM-kanalen, meerdere ADC’s, I²C, SPI en UART, plus de radio.

Het belangrijkste praktische feit is de spanning: de ESP32 werkt op 3,3V-logica, niet op de 5 V van de Uno. De pinnen zijn niet 5V-tolerant. Een uitgangssignaal van 5 V, zoals de Echo-pin van een HC-SR04, moet omlaag naar 3,3 V voordat het een ESP32-pin bereikt, anders riskeer je beschadiging. Dit ene verschil laat bijna iedereen struikelen bij de overstap vanaf een Uno.

Wanneer je hem gebruikt

Kies een ESP32 wanneer je robot draadloos moet zijn, bijvoorbeeld voor afstandsbediening, telemetrie of een dashboard in de browser, of wanneer je rekenkracht nodig hebt die een 8-bits bord niet kan bieden, bijvoorbeeld voor meer sensoren of lichte logica op het apparaat. De variant ESP32-CAM voegt een camera toe en maakt eenvoudige beeldverwerkingsprojecten mogelijk.

Kies een Arduino Uno wanneer je de basis leert, wanneer 5V-tolerantie veiliger bedraden maakt of wanneer het project eenvoudig en offline is; twee motoren die een lijn volgen, hebben daar geen Wi-Fi voor nodig.

Bedrading en valkuilen

• Hij werkt op 3,3 V en is niet 5V-tolerant. Gebruik een spanningsniveau-omzetter voor elk 5V-signaal voordat het een GPIO bereikt. Dit is de meest voorkomende manier waarop beginners een ESP32 beschadigen.
• Wi-Fi en motoren kunnen brown-out van het bord veroorzaken. De radio veroorzaakt scherpe stroompieken; een zwakke voeding delen met motoren veroorzaakt resets. Voed motoren apart via een motordriver en geef de ESP32 een stabiele 3,3V-rail.
• Niet elke pin is vrij. Verschillende GPIOs zijn alleen ingangen, gekoppeld aan het opstartgedrag of verbonden met het interne flashgeheugen. Controleer vooraf de pindindeling; een verkeerd toegewezen pin kan verhinderen dat het bord opstart.
• Eigenaardigheden van de ADC. Een van de twee ADC’s is niet beschikbaar terwijl Wi-Fi actief is, en de metingen zijn minder lineair dan die van een Uno; kalibreer als je nauwkeurigheid nodig hebt.

Pinnen die je niet mag gebruiken

Een ESP32 heeft ongeveer 34 GPIOs en dat is misleidend: een aanzienlijk deel is onbruikbaar, is alleen onder bepaalde voorwaarden bruikbaar of kan het opstarten verhinderen. Deze tabel moet je lezen voordat je iets bedraadt.

De veiligste algemene pinnen op een standaard 30-pins ontwikkelbord zijn GPIO 4, 5, 13, 14, 16, 17, 18, 19, 21, 22, 23, 25, 26, 27, 32, 33. Begin daarmee en je vermijdt elke valkuil hierboven.

De opstartpins geven de verwarrendste storing, omdat het bord perfect werkt totdat je er iets aan hangt. Een pull-upweerstand op GPIO 12, volstrekt logisch voor een knop, betekent dat het bord eenvoudig niet start, zonder fout of seriële uitvoer.

De pinnen die alleen ingang zijn falen anders: GPIO 34–39 hebben geen interne pull-up- of pull-downweerstand, dus een knop daarop zweeft en leest willekeurige waarden. Ze vereisen een externe weerstand.

3,3 V en wat dat je kost

De pinnen van de ESP32 zijn niet 5V-tolerant, en dit is de meest voorkomende manier waarop mensen hem beschadigen. Elk 5V-signaal vraagt om behandeling:

Onthoud de asymmetrie: uitgangen zijn meestal veilig, ingangen meestal niet. De Echo-pin van een HC-SR04 is het klassieke voorbeeld: die stuurt volledige 5 V naar een pin met een absoluut maximum van 3,6 V.

Het ADC-probleem

De ADC van de ESP32 is het zwakste onderdeel van de chip, en doen alsof dat niet zo is kost uren.

ADC2 werkt niet terwijl Wi-Fi actief is. De radio gebruikt hem. Elke analogRead op een ADC2-pin levert ongeldige waarden op of blokkeert zodra Wi-Fi verbinding maakt. Omdat een draadloze robot de hele reden is om een ESP32 te gebruiken, valt ADC2 daarmee vrijwel volledig af. Gebruik alleen ADC1: GPIO 32–39.

De respons is niet lineair. De 12-bits ADC is aan beide uiteinden duidelijk niet lineair en waarden onder ongeveer 0,1 V en boven ruwweg 3,1 V worden samengedrukt. De chip bevat fabriekskalibratiegegevens die de functies esp_adc_cal van ESP-IDF voor je toepassen; analogRead van Arduino gebruikt die standaard niet.

Heb je werkelijke nauwkeurigheid nodig van een analoge sensor, dan is een externe I²C-ADC zoals een ADS1115 de praktische oplossing. Die kost een paar dollar en neemt het hele probleem weg.

Voeding zonder brown-out

Hier falen ESP32-robotprojecten het vaakst, en de oorzaak is niet voor de hand liggend.

De radio verbruikt geen constante stroom, maar trekt deze in bursts. Een zendburst kan 500 mA gedurende enkele honderden microseconden vragen tegen een gemiddelde van 40–80 mA. Een voeding die op een multimeter goed lijkt, kan tijdens die pieken toch inzakken, waarna de ESP32 reset met het bericht Brownout detector was triggered.

Dat laatste punt moet duidelijk worden gezegd: voer 5 V toe op de VIN/5V-pin en laat de spanningsregelaar op het bord er 3,3 V van maken. Rechtstreeks 3,3 V toevoeren omzeilt zowel de spanningsregelaar als de filterwerking die de transienties dempt.

Twee kernen en hoe je ze echt gebruikt

De twee kernen zijn het belangrijkste voordeel van de ESP32 voor robots, maar het Arduino-framework verbergt ze: je loop() draait op kern 1 en de Wi-Fi-stack op kern 0.

Je kunt een taak expliciet aan een kern toewijzen:

void controlLoop(void *param) {
  const TickType_t period = pdMS_TO_TICKS(10);   // exactly 100 Hz
  TickType_t last = xTaskGetTickCount();
  for (;;) {
    readSensors();
    updatePid();
    driveMotors();
    vTaskDelayUntil(&last, period);              // no drift, unlike delay()
  }
}

void setup() {
  xTaskCreatePinnedToCore(
    controlLoop, "control", 4096, nullptr,
    2,          // priority above the default
    nullptr,
    1);         // core 1 — leave core 0 for Wi-Fi
}

Dit patroon maakt een ESP32 werkelijk goed voor robots in plaats van alleen verbonden: een regellus met strikte timing op de ene kern en een webserver op de andere die hem niet kan tegenhouden. vTaskDelayUntil is het belangrijke detail; anders dan delay() compenseert deze functie voor de tijd die de lus heeft gekost, zodat de periode exact 10 ms blijft.

Problemen oplossen

ESP32 of Arduino Uno?

Beide gebruiken dezelfde taal en IDE, en dat is het punt: de overstap kost je vrijwel niets in code, maar wel veel in bedradingsdiscipline.

De eerlijke aanbeveling: ** leer op een Uno en bouw met een ESP32.** De 5V-tolerantie en het volledige ontbreken van pinvalkuilen op de Uno maken vroege fouten herstelbaar. Zodra je weet wat een regellus is en waarom een gemeenschappelijke massa nodig is, biedt de ESP32 vijftien keer de kloksnelheid, 260 keer zoveel geheugen en een radio voor ongeveer dezelfde prijs.

De ESP32-CAM-variant verdient een eigen vermelding: dit bord voegt voor een paar dollar een camera en een SD-slot toe en is daarmee veruit de goedkoopste route naar robotbeeldverwerking. Daar staat tegenover dat er vrijwel geen GPIO meer over is.