Omschrijving
De structuur van een Arduino programma (sketch) is vrij eenvoudig en omvat over het algemeen de volgende hoofdonderdelen:

1. Opmerkingen: Begin van een sketch vaak met opmerkingen die informatie geven over de auteur, het doel van de sketch en andere relevante details. Opmerkingen beginnen met // voor enkele regels of /* */ voor blokken tekst.
2. Bibliotheken Includeren: Hier voeg je bibliotheken toe die nodig zijn voor jouw project. Dit gebeurt aan het begin van de sketch met de #include directive. Voorbeeld: #include <Servo.h> om een servomotor te besturen.
3. Variabelen Definiëren: Hier declareer je globale variabelen die in de hele sketch gebruikt zullen worden. Je definieert bijvoorbeeld pinnen of andere parameters die je in meerdere functies gebruikt.
4. Setup() Functie: Deze functie wordt eenmaal uitgevoerd bij het starten van de sketch. Je gebruikt het om pinmodi in te stellen (input, output), seriële communicatie te starten, of andere initialisatiecode uit te voeren die nodig is voordat de hoofdloop begint.

void setup() {
  pinMode(13, OUTPUT); // Stel pin 13 in als output
  Serial.begin(9600);  // Start seriële communicatie met 9600 bps
}

5. Loop() Functie: De kern van een Arduino sketch, deze functie loopt continu zolang het Arduino bord van stroom wordt voorzien. De loop() bevat de code die de logica van het project bestuurt, zoals het lezen van sensoren, het maken van berekeningen en het aansturen van outputs.

void loop() {
  digitalWrite(13, HIGH);   // Zet pin 13 aan
  delay(1000);               // Wacht een seconde
  digitalWrite(13, LOW);    // Zet pin 13 uit
  delay(1000);               // Wacht nog een seconde
}

6. Additionele Functies: Je kunt extra functies definiëren die door loop() of setup() worden aangeroepen. Deze functies kunnen helpen om de code overzichtelijk en modulair te houden.

Elk van deze onderdelen helpt bij het organiseren van de code en maakt het programmeren van de microcontroller effectiever en gestructureerder.

Gebruik van hoofd- en kleine letters
Gebruik hoofd- en kleine letters op de correcte manier, C++ is hoofdletter gevoelig. Dit wil zeggen dat het commando PinMode(13, OUTPUT); niet werkt en pinMode(13, OUTPUT); wel. Omdat pinMode() met een kleine letter p aan het begin geschreven moet worden. Dit geldt dus ook voor variabelen. Hierdoor zijn int pinLED = 13; en int PinLED = 14; twee verschillende variabelen. Gebruik voor variabelen duidelijke namen die omschrijven wat de inhoud van een variabele is, bijvoorbeeld int geboorteJaar = 1990; en int geboorteDag = 23;.

Gebruik van de ‘;’ (puntkomma)
In programmeren is de puntkomma (;) zoals een punt aan het einde van een zin. Het vertelt de computer dat je klaar bent met een instructie. Als je het vergeet, raakt de computer in de war omdat het niet weet waar de ene instructie stopt en de volgende begint. Het is een klein teken, maar heel belangrijk om fouten te voorkomen.

Gebruik van ‘{}’ (accolades)
Stel je voor dat je een reeks taken hebt die je wilt uitvoeren, maar alleen onder bepaalde omstandigheden. Accolades helpen je om deze taken als één geheel te groeperen, zodat ze alleen worden uitgevoerd wanneer die specifieke omstandigheden zich voordoen. Ze werken als een container die de taken bij elkaar houdt en vertelt de computer dat alles binnen die container samen hoort. Dit maakt je code gemakkelijker te begrijpen en te beheren, omdat je duidelijk kunt zien welke taken samen worden uitgevoerd in een bepaalde situatie. Je ziet ze bijvoorbeeld bij de setup() en loop() functie. Zo zie je wat er bij elke functie hoort, ze geven het begin en het einde aan.

Inspringen van de programma regels
Het inspringen van tekst in C++ code (of in elke andere programmeertaal) is belangrijk om verschillende redenen:

1. Leesbaarheid: Goed ingesprongen code is veel makkelijker te lezen en te begrijpen. Dit helpt de persoon die de code schrijft en anderen die later de code moeten aanpassen.
2. Structuur: Inspringen maakt de structuur van de code duidelijker. Vooral bij herhalingen zoals lussen (for) en voorwaarden (if). Hierdoor kun je snel zien welke stukken code bij elkaar horen.
3. Fouten vermijden: Correct inspringen helpt om logische fouten te voorkomen. Als de inspringing niet klopt, kan dit betekenen dat er een fout in het programma zit.
4. Samenwerking: Als iedereen dezelfde inspringstijl gebruikt, is het makkelijker voor teams om samen te werken en de code te begrijpen.

Download het programma zonder inspring en verbeter het, door de code te laten inspringen.

Zonder en met inspring

Download zonder inspring

Voorbeeld van een compleet programma

/*
  Eenvoudige LED knipper sketch
  Auteur: Laurens
  Beschrijving: 
  Dit programma knippert een LED die is aangesloten op pin 13 van een Arduino bord.
  De LED wordt om de seconde aan- en uitgezet, waarbij de status via de seriële monitor wordt weergegeven.
*/

// Inclusief de standaard Arduino bibliotheek
#include <Arduino.h> 

// Variabelen
int ledPin = 13; // Het pinnummer waarop de LED is aangesloten

void setup() {
  pinMode(ledPin, OUTPUT); // Stel de pinmode van ledPin in op OUTPUT
  Serial.begin(9600);      // Start de seriële communicatie met de computer
}

void loop() {
  turnLEDOn();   // Roep functie aan om de LED aan te zetten
  delay(1000);   // Wacht 1000 milliseconden (1 seconde)
  turnLEDOff();  // Roep functie aan om de LED uit te zetten
  delay(1000);   // Wacht nogmaals 1000 milliseconden (1 seconde)
}

// Functie om de LED aan te zetten
void turnLEDOn() {
  digitalWrite(ledPin, HIGH); // Zet de LED aan
  Serial.println("LED AAN");  // Stuur een bericht naar de seriële monitor
}

// Functie om de LED uit te zetten
void turnLEDOff() {
  digitalWrite(ledPin, LOW);  // Zet de LED uit
  Serial.println("LED UIT");  // Stuur een bericht naar de seriële monitor
}

Notities in Arduino C++ zijn kleine stukjes tekst die je in je code schrijft om uit te leggen wat de code doet. De computer leest deze notities niet wanneer hij de code uitvoert. Ze helpen je onder andere om je eigen code beter te begrijpen. Er zijn twee soorten Notities:

1. Enkelregelig notities
   Deze beginnen met ‘//’. Alles wat na ‘//’ op dezelfde regel staat, is een notities.
2. Meerregelig notities
   Deze beginnen met ‘/*’ en eindigen met ‘*/’. Alles tussen ‘/*’ en ‘*/’ is een notitie, ook als het over meerdere regels gaat.

Waarom gebruik je commentaar?

• Helderheid
  Notities maken je code gemakkelijker te begrijpen. Als je later terugkomt naar je code, helpen ze je herinneren wat je hebt gedaan.
• Delen
  Als je je code deelt met anderen, helpt een notities hen te begrijpen wat elk deel van de code doet.
• Herinneren
  Notities helpen je te herinneren waarom je bepaalde keuzes in je code hebt gemaakt. Of wat een eigen gemaakte functie doet, wat je door moet geven en wat de functie terug geeft.
• Fouten vinden
  Als je problemen in je code probeert op te lossen, helpen notities je begrijpen waarom je bepaalde stukken code hebt geschreven. Ook kun je code tijdelijk uitschakelen door er een notitie van te maken.

Enkelregelig notitie

// Dit is een enkelregelig notitie.
// int ledPin = 16;
int ledPin = 13;  // Dit betekent dat de groene LED op pin 13 zit.

Meerregelig notitie

/* 
  Dit is een meerregelig notitie.
  Het kan over meerdere regels gaan.
*/
int ledPin = 10; /* Dit betekent dat de rode LED op pin 10 zit */

// onderstaande code tijdelijk uitgeschakeld.
/*
for(int x=0; x<5; x++){
  Serial.println("Print iets 5 keer");
}
*/

In het kort
Notities zijn kleine stukjes tekst die je in je code schrijft om dingen uit te leggen. Ze maken je code makkelijker te begrijpen en zijn handig voor jezelf en voor anderen die naar je code kijken. Maar doen verder niets.

Omschrijving
In Arduino C++ zijn operators speciale tekens die je helpen bij taken zoals rekenen en vergelijken. Je hebt rekenkundige operators zoals ‘+’, ‘-‘, ‘*’, en ‘/’ voor wiskundige berekeningen. Vergelijkingsoperators zoals ‘==’, ‘!=’, ‘>’, en ‘<‘ controleren of waarden gelijk zijn of hoe ze zich tot elkaar verhouden. Logische operators zoals ‘!’, ‘&&’, en ‘||’ voeren logische bewerkingen uit. Met deze operators wordt het makkelijker om berekeningen en vergelijkingen in je code uit te voeren, zodat je programma precies doet wat je wilt. Hier bekijken we de samengestelde toewijzingsoperatoren. Deze zijn vergelijkbaar met de rekenkundige operators, maar compacter. Er zijn er 10, maar we gaan er voor nu 7 bekijken.

Samengestelde toewijzingsoperatoren zijn speciale tekens in programmeertalen die je helpen om snel en efficiënt wiskundige bewerkingen uit te voeren en de resultaten op te slaan in variabelen.

1. += (samengestelde optelling):
   • Voegt een waarde toe aan een variabele en slaat het resultaat op in dezelfde variabele.
   • Voorbeeld:
     Als x gelijk is aan 10 en je schrijft ‘x += 5’, dan wordt x nu 15.
     De lange versie zou zijn: ‘x = x + 5’
2. -= (samengestelde aftrekking):
   • Trekt een waarde af van een variabele en slaat het resultaat op in dezelfde variabele.
   • Voorbeeld:
     Als y gelijk is aan 20 en je schrijft ‘y -= 4’, dan wordt y nu 16.
     De lange versie zou zijn: ‘x = x – 4’
3. *= (samengestelde vermenigvuldiging):
   • Vermenigvuldigt een variabele met een waarde en slaat het resultaat op in dezelfde variabele.
   • Voorbeeld:
     Als z gelijk is aan 3 en je schrijft ‘z *= 2’, dan wordt z nu 6.
     De lange versie zou zijn: ‘z = z * 6’
4. /= (samengestelde deling):
   • Deelt een variabele door een waarde en slaat het resultaat op in dezelfde variabele.
     Als de resultaat variabele (a) een int is, gaat een deel verloren. Alleen het gedeelte van het gehele deel van het getal wordt opgeslagen.
   • Voorbeeld:
     • Als a een integer is, dus ‘int a = 14’.
       Als a gelijk is aan 14 en je schrijft ‘a /= 4’, dan wordt a nu 3.
       De lange versie zou zijn: ‘a = a / 4’
     • Als a een float is, dus float a =14.
       Als a gelijk is aan 14 en je schrijft ‘a /= 4’, dan wordt a nu 3,5.
       De lange versie zou zijn: ‘a = a / 4’
       
5. %= (samengestelde modulo):
   • Berekent de rest van de deling uit, van een variabele die gedeeld wordt door een waarde en slaat het resultaat op in dezelfde variabele.
   • Voorbeeld:
     Als b gelijk is aan 7 en je schrijft ‘b %= 3’, dan wordt b nu 1.
     3 zit 2 keer in 7 (dit is 6), dus houd je 1 over (dit is de rest).
     De lange versie zou zijn: ‘b = b % 3’
6. — (decrement):
   • Verlaagt de waarde van een variabele met 1.
   • Voorbeeld:
     Als count gelijk is aan 5 en je schrijft ‘count–‘, dan wordt count nu 4.
     De lange versie zou zijn: ‘count = count – 1’
7. ++ (increment):
   • Verhoogt de waarde van een variabele met 1.
   • Voorbeeld:
     Als score gelijk is aan 8 en je schrijft ‘score++’, dan wordt score nu 9.
     De lange versie zou zijn: ‘score = score +1’

Wat is pre-increment/post-increment en pre-decrement/post-decrement:

Pre-increment en post-increment, evenals pre-decrement en post-decrement, zijn manieren om een getal in programmeertalen zoals C++ te verhogen (incrementeren) of te verlagen (decrementeren). Bij pre-increment wordt het getal eerst verhoogd voordat het in een berekening wordt gebruikt, bijvoorbeeld ‘++x’. Bij post-increment wordt het getal eerst gebruikt in een berekening en daarna verhoogd, bijvoorbeeld ‘x++’. Hetzelfde geldt voor pre-decrement (–x) en post-decrement (x–), waarbij ‘–x’ eerst verlaagt en dan gebruikt, en ‘x–‘ eerst gebruikt en dan verlaagt. Deze operatoren zijn handig bij het tellen of bij lussen in programma’s.

• Pre-increment (++) en pre-decrement (–): Eerst wordt de waarde van de variabele verhoogd of verlaagd, en daarna wordt deze nieuwe waarde gebruikt in de rest van de uitdrukking. Voorbeeld:

  int x = 5;
  int result = ++x; // result wordt 6, x wordt 6

• Post-increment (++) en post-decrement (–): Eerst wordt de huidige waarde van de variabele gebruikt in de rest van de uitdrukking, en daarna wordt de waarde van de variabele verhoogd of verlaagd. Voorbeeld:

  int y = 5;
  int result = y++; // result wordt 5, y wordt 6

Deze operatoren zijn handig bij het schrijven van code omdat ze je helpen om sneller en efficiënter basis-wiskundige bewerkingen uit te voeren en variabelen te wijzigen.

Voorbeeld
Een veel gebruikte situatie de for-lus:

int ledPin = 13;  // Verbind de LED met pin 13

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

void loop() {
  for (int i = 0; i < 15; i++) {
    digitalWrite(ledPin, HIGH);  // Zet de LED aan
    delay(500);                  // Wacht 500 milliseconden
    digitalWrite(ledPin, LOW);   // Zet de LED uit
    delay(500);                  // Wacht 500 milliseconden
  }
  
  // Als de loop is voltooid, wacht het programma 10 seconden en begint weer opnieuw op regel 7.
  delay(10000); // wacht 10 seconden
}

Hier gebruiken we het ‘++’ teken om x elke keer met 1 te verhogen.

Omschrijving
In Arduino C++ zijn operators speciale tekens die je helpen bij taken zoals rekenen en vergelijken. Je hebt rekenkundige operators zoals ‘+’, ‘-‘, ‘*’, en ‘/’ voor wiskundige berekeningen. Vergelijkingsoperators zoals ‘==’, ‘!=’, ‘>’, en ‘<‘ checken of dingen gelijk zijn of hoe ze zich tot elkaar verhouden. Logische operators zoals ‘!’, ‘&&’, en ‘||’ voeren logische bewerkingen uit. Met deze operators wordt het makkelijker om berekeningen en vergelijkingen in je code te doen, zodat je programma precies doet wat je wilt. Hier bekijken we de Vergelijkingsoperatoren.

Vergelijkingsoperatoren in Arduino C++ zijn speciale tekens die je kunt gebruiken om dingen met elkaar te vergelijken. Ze helpen je om te kijken of iets waar is of niet waar is in je programma. Hier zijn de belangrijkste:

1. Gelijk aan
   ‘==’ (twee gelijke tekens naast elkaar). Dit gebruik je om te kijken of twee dingen precies hetzelfde zijn.
   • Bijvoorbeeld: ‘if (leeftijd == 10)’ betekent “als de leeftijd precies 10 is”.
2. Niet gelijk aan
   ‘!=’ (uitroepteken en gelijkteken naast elkaar). Hiermee kijk je of twee dingen niet hetzelfde zijn.
   • Bijvoorbeeld: ‘if (kamer != “slaapkamer”)’ betekent “als de kamer niet de slaapkamer is”.
3. Kleiner dan
   ‘<‘ (kleiner teken). Dit gebruik je om te zien of iets kleiner is dan iets anders.
   • Bijvoorbeeld: ‘if (aantalAppels < 5)’ betekent “als het aantal appels minder dan 5 is”.
4. Kleiner dan of gelijk aan
   ‘<=’ (kleiner teken en gelijkteken naast elkaar). Hiermee kijk je of iets kleiner is dan of gelijk aan iets anders.
   • Bijvoorbeeld: ‘if (temperatuur <= 25)’ betekent “als de temperatuur 25 graden of minder is”.
5. Groter dan
   ‘>’ (groter teken). Dit gebruik je om te kijken of iets groter is dan iets anders.
   • Bijvoorbeeld: ‘if (tijd > 12)’ betekent “als de tijd groter is dan 12 uur”.
6. Groter dan of gelijk aan
   ‘>=’ (groter teken en gelijkteken naast elkaar). Hiermee kijk je of iets groter is dan of gelijk aan iets anders.
   • Bijvoorbeeld: ‘if (punten >= 100)’ betekent “als het aantal punten 100 of meer is”.

Waarom zijn Vergelijkingsoperatoren Handig?

• Ze helpen je om beslissingen te nemen in je programma’s, zoals of je een lampje moet aanzetten als het donker is, of een bericht moet laten zien als iemand iets goed heeft gedaan.
• Vergelijkingsoperatoren maken het makkelijker om te bepalen wat er moet gebeuren op basis van wat er gebeurt in je programma.

Voorbeeld
Stel je voor dat je een programma hebt dat controleert of het buiten regent. Je zou het kunnen schrijven als:

int regenSensor = 1;  // Stel in dat er regen is (1 betekent ja, 0 betekent nee)

if (regenSensor == 1) {
  Serial.println("Het regent buiten! Neem je paraplu mee.");
} else {
  Serial.println("Het regent niet buiten. Je kunt zonder paraplu gaan.");
}

Hier gebruiken we het ‘==’ teken om te kijken of regenSensor gelijk is aan 1. Als dat zo is, printen we een bericht om te zeggen dat het regent. Anders, als regenSensor niet gelijk is aan 1 (wat zou betekenen dat het niet regent), printen we een ander bericht.

Vergelijkingsoperatoren maken programmeren leuk omdat ze je helpen om je programma’s te laten weten wat ze moeten doen, net zoals je beslissingen maakt in het dagelijks leven!

Omschrijving
In Arduino C++ zijn operators speciale tekens die je helpen bij taken zoals rekenen en vergelijken. Je hebt rekenkundige operators zoals ‘+’, ‘-‘, ‘*’, en ‘/’ voor wiskundige berekeningen. Vergelijkingsoperators zoals ‘==’, ‘!=’, ‘>’, en ‘<‘ checken of dingen gelijk zijn of hoe ze zich tot elkaar verhouden. Logische operators zoals ‘!’, ‘&&’, en ‘||’ voeren logische bewerkingen uit. Met deze operators wordt het makkelijker om berekeningen en vergelijkingen in je code te doen, zodat je programma precies doet wat je wilt. Hier bekijken we de rekenkundige operators.

Rekenkundige operators
Dit zijn speciale tekens in programma’s waarmee je wiskundige berekeningen kunt doen. Hier zijn wat voorbeelden:

1. Optellen (+): Met dit teken tel je twee getallen bij elkaar op. Bijvoorbeeld, 3 + 5 = 8.
2. Aftrekken (-): Met dit teken trek je het ene getal van het andere af. Bijvoorbeeld, 7 – 4 = 3.
3. Vermenigvuldigen (*): Met dit teken vermenigvuldig je twee getallen met elkaar. Bijvoorbeeld, 2 * 6 = 12.
4. Delen (/): Met dit teken deel je het ene getal door het andere. Bijvoorbeeld, 10 / 2 = 5.

Deze tekens maken het makkelijker om ingewikkelde berekeningen te doen in je programma’s, net zoals je op een rekenmachine zou doen!

Volgorde van rekenkundige operators
Het is ook belangrijk om te weten dat de volgorde waarin je deze tekens gebruikt, de uitkomst van je berekeningen kan veranderen:

1. Haakjes: Berekeningen tussen haakjes worden altijd als eerste gedaan. Bijvoorbeeld, in ‘(4 + 5) * 3’ reken je eerst ‘4 + 5’ uit tot ‘9’, en dan ‘9 * 3′, wat ’27’ oplevert.
2. Vermenigvuldigen en delen: Deze worden eerst gedaan voordat je optellen en aftrekken doet. Bijvoorbeeld, in ‘4 + 5 * 3’, eerst ‘5 * 3’ uitrekenen geeft 15, en dan ‘4 + 15′ geeft ’19’.
3. Optellen en aftrekken: Deze worden van links naar rechts uitgevoerd als er geen haakjes zijn. Bijvoorbeeld, in ’10 – 3 + 2′, eerst ’10 – 3′ geeft ‘7’, en dan ‘7 + 2’ geeft ‘9’.

Deze regels zorgen ervoor dat je de juiste antwoorden krijgt in je berekeningen, net zoals bij het gebruik van een rekenmachine!

Als een berekening ingewikkelder wordt, maak dan gebruik van haken. Dit vereenvoudigt de berekening, maakt hem overzichtelijker en zodoende minder fout gevoelig.

Voorbeeld
Bijvoorbeeld ‘x = 5 + 16 * 3 / 3 – 2’, wat is de waarde van x nu?

Om de waarde van ( x ) te vinden in de berekening ( x = 5 + 16 * 3 / 3 – 2 ), moeten we de volgorde van de rekenkundige operatoren volgen:

1. Eerst wordt vermenigvuldigen en delen uitgevoerd van links naar rechts:

• ( 16 * 3 / 3 )
• ( 16 * 3 = 48 )
• ( 48 / 3 = 16 )

1. Vervolgens wordt optellen en aftrekken van links naar rechts uitgevoerd:

• ( 5 + 16 = 21 )
• ( 21 – 2 = 19 )

Dus, ( x = 19 ).

Verklaring:

• Eerst wordt ( 16 * 3 = 48 ) berekend.
• Vervolgens wordt ( 48 / 3 = 16 ).
• Dan wordt ( 5 + 16 = 21 ) berekend.
• Tot slot wordt ( 21 – 2 = 19 ).

De volgorde van bewerkingen wordt bepaald door de rekenkundige regels waarbij vermenigvuldigen en delen voorrang hebben op optellen en aftrekken, en bewerkingen van links naar rechts worden uitgevoerd als ze dezelfde prioriteit hebben.

Omschrijving
De ‘for’-lus in Arduino is een manier om een stuk code meerdere keren achter elkaar uit te voeren zonder dat je die code steeds opnieuw hoeft te schrijven. Het werkt door eerst een startpunt in te stellen (zoals ‘i = 0’), dan te bepalen hoe lang de herhalingen doorgaan (bijvoorbeeld zolang ‘i’ minder is dan 5), en ten slotte te bepalen hoe de variabele verandert na elke herhaling (meestal door ‘i’ met 1 te verhogen). Dit is handig om bijvoorbeeld een LED meerdere keren te laten knipperen. In plaats van vijf keer dezelfde code te schrijven, gebruik je een ‘for’-lus om te zeggen: “Doe deze actie vijf keer”. Het maakt je programma korter en makkelijker te begrijpen.

Syntax
for(a;b;c){functies}

Parameters
a: hier geef je de begin waarde op, bijvoorbeeld ‘int i=1’
b: hier geef je aan hoe lang het uitgevoerd moet worden, bijvoorbeeld ‘i<11’
c: hier geef je aan hoe ‘i’ dient te veranderen, bijvoorbeeld ‘i=i+1’ (de verkorte schrijfwijze is: ‘i++’)
functies: dit zijn de commando regels die uitgevoerd dienen te worden zolang er aan de voorwaarde die bij b is opgegeven. Bijvoorbeeld zolang i kleiner is dan 11.

Geeft terug
Niets.

Voorbeeld

void setup() {
  Serial.begin(115200);
}

void loop() {
  for(int i=1 ; i<11 ; i=i+1 ){
    Serial.print("i = ");
    Serial.println(i);
  }
  Serial.println("Klaar.");
  Serial.println();
  delay(20000); // wacht 20 seconden
}

Toelichting voorbeeld

setup()
De seriële poort wordt geopend om gegevens naar de seriële monitor te schrijven.

loop()
Op regel 6 wordt gebruik gemaakt van de ‘for’-lus. Hier krijgt ‘i’ de begin waarde ‘1’, wordt de lus uitgevoerd zolang ‘i’ kleiner is dan 11 en ‘i’ wordt elke keer met 1 verhoogt.

Dus regel 6 wordt uitgevoerd en gaat dan de lus uitvoeren (indien i kleiner is dan 11), dit zijn de regels 7 en 8. Daarna gaat hij weer naar regel 6 en ‘i’ wordt met 1 verhoogt. Er wordt gecontroleerd of ‘i’ nog altijd kleiner is als 11. Zo ja, de regels 7 en 8 worden weer uitgevoerd. Dit gaat zo verder totdat het ‘i’ 11 wordt, de controle wordt uitgevoerd en ‘i’ is dus NIET meer kleiner dan 11. De lus wordt nu niet meer herhaald.

Regels 10, 11 en 12 worden uitgevoerd en het programma gaat weer naar regel 6. De ‘for’-lus begint weer opnieuw. Hier krijgt ‘i’ de begin waarde ‘1’, wordt de lus uitgevoerd zolang ‘i’ kleiner is dan 11 en ‘i’ wordt elke keer met 1 verhoogt.

Dit herhaald zich totdat je de microprocessorboard uitzet.

Uitvoer

i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
i = 10
Klaar.

i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
i = 10
Klaar.

Bovenstaand blijft zich herhalen totdat de microcontrollerboard uitgezet wordt.

Notities en waarschuwingen
Je kunt hier verschillende type variabelen gebruiken voor ‘i’.

Functies in programmeren zijn zoals kleine, herbruikbare stukjes code die een specifieke taak uitvoeren. Je kunt een functie vergelijken met een recept in een kookboek. Het recept geeft stap-voor-stap instructies over hoe je iets moet bereiden. Net zoals je een recept kunt gebruiken om een maaltijd meerdere keren te maken, kun je een functie herhaaldelijk gebruiken om dezelfde actie of berekening uit te voeren in je programma.

Waarom Gebruiken We Functies?
Functies helpen je om je code te organiseren door het op te splitsen in kleinere, beheersbare stukken. Dit maakt je code makkelijker te lezen en te onderhouden. Stel je voor dat je een heel groot project hebt; het is veel handiger om dat in kleinere stukjes te verdelen.

Hoe Werken Functies?
Elke functie heeft een naam. Wanneer je die naam in je programma gebruikt, voert de functie de taak uit die eraan is gekoppeld. Functies kunnen ook gegevens ontvangen, die we “parameters” noemen, en ze kunnen gegevens teruggeven, bekend als “return waarden”. Dit maakt functies erg flexibel en krachtig.

Functies in C++
In C++ kun je je eigen functies schrijven om specifieke taken uit te voeren. Dit kan variëren van eenvoudige berekeningen tot complexe taken. Naast het schrijven van je eigen functies, biedt C++ ook een uitgebreide bibliotheek met standaardfuncties. Deze standaardfuncties helpen je met veel voorkomende taken, zoals het manipuleren van tekst, het sorteren van lijsten, en het werken met bestanden.
Voorbeelden van standaardfuncties in C++ zijn:

• delay(): een pauze in je programma invoegen.
• pinMode(): instellen hoe een pin op je microcontroller wordt gebruikt (bijvoorbeeld als input of output).
• digitalRead(): de status van een pin lezen (bijvoorbeeld hoog of laag).

Extra Functionaliteit
Soms heb je speciale functies nodig die je moet importeren. Deze voeren zeer specifieke taken uit, zoals het aansturen of uitlezen van elektronische componenten. Bijvoorbeeld een display, real-time clock of temperatuursensor. Deze functies maken het mogelijk om extra componenten te gebruiken en voegen extra functionaliteit toe aan je microprocessorbord, zoals:

• Het genereren van willekeurige getallen.
• Het opzetten van een webserver of webclient.
• Het gebruik van extra communicatieprotocollen zoals SPI of I2C.

Door functies te gebruiken, kun je efficiënter programmeren en wordt je code overzichtelijker en makkelijker te onderhouden.

Omschrijving
In Arduino C++ zijn operators speciale tekens die je helpen bij taken zoals rekenen en vergelijken. Je hebt rekenkundige operators zoals ‘+’, ‘-‘, ‘*’, en ‘/’ voor wiskundige berekeningen. Vergelijkingsoperators zoals ‘==’, ‘!=’, ‘>’, en ‘<‘ checken of dingen gelijk zijn of hoe ze zich tot elkaar verhouden. Logische operators zoals ‘!’, ‘&&’, en ‘||’ voeren logische bewerkingen uit. Met deze operators wordt het makkelijker om berekeningen en vergelijkingen in je code te doen, zodat je programma precies doet wat je wilt. Hier bekijken we de logische operators.

bool var1 = true;
int x1 = 6;
int x2 = 10;

Serial.print("var1 = ");
Serial.println(var1);
Serial.print("!var1 = ");
Serial.println(!var1);

if ( var1 ){
    Serial.println("Regel 1");
}

if ( !var1 ){
     Serial.println("Regel 2");
}

if ( x1 == x2 ){
     Serial.println("Regel 3");
}

// '==' vergelijkt het linker deel met het rechter deel, als ze gelijk zijn geeft dit waar
if ( !(x1 == x2) ){
     Serial.println("Regel 4");
}

-- Begin --

var1 = 1
!var1 = 0
Regel 1
Regel 4
var1 = 1
!var1 = 0
Regel 1
Regel 4

bool var1 = true;
bool var2 = true;
bool var3 = false;
bool var4 = false;
int x1 = 6;
int x2 = 10;
int x3 = 6;

if ( var1 && var2 ){
    Serial.println("Regel 1");
}

if ( var1 && var3 ){
     Serial.println("Regel 2");
}

if ( var3 && var4 ){
     Serial.println("Regel 3");
}

// '==' vergelijkt het linker deel met het rechter deel, als ze gelijk zijn geeft dit waar
if ( (x1 == x2) && var1 ){
     Serial.println("Regel 4");
}

// '==' vergelijkt het linker deel met het rechter deel, als ze gelijk zijn geeft dit waar
  if ( (x1 == x3) && var2 ){
     Serial.println("Regel 5");
}

-- Begin --

Regel 1
Regel 5

bool var1 = true;
bool var2 = true;
bool var3 = false;
bool var4 = false;
int x1 = 6;
int x2 = 10;
int x3 = 6;

if ( var1 || var2 ){
    Serial.println("Regel 1");
}

if ( var1 || var3 ){
     Serial.println("Regel 2");
}

if ( var3 || var4 ){
     Serial.println("Regel 3");
}

// '==' vergelijkt het linker deel met het rechter deel, als ze gelijk zijn geeft dit waar
if ( (x1 == x2) || var1 ){
     Serial.println("Regel 4");
}

// '==' vergelijkt het linker deel met het rechter deel, als ze gelijk zijn geeft dit waar
  if ( (x1 == x3) || var2 ){
     Serial.println("Regel 5");
}

-- Begin --

Regel 1
Regel 2
Regel 4
Regel 5

Omschrijving
Het digitalRead() functie wordt gebruikt in het programma gebruikt om de status van een digitale pin op een microcontroller (zoals de Arduino / ESP32) te lezen. De pin die gelezen wordt, moet wel eerst als invoer gedefinieerd worden. Dit doe je met de functie pinMode(). Daarna kan met de functie digitalRead() een digitale pin gelezen worden. Dit resulteert in een waarde ‘hoog’ (HIGH) of ‘laag’ (LOW). Deze waarde wordt door de functie terug gegeven en kan in een variabele opgeslagen worden voor later gebruik.

Syntax
digitalRead(pin)

Parameters
pin: is het GPIO nummer dat je uit wil lezen. Dus voor bijvoorbeeld GPIO1 voer je hier ‘1’ in.

Geeft terug
HIGH of LOW.

Voorbeeld

int knopPin = 16;
int retourWaarde = 0;

void setup() {
  pinMode(knopPin, INPUT); // Stel de pin in als een invoerpin
}

void loop() {
  retourWaarde = digitalRead(knopPin); // leest de waarde uit van de invoer pin en kent deze toe aan de variabele retourWaarde
  delay(1000); // Wacht 1 seconde
  // rest van het programma
}

Toelichting voorbeeld
Eerst worden 2 variabelen gedefinieerd. Een bevat een waarde die aangeeft om welke pin het gaat (knopPin). Dit is handig omdat je tijdens de ontwikkeling van het programma deze waarde overal moeten wijzigen als deze tijdens het ontwikkelen wijzigt. In de andere variabele zetten we de waarde die uitgelezen wordt. Hier onthoud het programma wat de status is van de invoer pin als deze uitgelezen wordt. Anders zou je elke keer dat je deze waarde nodig hebt de pin opnieuw moeten uitlezen. Deze waarde zou intussen best anders kunnen zijn. In de setup() wordt de pin als invoer (INPUT) gedefinieerd. In de eerste regel van de loop() wordt de waarde van de invoer pin gelezen en toegekend aan de variabele ‘retourWaarde’ om ergens anders in het programma gebruikt te worden.

Notities en waarschuwingen
Kies wel een pin die een digitaal signaal aan kan en voor invoer geschikt is.

Omschrijving
Serial is niet één functie, maar een verzameling van functies. Met deze functies kan een computer communiceren met een microcontrollerbord en anders om. Er is maar een seriële poort beschikbaar voor deze communicatie. Er zijn meestal meerdere Serial poorten. Via deze poorten kan het microcontrollerbord ook met andere apparaten praten.

Hieronder worden een aantal basisfuncties besproken. Deze maken het mogelijk om waarden van het microcontrollerbord te tonen in de seriële monitor van de Arduino IDE. Ook kun je gegevens vanuit de seriële monitor naar het microcontrollerbord sturen. Dit wordt vaak gebruikt om een programma te testen en fouten op te sporen (debuggen).

Kort gezegd: Serial helpt je om te zien wat je programma doet en om ermee te communiceren tijdens het ontwikkelen.

Seriële monitor in Arduino IDE gebruiken

Hoe maak je de seriële monitor zichtbaar in de Arduino IDE?
Dit kan op drie manieren, door:

• in het menu te kiezen voor de opties ‘Hulpmiddelen’ en vervolgens ‘Seriële monitor’.
• de toetsen combinatie Ctrl+Shift+M.
• op het vergrootglas icoontje, rechtsboven te klikken

Zie de drie oranje pijlen in afb. 1

Afb. 1

Overzicht seriële monitor
In afbeelding 2 zie je het volledige venster van de seriële monitor. Linksboven wordt de poort getoond die door de seriële monitor wordt gebruikt. Dit is de poort van de computer waarop het microcontrollerbord (in afb.2 is dit ‘COM4’) aangesloten is. Direct daaronder bevindt zich het invoerveld (dit gebruik je voor de communicatie van de computer naar het microcontrollerbord), met rechts de ‘Verzenden’ knop. Onder het invoerveld vind je het uitvoergedeelte van het venster, waar de gegevens die van het microcontrollerbord naar de computer worden gestuurd, worden weergegeven.

Op de onderste regel staan de opties:

• Autoscroll
  Als het vinkje is ingeschakeld, wordt de laatste uitvoer op het scherm weergegeven en worden oudere regels naar boven geschoven, waardoor na verloop van tijd de bovenste regels niet meer zichtbaar zijn. Telkens wanneer er een nieuwe regel wordt toegevoegd, herhaalt dit proces zich. Aan de rechterkant verschijnt een scrollbalk waarmee je de bovenste regels weer zichtbaar kunt maken.
• Toon tijdstempel
  Als deze optie is aangevinkt, wordt bij elke regel een tijdstempel weergegeven in de vorm van ’17:02:11.787 ->’, wat staat voor ‘uur : minuut : seconden . milliseconden ->’. Na de pijl wordt de data weergegeven.
• Einde regel (afb. 3)
  Zet deze optie op ‘Geen regeleinde’. Ik heb alle mogelijkheden geprobeerd, maar de uitvoer verandert niet. Dit is waarschijnlijk gerelateerd aan specifieke microcontrollerborden van Arduino.
• Snelheid seriële poort (afb. 4)
  Dit is de snelheid waarmee gecommuniceerd wordt over de seriële poort. Deze snelheid hoort overeen te komen met wat in het programma is gedefinieerd (bijvoorbeeld: ‘Serial.begin(115200)’). Daarom moet je in de lijst ook voor deze waarde kiezen, zoals in afbeelding 4 is gedaan. Mocht er onleesbare tekst verschijnen in het uitvoergedeelte van de seriële monitor, dan betekent dit dat de waarden niet overeenkomen.
• Knop ‘Uitvoer wissen’ (afb. 4)
  Als je op deze knop klikt, wordt alle uitvoer van het uitvoer venster verwijderd.

Afb. 2

Afb. 3

Afb. 4

Serial

Een microcontrollerboard kan meerdere seriële poorten hebben. De ESP32 die in deze workshop wordt gebruikt, heeft drie seriële poorten, ook wel UART’s genoemd. UART staat voor Universal Asynchronous Receiver/Transmitter. In je programma worden deze aangeduid als ‘Serial’, ‘Serial1’ en ‘Serial2’. ‘Serial’ is verbonden met de USB-poort, waardoor het mogelijk is om te communiceren via deze seriële poort met de seriële monitor van de Arduino IDE. In deze uitleg focus ik me alleen op de ‘Serial’ poort en de functies die gebruikt worden om gegevens tussen de Arduino IDE en de ESP32 uit te wisselen. Niet alle functies en opties van functies worden hier besproken. De nadruk ligt op het debuggen. Bijvoorbeeld om te kijken wat een variabele als waarde heeft, komt het programma onder bepaalde omstandigheden in een bepaald deel van het programma en om te testen wat het programma doet als een variabele een bepaalde waard krijgt).

Serial.begin()

Omschrijving
De Serial.begin() functie start de communicatie tussen je Arduino en de computer via de seriële monitor. Bij het gebruik van deze functie geef je aan hoe snel de gegevens verstuurd moeten worden. Deze snelheid moet hetzelfde zijn als de snelheid die je instelt in de seriële monitor op je computer. Normaal gesproken zet je deze functie één keer in het begin van je code, meestal in het blokje dat setup() heet, zodat je Arduino weet dat hij klaar is om te beginnen met het verzenden en ontvangen van informatie.

Syntax
Serial.begin(snelheid);

Parameters
Serial: seriële poort object. Mogelijke waarden voor de ESP32 zijn: Serial, Serial1 en Serial2.
snelheid: Dit is de snelheid waarmee de seriële poort van de computer en de microcontroller met elkaar communiceren. Mogelijke waardes zijn: 300, 1200, 2400, 4800, 9600, 192000, 38400, 57600, 74880, 115200, 230400, 250000, 500000, 1000000 en 2000000 baud. De vetgedrukte zijn de meest gebruikelijke. Hiervan wordt 115200 in de workshops gebruikt.

Geeft terug
Niets

Voorbeeld

void setup() {
  Serial.begin(115200); // opent seriële poort en zet de snelheid op 115200 baud
}

void loop() {
  Serial.print("Hallo!");
  Delay(2000);
}

Toelichting voorbeeld

void setup()
Serial.begin(115200);
Start de communicatie met de seriële poort op een snelheid van 115200 baud. Dit betekent dat je deze snelheid ook moet kiezen in het venster van de seriële monitor op je computer.

void loop()
Serial.print(“Hallo!”);
Stuurt informatie van het microcontrollerbord naar de computer.

Delay(2000);
Wacht 2 seconden voordat de lus herhaald wordt.
Dus de tekst ‘Hallo!’ wordt elke 2 seconden naar de ‘Serial Monitor’ van de Arduino IDE gestuurd.

Notities en waarschuwingen
Zorg ervoor dat de snelheid die je in je programma instelt hetzelfde is als de snelheid die je kiest in de seriële monitor. Als deze niet hetzelfde zijn, werkt het niet goed en zie je misschien gekke tekens op je scherm.

Let op dat je ‘Serial.begin()’ met een hoofdletter ‘S’ schrijft.

Serial.print() / Serial.println()

Omschrijving
Met de functies Serial.print() en Serial.println() kun je gegevens van je microcontrollerbord naar de seriële monitor op je computer sturen. Als je Serial.println() gebruikt, stuurt het de gegevens en gaat daarna automatisch naar de volgende regel. Als je Serial.print() gebruikt, blijft de cursor op dezelfde regel staan, en wat je daarna stuurt, komt direct achter de vorige gegevens te staan.

Syntax
Serial.print(gegevens)
Serial.println(gegevens)

Parameters
Serial: seriële poort object. Mogelijke waarden voor de ESP32 zijn: Serial, Serial1 en Serial2.
gegevens: zijn teksten, getallen of variabelen (bij variabelen de inhoud ervan) die je naar de seriële monitor wil sturen.

Geeft terug
Niets

Voorbeeld

void setup() {
  Serial.begin(115200); // opent seriële poort en zet de snelheid op 115200 bps
}

void loop() {
  Serial.println("Eerste regel.");
  Serial.println("Tweede regel.");
  Serial.print("Begin derde regel ");
  Serial.print("en het vervolg van de derde regel, ");
  Serial.println("het einde van de derde regel.");
  Serial.println("Vierde regel.");
  Serial.println();
  int getal = 10;
  Serial.print("Het getal is: ");
  Serial.println(getal);
  Serial.print("Het tweede getal is: ");
  Serial.println(5);
  delay(300000);
}

Uitvoer van het programma:

Eerste regel.
Tweede regel.
Begin derde regel en het vervolg van de derde regel, het einde van de derde regel.
Vierde regel.

Het getal is: 10
Het tweede getal is: 5

Elk gebruik van println() zorgt ervoor dat je naar een nieuwe regel gaat na het versturen van de tekst, terwijl print() je op dezelfde regel houdt.

Toelichting voorbeeld
In het stukje code hierboven, worden verschillende dingen verstuurd van je microcontroller naar de seriële monitor op je computer. Hier is wat er stap voor stap gebeurt:

void setup()
Serial.begin(115200);
Dit initialiseert de seriële communicatie met een baud rate (snelheid) van 115200 bits per seconde. Het zorgt ervoor dat de Arduino kan communiceren met een computer via de seriële monitor.

void loop()
Serial.println(“Eerste regel.”);
Dit stuurt de tekst “Eerste regel.” naar de seriële monitor en gaat daarna naar de volgende regel.

Serial.println(“Tweede regel.”);
Dit stuurt de tekst “Tweede regel.” en gaat naar de volgende regel.

Serial.print(“Begin derde regel “);
Dit stuurt de tekst “Begin derde regel ” naar de monitor, maar blijft op dezelfde regel.

Serial.print(“en het vervolg van de derde regel, “);
Dit voegt de tekst “en het vervolg van de derde regel, ” direct achter de vorige tekst toe en blijft op dezelfde regel.

Serial.println(“het einde van de derde regel.”);
Dit voegt “het einde van de derde regel.” toe aan het einde van de derde regel en gaat daarna naar de volgende regel.

Serial.println(“Vierde regel.”);
Dit stuurt “Vierde regel.” en gaat naar de volgende regel.

Serial.println();
Deze opdracht verstuurd geen gegevens naar de computer, maar zorgt er wel voor dat de uitvoer naar de volgende regel gaat. Er ontstaat een lege regel. Dit is gemakkelijk om gegevens die je naar de computer stuurt van elkaar te scheiden en houdt het overzichtelijk.

int getal = 10;
Maakt een variabele van het soort integer (int) en geeft deze een waarde van 10.

Serial.print(“Het getal is: “);
Dit stuurt de tekst ‘Het getal is: ‘ naar de monitor en blijft op dezelfde regel.

Serial.println(getal);
Dit stuurt de inhoud van de variabele getal naar de computer, in dit geval ’10’, en gaat naar de volgende regel.

Serial.print(“Het tweede getal is: “);
Dit stuurt de tekst ‘Het tweede getal is: ‘ naar de monitor en blijft op dezelfde regel.

Serial.println(5);
Dit stuurt het getal 5 naar de monitor en gaat naar de volgende regel.

delay(300000);
Het programma wacht 300.000 milliseconden. Dit is 5 minuten en gaat dan verder. Omdat dit de laatste regel in het programma is, gaat het programma verder bij de eerste regel van loop(). Dit is regel 6 in het voorbeeld.

Notities en waarschuwingen
Let op dat je ‘Serial.print()’ en ‘Serial.println’ met een hoofdletter ‘S’ schrijft.

Serial.readString()

Omschrijving
Leest een of meerdere tekens uit de serial buffer en geeft die inhoud terug aan een string variabele. Maar voordat je dit kunt doen, moet je de seriële poort aanzetten met de functie Serial.begin(115200). Zonder dit werkt de seriële poort niet en kun je geen gegevens lezen en schrijven. Je hebt ook de functie Serial.available() nodig om te kijken of er al iets ingetypt is (zie hieronder voor de uitleg).

Syntax
Serial.readString()

Parameters
Serial: seriële poort object. Mogelijke waarden voor de ESP32 zijn: Serial, Serial1 en Serial2.

Geeft terug
Een string (alle tekens) die uit de buffer van Serial gelezen zijn.

Voorbeeld

void setup() {
  Serial.begin(115200);
}

void loop() {
  Serial.println("Geef een kleur in:");
  while (Serial.available() == 0) {}     //wacht totdat er gegevens aanwezig zijn en op enter gedrukt is
  String teststr = Serial.readString();  //Lees gegevens uit de serial buffer
  teststr.trim();                        // Verwijder alle '\r', '\n' en spaties aan het einde van de gegevens
if (teststr == "rood") {
    Serial.println("Een primaire kleur");
  } else {
    Serial.println("Andere tekst");
  }
}

Toelichting voorbeeld

void setup()
Serial.begin(115200);
Dit initialiseert de seriële communicatie met een baud rate (snelheid) van 115200 bits per seconde. Het zorgt ervoor dat de Arduino kan communiceren met een computer via de seriële monitor.

void loop()
Serial.println(“Geef een kleur in: “);
Dit stuurt de tekst “Geef een kleur in: ” naar de seriële monitor als een prompt voor de gebruiker om gegevens in te voeren.

while (Serial.available() == 0) {}
Dit is een lus die zich blijft herhalen totdat er gegevens beschikbaar zijn in de seriële buffer. Serial.available() retourneert het aantal bytes dat beschikbaar is om te lezen. Als dit aantal 0 is, wacht de lus totdat er gegevens beschikbaar zijn. Serial.available() geeft dan een aantal dat groter is dan 0.

String teststr = Serial.readString();
Deze regel leest de beschikbare gegevens uit de seriële buffer als een string en slaat deze op in de variabele teststr. In deze regel wordt ook ‘teststr’ gedefinieerd als string.

teststr.trim();
Dit verwijdert eventuele witruimten, inclusief carriage return (\r) en line feed (\n), aan het einde van de string teststr (dit zijn tekens die automatisch meegestuurd worden door de computer). Dit zorgt ervoor dat de string nauwkeurig kan worden vergeleken zonder extra spaties of nieuwe regels.

if (teststr == “rood”) { Serial.println(“Een primaire kleur”); } else { Serial.println(“Andere tekst”); }
Dit is een voorwaardelijke structuur.
Als de string teststr gelijk is aan “rood”, dan print het programma “Een primaire kleur” naar de seriële monitor.
Anders, print het programma “Andere tekst” naar de seriële monitor.

Notities en waarschuwingen
Let op!!!
Dat je Serial.readString() met de letters ‘S’ als hoofdletters schrijft. Doe je dit niet, krijg je een foutmelding.

Serial.read()

Omschrijving
Serial.read() is een functie die je gebruikt om één teken uit de Serial buffer te lezen die van je Arduino wordt gestuurd via de seriële poort. Na het lezen van dit teken, zit er één teken minder in de Serial buffer. Maar voordat je dit kunt doen, moet je de seriële poort aanzetten met de functie Serial.begin(115200). Zonder dit werkt de seriële poort niet en kun je geen gegevens lezen en schrijven.

Syntax
Serial.read()

Parameters
Serial: seriële poort object. Mogelijke waarden voor de ESP32 zijn: Serial, Serial1 en Serial2.

Geeft terug
Geeft het eerste teken terug van de seriële buffer. Deze waarde is van type integer.

Voorbeeld

void setup() {
  Serial.begin(115200); // Start de seriële communicatie met 115200 baud
  Serial.println("Type iets en druk op Enter:");
}

void loop() {
  if (Serial.available() > 0) { // kijkt of er data beschikbaar is om te lezen
    int incomingByte = Serial.read(); // Lees het binnenkomende byte (is een teken)
    Serial.print("Ontvangen: ");
    Serial.println(incomingByte, DEC); // Print de ontvangen byte als decimaal getal
  }
}

Toelichting voorbeeld

void setup()
Serial.begin(115200);
Hierin start je de seriële communicatie met Serial.begin(115200);, wat betekent dat de communicatie op een snelheid van 115200 baud plaatsvindt.

Serial.println(“Type iets en druk op Enter:”);
Vervolgens print je een bericht om de gebruiker te laten weten dat ze iets moeten typen.

void loop()
if (Serial.available() > 0) {}
Deze functie kijkt of er een of meerdere tekens in de invoer buffer staan, dit doet het deel ‘Serial.available’. De functie geeft een waarde terug (het aantal tekens dat in de Serial buffer zit) en de if-functie kijkt of die waarde groter is dan 0. Als dat waar is, worden de commando’s die tussen de accoladen ‘{}’ staan uitgevoerd. Als dit niet het geval is gaat het programma verder achter de afsluit accolade ‘}’.

int incomingByte = Serial.read();
Als er data is, wordt deze gelezen met Serial.read(), wat één byte data (= 1 teken) van de seriële buffer leest en in de variabele ‘incomingByte’ wordt gezet. Als het teken gelezen is, wordt deze uit de buffer gehaald.
Dus staan er 2 tekens in de buffer, staat er nog 1 teken in de Serial buffer nadat de functie Serial.read() is uitgevoerd.

Serial.print(“Ontvangen: “);
De tekst ‘Ontvangen: ‘ wordt naar de seriële monitor gestuurd.

Serial.println(incomingByte, DEC);
Deze byte wordt vervolgens geprint als decimaal getal met Serial.println(incomingByte, DEC); en gaat vervolgens naar de volgende lijn.

Notities en waarschuwingen

Serial.available()

Omschrijving
De functie Serial.available() in de Arduino programmeertaal wordt gebruikt om te controleren hoeveel bytes er beschikbaar zijn om te lezen van de seriële buffer. Het wordt gebruikt in een programma om te controleren voorafgaand aan Lezen van de seriële buffer. Het is gebruikelijk om Serial.available() te gebruiken voordat je seriële gegevens leest met functies zoals Serial.read() of Serial.readString(). Dit voorkomt dat je probeert te lezen als er geen gegevens zijn, wat fouten kan voorkomen. De buffer wordt pas gevuld als je de invoer bevestigd met de ‘Enter’ toets.

Syntax
Serial.available()

Parameters
Serial: seriële poort object. Mogelijke waarden voor de ESP32 zijn: Serial, Serial1 en Serial2.

Geeft terug
Retourneert een Integer
De functie retourneert een integer die aangeeft hoeveel bytes er beschikbaar zijn in de seriële buffer. Als er geen gegevens beschikbaar zijn, retourneert het 0. De buffer wordt pas gevuld nadat je met de ‘Enter’ toets de invoer hebt bevestigd.

Voorbeeld

void setup() {
  Serial.begin(115200); // Initialiseer seriële communicatie op 115200 bps
}

void loop() {
  if (Serial.available() > 0) {  // Controleer of er gegevens beschikbaar zijn
    int incomingByte = Serial.read();  // Lees de inkomende byte
    Serial.print("Ontvangen: ");
    Serial.println(incomingByte, DEC);  // Print de ontvangen byte als decimaal getal
  }
} 

Toelichting voorbeeld

void setup()
Serial.begin(115200);
Dit initialiseert de seriële communicatie met een baud rate (snelheid) van 115200 bits per seconde. Het zorgt ervoor dat de Arduino kan communiceren met een computer via de seriële monitor.

void loop()
if (Serial.available() > 0)
De if-voorwaarde Serial.available() > 0 controleert of er minstens één byte beschikbaar is in de seriële buffer.
Als er gegevens beschikbaar zijn, wordt de eerste byte (teken) gelezen met Serial.read() en opgeslagen in de variabele ‘incomingByte’. Het teken dat gelezen is wordt uit de seriële buffer verwijdert.

Serial.println(incomingByte, DEC);
De ontvangen byte wordt vervolgens geprint naar de seriële monitor als een decimale waarde. Hier zorgt de toevoeging ‘, DEC’ voor.
De decimale waardes van de tekens staan ook in de ASCII tabel.

Notities en waarschuwingen
Geen.

Omschrijving
Het delay() commando wordt gebruikt om een pauze in te voegen in de uitvoering van het programma. Het commando vertraagt de uitvoering van verdere instructies voor opgegeven hoeveelheid milliseconden. 1000 milliseconden is 1 seconde.

Syntax
delay(waarde)

Parameters
waarde: is de waarde in milliseconden die gewacht moet worden. De waarde is een unsigned long variabele.

Geeft terug
Niets.

Voorbeeld

void setup() {
  // initialisaties
}

void loop() {
  // doe iets hier

  delay(2000);  // wacht 2 seconden voordat de volgende instructie wordt uitgevoerd
}

Toelichting voorbeeld
In dit voorbeeld wordt de loop() functie herhaaldelijk uitgevoerd, en elke keer dat het programma delay(2000); bereikt, wacht het gedurende 2 seconden voordat het verder gaat met de volgende instructie.

Het delay() commando wordt vaak gebruikt voor timing, om bijvoorbeeld sensoren te lezen met tussenpozen, LED’s te laten knipperen of om een bepaalde tijd te wachten voordat een andere actie wordt uitgevoerd in een programma.

Notities en waarschuwingen
Niets.

Omschrijving
Configureert voor een bepaalde pin of deze gebruikt wordt voor in- of uitvoer. Kijk bij de pinbezetting van de ESP32-DevKitC Bord welke pinnen je kunt gebruiken voor in- of uitvoer.

Syntax
pinMode(pin, modus)

Parameters
pin: is het GPIO nummer dat je als invoer of uitvoer wil zetten. Dus voor bijvoorbeeld GPIO1 voer je hier ‘1’ in.
modus: hier bepaal je of de pin invoer ( ‘INPUT’ ) of uitvoer ( ‘OUTPUT’ ) wordt. De derde mode is ‘INPUT_PULLUP’. Deze mode is dus ook invoer, maar nu wordt een interne weerstand ingeschakeld die zorgt voor een constant signaal. Deze pin moet wel een interne pullup weerstand ondersteunen. Zie pinbezetting.

Geeft terug
Niets.

Voorbeeld

int ledPin = 13; // Definieer de pin waarop de LED is aangesloten

void setup() {
  pinMode(ledPin, OUTPUT); // Stel de pin in als een uitvoerpin
}

void loop() {
  // Andere code hier
}

Toelichting voorbeeld
Op regel 1 krijgt de variabele ‘ledPin’ de waarde 13, dit is de pin die in dit voorbeeld gebruikt wordt.
In regel 4 wordt deze pin ingesteld als een uitvoer (OUTPUT) pin.

Notities en waarschuwingen
Kies wel een pin die een digitaal signaal aan kan en voor uitvoer geschikt is.

Omschrijving
De digitalWrite() functie wordt gebruikt in het programma om de status van een digitale pin op een microcontroller (zoals de Arduino / ESP32) te wijzigen. De pin waar naar geschreven wordt, moet wel eerst als uitvoer gedefinieerd worden. Dit doe je met de functie pinMode(). Daarna kan met de functie digitalWrite() een digitale pin als ‘hoog’ (HIGH) of ‘laag’ (LOW) ingesteld worden.

Syntax
digitalWrite(pin, waarde)

Parameters
pin: is het GPIO nummer waar je de status van wil wijzigen. Dus voor bijvoorbeeld GPIO1 voer je hier ‘1’ in.
waarde: hier bepaal je of de pin ‘HIGH’ of ‘LOW’ wordt gezet. Dit houdt in aan (‘HIGH’) of uit (‘LOW’) wordt gezet.

Geeft terug
Niets.

Voorbeeld

int ledPin = 13; // Definieer de pin waarop de LED is aangesloten

void setup() {
  pinMode(ledPin, OUTPUT); // Stel de pin in als een uitvoerpin
}

void loop() {
  digitalWrite(ledPin, HIGH); // Zet de LED aan door de pin op HIGH te zetten (5V)
  delay(1000); // Wacht 1 seconde
  digitalWrite(ledPin, LOW); // Zet de LED uit door de pin op LOW te zetten (0V)
  delay(1000); // Wacht weer 1 seconde
}

Toelichting voorbeeld
Op regel 8 en 10 wordt pin 13 ingesteld. Op regel 8 wordt deze ingesteld op ‘HIGH’ en gaat het ledje aan. Op regel 10 wordt deze ingesteld op ‘LOW’ en gaat het ledje uit.

Notities en waarschuwingen
Kies wel een pin die een digitaal signaal aan kan en voor uitvoer geschikt is.