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

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 verwijst niet naar een enkele functie, maar naar een verzameling functies die communicatie tussen een computer en een microcontrollerbord mogelijk maken. Over het algemeen is er ten minste één poort beschikbaar voor deze communicatie. Bovendien kan een microcontrollerbord ook met andere apparaten communiceren via deze poorten.

Hieronder bespreek ik enkele basis functies die het mogelijk maken om waarden vanaf het microcontrollerbord weer te geven in de seriële monitor van de Arduino IDE, en om gegevens vanuit de Arduino IDE (via de seriële monitor) naar het microcontrollerbord te sturen. Deze functionaliteit wordt vaak gebruikt voor het debuggen van een programma.

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

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

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);
}

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

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

void loop() {
  Serial.println("Geef een kleur in:");
  while (Serial.available() == 0) {}     //wacht totdat er gegevens aanwezig zijn
  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");
  }
}

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
  }
}

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
  }
} 

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.