R a s p b e r r y P i : Python et le port GPIO

Objectif
Ce TP vise à vous fournir l'essentiel des informations nécessaires afin de vous permettre de créer
vos propres projets, tout en exploitant au mieux le port GPIO.
Le port GPIO (General Purpose Input/Output, ou Entrées/Sorties pour un usage générique)
mettra à votre disposition de nombreuses entrées-sorties, une alimentation, un port SPI, un port
I2C, et un port série. Après une rapide présentation du Raspberry Pi, de ses différentes versions
existantes, et des caractéristiques liées, nous nous pencherons sur le fonctionnement et la
programmation du port GPIO. Enfin, nous finirons par une mise en pratique de la théorie que
nous aurons vue précédemment.
1. Présentation du Raspberry Pi
Modèles et caractéristiques
Modèle A A+ Les
B modèles B+A et B2 B
possédaient un port GPIO à 26
Quadricœur
CPU Monocœur ARM 700 MHz points. Les modèles A+, B+ et MHz
ARM 900
B2 possèdent un port GPIO à
GPU Décodeur vidéo Broadcam VideoCore IV
40 points, correspondant aux
RAM 256 MO 26 512
points
MOdes modèles A/B plus
1 GO
USB 1 * USB2.0
14 points
2 * USB2.0
supplémentaires.
4 * USB2.0
Jack 3.5, composite et HDMI et jack
Audio/vidéo Jack 3.5, composite et HDMI HDMI et jack audio/vidéo
HDMI audio/vidéo
Ethernet 0 10/100 0 10/100
Entrées/sorties GPIO 26 pts GPIO 40 pts GPIO 26 pts GPIO 40 pts
OS Officiel : Raspbian Tiers : Fedora, XBMC/Kodi, OSMC
Stockage SD Micro SD SD Micro SD
Dimensions 86*54*17 65*54*17 86*54*17
Poids 45g 23g 45g
Consommation 1.5W 1W 3.5W 3W

1
[Link] Ihssen
 o Ports USB - ceux-ci sont utilisés pour connecter une souris
et un clavier, clé USB...
o Emplacement pour carte SD pour stocker le système
d’exploitation et les fichiers.
o Port Ethernet pour connecter le Raspberry Pi à un réseau
avec un câble. Le Raspberry Pi peut également se connecter
via le réseau local sans fil.
o Prise audio pour connecter un casque ou des haut-parleurs.
o Port HDMI pour connecter le moniteur (ou le projecteur)
qu’on utilisera pour afficher la sortie du Raspberry Pi.
o Connecteur d’alimentation Micro USB pour connecter une
alimentation électrique. On doit toujours faire ceci en dernier,
après avoir connecté tous tes autres composants.
o Ports GPIO pour connecter des composants électroniques
tels que des LEDs et des boutons au Raspberry Pi.

‐ Raspberry Pi est un ordinateur fonctionnant sous le système d’exploitation LINUX‐DEBIAN

2. LINUX mini (les commandes indispensables)

adapté à la Raspberry Pi sous le nom RASPBIAN, il est indispensable pour le configurer et

l’utiliser de connaitre quelques commandes Linux en mode console
 Pour éviter de taper à chaque fois sudo, passez en mode administrateur : sudo –i
 Linux utilise beaucoup les scripts, de petits fichiers de type texte qui permettent
l’enchainement de commandes systèmes.
 Exemple d’écriture d’un script en PYTHON :
sudo nano [Link]

2
[Link] Ihssen
  Lancer l’exécution d’un script PYTHON
sudo python [Link] (ctrl‐c pour l’arrêter)
ctrl‐x Y pour enregistrer et quitter.
 Pour rendre un programme PYTHON exécutable sans avoir à lancer la commande python,
le script doit contenir la ligne #!/usr/bin/python3.2 (ici pour indiquer qu’il s’agit d’un script
Python 3.2).
 sudo chmod +x [Link]
Pour l’executer
sudo ./[Link]

3. Le port GPIO

Dans le cas du SPI, on remarquera qu'il y a deux « Chip Enable ». Nativement, le Raspberry Pi
est donc capable de gérer deux SPI en parallèle.

3
[Link] Ihssen
 Activation de l'SPI

 Ouvrez un terminal, depuis une interface graphique, et/ou lancez la commande suivante :
sudo raspi-config

 Cela lance l'interface de configuration du Raspberry Pi, sélectionnez « Advanced Options »

puis validez :

 Sur le nouvel écran, sélectionnez « SPI » puis validez :

 Rebootez votre machine.

sudo reboot
 Testez que le SPI est bien reconnu avec la commande suivante (elle doit vous renvoyer une
ligne d'information)
lsmod | grep spi_
4. Python et le port GPIO
Python est un langage interprété (non compilé comme le C) orienté objet de très haut niveau, il
dispose d’une syntaxe (assez proche du C) qui permet une écriture et une lecture aisée et
structurée des programmes.

4
[Link] Ihssen
Les bibliothèques disponibles et recommandées
Il existe de nombreuses bibliothèques dédiées au Raspberry Pi. Elles sont stockées, pour la
plupart, sur Pypi. Celle que nous étudierons ici est la bibliothèque historique : [Link].
Pour l'installer, il suffit donc d'un simple pip install :
pip install [Link]
Si vous ne possédez pas encore pip, il vous suffit de charger [Link], puis de le lancer via la
commande ci-après. Une connexion Internet vous sera nécessaire. La première ligne de
commande est pour ceux qui exécuteraient le tout sans interface graphique.
wget [Link]
python [Link]
Bootstrap est une collection d'outils utiles à la création du design de sites et d'applications web.
C'est un ensemble qui contient des codes HTML et CSS, des formulaires, boutons, outils de
navigation et autres éléments interactifs, ainsi que des extensions JavaScript en option.
Le port GPIO n'est accessible qu'en mode root. N'oubliez donc pas de lancer Python avec la
commande sudo, sinon cela ne fonctionnera pas.
sudo python mon_script.py
La bibliothèque GPIO
import [Link] as GPIO
Concernant l'état des entrées-sorties (E/S), le module [Link] accepte des variables dédiées,
des entiers ou des booléens.
Ainsi, l'état haut peut valoir au choix [Link], 1 ou encore True.
De même, l'état bas peut valoir [Link], 0 ou False.
Configuration générale
Le Raspberry Pi autorise deux numérotations : celle de la sérigraphie du connecteur de la carte
([Link]), ou la numérotation électronique de la puce ([Link]).
À vous de choisir celle que vous voulez.
En noir la numérotation [Link]. En rouge, la numérotation [Link]

[Link]([Link])
[Link]([Link])
# On peut aussi demander la configuration etablie
configuration = [Link]()

Configuration des entrées-sorties

Afin d'initialiser une E/S, il suffit de préciser son numéro, fonction de la configuration
précédemment choisie, son paramétrage (entrée ou sortie) et éventuellement son état initial (pour
une sortie).

5
[Link] Ihssen
[Link](12, [Link]) # broche 12 est une entrée numérique
[Link](12, [Link]) # broche 12 est une sortie numériques
Lire une entrée
[Link](12, numérique
[Link], initial=[Link])# broche 12 est une sortie initialement a l'état haut
Afin de lire l'état d'une entrée, il suffit de préciser le numéro de l'E/S.
[Link](12)
Changer l'état d'une sortie numérique
Pour modifier l'état d'une sortie, il faut indiquer le numéro de la sortie, ainsi que l'état désiré.
[Link](12, [Link])
Configuration d'une entrée-sortie numérique
On peut interroger l'E/S afin de connaître son état de configuration. Les valeurs renvoyées sont
[Link],
[Link],
[Link],
GPIO.I2C,
GPIO.HARD_PWM,
[Link]
state = GPIO.gpio_function(pin)
print(state)
Remettre à zéro une entrée-sortie numérique
À la fin de tout programme, il est conseillé d'effectuer une purge des ressources afin de les
remettre dans l'état où le programme les a trouvées. On n'impactera ainsi que les E/S utilisées.
[Link]()
La PWM
La PWM pour Pulse Width Modulation consiste en un signal carré dont on fait varier le rapport
cyclique, en d'autres termes, dont on fait varier la durée de l'état haut, par rapport à l'état bas.
La PWM fonctionne comme un objet, en Python et sur Raspberry Pi. Il faut donc commencer par
créer une instance PWM, en déclarant le canal (channel) utilisé, ainsi que la fréquence désirée.
En cours de route, vous pourrez changer aussi bien le rapport cyclique, que la fréquence.

p = [Link](channel, frequence)
[Link](rapport_cyclique) #ici, rapport_cyclique vaut entre 0.0 et 100.0
[Link](nouvelle_frequence)
[Link](nouveau_rapport_cyclique)
[Link]()

Exemple d’application Python rend possible d'importer seulement une

import [Link] as GPIO partie d'une bibliothèque (une seule
from time import sleep classe/fonction). Pour cela, Python utilise toujours
[Link]([Link])
[Link](12,[Link])
l'instruction import, mais précédée de
p=[Link](18,1000) #create PWM instance with l'instruction from.
frequency
[Link](5) #start PWM of required Duty Cycle
[Link](80)
[Link](2)
[Link](100)
[Link](2)
La PWM est disponible sur pin GPIO18 de BCM
[Link]()
et GPIO12 de BOARD
[Link]()

6
[Link] Ihssen
Pull up et pull down
Afin d'éviter de laisser flottante toute entrée, il est possible de connecter des résistances de pull-
up ou de pull-down, au choix, en interne.
Pour information, une résistance de pull-up ou de pull-down est une résistance dans un circuit
électronique, située entre la source d'alimentation et une ligne, et qui amène délibérément cette
même ligne soit à l'état bas (0 en électronique numérique) pour une résistance de pull-up, soit à
l'état haut (1 logique) pour une résistance pull-down donc son but est d'éviter de laisser une
entrée ou une sortie dans un état incertain, en forçant une connexion à la masse ou à un potentiel
donné.
[Link](channel, [Link], pull_up_down=GPIO.PUD_UP)
[Link](channel, [Link], pull_up_down=GPIO.PUD_DOWN)
Interruption et détection de front
La détection de front est quelque chose d'important, et liée aux interruptions. Il existe trois
façons de procéder.
La première consiste à bloquer l'exécution du programme jusqu'à ce que l'événement se produise.
GPIO.wait_for_edge(channel, [Link])
Le second paramètre peut ici valoir [Link], [Link] ou [Link].
La seconde solution est liée à l'utilisation d'une boucle. On ajoute des événements à écouter sur
un canal, et au sein de la boucle while, on teste si quelque chose s'est produit sur un des canaux
écoutés.
GPIO.add_event_detect(channel, [Link])
While True:
if GPIO.event_detected(channel):
print("Bouton appuye")

Enfin, la dernière solution est celle qui est la plus proche du concept d'interruption sur
microcontrôleur. Pour ce faire, en cas d'événement, un thread parallèle est lancé en cas
d'interruption. Trois valeurs sont possibles : front montant ([Link]), front descendant
([Link]) ou bien les deux ([Link])).

Pour créer une fonction en Python, on utilise le mot clef def, puis le nom de la fonction à créer,
et enfin la liste des variables attendues par la fonction.
Def my_callback(channel):
print("un evenement s'est produit")
#ici on ajoute une tempo de 75 ms pour eviter l'effet rebond
GPIO.add_event_detect(channel, [Link], callback=my_callback, bouncetime=75)
#votre programme ici

Enfin, au besoin, vous pouvez supprimer les interruptions sur un canal très simplement.
GPIO.remove_event_detect(channel)
Le nécessaire pour l'I2C
Nous avons précédemment vu comment paramétrer le Raspberry Pi pour activer l'I2C. Nous
allons voir ici comment installer le nécessaire pour piloter l'I2C en Python.
La bibliothèque utilisée s'appelle « smbus-cffi » et est disponible sur Pypi, via pip. Elle requiert
des dé[Link] la liste des commandes à exécuter :
sudo apt-get install build-essential libi2c-dev python-dev
sudo apt-get install libffi-dev i2c-tools
sudo pip install smbus-cffi
7
[Link] Ihssen
Le nécessaire pour le SPI
Nous avons précédemment vu comment paramétrer le Raspberry Pi pour activer le SPI. Nous
allons voir ici comment installer le nécessaire pour piloter le SPI en Python.
La bibliothèque utilisée s'appelle « spidev ». Elle est disponible via pip, mais requiert cependant
des dépendances.
Voici donc la liste des commandes à exécuter pour installer l'ensemble :
sudo apt-get install python2.7-dev
sudo apt-get install python3-dev
sudo apt-get libevent-dev
sudo pip install spidev
Gestion d'une LED
Nous allons ici piloter notre LED de deux façons. Tout d'abord, nous la ferons simplement
clignoter. Par la suite, nous ferons varier son intensité via la PWM.
La LED sera branchée sur la broche (pin e) 3 du GPIO (GPIO2).

Pour le PWM nous utiliserons cette dernière de manière à modifier la quantité d'énergie
transmise. Pour cela, nous choisirons une fréquence de 200 Hz, et le rapport cyclique évoluera
dans le temps.
Code
[Link]
# Import des modules
import [Link] as GPIO
import time
# Initialisation de la numerotation et des E/S
[Link]([Link])
[Link](3, [Link], initial = [Link])
# On fait clignoter la LED
while True:
[Link](3, not [Link](3))
[Link](0.5)

8
[Link] Ihssen
Pour la PWM, nous devrons brancher notre LED sur la GPIO18 (broche 12), qui est la seule à
proposer cette fonctionnalité.

Code
[Link]
# Import des modules
import [Link]
import time
# Initialisation de la numerotation et des E/S
[Link]([Link])
[Link](12, [Link], initial = [Link])
Rapport = 10.0
sens = True
p = [Link](12, 200)
[Link](rapport) #ici, rapport_cyclique vaut entre 0.0 et 100.0
# On fait varier l'intensite de la LED
while True:
if sens and rapport < 100.0:
rapport += 10.0
elif sens and rapport >= 100.0:
sens = False
elif not sens and rapport > 10.0:
rapport -= 10.0
elif rapport == 10.0:
sens = True
[Link](rapport)
[Link](0.25)

Lecture d'un bouton

Lorsque nous désirons lire l'état d'un bouton, nous avons deux solutions : venir lire l'état à
intervalle régulier, ou bien programmer une interruption et vaquer au reste du programme.
Une fois le bouton appuyé, nous attendrons le relâchement tout simplement.

Les deux pattes de notre bouton seront branchées sur une masse et la broche 19 du GPIO
(GPIO10). Une résistance de pull-up sera également branchée entre une des pattes de +3,3V et la
broche 19. Enfin, notre LED sera branchée cette fois entre une masse et la broche 12 (GPIO18).

9
[Link] Ihssen
 [Link]
# Import des modules
import [Link]
import time
# Initialisation de la numerotation et des E/S
[Link]([Link])
[Link](12, [Link], initial=[Link])
[Link](19, [Link])
# Si on detecte un appui sur le bouton, on allume la LED
# et on attend que le bouton soit relache
while True:
state = [Link](19)
if not state:
# on a appuye sur le bouton connecte sur la broche 19
[Link](12, [Link])
while not state:
state = [Link](19)
[Link](0.02) # Pause pour ne pas saturer le processeur
[Link](12, [Link])
[Link](0.02) # Pause pour ne pas saturer le processeur

Pilotage d'un afficheur LCD

Pour cette partie, nous utiliserons un afficheur LCD à base de HD44780, piloté non pas sur 8
bits, mais en mode 4 bits. Malgré le fait que l'écran ne fonctionne qu'en 5V, nous pouvons tout
de même le brancher en direct sur le Raspberry, car nous ne recevons aucune donnée de l'écran,
nous ne faisons que lui envoyer des ordres. Notre écran sera alimenté par du +5V. Le signal RS
sera connecté à la broche 8 (GPIO14), enable sur la broche 10 (GPIO15), et D4 à D7 sur les
broches 3,5,7 et 11 (GPIO2, GPIO3, GPIO4, GPIO17).

10
[Link] Ihssen
Nous allons utiliser une bibliothèque fournie par Adafruit : Adafruit_CharLCD.py
[Link]
import [Link]
import adafruit_charlcd
lcd = Adafruit_CharLCD.Adafruit_CharLCD(pin_rs=14, pin_e=15, pins_db=[2,3,4,17])
[Link]()
[Link]("Hello world !!!")

Lire un capteur de température I2C

Nous allons ici utiliser un capteur LM76, puis aller lire le contenu d'un registre afin de connaître
la température.

import time
from smbus import SMBus
bus= SMBus(1) # 1 indique qu'il faut utiliser le port /dev/i2c-1
while True:
# Le composant porte l'adresse 0x48 (A0 et A1 relies à GND)
# On va lire plusieurs octets a partir du registre 0
data = bus.read_i2c_block_data(0x48, 0)
tempMSB = data[0]
tempLSB = data[1]
temperature=(((tempMSB << 8) + tempLSB) >>7) * 0.5
if temperature > 128 : # test si la temperature est negative
# complement a 1 de la temperature
temperature = (((((tempMSB << 8) + tempLSB) >>7 )* 0.5) -256)
print(temperature)
fichier = open ('fichier_anne_marie','a')
[Link] (str(temperature))
[Link] (', ')
[Link] ()
[Link](2)

11
[Link] Ihssen
Pilotage d'un périphérique SPI
Nous allons ici utiliser un circuit SPI, plus précisément un MCP3202, qui est un convertisseur
Analogique/Numérique 12 bits.

[Link]
from __future__ import division
import spidev

def lire_analog(puce_spi = 0, entree_analog = 1):

liaison = [Link](0, puce_spi)
liaison.max_speed_hz = 300000 # en Hertz

# Initialisation des parametres de lecture

# (cf datasheet pour les curieux)
if entree_analog == 0:
value = 128
else:
value = 160
to_send = [value, 0]

# Lecture
rd_octets = liaison.xfer2(to_send)

# La reponse arrive sur deux octets

msb = rd_octets[0]
lsb = rd_octets[1]
value = (msb << 8) + lsb
calcul = 2 * (value * 3.3) / 4096.0
return calcul

if __name__ == '__main__':
print(lire_analog())

12
[Link] Ihssen