Sander Schouten
Programmeren van fysieke objecten
met de Raspberry Pi
Wat is de Raspberry Pi
Achtergrond:
De Raspberry Pi is een singleboardcomputer gebaseerd op ARM-processors die tegen een minimale prijs wordt vervaardigd en verkocht.
De Raspberry Pi werd ontwikkeld aan de Universiteit van Cambridge.
De productie is op 10 januari 2012 begonnen.
Doel:
Kinderen kennis te laten maken met programmeren op eenvoudige wijze, zonder dat enorme kosten gemaakt moeten worden.
Door het enorme succes, zijn er tal van toepassingen, en dus ook doelgroepen, bij gekomen.
Voorbeelden van die toepassingen zijn te lezen in het volgende artikel.
Wat zit er op de printplaat:
De Raspberry Pi is dus een computer met al zijn componenten op 1 printplaat gebakken. Deze bevat o.a:
-
Een (ARM) processor
-
Een grafische processor (GPU)
-
Geheugen
-
Netwerk aansluiting
- Wifi
-
USB poorten
- HDMI aansluiting
- Bluetooth (vanaf versie 3)
- SD-kaart lezer
- GPIO poorten
Wat er niet in zit is een harde-schijf, Daarvoor heb je een SD kaart nodig.
Versies:
Inmiddels zijn er al diverse generaties van de Raspberry Pi. Iedere keer is de processor krachterig geworden en zijn de specificaties uitgebreid. Op het moment van schrijven, is de huidige versie 4.
Besturings Systeem:
De Raspberry Pi heeft geen harde schijf, dus ook geen vast besturings systeem. Het besturings systeem hangt af van de gebruikte SD kaart. Je kan zelf kiezen welk besturing systeem je op een kaart zet, zo kan je makkelijk en snel wisselen van toepassing. Dit geeft heel veel flexibiliteit.
Aansluiten:
Een Raspberry Pi heeft 5.1V stroom nodig. Dat gebeurd via een adapter die je aansluit aan de USB-C (versies ouder dan 4 gaan via micro-usb) aansluiting van de Pi. De aangeraden hoeveelheid stroom is 3 A (voor versie 3 is dat 2.5 A).
De Raspberry Pi kan je aansluiten op een TV of monitor via een HDMI kabel.
Een toetsenboord en/of muis sluit je aan op een van de USB poorten.
Overige feiten:
- Goedkoop (vanaf 40 euro)
- Klein van voormaat
- energie zuinig
- Aan te sluiten op je tv of monitor maar ook zonder te gebruiken (headless).
- Niet z’n krachtige processor vergeleken met een standaard computer.
Samenvatting:
Kortom, het is een kleine goedkope computer met vele leuke toepassingen, maar die (nog) niet snel en krachtig genoeg is om als volwaardige PC te gebruiken.
Raspberry Pi toepassingen
Een Raspberry Pi is geen volwaardige PC, het heeft te weinig rekenkracht voor hedendaagse (wat zwardere) toepassingen, zoals video bewerking en het spelen van de hedendaagse spellen. Al wordt dit wel steeds beter met iedere nieuwe generatie (versie).
In dit atrikel laat ik een aantal toepassingen zien waar een Raspberry prima voor gebruiken kan worden.
TIP: Door voor iedere toepassing een ander SD kaartje te gebruiken kan je later makkelijk schakelen tussen deze toepassingen zonder hiervoor een 2e Raspberry Pi te hoeven aanschaffen.
1. Desktop
Het meest gebruikte (officiele) besturings systeem voor de Raspberry Pi is "Raspberry Pi OS" (voorheen Raspbian). Deze komt met een Desktop en een aantal aanbevolen, reeds voorgeinstalleerde, applicaties.
Er zijn natuurlijk ook andere distributies met een Desktop die je kan gebruiken, maar deze is geoptimaliseerd voor de Raspberry Pi.
Enkele standaard applicaties:
- Web-browser
- Mail client
- (Libre) office
- Scratch (programmeer taal)
- Python (programmeer taal)
Dus met de reeds geinstalleerde applicaties kan je surfen op het internet, E-mails lezen en versturen, documenten typen, en .. programmeren, lees hier meer over in het volgende topic.
2. leren programmeren
De raspberry Pi was oorspronkelijk bedoelt om kinderen te leren programmeren. Dat zie je ook terug in de reeds geinstalleerde programma's op "Raspberry Pi OS".
Een van deze programma's is de programmeer omgeving "Scratch".
Scratch is een visuele programmeertaal,
het werkt met blokjes (slepen) in plaats van tekst en het is beschikbaar in het Nederlands.
De taal is geschikt voor het maken van visualisaties zoals interactieve verhalen, animaties, spellen, muziek en kunst en richt zich speciaal op jonge mensen vanaf 8 jaar. Maar het is stiekem ook heel leuk voor volwassenen.
Naast scratch bevat het OS ook ondersteuning (tools) voor de programmeer taal Python.
Python is de (op tekst gebaseerde) taal die tegenwoordig gebruikt wordt om te leren programmeren. Dit komt omdat
Python is ontwikkeld met het oog op leesbare code. Met weinig woorden kan men veel zeggen.
Daarnaast is het is een van de meest gebruikte (multi-purpose) programmeer talen en blijft groeien in populairiteit. Leuk feitje, het is ontwikkeld door de nederlander Guido van Rossum.
Om het gebruik van Python op een Raspberry Pi nog meer te simuleren hebben ze "Minecraft" omgezet naar Python, zodat je minecraft niet alleen kan spelen op de Pi, je kan er zelf ook in programmeren, door bv je eigen bouwstenen te maken.
Scratch en Python kunnen op iedere computer worden geinstalleerd, niet alleen op een Raspberry Pi.
3. Media (center)
Voor z'n kleine computer heeft de Raspberry Pi best wel een krachtige grafische processor (GPU). Dat blijkt uit de volgende toepassing, het afspelen van media.
De Raspberry Pi kan films afspelen in FULL HD. Samen met de HDMI aansluiting, maakt dat hem geschikt te gebruiken als media speler.
Dat kan op 2 manieren:
Waarschuwing:
Het wordt sterk aan te raden om hiervoor de nieuwste Raspberry Pi versie te gebruiken (minimaal 3 of hoger) voor een goede ervaring.
Niet alle video formaten kunnen goed worden afgespeeld, zo kan een Pi niet "transcoden" (omzetten naar een formaat, geschikt voor het doel apparaat) in geval van PLEX.
1. Als media center rechtstreeks aansluiten aan je TV (via HDMI).
Hiervoor kan je bv KODI gebruiken op de Raspberry Pi..
Kodi is een Media center, zowel voor je eigen content (films, muziek en foto's) als van bronnen op het internet.
Het makkelijkste is door gebruik te maken van een distributie zoals LibreElec of OMSC. Dan hoef je die alleen nog maar de image te downloaden en die te schrijven op een DS kaart.
2. Als media server op je thuis netwerk.
Het voordeel hiervan is dat je overal in huis de media kan bekijken, het nadeel is dat je client software (app) moet installeren op ieder apparaat waar op je wilt kijken. Het is dus vergelijkbaar aan b.v. Netflix, maar dan met je eigen content.
Hiervoor kan je bv PLEX gebruiken.
Het enige wat je hoeft te doen is een distributie van PLEX voor de Raspberry Pi op een SD kaartje te zetten, en de Raspberry Pi aan het thuisnetwerk aan te sluiten via een netwerk kabel (aanbevolen) of Wiki. Koppel dan een Externe harde schijf aan de Pi en je bent klaar. (via een browser kan je PLEX verder configureren).
4. Webserver
Naast Media server, kan een Raspberry Pi ook worden gebruik als andere soorten servers, waaronder een webservice. Door je Raspberry Pi in te richten als webservice kan je je eigen websites hosten.
Om je website beschikbaar te stellen vanaf het internet, zal je nog wel wat extra's moeten doen, zoals het regelen van een domein naam en vast IP adres van je provider, en je router intellen zodat de raspberry Pi en poort 80 toegankelijk worden van buiten af.
Let op, ook hier geld, een webserver op een Raspberry Pi minder goed presteerd als bij een hosting provider. Maar als je je eigen website in een testomgeving wilt beheren en hosten of zelf bestanden beheert en wilt delen in de cloud, dan kan dat prima.
Een veel gebruikte configuratie voor een webserver op een Raspberry Pi is LAMP. LAMP is het acroniem voor een pakket dat uit de volgende onderdelen bestaat: een Linux-besturingssysteem (het standaard Raspberry Pi OS, Raspbian), een Apache-webserver, een MySQL-database en de scripttaal PHP.
Daarnaast is het zelfde mogelijk om een website builder te installeeren zoals WordPress
Behalve voor websitehosting, kan de webserver ook worden gebruikt voor vele andere zaken. Zo is het mogelijk om de webserver van de Raspberry Pi als privé data- en mediaserver te gebruiken. Je kunt er ook met de gratis software ownCloud een eigen cloud kunnen inrichten en beheren. Met het filehosting-programma kun je o.a. data in de cloud opslaan, oproepen en synchroniseren. De lijst van projecten die met een Raspberry Pi-webserver kunnen worden uitgevoerd is lang; met je eigen webserver heb je het heft in eigen handen.
5. Spelcomputer
De Raspberry Pi is niet krachtig genoeg voor de hedendaagse spellen, maar is wel krachtiger dan de oude spelcomputers van vroeger.
Daarom zijn er vele "emulators" van de vroegere game consoles, voor de Raspberry Pi. Wil je ze allemaal en met een eenvoudige image al voor geinsalleerd, ga dan eens kijken naar Retro Pi.
Retro Pi is gebaseerd op Raspbian, en bevat een verzameling projecten, o.a. EmulationStation en RetroArch die er voor zorgen dat je jouw favoriete clasieke spellen kunt spelen met minimale configuratie.
Je kan hiervoor een toetsenboard gebruiken, maar voor een echte retro game ervaring gebruik je een joystick. Dat kan zowel via USB als via Bluetooth (vanaf versie 3).
Emulators weken niet zonder Roms'.
Bij de oudere console spellen kwamen de spellen vaak in de vorm van een cartridge. Z'n cardridge was vast geheugen dat alleen te lezen was, dat noemen we ROM (Read Only Memory).
Als die data (het spel) van z'n cardridge werd gehaald als een soort backup, dan noemen we dat dus “ROMs”. Inmiddels wordt het wat algemener gebruikt als benaming voor een retro spel.
Iedere ROM is dus specifiek gemaakt voor een game console (specifike hard- en software), dus kan je niet zomaar draaien op een andere computers. Daar heb je dus een Emulator voor nodig die een specifieke game console simuleert waardoor je alsnog die ROM's kan spelen.
ROM's kan je vinden op het internet, maar hier gelden vaak nog wel autheurs rechten voor. Dus je dient dan wel het originele spel te hebben om de ROM te mogen spelen op bv de Raspberry Pi.
6. Thuis automatisering
Tegenwoordig hebben we allemaal slimme apparaten in huis, die je op afstand kan instellen en bedienen.
Of het nu via infra rood (afstandsbediening), Bluethoot of Wifi is. Er zijn diverse commerciele systemen om al die apparaten vanuit 1 centraal punt aan te sturen en in te regelen. Bijvoorbeeld het systeem herkend dat je thuis bent (omdat je telefoon verbinding maakt met het thuis netwerk), dan gaat het licht aan, en wordt je favoriete playlist afgespeelt.
Maar dit kan je ook zelf bouwen met behulp van een Raspberry Pi, software en eventueel met een paar sensoren. Ook zijn en speciale modules te koop om in 1 keer vele opties
Je zou je eigen software kunnen schrijven, maar er zijn al een aantal open source projecten die je zo kan gebruiken, zoals Home Assistent en OpenHAB
7. Robotica
Iets waar de Raspberry Pi ook echt voor bedoelt is, naast het leren programmeren is Robotica.
De Raspberry Pi is klein, licht, verbruikt weinig stroom en is makkelijk uitbreidbaar via de GPIO poort.
De GPIO (General Purpose Input Output) poort is een set van digitale aansluit-pins die ieder configureerbaar is als Input of Output. Op deze pins kun je sensoren en actuatoren aansluiten.
Sensoren zijn de zintuigen binnen de electronica. Een sensor neemt waar en geeft een signaal door.
Iedere sensor heeft zijn eigen functie en kan verschillende dingen.
De meest eenvoudige sensor is een schakelaar die reageerd op het indrukken van een knop, die dan 'aan' of 'uit' terug geeft.
Maar er zijn ook veel slimmere sensoren zoals een temperatuur-sensor, licht-sensor, beweging-sensor, druk-sensor, afstand-sensorm, enz.
Sensoren zijn dus de INPUT van een systeem, net zoals bij een computer de muis, toetsenboard, webcam, joystick, scanner, etc.
Een actuator is dus precies wat een sensor niet is. Een actuator reageerd op een signaal, het doet dan een handeling (act).
De meest eenvoudige actuator is een led, die je met het sturen van een signaal (stroom), aan of uit kan gaan.
Andere actuators kunnen zijn een motor, scherm, speaker (afspelen van een geluid) of een andere schakelaar aansturen.
Actuatoren zijn dus de OUTPUT van een systeem, net zoals bij een computer de monitor, printer, speakers.
Je kan programma's schrijven die luisteren naar sensoren (input) en die actuatoren aansturen (output), en dat programma draaien op de Raspberry Pi waar de sensoren en actuatoren op aangesloten zijn.
Klik op "verder" om zelf aan de slag te gaan met deze toepassing.
Raspberry Pi workshop voorbereiding
Benodigde hardware voor deze Workshop:
-
1 Raspberry Pi (Rpi) 2 of hoger (deze workshop is nog niet getest met een Raspberry Pi 4)
-
1 (micro) SD kaart, met Raspberry Pi OS (Raspbian).
- Sensoren, actuatoren, breadbord en kabeltjes (afhankelijk van de opdracht).
Aansluiten opties:
- rechtstreeks op de Raspberry: een voedings adapter, voor de RPi, scherm (tv of monitor met HDMI ingang), HDMI kabel en toetsenbord.
- via TTL console kabel: PC/Laptop (Windows, Mac of Linux) en 1 TTL Console kabel (5V).
- via het lokale wifi netwerk: PC/Laptop (Windows, Mac of Linux) en een voedings adapter voor de RPi
Stap 1: Software installeren op je pc/laptop
Voor optie 1 is geen extra software benodigd. Je werkt rechtstreeks op de Raspberry Pi.
In geval van optie 2:
Op de pc/laptop dient het volgende te worden geïnstalleerd:
-
PL2303 Drivers, hierdoor wordt de TTL kabel herkend en kan worden gebruikt voor seriële communicatie. deze zijn hier te downloaden:
-
Applicatie voor seriele communicatie.
- Windows - putty
- Mac OS X (niet nodig)
- Linux (niet nodig)
In geval van optie 3:
Op de pc/laptop dient het volgende te worden geïnstalleerd:
-
Applicatie voor SSH communicatie.
- Windows - putty
- Mac OS X (niet nodig)
- Linux (niet nodig)
Stap 2: SD kaart voorbereiding
Voor deze workshop gaan we een image beschikbaar stellen waar de voorbeeld programma’s al op staan. (NOG NIET KLAAR)
Om deze image te gebruiken, volg dan de volgende stappen:
- Download de image (komt er aan).
- Windows
- Download en installeer Win32DiskImager.
- Stop een (lege) SD kaart in de SD card reader.
- Open Win32DiskImager en Select de workshop image
- Kies de drive letter van de SD kaart * waar de de image naar toe wilt schrijven.
- Click "Write".
- Mac OS X
- TODO
- Linux
- Stop een (lege) SD kaart in de SD card reader.
-
vind de SD kaart met het volgende commando: sudo fdisk -l. schrijf deze naam op. Wij gaan er even vanuit dat het /dev/sdx is.
-
Unmount de partities door het volgende commando uit te voeren: sudo umount /dev/sdx*. Het kan een error geven dat de kaart niet gemout is, dat is prima.
-
Kopieer de inhoud van de image op de SD met het volgende commando:
sudo dd bs=1M if=your_image_file_name.img of=/dev/sdx
*) Waarschuwing Er is een groot risico dat je je systeem beschadig als je de verkeerde drive letter kiest. Weet zeker dat je de drive letter van de SD kiest.
Wil je geen gebruik maken van de workshop image maar heb je nog geen SD kaart met Raspbian of Raspberry Pi OS, volg dan de volgende stappen:
- Download de laatste versie van Raspberry Pi Imager en installeer deze.
- Stop een (lege) SD kaart in de SD card reader.
- Open Raspberry Pi Imager en kies Raspberry Pi OS (maakt niet uit welke)
- Kies de SD kaart * waar de de image naar toe wilt schrijven.
- Controleer je keuzes en click 'WRITE'.
*) Waarschuwing Er is een groot risico dat je je systeem beschadig als je de verkeerde drive letter kiest. Weet zeker dat je de drive letter van de SD kiest.
Github
De code van de opdrachten staan ook op github. Deze zijn hier te downloaden
Stap 3: de Raspberry Pi aansluiten
Dit is het moment dat we de Raspberry Pi gaan aansluiten. Er zijn hier 3 opties:
Optie 1: Adapter, scherm en toetsenbord.
Door de RPi via een HDMI kabel aan een tv of monitor te sluiten, te voeden met een adapter en te bedienen met een toetsenbord, heb je een volwaardige computer setup. Dan kan je rechtstreeks op de RPi werken.
Ga direct door naar stap 4.
Optie 2: TTL console kabel (5V)
Met deze kabel kun je een seriële communicatie opzetten met je pc/laptop. Deze kabel levert ook stroom voor de RPi, een USB voeding adapter is dan ook niet nodig, sterker nog: sluit nooit beide aan!!
Voordeel van deze optie is dat je geen extra monitor en toetsenbord nodig hebt. Je maakt gebruik van de toetsenbord en scherm van je pc/laptop.
Nadeel is dat je een TTL kabel nodig hebt en deze drivers moet installeren. Ook heb je bv putty nodig om over deze kabel met de RPi te communiceren.
Optie 3: Netwerk
Als de Raspberry Pi aan het netwerk is gekoppeld, en het IP adres is bekend, dan kan je een terminal sessie starten met SSH.
Voordeel van deze optie is dat je geen extra monitor en toetsenbord nodig hebt. Je maakt gebruik van de toetsenbord en scherm van je pc/laptop.
Nadeel is dat je een Wiki netwerk moet hebben (of een hub/switch via een UTP kabel) waar je zowel je PC/laptop als de RPi op aan kan sluiten
Stap 3 - optie 2: aansluiten via TTL
Deze stap is alleen nodig als je gebruik wilt maken van de TTL kabel!
In het eerste plaatje hier onder zie je de TTL kabel, die bevat aan de ene kant een USB connector, en aan de andere kant 4 kleuren pin connectors. Sluit deze pins aan op de GPIO poort (zie hoofdstuk 5) van de Raspberry Pi volgens het 2e plaatje.
De TTL conole kabel.
Aansluiten van de TTL pins aan de GPIO port van de RPil.
-
De rode draad aan de 5V (voeding)
-
De zwarte draad aan GND (aarde)
-
De witte draad aan TxD (trancieve) GPIO 14 (UART)
-
De groene draad aan RxD (recieve) GPIO 15 (UART)
Sluit nu de USB kabel aan op de pc/laptop en als het goed is aangesloten moet de Pi power led gaan branden.
Voor windows gebruikers: Het device zal nu worden toegevoegd aan de device manager op de PC/latop, let op welke com poort de Pi krijgt toegewezen.
Connectie maken met de PRi vanaf Windows
Indien je de com poort niet weet die aan de Pi is toegewezen, open dan je Device Manager vanuit de Control Panel onder System, of rechter muis op Computer -> properties -> Device Manager.
Kijk welke ‘Port’ er achter de Profilic USB-to_serial staat. In dit voorbeeld is het COM5.
Start Putty en maak een seriële connectie over je COM poort en speed 115200 (baud).
klik je op ‘Open’ om een connectie te maken, en druk op ENTER om te beginnen met communiceren.
De gebruikersnaam is: pi
Het wachtwoord is: raspberry
Nu ben je ingelogd op de Raspberry Pi.
Connectie maken met de RPi vanaf LINUX
Open een terminal en voer de volgende commando's uit. Vervang de parameters afhankelijk van jouw machine:
$ lsusb
..
Bus 001 Device 016: ID 067b:2303 Prolific Technology, Inc. PL2303 Serial Port
..
$ modprobe usbserial vendor=0x067b product=0x2303
$ dmesg | grep 'ttyUSB'
[320948.120316] usb 1-1: pl2303 converter now attached to ttyUSB0
$ sudo chmod 777 /dev/ttyUSB0
$ cu -l /dev/ttyUSB0 -s 115200
Connectie maken met de RPi vanaf MAC OS X
Open een terminal en volg de volgende stappen. Vervang de xxxx met de waarde afhankelijk van jouw machine:
Stap 1: open de directory van je devices
$ cd /dev
Stap 2: toon alle devices, en ga op zoek naar een regel die begint met cu.usbserial-xxxx:
$ ls
Stap 3: Start de seriele verbinding (console) met de RPi via de TTL met 115200 baud :
$ screen cu.usbserial-xxxx 115200
Stap 3 - optie 3: benaderen via het netwerk
Deze stap is alleen nodig als je de rapsberry pi vanaf het netwerk wilt benaderen.
Zorg dat je raspberry Pi is aangesloten op het zelfde netwerk als je pc/laptop, en dat je het ip adres weet.
Zorg ervoor dat SSH enabled is op de RPi (als je de workshop image gebruikt, dan is deze stap niet nodig).
Open je SSH client, om verbinding te maken met je Rpi op zijn IP adres. (zie stap 1: software installeren).
Voor Linux en MAX OS X, kan het via de command line via:
ssh pi@<ip adres>
Met putty (windows):
1. Kies connectie type SSH
2. Geef het ip adres op
3. Optioneel kan je de verbinding een naam geven en opslaan voor hergebruik
4. Klik op de "Open" knop om de verbinding te openen.
Stap 4: Software installeren op de RPi
Plaats de micro SD met Raspberry Pi OS in de Raspberry Pi (zie onderkant).
Indien je gebruik maak van de workshop image, ga door naar stap 5.
Indien je geen gebruik maakt van de workshop image dan hoef je ook nog niets te installeren, zolang je python gebruikt. Wil je opdrachten maken in bijvoorbeeld Java of node.js, dan staan bij die opdrachten wat je moet installeren.
Stap 5: maak kennis met de GPIO
GPIO, General Purpose Input Output pinnen, zijn pinnen die je kunt verbinden met allerlei elektronica en apparatuur. Een pin wordt ook wel een poort genoemd (iets wat open en dicht kan). Iedere pin kun je zelf, vanuit de Raspberry Pi, aansturen en controleren. Je kunt simpel gezegd, een pin aan of uitzetten. Zo kun je bijvoorbeeld een lampje aan en uit zetten, zelfs een motor aan zetten. Je kunt ook een pin aansluiten op een component om iets uit te lezen.
Een aantal pins hebben een vast functie (soms ook dubbele functie), andere zijn vrij om te gebruiken als input of als output, die enkel zijn aangeduid met GPIOXX.
In het schema hier naast zie je de betekenins van iedere pin.
Hou dit schema (of onderstaande link) paraat voor de opdrachten, want de GPIOXX namen ga je gebruiken om een signaal naar toe te sturen of uit te lezen in je code.
Stap 6: maak kennis met breadboard
Als je tijdelijke electronische schakelingen gaat maken (prototype), in tegenstelling tot een printplaat waar de verbindingen vast staan, kan je het beste gebruik maken van een zogenaamd breadboard.
Met een dergelijk board kan snel en eenvoudig een schakeling worden opgebouwd zonder te solderen.
Een breadboard bestaat uit vele gaatjes (female) in rijen, die onderling aan elkaar geschakeld zijn. Dit helpt je om electronische circuits te maken.
Hier onder zie je hoe de onderliggende verbindingen zijn.
A en D zijn zogenaamde voedings lijnen (horizontaal). die gebruikt kunnen worden voor de - en + stroomen.
B en C zijn de schakel lijnen die verticaal lopen. die kunnen gebruikt worden om componenten aan te sluiten.
Opdracht 1
een led laten branden
Benodigdheden:
-
1 half-Breadboard
-
een LED lampje
-
een weerstand van 330 Ohm
Let op de kleurcode: oranje – oranje – bruin (-goud)
-
twee male-to-female kabeltjes
Aansluiten electronisch circuit:
- Plaats de LED ergens op het bord, zorg er voor dat de pootjes ieder een eigen (horizontale) baan hebben volgens de afbeelding.
- Bevestig de weerstand: Eén poot in de zelfde baan als korte poot van de LED, de andere op een van de buitenste (verticale) banen van het breadboard. De richting maakt hier niet uit.
- Sluit een draad aan op de GPIO: de 3e pin rechts: GND (Ground, aarde, 0 Volt) en verbind deze met het breadboard op de zelfde (verticale) baan als de weestand.
- Sluit een draad aan in de zelfde kolom als de lange poot van de LED en het andere uiteinde aan de
1e pin links: 3,3 Volt.
Let op! Sluit de led goed om aan! Een Led is namelijk een diode, die laat stroom in 1 richting door. Als de led verkeerd om wordt aangesloten, dan wekt de led niet (er loopt dan geen stroom).
Er gaat nu 3,3 Volt lopen van de GPIO naar de led, en via de weerstand weer teurg naar aarde. Als alles goed is aangesloten, en de Raspberry Pi staat aan, dan zal de LED gaan branden.
YES! de LED brand, maar wat nu? Hoe zetten we deze weer uit zonder de schakeling te verbreken?
Daarvoor zullen we de schakeling iets moeten aanpassen en starten met programmeren. Op naar de volgende opdracht!
Opdracht 1 (Python)
3 leds en een button
Benodigdheden:
-
1 half-Breadboard
-
6 set Male-female wires
-
1 Male-male wires
-
3 Leds (verschillende kleuren)
-
1 Button
-
3x 100 Ω weerstanden (voor leds)
-
1x 10K Ω weerstand (voor de button)
Bouwen van het electronisch circuit
Nu kan je echt aan de slag met het bouwen van het onderstaande circuit op je breadboard. Let op de kleur codes van de weerstanden. Daarnaast zijn er 2 type draadjes, male-male voor verbindingen op het breadboard, en male-female voor verbindingen tussen de GPIO en het breadboard.
Weerstanden: Er worden 2 verschillende weerstanden gebruikt, 100 ohm voor de led (des te hoger de weerstand, des te lager de stroom die er zal lopen en minder fel de led zal branden), en 10K ohm voor de button. De kleur ringen op een weerstand geven de waarde aan.
Sluit het citcuit op de volgende manier aan:
-
Sluit de 3,3V pin aan op de buitenste baan (+).
-
Sluit de GND pin aan op de binnenste baan (-).
-
Sluit een pootje van de button aan de baan van de voeding (rood).
-
Sluit een pootje van de button, via een 10K ohm weerstand, aan de GND (-) .
-
Sluit GPIO 21 aan de poot en weerstand van de button (blauw).
-
Sluit de korte poten van de leds, via een 100 ohm weerstand, aan de GND (-).
-
Sluit GPIO 20 aan de positieve-zijde (lange poot) van een van de leds (geel).
-
Sluit GPIO 16 aan de positieve-zijde (lange poot) van een van de leds (groen).
-
Sluit GPIO 12 aan de positieve-zijde (lange poot) van een van de leds (oranje).
Let op! Sluit de led goed om aan! Een Led is namelijk een diode, die laat stroom in 1 richting door. Als de led verkeerd om wordt aangesloten, dan wekt de led niet (er loopt dan geen stroom).
De programmeertaal Python
Voor deze opdracht gebruiken we de programmeer taal Python.
Python is een programmeertaal die begin jaren 90 ontworpen en ontwikkeld werd door de nederlander Guido van Rossum. De filosofie achter Python omvat het schrijven van leesbare code, met effectieve syntax, zodat je sneller kan ontwikkelen. “Met weinig woorden kan men veel zeggen”.
Python wordt beschouwd als een programmeer taal die makkelijk te leren is, en daarom gezien als ‘de’ programmeer taal voor op de Raspberry Pi. Raspbian wordt dan ook al standaard geleverd met Python. Ook bevat deze distributie al de RPi.GPIO package, zodat je vanuit python direct de GPIO poorten al kan gebruiken.
Links:
Hello world
De eerst opdracht bestaat uit het laten branden van een led, dit is de ‘Hello World” van de elektronica, en hiermee test je of je het circuit (met de led) goed hebt aangesloten. Tevens geeft dit aan dat je maar met een paar regels code een led kan besturen.
1. Start python (sudo, omdat je rootrechten nodig hebt om de GPIO poorten te gebruiken)
sudo python
2. Import de RPi GPIO library zodat we gebruik kunnen maken van GPIO.
>>> import RPi.GPIO as GPIO
3. Set de pin nummering mode (opties zijn BOARD of BCM), wij gebruiken BCM. Dat betekend dat we de pin namen gebruiken in het formaat GPIOXX, waarin XX het nummer van de pin is die we willen gebruiken. Zie hiervoor de GPIO nummering.
>>> GPIO.setmode(GPIO.BCM)
4. Definieer GPIO 20 als output, zodat we daar een signaal naar toe kunnen sturen.
>>> GPIO.setup(20, GPIO.OUT)
5. Zet de waarde van GPIO 20 aan/hoog/waar (3,3V), dat is het signaal, zie dat de led gaat branden!
>>> GPIO.output(20,True)
6. Zet de waarde van GPIO 20 nu weer uit/laag/onwaar (0V), zie dat de led weer uit gaat.
>>> GPIO.output(20,False)
7. Geef alle GPIO poorten weer vrij (stap 6 had ook kunnen worden overgeslagen, want dit brengt de poorten terug naar de default, en dat is in dit geval ook laag). Dit voorkomt vreemd gedrag in de volgende opdrachten.
>>> GPIO.cleanup()
8. Stop de python sessie met CRTL+D
Blink 3 leds
Nu laten we niet 1, 2 maar alle 3 de leds een voor een branden, net een stoplicht.
Ook drukken we tekst af op het scherm van de gebruiker, dat doen we met het wordt "print", wat we er achter zetten wordt op moment van uitvoeren op het scherm afgedrukt.
Gebruik van scripts
In de vorige opdracht, hebben we de CLI (command line interface) van Python gebruikt. Hierin hebben we regels code geschreven, die regels samen noemen we een Python script. Als we die zouden opslaan, dan kunnen we die code steeds opnieuw uitvoeren.Dus laten we nu eens een bestand met een python script uitvoeren.
*Command line editors
Op Raspbian heb je de keuze tussen de command line editors ‘nano’ en ‘vi’. Deze zitten al standaard in de Raspbian distributie. Vim en Emacs zijn niet standaard meegeleverd.
Vi werkt niet goed via deze terminal emulator (TTL driver). Daarom wordt nano aangeraden.
De opdracht bestanden voor python staan op /home/pi/opdrachten/python (~/opdrachten/python).
1. Ga vanuit je home directory naar de folder “python”:
cd opdrachten/python
2. Open “blink3Leds.py” met de command line editor nano *, bekijk de code en probeer deze te begrijpen:
nano blink3Leds.py
3. Sluit nano af met CRTL + X
4. Voer het programma uit:
sudo python blink3Leds.py
Sudo is hier nodig omdat je rootrechten nodig hebt om de GPIO poorten te mogen gebruiken.
5. Als je circuit goed is opgebouwd zal je de leds 1 voor 1 aan en uit zien gaan. Ook zie je op je scherm de stappen worden afgedrukt.
Het programma stopt uiteindelijk vanzelf.
Tip! Ruim altijd de GPIO poorten weer op met GPIO.cleanup() voor het programma is geëindigd. Anders blijft de poort bezet en krijg je een error/warning wanneer je deze poort opnieuw probeer te benaderen.
import RPi.GPIO as GPIO # importeer de GPIO bibliotheek. import time # importeer de 'time' bibliotheek. GPIO.setmode(GPIO.BCM) # je kan kiezen tussen BOARD and BCM pin-nummering. GPIO.setup(20, GPIO.OUT) # geef aan dat pin 20 een output is (led). GPIO.setup(16, GPIO.OUT) # geef aan dat pin 16 een output is (led). GPIO.setup(12, GPIO.OUT) # geef aan dat pin 12 een output is (led). print "Eerste led" GPIO.output(20,True) time.sleep(2) GPIO.output(20,False) time.sleep(2) print "tweede led" GPIO.output(16,True) time.sleep(2) GPIO.output(16,False) time.sleep(2) print "derde led" GPIO.output(12,True) time.sleep(2) print "klaar!" GPIO.cleanup() # De GPIO wordt weer netjes vrijgegeven als het programma wordt afgebroken.
Blink
In deze opdracht gaan we een led harhaaldelijk aan en uit zetten (knipperen). Als prgrammeur kan je heirvoor gebruik maken van zogenaamde "loops". In dit geval gebruiken we de "for loop": for .. in ..
Ook maken we in dit programma voor het eerst gebruik van een variable.
Een variabele associeert een naam met een waarde (in werkelijkheid een geheugenadres). Die waarde kan wroden uitgelezen en veranderd worden. In onze code is dat de variabele wacht.
Aanpassen van de code
Je kan de programma's aanpassen naar je eigen wensen, probeer eens wat uit.
1. Open het python script, bv:
nano blink.py
2. pas je code aan, bv de waarde van variabele "wacht"
3.Sluiten en opslaan klan met de toetscombinatie CTRL + X.
en beantwoord de vragen voor opslaan.
Voer onderstaande stappen uit:
1. Bekijk de code in nano (pas eventueel de code aan):
nano blink.py
2. Sluit nano af met CRTL + X
3. Voer het programma uit:
sudo python blink.py
4. Zie je de led 10 keer aan en uit gaan?
Het programma stopt vanzelf.
import RPi.GPIO as GPIO # importeer de GPIO bibliotheek. import time # importeer de 'time' bibliotheek. GPIO.setmode(GPIO.BCM) # je kan kiezen tussen BOARD and BCM pin-nummering. GPIO.setup(20, GPIO.OUT) # geef aan dat pin 20 een output is (led). # variable voor de tijd tussen aan en uit. wacht = 0.5 print "begin met 10x kipperen" # druk de tekst af. for x in range(10): # loop: doorloop x, waarbij x van 1 tot 10 loopt. GPIO.output(20,GPIO.HIGH) # zet voltage op de led(pin) zodat de led aan gaat. time.sleep(wacht) # wacht het opgegeven (variable wacht) aantal seconden. GPIO.output(20,GPIO.LOW) # zet geen voltage op de led(pin) zodat de led uit gaat. time.sleep(wacht) # wacht het opgegeven (variable wacht) aantal seconden. print "einde" # druk de tekst af. GPIO.cleanup() # De GPIO wordt weer netjes vrijgegeven als het programma wordt afgebroken.
Blink met input
Met deze opdracht kan je zelf opgeven hoe vaak en hoe lang de led aan en uit gaat. Het programma vraagt hiervoor 2 waarden.
Om input van een gebruiker te vragen maken we in dit voorbeeld gebruik van
raw_input, en hebben we onze code in een methode gezet.
Een methode is een gedeelte van een programma met een naam, eventueel met een of meerdere argumenten. Door de naam van de methode aan te roepen wordt de code in the methode uitgevoerd. Dit maakt het ook makkelijk om code te hergebruiken. In python definieer je een methode met het word def
In ons voorbeeld:
def Blink(numTimes,speed): ...
Hiermee creeren we de methode Blink, met 2 argumenten numTimes en speed.
Voer onderstaande stappen uit:
1.Bekijk de code in nano (pas eventueel de code aan):
nano blinkWithInput.py
2.Sluit nano af met CRTL + X
3.Voer het programma uit:
sudo python blinkWithInput.py
4.Er zullen 2 parameters gevraagd worden, geef naar eigen wens waarden op, of neem het voorbeeld over:
Enter total number of times to blink: 10
Enter length of each blink(seconds): 1
De led zal het aantal keeren branden voor het opgegeven aantal seconden. Iedere keer word naar je scherm geschreven. Het programma stopt uiteindelijk vanzelf.
Mocht je het programma voortijdig willen afbreken gebruik dan CTRL + C. De GPIO wordt dan netjes afgesloten en weer vrijgegeven door de GPIO.cleanup() in het finally blok.
import RPi.GPIO as GPIO # importeer de GPIO bibliotheek. import time # importeer de 'time' bibliotheek. GPIO.setmode(GPIO.BCM) # je kan kiezen tussen BOARD and BCM pin-nummering. GPIO.setup(20, GPIO.OUT) # geef aan dat pin 20 een output is (led). ##Definieer een functie genaamd Blink() def Blink(numTimes,speed): try: for i in range(0,numTimes): print "Iteration "+ str(i +1) GPIO.output(20,True) time.sleep(speed) GPIO.output(20,False) time.sleep(speed) print "Done" finally: # voer uit indien het programma wordt afgebroken GPIO.cleanup() # De GPIO wordt weer netjes vrijgegeven als het programma wordt afgebroken. iterations = raw_input("Enter total number of times to blink: ") speed = raw_input("Enter length of each blink(seconds): ") Blink(int(iterations), float(speed))
Led en een button
Met deze opdracht gaan we de button gebruiken, zolang deze is ingedrukt is de led aan.
We gaan nu pin 21 als input definieren, en zullen deze gaan uitlezen binnen de loop.
We lezen de "state" van de button uit met GPIO.input(21). Als deze is ingedrukt loopt er stroom en wordt dat gezien als True (waar), dat noemen we een conditie (True of False).
Als de button is ingedrukt willen we iets anders den dan als deze niet ingedrukt is, dat doen we met "If <conditie> then..else..." statements. In python wordt de "then weg gelaten, die moet je er maar bij bedenken.
Ook gebruiken we nu een andere loop, de "while loop": while <conditie>.
Deze doorloopt de onderiggende code zolang aan de conditie wordt voldaan. In ons geval veranderd onze conditie nooit, want deze is true, dat noemen we een oneindige loop. Die kan allen worden doorbroken als we het programma stoppen met CTRL + C.
Voer onderstaande stappen uit:
1.Bekijk de code in nano (pas eventueel de code aan):
nano button.py
2.Sluit nano af met CRTL + X
3.Voer het programma uit:
sudo python buttom.py
4. Druk eens op de button, misschien gaat er een lichtje branden.
Breek het programma af met CTRL + C.
import RPi.GPIO as GPIO # importeer de GPIO bibliotheek. import time # importeer de 'time' bibliotheek. GPIO.setmode(GPIO.BCM) # je kan kiezen tussen BOARD and BCM pin-nummering. GPIO.setup(20, GPIO.OUT) # geef aan aan dat pin 20 gebruikt wordt als output (led). GPIO.setup(21, GPIO.IN) # geef aan dat pin 21 gebruikt wordt als input (button). try: while True: # oneindige loop if GPIO.input(21): # als pin 21 hoog is dan: print "Button is on" # print tekst. GPIO.output(20, GPIO.HIGH) # zet voltage op de led(pin) zodat de led aan gaat. else: # anders (dus pin 21 is laag): GPIO.output(20, GPIO.LOW) # zet geen voltage op de led(pin) zodat de led uit gaat. time.sleep(0.1) # een vertraging om kans op debouncing van de button tegen te gaan (een state tussen aan en uit). finally: GPIO.cleanup() # De GPIO wordt weer netjes vrijgegeven als het programma wordt afgebroken.
Disco met 3 leds
De leds gaan willekeurig aan en uit, net een disco! Woop.. Woop!!
Hier gaan we een stapje verder en gebruiken we onderandere een gecombineerde "if ..then ..else". Als je meerdere condities hebt waarop je iets anders wilt gaan doen, kan je een ombinatie maken van "if <conditie>.. else ..", waarbij else en de volgende if gecombineerd worden naar elif (in de meeste programmer talen is dit else if <conditie>..., mar in python houde ze het liever zo kort mogelijk.
Om de disco zo willekeurig mogelijk te maken, maken we gebruik van de bibliotheek
random. Door die te importeren kunnen we gebruik maken van nieuwe functies, zoals:
random.randint(<van>,<tot>), die geeft een willekeuring nummer terug tussen de opgegeven waarden.
Voer onderstaande stappen uit:
1.Bekijk de code in nano (pas eventueel de code aan):
nano disco3Leds.py
2.Sluit nano af met CRTL + X
3.Voer het programma uit:
sudo python disco3Leds.py
4. Geniet van de disco
Breek het programma af met CTRL + C.
import RPi.GPIO as GPIO # importeer de GPIO bibliotheek. import time # importeer de 'time' bibliotheek. import random # importeer de 'random' bibliotheek. GPIO.setmode(GPIO.BCM) # je kan kiezen tussen BOARD and BCM pin-nummering. GPIO.setup(20, GPIO.OUT) # geef aan dat pin 20 gebruikt wordt als output (led). GPIO.setup(16, GPIO.OUT) # geef aan dat pin 16 gebruikt wordt als output (led). GPIO.setup(12, GPIO.OUT) # geef aan dat pin 12 gebruikt wordt als output (led). # methode om de volgende willekeurige led te bepalen. def nextLed(): i = random.randint(0,2) # deze methode geeft een willekeurig getal terug tussen de 0 en de 2. if i == 0: # als i gelijk is aan 0 dan : return 12 # geef de waarde 12 terug. elif i == 1: # als i gelijk is aan 1 dan : return 16 # geef de waarde 16 terug. else : # in alle andere gevallen (dus de waarde is 2) : return 20 # geef de waarde 20 terug. # variable voor de tijd tussen aan en uit. wacht = 0.2 try: while True: # oneindige loop led = nextLed() # roep de methode om de volgende led te bepalen op. GPIO.output(led, GPIO.HIGH) # zet de led (pin van de led) aan. time.sleep(wacht) # wacht het opgegeven (variable wacht) aantal seconden. GPIO.output(led, GPIO.LOW) # zet de led (pin van de led) uit. finally: GPIO.cleanup() # De GPIO wordt weer netjes vrijgegeven als het programma wordt afgebroken.
Het ladder spel
Het is tijd voor een spelletje, het ladder spel!
Het doel van dit spel is om de knop in te drukken als de knipperende led aan is.
Als dat lukt dan gaat de volgende led (trap trede) knipperen, maar dan iets sneller.
Als je mist (de led is op dat moment uit) dan ga je een level (trap trede) omlaag.
Kan jij het einde van de ladder bereiken?
Voer onderstaande stappen uit:
1.Bekijk de code in nano (pas eventueel de code aan):
nano ladder.py
2.Sluit nano af met CRTL + X
3.Voer het programma uit:
sudo python ladder.py
4.Speel het spel
Breek het programma af met CTRL + C.
########################################################################################## ## Ladder Game ## Het doel van dit spel is om de knop in te drukken als de led aan is ## Als dat lukt dan gaat de volgende led (trap trede) knipperen, maar dan iets sneller. ## Als je mist (de led is op dat moment uit) dan ga je een level (trap trede) omlaag. ## Kan jij het einde van de ladder bereiken? ########################################################################################## import RPi.GPIO as GPIO # Import GPIO library import time # Import 'time' library. import random # Import 'random' library # variabelen led1 = 20 # het pinnummer van led 1 led2 = 16 # het pinnummer van led 2 led3 = 12 # het pinnummer van led 3 button = 21 # het pinnummer van de button level = 1 # start met level 1, er zijn 3 levels (3 leds) gameOn = True # zolang deze waar (True) is, loopt het spel ledOn = True # begin met de led aan mode = 1 # game mode (1 = ritmisch, anders willekeurig) prevButtonState = False # bewaar de vorige button state (True, dan was deze ingedrukt) # Setup GPIO.setmode(GPIO.BCM) # gebruik de broadcom pin nummering GPIO.setup(led1, GPIO.OUT) # geef aan dat pin 20 gebruikt wordt als output (led) GPIO.setup(led2, GPIO.OUT) # geef aan dat pin 16 gebruikt wordt als output (led) GPIO.setup(led3, GPIO.OUT) # geef aan dat pin 12 gebruikt wordt als output (led) GPIO.setup(button, GPIO.IN) # geef aan dat pin 21 gebruikt wordt als input (button) # initialisatie GPIO.output(led1, GPIO.LOW) # zet de led uit bij begin van het spel GPIO.output(led2, GPIO.LOW) # zet de led uit bij begin van het spel GPIO.output(led3, GPIO.LOW) # zet de led uit bij begin van het spel # Methode om de led te bepalen aan de hand van het huidige level def getLed(level): if level == 1 : return led1 if level == 2 : return led2 if level == 3 : return led3 # Methode om de tijd dat de led aan of uit gaat te bepalen (moeilijkheid) # bij iedere cycle wordt geluisterd of op de knop is gedrukt # iedere cycle duurt 0.1 seconden def getCycles(level): if level == 1 : cycles = 10 if level == 2 : cycles = 5 if level == 3 : cycles = 2 return cycles # Methode om het volgende level te bepalen (promotie of degradatie) def nextLevel(promotie): global level global gameOn newLevel = level if level == 1: if promotie: newLevel = 2 # een level omhoog print("Raak, -> niveau 2") else: gameOn = False # verloren (spel wordt beeindigd) print("Mis, game over :(") if level == 2: if promotie: newLevel = 3 # een level omhoog print("Raak, -> niveau 3") else: newLevel = 1 # een level omlaag print("Mis, <- niveau 1") if level == 3: if promotie: gameOn = False # gewonnen (spel wordt beeindigd) print("Raak, -> Gewonnen!") else: newLevel = 2 # een level omlaag print("Mis, <- niveau 2") level = newLevel # Methode om te bepalen of de led aan of uit moet (radom) def getLedOn(): global ledOn global mode if (mode == 1): return not ledOn else: if random.randint(0,1) == 1: return True else: return False def isButtonPressed(): global prevButtonState global button result = False buttonState = GPIO.input(button) if buttonState != prevButtonState: if buttonState == True: result = True prevButtonState = buttonState return result try: # hierdoor kan je het spel netjes beeindigen met CTRL + C (zie finally) while gameOn: # GAME LOOP, blijf het spel uitvoeren totdat het spel gewonnen of verloren is maxCycles = getCycles(level) # bepaal het aantal cycles voor dit level (snelheid van de leds) goCycles = True # dit geeft aan of de cycles doorlopen moeten worden, geeft de mogelijkheid uit de cycles te stappen na button press. cycle = 0 # begin weer bij 0 led = getLed(level) # bepaal de led voor dit level ledOn = getLedOn() GPIO.output(led, ledOn) # zet de led aan of uit while cycle < maxCycles and goCycles: # Loop door de cycles heen if isButtonPressed(): # de knop is ingedrukt, en hiervoor nog niet (voorkomt dat je de knop ingedrukt kan houden nextLevel(ledOn) # Promomtie of degratatie goCycles = False # stop door de cycles te lopen, en begin met nieuw level cycle = cycle + 1 # volgende cycle time.sleep(0.1) # wacht even voor de volgende cycles (dit bepaalt de tijd per cycle) finally: GPIO.cleanup() ## De GPIO wordt weer netjes vrijgegeven als het programma wordt afgebroken
Opdracht 2
De temperatuur sensor
Benodigdheden:
-
1x half-Breadboard
-
3x Male-female wires
-
3x Male-male wires
-
1x Temperatuur sensor (DS18B20)
-
1x 4.7K Ω weerstand
Let op! Om de sensor te gebruiken moet ‘OneWire’ (w1) ondersteuning worden ingeschakeld. Als je gebruik maakt van de workshop image is dit al voor je gedaan, anders moet je dit nog doen.
Bouwen van het electronisch circuit
-
Plaats de temperatuur sensor ergens op het board, aangeraden om het schema te volgen. Let goed op hoe om je deze plaatst, let daarbij op de platte kant.
- Plaats dan de weerstand in de baan van de middelste poot van de temperatuur sensor (hou hiervoor nog minimaal 1 gaatje over op die baan), en de andere kant op een vrije baan.
-
Sluit de 3,3V pin aan op de buitenste baan (+).
-
Sluit de GND pin aan op de binnenste baan (-).
-
Sluit de GPIO 04 aan op de baan van de middelste poot van de sensor, maar nog wel voor de weerstand!
-
Verbind de linker poot van de sensor (verticale baan) aan de binnenste horizontale baan, dat is nu de GND (-).
-
Verbind de rechter poot van de sensor (verticale baan) aan de binnenste horizontale baan, dat is nu de 3,3V (+).
- Verbind het ander einde van de weerstand (verticale baan) aan de binnenste horizontale baan, dat is nu de 3,3V (+).
De weerstand (4.7K ohm) wordt gebruikt als ‘pullup’ voor de data-lijn, en is noodzakelijk om de data flow stabiel te houden.
Aangezien de Raspberry Pi geen ADC (Analog to Digital Converter) heeft, dat betekend geen analoge poorten, kunnen we niet direct analoge sensoren gebruiken. Om de temperatuur te meten hebben we dus een digitale temperatuur sensor nodig. Daarom gebruiken we de DS18B20.
Deze chip is klein, maar er zit meer in dan je denkt. Het bevat de speciale 1 draads seriële interface, sturing logica en de temperatuur sensor zelf.
Uitlezen van de temperatuur sensor
De temperatuur sensor meet de temperatuur en schrijft het in zijn register. Via de GPIO poort hebben we nu een seriele toegang tot die gegevens. In deze stap zullen we het device eerst moeten vinden, en dan het register uit gaan lezen.
1. Laat de computer zijn poorten scannen om de temperatuur sensor te vinden:
sudo modprobe w1-gpio
sudo modprobe w1-therm
2. Het resultaat zal zijn dat er een directory (folder) is weggeschreven in
"/sys/bus/w1/devices", ga naar deze directory:
cd /sys/bus/w1/devices
3. Zoek dat de directory op die begint met '28-' (serie nummer van de sensor is bij iedereen anders)
ls
4. Open die directory (kan versneld door "cd 28" te typen en dan op TAB te drukken)
cd 28-xxxx (verander xxxx in het gevonden serienummer)
5 De waarden van de temperatuur sensor (register) worden nu uitgelezen en in een bestand "w1_slave" in deze directory gezet. lees dat bestand met het volgende commando:
cat w1_slave
6. Het resultaat zal wat lastig te lezen zijn, maar als er in de eerste regel YES staat, dan is de temperatuur bepaalt en is die te lezen op de volgende regel: "t=XXXX", in 1/1000 graden Celsius. Dus in het voorbeeld hier naast was het precies 27 graden Celsius.
Temperatuur sensor uitlezen met Python
Laten we het nu de temperatuur gaan uitlezen met een Python programma “thermometer.py”.
Het python programma handelt eventuele fouten af en geeft iedere seconde de temperatuur in graden Celsius. Het programma start met het gebruik van het ‘modprobe’ commando, die nodig is om de seriële interface te starten. De waarden van de sensor worden uitgelezen en in een bestnad gezet (zoals we hebben gezien) met dit programma lezen we die uit.
De opdracht bestanden voor python staan op /home/pi/opdrachten/python (~/opdrachten/python).
1. Ga vanuit je home directory naar de folder “python”:
cd /home/pi/opdrachten/python
2. Voer het programma uit:
nano thermometer.py
import os import glob import time os.system('modprobe w1-gpio') os.system('modprobe w1-therm') base_dir = '/sys/bus/w1/devices/' device_folder = glob.glob(base_dir + '28*')[0] device_file = device_folder + '/w1_slave' def read_temp_raw(): f = open(device_file, 'r') lines = f.readlines() f.close() return lines def read_temp(): lines = read_temp_raw() while lines[0].strip()[-3:] != 'YES': time.sleep(0.2) lines = read_temp_raw() equals_pos = lines[1].find('t=') if equals_pos != -1: temp_string = lines[1][equals_pos+2:] temp_c = float(temp_string) / 1000.0 return temp_c while True: print(read_temp()) time.sleep(1)
Opdracht 3
Het "Simon says" spel
Ken jij het spel “Simon says” nog van vroeger, waarin je moest herhalen welke kleuren in welke volgorde gingen branden? Het begint bij 1, en er komt steeds 1 (random) bij. Onthoud de volgorde, en maak een zo’n lang mogelijke reeks. Indien je het niet juist herhaald, dan ben je af.
1. Voor deze opdracht zal je zelf moeten bedenken hoe het schema aangesloten moet worden. Het is het zelfde als opdracht 1, maar dan met 4 leds en 4 buttons.
Kijk ook naar de code om te zien welke GPIO poorten aangesloten moeten worden.
2. zoals je kan zien is het programma niet af, maak het programma af.
3. Voer het programma uit:
sudo python nomis.py
4. Speel het spel
import RPi.GPIO as GPIO # importeer de GPIO bibliotheek. import time # importeer de 'time' bibliotheek. import random # Import 'random' bibliotheek # Constanten declaratie leds = [20,16,12,7] # array met pinnummers van de leds buttons = [21,6,13,19] # array met pinnummers van de buttons aantal = len(leds) # totaal aantal buttons en leds wacht = 0.5 # de tijd in seconden tussen een led aan en uit. # Setup GPIO.setmode(GPIO.BCM) # je kan kiezen tussen BOARD and BCM pin-nummering. for pin in leds: GPIO.setup(pin, GPIO.OUT) ## Setup the leds to OUT(PUT) for pin in buttons: GPIO.setup(pin, GPIO.IN) ## Setup the buttons to IN(PUT) # Methode om alle leds een x aantal keer te laten knipperen def blinkAll(times): for x in range(0,times): for pin in leds: GPIO.output(pin, GPIO.HIGH) time.sleep(wacht) for pin in leds: GPIO.output(pin, GPIO.LOW) time.sleep(wacht) # Methode om een led 1x te laten knipperen # Color is gelijkt aan de index van de array: 0 ..3 def blink(color): GPIO.output(leds[color], GPIO.HIGH) time.sleep(wacht) GPIO.output(leds[color], GPIO.LOW) time.sleep(wacht) # GAME START blinkAll(1) print "Het spel is begonnen, herhaal de steeds langer wordende reeks. Succes!" sequence = [] gameOn = True # GAME LOOP while gameOn: # voeg een willekeurige led (kleur) toe aan de sequence (0, 1, 2 of 3) # <schrijf hier uw code> # speel de sequence af # <schrijf hier uw code> # Lees de spelers input (buttons), laat de bijbehorende led branden en controleer de input. # <schrijf hier uw code> # GAME END blinkAll(3) print "Game over!" print "Score: ", len(sequence)-1 GPIO.cleanup() ## clean up all the ports that were used
