Raspberry Pi

Uit RobotMC.be
Ga naar: navigatie, zoeken

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.

Raspberry pi board.jpg
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.

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

RPi Portforward.jpg

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 :

RPi publiek ip.jpg

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

Android Apps
Internet logo.jpg Internet screen.jpg Laten we de browser niet vergeten. We draaien op de RPi Apache en dus is hij perfect te benaderen van een standaard webbrowser. Ik toon er bv. de temperatuur in huis op. Mits de juiste server side scripting (bv. PHP) kan je hier een perfecte domotica applicatie mee bouwen.
JuiceSSH logo.jpg JuiceSSH screen.jpg JuiceSSH is een simpele seriele terminal, net zoals putty. Niet simpel om foutloos te typen op je smartphone, maar voor een simpele "sudo shutdown now" of "sudo reboot" best bruikbaar.
Splashtop logo.jpg Splashtop screen.jpg SplashTop is het equivalent van Remote Desktop connection die we ook gebruikten op de PC. Met deze kan je je Raspberry grafisch bedienen. Op een tablet best bruikbaar, maar op het piep-kleine smartphone scherm toch een challenge
RaspberryControl logo.jpg RaspberryControl screen.jpg Een app, compleet geschreven voor de RPi. Het werkt geheel via de SSH poort die ook putty en JuiceSSH gebruiken. Begin april 2014 kan je de GPIO te benaderen en de 1-wire interface (bv. temperatuursensor). In toekomstige versies zou ook I²C en SPI ondersteund worden. Er zit ook een terminal interface ingebouwd. Zeer belovenswaardig.

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

RPi IRreceiver.jpg
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