Raspberry Pi

Python et le port GPIO

Il est possible de trouver de multiples utilisations du Raspberry Pi sur Internet : serveur, passerelle multimédia, PC d'appoint… Tous ces projets mettent en œuvre le mini PC lui-même.

Cependant, au-delà de l'aspect mini PC embarqué, et de son OS Linux, cette cible possède un atout important : son port d'entrées-sorties, ou GPIO. Et ce dernier est souvent mal connu ou non exploité.

22 commentaires Donner une note à l'article (5)

Article lu   fois.

L'auteur

Site personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Introduction

Image non disponible
Source:http://www.clker.com/clipart-raspberry-pi.html

Ce tutoriel 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.

Bien que nous essayons de rester le plus clair possible, il se peut que certains concepts électroniques soient néanmoins évoqués. Je vous renvoie alors vers votre moteur de recherche préféré afin de mieux les appréhender.

II. Le Raspberry Pi

II-A. Présentation rapide

Le Raspberry Pi est une cible embarquée de type mini PC à moins de 50 €.

Le but initial du projet était de permettre aux étudiants de s'équiper du même matériel qu'en cours, et ce à moindres frais.

Après plusieurs années de développement, et plusieurs versions, le projet a bien évolué. Malgré son faible coût, la carte dispose d'un panel d'entrées-sorties honorable et se prête aussi bien à des applications statiques qu'embarquées.

II-B. Les systèmes d'exploitation disponibles

Bien que consistant en une cible embarquée, le Raspberry Pi dispose néanmoins d'un OS officiel appréciable, et non des moindres, puisqu'il s'agit tout simplement d'un Linux, entre autres une Debian. Cet OS a été surnommé Raspbianhttps://www.raspberrypi.org/downloads/.

La couche graphique est, par défaut, totalement désactivée, mais est très simple à lancer.

La communauté étant très active sur notre plateforme adorée, il est également possible d'y retrouver, entre autres, une Fedora, ou encore XBMC/Kodi, ou OSMX.

Parmi les OS annoncés dans l'avenir proche, nous pourrons citer le prochain Microsoft Windowshttp://www.developpez.com/actu/80907/Raspberry-Pi-2-six-fois-plus-puissant-pour-le-meme-prix-le-PC-prend-en-charge-Windows-10-qui-sera-disponible-gratuitement/, ainsi que Firefox OS.

II-C. Modèles et caractéristiques

Nous nous pencherons ici sur les modèles les plus couramment diffusés et ferons l'impasse sur les tout premiers modèles, ainsi que sur la gamme professionnelle, au format DIMM.

Image non disponible
Source:http://fr.wikipedia.org/wiki/Raspberry_Pi

Modèle

A

A+

B

B+

B2

CPU

Monocœur ARM 700 MHz

Quadricœur ARM 900 MHz

GPU

Décodeur vidéo Broadcam VideoCore IV

RAM

256 MO

512 MO

1 GO

USB

1 * USB2.0

2 * USB2.0

4 * USB2.0

Audio/vidéo

Jack 3.5, composite et HDMI

HDMI et jack audio/vidéo

Jack 3.5, composite et HDMI

HDMI et jack 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

L'alimentation, quelle que soit la carte, s'effectue par un connecteur micro‑USB. Les premières générations pouvaient être alimentées par un port USB, via un HUB. Ce n'est plus le cas des nouvelles versions (A+/B+/B2).

Ainsi, comme vous pouvez le constater, il existe toujours la possibilité de trouver un modèle plus adapté à son projet que les autres.

II-D. Le port GPIO

Les GPIO ne possèdent aucune protection. Il ne faut donc pas oublier d'utiliser des buffers ou des optocoupleurs si vous avez des doutes quant à votre montage.

Les modèles A et B possédaient un port GPIO à 26 points. Les modèles A+, B+ et B2 possèdent un port GPIO à 40 points, correspondant aux 26 points des modèles A/B plus 14 points supplémentaires. Un circuit conçu pour les versions A/B est donc compatible A+/B+/B2.

Pour la suite nous présenterons les deux versions à chaque fois.

Concernant les modèles A et B, il y a eu plusieurs révisions. Le câblage du GPIO a été modifié entre ces différentes versions. Le GPIO des versions A et B que nous verrons ici correspond à la dernière révision, qui est également la plus répandue : la 2.1.

Les entrées-sorties sont de type CMOS, et fonctionnent donc en +3.3V. N'essayez surtout pas de brancher des circuits TTL (+5V) sur les entrées-sorties, sans adaptation. Vous risqueriez de détruire votre Raspberry Pi.

II-D-1. Raspberry Pi - modèles A et B

Image non disponible
Fonctionnalités normales du port GPIO
Image non disponible
Fonctionnalités étendues du port GPIO

II-D-2. Raspberry Pi - modèles A+, B+, et B2

Image non disponible
Fonctionnalités normales du port GPIO
Image non disponible
Fonctionnalités étendues du port GPIO

L'ensemble de ces fonctionnalités peuvent être activées une à une selon vos besoins.

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.

II-D-3. Activation de l'I2C

La méthode que nous allons voir est la méthode standardisée à partir des versions « + ». Elle est donc compatible modèles A+, B+, B2.

  • Ouvrez un terminal, depuis une interface graphique, et/ou lancez la commande suivante :
 
Sélectionnez
sudo raspi-config
  • Cela lance l'interface de configuration du Raspberry Pi, sélectionnez « Advanced Options » puis validez :
Image non disponible
  • Sur le nouvel écran, sélectionnez « I2C » puis validez :
Image non disponible
  • Répondez « Yes » à toutes les questions qui suivent.
  • Rebootez votre machine.

     
    Sélectionnez
    sudo reboot
  • Testez que l'I2C est bien reconnu avec la commande suivante (elle doit vous renvoyer une ligne d'information) :
 
Sélectionnez
lsmod | grep i2c_

Voilà, vous disposez de l'I2C activé par défaut sur votre Raspberry Pi.

II-D-4. Activation du SPI

La méthode que nous allons voir est la méthode standardisée à partir des versions « + ». Elle est donc compatible modèles A+, B+, B2.

  • Ouvrez un terminal, depuis une interface graphique, et/ou lancez la commande suivante :
 
Sélectionnez
sudo raspi-config
  • Cela lance l'interface de configuration du Raspberry Pi, sélectionnez « Advanced Options » puis validez :
Image non disponible
  • Sur le nouvel écran, sélectionnez « SPI » puis validez :
Image non disponible
  • Répondez « Yes » à toutes les questions qui suivent.
  • Rebootez votre machine.

     
    Sélectionnez
    sudo reboot
  • Testez que le SPI est bien reconnu avec la commande suivante (elle doit vous renvoyer une ligne d'information) :
 
Sélectionnez
lsmod | grep spi_

Voilà, vous disposez du SPI activé par défaut sur votre Raspberry Pi.

II-D-5. Activation de l'UART et des autres périphériques

Je pense que vous avez dès à présent compris comment activer ou non les différentes options de votre Raspberry Pi.

  • Ouvrez un terminal, depuis une interface graphique, et/ou lancez la commande suivante :
 
Sélectionnez
sudo raspi-config
  • Cela lance l'interface de configuration du Raspberry Pi, sélectionnez « Advanced Options » puis validez :
Image non disponible
  • Sur le nouvel écran, sélectionnez l'option que vous voulez paramétrer, ici « serial » puis validez.
  • Répondez « Yes » à toutes les questions qui suivent.
  • Rebootez votre machine :
 
Sélectionnez
sudo reboot

Bien entendu, il vous faudra à chaque fois une bibliothèque adaptée pour pouvoir utiliser votre périphérique.

III. Python et le port GPIO

Pour la suite, nous partirons sur l'hypothèse que nous développons sur le dernier modèle à savoir un Raspberry Pi B2.

III-A. 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 : RPi.GPIO.

Pour l'installer, il suffit donc d'un simple pip install :

 
Sélectionnez
pip install RPi.GPIO

Si vous ne possédez pas encore pip, il vous suffit de charger get-pip.py, 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.

 
Sélectionnez
1.
2.
wget https://bootstrap.pypa.io/get-pip.py
python get-pip.py

Bien entendu, n'oubliez pas d'utiliser un « sudo » si nécessaire.

Pour rappel, Python est sensible à la casse. Attention donc à l'import de RPi.GPIO. RPi s'écrit avec un i minuscule, et tout le reste est en majuscules.

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.

 
Sélectionnez
sudo python mon_script.py

III-B. La bibliothèque GPIO

 
Sélectionnez
import RPi.GPIO as GPIO

Concernant l'état des entrées-sorties (E/S), le module RPi.GPIO accepte des variables dédiées, des entiers ou des booléens.

Ainsi, l'état haut peut valoir au choix GPIO.HIGH, 1 ou encore True. De même, l'état bas peut valoir GPIO.LOW, 0 ou False.

III-B-1. Configuration générale

Le Raspberry Pi autorise deux numérotations : celle de la sérigraphie du connecteur de la carte (GPIO.BOARD), ou la numérotation électronique de la puce (GPIO.BCM). À vous de choisir celle que vous voulez.

Image non disponible

En noir la numérotation GPIO.BOARD. En rouge, la numérotation GPIO.BCM

 
Sélectionnez
1.
2.
3.
4.
5.
GPIO.setmode(GPIO.BOARD)
GPIO.setmode(GPIO.BCM)

# On peut aussi demander la configuration etablie
configuration = GPIO.getmode()

III-B-2. 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).

 
Sélectionnez
1.
2.
3.
GPIO.setup(12, GPIO.IN)                    # broche 12 est une entree numerique
GPIO.setup(12, GPIO.OUT)                   # broche 12 est une sortie numerique
GPIO.setup(12, GPIO.OUT, initial=GPIO.HIGH)# broche 12 est une sortie initialement a l'etat haut

III-B-3. Lire une entrée numérique

Afin de lire l'état d'une entrée, il suffit de préciser le numéro de l'E/S.

 
Sélectionnez
GPIO.input(12)

III-B-4. 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é.

 
Sélectionnez
GPIO.output(12, GPIO.LOW)

Un toggle (inversement d'état) s'effectue en inversant l'état lu.

 
Sélectionnez
GPIO.output(12, not GPIO.input(12))

III-B-5. Connaître la 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 alors GPIO.INPUT, GPIO.OUTPUT, GPIO.SPI, GPIO.I2C, GPIO.HARD_PWM, GPIO.SERIAL ou GPIO.UNKNOWN.

 
Sélectionnez
1.
2.
state = GPIO.gpio_function(pin)
print(state)

III-B-6. 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.

 
Sélectionnez
GPIO.cleanup()

III-B-7. 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.

Image non disponible
Source : http://commons.wikimedia.org/wiki/File:PWM_duty_cycle_with_label.gif

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.

Bien que n'ayant pas été notée sur le brochage du connecteur du GPIO, pour des raisons de clarté, la PWM est disponible sur GPIO18.

 
Sélectionnez
1.
2.
3.
4.
5.
p = GPIO.PWM(channel, frequence)
p.start(rapport_cyclique) #ici, rapport_cyclique vaut entre 0.0 et 100.0
p.ChangeFrequency(nouvelle_frequence)
p.ChangeDutyCycle(nouveau_rapport_cyclique)
p.stop()

III-B-8. 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 a pour but 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é.

 
Sélectionnez
1.
2.
GPIO.setup(channel, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(channel, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

III-B-9. 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.

 
Sélectionnez
GPIO.wait_for_edge(channel, GPIO.RISING)

Le second paramètre peut ici valoir GPIO.RISING, GPIO.FALLING ou GPIO.BOTH.

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.

 
Sélectionnez
1.
2.
3.
4.
GPIO.add_event_detect(channel, GPIO.RISING)
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 (GPIO.RISING), front descendant (GPIO.FALLING) ou bien les deux (GPIO.BOTH)).

 
Sélectionnez
1.
2.
3.
4.
5.
6.
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, GPIO.BOTH, callback=my_callback, bouncetime=75) 
#votre programme ici

Enfin, au besoin, vous pouvez supprimer les interruptions sur un canal très simplement.

 
Sélectionnez
GPIO.remove_event_detect(channel)

III-B-10. 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épendances.

Voici la liste des commandes à exécuter :

 
Sélectionnez
1.
2.
3.
sudo apt-get install build-essential libi2c-dev python-dev
sudo apt-get install libffi-dev i2c-tools 
sudo pip install smbus-cffi

III-B-11. 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 :

 
Sélectionnez
1.
2.
3.
4.
sudo apt-get install python2.7-dev
sudo apt-get install python3-dev
sudo apt-get libevent-dev
sudo pip install spidev

III-C. Mise en pratique

Maintenant que nous avons vu toute la partie théorique, je vous propose un peu de mise en pratique, avec quelques exemples concrets.

III-C-1. Gestion d'une LED

Nous allons ici piloter notre LED de deux façons. Tout d'abord, nous la ferons simplement clignoter. Basique, mais incontournable. Par la suite, nous ferons varier son intensité via la PWM.

La LED sera branchée sur la broche (pin en anglais) 3 du GPIO (GPIO2).

Image non disponible

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.

Blink.py
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
# Import des modules
import RPi.GPIO as GPIO
import time

# Initialisation de la numerotation et des E/S
GPIO.setmode(GPIO.BOARD)
GPIO.setup(3, GPIO.OUT, initial = GPIO.HIGH)

# On fait clignoter la LED
while True:
    GPIO.output(3, not GPIO.input(3))
    time.sleep(0.5)

Bien entendu, pour éclaircir votre code, vous avez la possibilité d'utiliser des variables intermédiaires. Par exemple, dans le code que nous venons de voir, vous auriez pu remplacer le « 3 » par une variable « led ».

Image non disponible

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

Pwm.py
Sélectionnez
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.
# Import des modules
import RPi.GPIO
import time

# Initialisation de la numerotation et des E/S
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT, initial = GPIO.LOW)

Rapport = 10.0
sens = True

p = GPIO.PWM(12, 200)
p.start(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
    p.ChangeDutyCycle(rapport)
    time.sleep(0.25)

III-C-2. 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).

Image non disponible
Button.py
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
# Import des modules
import RPi.GPIO
import time

# Initialisation de la numerotation et des E/S
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(19, GPIO.IN)

# Si on detecte un appui sur le bouton, on allume la LED 
# et on attend que le bouton soit relache
while True:
    state = GPIO.input(19)
    if not state:
        # on a appuye sur le bouton connecte sur la broche 19
        GPIO.output(12, GPIO.HIGH)
        while not state:
            state = GPIO.input(19)
            time.sleep(0.02)  # Pause pour ne pas saturer le processeur
        GPIO.output(12, GPIO.LOW)
    time.sleep(0.02)  # Pause pour ne pas saturer le processeur

III-C-3. 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. De fait, aucun souci d'incompatibilité.

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).

Les afficheurs LCD possèdent une mémoire pour créer des caractères spéciaux. On peut écrire et lire dans cette mémoire. Si au sein de votre projet, vous devez à un moment donné lire cette mémoire, il est indispensable d'adapter les signaux, a minima avec une diode Zener, au mieux avec un optocoupleur.

Image non disponible

Plutôt que de « réinventer la roue », nous allons utiliser une bibliothèque fournie par Adafruit : Adafruit_CharLCD.pyhttps://github.com/adafruit/Adafruit_Python_CharLCD/blob/master/Adafruit_CharLCD/Adafruit_CharLCD.py

Lcd.py
Sélectionnez
1.
2.
3.
4.
5.
6.
import RPi.GPIO
import adafruit_charlcd

lcd = Adafruit_CharLCD.Adafruit_CharLCD(pin_rs=14, pin_e=15, pins_db=[2,3,4,17])
lcd.clear()
lcd.message("Hello world !!!")
Image non disponible
Image non disponible

III-C-4. Lire un capteur de température I2C

Cet exercice n'est pas le mien, mais celui de M. Pascal YON, professeur à l'IUT GEII de l'université de Rennes 1.

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

Image non disponible
 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
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')
    fichier.write (str(temperature))
    fichier.write (',  ')
    fichier.close () 
    
    time.sleep(2)

III-C-5. 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.

Image non disponible
Spi.py
Sélectionnez
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.
from __future__ import division 
import spidev 
 
def lire_analog(puce_spi = 0, entree_analog = 1): 
    liaison = spidev.SpiDev(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())

IV. Allons plus loin

Maintenant que vous avez vu comment créer vos programmes et vous interfacer aisément avec l'extérieur, avec des montages externes simples, certains d'entre vous voudraient peut-être aller plus loin, en se créant leurs propres cartes maison.

Si tel était le cas, je vous conseille de vous orienter vers KICADhttp://www.kicad-pcb.org/display/KICAD/KiCad+EDA+Software+Suite pour la conception, et OSH PARKhttps://oshpark.com/ pour la fabrication.

KICAD est un logiciel open source de conception électronique, très diffusé maintenant et disposant d'une grande communauté. Il tourne sous Linux, Mac, Windows.

Vous trouverez de nombreux tutoriels, et aides, sur divers sites et forums.

L'intégralité des schémas de ce tutoriel a été effectuée avec KICAD. Notez que nous aurions également pu nous orienter vers un projet type Fritzinghttp://fritzing.org/home/, lequel permet d'effectuer des schémas plus concrets pour Arduino et Raspberry Pi.

OSH PARK est une association américaine à but non lucratif, ayant un partenariat avec une société de fabrication de circuits imprimés, moyennant un partenariat donnant-donnant : l'association ramène du chiffre d'affaires, et permet d'optimiser les chutes des professionnels, et en contrepartie l'association bénéficie de tarifs défiant toute concurrence.

Ainsi, une carte Arduino (la carte seule) revient à 11 €, le tout en connectique dorée et sérigraphiée.

Les frais de port sont gratuits à travers le monde entier. Les cartes sont vendues par multiples de trois, et le vernis est systématiquement violet.

Image non disponible
Une carte au format Arduino de chez OSH Park(Carte du scanner 3D Open SourceBQ Ciclop)

V. Conclusion

Comme nous venons de le voir, le Raspberry Pi est un mini PC dont les possibilités décuplent dès lors que nous prenons en compte son port GPIO.

Liaison concrète entre le monde de l'électronique et celui de l'informatique, le port GPIO est un outil fort pratique, et simple à interfacer grâce à Python.

Il fait ainsi du Raspberry Pi une cible idéale à embarquer et programmer en Python afin de réaliser :

  • de la robotique (robot suiveur, bras motorisé...) ;
  • de la domotique (station météo, pilotage de volets roulants, centrale d'alarme...) ;
  • ou tout autre projet que, il y a encore peu d'années, vous n'auriez pas pensé pouvoir réaliser vous-même.

J'espère que ce tutoriel vous aura permis de mieux l'appréhender et vous aura ouvert de nouvelles perspectives avec votre framboise numérique.

VI. Remerciements

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Licence Creative Commons
Le contenu de cet article est rédigé par Alexandre GALODE et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale 3.0 non transposé.
Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright © 2013 Developpez.com.