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.