Guide GPIO pour débutants

Dans ce billet de blog, vous apprendrez tout sur les broches GPIO du Raspberry Pi. Ce billet s'adresse tout particulièrement aux débutants en électronique.

Tout d'abord, un avertissement
Le Raspberry Pi peut être irrémédiablement endommagé si les broches sont utilisées de manière incorrecte. Assurez-vous donc toujours que votre circuit est correct et que vous utilisez suffisamment de résistances.

Que sont les broches GPIO ?

Les broches GPIO sont les 40 petites broches métalliques situées sur le dessus du Raspberry Pi. L'abréviation GPIO signifie "general purpose input output". Cela signifie que les broches GPIO peuvent être utilisées comme interface pour presque tous les appareils électroniques.

En raison du grand nombre de façons de (mal)utiliser les broches, le démarrage peut être un peu confus. Par conséquent, cet article de blog fournit quelques exemples sur la façon de contrôler les broches en utilisant Bash, C et Python. Une petite expérience en programmation est donc un avantage.

Bien que les 40 broches semblent identiques, elles ont des fonctions différentes. 26 broches peuvent être utilisées pour GPIO et certaines ont des fonctions supplémentaires. Quatre autres broches sont utilisées comme source d'alimentation (POWER, deux fois 3V3 et deux fois 5V) et 8 comme pôle négatif (également masse ou GROUND). Les deux broches restantes sont l'interface I2C pour l'ID EEPROM.

Pinout

Le graphique ci-dessous montre les informations les plus importantes, entre autres le brochage. Le brochage est identique pour la plupart des modèles de Raspberry Pi, mais il existe des différences. Vérifiez toujours le brochage exact de votre modèle avant de connecter un périphérique. Pour cela, il vous suffit d'ouvrir un terminal sur votre Raspberry Pi (Ctrl+Alt+t) et d'exécuter la commande suivante.

brochage

Vous verrez un graphique de toutes les connexions et le brochage exact de votre Raspberry Pi.

Brochage du Raspberry Pi

Vous avez peut-être remarqué que les numéros GPIO apparaissent de manière aléatoire et ne correspondent pas à la numérotation des broches. Pour éviter toute confusion, je fais référence à la numérotation de 1 à 40 comme étant le numéro de la BOARD et le numéro de 1 à 26 comme étant le numéro du BCM ou du GPIO.

Ainsi, la broche 1 de la carte est le connecteur 3V3 POWER et la broche GPIO 2 est la broche voisine avec le numéro 3 de la carte.

Comment connecter un dispositif aux broches

Il existe plusieurs alternatives pour connecter un périphérique aux broches GPIO. Certains périphériques disposent d'une tête GPIO qui permet de brancher directement le périphérique sur les broches GPIO. Cependant, ce n'est généralement pas le cas, c'est pourquoi on utilise des fils de liaison ou des câbles d'extension GPIO.

Regarder notre vidéo sur les broches GPIO !

Dans l'exemple suivant, une LED est connectée au Raspberry Pi à l'aide de câbles de liaison.

Le circuit

Les fils de liaison femelle-mâle permettent de connecter la broche GPIO à un connecteur ou à une planche à pain. La broche doit ensuite être programmée pour faire fonctionner le dispositif. Le dispositif peut être un bouton, une LED, un capteur, un moteur ou un écran. Il est seulement important que le dispositif puisse fonctionner avec 5 volts ou moins et qu'il soit compatible avec les interfaces I2C, SPI ou UART.

Pour la construction, nous avons besoin de l'équipement suivant.

  • Raspberry Pi avec Raspberry Pi OS
  • Deux fils de liaison mâle-femelle
  • Un fil de liaison mâle à mâle
  • Résistance de 10 kilo Ohm
  • LED
  • Planche à pain sans soudure

Connectez la broche 13 du GPIO (numéro de carte 33) au + bande et la broche de MASSE située à côté (BOARD numéro 34) au - bande de la planche à pain. Ensuite, branchez une extrémité de la résistance de 10 kilo Ohms (n'importe quelle résistance) dans la prise de courant de l'appareil. + bande et l'autre extrémité dans l'une des bandes transversales. Pour la LED, l'orientation est cruciale. L'anode est le plus long des deux bras et souvent plié, la cathode est le bras le plus court. L'anode doit toujours pointer dans la direction + dans la direction de la source d'énergie, et la cathode dans la direction de la source d'énergie c'est-à-dire vers la MASSE. Placez donc le bras le plus long dans la même barrette transversale que la résistance, de sorte que le bras le plus court se trouve dans la barrette transversale adjacente. Enfin, utilisez le câble de liaison mâle à mâle pour relier la barrette transversale de la cathode (bras le plus court de la DEL) à la résistance. - bande.

Le schéma suivant montre le montage, assurez-vous que tout est correct et que les composants sont insérés dans la carte aussi loin que possible, sinon il y aura des contacts lâches.

Aufbau des Schaltkreises (en anglais)

Les trois exemples de code suivants en Bash, Python et C sont basés sur cette structure. Si vous utilisez d'autres broches, vous devez modifier le code en conséquence.

Bash

Contrôler les broches GPIO via Bash est très facile. Sous Linux, les broches GPIO sont contrôlées par les fichiers du répertoire /sys/class/gpio dossier. Pour utiliser une broche GPIO, il faut d'abord l'exporter. A titre d'exemple, j'utilise la broche GPIO 13. Dans ce qui suit, les noms de fichiers sont en gras et en italique.

Ouvrez un terminal et lister le contenu du dossier gpio.

cd /sys/class/gpio
ls

Le dossier contient les fichiers export et unexport ainsi que des sous-dossiers pour chaque broche GPIO exportée.

Nous exportons la broche en écrivant le numéro GPIO dans le champ /sys/class/gpio/export fichier. Exécutez cette commande dans le terminal.

echo 13 > /sys/class/gpio/export
ls

Maintenant un dossier avec le numéro de broche correspondant gpio13 a été créé. Ce dossier contient d'autres dossiers et fichiers. Pour l'instant, seuls les fichiers de direction et de valeur sont importants pour nous.

Le site direction enregistre le mode de la broche :

sur -> La broche est en mode lecture ou entrée

out -> La broche est en mode écriture ou sortie

Le site valeur stocke l'état de tension de la broche :

0 -> la broche est en mode BAS -> aucune tension n'est appliquée à la broche

1 -> La broche est en mode HIGH -> Une tension est appliquée à la broche

Les commandes suivantes règlent le mode sur out et la valeur à 1.

echo out > /sys/class/gpio/gpio13/direction
echo 1 > /sys/class/gpio/gpio13/value

La LED est maintenant allumée. Il est important de réinitialiser les valeurs des broches après utilisation. Les commandes suivantes doivent être exécutées après chaque utilisation.

echo 0 > /sys/class/gpio/gpio13/value
echo in > /sys/class/gpio/gpio13/direction
echo 13 > /sys/class/gpio/unexportation

Programme Python

Nous allons maintenant abstraire et automatiser ces commandes Bash en Python.

Le script Python suivant fournit un simple GPIO_Pin classe. Cela le rend extrêmement facile à utiliser. Le site os nous permet d'exécuter les mêmes commandes bash que ci-dessus à partir de Python. De plus, en utilisant le module Je ne sais pas. nous n'avons plus besoin de réinitialiser et d'exporter manuellement les broches.

importez os
from time import sleep

classe GPIO_Pin :
    def __init__(self, num, mode) :
        si 0 <= num ou num  Enter a number from 0 - 40')
        si mode == 'out' ou mode == 'write' :
            self.mode = 'out'
        elif mode == 'in' ou mode == 'read' :
            self.mode = 'in
        autre :
            print('Invalid Pin Mode -> Enter "out" or "write" for output, "in" or "read" for input')
        si self.num et self.mode :
            os.system(f 'echo {str(self.num)} > /sys/class/gpio/export')
            sleep(0.05)
            os.system(f 'echo {self.mode} > /sys/class/gpio/gpio{str(self.num)}/direction')

    def reset(self) :
        os.system(f'echo 0 > /sys/class/gpio/gpio{str(self.num)}/value')
        os.system(f'echo in > /sys/class/gpio/gpio{str(self.num)}/direction')

    def write(self, valeur) :
        si valeur == 0 ou valeur == 'LOW' :
            os.system(f'echo 0 > /sys/class/gpio/gpio{str(self.num)}/value')
        elif valeur == 1 ou valeur == 'HIGH' :
            os.system(f'echo 1 > /sys/class/gpio/gpio{str(self.num)}/value')
        else :
            print('Valeur non valide -> Entrez 1 ou "HIGH" pour HIGH, 0 ou "LOW" pour LOW')

    def __del__(self) :
        self.reset()
        os.system(f 'echo {str(self.num)} > /sys/class/gpio/unexport')

    def set_mode(self, mode) :
        self.mode = mode
        os.system(f'echo {str(self.mode)} > /sys/class/gpio/gpio{str(self.num)}/direction')

def main() :
    pin = GPIO_Pin(13, 'out')
    nombre_de_clignotements = 10
    for i in range(number_of_blinks) :
        pin.write('HIGH')
        sleep(0.5)
        pin.write('LOW')
        sleep(0.5)

if __name__ == '__main__' :
    main()

Avec le module de temps, nous pouvons même faire clignoter la LED sans aucun problème. L'ensemble du script peut être étendu à un module Python pour le contrôle des GPIO.

Programme C

En C également, nous pouvons facilement modifier le contenu du dossier gpio. En utilisant la bibliothèque standard stdlib nous pouvons ouvrir des fichiers et en modifier le contenu.
Le programme C suivant doit être compilé avant de pouvoir être exécuté. Créez un fichier gpio.c et copier le programme dedans.
Ensuite, ouvrez un terminal et naviguez jusqu'au dossier où se trouve le fichier gpio.c est situé. Utilisez les commandes suivantes pour compiler et exécuter le programme.

gcc -o gpio gpio.c
./gpio

Voici le programme.

#include 
#include 
#include 

#define GPIO_ROOT "/sys/class/gpio" (en anglais)
#définir EXPORT "/sys/class/gpio/export".
#define UNEXPORT "/sys/class/gpio/export" (en anglais)

#définir LOW 0
#définir HIGH 1

int export_pin(int num) {
    FILE* export = fopen(EXPORT, "w") ;
    if (export == NULL) {
        printf("Impossible d'ouvrir le fichier d'exportation\n") ;
        exit(-1) ;
    }
    fprintf(export, "%d", num) ;
    fclose(export) ;
    retournez 0 ;
}

int unexport_pin(int num) {
    FILE* unexport = fopen(UNEXPORT, "w") ;
    if (unexport == NULL) {
        printf("Impossible d'ouvrir le fichier unexport\n") ;
        exit(-1) ;
    }
    fprintf(unexport, "%d", num) ;
    fclose(unexport) ;
    retournez 0 ;
}

int set_direction(char *mode, int num) {
    char direction_file_path[1024] ;
    snprintf(direction_file_path, sizeof(direction_file_path), "/sys/class/gpio/gpio%d/direction", num) ;
    FILE* direction = fopen(direction_file_path, "w") ;
    if (direction == NULL) {
        printf("Impossible d'ouvrir le fichier de direction\n") ;
        exit(-1) ;
    }
    fputs(mode, direction) ;
    fclose(direction) ;
    retourne 0 ;
}

int set_value(int val, int num) {
    char value_file_path[1024] ;
    snprintf(value_file_path, sizeof(value_file_path), "/sys/class/gpio/gpio%d/value", num) ;
    FILE* value = fopen(value_file_path, "w") ;
    if (value == NULL) {
        printf("Impossible d'ouvrir le fichier de valeur\n") ;
        exit(-1) ;
    }
    fprintf(valeur, "%d", val) ;
    fclose(valeur) ;
    retournez 0 ;
}

int main() {

    int rslt ;
    int num ;
    int num_blinks ;

    num = 13 ;
    nombre_de clignotements = 10 ;

    rslt = export_pin(num) ;
    rslt = set_direction("out", num) ;
    for (int i = 0 ; i < num_blinks ; i++) {
        rslt = set_value(HIGH, num) ;
        sleep(1) ;
        rslt = set_value(LOW, num) ;
        sleep(1) ;
    }

    rslt = set_value(LOW, num) ;
    rslt = set_direction("in", num) ;
    rslt = unexport_pin(num) ;

    retourne EXIT_SUCCESS ;
}

PiCockpit - Application GPIO

Le moyen le plus simple de contrôler les broches GPIO est d'utiliser l'application GPIO. Le site Interface web du PiCockpit est gratuit pour un maximum de 5 Raspberry Pi. Il offre deux grands avantages : Vous n'avez pas besoin de connaître la programmation pour contrôler vos broches GPIO et vous pouvez le faire de n'importe où.

Il suffit d'installer le client PiCockpit sur votre Raspberry Pi et de vous connecter à votre compte PiCockpit. Après cela, vous pouvez facilement contrôler les broches GPIO via l'interface web.

Les prochaines étapes

Vous savez maintenant comment utiliser les broches GPIO à l'aide de fils de liaison. Bien sûr, il existe aussi des modules Python et des bibliothèques C externes pour contrôler les broches GPIO. Une bonne étape suivante serait d'étendre l'un des exemples de code. Par exemple en utilisant des LEDs supplémentaires ou un bouton.
Amusez-vous bien à expérimenter !

Laissez un commentaire