Gpio’s op je PC aansturen via een Raspberry Pi Zero

Eén van de leukste functies van een Raspberry Pi is de gpio-header waarop je allerlei elektronische componenten kunt aansluiten. Zou het niet extra leuk zijn als je dat ook op je PC zou kunnen? Dat kan! Door een Raspberry Pi Zero via usb aan te sluiten en hier speciale firmware op te draaien, kun je de gpio-pinnen van je Pi op je Linux-PC aansturen.

Met een Raspberry Pi kun je de gekste makerprojecten uitvoeren dankzij de 40 gpio-pinnen die je de brug naar de elektronicawereld laten overstreken. Je sluit knoppen of sensoren op je Pi aan, leds of relais of zelfs volledige uitbreidingsbordjes (een HAT, pHAT, SHIM of Bonnet) en je software komt pas echt tot leven. Je zult het misschien al vaak jammer gevonden hebben dat je PC geen gpio-pinnen heeft.

Geen nood! Via een omweg kun je ook gpio-pinnen op je PC gebruiken. De Raspberry Pi Zero en Zero W hebben immers een usb otg-poort, die je als ethernetapparaat kunt configureren. En met de software Gpiozero (https://gpiozero.readthedocs.io/en/stable/) kun je ook gpio-pinnen van een Pi via het netwerk aansturen. Combineer beide functies en je kunt dus in Python-code op je Linux-PC de gpio-pinnen van een via usb aangesloten Pi Zero aansturen. De Pi Zero dient dan in feite als een soort interfacebordje voor gpio. En met een prijs van rond de € 5,- voor de Pi Zero is het zelfs een heel goedkope oplossing!

Waarom alleen met de Pi Zero?

De aanpak die we hier bespreken, werkt alleen met de Pi Zero of Pi Zero W, omdat dat de enige Pi-modellen zijn met een usb otg-poort en we daarover een netwerkverbinding opzetten. De wifi gebruiken we niet, omdat we de aangesloten Pi met minimale firmware opstarten die nodig is om de gpio-pinnen aan te sturen. De Pi Zero W biedt in dit geval dus geen meerwaarde boven de Pi Zero en is bovendien dubbel zo duur (rond de € 10,-). Maar je kunt ze perfect gebruiken als je toevallig nog een exemplaar hebt liggen. Het is wel handig als je Pi Zero al een gpio-header heeft; misschien moet je die nog erop solderen (zie ook het kader “Solderen of niet”).

Installatie

We gaan er in dit artikel vanuit dat je op je PC Ubuntu 18.04 LTS draait. Voeg eerst de Raspberry Pi PPA aan je systeem toe:

sudo add-apt-repository ppa:rpi-distro/ppa

Installeer daarna de volgende pakketten:

sudo apt install usbbootgui python3-gpiozero python3-pigpio

De softwarekant is nu klaar.

Pi Zero aansluiten

Aan de hardwarekant is niet veel nodig: alleen je Pi Zero en een microUSB-kabel. Je hoeft zelfs geen microSD-kaart in je Pi Zero te steken. De software rpiboot stuurt immers via usb de vereiste firmware naar je Pi, die daarvan opstart en dan een minimale versie van Raspbian (de van Debian afgeleide officiële Linux-distributie voor de Pi) in het RAM laadt. Het besturingssysteem start dan de daemon pigpio, die toegang geeft tot de gpio-pinnen via de netwerkverbinding over usb.

Sluit je Pi Zero dus via de microUSB-kabel op je PC aan. Doe dat met de microUSB-aansluiting waar ‘USB’ bij staat, niet degene waar ‘PWR’ bij staat. Voer dan in een terminalvenster de volgende opdracht uit:

sudo rpiboot -d /usr/share/rpiboot/gpioexpand/

De directory /usr/share/rpiboot/gpioexpand/ bevat de firmwarebestanden voor de Pi. Het programma rpiboot laat dan in enkele boodschappen zien dat de bootcode naar je Pi wordt gestuurd. Als dat is voltooid, sluit je het programma af en krijg je de opdrachtprompt terug te zien. Je Pi draait nu de aangepaste firmware en maakt zijn gpio-pinnen via het netwerk toegankelijk.

Netwerk testen

De Pi-firmware gebruikt alleen IPv6, dus je Pi is alleen via een IPv6-adres bereikbaar. Kijk met ip address wat de naam van de usb-interface van je Pi is. Waarschijnlijk is het de laatste interface in de lijst, omdat ze net pas is aangemaakt. Bij ons ziet dat er als volgt uit:

8: enp0s20f0u1i2: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000

    link/ether fa:00:fc:31:39:04 brd ff:ff:ff:ff:ff:ff

    inet6 fe80::751d:d87c:900d:d6c2/64 scope link tentative

       valid_lft forever preferred_lft forever

Nu kun je naar je Pi pingen om te zien of de netwerkverbinding het doet:

ping6 fe80::1%enp0s20f0u1i2

Je gebruikt daarvoor het IPv6-adres fe80::1 en plakt het procentteken (%) erachter met daarna de naam van de interface (in ons geval enp0s20f0u1i2). Als alles goed gaat, krijg je antwoorden van de Pi op je ping-pakketjes. Druk op CTRL+C om de ping6-opdracht te stoppen.

Omgevingsvariabelen instellen

Gpiozero maakt gebruik van twee omgevingsvariabelen, die wel handig zijn om in te stellen. Plaats daarom de volgende twee regels in ~/.bashrc:

export GPIOZERO_PIN_FACTORY=pigpio

export PIGPIO_ADDR=fe80::1%enp0s20f0u1i2

Op de tweede regel vervang je het adres uiteraard door dat van jou, inclusief het procentteken en de naam van de interface. Als je daarna een nieuw terminalvenster opent, zijn de omgevingsvariabelen correct ingesteld en is alles klaar om de gpio-pinnen van je Pi aan te sturen.

Aan de slag!

Haal de usb-aansluiting van je Pi Zero nu uit je PC, zodat hier geen spanning meer op staat. We gaan nu als test een led op de Pi aansluiten en die laten knipperen via een Python-script. We creëren daarvoor een eenvoudige schakeling met één led op een breadboard. Neem daarvoor een led, een weerstand van 220 ohm en twee jumperwires. Plaats de led op het breadboard. Verbind de kathode (het korte pootje) via de weerstand van 220 ohm met een GND-pin op de Pi om de stroom door de led te begrenzen. De anode (het lange poortje) sluit je aan op pin BCM26 van de Pi. De locaties en namen van de gpio-pinnen van de Pi vind je op https://pinout.xyz. Bekijk het schema bij dit artikel voor de aansluiting en controleer goed of je alles correct hebt aangesloten voordat je de Pi terug op je PC aansluit.

 De Pi Zero dient als interfacebordje om een led op je pc aan te sluiten.

 Voer de rpiboot-opdracht opnieuw uit om de firmware op de Pi te starten. Het IP-adres blijft normaal gezien hetzelfde, dus dezelfde omgevingsvariabelen blijven werken. Schrijf dan in een bestand de volgende Python-code:

 from gpiozero import LED

from time import sleep

 led = LED(26)

while True:

    led.on()

    sleep(1)

    led.off()

    sleep(1)

Sla het bestand op als gpiozero_blink.py en voer het daarna uit:

python3 gpiozero_blink.py

Als alles goed gaat, zie je nu de led op het breadboard knipperen. Je hebt je eerste elektronicacomponent via je PC aangestuurd! Bekijk zeker ook eens de uitgebreide documentatie van Gpiozero op https://gpiozero.readthedocs.io. Je vindt hier tientallen voorbeelden van Python-code om allerlei elektronische componenten aan te sturen via de gpio-pinnen. En dankzij rpiboot en een Pi Zero kun je dat nu ook op je PC.

Solderen of niet

De Pi Zero en Pi Zero W komen standaard zonder gpio-header gesoldeerd. Je kunt dan op twee manieren elektronische componenten aansluiten. Of je soldeert de componenten rechtstreeks op de gaatjes. Dat is het minste werk, maar wel vrij drastisch: je kunt je Pi achteraf dan niet meer voor andere schakelingen gebruiken, tenzij je de componenten gaat desolderen. Of je soldeert een 40-pins header op de gaatjes. Dat is iets meer werk, maar met wat oefening goed te doen. Je kunt dan jumperwires op de gpio-pinnen aansluiten en dus gemakkelijk tijdelijke opstellingen met een breadboard maken om te experimenteren. Voor wie solderen een brug te ver is, zijn er gelukkig ook versies van de Pi Zero en Pi Zero W te koop met al een gpio-header op gesoldeerd. Die laatste versie staat ook bekend als de Pi Zero WH.

Gpio’s van een Pi uitbreiden

Dezelfde aanpak is ook interessant als je meerdere HAT’s of veel andere componenten op een Raspberry Pi wilt aansluiten en je te weinig vrije gpio-pinnen hebt. Dan sluit je een deel van de componenten op de ene Pi (dat hoeft geen Zero te zijn) aan en een deel op een Pi Zero die via usb otg met de eerste Pi is verbonden. We tonen hier hoe dat in zijn werk gaat en hoe je in één Python-script onder Raspbian gpio’s van twee verschillende Pi’s aanstuurt.

Installeer op je Pi eerst usbbootgui en de andere pakketten zoals we in het begin van het artikel op Ubuntu hebben gedaan. We gaan ervan uit dat Raspbian op je Pi staat. Als je Raspbian Lite gebruikt, dan worden met de installatie van usbbootgui helaas ook heel wat grafische pakketten geïnstalleerd die we niet nodig hebben. Maar de firmwarebestanden die rpiboot nodig heeft om de gpio-pinnen aan te sturen, zitten in het pakket usbbootgui (dat een grafische manier aanbiedt om de firmware te installeren). De PPA hoef je niet te installeren, want de pakketten zitten al in de repository van Raspbian.

Sluit daarna je Pi Zero aan en voer de rpiboot-opdracht uit om de aangepaste firmware op je Pi Zero op te starten. De verbinding testen door te pingen gaat eenvoudig, want de Pi Zero krijgt in Raspbian altijd als interface usb0:

ping6 fe80::1%usb0

Start nu ook de pigpio-bibliotheek als een daemon:

sudo pigpiod

80 gpio-pinnen!

Werkt dit, dan kun je nu in één Python-script de gpio’s van de Pi én die van de Pi Zero aanspreken. We stellen deze keer geen omgevingsvariabele voor het adres in (maar vergeet niet export GPIOZERO_PIN_FACTORY=pigpio in ~/.bashrc te vermelden), maar kiezen in de code telkens welke set gpio’s we gebruiken. Een eenvoudig voorbeeld maakt dit duidelijk:

from gpiozero import LED, Button

from gpiozero.pins.pigpio import PiGPIOFactory

from time import sleep

from signal import pause

pizero = None

while not pizero:

    try:

        pizero = PiGPIOFactory(‘fe80::1%usb0’)

    except OSError:

        sleep(1)

button = Button(26) # knop op de Pi

led = LED(26, pin_factory = pizero) # led op de Pi Zero

led.source = button.values

pause()

We hergebruiken hier ons breadboard met led dat nog altijd op gpio-pin 26 van de Pi Zero is aangesloten. Op de Pi sluiten we (wanneer de voeding niet is aangesloten) een breadboard aan met een knop op gpio-pin 26. In de code zie je dat we zonder aanduiding met pin_factory de gpio-pinnen op de Pi gebruiken en met de aanduiding met pin_factory = pizero de gpio-pinnen op de Pi Zero. We laten de led op de Pi Zero aangaan wanneer je de knop op de Pi ingedrukt hebt. De while-lus in het begin laat het script wachten tot de Pi Zero is aangesloten en de firmware is geïnstalleerd. Met hetzelfde principe als in dit eenvoudige script spreek je maar liefst 80 gpio-pinnen aan.

Met de knop op de Pi besturen we de led op de Pi Zero.

Via een omweg kun je ook gpio-pinnen op je PC gebruiken.

We gaan als test een led op de Pi aansluiten en die laten knipperen via een Python-script.