Fonctions et applications GPIO sur le Raspberry Pi

On entend souvent dire que les ordinateurs à carte unique Raspberry Pi sont un moyen très pratique de commencer une aventure électronique. Mais où les mondes de la programmation théorique et des circuits imprimés se rencontrent-ils réellement ?

TLDR, c’est-à-dire, pour les impatients

Prêt et souhaitez déjà commencer à programmer ? Allez ici.

Introduction

Les ordinateurs Raspberry Pi ont été développés comme un outil éducatif. Suivant l'exemple des "micro-ordinateurs" britanniques des années 80 (inspirés par les produits Commodore ou Apple), ils étaient conçus pour offrir une grande adaptabilité à bas prix. Et cet objectif a été atteint. Les modèles Raspberry Pi de la famille Zero sont même incroyablement abordables, tandis que le fabricant et la énorme communauté d’ingénieurs/enthousiastes fournissent une quantité innombrable de matériels pédagogiques, d’aides, de bibliothèques, etc. En fait, tout ce dont vous avez besoin pour développer vos compétences avec Raspberry Pi, c’est de l’enthousiasme. Et un peu de temps.

Du point de vue de l’électronique, la fonctionnalité la plus importante (et certainement la plus unique) du Raspberry Pi est la capacité à connecter directement l’ordinateur à des composants électroniques, électromécaniques, etc. Cela se fait via le connecteur GPIO — qui n’existe pas sur les ordinateurs portables ou de bureau. C’est la sortie des interfaces du microprocesseur et d’autres composants de la carte mère, qui dans d’autres appareils sont inaccessibles à l’utilisateur. Nous allons examiner ce connecteur et ses capacités.

Dans cet article, nous couvrons les sujets suivants :

• Une discussion sur le GPIO et ses diverses fonctions
• Les interfaces de communication de Raspberry Pi
• Comment éviter les plantages lors de l’apprentissage et du développement de projets
• Les environnements de développement les plus importants pour le RPi
• Bibliothèques Python pour gérer les broches GPIO
• Support d’entrée et sortie des broches numériques
• Connexion d’une ampoule 230V au Raspberry Pi
• Génération de signaux à onde carrée
• Introduction à l’interface I2C
• Produits utilisant le connecteur GPIO

Qu’est-ce que le GPIO ?

GPIO signifie General Purpose Input/Output, c’est-à-dire entrée/sortie à usage général. Et en effet, c’est ce que cette connexion spécifique sur la carte mère du RPi offre. Elle a subi seulement de légères modifications depuis la deuxième génération de l’ordinateur et est maintenant strictement standardisée, donc compatible entre différentes versions de l’appareil, toujours au même format et offrant les mêmes (ou au moins presque identiques) capacités.

Pour le format du connecteur, on a choisi la très populaire sortie "broche" en grille de 2,54 mm (0,1 pouce), couramment utilisée en électronique, et surtout — en éducation. L’espacement des broches est compatible avec, par exemple, les plaques de prototypage à contact, les modules Arduino et (littéralement) des millions de composants.

Disposition, types et capacités des broches individuelles

La documentation détaillée du GPIO est largement disponible sur Internet, ici nous ne discuterons que des bases — et accorderons une attention particulière aux fonctions pouvant être utilisées quasiment immédiatement après le démarrage de l’ordinateur. Le tableau suivant montre l’espacement des broches (à titre de référence : la broche n° 2 est la plus proche du coin de la carte) :

Le connecteur GPIO est toujours dans la même position relative aux trous de fixation.

Alimentation

Les broches d’alimentation sont divisées en celles fournissant une tension de 3,3V DC (1, 17), 5,0V DC (2, 4), et reliées à la masse système (6, 9, 14, 20, 25, 30, 34, 39). Le courant maximal tiré des broches GPIO est limité et dépend de plusieurs facteurs. Théoriquement, le circuit d’alimentation sur la carte mère peut fournir 1A pour le bus 3,3V, mais cette énergie est partagée entre tous les composants présents sur la carte. Pour les broches 5,0V — elles sont en court-circuit avec la ligne d’alimentation de tout l’ordinateur, donc la limitation est l’efficacité de l’alimentation utilisée et la puissance actuellement consommée par l’ordinateur (qui variera selon le modèle, les logiciels en fonctionnement, etc.). Les broches GND partagent le pôle de masse avec toute la carte mère.

Entrées/sorties numériques

Toutes les broches nommées GPIO peuvent agir comme des entrées et sorties numériques, ainsi que pour des fonctions associées exécutées par logiciel (par exemple la génération de signal PWM, émulation de l’interface i^2C). L’utilisateur peut librement définir leur état logique, qui correspondra à des tensions 0V pour l’état bas, et 3,3V pour l’état haut. Il est aussi possible de configurer ces contacts en entrée, c’est-à-dire vérifier si une tension de 3,3V leur est appliquée ou non — ce qui permet, par exemple, de manipuler des boutons et interrupteurs en lisant leur état.

Veuillez noter que sous aucun prétexte une tension supérieure à 3,3V ne doit être appliquée — cela endommagerait de façon permanente l’ordinateur.

De même : le courant tiré des broches lorsqu’elles agissent en sortie ne doit pas dépasser quelques milliampères.

Interfaces de communication série

En pratique, le fonctionnement des circuits électroniques modernes repose sur des interfaces de communication, telles que UART, I²C, SPI, etc. Ce sont des méthodes de communication série, c’est-à-dire qui transmettent les données bit par bit. Cette communication peut être implémentée au niveau matériel (gérée par un circuit spécialisé) ou au niveau logiciel (le processeur contrôle directement l’émission et la réception des signaux via des sorties et entrées numériques). Dans le premier cas, l’utilisateur doit utiliser les broches que les concepteurs ont prévues pour une fonction spécifique ; dans le second, il peut choisir librement les points de connexion, mais la communication peut gêner ou ralentir temporairement le fonctionnement du programme — mais à un niveau basique, nous pouvons ignorer ces problèmes.

I^2C

Le bus I^2C (acronyme de Inter-Integrated Circuit) est très populaire dans d’autres appareils électroniques — mais aussi pour des projets amateurs. Cela tient à sa simplicité facilitant l'émulation logicielle, la possibilité de connecter de nombreux périphériques, une large tolérance en termes de vitesse de transmission, ainsi que la large disponibilité de composants et capteurs compatibles standards. Seulement deux lignes sont nécessaires pour l’interface : la ligne d’horloge (SCL, de signal clock, broche 5) et la ligne de données (SDA, signal data, broche 3). On peut connecter (théoriquement) 128 puces indépendantes au bus (y compris la puce hôte, donc dans notre cas le Raspberry Pi) — chacune doit avoir une adresse unique (généralement définie en partie).

SPI

L’interface série SPI (Serial Peripheral Interface) fonctionne légèrement différemment de l’I^2C, en mettant l’accent sur la résilience de transmission. Le GPIO du Raspberry Pi possède deux telles interfaces, mais ici nous nous concentrerons sur la principale (numérotée 0).

Dans la communication SPI, au lieu d’adresser des puces individuelles, chacune reçoit sa propre ligne CE (Chip Enable), utilisée pour activer la communication avec un périphérique donné (les broches 24 et 26 permettent de gérer deux récepteurs indépendants). La communication s’effectue autrement avec deux lignes indépendantes : une allant du maître (Master) à l’esclave (Slave), c’est-à-dire Master Out, Slave In (MOSI , broche 21) ; et dans la direction inverse : Master In, Slave Out (MISO), broche 10). La dernière ligne est l’horloge CLK sur la broche 23.

SPI permet une communication plus rapide que l’I^2C, pouvant se faire en mode full-duplex (transmission simultanée dans les deux directions). Le protocole est simple et flexible. De nombreuses mémoires et modules utilisent cette méthode de transmission.

UART

Autrefois, le "port série" était l’équipement de base de chaque ordinateur, aujourd’hui sa fonction est reprise par le standard USB dérivé. UART signifie Universal Asynchronous Receiver-Transmitter, c’est-à-dire récepteur-transmetteur asynchrone universel. C’est une méthode de communication utilisée depuis des décennies, principalement pour envoyer des commandes alphanumériques. Comme dans le RPi cette interface est matérielle, la gestion des tampons et l’envoi des données se fait nativement, assurant une transmission très stable même à des débits élevés (typiquement 9600 b/s). La limitation est malheureusement assez restrictive — UART est utilisé uniquement pour la communication entre deux appareils. Néanmoins, de nombreux modules électroniques, par exemple récepteurs GPS, modems GSM (LTE, 4G, 5G), nécessitent cette interface.

Deux broches GPIO sont utilisées pour la communication UART : transmission (TXD, de transmit, n° 8) et réception (RXD, receive, n° 10). Rappelez-vous qu'un bon fonctionnement nécessite que les deux appareils soient réglés sur le même débit en bauds.

Sécurité et bonnes pratiques

Avant d’aborder les applications pratiques et exemples, examinons les considérations de sécurité — les deux plus importantes ont déjà été mentionnées :

Tension uniquement 3,3V DC

Contrairement à Arduino, les broches logiques et interfaces de Raspberry Pi (celles discutées ci-dessus !) fonctionnent sous 3,3V DC. Il sera donc préférable de connecter des circuits fonctionnant sous cette tension à l’ordinateur — sinon un convertisseur de niveau (un composant qui "traduit" une plage de tension en une autre) est nécessaire.

Économisez l’électricité !

Chaque broche GPIO peut fournir au maximum 16mA (et la consommation totale ne doit pas dépasser environ 50mA), vous devez donc choisir soigneusement les composants pour ne pas surcharger les capacités de l’ordinateur. Pour gérer des charges plus élevées, il est préférable d’utiliser des éléments intermédiaires (transistors, relais) — nous en apprendrons davantage plus loin dans l’article.

Utilisez des diodes de protection et des filtres

Lors de l’utilisation de composants générant du bruit et des surtensions, il est recommandé d’utiliser des éléments supprimant d’éventuelles interférences (par exemple des diodes en court-circuit sur les bobines de relais, des condensateurs filtrant la tension en sortie des moteurs DC). Cela évitera des problèmes au niveau logiciel, ainsi que des pannes possibles.

Manipulez calmement l’alimentation de l’ordinateur et des périphériques

Un article séparé sera dédié aux mises en marche et arrêt des ordinateurs Raspberry Pi — mais une chose est certaine, déconnecter et reconnecter l’alimentation "à chaud" est une mauvaise idée. Cela peut être tentant en cas de plantage d’un programme. Il est donc bon de se souvenir que sous Linux (et dans son terminal) on utilise le raccourci Ctrl+C pour interrompre un programme. Pour éteindre l’ordinateur, il faut préférer la commande sudo shutdown -h ou sudo poweroff, ou encore une commande analogue depuis le menu principal (en cas d’interface graphique).

Pour la connexion des composants externes, il est préférable de le faire ordinateur éteint. Bien sûr, ce n’est pas toujours pratique, par exemple lors de la correction d’un programme/circuit. Dans ces situations, il faut simplement garder son bon sens et (d’autant plus) se souvenir d’utiliser des composants intermédiaires.

La prudence n’est jamais de trop

Enfin, rappelons simplement que la prudence est de mise. Elle permet d’éviter bien des erreurs inutiles et potentiellement dangereuses, par exemple les courts-circuits. Il est également utile de prototyper vos circuits sur une plaque à contact et d’utiliser des câbles de couleurs standardisées et différentes (par ex. noir pour la masse, rouge pour l’alimentation), afin de corriger plus efficacement les erreurs inévitables.

Exemples d’interaction et de programmation

Comme les systèmes Raspberry Pi sont basés sur le noyau Linux, et que le dispositif est conçu pour l’éducation, nous disposons d’un large éventail d’environnements de développement permettant d’interagir avec le port GPIO. Nous allons ici privilégier le langage Python, fondamental pour les ordinateurs du fabricant britannique, mais il est bon de connaître les alternatives.

Scratch

Pour les jeunes utilisateurs débutant en programmation, une introduction intéressante à l’interaction avec des composants électroniques est Scratch. Cet environnement visuel permet de construire des programmes complexes par blocs (chacun représentant une instruction, un opérateur ou une fonction) connectés à l’écran comme des briques. Typiquement, cet outil est utilisé pour créer des jeux simples, etc. Raspberry Pi OS inclut une version de Scratch avec des fonctionnalités supplémentaires : lecture et réglage des états logiques sur les broches GPIO. Les débutants peuvent ainsi en quelques instants réaliser un programme commandant un interrupteur, des LED, ou même un contrôleur de moteur DC.

C/C++

Pour ceux qui connaissent C ou C++, communiquer avec le port GPIO ne posera pas de grandes difficultés. La version complète du système RPi inclut les compilateurs gcc et g++, donc un simple éditeur texte comme nano (également préinstallé) suffit pour écrire un programme. Une bibliothèque pour gérer le port devra être installée. Actuellement, pigpio est la plus couramment utilisée, ou l’ancienne (et non plus maintenue) solution WiringPi.

Java

La situation est similaire avec Java, bien qu’il faille ici installer l’environnement soi-même, en lançant les commandes sudo apt update et sudo apt install default-jdk. Vous aurez alors accès à la dernière version disponible de Java. Depuis plusieurs années, le projet Pi4J (prononcez "Pi pour Java") est en développement, qui fournit un ensemble complet d’outils de développement pour supporter les interfaces de l’ordinateur via Java, via une API orientée objet et lisible. Les développeurs y ont prévu un accès aux broches GPIO, au bus I^2C, au générateur PWM et à la communication série.

Node-RED

Pour ceux familiers avec la programmation des systèmes d’automatisation, une alternative intéressante aux options ci-dessus sera la possibilité d’installer Node-RED. C’est un logiciel pour exécuter des applications de contrôle des dispositifs, traitement des données, etc. Il fonctionne dans un navigateur web, ainsi nous n’avons pas besoin de connecter un moniteur à notre RPi — il peut être placé dans un boîtier séparé, par exemple pour un projet électromécanique. La connexion se fait via l’adresse IP locale de l’ordinateur. Node-RED se prête parfaitement à la création de projets IoT, domotique, etc. L’installation de l’environnement se fait via un script auto-publié sur Internet, tapez simplement dans le terminal bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered).

Modules/bibliothèques Python populaires

Pour le langage Python, l’apprentissage est beaucoup plus facile, car l’un des objectifs du RPi était de populariser ce langage — déjà réputé pour sa philosophie stricte, sa transparence et sa relative simplicité. Les utilisateurs intéressés par le support GPIO en Python disposent de 4 bibliothèques de base.

RPi.GPIO

La première, la plus ancienne, est RPi.GPIO — elle n’est pas recommandée pour les projets sous Raspberry Pi 5, mais fonctionne bien avec les versions plus anciennes de l’appareil, et était installée par défaut sur Raspberry Pi OS jusqu’en 2023.

gpiozero

La bibliothèque gpiozero fait partie des niveaux supérieurs — cela signifie quelle est plus conviviale (par ex. avec des classes objets prêtes à l’emploi), mais peut causer des délais d’exécution du programme. Ils seront acceptables lors de l’apprentissage et dans les programmes les plus simples, mais dans des applications requérant précision cette solution peut être incommode. Installez la bibliothèque avec les commandes : sudo apt update et sudo apt install python3-gpiozero.

pigpio

Une alternative supportée par tous les modèles RPi (de 1A à 5, y compris les versions Zero 1, W et 2) est l’outil pigpio, qui comprend en fait deux composants. Un démon tournant sur le système et une bibliothèque, qui permet de le contrôler depuis Python. Cette solution présente plusieurs avantages (vitesse, compatibilité), toutefois la dépendance à un logiciel additionnel n’est pas toujours souhaitable. Peut-être que le plus grand avantage de pigpio est le support du PWM et de l’I²C.

lgpio/libgpiod

Les bibliothèques lgpio et libgpiod sont basées sur ce qu’on appelle "libgpiod". caractères de périphériques (/dev/gpiochipN). Elles remplacent l’ancienne approche basée sur sysfs, que Linux abandonne progressivement. Ces bibliothèques permettent un contrôle direct, sûr et efficace des broches GPIO. Elles sont recommandées pour de nouveaux projets, y compris Raspberry Pi. Cependant : comme ces solutions sont (temporairement) moins populaires et assez peu documentées, nous les passerons sous silence dans la suite.

Mise en état de la sortie GPIO

Pour écrire un programme en Python, ouvrez simplement un éditeur de texte, placez le code puis enregistrez-le dans un fichier au format nom.py — de préférence dans un endroit accessible, par ex. le dossier personnel /home. Ensuite, lancez le script depuis un terminal, en vous plaçant dans le répertoire et en utilisant la commande python nom.py, éventuellement sudo python nom.py (l’usage des permissions superutilisateur peut être parfois nécessaire, notamment avec la bibliothèque pigpio).

Dans le premier exemple simple, qui est de faire clignoter les LED connectées au GPIO, nous allons utiliser la bibliothèque RPi.GPIO. Le montage électrique est le suivant :

Pour le code du programme, il peut ressembler à ceci :

import RPi.GPIO as GPIO
from time import sleep

GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)

print("Ctrl+C → STOP")

try:

    while True:
        GPIO.output(18, GPIO.HIGH)
        sleep(1)
        GPIO.output(18, GPIO.LOW)
        sleep(1)

except KeyboardInterrupt:
    print("
Arrivederci!")
    GPIO.cleanup()

En premier lieu, nous déclarons que nous utiliserons la bibliothèque RPi.GPIO (et l’appellerons GPIO), et que depuis la bibliothèque time nous allons utiliser uniquement l’instruction sleep (qui cause une pause du programme pendant un temps spécifié en secondes).

Nous précisons que dans ce programme nous nous référons aux broches par leur numéro GPIO (selon le tableau fourni au début du texte), et non l'ordre des broches sur le connecteur : GPIO.setmode(GPIO.BCM). Ensuite, nous configurons GPIO18 comme broche de sortie.

Nous incluons ensuite une instruction informant l’utilisateur que pour arrêter le programme, il faut presser la combinaison Ctrl + C. Pour que l’arrêt soit correct et que toutes les actions effectuées par Python sur le GPIO soient interrompues, la sortie ne doit pas être "brutale", c’est pourquoi nous utilisons la structure try … except. Cela fait que le code à l’intérieur du bloc try s’exécutera tant qu’une interruption Ctrl+C ne sera pas détectée (KeyboardInterrupt) — alors Python passera au bloc except et terminera son exécution en saluant l’utilisateur et en libérant le GPIO via GPIO.cleanup().

Le bloc principal du programme est écrit sous forme de boucle infinie (comme dans l’environnement Arduino). Autrement dit, les instructions sous while True seront exécutées sans cesse (car True est toujours vrai). Ainsi, nous mettons d'abord l’état haut sur la broche 18 (GPIO.HIGH), puis attendons une seconde, puis mettons l’état bas (GPIO.LOW), encore une seconde d’attente, puis retour au début de la boucle. En résultat, les diodes connectées s’allument et s’éteignent, jusqu’à interruption du programme.

Contrôle d’une ampoule 230V

Notons ici que du point de vue du programme le contrôle d’une ampoule 230V serait identique. En revanche, le montage électrique serait modifié, selon un schéma plus complexe :

La fermeture du circuit d’une ampoule alimentée sur secteur (L1) se fait via un relais (K1) avec une bobine 5V DC, alimentée depuis le connecteur GPIO. Le passage du courant est assuré par un transistor (Q1), grâce auquel un tout petit courant de base provenant de la broche 18 suffit à commander le circuit. On peut aussi placer une LED (D2) et sa résistance (R2), ce qui servira de témoin de fonctionnement du transistor. La diode D1 est un dispositif de protection typique, servant à éliminer les interférences générées à l’entrée du relais lorsque les contacts reviennent à leur position au repos, c’est-à-dire quand le circuit est ouvert — ainsi, le connecteur GPIO, l’alimentation de l’ordinateur et les transistors sont protégés.

Lecture de l’état du GPIO

La lecture de l’état sur une broche GPIO est tout aussi simple. Faisons-le cette fois avec la bibliothèque gpiozero et les deux méthodes différentes de lecture d’état qu’elle offre.

Le schéma pour les deux exemples est très simple :

Nous utilisons un interrupteur à contacts normalement ouverts (NO), cela peut être un bouton monostable ordinaire ou un levier bistable.

Le premier code de programme est :

from gpiozero import Button
from time import sleep

SW = Button(21)

print("Ctrl+C → STOP")

try:

    while True:
        print(SW.value)
        sleep(0.5)

except KeyboardInterrupt:
    print("
Hasta la vista!")

On remarque tout de suite que la structure est similaire au premier exemple, concentrons-nous donc sur les différences. D’abord, de la bibliothèque gpiozero, on importe seulement la classe Button. Contrairement à la bibliothèque RPi.GPIO, elle effectue la plupart des configurations. Il suffit de créer un nouvel objet de classe Button et lui assigner la broche 21 : SW = Button(21). Dans une boucle infinie, on vérifie l’état de l’interrupteur toutes les demi-secondes et on l’affiche sous forme textuelle : print(SW.value). Le terminal affichera une chaîne de 0 (bouton relâché) ou de 1 (bouton pressé) :

Ctrl+C → STOP
0
0
0
0
0
1
0
1
0
0
1
1

Il est important de noter qu’à la création de l’objet (SW)), une résistance de tirage interne (pull-up) a été connectée à la broche 21 — donc la tension de sortie est environ 3,3V. Quand la broche est mise à la masse par le bouton, la tension tombe sous le seuil de 0 logique (proche de 0V). Cependant, la bibliothèque gpiozero simplifie en inversant ces valeurs binaires. Bouton pressé vaut 1, bouton relâché vaut 0. C’est un exemple de simplification qui peut perturber un électronicien expérimenté.

Une fonction utile de gpiozero est la gestion des interruptions déclenchées par un changement d’état du bouton. L’exemple suit :

from gpiozero import Button
from time import sleep

SW = Button(21)

def on_press():
print("ON")
sleep(0.1)

def on_release():
print("OFF")
sleep(0.1)

SW.when_pressed = on_press
SW.when_released = on_release

print("Ctrl+C → STOP")

try:
    while True:
        print(".")
        sleep(0.5)

except KeyboardInterrupt:
    print("
Até logo!")

On voit qu’on a deux fonctions ici : l’une affiche ON, l’autre OFF. Dans les deux, on met un délai de 100 ms pour éviter que le programme signale plusieurs fois la même pression de bouton (le phénomène de debounce). Puis on indique que lors de la pression, la fonction on_press doit être exécutée, et lors du relâchement on_release. Puis la boucle infinie classique démarre, symbolisant ici des Opérations Très Importantes, elle sert seulement à afficher des points dans le terminal toutes les demi-secondes. La colonne de points sera interrompue (tout comme le déroulement du programme) lorsqu’un changement d’état de la broche 21 interviendra. Nous verrons :

Ctrl+C → STOP
.
.
.
ON
.
.
OFF
.
.

Génération de signal PWM

Pour générer un signal PWM, nous utiliserons la troisième des bibliothèques mentionnées, pigpio. Important : elle ne fonctionne pas seule. Après l’installation du paquet (sudo apt install pigpio), il faut encore lancer un processus tournant en arrière-plan (daemon), qui gérera à bas niveau les interfaces GPIO. On l’active en tapant dans le terminal sudo pigpiod.

Maintenant, on peut tester un programme Python :

import pigpio
import time

GPIO = pigpio.pi()
LED = 18

print("Ctrl+C → STOP")

try:

    while True:

        for duty in range(0, 256, 5):
            GPIO.set_PWM_dutycycle(LED, duty)
            time.sleep(0.01)

        for duty in range(255, 0, -5):
            GPIO.set_PWM_dutycycle(LED, duty)
            time.sleep(0.01)

except KeyboardInterrupt:
    GPIO.set_PWM_dutycycle(LED, 0)
    GPIO.feet()
    print("
Papa!")

Notre script appelle le programme pigpiod et il est représenté ici par un objet que nous appelons simplement GPIO. La structure du code est similaire au premier exemple des LED clignotantes, mais au lieu de changer l’état une fois par seconde, il le change à une fréquence imperceptible à l’œil humain, générant un signal carré PWM. Cela crée l’illusion que les LED s’éclaircissent ou s’abaissent. Le rapport entre la durée où l’état haut est actif par rapport à l’état bas s’appelle le rapport cyclique. Pour la bibliothèque pigpiod, le maximum est 255 (état haut continu), le minimum est 0 (l’inverse). Les valeurs intermédiaires produisent un effet d’éclairage partiel.

Ainsi, on crée deux boucles exécutées alternativement. Dans la première, la variable duty (rapport) prend les valeurs de 0 à 255 par pas de 5 (0, 5, 10, 15...) : for duty in range(0, 255, 5). On envoie alors cette valeur comme signal PWM sur la broche GPIO 18 (set_PWM_dutycycle). Dans la deuxième boucle, on inverse le processus, en décrémentant le rapport : for duty in range(255, 0, -5). Les LED vont éclaircir progressivement, puis s’atténuer. Si l’on veut accélérer ou ralentir ce processus, on modifie la durée dans time.sleep(0.01).

Connexion des moteurs servo

Maintenant que la génération de signal PWM a été abordée, consacrons un instant aux moteurs servo.

Les moteurs servo sont un moteur dans un seul boîtier avec un réducteur et un contrôleur. Selon le signal reçu, ils positionnent l’angle d’inclinaison de leur axe (orbite) avec précision. Pour piloter les servos modèles, on génère des signaux PWM à une fréquence de 50Hz (c’est-à-dire toutes les 20ms). Un remplissage de 500 µs (parfois 1000 µs) correspond à la position 0°, tandis que des impulsions d’environ 2500 µs correspondent à l’amplitude maximale (parfois 180°, parfois 270°, voire 360°). De nombreux mini-servos pour robotique amateure fonctionnent en 5V DC, donc un mécanisme simple peut être connecté directement à la broche GPIO :

Pour démarrer le moteur ainsi connecté, nous utilisons la fonction set_servo_pulsewidth, pour laquelle l’argument n’est pas le remplissage, mais la durée d’impulsion en microsecondes. Notre programme envoie un signal PWM au servo avec un état haut de 500 µs, puis 2500 µs. Cela provoque un mouvement alternatif de l’orbite.

Note : comme les servos diffèrent, notre moteur pourrait se comporter de façon chaotique — essayez alors avec 1000 et 2000.

import pigpio
import time

GPIO = pigpio.pi()
SERVO = 18

print("Ctrl+C → STOP")

try:

    while True:
        GPIO.set_servo_pulsewidth(SERVO, 500)
        time.sleep(1)
        GPIO.set_servo_pulsewidth(SERVO, 2500)
        time.sleep(1)

except KeyboardInterrupt:
    GPIO.set_PWM_dutycycle(SERVO, 0)
    GPIO.feet()
    print("
Au revoir!")

Gestion de l’I^2C

Gérer des composants via l’interface I^2C n’est pas compliqué, mais demande une bonne connaissance de la documentation du circuit/module utilisé. Pour gagner du temps, voici les premières étapes nécessaires pour établir une communication entre ordinateur et récepteur.

Pour la connexion, seuls deux câbles sont nécessaires — oui, comme décrit dans la section dédiée au bus I2C. Souvenez-vous que le dispositif doit fonctionner en 3,3V, et non 5V ! De plus, par défaut l’interface n’est pas activée. Pour l’exécuter, ouvrez un terminal et lancez l’outil de configuration fourni dans chaque version de Raspberry OS : sudo raspi-config. Là, dans la section 3 (Interface Options) sélectionnez l’option I5 (Enable/disable automatic loading of I2C kernel module). Confirmez. Puis quittez et redémarrez l’ordinateur avec sudo reboot.

Après ce nouveau démarrage, on peut installer le paquet i2c-tools, qui comprend plusieurs utilitaires utiles. Tapez sudo apt update puis sudo apt install i2c-tools. Si le récepteur est déjà connecté à l’interface I^2C, vérifiez sa détection en tapant i2cdetect -y 1 (ce dernier paramètre indique que l’on cherche les périphériques connectés sur l’interface n°1, i.e. sur les broches 3 et 5 du connecteur GPIO). On devrait voir une réponse telle que :

Le tableau résultant de l’outil i2cdetect.

Chaque ligne indique le début d’une adresse (en hexadecimal). Les colonnes correspondent au second caractère de l’adresse. Dans l’exemple, il n’y a qu’un seul appareil à l’adresse 0x27 (en décimal = 39) sur tout le bus. Donc dans notre programme c’est l’adresse à utiliser pour communiquer avec le périphérique — même si c’est le seul connecté.

La gestion la plus efficace de l’I^2C est fournie par la bibliothèque pigpio. La connaissance de quelques commandes suffit pour la communication :

Overlays

Les capacités du port GPIO ne se limitent pas à l’expérimentation avec des composants électroniques. Le connecteur GPIO sert aussi à d’autres usages, principalement la connexion de cartes d’extension, non seulement produites industriellement, mais aussi auto-construites.

Les "overlays" Raspberry, appelés aussi "HAT" : ce terme est une abréviation de Hardware Attached on Top, c’est-à-dire des modules connectés dessus. De nombreux fabricants proposent des overlays avec une large variété de fonctions. Parmi celles-ci les écrans, interfaces supplémentaires, contrôleurs pour moteurs (DC, BLDC, moteurs servo), adaptateurs pour d’autres standards (LEGO® Powered Up).

Comme le connecteur GPIO contient des broches d’alimentation, qui peuvent jouer non seulement le rôle de sorties, mais aussi d’entrées, souvent les HAT fournissent de l’énergie à l’ordinateur. Ici, il convient de distinguer principalement deux types d’overlays. Les premiers sont les UPS (Uninterrupted Power Supply), qui sont des alimentations sans coupure assurant le fonctionnement ininterrompu de l’ordinateur même en cas de coupure de courant (ils disposent de stabilisateurs et de batteries rechargeables). Ces HAT peuvent aussi servir pour prendre en charge des projets mobiles. La deuxième proposition intéressante est celle des adaptateurs PoE, Power over Ethernet permettant d’alimenter l’ordinateur Raspberry via un câble Ethernet (norme 802.3).

Résumé

Le connecteur GPIO est un des plus grands atouts des ordinateurs Raspberry Pi — et il est devenu un standard parmi les ordinateurs à carte unique. Outre les énormes possibilités qu’il offre aux ingénieurs, il constitue aussi un outil pédagogique idéal, offrant un pont entre le jeu avec les ordinateurs et l’apprentissage des composants électroniques. Une vaste foule d’enthousiastes s’est développée autour des ordinateurs raspberry Pi, accueillante envers les nouveaux utilisateurs et toujours prête à aider. Il serait dommage de rater une telle opportunité, alors si vous cherchez un moyen d’apprendre la construction de systèmes embarqués ou d’électronique complexe — il vous suffit de prendre les outils et les connaissances qui sont à votre portée.

Transfer Multisort Elektronik (TME) est l’un des plus grands distributeurs mondiaux de composants électroniques, de pièces électrotechniques, d’équipements d’atelier et d’automatisation industrielle. Le catalogue comprend plus de 1 500 000 de produits provenant de 1 300 fabricants leaders. Les centres logistiques modernes de TME à Łódź et Rzgów (Pologne), avec une superficie totale de plus de 40 000 m², expédient près de 6 000 colis par jour à des clients dans plus de 150 pays.

TME investit également dans le développement des connaissances et compétences des jeunes ingénieurs et passionnés d’électronique grâce au projet TME Education et soutient la communauté technologique en organisant la série d’événements TechMasterEvent, promouvant l’innovation et l’échange d’expériences.