Utilisation du GPIO avec Wiringpi-python

Le site du projet https://github.com/WiringPi/WiringPi-Python

La bibliothèque WiringPI est une bibliothèque C écrite par Gordon ’drogon’ Henderson qui permet de contrôler le GPIO du raspberry pi.
Il existe une bibliothèque python Wiring-python qui permet d’utiliser WiringPi.

L’un gros avantage de cette bibliothèque est d’utiliser les sorties matériels PWM (hard pwm) alors que RPi.GPIO n’utilise que des versions logicielles des PWM (soft PWM) qui amènent beaucoup de jitter sur les sorties suivant le taux de charge du raspi.

Enfin, WiringPI utilise une syntaxe proche de celle d’Arduino.

NE PAS OUBLIER : LES ENTREES/SORTIES DU GPIO SONT EN 3,3V

Installation sur Raspbian Jessie

Utiliser la bibliothèque

1ère étape  : appeler la bibliothèque import wiringpi

2ème étape  : initialiser la bibliothèque

Lors de l’initialisation, on a 3 choix pour nommer les broches du connecteur :

Pour voir les broches en ligne :http://pinout.xyz/

Commander une sortie logique

Dans la suite, je vais utiliser la numérotation "physique" des broches sur le connecteur. Nous allons faire l’équivalent du "Hello World !" : faire "clignoter" la sortie broche 11.
Il va être nécessaire de configurer la broche 11 en sortie. Pour cela, on utilise les fonctions :

Le programme blink.py. On utilise la bibliothèque time pour réaliser les temporisations de 1s.

import wiringpi
import time
 
wiringpi.wiringPiSetupPhys()
wiringpi.pinMode(11,1)
 
while True :
    wiringpi.digitalWrite(11,0)
    time.sleep(1)
    wiringpi.digitalWrite(11,1)
    time.sleep(1)

Le programme doit être lancé en mode administrateur à l’aide de la commande sudo.

sudo python blink.py

On obtient le signal suivant sur la broche 11 :

Lire une entrée logique

On va lire l’entrée sur la broche 12 et afficher cet état dans la console.

Les fonctions utilisées :

le programme input.py

import wiringpi
 
wiringpi.wiringPiSetupPhys()
wiringpi.pinMode(12,0)
 
while True :
    input=wiringpi.digitalRead(12)
    if (input==0):
        print "broche 12 = 0"
    if (input==1):
        print "broche 12 = 1"

Contrôler les résistances de PULL UP et PULL DOWN

Les résistances de pull-up et de pull-down permettent de contrôler l’état des entrées lorsque celles-ci sont en l’air (typiquement, lorsque l’on utilise un interrupteur en entrée).

Avec résistance de pull down :

Avec résistance de pull up :

Exemple input2.py avec une résistance de pull-up :

import wiringpi
 
wiringpi.wiringPiSetupPhys()
wiringpi.pinMode(12,0)
wiringpi.pullUpDnControl(12,2)
 
while True :
    input=wiringpi.digitalRead(12)
    if (input==0):
        print "broche 12 = 0"
    if (input==1):
        print "broche 12 = 1"

Pour l’exécuter en administrateur : sudo python input2.py

Les sorties PWM (Pulse Width Modulation)

Le raspberry pi est équipé de 2 sorties PWM : broche 32 (BCM18) et broche 33 (BCM 27).
Le raspberry peut avoir 2 modes de fonctionnement (cf datasheet p139)

• le mode "balanced" : la fréquence n’est pas constante, ce qui peut poser problème lors de la commande d’un moteur ou d’une led...
• le mode "M/S" : c’est le mode que l’on utilisera car la fréquence est constante

Le programme pwm1.py suivant permet de générer un signal de rapport cyclique 700/1024=0.68=68%.

import wiringpi
 
wiringpi.wiringPiSetupPhys()
wiringpi.pinMode(32,2)
wiringpi.pwmSetMode(0)
 
wiringpi.pwmWrite(32,700)

Pour l’exécuter en administrateur : sudo python pwm1.py

Remarque : on peut aussi utiliser la broche 33 comme expliqué précédemment

Le chronogramme obtenu sur la broche 32 est le suivant :

Le période du signal est d’environ 3,4 x 500 us = 1,7 ms, soit une fréquence de 586 Hz environ (voir paragraphe suivant pour le calcul).

Réglage de la fréquence des sorties PWM et de la plage du codage du rapport cyclique

La fréquence des sortie PWM est définie par la relation :
pwmFrequency in Hz = 19.2 MHz / (pwmClock x pwmRange)

• pwmFrequency = fréquence des signaux PWM
• pwmClock = diviseur du signal d’horloge
• pwmRange = plage de variation du code du rapport cyclique

Ainsi, dans l’essai précédent (fonctionnement par défaut), on a pwmClock=33, et pwmRange=1024.

Par conséquent, si on souhaite augmenter le fréquence à quelques KHz, il faut changer le rapport de pwmClock (et diminuer pwmRange si on veut obtenir une fréquence supérieure à 18.75 kHz).

Le choix pwmClock=10 permet d’avoir une fréquence en sortie de 1.875kHz, ce qui est plus adapté pour un moteur.

Les fonctions pour configurer les sorties PWM :

Cela donne le programme pwm2.py suivant :

import wiringpi
 
wiringpi.wiringPiSetupPhys()
wiringpi.pinMode(32,2)
 
wiringpi.pwmSetMode(0)
wiringpi.pwmSetRange(1024)
wiringpi.pwmSetClock(10)
 
wiringpi.pwmWrite(32,700)

Pour l’exécuter en administrateur : sudo python pwm2.py

et le chronogramme qui correspond à la fréquence calculée :

Les temporisations

La bibliothèque permet de gérer des temporisations et des mesures de durées.
Pour utiliser ces fonctions, il est obligatoire d’initialiser la bibliothèque à l’aide d’une des 3 commandes wiringpi.wiringPiSetup...() .

Lorsque l’évènement (front montant, descendant ou les deux) est détecté sur l’entrée, on quitte le programme principal pour exécuter une fonction

ATTENTION : nous ne sommes pas avec un système "temps réel" comme avec un microcontrôleur. Du fait de l’OS GNU/Linux qui est multitâches et qui ne gère donc pas que notre programme (mais aussi l’affichage, le réseau ...) les durées des tempos sont des durées minimales qui peuvent être légèrement supérieures dans la pratique.

Exemple timing1.py qui permet d’afficher toutes les 500ms la durée depuis le lancement du programme (plus précisément depuis l’initialisation wiringpi.wiringPiSetup...() )

import wiringpi
 
wiringpi.wiringPiSetupPhys()
 
while True :
    wiringpi.delay(500)
    instant=wiringpi.millis()
    print instant

Voici ce que l’on obtient (on voit bien de légers décalages temporels qui apparaissent) :

Un 2ème exemple d’utilisation de la bibliothèque. On reprend le programme blink.py du début du tuto (faire changer d’état la sortie 11 toutes les secondes) mais sans utiliser la bibliothèque time.

Le programme timing2.py :

import wiringpi
 
wiringpi.wiringPiSetupPhys()
wiringpi.pinMode(11,1)
 
while True :
    wiringpi.digitalWrite(11,0)
    wiringpi.delay(1000)
    wiringpi.digitalWrite(11,1)
    wiringpi.delay(1000)     

Gestion des interruptions

Le bibliothèque permet de gérer les interruptions sur n’importe quelle broche du connecteur.
Cela peut être très pratique lorsque l’on ne veut pas faire du "polling" d’entrée (c’est à dire scruter constamment l’état des entrées).
Avec les interruptions, on peut détecter les changements d’états suivants : front montant (EDGE RISING), front descendant (EDGE FALLING), et les 2 (EDGE_BOTH).

Fonction :

Voici un programme interruption.py qui indique lorsqu’un front descendant (EDGE FALLING) est détecté sur la broche 11 du raspberry :

import wiringpi
 
def afficher():
    print "front descendant sur broche 11 ! "
 
wiringpi.wiringPiSetupPhys()
wiringpi.pinMode(11,0)
wiringpi.wiringPiISR(11,1,afficher)
 
while True :
    wiringpi.delay(1000)
    print "attente ..."