GPIO

Général Purpose Input/Ouput

Les GPIO permettent de communiquer avec d'autres circuits électronique. A l'instar de l'Arduino (un microcontrôleur), le Raspberry en possède lui aussi un, ce qui en fait à la fois un micro ordinateur et un microcontrôleur.

Dans le cadre bleu, le GPIO sur raspberry PI2

Et celui du raspberry PI3. Pas beaucoup de différences entre les deux images non ?

Des différences existent avec les versions antérieures au raspberry Pi 2 (hors Pi A+ et B+ qui sont identiques)

Les GPIO des versions précédentes avaient moins de connecteurs et le mapping diffère.

Le GPIO peut donc envoyer ou recevoir des signaux, mais ne traitre que des données numériques (binaire, 1 ou 0). Il fonctionne en 3.3 Vcc et le courant sera de faible intensité (attention à ne pas lui envoyer du 5V) .

Il existe un connecteur fournissant du 5Volt. Idéale pour faire quelques tests mais pour des projets électroniques sur du plus long terme, il sera préférable d'avoir une source externe en 5V.

Voici le schéma du gpio sur 40 pins

Cependant, à chaque position de pins existe un nom composé de "GPIO" et d'un numéro qui n'a évidemment rien à voir avec son pin...

• En rouge: 5Volts
• En orange: 3.3Volts
• En noir, la terre...

D'où le tableau de correspondance suivant:

Comme vous pouvez le constater, c'est du grand n'importe quoi...

Certains PIN n'ont pas de GPIO correspondant. Il s'agit dans ce cas d'alimentation permanente ou de masse (terre/gnd/ground) et ne sont donc pas programmables. Tous les GPIO peuvent être utilisés comme vous le voulez. Cependant, certains de ces GPIO peuvent avoir une spécialisation que vous pourrez utiliser moyennant activation (raspi-config) et/ou l'installation de driver correspondant (I2C, UART, PCM ou SPI).

Wiring Pi

Une bien triste nouvelle, M. Gordon, le développeur de la première heure qui avait créé cette géniale librairie à mis fin à son développement pour le publique en Août 2019...

Wiring Pi, une librairie C/C++ pour piloter le GPIO.

En principe, WiringPi est déjà installé sur votre système

Tapez gpio readall ou gpio -v vous le confirmera !

WiringPi 2.60

Une version 2.60 de WiringPi "non officielle" (en même temps, comme son développeur a cessé de le maintenir, elle ne peut qu'être non officielle !) existe et prend en charge le PI 4:

Après contrôle du code, celui-ci est très bien ! Conforme au code d'origine, en ajoutant que le nécessaire pour le Pi 4 !

https://github.com/WiringPi/WiringPi

Et cela me permet de voir que je suis passé à côté de quelque chose (En même temps, comme je ne l'utilisais pas, ...): Le mécanisme de pin pull-up/down/enable est aussi changé sur le pi 4...

Se faire son propre WiringPi 2.52

Le mécanisme de pin pull-up/down/enable est changé sur le pi 4...et les explications ne sont pas données ici !

Pour ceux qui n'ont pas la V2.52 mais ont un PI 4, vous pouvez repartir des sources d'une V2.50 et faire vous même votre propre wiringPi 2.52 !

N'ayant pas la version 2.50 originale de Gordon, je suis reparti de celle-ci fonctionnant très bien sur mes Pi:

used to build the wiringPython, Ruby, Perl, etc. wrappers for these other languages.

Après comparaison avec la 2.44 que j'avais, cette copie est très bien !

Le code de Gordon est plutôt propre, et il n'est pas trop difficile d'intervenir dedans !

Dans le fichier wiringPi.h, vous trouvez la définition des constantes sur les différents modèles de PI

Exemple pour le pi3B+, ce sera le code 13:

#define PI_MODEL_3BP 13

Pour le PI 4B, il s'agit du code 17 (celui qui est pour le moment inconnu lorsque vous tapez gpio -v)

Ajoutez une nouvelle constante pour le PI 4

// Pi model types and version numbers // Intended for the GPIO program Use at your own risk. #define PI_MODEL_A 0 #define PI_MODEL_B 1 #define PI_MODEL_AP 2 #define PI_MODEL_BP 3 #define PI_MODEL_2 4 #define PI_ALPHA 5 #define PI_MODEL_CM 6 #define PI_MODEL_07 7 #define PI_MODEL_3B 8 #define PI_MODEL_ZERO 9 #define PI_MODEL_CM3 10 #define PI_MODEL_ZERO_W 12 #define PI_MODEL_3BP 13 #define PI_MODEL_3AP 14 #define PI_MODEL_CM3P 16 #define PI_MODEL_4B 17

Dans wiringPi.c, on retrouve la définition des pi, mémoire, …

Ajouter une nouvelle constante pour prendre en compte la nouvelle adresse de base du mapping des GPIO du Pi 4 (C'est pour cette raison que votre led ne clignote plus ! ; ) )

Par exemple

#define GPIO_PERI_BASE_NEW_2 0xFE000000

et remplacez le modèle unknow17 dans piModelNames pour prendre en compte le modèle Pi 4!

// Data for use with the boardId functions. // The order of entries here to correspond with the PI_MODEL_X // and PI_VERSION_X defines in wiringPi.h // Only intended for the gpio command - use at your own risk! // piGpioBase: // The base address of the GPIO memory mapped hardware IO #define GPIO_PERI_BASE_OLD 0x20000000 #define GPIO_PERI_BASE_NEW 0x3F000000 #define GPIO_PERI_BASE_NEW_2 0xFE000000 static volatile unsigned int piGpioBase = 0 ; const char *piModelNames [20] = { "Model A", // 0 "Model B", // 1 "Model A+", // 2 "Model B+", // 3 "Pi 2", // 4 "Alpha", // 5 "CM", // 6 "Unknown07", // 07 "Pi 3", // 08 "Pi Zero", // 09 "CM3", // 10 "Unknown11", // 11 "Pi Zero-W", // 12 "Pi 3B+", // 13 "Pi 3A+", // 14 "Unknown15", // 15 "CM3+", // 16 "Pi 4B", // 17 "Unknown18", // 18 "Unknown19", // 19 } ;

Maj piMemorySize pour les codes sur les différents capacités de la mémoire, ajoutez les capacités 2048 et 4096 manquantes !

const int piMemorySize [8] = { 256, // 0 512, // 1 1024, // 2 2048, // 3 4096, // 4 0, // 5 0, // 6 0, // 7 } ;

La commande gpio -v devrait déjà refonctionner...

Dans la fonction wiringPiSetup, remplacez le switch case par celui-ci pour prendre en compte la nouvelle adresse de base du mapping des GPIO

switch (model) { case PI_MODEL_A: case PI_MODEL_B: case PI_MODEL_AP: case PI_MODEL_BP: case PI_ALPHA: case PI_MODEL_CM: case PI_MODEL_ZERO: case PI_MODEL_ZERO_W: piGpioBase = GPIO_PERI_BASE_OLD ; break ; case PI_MODEL_4B: piGpioBase = GPIO_PERI_BASE_NEW_2 ; break; default: piGpioBase = GPIO_PERI_BASE_NEW ; break ; }

Cette fois-ci gpio write pin valeur doit fonctionner, puisque l'on adresse maintenant dans la bonne zone mémoire ! Votre led doit s'allumer !

A ce stade, la commande gpio readall ne fonctionne toujours pas, cela ne va pas durer...

Dans readall.c, la fonction doReadall, il faut ajouter le nouveau modèle, sinon, refus de lancer les traitements.

void doReadall (void) { int model, rev, mem, maker, overVolted ; if (wiringPiNodes != NULL) // External readall { doReadallExternal () ; return ; } piBoardId (&model, &rev, &mem, &maker, &overVolted) ; /**/ if ((model == PI_MODEL_A) || (model == PI_MODEL_B)) abReadall (model, rev) ; else if ((model == PI_MODEL_BP) || (model == PI_MODEL_AP) || (model == PI_MODEL_2) || (model == PI_MODEL_3AP) || (model == PI_MODEL_3B) || (model == PI_MODEL_3BP) || (model == PI_MODEL_ZERO) || (model == PI_MODEL_ZERO_W) || (model == PI_MODEL_4B) ) piPlusReadall (model) ; else if ((model == PI_MODEL_CM) || (model == PI_MODEL_CM3) || ((model == PI_MODEL_CM3P))) allReadall () ; else printf ("Oops - unable to determine board type... model: %d\n", model) ; }

De plus, pour afficher correctement le type au niveau entête et fin du tableau, il faut maj la fonction plus2header()

static void plus2header (int model) { //printf ("modèle n°:%d\n", model); /**/ if (model == PI_MODEL_AP) printf (" +-----+-----+---------+------+---+---Pi A+--+---+------+---------+-----+-----+\n") ; else if (model == PI_MODEL_BP) printf (" +-----+-----+---------+------+---+---Pi B+--+---+------+---------+-----+-----+\n") ; else if (model == PI_MODEL_ZERO) printf (" +-----+-----+---------+------+---+-Pi Zero--+---+------+---------+-----+-----+\n") ; else if (model == PI_MODEL_ZERO_W) printf (" +-----+-----+---------+------+---+-Pi ZeroW-+---+------+---------+-----+-----+\n") ; else if (model == PI_MODEL_2) printf (" +-----+-----+---------+------+---+---Pi 2---+---+------+---------+-----+-----+\n") ; else if (model == PI_MODEL_3B) printf (" +-----+-----+---------+------+---+---Pi 3B--+---+------+---------+-----+-----+\n") ; else if (model == PI_MODEL_3BP) printf (" +-----+-----+---------+------+---+---Pi 3B+-+---+------+---------+-----+-----+\n") ; else if (model == PI_MODEL_3AP) printf (" +-----+-----+---------+------+---+---Pi 3A+-+---+------+---------+-----+-----+\n") ; else if (model == PI_MODEL_4B) printf (" +-----+-----+---------+------+---+---Pi 4B--+---+------+---------+-----+-----+\n") ; else printf (" +-----+-----+---------+------+---+---Pi ?---+---+------+---------+-----+-----+\n") ; }

Voilà, gpio readall doit refonctionner !

Vous pouvez changer le numéro de version de wiringPi

il y a 2 fichiers

version.h

Et le fichier VERSION utilisé pour nommer la librairie libwiringPi.so.x.xx lors de la compilation.

Et il y a aussi un fichier de control: debian-template/wiringPi/DEBIAN/control

Reste à tout reconstruire, tapez ./build ...

Voilà, c'était pas difficile... Bien évidemment, ces explications ne sont pas données à ce "DanielK" qui ne comprendra sûrement rien à ce qu'il faut faire de toute façon ...

Reste à surveiller les forks de wiringPi qui a n'en pas douter auront des maj compatibles pi4.

Sinon

Pour installer la dernière version pour Raspberry Pi4, tapez

wget https://project-downloads.drogon.net/wiringpi-latest.deb

sudo dpkg -i wiringpi-latest.deb

Sinon

Pour l'installer, vous pouvez passer par GIT:

Si non installé, tapez:

apt-get install git-core

Pour récupérer la librairie:

git clone git://git.drogon.net/wiringPi

Dans votre répertoire courant, vous avez maintenant un répertoire wiringPi

cd wiringPi

./build pour construire les librairies

Des exemples sont disponibles dans le répertoire examples

Pour compiler votre programme avec la librairie Wiring Pi:

gcc -Wall -o votre programme_executable_genere votre_fichier_source -lwiringPi

Exemple de programme:

Positionner à 1 (ON) ou non (OFF) un ou des ports du GPIO en ligne de commandes

#include <wiringPi.h> #include <stdlib.h> #include <stdio.h> #include <string.h> int main (int argc, char *argv[]) { int i, iGpio; if (argc <3) { printf ("Argument manquant: n°GPIO ON/OFF\n"); } else { wiringPiSetup () ; for (i=1; i < argc; i=i+2) { iGpio=atoi (argv[i]); if (i+1 >= argc) { printf ("Paramètre manquant pour le GPIO n°%s\n", argv[i]); } else { pinMode (iGpio, OUTPUT) ; printf ("GPIO %d %s\n", iGpio, argv[i+1]); if (strcmp(argv[i+1], "ON") ==0) digitalWrite (iGpio, HIGH); else digitalWrite (iGpio, LOW); } } } return 0 ; }

Pourra être utile pour contrôler votre premier montage de led. Celle-ci s'allumera ou s'éteindra. Enfin, si vous n'avez pas monté votre circuit à l'envers et que vous ne vous êtes pas trompé de n° de port (entre autre) !

Dans vos projets, pensez bien à initiliser les ports qui seront utilisés avant d'effectuer vos traitements. Leur état étant à considérer comme inconnu.

GPIO

Un autre librairie pour le langage Python.

Pi4J

Utilisé pour le langage JAVA.

bcm2835

Encore une autre librairie...

Annexes

Sonde DHT11/DHT22

Sonde DS18B20

Relais

Shifter Level

https://pinout.xyz/pinout/wiringpi#