Arduino/Programmeren

Sketch: setup, loop

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);
  delay(1000);
  digitalWrite(13, LOW);
  delay(1000);
}

Een Arduino-programma of "sketch" bevat, naast allerlei andere definities, twee functie-definities:

• setup: wordt eenmaal uitgevoerd, bij het opstarten van het programma
  • deze functie gebruik je voor het initialiseren van de pinnen en andere interfaces;
• loop: wordt herhaald uitgevoerd (totdat de Arduino uitgezet wordt, of herstart).
  • het eigenlijke programma: een niet-eindigende herhaling.

Dit zijn beide functies zonder resultaat; het woordje void geeft aan dat het resultaat "leeg" is. (Zie functies.) Deze functies hebben ook geen parameters.

Het "main" programma van de Arduino kun je je als volgt voorstellen:

setup();
while (true) {
  loop();
}

Commentaar

x = 12;   // this is comment

• commentaar begint met // en eindigt aan het eind van de regel;
• commentaar gebruik je om de lezer van het programma te helpen;
• voor de computer heeft dit commentaar geen betekenis.

Functie met resultaat

int sqr(int x) {  // function definition
  return x * x;
}

y = sqr(x + 1);  // function call

int max(int a, int b) {  // function definition
  if (a >= b) {
    return a;
  } else {
    return b;
  }
}

x = max(x - 15, 0); // function call

• een functiedefinitie begint met het type van het resultaat; in deze voorbeelden: int, ofwel integer.
  • een int-waarde is een geheel getal (meestal een 16-bits getal, in het bereik -32768..32767).
• dan: de naam van de functie
  • deze kun je zelf kiezen; gebruik een naam met een duidelijke betekenis;
• de parameters, tussen (); elke parameter heeft een type en een naam (als een variabele);
• de body, tussen {}; deze bevat de opdrachten (statements) voor het uitrekenen van het functieresultaat
  • de opdracht return expr; zorgt ervoor dat de waarde van de expressie als functieresultaat opgeleverd wordt;
  • deze opdracht beëindigt de functie: de verwerking wordt voortgezet ("keert terug") op de plaats van de aanroep.

• de aanroep (gebruik) van een functie in een expressie bestaat uit de naam van de functie gevolgd door de parameters tussen haakjes;
• deze parameters zijn expressies;

Functie zonder resultaat

void fname(type1 par1, type2 par2) {
  statementx(par1 + 11, par2);
  statementy(par2, 42);
}

void ledOn(int pin) {
  digitalWrite(pin, HIGH);
}

ledOn(ledR);
ledOn(ledG);

• de definitie van een functie zonder resultaat begint met void
  • het woordje void geeft aan dat het functieresultaat "leeg" is;
• daarna: de naam van de functie
  • gebruik een functienaam met een duidelijke betekenis;
• dan: de parameters, tussen ()
  • gebruik parameternamen met een duidelijke betekenis;
• tenslotte: de body met de opdrachten tussen {}.
• een functie zonder resultaat gebruik je voor het effect van de opdrachten (statements) in de body;

De aanroep van een functie noteer je als de naam van de functie met daarachter de parameter-waarden tussen haakjes

• bijvoorbeeld: digitalWrite(led, HIGH)

Wat is de betekenis van een aanroep van de functie ledOn(ledR);?

• je kunt de parameters als lokale variabelen van de functie beschouwen;
• deze variabelen worden geïnitialiseerd met de parameter-waarden (expressies) in de aanroep;
  • int pin = ledR;
• de opdrachten in de body van de functie worden uitgevoerd:
  • digitalWrite(pin, HIGH);
• daarna is de functie klaar en gaat de verwerking verder op de plaats van aanroep.

Variabele, declaratie, initialisatie

int led = 13;

unsigned long now = millis();

Een variabele koppelt een naam aan een waarde. In de loop van het programma kun je een variabele koppelen aan een nieuwe waarde (toekenning).

Voordat je een variabele kunt gebruiken, moet je deze declareren: je geeft dan het type van de variabele, de naam, en soms een beginwaarde (initialisatie).

• int - type van de variabele; "int" staat voor integer: geheel getal (typisch: 16 bits getal, -32768..32767)
• led - naam van de variabele. Gebruik namen met een duidelijke betekenis.
• 13 - de beginwaarde van de variabele.

Het type van een variabele geeft aan welk soort waarden deze variabele kan aannemen. Dit kan gebruikt worden om te bepalen hoeveel geheugenruimte er nodig is voor de variabele. Je kunt foutmeldingen krijgen als je een operatie op een variabele probeert uit te voeren die niet voor dat type gedefinieerd is.

Variabele: gebruik in expressie

Je kunt daarna de naam van een variabele gebruiken in een uitdrukking (expressie). Voor het uitrekenen van die uitdrukking wordt dan waarde gebruikt die op dat moment gekoppeld is aan de variabele.

Toekenning (assignment)

x = 13;
x = (y + 12) * z;
x = x + 12;
x += 12;
ledStatus = HIGH;
ledStatus = 1 - ledStatus;
ledRedStatus = 255 - ledGreenStatus;
ledStatus = min(ledStatus + 15, 255);

Door middel van een toekenning, met het teken =, koppel je een nieuwe waarde aan een variabele.

Voorbeeld: x = x + 12;:

• reken eerst de uitdrukking x + 12 uit, met de waarde die op dit moment aan x gekoppeld is.
• ken deze waarde toe aan x. In het vervolg van de uitvoering van het programma is x aan deze waarde gekoppeld, totdat je een andere waarde aan x toekent.

Let op: voor de vergelijking van twee waarden gebruik je ==. Als je een enkele = gebruikt, betekent dat toekenning. Dit is meestal niet wat je bedoelt, maar de compiler zal je meestal niet waarschuwen.

Expressies en operatoren

Rekenkundige operatoren

x + y    // add
x - y    // subtract
x * y    // multiply
x / y    // divide
x % y    // remainder
x && y   // logical and (conditional)
x || y   // logical or (conditional)

Vergelijkingsoperatoren

x == y    // equals to
x != y    // differs from
x > y     // greater than
x >= y    // at least
x < y     // less than
x <= y    // at most

Let op: voor het vergelijken van 2 waarden gebruik je ==. Als je een enkele = gebruikt, betekent dit toekenning. Je krijgt hiervoor meestal geen waarschuwing van de compiler, maar je programma doet niet wat je bedoelt.

Logische operatoren

! x       // not
x && y    // logical and (conditional)
x || y    // logical or (conditional)

Bit-operaties

x & y     // bitwise and
x | y     // bitwise or
x << y    // x leftshift y positions
x >> y    // x rightshift y positions

Besturingsstructuren (control structures)

if

Het if-statement heeft de vorm:

if (conditie) {
  opdracht1;
} else {
  opdracht2;
}

De betekenis hiervan is:

1. reken de waarde van de conditie uit
2. als deze waarde true is, voer dan opdracht1 uit;
3. als deze waarde false is, voer dan opdracht2 uit.

Met andere woorden: slechts één van deze twee opdrachten wordt uitgevoerd.

Een voorbeeld van een conditie is: ledState == HIGH. Het teken == staat voor "is gelijk aan". Deze vergelijking heeft true als resultaat wanneer ledState gelijk is aan HIGH; in alle andere gevallen is het resultaat false.

Voorbeeld:

if (ledState == LOW) {
  ledState = HIGH;
} else {
  ledState = LOW;
}

Een verkorte vorm van het if-statement gebruik je als opdracht2 leeg is: er hoeft in het else-geval niets gedaan te worden:

if (conditie) {
  opdracht1;
}

Voorbeeld:

if (digitalRead(onButton) == LOW) {
  digitalWrite(led, HIGH);
}

while

while (cond) {
  action();
}

for

for (i = start; i < limit; i++) {
  action(i);
}

Arduino functies

pinMode(led, OUTPUT);
pinMode(button, INPUT);
pinMode(button, INPUT_PULLUP);

digitalWrite(led, ledState);
buttonState = digitalRead(button);
ldrState = analogRead(ldr);
analogWrite(led, ledState);

now = millis();
delay(500);
delayMicroseconds(500000);
now = micros();

Libraries and preprocessor

#include <stdio.h>
#include "mydefs.h"

Serial.begin(9600);

Serial.print("x=");
Serial.println(x);

if (Serial.available() > 0) {
  nextByte = Serial.read();
}