Raspberry Pi
<meta name="keywords" content="Raspberry Pi, RPi, DS18B20, Python, C, C++"></meta> <meta name="description" content="Mini projects met de Raspberry Pi"></meta>
Raspberry Pi, de 35 euro computer
Het is niet de bedoeling om de zoveelste pagina/blog te starten over de Raspberry Pi. Dit platform is zo hot dat het internet vol staat van blogs en informatie. Toch even een kort overzichtje van wat dit pareltje eigenlijk is en kan.
De Raspberry Pi is een volledige computer voorzien van ARM hoofd-processor, een Broadcomm GPU (grafische versneller) en een BCM2835 voor de low level interfaces (I²C, SPI en 17 I/O pinnen). Hij heeft geen hard disk, maar is wel voorzien van een SD slot. Hierin stoppen we een SD kaart van 4Gb of meer met een volledig operating systeem, typisch Linux, die tevens als storage zal dienen. Je sluit een toetsenbord, muis en scherm via HDMI aan en - tada- een volledige computer met een grafische omgeving met multi-tasking, alle toeters en bellen om -onboard- te programmeren, een webserver op te zetten enz.... Doordat hij een snelle GPU heeft is hij perfect te gebruiken als mediacenter (audio, video, foto's) en kan hij video streamen.
De Raspberry Pi is dus geen microcontroller. Hij kan dan ook niet vergeleken worden met een Arduino. Je kan hem beter vergelijken met een Pentium2 van eind jaren '90. Geen racepaard dus, maar dankzij zijn snelle GPU een stevige multimedia-computer. Het feit dat hij geen microcontroller is heeft zo zijn voor- en nadelen.
Voordelen :
- Alle voorzieningen van een modern operating systeem : ethernet, usb, grafische omgeving, Internet access, ...
- Eenvoudig uitbreidbaar via USB : WIFI, Bluetooth, Hard disks, ....
- Massa's software voorhanden : Editors, Office pakketten, databases, webservers, spelletjes ....
- Oneindig veel programmeertalen
- Veel informatie
Nadelen :
- Zonder een basis-kennis van Linux wordt het moeilijk
- Low-level access van peripherals dient te gebeuren via de kernel (dus met de Linux interfaces)
- Linux werkt met "preemptive multi-tasking", wat betekent dat je echte real-time toepassingen die tijdskritisch zijn niet mogelijk zijn
Persoonlijk denk ik dat de voordelen ruim opwegen tegen de nadelen, en zeker voor 35 eurootjes, maar ja, ik had dan ook al wat Linux achtergrond.
Aan de slag
Oke, genoeg blabla, laten we er in vliegen !
Voor we beginnen
Enkele bedenkingen vooraf.
- GPIO is 3.3 volt : De GPIO poort werkt op 3.3V. Er zit geen interne beveiliging op, dus 5V aan een input pin kan dodelijk zijn voor je RPi. Zeg nu niet dat ik je niet gewaarschuwd heb :-) Gebruik een level converter om tussen 3.3 en 5V te communiceren. Op EBay vind je deze voor een paar dollar.
- Nooit zomaar afzetten : Linux is een Operating Systeem dat redelijk wat in cache doet en dit op gezette tijdstippen wegschrijft. Je RPi gewoon uit het stopcontact trekken kan je SD kaart om zeep helpen. Daarom steeds een "shutdown" doen voordat je de stroom afzet
sudo shutdown -h now sudo > omdat je iets met "root" privileges wil uitvoeren shutdown > het commando -h > "halt" (-r is bv. reboot) now > nu, als jet 10 zou zetten start de shutdown binnen 10 minuten
- Hou je systeem up to date : Linux heeft een heel elegante manier om alle software up to date te houden. Het kan geen kwaad om dit regelmatig te draaien en dan weet je dat alles de laatste (stabiele) versie heeft. Gebruik dan volgende 2 commando's na elkaar en alles wat je geinstalleerd hebt wordt ge-upgrade :
sudo apt-get update sudo > omdat je "root" privileges nodig het apt-get > om nieuwe applicaties te installeren update > zegt dat je van alles wil weten of er een update is sudo apt-get upgrade sudo > omdat je "root" privileges nodig het apt-get > om nieuwe applicaties te installeren upgrade > zegt dat je alles wil naar de laatste versie zetten
De eerste boot
Om de eerste keer te starten heb je een SD kaart (4Gb of meer) nodig waarop je een OS installeert. Ikzelf gebruik Raspbian Wheezy en de installatie was zeer recht-toe recht-aan. Gewoon de instructies volgen op deze website. Als extra hardware heb je nodig : een USB muis, een USB keyboard, een HDMI kabel & scherm (bv. uw TV), een netwerk kabel en een 5V USB voeding. Aansluiten en wachten... Je zal nu zien dat de Raspberry boot, een grafische interface start en dat je moet inloggen (user:pi, password : raspberry)
Niet duidelijk ? Een beginners guide vind je op http://elinux.org/RPi_Easy_SD_Card_Setup
Bediening via de laptop
Een toetsenbord, muis, HDMI scherm ? Eigenlijk zit dat ongeveer allemaal in je laptop. Op internet vond ik 2 manieren om uw laptop te gebruiken voor de bediening van uw RPi.
- Via USB : Een USB kabel, een drivertje op je PC en putty als seriële terminal en klaar.
- Via een netwerk kabel : Een UTP kabel, een kleine aanpassing op de SD kaart en putty en klaar
Ik heb geen van beide zelf geprobeerd, maar het lijken me wel 2 simpele manieren. Binnenkort toch eens effe op de pijnbank leggen.
Remote control
Eigenlijk vind ik (persoonlijk) dat toetsenbord, muis en aansluiting op mijn TV maar omslachtig, zeker omdat ik de Raspberry ook elders wil kunnen gebruiken en ultiem op een mobiele robot. Linux is perfect te bedienen van een remote computer en eigenlijk is dat wat ik wilde doen. Hiertoe zijn een aantal stappen nodig : een vast IP adres en wat software installeren. Laten we dit even nader bekijken.
Netwerk aanpassingen
Omdat ik draadloos wou kunnen communiceren, heb ik een WIFI dongle in m'n Raspberry gestopt. Je kan best eentje kopen die ondersteund wordt door je distributie (in mijn geval Raspbian Wheezy) en dus kocht ik een Logilink bij Conrad. Lap, weeral 8.29€ armer !
Hardware configuratie
Om de WIFI dongle te laten werken moest ik niets doen. Via de grafische interface kan je perfect je thuisnetwerk vinden en configureren. Werkte vlotjes. ALs je toch probelmen hebt zijn er 2 bestanden die je moet aanpassen
sudo nano /etc/network/interfaces
Hierin voeg je een aantal lijnen toe :
auto lo iface lo inet loopback iface eth0 inet dhcpallow-hotplug wlan0 iface wlan0 inet dhcp wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf iface default inet dhcp
Het tweede bestand (wpa_supplicant.conf) dient om je wireless netwerken zelf te configureren (SSID, password, ....).
sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
per SSID die je wil, voeg je het volgende toe :
network={ ssid="YOURSSID" psk="YOURPASSWORD" # Protocol type can be: RSN (for WP2) and WPA (for WPA1) proto=WPA # Key management type can be: WPA-PSK or WPA-EAP (Pre Shared or Enterprise) key_mgmt=WPA-PSK # Pairwise can be CCMP or TKIP (for WPA2 or WPA1) pairwise=TKIP #Authorization option should be OPEN for both WPA1/WPA2 (in less commonly used are SHARED and LEAP) auth_alg=OPEN id_str="thuis" # Een simpele, logische naam }
Merk op : id_str is een handige manier om later naar dit netwerk te verwijzen. Kies hiervoor logische namen, zoals "thuis", "werk", "club" ...
RPi on the move
Tenslotte zat ik nog met het probleem dat ik ook op clubdagen de Raspberry Pi wou gebruiken. De Nayer heeft wel een guest netwerk en ook dat kan geconfigureerd worden, maar ik besloot mijn smartphone als hotspot te gebruiken. In de veronderstelling dat je weet hoe je je IPhone of Android of Windows smartphone instelt, dis is wat je moet doen op je RPi :
sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
voeg het volgende netwerk toe :
network={ ssid="hotspot-ssid" (de naam van uw hotspot) psk="hotspot-passwd" (het paswoord van uw hotspot) key_mgmt=WPA-PSK (het beveiligingsprotocol) }
Statische IP addressen
Tot nog toe werken we met DHCP, maar dat betekent dat je niet zeker kan zijn dat je RPi ook steeds hetzelfde IP adres heeft. Nogal lastig als je hem remote wil bedienen, maar niet weet op welk IP adres hij te benaderen is. Vandaar een laatste aanpassing om ipv DHCP vaste IP addressen te gaan gebruiken. Ik besloot dit alleen te doen voor de WIFI verbindingen, niet voor de UTP kabel (=eth0), maar de manier is quasi identiek mocht je dat toch willen. Gewoon het sectietje voor "iface eth0" aanpassen zoals voor "thuis" of "habibi"
Eigenlijk was het vrij eenvoudig :
sudo nano /etc/network/interfaces
dit ziet er bij mij als volgt uit :
auto lo iface lo inet loopback iface eth0 inet dhcp allow-hotplug wlan0 iface wlan0 inet manual wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf iface thuis inet static address 192.168.0.99 gateway 192.168.0.1 netmask 255.255.255.0 iface habibi inet static address 192.168.0.99 gateway 192.168.0.1 netmask 255.255.255.0
Hier zeg ik dus dat het netwerk met naam "thuis" en "habibi" een vast IP adres krijgt (in dit geval -niet- toevallige hetzelfde). Dit zijn twee plaatsen waar ik regelmatig ben, beide met een andere SSID op de router.
Het enige nadeel is dat ik op m'n Android geen statische IP addressen kan uitdelen. Gelukkig toont mijn Android wel het IP adres van alle aangesloten devices. Niet zoals ik het wou, maar zeker bruikbaar. Geen beperking van de RPi, wel van de standaard Android software.
Klaar !
Als je nu je RPI boot (of het netwerk stopt/start) en je PC ook via deze hotspot connecteert dan kan je de RPi ook daar remote bedienen zonder extra kabels. Dit laatste is wel belangrijk : als je RPi via de hotspot geconnecteerd is en de PC via een andere SSID dan lukt het niet. Voorlopig werkt alles alleen via de LAN. Wil je van eender waar ter wereld je Pi bedienen, dat kan ook en wordt verder op uitgelegd.
sudo reboot
Nooit je Rpi zomaar af en aan zetten ! Linux moet nog een aantal dingen opkuisen en met het reboot commando ben je zeker dat dit ook netjes gebeurt. Anders loop je het risico dat je SD kaart moet geherformatteerd worden.
Nodige software voor je PC
Op de PC gebruik ik putty.exe voor een seriele terminal en Remote Desktop Connection (standaard onder Windows) als grafische interface
Op de Raspberry moet je voor putty "ssh" downloaden en configureren :
sudo apt-get update (een goede gewoonte : zorg dat je systeem up to date is) sudo apt-get upgrade (een goede gewoonte : zorg dat je systeem up to date is) sudo apt-get install ssh (downloaden en installeren software) sudo update-rc.d ssh defaults (zorgen dat SSH ook start bij reboot)
Na reboot kan je nu je RPi benaderen met putty op het ingestelde IP adres (in mijn geval 192.168.0.99) en poort 22 (standaard voor SSH)
Voor "Remote Desktop Connection" werkt via het Microsoft eigen "RDP" protocol. Gelukkig bestaat daar een Linux implementatie van. Simpelweg installeren :
sudo apt-get update (een goede gewoonte : zorg dat je systeem up to date is) sudo apt-get upgrade (een goede gewoonte : zorg dat je systeem up to date is) sudo apt-get install xrdp
Na installatie moet je nog wel het toetsenbord juist instellen. Vooral voor ons Belgen met een AZERTY een probleempje. Ik heb lang gesukkeld en heel wat gegoogled, tot ik erachter kwam dat ik km-813.ini moest downloaden en in de /etc/xrdp folder zetten.
Nog eens herstarten (sudo reboot) en nu kan je je RPi zowel serieel als grafisch benaderen vanaf je PC, draadloos thuis en via een hotspot op je smartphone.
Toegang via Internet
Dit is het neusje op de zalm. Zou het niet geweldig zijn als je je RPi van eender waar ter wereld kon bereiken ? Ikzelf draai er een simpele webserver op en kan met putty en Remote Desktop Connection inloggen. Pretty neat stuff !
BELANGRIJK : PAS EERST HET PASWOORD VAN DE GEBRUIKER PI AAN. Je wil de voordeur niet wagenwijd openzetten voor hackers zoals ik :-)
sudo passwd
Aanpassen van je router
Je router heeft 2 IP adressen, een publiek voor op het Internet en een privaat voor je lokaal netwerk. Al je devices thuis zitten op het private netwerk en gaan via de router zijn publiek IP address het internet op. Uit veiligheidsredenen is het omgekeerde standaard niet mogelijk. Via een kleine aanpassing aan je router kan het echter wel.
Wat we gaan doen is port-forwarding. Elke dienst (ftp,e-mail, webserver...) heeft een IP adres, maar ook een poortnummer. Alle poortnummers van 0 tot 1023 zijn gereserveerd. Zo is FTP poort 21, SSH poort 22, HTTP poort 80 enzovoort. Wat we nu gaan doen is aan de buitenwereld zeggen dat al jou interne devices op hetzelfde IP adres zitten dan je router, maar dat je bepaalde poorten naar bepaalde devices op je LAN gaat doorsturen.
Mijn router/provider (Telenet) laat niet toe om de poorten van 0 tot 1023 te forwarden, maar wel de poorten van 1024 tot 65535. Ik heb 3 poorten geidentificeerd om door te sturen naar m'n Raspberry Pi
Aanpassen van je RPi
Nu moest ik nu nog op mijn RPi de juiste diensten aan die poorten hangen :
- HTTP op poort 8080 (en ook nog 80)
sudo nano /etc/apache2/ports.conf add : NameVirtualHost *:80 NameVirtualHost *:8080 Listen 80 Listen 8080 sudo /etc/init.d/apache2 restart
- SSH op poort 3322 (en ook nog 22)
sudo nano /etc/ssh sshd_config add : Port 22 Port 3322 sudo /etc/init.d/ssh restart
- XRDP op poort 3389
Je hebt geluk. XRDP draait standaard op poort 3389, niets te doen dus Werkt net niet, check dan /etc/xrdp/xrdp.ini. Daarin staat het poortnummer. Als je dit verandert moet je het ook in de registry van je PC aanpassen.
Het publieke IP adres
Tenslotte moet je nog het publieke IP adres van je router kennen. In mijn geval :
Dit verandert echter regelmatig. Als je het dus ernstig meent moet je een dienst zoals DynDNS of NoIPgebruiken die dit veranderende IP adres in een domain name omzet. Sinds kort spijtig genoeg niet meer gratis, daarom gebruik ik DuckDNS
Bediening via je Android
Helemaal te gek wordt het natuurlijk als je geen TV/keyboard/muis, geen laptop of PC nodig hebt, maar gewoon je Smartphone of Tablet. Kwestie van de juiste apps te gebruiken. Hier een overzichtje van mijn assortiment voor Android
Je kan al deze applicaties net zo vrolijk gebruiken op je lokale netwerk als via Internet. Het enige dat je dan moet doen is het publieke adres van je router ingeven en de poortnummers boven de 1024 gebruiken die we eerder configureerden. Voor de rest werkt alles krak hetzelfde. Wil je via de LAN werken, zorg dan wel de je Android en RPi p hetzelfde accesspoint geconnecteerd zijn. Een foutje waar ikzelf een tijdje op gezocht heb tot ik doorhad dat mijn Android via een hotspot geconnecteerd was, mijn Raspberry Pi via mijn SSID van thuis.
Gebruik je op je Android geen WIFI maar 3G/4G, dan kan je alleen via Internet toegang krijgen, niet via LAN, simpelweg omdat de Raspberry Pi en de smartphone/tablet niet op hetzelfde LAN zitten.
Mini-projecten
Alles is een bestand !
Een van de standaard projecten om mee te starten is het aansluiten van een temperatuur sensor op je Raspberry. Het leert je één van de belangrijkste principes van Linux en eens dat je dat doorhebt wordt alles begrijpbaar. Het principe is eenvoudig : Onder Linux zijn alle randapparaten te gebruiken als bestanden. Of het nu een sensor is, een stuk geheugen, een bestand op de harddisk, een communicatie via Ethernet, alles werkt volgens het zelfde principe : file open, read of write, file close. In het begin wat raar, want ook een pin van de GPIO moet je zo verzetten maar eens je dit doorhebt wordt alles duidelijk.
Omdat dit project 100-en keren te vinden is op internet, gaan we niet alles doorspitten. Op de site van Adafruit wordt alles heel aanschouwelijk uitgelegd en ik ga het dus echt niet overtypen. Nee, echt niet !
Eens ze over de software beginnen wordt het cryptisch.
- Stap 1 : enablen van de GPIO & I²C (staan standaard nog af)
sudo nano /etc/modules voeg volgende twee lijnen toe : i2c-bcm2708 i2c-dev Herstart je RPI (sudo reboot)
- Stap 2 : laden van de kernel modules
sudo modprobe w1-gpio sudo modprobe w1-therm
Deze twee lijnen gaan de modules voor GPIO en de temperatuursensor in de kernel laden. Vanaf dan zijn het "bestanden"
- Stap 3 : Uitlezen van je thermometer als een bestand (met 'cat')
cd /sys/bus/w1/devices ls cd 28-xxxx (change this to match what serial number pops up) cat w1_slave
Je ziet nu twee lijnen en de laatste eindigt met iets als "t=20123". Dit is je temperatuur in 1/1000e van een graad, dus iets meer dan 20°C
We zouden echter geen programmeurs zijn als we dit niet in code omzetten. Hier een stukje Python code die de temperatuur leest en afdrukt. In de functie 'read_temp_raw' zie je duidelijk dat de temperatuursensor zich presenteert als een bestand : open-read-close
import os, glob, time, socket, datetime
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 # convert to °C
return temp_c
print read_temp()
Infrarood afstandsbediening
Welk project ken je dat geen infrarood afstandsbediening kan of zou kunnen gebruiken ? Juist, weinig. In de meeste microcontroller toepassingen programmeer je je IR code in ofwel een interrupt routine ofwel in de main loop door te testen op pulsen en pulslengtes. Bij de Raspberry Pi - en eender welk ander Linux systeem - gaat dat helemaal anders. Voor Linux is LIRC (Linux Infra Red Control) ontwikkeld waardoor je met een simpele IR ontvanger de meest gangbare infrarood afstandsbedieningen kan inlezen. Alles is gebaseerd op een "daemon" (LIRCD) die als service draait, alles interpreteert en hoog niveau commando's ter beschikking stelt van de programma's die dat willen. Geen interrupt of timing gepruts dus, wel wat configuratie werk, maar hiervoor krijg je een robuste, universele omgeving terug die stabiel en betrouwbaar werkt.
LIRC laat toe om IR te ontvangen en IR te zenden. Wij gaan alleen het ontvangen gebruiken. Wil je ook kunnen zenden, dan moet je een IR Led toevoegen.
De hardware
Ik gebruikte een TSOP4838 die ik nog vond in m'n spullen. Normaal moet die 5V hebben, maar alles bleek prima te werken bij 3.3V. Effe de output pin aan GPIO#18 en klaar.
De software
Eerst moeten we de software downloaden. De eerste is LIRC, de tweede de libraries om zelf software te schrijven.
sudo apt-get update (een goede gewoonte : zorg dat je systeem up to date is) sudo apt-get install lirc sudo apt-get install liblircclient-dev
Daarna moeten we de juiste kernel modules laden :
sudo nano /etc/modules en voeg volgende lijnen toe (de laatste is eigenlijk niet nodig) : lirc_dev lirc_rpi gpio_in_pin=18 lirc_rpi gpio_out_pin=7
(Her)start LIRC :
sudo /etc/init.d/lirc stop sudo /etc/init.d/lirc start
De eerste testen
Stop de receiver en start het test programma :
sudo /etc/init.d/lirc stop mode2 -d /dev/lirc0
Je zou nu iets als dit moeten zien :
space 16300 pulse 95 space 28794 pulse 80 space 19395 pulse 83 space 402351 pulse 135 space 7085 pulse 85 space 2903
Hoera, het leeft !
Configuratie van je afstandsbediening
Je weet nu dat je hardware & software werkt. Nu is het kwestie van jou afstandsbediening te configureren. Op de website van LIRC vind je honderden bestaande afstandsbedieningen en ik had geluk : de mijne stond er tussen. Nau ja, geluk. Je moet al een heeeeeel speciale hebben als hij niet bestaat. Een typische philips, sony, panasonic .... afstandsbediening, zelfs van de jaren stillekes herkent hij.
Staat de jouwe er niet tussen ? Geen paniek. LIRC ondersteunt nagenoeg alles omdat het protocols en toetsen kan aanleren met het commando irrecord.
irrecord -d /dev/lirc0 ~/lircd.conf > druk nu de toetsen in die gevraagd worden. > Zodra klaar, vervang de standaard config file met diegene die je net maakte sudo cp lircd.conf /etc/lirc/lircd.conf > Herstart lirc : sudo /etc/init.d/lirc restart
Met het commando "irw" kan je je afstandsbediening testen en dan zou je zoiets als dit moeten zien (ik drukte toetsen 1, 2, 3, 2, 1 in)
0000000000001141 00 1 philips-rt952 0000000000001141 01 1 philips-rt952 0000000000001141 02 1 philips-rt952 0000000000001142 00 2 philips-rt952 0000000000001142 01 2 philips-rt952 0000000000001143 00 3 philips-rt952 0000000000001143 01 3 philips-rt952 0000000000001143 02 3 philips-rt952 0000000000001142 00 2 philips-rt952 0000000000001142 01 2 philips-rt952 0000000000001142 02 2 philips-rt952 0000000000001141 00 1 philips-rt952 0000000000001141 01 1 philips-rt952 0000000000001141 02 1 philips-rt952
Eigen C software
Leuk en aardig, maar hoe gebruik ik dit in mijn eigen software ? Hiervoor bestaat er een library die je ook installeerde in het begin (lirc client library) . Eigenlijk draait het uitlezen van je afstandsbediening rond 6 routines :
lirc_init : aan het begin van je programma lirc_readconfig : laadt de configuratiefile voor je afstandsbediening (of de default als er lokaal geen gevonden wordt) lirc_next_code : deze blokkeert tot de volgende code binnenkomt. Geen paniek, onder linux kan je met multitrhreading werken om toch je programma te laten voortgaan lirc_code2char : deze geeft de configstring die je in de config file opgaf lirc_freeconfig : geeft de configuratie structuur terug vrij lirc_deinit : aan het einde van je programma
Een simpel programmaatje dat alle toetsen die je indrukt weergeeft wordt dan :
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <errno.h>
#include <unistd.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <lirc/lirc_client.h>
char *progname;
int main(int argc, char *argv[])
{
struct lirc_config *config;
progname=argv[0];
if(argc>2)
{
fprintf(stderr,"Usage: %s <config file>\n",progname);
exit(EXIT_FAILURE);
}
if(lirc_init("ir_demo",1)==-1) exit(EXIT_FAILURE);
if(lirc_readconfig(argc==2 ? argv[1]:NULL,&config,NULL)==0)
{
char *code;
char *c;
int ret;
int finished = 0 ;
while(!finished && lirc_nextcode(&code)==0)
if(code==NULL) continue;
printf ("code = %s", code) ;
char *token = strtok (code, " \n") ;
while (token != NULL)
{
if (!finished) finished = !strcmp(token, "STANDBY") ;
printf (" '%s' %d\n", token, finished) ;
token = strtok (NULL, " \n") ;
}
while((ret=lirc_code2char(config,code,&c))==0 &&
c!=NULL)
{
#ifdef DEBUG
printf("Execing command \"%s\"\n",c);
#endif
system(c);
}
free(code);
if(ret==-1) break;
}
lirc_freeconfig(config);
}
lirc_deinit();
exit(EXIT_SUCCESS);
}
Als je dit compileert en runt, krijg je dingen zoals dit te zien :
code = 0000000000001264 00 END- philips-rt952 '0000000000001264' 0 '00' 0 'END-' 0 'philips-rt952' 0 code = 0000000000001264 01 END- philips-rt952 '0000000000001264' 0 '01' 0 'END-' 0 'philips-rt952' 0
Veel succes !
Een paar interessante links
- Raspberry Pi door Joep Suijs : een kort overzicht van de Raspberry in presentatie vorm
- Raspberry Pi Specificaties : De wikipedia pagina van de Raspberry Pi
- Adafruit Learning Home : Een site vele lessen en toffe projectjes met de Raspberry Pi