Arduino

Kort gezegd: een Arduino is het 'brein' dat alledaagse apparaten en apparatuur precies laat doen wat ze moeten doen.

• USB-poort: dient voor twee zaken: het uploaden van jouw programma vanaf de computer naar de Arduino én het leveren van stroom tijdens het testen.

• voedingsaansluiting (DC): om de Arduino van stroom te voorzien via een batterij of adapter (7-12V) wanneer hij niet aan de computer gekoppeld is.

• resetknop: hiermee start je het opgeslagen programma weer helemaal vanaf het begin op.

We gebruiken een breadboard omdat we zo:

• snel kunnen testen. Binnen een paar minuten kunnen we een schakeling opbouwen;

• geen componenten beschadigen door de hitte van een soldeerbout.

• onze componenten allemaal kunnen herbruiken. Is je project klaar of werkt het niet? Je trekt de kabeltjes er zo weer uit.

Je kunt een LED-lampje direct laten branden op een Arduino zonder enige code door gebruik te maken van de vaste voedingspinnen.

⚠️ Belangrijk: Sluit een LED nooit direct aan op de 5V en GND zonder een weerstand! Een LED heeft bijna geen eigen weerstand en zal zonder beveiliging direct doorbranden (en kan je Arduino beschadigen). Gebruik altijd een weerstand van 220 Ohm tot 1k Ohm.

Wat heb je nodig?

• • 1x Arduino (aangesloten op de computer of batterij voor stroom);

  • 1x Breadboard;

  • 1x LED-lampje;

  • 1x Weerstand (bijv. 220 Ohm - kleurencodes: rood-rood-bruin);

  • 2x Jumper draden (steekkabels).

Zo sluit je het stap voor stap aan:

• plaats de LED op het breadboard:

  • een LED heeft een lange poot (plus / anode) en een korte poot (min / kathode);

  • prik de lange en korte poot in twee verschillende rijen op het breadboard.

• plaats de weerstand:

  • prik één kant van de weerstand in de rij van de lange poot van de LED;

  • prik de andere kant van de weerstand in een lege rij op het breadboard.

• verbind met de 5V (Plus):

  • sluit een kabeltje aan vanaf de 5V-pin van de Arduino naar de rij waar de weerstand in zit.

• verbind met de GND (Min/Massa):

  • sluit een tweede kabeltje aan vanaf de GND-pin (Ground) van de Arduino naar de rij met de korte poot (min) van de LED.

Wat gebeurt er?

Zodra je de Arduino van stroom voorziet via de USB-kabel of adapter, stroomt de spanning direct vanuit de 5V-pin, door de weerstand, door de LED en via de GND-pin weer terug. De stroomkring is gesloten en het lampje brandt meteen, volledig zonder programmacode!

Uiteraard willen we meer kunnen dan enkel lampjes laten branden en hebben we dus programmacode nodig om sensoren en actuatoren aan te sturen en uit te lezen. Hievoor hebben we de Arduino IDE (Integrated Development Environment) nodig.

Code editor

Hier schrijf je de code om sensoren uit te lezen en actuatoren (zoals motoren of lampjes) aan te sturen.

Knoppen

Met deze knoppen controleer je eerst of je code geen spelfouten (syntax) bevat (verifiëren) en stel je het programma beschikbaar op de Arduino (uploaden).

Error console

Hier zie je meteen waar het misgaat als de code niet werkt. Door de foutmeldingen goed te lezen en te begrijpen, kun je problemen in je code snel zelf opsporen en herstellen.

Seriële monitor (Input/Output)

Een onmisbare functie om live te zien wat er gebeurt. Je kan hiermee gemeten sensorwaarden of statusberichten direct op je scherm tonen om te testen of alles naar behoren werkt.

Wanneer je een nieuw project start in de Arduino IDE, zie je dat er standaard altijd twee functies klaarstaan: setup() en loop(). Dit is de basisstructuur van elk Arduino-programma.

setup()

void setup{

}

Deze functie wordt één keer uitgevoerd, direct wanneer de Arduino opstart of gereset wordt.

Deze functie dient om de begininstellingen klaar te zetten. Hier geef je bijvoorbeeld aan welke pinnen als in- of uitgang werken (pinMode()), start je de seriële communicatie op (Serial.begin()) of stel je aangesloten schermen en sensoren in.

loop()

void loop(){

}

Zodra de setup() is afgerond, start de loop(). Deze functie blijft zich eindeloos herhalen zolang de Arduino stroom heeft.

Deze functie is het actieve hart van je programma. Hier schrijf je de code die continu moet draaien, zoals het voortdurend uitlezen van sensoren, het uitvoeren van berekeningen en het direct aansturen van lampjes of motoren op basis van die metingen.

Deze pinnen zijn digitale pinnen, dat wil zeggen dat deze pinnen maar twee toestanden kennen: er staat wel spanning op, of er staat geen spanning op. Er is geen tussenweg.

Maar wanneer gebruik je nu de modus input of output?

• Als INPUT (waarden binnenkrijgen): voor sensoren die alleen een ja/nee-signaal geven. Denk aan een drukknop, een bewegingssensor (wel/geen beweging) of een regensensor die enkel meldt of het regent of niet. Het instellen van een poort als input pin doe je in de setup() als volgt:
  int led = 13;
  void setup(){
  pinMode(led,INPUT);
  }

• Als OUTPUT (waarden uitsturen): om apparaten direct aan te sturen met een aan/uit-commando. Denk aan het laten knipperen van een LED, het laten afgaan van een alarmzoemer, of het inschakelen van een motor via een relais. Het instellen van een poort als input pin doe je in de setup() als volgt:
  int led = 13;
  void setup(){
  pinMode(led,OUTPUT);
  }

Met het commando digitalWrite() vertel je de Arduino dat hij spanning moet zetten op een digitale pin (die ingesteld staat als OUTPUT) of die spanning er juist af moet halen.

Het commando heeft steeds twee dingen nodig tussen de haakjes: welke pin je wilt aansturen en welke stand (HIGH of LOW) je kiest:
digitalWrite(pinNummer, WAARDE);

Spanning zetten

digitalWrite(pin, HIGH);

Wanneer je kiest voor HIGH, zet de Arduino de volle spanning op die pin (5 Volt).

• Wat gebeurt er elektrisch? De pin verandert in een stroombron.

• Wat betekent dit in de praktijk?

  • Een aangesloten LED-lampje gaat AAN.

  • Een zoemer begint te piepen.

  • Een relais schakelt in om een zwaardere motor te starten.

Spanning afhalen

digitalWrite(pin, LOW);

Wanneer je kiest voor LOW, haalt de Arduino de spanning van de pin af (0 Volt).

• Wat gebeurt er elektrisch? De pin geeft geen spanning meer af.

• Wat betekent dit in de praktijk?

  • Een aangesloten LED-lampje gaat UIT.

  • Een zoemer stopt met piepen.

  • Een relais schakelt uit om een motor te stoppen.

Een Arduino kan informatie krijgen van sensoren, knoppen en andere onderdelen. Om zo'n signaal uit te lezen, gebruiken we onder andere digitalRead(pin) en analogRead(pin).

digitalRead()

Bij een digitaal signaal zijn er maar twee mogelijkheden:

• LOW → 0 → geen signaal

• HIGH → 1 → wel een signaal

Je gebruikt digitalRead() bijvoorbeeld bij een drukknop. De Arduino kijkt dan eigenlijk alleen: is de knop ingedrukt of niet?

int toestand = digitalRead(2);

Hier leest de Arduino de digitale pin 2 uit.

analogRead()

Bij een analoog signaal zijn er veel verschillende waarden mogelijk. De Arduino meet hoeveel spanning er op de ingang staat. Bij een Arduino Uno geeft analogRead(pin) een waarde van 0 tot 1023:

• 0 → ongeveer 0 V

• 512 → ongeveer 2,5 V

• 1023 → ongeveer 5 V

int waarde = analogRead(A0);

Hier leest de Arduino de spanning op A0 uit.

Dit gebruik je bijvoorbeeld bij een potentiometer of Velostat, omdat de waarde kan veranderen.

Met het commando 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);

De seriële monitor is een soort venster tussen de Arduino en de computer. Je kunt er informatie vanuit de Arduino naar je computer sturen. Dit is handig om te controleren wat je programma doet of om waarden van sensoren te bekijken.

Eerst moet je in setup() de seriële communicatie starten:

void setup() {

  Serial.begin(9600);

}

De 9600 is de snelheid waarmee de Arduino en computer met elkaar communiceren. Voorlopig hoef je vooral te onthouden dat je deze regel nodig hebt.

Daarna kun je met Serial.println() een waarde of tekst naar de seriële monitor sturen:

void loop() {

  int waarde = analogRead(A0);

  Serial.println(waarde);

  delay(500);

}

De Arduino leest hier de waarde van A0 en stuurt die naar de computer. In de seriële monitor zie je dan bijvoorbeeld:

512

518

525

540

563

Als je op een potentiometer draait of op een Velostat drukt, zal de waarde veranderen.