Bonjour à tous,
beaucoup ce demande comment fonctionne les GPIO sur le rasberry pi et c’est bien normal. Ces GPIO sont très utilisées pour la domotique mais pas seulement, on peut s’en servir pour des montages électroniques, contrôle de robot, etc.
GPIO
C’est l’abréviation de General Purpose Input/Output, ou plus simplement entrées/sorties générales. Elles fonctionnent en 3,3v sur le raspberry et sont au nombre de 17.
Les I/O sont représentées par GPIO <numéro> (fonction secondaire). Celles avec des — ne sont pas utilisées, certaines sont connectées à la masse, d’autres au 3,3v et 5v. Il est donc déconseillé de les utiliser.
Pour les piloter des exemples sont fournis par raspbian en python. Personnellement je ne connais pas ce langage je suis plus familiarisé avec le C. Je vais donc vous parlez d’un outil permettant de les manipuler en ligne de commande et en langage C.
wiringPi
wiringPi est une bibliothèque écrite en langage C par Gordon Henderson qui fournis des outils pour utiliser les GPIO : projects.drogon.net/raspberry-pi/wiringpi
Vous risquez peut être de tomber sur une page dont le certificat n’est pas conforme. Ceci n’est pas grave vous pouvez tout de même accéder au site sans risque. Le site fonctionnais sans erreur jusqu’à ce jour. Remarquer que les liens sont en https, le site ne parvient simplement pas à envoyer le certificat alors que le site n’utilisais pas la connexion sécurisée avant.
Pour installer wiringPi il faut télécharger le projet via la commande suivante :
wget https://git.drogon.net/?p=wiringPi;a=snapshot;h=98bcb20d9391ebde24f9eb1244f0d238fb1a1dab;sf=tgz
Si vous avez une erreur comme expliqué plus haut utilisez :
wget --no-check-certificate https://git.drogon.net/?p=wiringPi;a=snapshot;h=98bcb20d9391ebde24f9eb1244f0d238fb1a1dab;sf=tgz
Une fois téléchargé, il faut extraire les fichier et les compiler comme suite :
tar xfz wiringPi-98bcb20.tar.gz
cd wiringPi-98bcb20
./build
Si cela a fonctionné utilisez ceci pour le vérifier :
gpio -v
qui vous donne la version de wiringPi installée. Avec wiringPi le nommage des GPIO a légèrement changé :
wiringPi Pin : correspond aux numéro de pin utilisé avec wiringPi- BCM GPIO : numérotation classique du raspberry pi, comme sur ma première image
- R1 / R2 : Révision 1 / Révision 2 du raspberry.
Les GPIO en ligne de commande
La pratique étant le meilleur exemple je vais vous montrez comment allumer une led. Voici le schéma réalisé
Je vous ai dit de ne pas utilisé les sorties — car elles étaient indéterminées. Moi je sais que celle que j’ai utilisé est connectée à la masse (Ground) en regardant les schéma du raspberry. Dans mon cas je n’avais que des connecteurs femelles 3 broches à ma disposition.
Avant d’allumer ou éteindre une led il faut paramétrer les pins en entrée ou en sortie :
gpio [-g] mode <pin> in/out/pwm/up/down
- gpio : commande permettant de manipuler les gpio, tout ce qui ce trouve juste après sont des options ou paramètres.
- [-g] : est optionnel, cette option permet d’employer la notation BCM comme numéro de pin.
- mode : défini le mode qui sera utilisé par la pin
- <pin> : est un paramètre qui attend le numéro de la pin, si l’option -g n’est pas utilisée référez vous aux colonnes situées au extrémité du tableau précédent.
- in : paramètre la pin en entrée.
- out : paramètre la pin en sortie.
- pwm : sans entrer dans les détails, c’est ce qui permet d’avoir un signal analogique en sortie.
- up/down : active une résistance de pull-up ou pull-down (expliqué par la suite).
Dans mon exemples j’utilise les GPIO 0 et 7, je vais donc les configurer toutes les deux en sorties :
gpio mode 0 out
gpio mode 7 out
Pour mettre les sorties a l’état haut, soit 3,3v, il faut utiliser les commandes :
gpio write 7 1
gpio write 0 1
Le dernier paramètre défini l’état de la sortie :
- 0 : LOW – état bas – sans tension
- 1 : HIGH – état haut – avec tension.
Ces commandes sont pratique pour des petits scriptes bash manipulant les GPIO mais insuffisant pour faire des interactions avec l’utilisateur poussées, pour cela il faut passer par un langage comme le PHP/Javascripte qui utilise des scriptes bash ou un langage procédural comme le C (il existe également une librairie java pour ceux qui préfère la programmation objet).
Je n’ai expliqué que le fonctionnement des commandes de bases, bien d’autres sont disponibles sur le site de Gordon.
Les GPIO en langage C
Étant personnellement un grand utilisateur du mode console je vais vous montrez comment compiler en ligne de commande. Pour ceux qui préfaire utiliser un utilitaire graphique pour compiler cela fonctionnera tout aussi bien. Si vous voulez également éditer le fichier avec un éditeur graphique puis le compiler en mode console ça fonctionne également.
Dans ce 2ième exemples je vais vous montrez comment détecter l’appuie sur un bouton et allumer une led. Un petit rappel ou une découvert pour certain, comment détecter l’appuie d’un bouton électriquement :
- Dans le cas de gauche, la résistance R2 n’a pas de courant car la broche INPUT n’est pas a la masse. On retrouve donc les 3,3V au bornes de la résistances et donc sur la broche INPUT, soit un état haut. Quand on appuie sur le bouton on place la borne inférieur sur à la masse. Un courant ce crée dans la résistance et INPUT est enfin connecté a la masse, soit 0V soit un état bas.
- Dans le cas de droite, la résistance R1 est connecté a la masse, la broche INPUT ne génère pas de courant, donc on retrouve a nouveau la même tension sur les bornes de la résistances, soit 0V qui ce répercute sur INPUT, donc un état bas. Quand on appuie sur le bouton on arrive dans le même cas de figure que la partie gauche sauf que INPUT est connecté directement sur la sortie du générateur de tension soit 3,3v, soit un état haut.
Le 2ème cas est dangereux, car le raspberry a une résistance interne faible, ce qui va provoquer un certain courant, si celui-ci est trop important il peut endommager votre raspberry pi. Ceci est valable pour tout montage de détection de bouton en général.
Résistance de pull-up et pull-down
Le Problème du cas précédent c’est qu’il faut dans un premier temps une résistance en plus du bouton, ce qui prend de la place. D’autre part il ne faut pas ce tromper dans le montage. Pour palier à cela on trouve une résistance dans le raspberry que l’on peut activer en pull-up, pull-down ou désactivée.
Une résistance de pull-up est connectée au générateur interne tandis qu’une pull-down est connectée à la masse.
Voici le montage que j’ai réalisé en utilisant la résistance de pull-up de la GPIO 7 :
Passons au code C. Pour commencer il faut créer un fichier C, pour cela utiliser votre IDE ou éditeur de texte préférer ou comme moi nano en mode console :
nano gpio.c
Voici le code source commenté :
#include <stdio.h>
#include <stdlib.h>
// Inclure la lib wiringPi.h
#include <wiringPi.h>
int main(){
// Initialiser la lib
if( wiringPiSetup() ){
fprintf(stderr, "Erreur lors de l'initialisation, est vous bien root ?");
exit(1);
}
printf("wiringPi est initialisé\n");
// Mode des pins
pinMode(0, OUTPUT);
pinMode(7, INPUT);
printf("pin 0, 7 sont en mode OUTPUT et INPUT\n");
printf("Application démarrée, appuyez sur CTRL+C pour l'arreter\n");
// Set la résistance de pull-up
pullUpDnControl(7, PUD_UP);
while(1){
if( !digitalRead(7) ) // Si on appuie sur le bouton
digitalWrite(0, HIGH); // On allume la led
else
digitalWrite(0, LOW); // Si non on l'eteint
}
return 0;
}
Je ne pense pas avoir besoin d’expliquer le code, pour ceux qui connaisse le langage C, il n’y a aucune difficulté, pour les autres je vous conseil de commencer par quelques tutos sur le langage C pour comprendre ceci.
Il faut ensuite compiler le code :
gcc -o gpio gpio.c -lwiringPi
- gcc : GNU C Compiler, compilateur C de la fondation GNU.
- -o gpio : cette option permet de définir le nom du fichier de sortie, si il n’est pas présent il prendra la valeur par défaut : a.out.
- gpio.c : fichier C à compiler
- -lwiringPi : permet de linker la librairie wiringPi
Pour exécuter le programme :
./gpio
Voici le résultat :
Aller plus loin
Voici les bases des GPIO avec raspberry pi. Pour ceux qui désirent aller plus loin et approfondir le sujet je leurs conseille l’auto apprentissage. Le site de Gordon est très bien fait : projects.drogon.net/raspberry-pi/wiringpi
Vous avez également dans le dossier où vous avez extrait les fichier de wiringPi un dossier:
wiringPi-98bcb20/
qui contient un sous-dossier
wiringPi-98bcb20/exmples
avec divers fichier C contenant des exemples sur le PWM, I2C et bien d’autres.
sources; plomteuxkevin.wordpress.com/2013/03/16/les-gpio/
Présentation
Le bus I2C (Inter Integrated Circuit) a été développé au début des années 80 par Philips Semiconductors pour permettre de relier facilement à un microprocesseur les différents circuits d'un téléviseur moderne.
Le bus I2C permet de faire communiquer entre eux des composants électroniques très divers grâce à seulement trois fils : un signal de données (SDA), un signal d'horloge (SCL) et un signal de référence électrique (masse).
Ceci permet de réaliser des équipements ayant des fonctionnalités très puissantes (en apportant toute la puissance des systèmes micro-programmés) tout en conservant un circuit imprimé très simple par rapport un schéma classique (8 bits de données, 16 bits d'adresse + les bits de contrôle).
Les données sont transmises en série à 100 Kbits/s en mode standard et jusqu'à 400 Kbits/s en mode rapide. Ce qui ouvre la porte de cette technologie à toutes les applications où la vitesse n'est pas primordiale.
De nombreux fabricants ayant adopté le système, la variété des circuits disponibles disposant d'un port I2C est énorme : ports d'E/S bidirectionnels, convertisseurs A/N et N/A, mémoires (RAM, EPROM, EEPROM,...), circuits audio (égaliseur, contrôle de volume,...) et autre drivers (LED, LCD,...).
Le nombre de composants qu'il est ainsi possible de relier est essentiellement limité par la charge capacitive des lignes SDA et SCL : 400 pF.
Afin de d'éviter les conflits électriques, les Entrées/Sorties SDA et SCL sont de type "collecteur ouvert".
Voici un schéma de principe :
Structure d'E/S d'un module I2C
Le CBus de Phillips est l'ancètre du bus I2C. Par d'autres constructeurs, il y a également SPI de Motorola et µWire de National SemiConductor.
Le protocole I2C
Plusieurs circuits pouvant être branchés en même temps sur le même bus, il a été nécessaire d'instaurer un protocole entre eux, afin d'éviter les problèmes dus à une prise de parole simultanée de différents modules. C'est le protocole I2C. Celui-ci définit la succession des états logiques possibles sur SDA et SCL, et la façon dont doivent réagir les circuits en cas de conflits.
Pour prendre le contrôle du bus, il faut que celui-ci soit au repos (SDA et SCL à '1'). Pour transmettre des données sur le bus, il faut donc surveiller deux conditions particulières : la condition de départ (SDA passe à '0' alors que SCL reste à '1') et la condition d'arrêt (SDA passe à '1' alors que SCL reste à '1').
Lorsqu'un circuit prend le contrôle du bus après avoir vérifié qu'il était pris, il en devient le maître. C'est lui qui génère alors le signal d'horloge.
Exemple de condition de départ et d'arrêt
Après avoir imposé la condition de départ, le maître applique sur SDA le bit de poids fort D7. Il valide ensuite la donnée en appliquant pendant un instant un niveau '1' sur la ligne SCL. Lorsque SCL revient à '0', il recommence l'opération jusqu'à ce que l'octet complet soit transmis. Il envoie alors un bit ACK à '1' tout en scrutant l'état réel de SDA. L'esclave doit alors imposer un niveau '0' pour signaler au maître que la transmission s'est effectuée correctement. Les sorties de chacun étant à "collecteur ouvert", le maître voit le '0' et peut alors passer à la suite.
Exemple de transmission réussie
Dans cet exemple : SCL (horloge imposée par le maître), SDAM (niveaux de SDA imposés par le maître), SDAE (niveaux de SDA imposés par l'esclave), SDAR (niveaux de SDA réels résultants).
- Transmission d'une adresse
Le nombre de composants qu'il est possible de connecter sur un bus I2C étant largement supérieur à deux, il est nécessaire de définir pour chacun une adresse unique. L'adresse d'un circuit, codée sur sept bits, est défini d'une part par son type et d'autre part par l'état appliqué à un certain nombre de ses broches ( Voir §9 ). Cette adresse est transmise sous la forme d'un octet au format particulier.
Exemple d'octet d'adresse
On remarque ici que les bits D7 à D1 représentent les adresses A6 à A0, et que le bit D0 est remplacé par le bit de R/W qui permet au maître de signaler s'il veut lire ou écrire une donnée. Le bit d'acquittement ACK fonctionne comme pour une donnée, ceci permet au maître de vérifier si l'esclave est disponible.
Cas particulier des mémoires
L'espace adressable d'un circuit de mémoire étant sensiblement plus grand que la plupart des autres types decircuits, l'adresse d'une information y est codée sur deux octets ou plus. Le premier représente toujours l'adresse du circuit, et les suivants l'adresse interne de la mémoire.
Les adresses réservées
Les adresses 00000XXX et 111111XX sont réservés à des modes de fonctionnement particuliers.
L'écriture d'une donnée par le maître ne pose pas de problème particulier :
Exemple d'écriture d'une donnée
Cas particulier d'utilisation d'ACK
L'écriture d'un octet dans certains composants (mémoires, micro-contrôleur,...) peut prendre un certain temps. Il est donc possible que le maître soit obligé d'attendre l'acquittement ACK avant de passer à la suite.
La lecture d'une donnée par le maître se caractérise par l'utilisation spéciale qui est faite du bit ACK. Après la lecture d'un octet, le maître positionne ACK à '0' s'il veut lire la donnée suivante ( cas d'une mémoire par exemple ) ou à '1' la cas échéant. Il envoie alors la condition d'arrêt.
Exemple de lecture d'une donnée
Gestion des conflits
La structure même du bus I2C a été conçue pour pouvoir y accueillir plusieurs maîtres. Se pose alors le problème commun à tous les réseaux utilisant un canal de communication unique : la prise de parole. En effet, chaque maître pouvant prendre possession du bus dès que celui-ci est libre, il existe la possibilité que deux maîtres prennent la parole en même temps. Si cela ne pose pas de problème sur le plan électrique grâce à l'utilisation de collecteurs ouverts, il faut pouvoir détecter cet état de fait pour éviter la corruption des données transmises.
Comme nous l'avons vu précédemment, pour prendre le contrôle du bus, un maître potentiel doit d'abord vérifier que celui-ci soit libre, et qu'une condition d'arrêt ait bien été envoyée depuis au moins 4,7µs. Mais il reste la possibilité que plusieurs maîtres prennent le contrôle du bus simultanément.
Chaque circuit vérifie en permanence l'état des lignes SDA et SCL, y compris lorsqu'ils sont eux même en train d'envoyer des données. On distingue alors plusieurs cas :
- les différents maîtres envoient les mêmes données au même moment ; les données ne sont pas corrompues, la transmission s'effectue normalement, comme si un seul maître avait parlé ; ce cas est rare.
- un maître impose un '0' sur le bus ; il relira forcément '0' et continuera à transmettre. Il ne peut pas alors détecter un éventuel conflit.
- un maître cherche à appliquer un '1' sur le bus ; s'il ne relit pas un niveau '1', c'est qu'un autre maître a pris la parole en même temps ; le premier perd alors immédiatement le contrôle du bus, pour ne pas perturber la transmission du second ; il continue néanmoins à lire les données au cas où celles-ci lui auraient été destinées.
Soit le chronogramme suivant :
Dans cet exemple :
SCLR : Horloge résultante.
SDA1 : Niveaux de SDA imposés par le maître n°1.
SDA2 : Niveaux de SDA imposés par le maître n°2.
SDAR : Niveaux de SDA réels résultants lus par les deux maîtres.
Analyse
Lors du deuxième octet, le maître n°2 cherche à imposer un '1' (SDA2) , mais relit un '0' (SDAR), il perd alors le contrôle du bus et devient esclave (Cas n°3) . Il reprendra le contrôle du bus, lorsque celui-ci sera de nouveau libre. Le maître n°1 ne voit pas le conflit et continue à transmettre normalement (Cas n°2). Au total, l'esclave a reçu les données du maître n°1 sans erreurs et le conflit est passé inaperçu.
Nouvelles caractéristiques
Afin de compenser quelques lacunes des premières spécifications du bus I2C (qui datent de 1982), quelques nouvelles améliorations ont été apportées à partir de 1993 :
- le mode rapide : le bus a désormais la capacité de transmettre des données jusqu'à une vitesse de 400 Kbit/s.
- des entrées à triggers de Schmitt afin de limiter la sensibilité au bruit.
- la mise en haute impédance d'un circuit non alimenté : ceci évite de bloquer le bus si un périphérique n'est pas alimenté.
- extension à 10 bits de l'adressage des circuits : l'adressage d'un circuit se fait maintenant sur 10 bits répartis dans deux octets d'adresse de la façon ci-dessous.
Adresses réservées
Les adresses 0000 0XXX ne sont pas utilisées pour l'adressage de composants. Elles ont été réservées par Phillips pour effectuer certaines fonctions spéciales.
- 0000 0000 : adresse d'appel général
Après l'émission d'un appel général, les circuits ayant la capacité de traiter ce genre d'appel émettent un acquittement.
Le deuxième octet permet définir le contenu de l'appel :
Remet tous les registres de circuits connectés dans leur état initial ( Mise sous tension ). Les circuits qui le permettent rechargent leur adresse d'esclave.
Les circuits qui le permettent rechargent leur adresse d'esclave.
Les circuits définissant leur adresse de façon matériel réinitialisent leur adresse d'esclave.
Cette commande joue le rôle d'interruption. XXXX XXX1 peut être l'adresse du circuit qui a généré l'interruption.
- 0000 0001: octet de start
Cet octet est utilisé pour synchroniser les périphériques lents avec les périphériques rapides.
- 0000 001X : début d'adressage CBus
L'émission de cet octet permet de rendre sourd tous les circuits I2C présents sur le bus. A partir de ce moment, on peut transmettre ce que l'on désire sur le bus, en utilisant par exemple un autre protocole. Le bus repasse en mode normal lors de la réception d'une condition d'arrêt.
Ces octets ne sont pas définis et sont ignorés par les circuits I2C. Ils peuvent être utilisés pour débugger un réseau multi-maître.
Les I/O sont représentées par GPIO <numéro> (fonction secondaire). Celles avec des — ne sont pas utilisées, certaines sont connectées à la masse, d’autres au 3,3v et 5v. Il est donc déconseillé de les utiliser.
Avant d’allumer ou éteindre une led il faut paramétrer les pins en entrée ou en sortie :
