mardi 17 juillet 2012

Integrer un driver au noyau linux

Avant de proposer la deuxième partie de mon tutoriel sur la gestion d'une entrée GPIO à travers un driver Linux, je vais montrer comment intégrer le driver de led, précédemment créé, directement dans les sources du noyau pour pouvoir le compiler et l'installer en même temps que les autres modules.

Je rappelle que le fichier source du module est disponible sous github.

git://github.com/sinseman44/rpiled.git

Mon noyau Linux ayant été compilé avec l’environnement buildroot. les sources du kernel se trouve dans le dossier buildroot/output/build/linux-HEAD.
A partir de ce dossier parent, je vais copier le fichier source du module (raspberrypi_test_led.c) dans la partie drivers/gpio.

Dans ce dossier, 2 fichiers vont être modifiés pour l'intégration (Kconfig et Makefile).
Le premier Kconfig, fichier d'interface permettant de sélectionner via le menuconfig, les modules à installer avec le noyau  :

menuconfig GPIOLIB                                                                                
        bool "GPIO Support"                                                                       
        depends on ARCH_WANT_OPTIONAL_GPIOLIB || ARCH_REQUIRE_GPIOLIB                             
        select GENERIC_GPIO                                                                       
        help                                                                                      
          This enables GPIO support through the generic GPIO library.                             
          You only need to enable this, if you also want to enable                                
          one or more of the GPIO drivers below.                                                  
                                                                                                  
          If unsure, say N.                                                                       
                                                                                                  
if GPIOLIB

config RPI_GPIO_LED
        tristate "Raspberry Pi led GPIO"
        depends on GPIOLIB
        help
         driver to test a led connected to the raspberry pi

config DEBUG_GPIO                                                                                 
        bool "Debug GPIO calls"                                                                   
        depends on DEBUG_KERNEL                                                                   
        help                                                                                      
          Say Y here to add some extra checks and diagnostics to GPIO calls.                      
          These checks help ensure that GPIOs have been properly initialized                      
          before they are used, and that sleeping calls are not made from                         
          non-sleeping contexts.  They can make bitbanged serial protocols                        
          slower. The diagnostics help catch the type of setup errors                            
          that are most common when setting up new platforms or boards. 

Il y a deux possibilités pour la compilation soit statique, le noyau va construire le fichier objet et inclure le module directement l'image finale, soit dynamique, le driver va être compilé en module et c'est à l'utilisateur de charger/décharger par la suite le module sur le système embarqué.
Certains drivers ont la variable bool à la place de tristate, dans ce cas, le driver est soit compilé en statique, soit pas. La variable tristate, laisse le choix à l'utilisateur de compiler le driver en statique (X), en module (M) ou pas du tout.

La capture d'écran montre que notre driver va être compilé en module.

# make linux26-menuconfig

menu device drivers -> GPIO support


Le deuxième fichier à modifier est le Makefile :

[ ... ]
obj-$(CONFIG_GPIO_WM831X) += gpio-wm831x.o 
obj-$(CONFIG_GPIO_WM8350) += gpio-wm8350.o
obj-$(CONFIG_GPIO_WM8994) += gpio-wm8994.o
obj-$(CONFIG_GPIO_XILINX) += gpio-xilinx.o 
obj-$(CONFIG_RPI_GPIO_LED) += raspberrypi_test_led.o
Il ne reste plus qu'à utiliser les commandes de compilation :
# make
Le module, une fois compilé, va être installé sur le système de fichiers et visible dans le dossier lib/modules/3.1.9/kernel/drivers/gpio.

lundi 16 juillet 2012

On va jouer avec les GPIOs (partie 1)

La carte raspberry pi offre la possibilité d'interagir (facilement) avec quelques entrées/sorties (connecteur 2x13 pins présents sur un coté de la carte). Ce tutoriel va se concentrer sur l'utilisation d'une entrée (partie 1) et d'une sortie (partie 2) pour montrer les différentes possibilités que nous offrent cette carte.

Petit rappel (wiki raspberry pi) :


Les GPIOs sont présentes sur le connecteur 2x13 pins, avec d'autres signaux, tels que les alimentations +3,3v et +5v et la masse.
Certaines de ces GPIOs (0, 1, 4, 7, 8, 9, 10, 11, 14, 15, 18, 21) sont multiplexées avec d'autres fonctionnalités (Ex : GPIO 14 est multiplexé avec la transmission UART, soit on l'utilise en tant que GPIO ou en tant que transmission UART, mais pas les deux en même temps).


Pour ce billet, je vais me concentrer sur deux GPIOs (la 17 en sortie, reliée à une led et la 18 en entrée, reliée au bouton poussoir).


Le schéma de câblage est du plus basique. Une LED standard orange, avec une tension à ses bornes de 2,1v et une résistance de 60 Ohms pour fournir les 20 mA nécessaires. Une résistance de tirage d'une centaine d'ohms pour la liaison avec le bouton poussoir.

 
 

Accès aux GPIOs depuis l'espace utilisateur :


On va commencer à jouer avec les GPIOs depuis l'espace utilisateur, puisque il est possible d'interagir avec chaque GPIO du système depuis l'interface /sys/class/gpio.

[raspberry_pi]# cd /sys/class/gpio/
[raspberry_pi]# ls -al
drwxr-xr-x    2 root     root             0 Jan  1  1970 .
drwxr-xr-x   27 root     root             0 Jan  1  1970 ..
--w-------    1 root     root          4096 Jul  4 18:39 export
lrwxrwxrwx    1 root     root             0 Jan  1  1970 gpiochip0 -> ../../devices/virtual/gpio/gpiochip0
--w-------    1 root     root          4096 Jan  1  1970 unexport

[raspberry_pi]# echo 17 > export 
[raspberry_pi]# ls -al
drwxr-xr-x    2 root     root             0 Jan  1  1970 .
drwxr-xr-x   27 root     root             0 Jan  1  1970 ..
--w-------    1 root     root          4096 Jul  4 18:39 export
lrwxrwxrwx    1 root     root             0 Jul  4 18:39 gpio17 -> ../../devices/virtual/gpio/gpio17
lrwxrwxrwx    1 root     root             0 Jan  1  1970 gpiochip0 -> ../../devices/virtual/gpio/gpiochip0
--w-------    1 root     root          4096 Jan  1  1970 unexport

Au démarrage du système, les GPIOs sont configurées par le noyau et de ce fait, non visible depuis l'espace utilisateur. Pour les rendre visible, il suffit de les exporter en indiquant le numéro de la pin souhaitée.

[raspberry_pi]# ls gpio17
active_low  direction   power       subsystem   uevent      value

[raspberry_pi]# cat gpio17/direction
in

On va configurer la GPIO17 en sortie et allumer (ou éteindre) la led grâce au fichier value.

[raspberry_pi]# echo out > gpio17/direction
[raspberry_pi]# cat gpio17/direction
out
[raspberry_pi]# cat gpio17/value
0
[raspberry_pi]# echo 1 > gpio17/value (la LED s'allume)
[raspberry_pi]# cat gpio17/value
1
[raspberry_pi]# echo 0 > gpio17/value (la LED s'éteint)
[raspberry_pi]# cat gpio17/value
0

On va configurer la GPIO18 en entrée et vérifier l'état du bouton grâce au fichier value.

[raspberry_pi]# echo in > gpio18/direction
[raspberry_pi]# cat gpio18/direction
in
[raspberry_pi]# cat gpio18/value
0
(on appuie sur le bouton)
[raspberry_pi]# cat gpio18/value
1
(on relâche le bouton)
[raspberry_pi]# cat gpio18/value
0


Accès aux GPIOs depuis l'espace noyau :

 

Préambule

Je conseille, surtout un peu de lecture (pour les plus courageux), sur l'utilisation des GPIOs dans un driver Linux. Cette documentation nommée, gpio.txt, se trouve dans les sources du noyau, LINUX_PATH/Documentation/gpio.txt.

Pilotage d'une LED

Grâce aux drivers, nous avons la possibilité de contrôler un périphérique avec des interactions (ou pas) depuis l'espace utilisateur. Pour cet exemple, je vais contrôler une LED via le driver (Activation, désactivation et clignotement).
Ce driver est présent sur github à cette adresse :

git://github.com/sinseman44/rpiled.git

La récupération des sources et du module (déjà compilé) se fera via la commande :

# git clone git://github.com/sinseman44/rpiled.git
Cloning into rpiled...
remote: Counting objects: 10, done.
remote: Compressing objects: 100% (7/7), done.
remote: Total 10 (delta 1), reused 10 (delta 1)
Receiving objects: 100% (10/10), 8.58 KiB, done.
Resolving deltas: 100% (1/1), done.

# ls
Makefile  raspberrypi_test_led.c  raspberrypi_test_led.ko  README

Pour ceux qui veulent re-compiler leur module, passer au chapitre suivant, sinon passer directement au chapitre "utilisation du module.

 

Compilation du module

(La chaîne de compilation croisée a été préalablement installée dans le PATH)

Dans ce tutoriel, le module est compilé en dehors du noyau linux, un guide est fourni dans les docs du noyau linux, chapitre  "How to build external modules" dans LINUX_PATH/Documentations/kbuild/modules.txt. Un makefile est fourni dans le package pour la compilation de celui-ci.

Pour obtenir un module à partir de ce code source, il va falloir le compiler en utilisant les sources du noyau et le compilateur croisée :

# cd rpiled
# make ARCH=arm CROSS_COMPILE=arm-unknown-linux-gnueabi-

On indique l'architecture de la cible et la chaîne de compilation croisée.
A la sortie de compilation, plusieurs fichiers se sont créés ainsi que le module, raspberrypi_test_led.ko :

# ls -al
drwxr-xr-x 3 sinseman44 sinseman44  4096 2012-07-13 14:25 ./
drwxr-xr-x 5 sinseman44 sinseman44  4096 2012-07-11 10:24 ../
-rw-r--r-- 1 sinseman44 sinseman44   212 2012-07-05 09:04 Makefile
-rw-r--r-- 1 sinseman44 sinseman44    95 2012-07-13 14:25 modules.order
-rw-r--r-- 1 sinseman44 sinseman44     0 2012-07-13 14:25 Module.symvers
-rw-r--r-- 1 sinseman44 sinseman44 14927 2012-07-13 14:01 raspberrypi_test_led.c
-rw-r--r-- 1 sinseman44 sinseman44 11627 2012-07-13 14:25 raspberrypi_test_led.ko
-rw-r--r-- 1 sinseman44 sinseman44   519 2012-07-13 14:25 .raspberrypi_test_led.ko.cmd
-rw-r--r-- 1 sinseman44 sinseman44  1711 2012-07-13 14:25 raspberrypi_test_led.mod.c
-rw-r--r-- 1 sinseman44 sinseman44  3808 2012-07-13 14:25 raspberrypi_test_led.mod.o
-rw-r--r-- 1 sinseman44 sinseman44 18669 2012-07-13 14:25 .raspberrypi_test_led.mod.o.cmd
-rw-r--r-- 1 sinseman44 sinseman44  8544 2012-07-13 14:25 raspberrypi_test_led.o
-rw-r--r-- 1 sinseman44 sinseman44 22213 2012-07-13 14:25 .raspberrypi_test_led.o.cmd
drwxr-xr-x 2 sinseman44 sinseman44  4096 2012-07-13 14:25 .tmp_versions/

Utilisation du module 


Maintenant que le module est compilé, on le transfert sur la carte, via le réseau ethernet, avec la commande :

# scp raspberrypi_test_led.ko root@ADRESSE_IP_DE_LA_CARTE:

Sur la carte, on charge le module :

# insmod raspberrypi_test_led.ko

On peut vérifier que le module est bien chargé sur notre système grâce à la commande :

# lsmod
Module                  Size  Used by    Not tainted
raspberrypi_test_led    3200  0

différentes informations sur le module peuvent être affichées :

# modinfo raspberrypi_test_led.ko
filename:       raspberrypi_test_led.ko
description:    LED driver on raspberry PI
author:         Sinseman44 
license:        GPL
vermagic:       3.1.9 preempt mod_unload modversions ARMv6
depends:

Accès au périphérique via le sysfs


Lors du chargement du module, une nouvelle classe est créée dans le sysfs, avec l'accès au périphérique en fonction de l'action souhaitée.
  • led_value (R/W) : lecture et écriture de l'état de la LED
  • led_blink (R/W) : Activation et désactivation du clignotement de la LED
  • led_timer (R/W) : lecture et écriture de la vitesse (0 à 999) de clignotement (millisecondes)

# ls -al /sys/class/rpiled/rpiled/
total 0
drwxr-xr-x    3 root     root             0 Jul 14 10:26 .
drwxr-xr-x    3 root     root             0 Jul 14 10:26 ..
-r--r--r--    1 root     root          4096 Jul 14 10:26 dev
-rw-r--r--    1 root     root          4096 Jul 14 10:28 led_blink
-rw-r--r--    1 root     root          4096 Jul 14 10:28 led_timer
-rw-r--r--    1 root     root          4096 Jul 14 10:28 led_value
drwxr-xr-x    2 root     root             0 Jul 14 10:28 power
lrwxrwxrwx    1 root     root             0 Jul 14 10:28 subsystem -> ../../../../class/rpiled
-rw-r--r--    1 root     root          4096 Jul 14 10:28 uevent

Lecture de l'état de la LED :

# cat /sys/class/rpiled/rpiled/led_value
state of LED : 1

Activation ou désactivation (écriture) de la LED :

# echo 0 > /sys/class/rpiled/rpiled/led_value
# cat /sys/class/rpiled/rpiled/led_value
state of LED : 0

Lecture de l'état de clignotement de la LED :

# cat /sys/class/rpiled/rpiled/led_blink
off

Activation ou désactivation du clignotement de la LED :

# echo on > /sys/class/rpiled/rpiled/led_blink
# cat /sys/class/rpiled/rpiled/led_blink
on

Lecture de la vitesse de clignotement de la LED :

# cat /sys/class/rpiled/rpiled/led_timer
blink led timer (ms) : 1

Changement de vitesse de clignotement de la LED :

# echo 500 > /sys/class/rpiled/rpiled/led_timer
# cat /sys/class/rpiled/rpiled/led_timer
blink led timer (ms) : 500



 

Accès au périphérique via un nœud dans /dev

Au chargement du module, un nœud nommé rpiled va être créé dans le dossier dev avec comme numéro de majeur 252 et numéro de mineur 0. Ce nœud va servir à l'utilisateur pour interagir avec le périphérique via une application (utilisation des méthodes open, read, close). exemple :
# cat /dev/rpiled

Conclusion

Maintenant que le gestion d'une GPIO en sortie est traitée (driver et application), nous allons nous intéresser à la gestion d'une GPIO en entrée (bouton poussoir) à l'aide d'un driver Linux.

dimanche 1 juillet 2012

On va faire du custom (Partie 2)

Après avoir compiler nos différents éléments, nous allons maintenant les insérer sur une carte SD. avant cela, nous allons la formater suivant le tutoriel fourni sur le wiki de raspberry pi. Il suffit simplement de suivre le tutoriel à une petite modification près. Au lieu de formater la partition linux au format Ext3, nous allons la formater au format Ext4.

ensuite, décompressez les deux archives boot.tar.gz et rootfs.tar.gz trouvées dans le dossier de buildroot output/images, dans respectivement, les partitions boot (FAT32 LBA) et rootfs (EXT4) créées précédemment.
A noter que l'extraction de l'archive rootfs doit se faire avec les droits super utilisateurs.
# tar xzf output/images/boot.tar.gz -C /media/FAT32_PARTITION
# sudo tar xzf output/images/rootfs.tar.gz -C /media/EXT4_PARTITION

ensuite démonter la carte SD et insérer la sur la carte raspberry pi.
# sudo umount /media/FAT32_PARTITION
# sudo umount /media/EXT4_PARTITION

Finalement après avoir ouvert une console série, et branché la raspberry pi, voici les traces de démarrage :
Linux version 3.1.9 (sinseman44@BENSERV) (gcc version 4.6.3 (crosstool-NG 1.15.2 - buildroot 2012.05) ) #1 PREEMPT Sun Jul 1 00:50:23 CEST 2012
CPU: ARMv6-compatible processor [410fb767] revision 7 (ARMv7), cr=00c5387d
CPU: VIPT nonaliasing data cache, VIPT nonaliasing instruction cache
Machine: BCM2708
Memory policy: ECC disabled, Data cache writeback
Built 1 zonelists in Zone order, mobility grouping on.  Total pages: 32512
Kernel command line: dma.dmachans=0x3c bcm2708_fb.fbwidth=720 bcm2708_fb.fbheight=480 bcm2708.boardrev=0x2 bcm2708.serial=0xd5a6dc6e 
smsc95xx.macaddr=B8:27:EB:A6:DC:6E dwc_otg.lpm_enable=0 console=ttyAMA0,115200 
kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 rootwait
PID hash table entries: 512 (order: -1, 2048 bytes)
Dentry cache hash table entries: 16384 (order: 4, 65536 bytes)
Inode-cache hash table entries: 8192 (order: 3, 32768 bytes)
Memory: 128MB = 128MB total
Memory: 125572k/125572k available, 5500k reserved, 0K highmem
Virtual kernel memory layout:
    vector  : 0xffff0000 - 0xffff1000   (   4 kB)
    fixmap  : 0xfff00000 - 0xfffe0000   ( 896 kB)
    DMA     : 0xffc00000 - 0xffe00000   (   2 MB)
    vmalloc : 0xc8800000 - 0xd8000000   ( 248 MB)
    lowmem  : 0xc0000000 - 0xc8000000   ( 128 MB)
    modules : 0xbf000000 - 0xc0000000   (  16 MB)
      .text : 0xc0008000 - 0xc03b0000   (3744 kB)
      .init : 0xc03b0000 - 0xc03cd000   ( 116 kB)
      .data : 0xc03ce000 - 0xc03ec8c0   ( 123 kB)
       .bss : 0xc03ec8e4 - 0xc04391d8   ( 307 kB)
NR_IRQS:85
timer_set_mode: unhandled mode:1
timer_set_mode: unhandled mode:3
Console: colour dummy device 80x30
console [tty1] enabled
Calibrating delay loop... 795.44 BogoMIPS (lpj=3977216)
pid_max: default: 32768 minimum: 301
Mount-cache hash table entries: 512
CPU: Testing write buffer coherency: ok
devtmpfs: initialized
NET: Registered protocol family 16
vc-mem: mm_vc_mem_phys_addr = 0x00000000
vc-mem: mm_vc_mem_size      = 0x10000000 (256 MiB)
mailbox: Broadcom VideoCore Mailbox driver
bcm2708_vcio: mailbox at f200b880
bcm_power: Broadcom power driver
bcm_power_open() -> 0
bcm_power_request(0, 8)
bcm_mailbox_read -> 00000080, 0
bcm_power_request -> 0
Serial: AMBA PL011 UART driver
dev:f1: ttyAMA0 at MMIO 0x20201000 (irq = 83) is a PL011 rev3
console [ttyAMA0] enabled
bio: create slab  at 0
SCSI subsystem initialized
usbcore: registered new interface driver usbfs
usbcore: registered new interface driver hub
usbcore: registered new device driver usb
Switching to clocksource stc
FS-Cache: Loaded
CacheFiles: Loaded
Switched to NOHz mode on CPU #0
NET: Registered protocol family 2
IP route cache hash table entries: 1024 (order: 0, 4096 bytes)
TCP established hash table entries: 4096 (order: 3, 32768 bytes)
TCP bind hash table entries: 4096 (order: 2, 16384 bytes)
TCP: Hash tables configured (established 4096 bind 4096)
TCP reno registered
UDP hash table entries: 256 (order: 0, 4096 bytes)
UDP-Lite hash table entries: 256 (order: 0, 4096 bytes)
NET: Registered protocol family 1
RPC: Registered named UNIX socket transport module.
RPC: Registered udp transport module.
RPC: Registered tcp transport module.
RPC: Registered tcp NFSv4.1 backchannel transport module.
bcm2708_dma: DMA manager at c8808000
bcm2708_gpio: bcm2708_gpio_probe c03d3d68
vc-mem: Videocore memory driver
VFS: Disk quotas dquot_6.5.2
Dquot-cache hash table entries: 1024 (order 0, 4096 bytes)
FS-Cache: Netfs 'nfs' registered for caching
msgmni has been set to 245
io scheduler noop registered
io scheduler deadline registered
io scheduler cfq registered (default)
BCM2708FB: registering framebuffer (720x480@16)
bcm2708_fb_set_par info(c7868000) 720x480 (720x480), 0, 16
BCM2708FB: start = c8900000,49385000 width=720, height=480, bpp=16, pitch=1440 size=691200 success=0
Console: switching to colour frame buffer device 90x30
BCM2708FB: register framebuffer (0)
brd: module loaded
loop: module loaded
vcos: [1]: vchiq_init_state: slot_zero = 0xffd80000, is_master = 0
vcos: [1]: vchiq_init_state: called
vcos: [1]: vchiq: initialised - version 2 (min 2), device 253.0
usbcore: registered new interface driver smsc95xx
cdc_ncm: 04-Aug-2011
usbcore: registered new interface driver cdc_ncm
dwc_otg: version 2.90b 6-MAY-2010 (platform bus)
Core Release: 2.80a
Setting default values for core params
Finished setting default values for core params
c8840008 -> 1
Using Buffer DMA mode
Periodic Transfer Interrupt Enhancement - disabled
Multiprocessor Interrupt Enhancement - disabled
Dedicated Tx FIFOs mode
dwc_otg bcm2708_usb: DWC OTG Controller
dwc_otg bcm2708_usb: new USB bus registered, assigned bus number 1
dwc_otg bcm2708_usb: irq 75, io mem 0x00000000
Init: Port Power? op_state=1
Init: Power Port (0)
usb usb1: New USB device found, idVendor=1d6b, idProduct=0002
usb usb1: New USB device strings: Mfr=3, Product=2, SerialNumber=1
usb usb1: Product: DWC OTG Controller
usb usb1: Manufacturer: Linux 3.1.9 dwc_otg_hcd
usb usb1: SerialNumber: bcm2708_usb
hub 1-0:1.0: USB hub found
hub 1-0:1.0: 1 port detected
usbcore: registered new interface driver uas
Initializing USB Mass Storage driver...
usbcore: registered new interface driver usb-storage
USB Mass Storage support registered.
usbcore: registered new interface driver libusual
mousedev: PS/2 mouse device common for all mice
usbcore: registered new interface driver xpad
cpuidle: using governor ladder
cpuidle: using governor menu
sdhci: Secure Digital Host Controller Interface driver
sdhci: Copyright(c) Pierre Ossman
bcm_power_open() -> 1
mmc0: SDHCI controller on BCM2708_Arasan [platform] using platform's DMA
mmc0: BCM2708 SDHC host at 0x20300000 DMA 2 IRQ 77
sdhci-pltfm: SDHCI platform and OF driver helper
usbcore: registered new interface driver usbhid
usbhid: USB HID core driver
TCP cubic registered
Initializing XFRM netlink socket
NET: Registered protocol family 17
Registering the dns_resolver key type
VFP support v0.3: implementor 41 architecture 1 part 20 variant b rev 5
Waiting for root device /dev/mmcblk0p2...
mmc0: new high speed SDHC card at address b368
mmcblk0: mmc0:b368       7.45 GiB
 mmcblk0: p1 p2
EXT4-fs (mmcblk0p2): warning: maximal mount count reached, running e2fsck is recommended
EXT4-fs (mmcblk0p2): mounted filesystem with ordered data mode. Opts: (null)
VFS: Mounted root (ext4 filesystem) on device 179:2.
devtmpfs: mounted
Freeing init memory: 116K
usb 1-1: new high speed USB device number 2 using dwc_otg
EXT4-fs (mmcblk0p2): re-mounted. Opts: user_xattr,acl,barrier=1,data=ordered
usb 1-1: New USB device found, idVendor=0424, idProduct=9512
usb 1-1: New USB device strings: Mfr=0, Product=0, SerialNumber=0
hub 1-1:1.0: USB hub found
hub 1-1:1.0: 3 ports detected
usb 1-1.1: new high speed USB device number 3 using dwc_otg
usb 1-1.1: New USB device found, idVendor=0424, idProduct=ec00
usb 1-1.1: New USB device strings: Mfr=0, Product=0, SerialNumber=0
smsc95xx v1.0.4
smsc95xx 1-1.1:1.0: eth0: register 'smsc95xx' at usb-bcm2708_usb-1.1, smsc95xx USB 2.0 Ethernet, b8:27:eb:a6:dc:6e
smsc95xx 1-1.1:1.0: eth0: link up, 100Mbps, full-duplex, lpa 0x45E1
øø
Welcome to RaspberryPi
(none) login: root
Password:
[root@(none) ~]# uname -a
Linux (none) 3.1.9 #1 PREEMPT Sun Jul 1 00:50:23 CEST 2012 armv6l 
ARMv6-compatible processor rev 7 (v6l) BCM2708 GNU/Linux

Amusez-vous bien ...

Comment gagner du temps

Une fois que l'on a une chaine de compilation fonctionnelle, il ne sert à rien d'en reconstruire une à chaque fois, c'est pourquoi je propose ma chaîne de compilation croisée (~ 228 Mo) pour la carte raspberry pi, compilée sur une machine X86, donc fonctionnelle sur les machines X86 ou 64bits.

Si tout de fois, une chaîne de compilation croisée a déjà été compilée, il est préférable de nettoyer l'environnement avec d'utiliser la nouvelle chaîne.
# make clean

Pour l'utiliser, il faut tout d'abord la décompresser puis configurer buildroot, pour cela, on reprend la commande :
# tar xvzf arm-unknown-linux-gnueabi.tar.gz -C CHEMIN_INSTALLATION
# make menuconfig

Dans le menu, on entre dans le sous menu toolchain :


Dans ce sous-menu, on choisi external toolchain type et custom toolchain, dans les deux premiers champs. Le suivant sert à entrer le chemin de la chaîne de compilation croisée, la libc est une glibc et elle a le support c++.


Il ne reste plus qu'à compiler l'environnement avec cette nouvelle chaine et le tour est joué ...
# make