Que va-t-on faire ?

Nous allons assembler les trois DELs sur une breadboard reliée à une Raspberry PI et nous allons coder un petit script en Python imitant un feu tricolore.

RPI et feu tricolore

Les prérequis

Pour les composants, nous aurons besoin:

• de trois DELs (si possible de couleurs différentes)
• d’une résistance d’une centaine d’ohms
• et de quelques fils

Coté Raspberry, j’ai un PI-Cobbler pour faciliter la connexion avec la breadboard. J’ai fait le montage avec Raspbian sur la Raspberry.

Le montage électronique

Pour le montage électronique, nous utiliserons les ports GPIO 22, 17 et 18 que nous relierons chacun à une anode d’une des diodes. Enfin, nous relierons les cathodes à une des pattes de la résistance. La deuxième patte de la résistance sera relié à une borne GND du port de la Raspberry. Rappel : patte longue = anode, patte courte = cathode.

Le choix de la résistance viens de la formule U = RI. Nos diodes fonctionnent avec une tension de 1.5V, consomment un courant de 20mA et le port GPIO nous fournit du 3.3V. Nous devons donc disperser 1.8V via la résistance. Donc, nous avons : R = U / I = 1.8 / 0,02 = 90 ohms. Une résistance d’une centaine d’ohms est donc suffisante.

Un schéma vaut mieux que mille mots :

Schéma feu tricolore

Et une photo, le montage fini :

Montage feu tricolore

La partie logicielle

La base

Nous allons maintenant écrire un petit morceaux de code pour contrôler nos DELs. Voulant m’initier à Python, cela m’a paru être une bonne occasion.

Donc, sur la Raspbian toute fraiche, j’ai installé les paquets suivant :

• Python, pour exécuter le code ;
• Python-dev, qui est requis pour une bibliothèque que nous allons utiliser ;
• Et vim, un vrai éditeur de texte.

Ensuite, pour interagir simplement avec les ports GPIO, nous allons utiliser la bibliothèque RPi.GPIO. Pour l’installer, c’est simple :

pip install RPi.GPIO

Il y a quelques phases de compilation, ça peut prendre quelques minutes.

Le code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

""" Feu tricolore en Python """
 
import time               #Gestion du temps, pour mettre en pause
import RPi.GPIO as GPIO   #Lib de gestion des GPIOs
import signal             #Gérer les interruptions systèmes
import sys                #Pour interagir avec le système
 
rouge = 22                #Nos numéros de ports GPIOs 
jaune = 17                #associés à la couleur
vert  = 18                #de la DEL
 
GPIO.cleanup()              #On ne connait pas l'état du port, donc on RAZ
GPIO.setmode(GPIO.BCM)      #On configure la numérotation des ports
GPIO.setup(rouge, GPIO.OUT) #Ici, on configure les ports en mode sortie
GPIO.setup(jaune, GPIO.OUT) #Ainsi, nous pourrons envoyer une tension
GPIO.setup(vert, GPIO.OUT)  #sur ceux-ci
 
#Fonction de gestion de l'interruption CTRL-C
#Histoire de remettre les ports GPIO à zéro
#avant de rendre la main
#
def signal_handler(signal, frame):
    print "Fermeture en cours"
    GPIO.cleanup()
    sys.exit(0)
 
#Fonction mettant le port GPIO passé en paramètre
#à l'état haut : allume la diode
#
def allume(couleur):
    GPIO.output(couleur, GPIO.HIGH)
    print "allume %d" % couleur
 
#Fonction mettant le port GPIO passé en paramètre
#à l'état bas : éteint la diode
#
def eteint(couleur):
    GPIO.output(couleur, GPIO.LOW)
    print "eteint %d" % couleur
 
#Ici, rien de bien méchant, on gère
#la séquence d'allumage des diodes
#
def changeCouleur(index):
    if(index == 0):
        allume(rouge)
        eteint(jaune)
        return 3
    elif(index == 1):
        allume(vert)
        eteint(rouge)
        return 1
    elif(index == 2):
        allume(jaune)
        eteint(vert)
        return 1
    else:
        return 0
 
#Ici, on associe le CTRL-C à notre fonction
signal.signal(signal.SIGINT, signal_handler)
 
#Et enfin, la boucle principale de notre programme
i = 0
while True:
    t = changeCouleur(i)
    i += 1
    if(i == 3):
        i = 0
    time.sleep(t)

Une fois le programme lancé, il va allumer séquentiellement la diode rouge durant trois secondes, puis la verte durant une seconde, puis la jaune durant une seconde et enfin recommencera son cycle.

Annexes

La documentation de RPi.GPIO : Lien