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