De Arduino is een kleine computer. Standaard zal een computer niets doen. Een computer moet opdrachten krijgen. Dat gaat via commando's. Programmeren is het achter elkaar zetten van heel veel commando's.

Een voorbeeld van een programma is de handleiding bij een IKEA kast, de beschrijving bij een modelvliegtuigje of bijvoorbeeld voor een dagelijkse actie:

• Loop naar de keuken
• Open de koelkast
• Pak een flesje bier
• Sluit de koelkast
• Open de keukenlade
• Pak de flessenopener
• Open het bierflesje
• Gooi het dopje in de vuilnisbak
• Leg de opener terug in de keukenlade
• Sluit de keukenlade
• Loop naar de bank
• Ga zitten
• Drink!

In de Arduino wereld noemen we een programma een sketch. Waarschijnlijk hebben de ontwikkelaars hier voor de naam sketch gekozen omdat het laat zien dat het een snelle poging is, een schetsje. Niets definitief. Je kunt het nog vaak aanpassen.

In onderstaande figuur zie je hoe "auto rijden" meestal gaat. Je stapt in, start de motor en gaat rijden. Dit zijn dingen die je eenmalig doet. Daarna doe je iedere keer hetzelfde. Je gaat rechtdoor en slaat af, daarna ga je weer rechtdoor totdat je opnieuw afslaat.

De Arduino werkt op dezelfde manier. Je programma bestaat uit een deel dat altijd direct zal worden uitgevoerd, meteen aan het begin, alleen altijd maar een (1) keer. Dit is de setup. Hierna zal een stuk code komen dat hierna continue zal worden uitgevoerd. Opnieuw en opnieuw en opnieuw en opnieuw en opnieuw en opnieuw en opnieuw. Dit is de loop. Er zit geen einde aan, het blijft doorgaan (zolang de stroom aanstaat).

We hebben dus 2 losse stukken code in onze sketch. Zo een los stukje code noemen we een functie. We hebben dus een setup functie en een loop functie. Iedere Arduino sketch (ieder Arduino programma) heeft altijd verplicht deze 2 functies nodig. Later zullen we zien dat we ook andere functies zelf kunnen maken, maar voor nu zijn deze beiden voldoende.

Iedere Arduino sketch zal dus een keer de setup functie uitvoeren en ontelbaar vaak (oneindig vaak) de loop functie. Maar wat hebben we hier nu aan?

De code die in de setup functie komt zal altijd maar een (1) enkele keer worden doorlopen, enkel bij de start van de sketch. Daarna niet meer. Dit doorlopen zal automatisch gebeuren, daar hoef je zelf niets voor te doen. Omdat de setup altijd meteen aan het begin zal worden uitgevoerd kunnen we die prima gebruiken om alles in orde te brengen voor het programma.

Vergelijk met koken. Je begint met alles te wassen, te snijden, klaar te zetten. Voordat je echt een pan op het vuur zet. Dit doe je in de setup.

Het woord setup moet in kleine letters worden geschreven.

Soms wil je wat notities opnemen in je code. Dat kun je doen door deze achter de // te typen. Deze teksten worden dan niet uitgevoerd als commando's. Dit commentaar schrijven we altijd in het Engels.

// put your setup code here, function is executed once:
void setup() {

	// put the commands here

}

Het woordje void geeft aan dat de functie geen informatie terug geeft, dat is nu even niet van belang.

Nadat de setup is doorlopen dan is de loop aan de beurt. De code in de loop zal voor altijd en eeuwig worden doorlopen. Als de code in de loop functie is afgelopen dan start deze loop functie direct overnieuw. Dit gaat maar door-en-door-en-door. Dit is een continue "herhaling" (herhaling is loop in het Engels). Wellicht dat daar de naam van deze functie ook vandaan komt?

De bovengenoemde 2 functies, setup en loop, heb je echter altijd nodig.

Het woord loop moet op deze manier worden geschreven, in kleine letters

// put your main code here, function is executed repeatedly:
void loop() {

	// put the commands here

}

Je ziet dat hier op Punthooft we programma code op een speciale manier schrijven. Hierdoor springt het er meer uit en is het duidelijker wat er moet gebeuren.

Een belangrijke regel in de taal C is dat iedere regel moet worden afgesloten met een punt komma. Doe je dat niet dan zal de compiler hierover gaan klagen. Tot nu toe hebben we nog geen opdrachten gezien, maar die komen er aan als je verder leest.

Het is een goed gebruik om veel commentaar in je code op te nemen. Voor en tussen de code staat commentaar. Commentaar zijn de opmerkingen die de programmeur heeft toegevoegd om alles leesbaarder te maken. Dit kan voor een andere lezer zijn of voor in de toekomst als je het niet meer precies weet. Commentaar kan op 2 manieren worden opgenomen.

Commentaar gebied, alles wat tussen de tekens staat is commentaar. Dit kan op een regel zijn of op meerdere regels. Het commentaar staat tussen /* en */ tekens. Deze tags geven het begin en eind punt aan van het commentaar blok.

Alles tussen deze tags is commentaar. Ook als hierin code statements staan, dan zullen die niet worden uitgevoerd.

/* dit is commentaar */

/* dit is 
   ook
   een stukje
   commentaar */

Regel commentaar is een andere manier van commentaar opnemen. Alles na de // tag zal verder worden genegeerd.

// dit is commentaar

foo = 123; // dit laatste is commentaar

Het is belangrijk om veel commentaar op te nemen, zodat je later nog steeds begrijpt wat iedere regel doet. Goed programmeren is goed commentaar toevoegen!

Hierboven stond een eerste commando, wat dit doet komen we later terug.

De code die je schrijft kan (of zal) soms fouten bevatten. Het is niet mogelijk om scripts die fouten bevat te uploaden naar het Arduino bordje. In de IDE kun je het script verifieren.

Al je geschreven code zal worden nagelopen en als er fouten in zitten dan zal dat worden aangegeven. Je moet eerst de fouten herstellen voordat je verder kunt.

Als de code juist is dan kun je deze compileren en het script uploaden. Dit gaat in de IDE met een knop. Het compileren is het omzetten van je geschreven code naar een formaat dat de Arduino microcontroller begrijpt, zodra dat is gebeurd zal deze machinecode worden overgepompt naar de Arduino.

Als de code werkt en is getest, dan kan de PC worden losgekoppeld van de Arduino. De sketch staat op de Arduino en zal erop blijven staan. Deze kan gewoon worden uitgevoerd, zonder dat we onze computer hier verder nog voor nodig hebben.

Er bestaan 2 soorten fouten. Een syntax fout is bijvoorbeeld een verkeerd geschreven woord. De compiler kan hier niets mee en zal een fout rapporteren. Code met syntax fouten kan niet worden gebruikt.

dely(1000);                  // wait for a second

Hierboven een syntax fout, omdat het commando delay verkeerd is geschreven (zonder a).

De andere fout is vaak lastiger, dat is een semantische fout. Bijvoorbeeld als je wilt dat iets 5 keer gebeurd, maar het gebeurd maar 4 keer, dan is er iets mis. De compiler weet niet dat er iets fout is. Het programma loopt immers gewoon goed. Maar de gebruiker ziet en weet dat er iets verkeerd is. Deze fouten kun je enkel vinden door goed te testen.

  delay(1);                  // wait for a second

Hierboven een semantische fout. Het commentaar geeft aan dat er een wacht periode van 1 seconde zal gebeuren. In werkelijkheid zal er slechts 1/1000e van een seconde worden gewacht. De compiler kan het commentaar niet lezen. Dit is een semantische fout, een programmeerfout

Een programma heet in Arduino taal een Sketch. Hier kun je zelf commando's ingeven.

Om de taal te leren adviseer ik sterk om het prachtige boek The C Programming Language geschreven door Brian Kernighan en Dennis Ritchie te lezen. Dit boek is voor het laatst uitgebracht in 1988 (2nd edition), maar nog steeds helemaal geldig. Het is geschreven in begrijpelijk Engels geschreven. De uitvinders van de taal C leren je prima hoe je moet programmeren. De C taal is de taal die we ook voor de Arduino gebruiken en je stiekem ook tegenkomt in talen als C++, ObjectiveC, C# en afgeleide vormen in andere talen als Javascript, Java en PHP.

Hoe je nu dingen gaat aansluiten op de Arduino lees je hier Schema.