Led aan en uit - Claasen-tech

Workshop 1

Dit is de eerste in een reeks workshops waar we kijken hoe we een Single Board Computer kunnen programmeren en hoe we onderdelen kunnen aansturen en uitlezen. Zoals led’s, motoren, knoppen en dergelijken.

We beginnen eenvoudig door een led aan en uit te schakelen door middel van een Single Board Computer zoals bijvoorbeeld een Arduino Uno of Raspberry Pi.

Benodigdheden

Single Board Computer (Arduino, Raspberry Pi of Raspberry Pi Pico)
1 x led (kleur maakt niets uit)
1 x weerstand van min. 150Ω (max. 1KΩ)
2 x jumper kabels
1 x breadboard
Programeer omgeving
Arduino: Arduino IDE
Raspberry Pi: Python IDE of een gewone tekst editor
(Thonny is een IDE voor Windows, Mac of Linux)
Raspberry Pi Pico: Thony IDE

Technische info

Op onderstaande pagina’s wordt dieper ingegaan op materie die in deze workshop gebruikt wordt en/of hier staat extra informatie.

Breadboard

In afb. 1 zie je dat er een groen draadje op het breadboard gestoken is. Dit komt van een digitale poort (bij punt B) van een Single Board Computer (niet zichtbaar op de afb.). Dit groene draadje staat via het breadboard in verbinding met de weerstand. Let op dat je de weerstand van de ene kant van het breadboard naar de andere kant verbindt, anders werkt hij niet (kijk bij breadboard hoe het werkt). De andere kant van de weerstand staat in verbinding met het ledje (de weerstand wordt met de anode = het lange pootje van het ledje verbonden). De andere aansluiting van het ledje (kathode = het korte pootje) staat via het breadboard in verbinding met het zwarte draadje. Het zwarte draadje wordt verbonden met de Min of aarde (bij punt A) van een Single Board Computer.

Opmerking:
De weerstand mag zowel tussen het ledje (kathode) en de min als tussen het ledje (anode) en de plus geplaats worden.

De kabeltjes sluit je als volgt aan op de Single Board Computers:

Arduino (Uno, Micro en Digi Spark):
A) zwarte draadje, sluit je op een ‘GND’ (is Ground of aarde) poort aan.
B) groene draadje, sluit je op de uitvoer pin ‘2’ aan op de Arduino.

Raspberry (Pi 2 B+, Pi 3 B+, Pi Zero W en Pi 4):
A) zwarte draadje, sluit je op een ‘GND’ (is Ground of aarde) poort aan.
B) groene draadje, sluit je op de uitvoer pin ‘2

Raspberry Pi Pico:
A) zwarte draadje, sluit je op een ‘GND’ (is Ground of aarde) poort aan.
B) groene draadje, sluit je op de uitvoer pin ’26’ aan op de Raspberry Pi Pico.

Het programma

Hieronder leg ik uit hoe je het programma schrijft voor de Raspberry Pi, Raspberry Pi Pico en de Arduino om volgens het bovenstaande breadboard layout het ledje te laat knipperen. De Raspberry Pi, Raspberry Pi Pico en de Arduino doen dit in een andere taal. Ik doe dat voor de Raspberry Pi in Python en voor de Raspberry Pi Pico in MicroPython (MicroPython is een variant op Python). Er zijn meer mogelijkheden, maar Python is volgens mij een veel gebruikte taal en je vindt hier zeer veel voorbeelden van. De Arduino maakt gebruik van C++.

Bij de Raspberry Pi ontwikkel je het programma ook op de Raspberry Pi. In tegenstelling tot de Arduino. Hier heb je een andere computer voor nodig om het programma te schrijven en vervolgens wordt het programma vertaald (in een voor de Arduino begrijpbare taal) en naar de Arduino overgezet.

Arduino programma (C++)

Hieronder staat het C++ programma om het ledje te laten knipperen.
Geef dit in de Arduino IDE in en upload dit naar de Arduino.

// Hier maak je een variabele die aangeeft op welke pin het ledje aangesloten zit.
int pin = 2;
// met de 'duur' variabele geef je aan hoelang het ledje aan én uit moet gaan.
int duur = 1000;

// de setup functie wordt een keer uitgevoerd als je het Single Board Computer start of reset.
void setup() {
// initializeert de digital pin 'pin' als uitvoer.
pinMode(pin, OUTPUT);
}

// de loop functie loopt keer op keer opnieuw, het is een eindeloze lus.
void loop() {
digitalWrite(pin, HIGH); // laat het ledje branden (HIGH is het voltage niveau, dus 5 volt)
delay(duur); // wacht 1 seconde
digitalWrite(pin, LOW); // zet het ledje uit door het voltage nivea op LOW te zetten, 0 volt
delay(duur); // wacht 1 seconde
}

Uitleg code:
In regel 2 en 4 worden 2 integer variabelen gedefinieerd, namelijk ‘pin’ (deze bevat het pin nummer waar de groene draad op aangesloten wordt) en ‘duur’ (deze bevat de waarde in milliseconden hoe lang dat het ledje aan en uit blijft). Opmerking, 1000 milliseconden is 1 seconde.

Regel 7 t/m 10 is de ‘setup()’ functie, deze wordt als eerste éénmalig uitgevoerd bij elke start of reset van het programma.
Op regel 9 wordt van de mode van de pin aangegeven. Dit wordt door het commando ‘pinMode’ gedaan, deze krijgt de waarde ‘INPUT’ of ‘OUTPUT’. Dit betekent dat de pin dan data (stroom) ontvangt of uitstuurt. In bovenstaande code dus stroom uitstuurt.

Regel 13 t/m 18 is de ‘loop()’ functie, deze wordt na de ‘setup()’ functie uitgevoerd. Deze herhaald zich continue. Dus als regel 18 uitgevoerd is, gaat hij weer naar regel 13. Dit is het eigenlijke uitvoerende gedeelte van het programma.
Regel 14 en 16 geven we het commando, ‘digitalWrite’, om 5 volt (‘HIGH’) of 0 volt (‘LOW’) op de pin te zetten. In ons programma dus op pin ’18’ (zoals we op regel 2 aangegeven hebben).
Op regel 15 en 17 geven we het commando, ‘delay’, om 1000 milliseconden (1 sec.) te wachten (zoals in regel 4 aangegeven).

LET OP!!!
C++ is hoofdletter gevoelig, dus ‘digitalWrite’ werkt, maar ‘digitalwrite’ of ‘DigitalWrite’ werkt niet.

Raspberry Pi programma (Python)

Hieronder staat het programma in Python om het ledje te laten knipperen.
Voer dit op de Raspberry Pi in een tekst-editor of IDE (b.v. Thonny) in.

from gpiozero import LED
import time

led = LED(26)
duur = 1
knipperaantal = 60

while knipperaantal > 0:
    knipperaantal = knipperaantal - 1
    led.on()
    time.sleep(duur)
    led.off()
    time.sleep(duur)

Uitleg code:
In regel 1 en 2 worden de modules ‘gpiozero’ en ‘time’ geladen zodat je functies die hierin staan kunt gebruiken. Van de module ‘time’ worden alle functies geladen en van ‘gpiozero’ alleen de functie ‘LED’.

Regel 4 wordt aan de variabele ‘led’ de class ‘LED’ van pin 26 toegekend.
Regel 5 krijgt de variabele ‘duur’ de waarde ‘1’.
Regel 6 krijgt de variabele ‘knipperaantal’ de waarde ’60’.

Regel 8. Bij de Arduino hebben we gezien dat een deel van het programma automatisch herhaald wordt als het einde van het programma bereikt wordt. Bij de Raspberry Pi schrijf je een programma in Python. Als het einde van het programma bereikt wordt stopt het programma. Dit is bij de meeste programmeer talen zo. Dus als we willen dat een deel van het programma herhaald wordt moeten we hier een constructie voor schrijven. In dit geval doen we dat op regel 8 door middel van het commando ‘while’. Zolang de vergelijking waar is, herhaald de lus zich. In bovenstaande code wordt de lus dus 60 maal uitgevoerd en dan stopt het programma.
We zouden regel 8 kunnen veranderen in ‘while True:’. de lus zou dan oneindig zijn en dus nooit stoppen.

Regel 9, 10, 11, 12 en 13 zijn ingesprongen. Dit maakt hun deel uit van de while-lus. Dus dit deel wordt 60 maal uitgevoerd.
In regel 9 wordt de variabele ‘knipperaantal’ (die de waarde 60 bevat) vermindert met 1 (dus 60 wordt 59). Je ziet dat dit een belangrijke regel is. Als deze regel er niet zou zijn, zou de lus oneindig zijn, dus nooit stoppen.
Regel 10, hier wordt het ledje aangezet.
Regel 11, hier wordt gewacht voor de tijd in seconden. De variabele ‘duur’ heeft een waarde van 1 dus wordt er 1 seconde gewacht.
Regel 12, hier wordt het ledje uitgezet.
Regel 13, net als in regel 11 wordt hier gewacht.
Het einde van de lus wordt bereikt en het programma springt naar regel 8 en kijkt of de vergelijking waar (True) is. Zo ja, wordt er verdergegaan naar regel 9. Zo nee, dan springt het programma naar regel 14. Maar omdat deze niet bestaat, eindigt het programma.

LET OP!!!
Python is hoofdletter gevoelig, dus ‘led.on()’ werkt, maar ‘Led.on’ of ‘Led.On’ werkt niet.

Raspberry Pi Pico programma (MicroPython)

Hieronder staat het programma in MicroPython om het ledje te laten knipperen.
Voer dit op de Raspberry Pi Pico in via de IDE Thonny uit.

import machine
import utime

led1 = machine.Pin(16, machine.Pin.OUT)
duur = 1
knipperaantal = 60

while knipperaantal>0:
    knipperaantal = knipperaantal-1
    led1.value(1)
    utime.sleep(duur)
    led1.value(0)
    utime.sleep(duur)

Uitleg code:
Let op!!!
De programmeertaal die de Raspberry Pi Pico gebruikt is MicroPython, dit is een variatie op de programmeertaal Python. Deze gebruikt andere modules en sommige dingen gaan net even iets anders.

In regel 1 en 2 worden de modules ‘machine’ en ‘utime’ geladen zodat je functies die hierin staan kunt gebruiken.

Op regel 4 wordt ‘led1’ een class van ‘machine’ en gelijktijdig pin 16 als uitvoer toegekend aan de class ‘led1’.
Op regel 5 krijgt de variabele ‘duur’ de waarde ‘1’.
Op regel 6 krijgt de variabele ‘knipperaantal’ de waarde ’60’.

Regel 8. Bij de Arduino hebben we gezien dat een deel van het programma automatisch oneindig herhaald wordt als het einde van het programma bereikt wordt. Bij de Raspberry Pi schrijf je een programma in MicroPython. Als het einde van het programma bereikt wordt stopt het programma. Dit is bij de meeste programmeer talen zo. Dus als we willen dat een deel van het programma herhaald wordt, moeten we hier een constructie voor schrijven. In dit geval doen we dat op regel 8 door middel van het commando ‘while’. Zolang de vergelijking waar is, herhaald de lus zich. In bovenstaande code wordt de lus dus 60 maal uitgevoerd en dan stopt het programma. Let op, de regel met het commando ‘while’ wordt met een dubbele punt afgesloten. Zo weet het programma dat de inhoud van de lus begint.
We zouden regel 8 kunnen veranderen in ‘while True:’. De lus zou dan oneindig zijn en dus nooit stoppen.

LET OP!!!
Ook MicroPython is hoofdletter gevoelig, dus maak bijvoorbeeld in regel 4 op de juiste plaatsen gebruik van hoofdletters.