RPI GPIO & Python

nous allons aborder ici les bases de l’utilisation des entrées sorties du RPI avec Python sous thonny Python par exemple.

PERMISSIONS:

pour utiliser les GPIO en Python sur un raspberry Pi , il faut etre membre du groupe GPIO . l’utilisateur PI est membre par defaut , par contre , tout autre utilisateur doit etre déclaré manuellement:

sudo usermod -a -G gpio <username>

LES BIBLIOTHEQUES pour la gestion du GPIO:

il existe beaucoup de bibliotheques python pour le raspberry PI , les plus courantes pour la gestion GPIO sont les bibliotheques « RPi.GPIO » et « gpiozero » .

nous allons dans un premier temps explorer les modalité de fonctionnement avec la bibliotheque RPI.GPIO.

CONFIGURATION GENERALE:

le raspberry Pi utilise 2 numerotations , celle du connecteur 40 broches et celle liée a la numerotation de la puce (GPIO.BCM). suivant la numerotation choisie il faudra éventuellement adapter le mode avec les commandes python suivantes:

GPIO.setmode(GPIO.BOARD)

ou

GPIO.setmode(GPIO.BCM)

CONFIGURATION DES ENTREES/SORTIES:

pour initialiser les entrées-sorties , il faut préciser son numero en fonction de la configuration générale choisie et son paramétrage (entrée ou sortie) et peut etre son etat initial si nécessaire . ci dessous 3 exemples de bases:

GPIO.setup(14, GPIO.IN)

GPIO.setup(13, GPIO.OUT)

GPIO.setup(13, GPIO.OUT, initial=GPIO.HIGH)

LIRE UNE ENTREE:

pour recuperer l’etat d’entrée d’une broche , la commande est simple:

GPIO.input(12)

CHANGER L’ETAT D’UNE SORTIE:

GPIO.output(12, GPIO.LOW)

LE PWM:

le PWM fonctionne comme un objet sous python , il faut donc créer une instance avec le canal utilisé et la frequence souhaitée. ci dessous un exemple:

p = GPIO.PWM(channel, frequence)
p.start(rapport_cyclique) #rapport_cyclique entre 0.0 et 100.0
p.ChangeFrequency(nouvelle_frequence)
p.ChangeDutyCycle(nouveau_rapport_cyclique)
p.stop()

regardons maintenant quelques exemples avec la bibliotheque GPIOzero:

PREMIER EXEMPLE SIMPLE , la LED :

pour cet exemple nous allons utiliser la librairie GPIO zero. tous les détails de cette librairie sont disponible ici ( en anglais uniquement malheureusement):

https://gpiozero.readthedocs.io/en/stable/

petit avantage de la gestion GPIO sous Python du RPI par rapport a l’arduino, beaucoup de librairies spécifiques existent pour tous les composants basiques ou plus evolués , par exemple pour gérer l’allumage et l’extinction d’une led , on utilise une librairie , exemple ci dessous ( on fait clignoter une LED a frequence d’une seconde):

NOTA: pour l’utilisation de LEd sur RPI , avec une tension de sortie GPIO a 3,3 V , les resistance standard de 220 Ohms pour du 5V passent a 180 Ohms pour du 3,3V (165 Ohms en calcul theorique pour un courant a 20 mA).

from gpiozero import LED
from time import sleep

led = LED(17)

while True:
    led.on()
    sleep(1)
    led.off()
    sleep(1)

DEUXIEME EXEMPLE , le Bouton :

après avoir testé la commande d’une « sortie » , deuxieme cas simple , une entrée avec la réception d’un appui bouton:

ici , comme avec la LED , on branche le bouton entre la masse et la broche GPIO 2 et suivant la situation du bouton un message est affiché dans la zone de message en bas de l’IDE Thonny Python.

from gpiozero import Button
from time import sleep

button = Button(2)

while True:
    if button.is_pressed:
        print("Pressed")
    else:
        print("Released")
    sleep(1)

TROISIEME EXEMPLE , Bouton + LED:

ici on combine les 2 exemples précédents. après appui sur le bouton , la led s’allume.

from gpiozero import LED, Button

led = LED(17)
button = Button(2)

while True:
    if button.is_pressed:
        led.on()
    else:
        led.off()

COMMANDE de la PI camera avec un Bouton

dans cet exemple , nous allons déclencher la prise d’une image par la PIcamera ( voir rubrique TUTO et généralités pour la PIcamera). le branchement sera le même que pour le bouton seul sans PIcam car rien a rajouter:

et le programme tres simple également:
from gpiozero import Button
from picamera import PiCamera
from datetime import datetime
from signal import pause

button = Button(2)
camera = PiCamera()

def capture():
    timestamp = datetime.now().isoformat()
    camera.capture('/home/pi/%s.jpg' % timestamp)

button.when_pressed = capture

pause()

COMMANDE de la PI camera avec deux Boutons

variante du programme précédent avec 2 boutons qui vont pour l’un commander le start and stop de la camera et l’autre la prise d’une image .le deuxieme bouton est branché sur le GPIO 3.

from gpiozero import Button
from picamera import PiCamera
from datetime import datetime
from signal import pause

left_button = Button(2)
right_button = Button(3)
camera = PiCamera()

def capture():
    timestamp = datetime.now().isoformat()
    camera.capture('/home/pi/%s.jpg' % timestamp)

left_button.when_pressed = camera.start_preview
left_button.when_released = camera.stop_preview
right_button.when_pressed = capture

pause()

de la même façon, on pourrait remplacer le bouton par un détecteur de présence infrarouge ou une barrière lumineuse avec détecteur de luminosité pour détecter le passage dans le faisceau et ainsi déclencher la prise de vue.

GPIO & PHOTORESISTANCE

bien que le GPIO du RPI n’ait pas de broche analogique, nous allons voir comment lire l’intensite lumineuse avec une photo résistance .

le principe de la mesure est simple , on va utiliser la librairie  » gpiozero  » , et un condensateur de 1μF en série avec la photorésistance.

cela va constituer un circuit RC pour lequel la fonction Lightsensor() de la librairie GPIOZERO va mesurer le temps de charge et décharge du condensateur pour en déduire la résistance correspondante et donc la luminosité résultante. R = f ( luminosité).

LE MONTAGE

le programme Python:

from gpiozero import LightSensor

ldr = LightSensor(4)  # ici broche GPIO4
while True:
    print(ldr.value)

ne reste plus soit qu’a faire varier l’intensité lumineuse sur la photorésistance avec une lampe LED ou couvrir plus ou moins avec les doigts et/ou des filtres et voir comment varie la valeur affichée . bien entendu il est possible d’améliorer le programme avec une petite interface visuelle sous Tkinter …

GPIO & Capteur HC-SR501

voyons comment utiliser un capteur HC-SR501 sur le GPIO RPI.

  • broche Vcc du HC-SR501 sur le 5V du RPI
  • broche Gnd du capteur sur Gnd du RPI
  • broche Out (3,3V TTL) sur GPIO 4

LE PROGRAMME PYTHON:

from gpiozero import MotionSensor

pir = MotionSensor(4)

while True:
	pir.wait_for_motion()
	print("Ca Bouge !...")
	pir.wait_for_no_motion()

voila pas plus compliqué que ça , encore une fois c’est la librairie qui fait tout .

GPIO 8 entrées analogiques avec le MCP3008

le MCP3008 est un module de conversion ANALOGIQUE / NUMERIQUE qui fonctionne avec le Bus SPI du RPI .

nous allons voir comment l’utiliser directement sur une breadboard , mais on peut le commander en petit modules du genre du Ras Pio Analog Zero ci dessous :

CONFIGURATION du BUS SPI

pour pouvoir utiliser le Bus SPI du RPI , il va falloir tout d’abord l’activer , pour cela aller dans le menu de config du RPI et activer l’option SPI puis rebooter le RPI.

LE MONTAGE DE TEST

pour tester le fonctionnement du MCP 3008 nous allons utiliser un potentiomètre . ci dessous schéma de câblage de l’ensemble avec le potard sur la breadboard.

pour memo rappel des brochages GPIO SPI du RPI : ( voir RPI generalites)

LE PROGRAMME PYTHON

from gpiozero import MCP3008
pot = MCP3008(0)
while True:
    print(pot.value)

le MCP3008 possède 8 canaux d’entrée notés de 0 a 7 ( de bas en haut sur le montage a droite du MCP3008 ) , dans ce bout de programme on lit le canal 0 que l’on met dans la variable pot via la commande : « pot = MCP3008(0)  » puis on fait afficher la valeur dans une boucle while .

si l’on voulait lire 3 capteur Analogiques ( 3 potards par exemple sur les canaux 0 – 1 et 2 ) , il suffirait d’avoir 3 lignes du genre:

pot1 = MCP3008(0) 
pot2 = MCP3008(1) 
pot3 = MCP3008(2) 

voila synthétisée la façon de pouvoir utiliser jusqu’à 8 capteurs analogiques pour une station meteo par exemple.

moteur Pas a Pas type NEMA 17

comme pour l’Arduino, nous allons voir ici comment piloter un moteur Pas a Pas sur GPIO avec un programme Python. de la meme façon , nous allons utiliser un driver POLOLU A4988 , mais le principe est le même avec les autres drivers de la gamme POLOLU

avant de commencer la partie conexion RPI , petit rappel du schéma de principe d’un POLOLU A4988 (pour memo, le niveau logique TTL admissible est entre 3 et 5,5 V donc compatible avec la logique TTL 3,3V du RPI):

CABLAGE

GPIO 20 sur STEP du Pololu et GPIO 21 sur DIR du Pololu. MS1-MS2-MS3 non connecté => full step. pour le réglage de la limite d’intensité du Pololu voir la rubrique ARDUINO CNC.

ne pas oublier de mettre un condensateur 100micro Fahrad entre + et 6 de l’alim de puissance (Power Supply sur le schéma).

EXEMPLE PROGRAMME PYTHON n°1

le programme ci dessous fait faire un tour dans un sens puis un tour dans l’autre sens

from time import sleep
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)
GPIO.setup(20, GPIO.OUT)
GPIO.setup(21, GPIO.OUT)

GPIO.output(21, 1)
for x in range(200):
	GPIO.output(20, GPIO.HIGH)
	sleep(0.005)
	GPIO.output(20, GPIO.LOW)
	sleep(0.005)

sleep(0.5)

GPIO.output(21, 0)
for x in range(200):
	GPIO.output(20, GPIO.HIGH)
	sleep(0.005)
	GPIO.output(20, GPIO.LOW)
	sleep(0.005)