Aan de slag met de Raspberry Pi 400 (zelfstudie)

Raspberry Pi 400 uitbreidingsconnector

De Raspberry Pi 400 heeft, net als de andere Raspberry Pi’s, een 40-polige connector waar uitbreidingen op aangesloten kunnen worden. De pennen kunnen vanuit de programmeertalen zoals Scratch en Python worden aangestuurd zodat toepassingen met hardware gemaakt kunnen worden.

De uitbreidingsconnector van de verschillende Raspberry Pi modellen is grotendeels gelijk. Dat betekent dat hardware en uitbreidingen tussen de verschillende Raspberry Pi’s uitgewisseld kan worden.

Er zijn veel verschillende uitbreidingen op de markt, variërend van kleine toepassingen zoals leds, tot hele robots en weerstations. Sommige uitbreidingen hebben een speciale vorm die het aansluiten aan de Raspberry Pi 400 bemoeilijken, bijvoorbeeld omdat er gebruik wordt gemaakt van een display dat nu naar achteren wijst en niet door de gebruiker kan worden bekeken. Daarom is het mogelijk om middels een speciale 40-polige kabel uitbreidingen ‘op een afstandje’ te monteren.

De nummering van de pennen loopt van 1 tot 40. Maar we zien in de afbeelding ook een andere nummering gebruikt worden zoals GPIO2, GPIO3 en GPIO4 die niet overeenkomt met de pennumering. De nummers 1 tot 40 wordt de BOARD of fysieke nummering genoemd en de GPIO-nummering de BCM of logische nummering.

Python RPi.GPIO module

Om de digitale pinnen aan te sturen wordt in Python gebruik gemaakt van een speciale module: RPi.GPIO. Het gebruik van deze module is eenvoudig: importeer de module, stel de nummeringswijze (BOARD of BCM) in, stel per te gebruiken digitale pen in, of deze als ingang of als uitgang gebruikt moet worden en gebruik de pennen naar eigen inzicht:

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)      # of GPIO.setmode(GPIO.BOARD)
GPIO.setup(17, GPIO.OUT)    # Stel GPIO17 (fysieke pen 11) in als uitgang
GPIO.setup(23, GPIO.IN)     # Stel GPIO23 (pin 16) in als ingang

GPIO.output(17, GPIO.HIGH)  # GPIO17 aanzetten
GPIO.output(17, GPIO.LOW)   # GPIO17 uitzetten
pin_waarde = GPIO.input(23) # Waarde van GPIO23 inlezen

GPIO.cleanup()              # Herstel de ingestelde waarden

RGB led met Python besturen

Een RGB led is een verpakking met drie losse leds in de kleuren rood, groen en blauw. Elk van de leds is met een elektrische aansluiting met de buitenwereld verbonden. Alle drie de leds hebben een gezamenlijke massa (common cathode). Om de stroom door de led te beperken moet een led zijn voorzien van een voorschakelweerstand. Een module met hierop een RGB led en drie voorschakelweerstanden maakt het ons gemakkelijk om de led op een Raspberry Pi aan te sluiten. Je koopt zo’n module per twee bij de elektronikawinkel. Vier montagedraadjes met aangesoldeerde stekkertjes maken de verbindingen.

Door elk van de drie kleurenleds in sterkte te wijzigen ontstaan de typische regenboogeffecten die we kennen van meerkleurenleds. De RPi.GPIO module heeft speciale voorzieningen voor het aansturen van de pennen met pulsbreedtemodulatie (pulse width modulation of PWM). Hierbij wordt een signaal met een bepaalde instelbare frequentie op de pen aangeboden, bijvoorbeeld 100 Hz. Dit signaal wisselt dan 100 keer per seconde tussen “aan” en “uit”. De helft van de tijd is de led aan en de andere helft is de led uit, maar door de snelle wisselingen merkt ons oog dat niet en lijkt de led vast te branden zonder te knipperen.

Door de verhouding van de aan- en uittijd te veranderen wordt de led meer (langere aan-tijd) of minder (langere uit-tijd) helder. Dit wordt de duty cycle genoemd en wordt uitgedrukt in een percentage 0% (alleen ‘uit’) tot 100% (alleen ‘aan’). Door de helderheid van ieder van de drie kleuren leds los van elkaar in sterke te regelen kunnen een bijna oneindig aantal samengestelde kleuren worden bereikt.

Het principe van het veranderen van de verhouding tussen “aan” en “uit” werkt niet alleen voor leds maar ook bijvoorbeeld voor gelijkstroommotoren die met PWM in snelheid geregeld kunnen worden. In software gaat dat als volgt:

GPIO.setup(17, GPIO.OUT)   # Gebruik GPIO17 als PWM signaalgever
pin17 = GPIO.PWM(17, 250)  # Stel een 250 Hz PWM signaal in op pin 17
pin17.start(0)             # Start het PWM signaal met 0%
pin17.ChangeDutyCycle(50)  # Zet de duty cycle op 50%
pin17.ChangeDrequency(500) # Verhoog de frequentie naar 500 Hz
pin17.stop()

Normaal kies je een hogere frequentie zodat je de aan-uit overgangen niet ziet, maar een lagere frequentie kan prima gebruikt worden om een knipperled te maken:

pin17.ChangeFrequency(0.5) # Stel de frequentie in op 0.5 Hz
                           # De pen gaat nu iedere 2 seconden aan- en uit

Fysieke aansluitingen

De RGB led module is voorzien van vier aansluitpennen: GND, R, G, en B. Deze worden verbonden met de pennen GND (9), GPIO17 (11), GPIO27 (13) en GPIO22 (15) op de uitbreidingsconnector van de Raspberry Pi. Voor de verbindingen tussen de pennen van de Raspberry Pi uitbreidingsconnector en de pennen van de RGB led module kunnen het best flexibele montagedraden met aansluitconnectoren aan beide zijden worden toegepast. Deze verbindingsdraden kunnen los van elkaar getrokken worden (“gesplitst worden”) om de gewenste kleurcodering toe te passen. Het is handig om draadkleuren te gebruiken in overeenstemming met het doel: rood voor rood, blauw voor blauw en groen voor groen.

De maat van de stekkertjes komt precies overeen met de maat van de pennen van de uitbreidingsconnector. Je kunt zelfs de kleine aansluitconnectoren met elkaar verbindingen met een druppel superlijm om een handige stekker te maken, maar nodig is het niet: de stekkertjes blijven prima los zitten.

In de afbeelding hieronder is schematisch weergegeven hoe de verbindingen moeten worden gemaakt en met gekleurde cirkeltjes is aangegeven op welke pennen de verschillende stekkertjes moeten worden aangesloten.

Besturen vanuit een programma

Het volgende Python programma wisselt de kleuren van de led. Er wordt gebruik gemaakt van pulsbreedtemodulatie. Het wisselen van kleuren gebeurt met een aantal lussen om verschillende kleurcombinaties te laten zien. Maak gebruik van de Thonny programmeereditor om het programma zoals hieronder afgebeeld over te nemen.

import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)

RUNNING = True

green = 27
red = 17
blue = 22

GPIO.setup(red, GPIO.OUT)
GPIO.setup(green, GPIO.OUT)
GPIO.setup(blue, GPIO.OUT)

Freq = 100

RED = GPIO.PWM(red, Freq)
GREEN = GPIO.PWM(green, Freq)
BLUE = GPIO.PWM(blue, Freq)

try:
        RED.start(0)
        GREEN.start(0)
        BLUE.start(0)
	while RUNNING:
	        # Lighting up the RGB led. 100 means giving 100% to the pin
		for x in range(0,101):
			GREEN.ChangeDutyCycle(x) # Changes the with of the PWM duty cycle
			time.sleep(0.05)
		for x in range(0,101):
			RED.ChangeDutyCycle(100-x)
			time.sleep(0.025)
		for x in range(0,101):
			GREEN.ChangeDutyCycle(100-x)
			BLUE.ChangeDutyCycle(x)
			time.sleep(0.025)
		for x in range(0,101):
			RED.ChangeDutyCycle(x)
			time.sleep(0.025)
except KeyboardInterrupt:
	# Gracefully exit the RGB lighting loop in order to shut down the lights
	RUNNING = False
	GPIO.cleanup()