Programmeertaal

Zonder programmacode is een Arduino niks meer dan een verzameling losse onderdelen en kunnen we dit enkel gebruiken als stroombron. Code is namelijk de handleiding en de logica die je de microcontroller meegeeft om sensoren en actuatoren uit te lezen en aan te sturen.

De sensoren (zoals een temperatuursensor of drukknop) en actuatoren (zoals een lampje of motor) weten uit zichzelf niet wat ze moeten doen. Met je programmacode vertel je de Arduino precies wanneer hij actie moet ondernemen, hoe hij de binnengekomen informatie moet verwerken en wat hij vervolgens moet aansturen.

Korom: de Arduino levert als het ware de spieren en de sensoren, maar de code vormt het brein dat het hele systeem laat werken.

Een algoritme is de denkwijze/logica in je hoofd of op papier. Programmacode, zoals de code die je in de Arduino IDE schrijft, is de taal waarin je dat algoritme opschrijft, zodat de computer of microcontroller het snapt en kan uitvoeren.

Een variabele kun je het beste vergelijken met een gelabeld doosje in het geheugen van een computer (of Arduino) waarin je een waarde kunt opslaan. Die waarde kun je later in je programma opvragen, gebruiken én veranderen.

Waarom gebruiken we variabelen?

Stel dat je het aantal keren dat iemand op een knop drukt wilt bijhouden. De computer moet dat getal ergens onthouden. Daar gebruik je een variabele voor.

Een variabele heeft altijd twee dingen

• • een naam: zodat je weet wat er in het doosje zit (bijvoorbeeld aantalAfdrukken of temperatuur).

  • een inhoud/waarde: de data die er op dat moment in opgeslagen is (bijvoorbeeld 5 of 21.5).

Voorbeeld in het dagelijks leven

Denk aan de score (thuisTeamScore) van een voetbalwedstrijd:

• aan het begin staat het doosje thuisTeamScore op 0;

• scoort het team? Dan haal je de 0 uit het doosje en stop je er een 1 in;

• aan het einde van de wedstrijd leest het scorebord het doosje uit en toont de huidige stand.

Hoe ziet dit eruit in Arduino-code?

In een programmeertaal moet je de computer vertellen wat voor soort doosje het is (het datatype), welke naam het krijgt en welke waarde erin gaat.

int thuisTeamScore = 0; // Maak een doosje 'thuisTeamScore' voor hele getallen en stop er 0 in.
thuisTeamScore = 1; // Het team scoort en we stoppen nu de waarde 1 in het doosje.

Naamgeving

We gebruiken als naam voor onze variabele steeds logische namen en we gebruiken de CamelCase-methode. Dit wil zeggen dat als we een variabelenaam  kiezen en deze bestaat uit meerdere woorden, we elk woord starten met een hoofdletter en we kleven de woorden aan elkaar. Bijvoorbeeld: thuisTeamScore en niet thuisteamscore.

Computers willen graag precies weten wát je op wilt slaan, omdat verschillende soorten informatie anders worden opgeslagen. Hieronder noteren we de meest voorkomende datatypes.

Voordat je een variabele kan gebruiken, moet je deze eerst initialiseren of aanmaken. Wanneer je die aanmaakt, moet je het type mee noteren. Nadien, wanneer je de variabele gebruikt, hoef je het type niet meer te vermelden.

type naam = waarde;

Voorbeeld

int ledPin = 13; // Het lampje zit op pin 13, 13 is een geheel getal, dus van type int

int wachttijd = 500; // Knippersnelheid in milliseconden, 500 is een geheel getal, dus van type int

void setup(){

pinMode(ledPin, OUTPUT);

}

void loop(){

digitalWrite(ledPin, HIGH); // Lampje AAN
  delay(wachttijd);           // Wacht 0,5 seconde
  digitalWrite(ledPin, LOW);  // Lampje UIT
  delay(wachttijd);           // Wacht 0,5 seconde

}

Het gebruik van deze variabelen is handig, want wil je dat het lampje sneller gaat knipperen? Dan hoef je nu alleen bovenin wachttijd = 100; aan te passen. Je hoeft dit niet meer op meerdere plekken in je code te veranderen! Indien je LED niet op pin 13 is aangesloten, maar op pin 9, kan je dit ook eenvoudig bovenaan de code aanpassen.

Om je code overzichtelijk te houden en uit te leggen wat een specifiek stukje code doet, kun je commentaar toevoegen. Commentaar is tekst die bedoeld is voor jou of anderen die de code lezen.

De computer en de Arduino negeren deze lijnen volledig tijdens het uitvoeren. Tekst in commentaar wordt dus niet gecontroleerd op spelfouten of codeerfouten en neemt geen geheugen in beslag op je Arduino.

Hoe schrijf je commentaar in de Arduino IDE?

Enkele regel commentaar (//)

Alles wat achter twee schuine strepen staat op dezelfde regel, wordt genegeerd.

Voorbeeld

int ledPin = 13; // Sla het pinnummer van de LED op

Meerdere regels commentaar (/* ... */):

Handig voor langere uitleg of een blok tekst verspreid over meerdere regels.

Voorbeeld

/*

Dit programma laat een LED lampje knipperen

Auteur: T. Van den Eede

Datum: 01/09/2026

*/

!Tip! Commentaar wordt ook vaak gebruikt om tijdelijk een stukje code uit te schakelen tijdens het testen, zonder dat je het meteen hoeft te verwijderen!

Een algoritme is een logisch stappenplan: een reeks instructies in een vaste volgorde die leidt tot het gewenste eindresultaat.

Om de Arduino dit stappenplan te laten uitvoeren, moeten we het vertalen naar de programmeertaal van Arduino. Dit doen we met behulp van functies en controlestructuren.

• Functies: reeds geprogrammeerde acties die de Arduino kan uitvoeren (zoals digitalWrite() of delay())

• Controlestructuren: beslissingen en herhalingen in de code (zoals if/else of for-loops)

In de Arduino-taal dient een puntkomma (;) als de 'punt achter de zin'. Je sluit vrijwel elke afzonderlijke instructie af met een ;. Mis je een puntkomma? Dan weet de Arduino niet waar de instructie stopt en krijg je een foutmelding!

Voorbeeld

digitalWrite(13,HIGH); //Instructie 1: zet pin 13 AAN, afgesloten met een ;

delay(1000); //Instructie 2: wacht 1 seconde, afgesloten met een ;

Een functie is een reeks instructies die bij elkaar horen en later in een programma opnieuw gebruikt kunnen worden. Binnen de Arduino taal zijn er al heel veel functies reeds door andere geprogrammeerd, die wij kunnen gebruiken. Maar je zou ook zelf functies kunnen maken. 

returntype functienaam(parameters){

instructies;

}

Een functie kan een returnwaarde hebben (iets teruggeven), maar dat hoeft niet. Een functie als analogRead() leest een sensor uit en geeft de gemeten waarde terug aan je programma. Een functie als digitalWrite() voert alleen een actie uit (lampje aan/uit) en geeft niets terug (void).

Voorbeeld

int kwadraat(x){

return x*x;

}

uitkomst = kwadraat(4);

In de Arduino taal zijn er steeds twee verplichte functies aanwezig in een programma, namelijk de setup() en de loop() functie. De setup() wordt éénmalig bij het starten van het programma uitgevoegd, de loop() blijft worden uitgevoerd, zolang de Arduino van stroom wordt voorzien.

Hier noteren we een overzicht van belangrijke functies bij het gebruik van een Arduino.

pinMode(pin,modus)

De functie pinMode(pin, modus) wordt gebruikt om een pin in te stellen als input of output. Het eerste argument van de functie, pin, is de nummer van de pin (0-13) dat je wilt instellen. De modus is ofwel OUTPUT ofwel INPUT.

Voorbeeld

int led = 13;

int knop = 5;

void setup(){

pinMode(led,OUTPUT);

pinMode(knop,INPUT)

}

void loop(){

}

digitalWrite(pin,status)

De functie digitalWrite(pin,status) zorgt ervoor dat je een spanning kan zetten op een output-pin. De pin is opnieuw de nummer van de pin (0-13) die je wenst te gebruiken, de status zal HIGH of LOW zijn, spanning of geen spanning.

Voorbeeld

int led = 13;

void setup(){

pinMode(led,OUTPUT);

}

void loop(){

digtalWrite(led,HIGH); //wel spanning op pin13

}

delay(tijd)

Met de functie delay(tijd) laat je de Arduino een ingestelde tijd pauzeren. Tijdens deze pauze doet de Arduino even helemaal niets: hij stopt met het uitvoeren van de code en wacht simpelweg tot de tijd voorbij is.

De tijd die je tussen de haakjes zet, geef je op in milliseconden.

delay(tijdInMs);

Voorbeeld

int led = 13;

void setup(){

pinMode(led,OUTPUT);

}

void loop(){

digtalWrite(led,HIGH); //wel spanning op pin13

delay(1000); //even wachten

digtalWrite(led,LOW); //geen spanning op pin13

delay(1000); //even wachten

}

Serial.begin(snelheid)

Serial.println(tekst)

Hiervoor verliep de uitvoering van de code steeds lineair: elke regel werd opeenvolgend uitgevoerd. Om een programma flexibel te maken, is het echter noodzakelijk dat de Arduino kan reageren op veranderende omstandigheden, zoals wisselende sensorwaarden of input van de gebruiker.

Via keuzestructuren (voorwaardelijke instructies) introduceer je logica in je code. Je geeft het programma de mogelijkheid om voorwaarden te evalueren en op basis daarvan te bepalen welke specifieke codeblokken wel of niet moeten worden uitgevoerd.

Voorbeeld

int leeftijd = 2;

void setup(){

Serial.begin(9600); //snelheid gegevensoverdracht instellen tussen Arduino en seriële monitor, 9600 bps

}

void loop(){

if (leeftijd > 20){

Serial.print("Je bent al bijna volwassen!");

} else {

Serial.print("Je bent nog erg jong.");

}

}