Code uploaden en begrijpen

Onze eerste schakeling is opgebouwd. De led is via een weerstand aangesloten tussen GPIO 23 en GND.

Toch zal de led nog niet doen wat we willen. De ESP32 weet namelijk nog niet dat GPIO 23 als uitgang moet worden gebruikt. Ook weet hij niet wanneer de led aan of uit moet gaan.

Dat gaan we hem nu vertellen met code.

In dit hoofdstuk richten we eerst de Arduino IDE in voor onze ESP32. Daarna schrijven, controleren en uploaden we ons eerste programma. Daarbij kijken we niet alleen naar welke code je moet invoeren, maar vooral naar wat iedere regel doet.

Het doel is niet dat je code uit je hoofd leert. Het doel is dat je leert voorspellen wat de ESP32 met onze opdrachten gaat doen.

Van een idee naar instructies

Wij willen dat de led één seconde brandt, daarna één seconde uitgaat en dit voortdurend herhaalt.

Voor ons is die opdracht gemakkelijk te begrijpen. Een microcontroller heeft meer precieze instructies nodig.

We moeten hem vertellen:

welke pin met de led is verbonden;
dat deze pin als uitgang wordt gebruikt;
dat de uitgang moet worden ingeschakeld;
hoelang deze toestand moet blijven bestaan;
dat de uitgang daarna moet worden uitgeschakeld;
hoelang hij uit moet blijven;
dat deze stappen steeds opnieuw moeten worden uitgevoerd.

De code is dus geen magische tekst die een led laat knipperen. Het is een nauwkeurige beschrijving van het gedrag dat we van de ESP32 verwachten.

De Arduino IDE openen

Start de Arduino IDE op je computer.

Wanneer je een nieuw leeg programma opent, zie je meestal deze basisstructuur:

void setup() {
  // put your setup code here, to run once:
}

void loop() {
  // put your main code here, to run repeatedly:
}

De Engelstalige opmerkingen kunnen per versie iets verschillen, maar setup() en loop() zijn altijd herkenbaar.

Een programma voor Arduino wordt vaak een sketch genoemd. In deze gids gebruik ik meestal het woord programma of code, omdat dat duidelijker beschrijft waar we mee bezig zijn.

Voordat we code naar de ESP32 kunnen uploaden, moet de Arduino IDE weten welk type microcontroller we gebruiken.

Ondersteuning voor de ESP32 installeren

De Arduino IDE ondersteunt veel officiële Arduino-borden. De ondersteuning voor onze ESP32 moet afzonderlijk worden geïnstalleerd.

Open in de Arduino IDE de Boards Manager. Dat kan via het bordbeheer in de zijbalk of via het menu:

Tools → Board → Boards Manager

In een Nederlandstalige weergave kunnen de namen iets anders worden weergegeven, bijvoorbeeld:

Hulpmiddelen → Bord → Bordenbeheer

Zoek in het zoekveld naar:

esp32

Zoek vervolgens het pakket van Espressif Systems en installeer het.

Het pakket bevat onder andere:

informatie over verschillende ESP32-borden;
de compiler die onze code vertaalt;
functies waarmee we de hardware kunnen gebruiken;
hulpmiddelen voor het uploaden;
voorbeeldprogramma’s en bibliotheken.

Het downloaden en installeren kan enige tijd duren. Sluit de Arduino IDE tijdens dit proces niet af.

Start de Arduino IDE na de installatie eventueel opnieuw op. Daarmee weet je zeker dat alle nieuwe onderdelen correct zijn geladen.

Het juiste bord selecteren

De Arduino IDE moet weten voor welk bord hij de code moet vertalen. Een programma voor een Arduino Uno wordt namelijk anders verwerkt dan een programma voor een ESP32.

Open het menu voor de bordselectie en zoek binnen de geïnstalleerde ESP32-borden naar:

ESP32 Dev Module

Voor veel algemene ontwikkelborden met een ESP32-WROOM-32-module is ESP32 Dev Module een bruikbare keuze.

Sommige ontwikkelborden staan met een specifiekere naam in de lijst. Wanneer de leverancier duidelijk aangeeft welk model je hebt, kun je die specifieke borddefinitie gebruiken. Bij twijfel gebruiken we in deze gids ESP32 Dev Module.

De bordselectie bepaalt onder andere:

voor welk type microcontroller de code wordt vertaald;
hoeveel geheugen beschikbaar is;
welke uploadmethode wordt gebruikt;
welke standaardinstellingen bij het bord horen.

Een verkeerd geselecteerd bord kan ervoor zorgen dat het uploaden mislukt of dat bepaalde functies niet werken zoals verwacht.

De ESP32 aansluiten

Controleer eerst nog eenmaal de schakeling:

GPIO 23 is via een weerstand met de anode van de led verbonden;
de kathode van de led is met GND verbonden;
er is geen directe verbinding tussen 3,3 volt en GND;
er zijn geen losse metalen delen die elkaar raken.

Sluit daarna de ESP32 met de USB-datakabel aan op je computer.

Mogelijk gaat de voedingsled op het ontwikkelbord branden. De losse led op het breadboard kan uit blijven, zwak branden of kort oplichten. GPIO 23 is op dit moment nog niet door ons nieuwe programma ingesteld.

De juiste poort selecteren

Naast het juiste bord moet de Arduino IDE weten via welke USB-verbinding hij met de ESP32 communiceert.

Open de bord- of poortselectie en kies de poort waarop de ESP32 is aangesloten. Via het menu vind je deze meestal onder:

Tools → Port

De naam van de poort verschilt per besturingssysteem. Je kunt bijvoorbeeld iets zien als:

COM3

op Windows, of:

/dev/cu.usbserial-...

op macOS. Onder Linux begint de naam vaak met:

/dev/ttyUSB...

of:

/dev/ttyACM...

Zie je meerdere poorten en weet je niet welke bij de ESP32 hoort? Gebruik dan deze eenvoudige methode:

kijk welke poorten zichtbaar zijn;
koppel de ESP32 los;
open de lijst opnieuw;
onthoud welke poort verdwenen is;
sluit de ESP32 opnieuw aan;
selecteer de poort die terugkomt.

Op deze manier testen we onze aanname in plaats van zomaar een poort te kiezen.

Als er geen poort verschijnt

Verschijnt er geen nieuwe poort wanneer je de ESP32 aansluit? Controleer dan eerst de eenvoudigste mogelijke oorzaken:

gebruik je een USB-datakabel en geen laadkabel;
zit de kabel aan beide kanten volledig aangesloten;
werkt de gekozen USB-aansluiting van de computer;
verschijnt er een melding van het besturingssysteem;
krijgt de ESP32 zichtbaar voeding;
werkt het met een andere USB-kabel;
werkt het zonder USB-hub of adapter;
verschijnt de poort nadat je de Arduino IDE opnieuw opent.

Sommige ESP32-ontwikkelborden gebruiken een USB-naar-serieelchip waarvoor het besturingssysteem een stuurprogramma nodig kan hebben. Veelgebruikte chips zijn bijvoorbeeld de CP210x en CH340.

Installeer niet zomaar een willekeurig stuurprogramma. Kijk eerst welke chip werkelijk op jouw bord zit en gebruik daarna de software van de fabrikant.

Een brandende voedingsled betekent alleen dat de kabel stroom levert. Het bewijst niet dat de kabel ook gegevens kan verzenden of dat de computer het bord herkent.

Ons eerste programma

Verwijder de standaardtekst uit het lege programma en voer de volgende code in:

const int ledPin = 23;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(1000);

  digitalWrite(ledPin, LOW);
  delay(1000);
}

Neem de code zorgvuldig over.

Let daarbij op:

hoofdletters en kleine letters;
ronde haakjes ( en );
accolades { en };
puntkomma’s ;;
de schrijfwijze van iedere opdracht.

Programmeertalen zijn minder vergevingsgezind dan gewone schrijftaal. pinMode, pinmode en PinMode zijn voor de compiler drie verschillende namen.

De code regel voor regel begrijpen

Laten we bekijken wat we de ESP32 precies vertellen.

De pin vastleggen

De eerste regel is:

const int ledPin = 23;

Met deze regel maken we een naam voor het nummer van de pin.

int betekent dat de variabele een geheel getal bevat.

ledPin is de naam die wij hebben gekozen.

23 is het nummer van de GPIO waarop onze led is aangesloten.

Het woord const geeft aan dat deze waarde tijdens het uitvoeren van het programma niet mag veranderen. Onze led blijft immers fysiek met GPIO 23 verbonden.

We hadden overal rechtstreeks het getal 23 kunnen gebruiken. Toch is ledPin duidelijker. Wanneer je later de code leest, begrijp je sneller dat deze pin voor de led wordt gebruikt.

Ook kunnen we de schakeling later gemakkelijker aanpassen. Als we de led naar een andere geschikte pin verplaatsen, hoeven we alleen deze ene regel te veranderen.

De puntkomma aan het einde markeert het einde van de opdracht.

Wat gebeurt er in setup()?

Daarna volgt:

void setup() {
  pinMode(ledPin, OUTPUT);
}

De inhoud van setup() wordt één keer uitgevoerd wanneer de ESP32 opstart of opnieuw wordt ingesteld.

Met:

pinMode(ledPin, OUTPUT);

stellen we de pin met de naam ledPin in als uitgang.

Omdat ledPin de waarde 23 bevat, betekent deze regel in onze schakeling:

Gebruik GPIO 23 als een uitgang die door het programma kan worden aangestuurd.

OUTPUT is Engels voor uitgang.

Zonder deze instelling weet de ESP32 niet automatisch waarvoor we GPIO 23 willen gebruiken. Een GPIO kan in verschillende situaties namelijk als ingang of als uitgang functioneren.

De accolades geven aan welke opdrachten bij setup() horen:

{
  // Alles hierbinnen hoort bij setup
}

Zodra de laatste accolade van setup() is bereikt, gaat de ESP32 verder met loop().

Wat gebeurt er in loop()?

De inhoud van loop() wordt voortdurend herhaald:

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(1000);

  digitalWrite(ledPin, LOW);
  delay(1000);
}

De eerste opdracht is:

digitalWrite(ledPin, HIGH);

digitalWrite() verandert de toestand van een digitale uitgang.

ledPin vertelt welke uitgang we willen veranderen.

HIGH betekent dat de uitgang hoog wordt gemaakt. Bij de ESP32 komt dat voor onze schakeling neer op ongeveer 3,3 volt. Daardoor kan er stroom door de weerstand en de led naar GND lopen. De led gaat branden.

Daarna komt:

delay(1000);

delay() laat het programma wachten. De tijd wordt opgegeven in milliseconden.

Duizend milliseconden is één seconde. De led blijft daarom ongeveer één seconde branden.

Vervolgens voeren we uit:

digitalWrite(ledPin, LOW);

LOW maakt de uitgang laag, ongeveer 0 volt. Er staat dan vrijwel geen spanningsverschil meer over onze ledschakeling en de led gaat uit.

Daarna wacht het programma opnieuw één seconde:

delay(1000);

Wanneer de laatste regel van loop() is uitgevoerd, springt de ESP32 automatisch terug naar het begin van loop().

Het patroon wordt daardoor:

led aan;
één seconde wachten;
led uit;
één seconde wachten;
opnieuw beginnen.

Wat verwacht je dat er gebeurt?

Voordat we de code uploaden, doen we weer een voorspelling.

We verwachten dat:

de led ongeveer één seconde brandt;
de led daarna ongeveer één seconde uit is;
dit patroon zich blijft herhalen;
het programma opnieuw begint wanneer we op de resetknop drukken;
het programma bewaard blijft wanneer we de voeding loskoppelen.

Deze verwachtingen geven ons straks concrete punten om te controleren.

Controleren is nog niet uploaden

Boven in de Arduino IDE staat een knop met een vinkje. Daarmee kunnen we de code controleren. Dit wordt ook wel verifiëren of compileren genoemd.

Tijdens deze controle onderzoekt de Arduino IDE of de code volgens de regels van de programmeertaal is geschreven. Daarna wordt de code vertaald naar instructies die de ESP32 kan uitvoeren.

Klik eerst op de knop met het vinkje.

Wanneer de controle slaagt, verschijnt onder in het venster een melding dat het compileren is voltooid. Vaak zie je ook informatie over de hoeveelheid gebruikt geheugen.

Op dit moment is de code nog niet naar de ESP32 gestuurd. We hebben alleen vastgesteld dat de Arduino IDE er een uitvoerbaar programma van kan maken.

Dat onderscheid is belangrijk:

Controleren onderzoekt en vertaalt de code.
Uploaden plaatst het vertaalde programma op de ESP32.

Code die zonder foutmelding compileert, hoeft nog niet te doen wat je bedoelde. De compiler controleert de taalregels, niet jouw bedoeling.

De volgende regel is bijvoorbeeld geldige code:

const int ledPin = 22;

De compiler vindt daar niets mis mee. Maar als de led fysiek op GPIO 23 is aangesloten, zal onze schakeling niet werken zoals verwacht.

Een technisch geldige opdracht kan dus nog steeds een verkeerde opdracht zijn.

Foutmeldingen lezen

Als de code niet kan worden gecompileerd, verschijnt onder in de Arduino IDE een foutmelding.

Dat kan in het begin indrukwekkend lijken. Soms bestaat de melding uit meerdere regels en technische termen. Toch staat er meestal bruikbare informatie in.

Kijk eerst naar:

het genoemde regelnummer;
de eerste duidelijke foutmelding;
een ontbrekende puntkomma;
een verkeerd gespelde opdracht;
een ontbrekende of extra accolade;
een verschil tussen hoofdletters en kleine letters.

Stel dat we de puntkomma achter deze regel vergeten:

const int ledPin = 23

De compiler kan dan pas op de volgende regel ontdekken dat er iets niet klopt. Het aangegeven regelnummer wijst daarom niet altijd precies naar de plaats waar de fout is ontstaan. Kijk ook naar de regel erboven.

Verander bij voorkeur één ding tegelijk en controleer de code daarna opnieuw.

Het programma uploaden

Wanneer de code zonder foutmeldingen is gecontroleerd, kunnen we hem uploaden.

Controleer eerst:

ESP32 Dev Module of het juiste specifieke bord is geselecteerd;
de juiste USB-poort is geselecteerd;
de ESP32 is via een datakabel aangesloten;
de schakeling is nog steeds correct opgebouwd.

Klik daarna op de knop met de pijl naar rechts: Uploaden.

De Arduino IDE voert nu opnieuw de controle uit en probeert daarna verbinding te maken met de ESP32. Onderaan het venster kun je de voortgang volgen.

Tijdens het uploaden kan informatie verschijnen zoals:

Connecting...

en later een melding dat het uploaden is voltooid.

De ESP32 start daarna meestal automatisch opnieuw op en begint het nieuwe programma uit te voeren.

Kijk eerst, raak nog niets aan

Als het uploaden is geslaagd, kijk dan naar de losse led op het breadboard.

Je verwacht het volgende patroon:

ongeveer één seconde aan;
ongeveer één seconde uit;
daarna opnieuw.

Vergelijk dit met je voorspelling.

Knippert de led in het verwachte tempo? Dan werken verschillende onderdelen samen:

de computer herkent de ESP32;
de USB-kabel kan gegevens verzenden;
het juiste bord en de juiste poort zijn geselecteerd;
de code kan worden gecompileerd;
het programma is naar de ESP32 verzonden;
GPIO 23 wordt als uitgang gebruikt;
de externe schakeling reageert op die uitgang.

We hebben dus niet alleen een knipperende led gemaakt. We hebben een volledige keten getest, van geschreven code tot zichtbaar gedrag.

Als het uploaden niet begint

Sommige ESP32-ontwikkelborden gaan niet automatisch in de juiste uploadmodus.

Blijft de Arduino IDE bij Connecting... staan, dan kun je de volgende methode proberen:

start het uploaden opnieuw;
houd de knop BOOT op de ESP32 ingedrukt wanneer Connecting... verschijnt;
laat BOOT los zodra het schrijven daadwerkelijk begint.

Dit is niet bij ieder bord nodig. Gebruik de knop daarom pas wanneer het normale uploaden niet werkt.

Controleer bij een uploadprobleem ook opnieuw:

het geselecteerde bord;
de geselecteerde poort;
de USB-kabel;
de USB-aansluiting;
eventuele meldingen van het besturingssysteem;
of de seriële monitor de poort bezet houdt;
of losgekoppelde externe bedrading verschil maakt.

Probeer de oorzaak af te bakenen. Verander niet tegelijk van bordinstelling, kabel, poort en code, want dan weet je achteraf niet welke verandering het probleem heeft opgelost.

Als het uploaden slaagt maar de led niet knippert

Een geslaagde upload betekent dat de code op de ESP32 staat. Het bewijst nog niet dat de externe schakeling correct is.

Controleer eerst wat je precies waarneemt:

blijft de led voortdurend uit;
blijft hij voortdurend aan;
knippert hij veel sneller of langzamer;
knippert alleen een led op het ESP32-bord;
reageert de losse led wanneer je voorzichtig aan een draad beweegt?

Controleer daarna de keten van GPIO 23 naar GND:

GPIO 23 → weerstand → anode led → kathode led → GND

Mogelijke oorzaken zijn:

de draad zit op een andere GPIO;
de led is omgekeerd geplaatst;
beide pootjes van de led zitten in dezelfde verbonden rij;
de weerstand en de led delen niet werkelijk dezelfde rij;
de GND-verbinding ontbreekt;
een voedingsrail is halverwege onderbroken;
de code gebruikt een ander pinnummer;
je kijkt naar de ingebouwde led in plaats van de externe led.

Vergelijk altijd de fysieke schakeling met de code. De regel:

const int ledPin = 23;

en de werkelijke aansluiting moeten hetzelfde pinnummer aanwijzen.

Zelf de code veranderen

Nu de basisschakeling werkt, kunnen we onderzoeken wat verschillende regels doen.

Verander eerst:

delay(1000);

in:

delay(250);

Doe dit bij beide wachttijden.

Controleer de code, upload hem opnieuw en kijk wat er verandert.

De led blijft nu een kwart seconde aan en een kwart seconde uit. Een volledige cyclus duurt ongeveer een halve seconde.

Verander daarna alleen de eerste wachttijd:

digitalWrite(ledPin, HIGH);
delay(100);

digitalWrite(ledPin, LOW);
delay(900);

Voorspel opnieuw wat je verwacht voordat je de code uploadt.

De led zal nu kort oplichten en daarna langer uit blijven. De totale cyclus duurt nog steeds ongeveer één seconde, maar de verhouding tussen aan en uit is veranderd.

Dit is een eenvoudige manier om code te leren begrijpen:

Verander één waarde, voorspel het gevolg en vergelijk je voorspelling met het werkelijke gedrag.

Commentaar aan code toevoegen

We kunnen uitleg aan onze code toevoegen zonder dat de ESP32 die tekst probeert uit te voeren.

Tekst achter twee schuine strepen is commentaar:

// De led is aangesloten op GPIO 23
const int ledPin = 23;

De compiler negeert alles achter // op die regel.

We kunnen onze volledige code bijvoorbeeld zo verduidelijken:

// De led is via een weerstand aangesloten op GPIO 23
const int ledPin = 23;

void setup() {
  // Stel de ledpin in als uitgang
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // Zet de led aan
  digitalWrite(ledPin, HIGH);
  delay(1000);

  // Zet de led uit
  digitalWrite(ledPin, LOW);
  delay(1000);
}

Goed commentaar legt vooral uit waarom iets gebeurt of welke fysieke aansluiting bij de code hoort.

De volgende opmerking voegt weinig toe:

digitalWrite(ledPin, HIGH);  // Schrijf HIGH naar ledPin

Deze opmerking is nuttiger:

digitalWrite(ledPin, HIGH);  // Laat zien dat de meting wordt uitgevoerd

Commentaar is ook waardevol voor foutzoeken. Noteer bijvoorbeeld waarom je een bepaalde pin, grenswaarde of wachttijd hebt gekozen.

Berichten bekijken met de seriële monitor

De led laat ons zien dat de code iets doet. Toch kan een led maar weinig informatie geven. We kunnen niet zien welke regel wordt uitgevoerd of welke waarde een variabele bevat.

Daarvoor gebruiken we later vaak de seriële monitor.

Voeg eerst in setup() deze regel toe:

Serial.begin(115200);

Onze setup() wordt dan:

void setup() {
  Serial.begin(115200);
  pinMode(ledPin, OUTPUT);
}

Voeg daarna berichten toe aan loop():

void loop() {
  digitalWrite(ledPin, HIGH);
  Serial.println("Led aan");
  delay(1000);

  digitalWrite(ledPin, LOW);
  Serial.println("Led uit");
  delay(1000);
}

Het volledige programma is nu:

const int ledPin = 23;

void setup() {
  Serial.begin(115200);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);
  Serial.println("Led aan");
  delay(1000);

  digitalWrite(ledPin, LOW);
  Serial.println("Led uit");
  delay(1000);
}

Upload deze versie en open daarna de seriële monitor in de Arduino IDE.

Stel de snelheid van de seriële monitor in op:

115200 baud

Deze waarde moet overeenkomen met de waarde in:

Serial.begin(115200);

Je ziet nu afwisselend:

Led aan
Led uit
Led aan
Led uit

De seriële monitor geeft ons daarmee een kijkje in het programma. Wanneer de led niet reageert maar de berichten wel verschijnen, weten we dat de ESP32 de code uitvoert. We kunnen het onderzoek dan richten op de pin en de externe schakeling.

Dat is veel gerichter dan concluderen dat “niets werkt”.

De resetknop gebruiken

Op het ESP32-ontwikkelbord zit een knop met de aanduiding EN of RST.

Wanneer je deze knop indrukt, start de microcontroller opnieuw op. Het programma begint dan weer bij setup() en gaat daarna verder met loop().

De code wordt door een reset niet gewist.

Je kunt dit zichtbaar maken met een extra bericht:

void setup() {
  Serial.begin(115200);
  pinMode(ledPin, OUTPUT);

  Serial.println("ESP32 gestart");
}

Het bericht ESP32 gestart verschijnt één keer na het opstarten. De berichten uit loop() blijven zich herhalen.

Druk je op de resetknop, dan verschijnt ESP32 gestart opnieuw.

Zo kunnen we zelf waarnemen dat setup() één keer wordt uitgevoerd en loop() daarna blijft herhalen.

Het programma blijft bewaard

Koppel de USB-kabel los en wacht enkele seconden. Sluit de ESP32 daarna opnieuw aan.

Je hoeft de code niet opnieuw te uploaden. Het programma is in het geheugen van de ESP32 opgeslagen en begint na het inschakelen opnieuw.

Dat betekent dat een ESP32 zelfstandig kan werken. Wanneer het programma eenmaal is geüpload, is de Arduino IDE niet nodig voor de uitvoering.

De ESP32 heeft natuurlijk nog wel een geschikte voeding nodig. Tijdens onze oefeningen gebruiken we daarvoor de USB-aansluiting.

Wat delay() werkelijk doet

Voor onze eerste oefening is delay() gemakkelijk en overzichtelijk. De opdracht laat het programma gedurende een bepaalde tijd wachten.

Tijdens:

delay(1000);

doet onze code één seconde lang niets anders.

Bij een eenvoudige knipperende led is dat geen probleem. In een groter project kan het lastig worden. Stel dat de ESP32 tijdens die seconde ook een knop moet controleren, een sensor moet uitlezen of een MQTT-bericht moet verwerken. Dan kan een lange delay() ervoor zorgen dat het project traag reageert.

Later leren we hoe we tijd kunnen bijhouden zonder het volledige programma stil te zetten.

Voor nu gebruiken we delay() omdat het gedrag daarmee duidelijk zichtbaar en gemakkelijk te begrijpen is.

Code lezen als een reeks gebeurtenissen

Probeer code niet alleen als losse regels te bekijken. Lees hem als een verhaal:

Bewaar dat de led op pin 23 zit.

Start de seriële communicatie.

Maak pin 23 een uitgang.

Zet de uitgang hoog.

Meld dat de led aan is.

Wacht één seconde.

Zet de uitgang laag.

Meld dat de led uit is.

Wacht één seconde.

Begin opnieuw.

Wanneer je een programma op deze manier kunt navertellen, begrijp je meestal al een groot deel van het gedrag.

Komt het werkelijke gedrag niet overeen met dit verhaal? Dan kun je onderzoeken bij welke stap het verschil ontstaat.

Een kleine oefening

Pas het programma zo aan dat de led:

tweemaal kort knippert;
daarna twee seconden uit blijft;
dit patroon voortdurend herhaalt.

Gebruik voor een korte flits bijvoorbeeld:

delay(150);

Probeer de code eerst zelf op te bouwen. Schrijf op wat je verwacht en upload hem daarna.

Een mogelijke oplossing is:

const int ledPin = 23;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(150);

  digitalWrite(ledPin, LOW);
  delay(150);

  digitalWrite(ledPin, HIGH);
  delay(150);

  digitalWrite(ledPin, LOW);
  delay(2000);
}

Kijk niet alleen of de oplossing werkt. Loop ook regel voor regel door het programma en verklaar waarom het zichtbare patroon ontstaat.

Wat je uit dit hoofdstuk kunt meenemen

We hebben voor het eerst de volledige weg van idee naar gedrag afgelegd:

Idee → code → controle → upload → uitvoering → waarneming

Daarbij heb je ontdekt dat:

de Arduino IDE ondersteuning voor het gekozen bord nodig heeft;
het juiste bord en de juiste USB-poort moeten worden geselecteerd;
controleren en uploaden twee verschillende stappen zijn;
setup() één keer wordt uitgevoerd;
loop() voortdurend wordt herhaald;
pinMode() bepaalt hoe een GPIO wordt gebruikt;
digitalWrite() een digitale uitgang hoog of laag maakt;
HIGH en LOW de toestand van de uitgang bepalen;
delay() het programma tijdelijk laat wachten;
commentaar code begrijpelijker kan maken;
de seriële monitor zichtbaar maakt wat er in het programma gebeurt;
foutloos compileren niet hetzelfde is als correct gedrag;
code en fysieke bedrading altijd met elkaar moeten overeenkomen.

De knipperende led is misschien eenvoudig, maar de werkwijze erachter is dezelfde die we later gebruiken voor sensoren, WiFi en MQTT.

We bedenken wat er moet gebeuren, vertalen dat naar duidelijke instructies en controleren vervolgens of de werkelijkheid overeenkomt met onze verwachting.

In het volgende hoofdstuk gaan we beter bekijken wat er elektrisch gebeurt. We onderzoeken spanning, stroom en de pinnen van de ESP32 zonder daarvoor eerst een ingewikkelde theoretische omweg te maken.

Actuele installatiehulp

Software en menunamen kunnen na verloop van tijd veranderen. De actuele officiële stappen vind je bij Espressif: Arduino-ESP32 installeren en Arduino: een bord en poort selecteren.