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:

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!