Pi IoT en Python à l’aide de pilotes Linux

Page 1 sur 3

Le pilote GPIO sous Linux était autrefois GPIO sysfs, mais ce n’est plus le pilote de caractères GPIO. Découvrez comment contrôler le GPIO de manière moderne.

Ce contenu provient de notre livre récemment publié :

Raspberry Pi IdO en Python tuchanter les pilotes Linux

Par Harry Fairhead et Mike James

Achetez sur Amazon.

Contenu

  1. Choisir un Pi pour l’IoT
  2. Premiers pas avec Python
  3. Pilotes : un premier programme
  4. Le pilote de caractères GPIO ***NOUVEAU!!
  5. GPIO utilisant le contrôle d’E/S
  6. Événements GPIO

  7. L’arborescence des appareils
    Extrait : Le DHT22
  8. Quelques appareils électroniques

  9. Modulation de largeur d’impulsion
    Extrait : PWM
  10. Appareils SPI

  11. Bases I2C
    Extrait : I2C
  12. Le pilote Linux I2C

  13. I2C avancé

  14. Pilotes de capteur

  15. Aller plus loin avec les chauffeurs

  16. Annexe I

Le pilote de caractères GPIO

En ce qui concerne l’IoT, le pilote Linux fondamental est le pilote GPIO, qui vous donne accès aux lignes GPIO individuelles. Il s’agit d’un autre pilote intégré et ressemble donc au pilote de LED présenté dans le chapitre précédent, mais il s’agit d’un pilote de caractère et utilisé d’une manière légèrement différente.

Dans la plupart des cas, lorsqu’un périphérique est connecté via un ensemble de lignes GPIO, vous utilisez généralement un pilote de périphérique spécifique. De cette façon, vous pouvez presque ignorer les lignes GPIO et ce qu’elles font. Cependant, il existe encore des situations simples où un pilote complet serait exagéré. Si vous souhaitez interfacer un bouton ou une LED, le contrôle direct sur les lignes GPIO est le moyen le plus direct de faire le travail même s’il existe des pilotes de LED Linux – voir le chapitre précédent – et même un pilote d’entrée.

Jusqu’à récemment, la manière standard de travailler avec GPIO sous Linux consistait à utiliser l’interface sysfs. Vous verrez beaucoup d’articles prônant son utilisation et vous rencontrerez de nombreux programmes qui l’utilisent. Cependant, GPIO sysfs était obsolète dans Linux 4.8 fin 2016 et devrait être supprimé du noyau en 2020. Bien sûr, il faut du temps pour que les distributions Linux utilisent les derniers noyaux. Au moment d’écrire ces lignes, Pi OS utilise Linux 4.19, sorti deux ans plus tôt. Néanmoins, sysfs GPIO sera bientôt supprimé et bien que vous ayez encore besoin de le savoir pour faire face aux logiciels hérités, vous ne devriez pas l’utiliser pour de nouveaux projets.

Son remplacement est le périphérique de caractères GPIO et, bien que cela ressemble superficiellement à l’ancienne interface sysfs, il présente de nombreuses différences majeures. Bien qu’il présente certains avantages, il est également légèrement plus complexe et ne peut plus être utilisé à partir de la ligne de commande – il s’agit d’une interface de programme uniquement. Cela dit, il existe des programmes utilitaires simples qui sont assez standard et permettent le contrôle GPIO à partir de la ligne de commande. Ceux-ci sont couverts dans la première partie du chapitre, même s’il est peu probable qu’ils soient la principale façon dont vous travaillez avec la nouvelle interface. Il existe également une bibliothèque wrapper appelée libgpiod (Librare ggénéral Pbut jeentrée/Osortie périphérique) Bien qu’il ne soit pas nécessaire pour un accès simple aux lignes GPIO, il est décrit dans ce chapitre.

Périphérique de caractères GPIO

La nouvelle approche de travail avec GPIO est préinstallée dans la dernière version de Pi OS, mais elle n’est pas prise en charge dans les versions antérieures. Si vous regardez dans le répertoire /dev vous trouverez des fichiers correspondant à chaque contrôleur GPIO installé. Vous verrez au moins :

/dev/gpiochip0

Cela représente le contrôleur GPIO principal et toutes les lignes GPIO qu’il fournit. Si vous savez comment fonctionne sysfs, vous attendez peut-être des instructions sur la façon de lire et d’écrire dans le fichier à partir de la console. Dans ce cas, lire et écrire dans le fichier ne vous sera d’aucune utilité car la plupart du travail est effectué à l’aide de l’appel système de contrôle d’entrée/sortie, ioctl() qui ne peut pas être utilisé depuis la ligne de commande. L’utilisation d’ioctl est typique d’un pilote de caractères, mais cela signifie que l’utilisation du pilote GPIO est très différente des autres pilotes orientés fichier décrits plus loin. Le chapitre suivant examine l’utilisation d’ioctl pour contrôler directement le périphérique de caractères GPIO.

Si vous souhaitez explorer le GPIO à partir de la ligne de commande, vous devez installer certains outils qui ont été créés principalement comme exemples d’utilisation de la nouvelle interface de périphérique. Pour ce faire, vous devez d’abord les installer ainsi que la bibliothèque C libgpiod que vous utiliserez plus tard avec une liaison Python :

sudo apt-get install gpiod libgpiod-dev libgpiod-doc

Notez que, si vous ne souhaitez pas utiliser la bibliothèque pour accéder au pilote, vous n’avez pas besoin de l’installer – le pilote GPIO est chargé dans le noyau Linux et est prêt à l’emploi.

Les utilitaires

Les applications autonomes installées sont :

Répertorie tous les contrôleurs GPIO installés :

gpio1

Répertorie toutes les lignes GPIO fournies par le contrôleur GPIO nommé :

gpio2

Vous pouvez donner des noms de lignes particulières en modifiant l’arborescence des appareils. Si vous leur donnez des noms fixes appropriés, alors :

gpifind Nom

renverra le numéro de la ligne GPIO.

Vous pouvez l’utiliser pour définir n’importe quel nombre de lignes GPIO en une seule opération. La commande a la forme :

gpioset options nom/numéro de puce =

=
où les options sont :
-l, –active-low définit l’état actif de la ligne sur bas
-m, –mode= indique au programme quoi faire après avoir défini les valeurs

exit : quitter immédiatement, la valeur par défaut
attendre : attendez que l’utilisateur appuie sur ENTER
time : dormir pendant un laps de temps spécifié
signal : attendre SIGINT ou SIGTERM

-s, –sec=SECONDE nombre de secondes à attendre
-u, –usec=USEC nombre de microsecondes à attendre
-b, –background se détache du terminal de contrôle

Notez que le changement d’état de la ligne ne persiste que pendant l’exécution de la commande. Cela signifie que pour voir l’effet, vous devez utiliser wait ou time. Par exemple:

gpioset -m wait 0 4=0 17=1

définit gpiochip 0 GPIO4 sur 0 et GPIO17 sur 1 et attend que l’utilisateur appuie sur Entrée.

La commande gpioget renvoie l’état des lignes spécifiées sous forme de texte :

gpioget chip name/number  

Par exemple:

gpioget0 4 17

affichera l’état actuel de GPIO4 et GPIO17 sur gpiochip0.

La commande gpiomon vous permet de surveiller les modifications apportées aux lignes d’entrée à l’aide d’un appel système poll :

gpiomon options chip name/number <offset 1> 

Les options sont :

 -n, --num-events=NUM	exit after processing NUM events
 -s, --silent		don't print event info
 -r, --rising-edge	only process rising edge events
 -f, --falling-edge	only process falling edge events
 -F, --format= FMT	specify custom output format FMT
Format specifiers: %o: GPIO line offset %e: event type (0 - falling edge, 1 - rising edge) %s: seconds part of the event timestamp %n: nanoseconds part of the event timestamp

Par exemple, pour surveiller GPIO4 et GPIO17 pour tout changement :

gpio3

Ces utilitaires sont utiles et peuvent être utilisés dans des scripts pour contrôler les lignes GPIO. Par exemple, si vous enregistrez :

while true
do
 gpioset -m time -s 1 0 4=0 17=1
gpioset -m time -s 1 0 4=1 17=0
done

dans un fichier texte appelé binky.sh et définissez son autorisation d’exécution sur le propriétaire, vous pouvez l’exécuter dans une console et faire clignoter une paire de LED connectées à GPIO4 et GPIO17. Notez que si l’une des lignes GPIO est utilisée, le script renverra un message d’erreur. Vous devez également garder à l’esprit que la ligne GPIO n’est utilisée que pendant l’exécution de la commande gpioset – c’est-à-dire que la ligne est ouverte au début de la commande et fermée lorsqu’elle se termine, renvoyant ainsi la ligne à l’entrée.

Vous pouvez aller loin avec les scripts shell et les utilitaires GPIO, mais tôt ou tard, vous voudrez travailler avec Python.

.

Leave a Comment

Your email address will not be published. Required fields are marked *