Raspberry Pi

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.

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 :

sudo raspi-config

• Cela lance l'interface de configuration du Raspberry Pi, sélectionnez « Advanced Options » puis validez :

• Sur le nouvel écran, sélectionnez « I2C » puis validez :

• 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) :

lsmod | grep i2c_

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

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 :

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 :

• 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) :

lsmod | grep spi_

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

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 :

sudo raspi-config

• Cela lance l'interface de configuration du Raspberry Pi, sélectionnez « Advanced Options » puis validez :

• 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 :

sudo reboot

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

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.

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

GPIO.setmode(GPIO.BOARD)
GPIO.setmode(GPIO.BCM)

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

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

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

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

GPIO.input(12)

Pour modifier l'état d'une sortie, il faut indiquer le numéro de la sortie, ainsi que l'état désiré.

GPIO.output(12, GPIO.LOW)

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

GPIO.output(12, not GPIO.input(12))

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.

state = GPIO.gpio_function(pin)
print(state)

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

GPIO.cleanup()

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.

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.

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

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

GPIO.setup(channel, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(channel, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

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

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

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.

GPIO.remove_event_detect(channel)

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 :

sudo apt-get install build-essential libi2c-dev python-dev
sudo apt-get install libffi-dev i2c-tools 
sudo pip install smbus-cffi

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

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

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.

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

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

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

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

# 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

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

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

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 !!!")

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.

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)

Nous allons ici utiliser un circuit SPI, plus précisément un MCP3202, qui est un convertisseur Analogique/Numérique 12 bits.

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