TP2 : Outils de développement et GPIO
La carte Raspberry Pi offre de nombreuses possibilités pour développer des applications embarquées. Notamment, elle dispose de ports d'entrées/sorties génériques (GPIO) qui permettent de s'interfacer avec un grand nombre de périphériques plus ou moins exotiques.
Dans ce TP il vous est demandé de développer une application "user-land" qui fasse clignoter une ou plusieurs LED's selon on motif que vous choisirez et également de récupérer les informations de plusieurs boutons poussoirs.
À la fin de ce TP, vous devriez avoir acquis les compétences suivantes:
- Compilation croisée via un compilateur déporté
- Contrôle distant de système embarqué par liaison réseau (SSH)
- Manipulation d'un périphérique GPIO et de ses registres "memory mappés"
- Interface numérique/analogique via des ports GPIO
- Programmation d'automates de contrôle en C
0. Plateforme de développement
Pour exécuter votre programme sur une carte Raspberry Pi, vous devez vous
connecter en SSH sur une carte Raspberry Pi en passant par le routeur peri.
Le routeur a deux adresses: 132.227.102.36 du coté laboratoire et 192.168.1.1 de l'autre coté.
Le routeur crée un sous-réseau (192.168.1.x) où sont connectées les cartes.
Les cartes sont numérotées de 20 à 24 plus des cartes étudiants (ici n°30), le routeur a été programmé de telle sorte
que l'adresse internet de la carte n°X est comme adresse 192.168.1.X
(par exemple la carte n°20 a comme adresse sur ce réseau 192.168.1.20).
Pour faire ça, le firmware du routeur a été remplacé par dd-wrt qui permet ce type de mode.
Le routeur a été également été programmé pour que tous les paquets entrants sur le
port 5000+X de l'adresse 132.227.102.36 soient routés vers l'adresse 192.168.1.X.
Il n'y a qu'un seul compte utilisateur sur une carte Raspberry Pi. Le nom de login est pi et le mot de passe est raspberry.
Ainsi, pour se connecter en ssh sur la carte n°22 avec le login pi, il faut taper (remarquez que c'est un p minuscule):
$ ssh -p 5022 pi@132.227.102.36 pi@132.227.102.36's password: raspberry
Pour copier un fichier file.x depuis votre compte enseignement sur le carte ,°22 il faut taper (remarquez que c'est un P majuscule):
$ scp -P 5022 file.x pi@132.227.102.36 pi@132.227.102.36's password: raspberry
Comme, il n'y a qu'un compte par carte et que vous allez devoir vous les partager,
vous devez créer un répertoire à la racine avec le nom de votre login sur le réseau
enseignement accolé avec un tiret avec le nom de votre binôme si vous en avez un.
Par exemple, deux personnes en binôme se nommant respectivement almada et fomentin vont créer un répertoire almada-fomentin (en minuscule).
1. Prise en mains des outils de développement: Hello World!
La première étape consiste à vous familiariser avec les outils de développement. Pour cela, vous allez développer un petit programme de type "Hello World!" qui affiche une phrase sur la sortie standard grâce à un printf.
Pour compiler votre programme, suivez les instructions suivantes.
- Tout d'abord, configurez votre terminal pour utiliser le compilateur croisé (vous pourrez
ajouter cette commande dans le fichier $HOME/.bashrc):
$ source /users/enseig/franck/peri/export_rpi_toolchain.sh
- Une fois le terminal configuré, vérifiez que le compilateur est accessible:
$ which bcm2708hardfp-gcc
Si cette commande ne retourne rien, la configuration n'a pas fonctionné. Appelez le chargé de TP pour vous aider.
Votre suite d'outils (toolchain) contient tous les outils nécessaires pour
la compilation, l'édition des liens et la manipulation de binaires pour la
carte Raspberry Pi. Et tous ces outils sont préfixés par la même chaîne de
caractères: bcm2708hardfp-. Il s'agit donc d'un compilateur pour un SoC
BCM2708 avec l'option hardfp activée (calcul flottant matériel). Il s'agit
bien du SoC de la carte Raspberry Pi.
Maintenant, pour compiler un programme C vers un binaire qui puisse s'exécuter sur la carte Raspberry Pi, il vous faut écrire un Makefile pour plus de facilité. Pour cela, suivez la syntaxe de base des Makefile:
cible: dépendances
commande
Notez bien que l'indentation de la seconde ligne doit OBLIGATOIREMENT être une tabulation et non une suite d'espaces.
Vous pourrez donc par exemple, écrire la règle de Makefile suivante:
helloworld.x: helloworld.c
bcm2708hardfp-gcc -o $@ $< -O2 -static
L'option "-static" est importante ici, car la librairie C du compilateur croisé n'est pas tout à fait identique à la librairie C sur la carte Raspberry Pi. Ajouter "-static" à la ligne de compilation permet de créer un binaire qui contient en plus les fonctions de la librairie C utilisée par votre programme. Ceci permettra à celui-ci de ne pas essayer d'utiliser des fonctions de la librairie C installée sur la carte.
Essayez toutes les variantes ou combinaisons de programme C que vous souhaitez.
2. Contrôle de GPIO en sortie
Dans cet exercice, on vous propose de manipuler une pin du GPIO en mode "sortie" pour contrôler le clignotement d'une LED à une fréquence donnée.
Avant de commencer à écrire du code, déterminez quelles sont les différentes étapes nécessaires depuis l'initialisation jusqu'à l'envoi des valeurs 0 ou 1 sur le GPIO.
Dans un premier temps, on vous ne demande pas d'écrire le code spécifique à la manipulation des registres du contrôleur GPIO. Pour vous aider, vous avez à disposition une petite librairie "libgpio".
Pour récupérer cette librairie, exécuter la commande suivante dans un terminal et dans le dossier que vous souhaitez pour contenir votre code pour ce premier TP.
cp -r /users/enseig/jpeeters/m1.peri/lab1 .
Éditez le fichier lab1.c et ajoutez le code que vous pensez nécessaire à la réalisation de cet exercice.
ATTENTION: ne changez pas les valeurs de GPIO_LED0, car vous risqueriez d'endommager la carte Raspberry Pi.
Ensuite, compilez-le grâce au Makefile qui vous est fourni.
Qu'observez-vous ? Essayez de changer la fréquence de clignotement.
3. Contrôle de plusieurs GPIO en mode "sortie"
Refaites le même exercice que précédemment, mais cette fois-ci configurez plusieurs GPIO en sorties.
En plus du GPIO 4 de l'exercice précédent, rajoutez 3 définitions pour les LED1, LED2 et LED3 qui sont respectivement connectées aux GPIO 17, 22 et 27.
Avant d'exécuter votre programme, validez votre code avec le chargé de TP !
4. Lecture de la valeur d'une entrée GPIO
Maintenant que vous maîtrisez le contrôle d'un GPIO en sortie, passons au mode "entrée".
Toujours à l'aide de la librairie libgpio fournie avec ce TP, écrivez un programme qui configure la GPIO <à définir> en entrée. Et affichez la valeur de ces GPIO dans une boucle infinie (boucle d'échantillonnage).
Une fois réalisé, compilez votre programme comme précédemment à l'aide du Makefile fourni. Et validez votre code avec le chargé de TP !
Ensuite, copiez votre programme sur la carte comme indiqué dans l'exercice précédent.
Les cartes Raspberry Pi sont équipées d'un petit circuit analogique dans lequel des boutons poussoir sont connectés aux certains GPIO. Ces GPIO sont connectés avec une résistance de Pull-Up, ce qui signifie que lorsque que vous n'appuyez pas, la valeur du GPIO vaut 1 et lorsque vous appuyez, le courant passe par à la masse et la valeur du GPIO passe à 1.
Qu'observez-vous ?
Quelle est la fréquence d'échantillonnage (approximative) en sachant que le processeur de la carte fonctionne à une fréquence de 700MHz ?
À supposer que vous êtes capable d'appuyer sur le bouton à une fréquence de 10Hz (c.-à-d. 10 fois par seconde) et sachant que le théorème de Shannon dit qu'il faut au moins échantillonner au double de la fréquence du signal d'entrée pour ne pas perdre de cycle, quelle est la plus petite fréquence d'échantillonnage possible ?
Pour plus de fiabilité, on utilisera une fréquence d'échantillonnage de 100Hz. Comment pouvez-vous écrire un programme qui échantillonne à cette fréquence ?
5. Manipulation de registres bas-niveau
Pour mieux comprendre les implications à bas niveau de l'utilisation d'un contrôleur de GPIO, on vous demande de réécrire les fonctions gpio_setup, gpio_config, gpio_value et gpio_update.
Vous réaliserez cela étape par étape. Aidez-vous des fichiers objet précompilés dans le répertoire lab1.
Par exemple, si vous souhaitez écrire votre propre gpio_setup, créez un fichier gpio_setup.c dans lequel vous écrirez votre code. Pour recompiler la librairie libgpio, il vous suffit de réutiliser le Makefile fourni.
ATTENTION: pour fonctionner avec le reste de la librairie libgpio, il vous faut déclarer dans gpio_setup.c une variable globale gpio_base_p de type uint32_t volatile *. Cette variable qui est un pointeur vers un entier non signé de 32 bits doit contenir l'adresse de début de la région de mémoire virtuelle associée après un appel à la fonction mmap.
6. Amusez-vous !
Maintenant que vous maîtrisez tous les aspects liés à la configuration et à la programmation des GPIO sur Raspberry Pi, laisser aller votre imagination et proposer d'autres programmes à exécuter sur la carte Raspberry Pi qui vous est fournie.
