Elektronica aansluiten
Op een Raspberry Pi kun je schakelaars en leds rechtstreeks aansluiten – leuk om mee te experimenteren. We laten met een experimenteerboard zien waar je bij de elektronica en de bedrading op moeten letten.
Op een Raspberry Pi zitten achter de netwerkpoort 40 pinnen waar je uitbreidingsboards zoals een HAT of jumperkabels rechtstreeks op kunt aansluiten. Van die ze pinnen zijn er 27 zogenaamde General Purpose Input/Output pins (GPIO), oftewel input- en output-pinnen zonder een vooraf vastgelegde functie. Elke daarvan kun je als output configureren en er met je eigen programma’s een spanning van 3,3 volt op zetten of verbinden met massa (GND). Maar je kunt ze ook allemaal als input gebruiken, zodat je eigen programma herkent of ze zijn aangesloten op de 3,3 volt spanning of op massa.
INPUTS HOOG OF LAAG
Inputs moeten in een schakeling verbonden zijn met massa (GND-pin) of met 3,3 volt. Sluit ze niet rechtstreeks aan op de 5-volt pinnen, anders kun je de Raspberry Pi onherstelbaar beschadigen. Als de inputs zonder elektrische aansluiting in de lucht hangen, leest de Pi willekeurig een hoog of laag niveau uit, afhankelijk van het feit of er zich een paar elektronen op het stuk draad hebben verzameld of niet. Zo’n ongedefinieerd niveau wil je vermijden.
Als je een drukknop aansluit, maakt die in ingedrukte toestand verbinding met de 3,3 volt. Maar is de knop niet ingedrukt, dan zou de verbinding in de lucht hangen. Daarom kun je tussen de pin en massa beter een verbinding inbouwen waarlangs ladingen kunnen wegvloeien. Als die verbinding alleen een draad zou zijn, zou er bij het indrukken van de drukknop kortsluiting ontstaan, daarom worden er zogenaamde pull-down-weerstanden gebruikt die de stroom begrenzen als de schakelaar gesloten is. Een waarde van 10 kΩ is daarvoor gebruikelijk. Door zo’n grote weerstand kunnen alleen lage stromen lopen, de lage restlading bij het openen van de schakelaar stroomt daarom veilig weg.
BOUNCEN
Wanneer een schakelaar wordt gesloten, ontstaat er een minder dan een tiende van een seconde een nog niet volledig gesloten verbinding. Meestal oscilleren de verende metalen plaatjes en maken ze meerdere keren een verbinding, die ze direct daarna weer verliezen. Elektronici noemen dat heen en weer stuiteren bouncen.
Aangezien de Raspberry Pi met een interrupt op stijgende en vallende flanken van een GPIO kan reageren, registreert hij het bouncen als meerdere knopdrukken. Dat kun je zowel met hard- als met software tegengaan.
Het ‘debouncen’ via hardware kan bijvoorbeeld met een condensator van 0,1 µF tussen de pin en GND. Die condensator moet zich bij het inschakelen eerst opladen en houdt daarom bij het inschakelen de spanning kort vast. Bij het uitschakelen ontlaadt hij zich en houdt hij de spanning nog even hoog. Met een hogere capaciteit gaat het debouncen nog beter, maar bij zeer grote condensators reageert de schakelaar met een vertraging. Pas de waarde dus aan je schakelaar en je behoeften aan. Afhankelijk van de schakelaar kun je daarmee niet elke ongewenste interrupt voorkomen, maar het reduceert het op en neer gaan wel tot enkele uitzonderingen.
Je kunt dat ook in de software aanpakken. Het programma kan de status van een GPIO met tussentijden van een tiende van een seconde opvragen. Of je kunt een time.sleep(0.1) invoegen als reactie op een schakelgebeurtenis, om pas na een tiende van een seconde weer op een andere interrupt te reageren. In de code bij de link op de volgende pagina staat een voorbeeld.
Componenten zoals leds hebben een vrij kleine weerstand, waardoor er zelfs bij 3,3 volt relatief grote stromen kunnen lopen. In het ergste geval zal een led kapot gaan als die rechtstreeks op de GPIO-pinnen wordt aangesloten. Daarom is het aan te raden om de spanning op de led te verlagen, wat volgens de wet van Ohm ook de stroom beperkt. Voeg daarvoor een voorschakelweerstand in de schakeling in. Je kunt de perfecte waarde voor de weerstand van een led berekenen met de waarden op het datablad van de led. Als je dat te ingewikkeld vindt, is 80 Ω een geschikte waarde voor alle gangbare leds –. 100 Ω is ook goed.
EXPERIMENTEERBOARD
Om een warboel aan draden te voorkomen, is het de moeite waard om met een experimenteerboard te werken. Ze houden de componenten op hun plaats en zorgen voor overzicht.
Wanneer je veel ruimte nodig hebt, kun je ook een oude IDE-lintkabel gebruiken als verbinding met een board. De 40-pins connector past precies op de pinheader van de Raspberry Pi. De draden van nieuwere UDMA-kabels hebben echter een extra massaverbinding tussen alle signaalkabels, zodat de draad te fijn is om te verwerken.
Als je het makkelijker wilt doen, kun je voor 5 tot 10 euro een aangepaste printplaat kopen. Verschillende fabrikanten bieden daarvoor modellen onder namen als Raspberry Pi Prototyping HAT. Ze verbinden de GPIO-pinnen met gaten die niet direct naast elkaar liggen, zodat je er wat tussen kunt solderen. Bovendien leiden ze GND en 3,3 volt als rails over de printplaat, waardoor kortere draadafstanden mogelijk zijn.
PROGRAMMEREN MET PYTHON
Voor het gemak gebruiken de volgende voorbeelden Python voor de aansturing. De interface voor de pinnen is hier de GPIO-bibliotheek. Eerst vertel je de bibliotheek welk nummeringsschema je gebruikt (GPIO.BCM zijn de pinnummers van de SoC) en welke pinnen als in- of output dienst doen: import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) GPIO.setup(2, GPIO.OUT,
initial=GPIO.LOW) GPIO.setup(22, GPIO.IN)
Een oneindige lus zorgt voor een knipperende led: import time while True:
GPIO.output(2, GPIO.HIGH) time.sleep(0.5) GPIO.output(2, GPIO.LOW) time.sleep(0.5)
Een led alleen maar laten knipperen ziet er lang niet zo mooi uit als een subtiele verandering van de helderheid. Dat is verbazingwekkend eenvoudig met pulse-width-modulation (PWM). De Raspberry Pi ondersteunt PWM in de hardware op de pinnen GPIO12, GPIO13, GPIO18 en GPIO19, en emuleert het effect op alle andere pinnen door snel te schakelen via de software. Dit moduleert de pulsbreedte met 50 Hz: GPIO.setup(12, GPIO.OUT) led = GPIO.PWM(12, 50) # 50Hz while True: for dc in range(0, 101, 5): led.ChangeDutyCycle(dc) time.sleep(0.1) for dc in range(100, -1, -5): led.ChangeDutyCycle(dc) time.sleep(0.1)
Als je een PWM-signaal afvlakt met een condensator, kun je spanningen tussen 0 en 3,3 volt in fijne stappen regelen. De optimale capaciteit is afhankelijk van de belasting, aangezien grote stromen grote condensatoren toch snel ontladen. In het algemeen zorgt een grotere condensator voor een vlakkere spanning. Als je het afgevlakte signaal wilt moduleren, moet je de condensator niet te groot kiezen, omdat die dan ook de modulatie afvlakt. Probeer voor je project gewoon verschillende capaciteiten uit.
UITLEESOPTIES
Het uitlezen van GPIO-pinnen doe je met GPIO.input(pinNo). Als de Raspberry Pi op dat moment nog bezig is met andere berekeningen, zal hij het met die functie niet meteen kunnen bijbenen als de spanning op de pin verandert. Dat is op te lossen met de functie
GPIO.wait_for_edge(pinNo, GPIO.RISING).
Die blokkeert de boel totdat de Pi een interrupt vanwege een stijgende flank verwerkt. Aangezien het programma daarbij geblokkeerd is, is het aan te raden om een dergelijke query aan een aparte thread toe te wijzen
(time.sleep(0.1) dient voor het debouncen):
from threading import Thread def ck_btn_forever():
while True:
GPIO.wait_for_edge(26,GPIO.RISING) print("Button pressed") time.sleep(0.1) Thread(target=ck_btn_forever).start()
In plaats daarvan kun je het monitoren natuurlijk ook aan de bibliotheek overlaten en bij een event dan een callable uitvoeren, in het onderstaande voorbeeld een lambda-functie: GPIO.add_event_detect(
22, GPIO.RISING, callback=lambda _: print( "<- Switch to the left."))
GPIO.add_event_detect( 10, GPIO.RISING, callback=lambda _: print( "-> Switch to the right."))
SERIËLE INTERFACES
De Raspberry Pi stelt op zijn pinheader ook twee SPIinterfaces, een I2C-bus en een seriële verbinding beschikbaar. Via die interfaces kun je meer complexe sensors met eigen intelligentie aansluiten. Via I2C ondersteunt de Raspberry Pi ook chips die nog meer GPIOpinnen toevoegen.
Al die uitbreidingen nemen slechts een deel van de GPIO-pinnen in beslag, zodat er voor elk project nog pinnen over zijn om met een tuimelschakelaar makkelijk tussen modi te wisselen of om met een statusled aan te geven wat de Raspberry Pi aan het doen is.