Utiliser des GPIO dans les applications de haut niveau

Article
11/05/2024

Important

Il s’agit de la documentation Azure Sphere (héritée). Azure Sphere (hérité) prend sa retraite le 27 septembre 2027 et les utilisateurs doivent migrer vers Azure Sphere (intégré) pour l’instant. Utilisez le sélecteur de version situé au-dessus du TOC pour afficher la documentation Azure Sphere (intégrée).

Azure Sphere prend en charge les GPIO (entrées/sorties à usage général). Un GPIO est un type de broche numérique programmable qui fait partie d’un circuit intégré. Les GPIO n’ont pas de fonctionnalités prédéfinies et leur comportement peut être personnalisé par une application. Les GPIO sont couramment utilisés pour changer l’état des périphériques matériels, pour contrôler les LED et pour lire l’état des commutateurs.

Remarque

Cette rubrique décrit comment utiliser des GPIO dans une application générale. Pour plus d’informations sur l’utilisation des GPIO dans les applications temps réel, consultez Utiliser des périphériques dans une application prenant en charge le temps réel.

Les applications générales Azure Sphere peuvent communiquer avec les GPIO en appelant les API GPIO des bibliothèques d’application. L’exemple GPIO_HighLevelApp sample montre comment communiquer avec les GPIO sur un appareil MT3620.

Les opérations suivantes sont prises en charge pour les GPIO :

Lecture des entrées
Définir les sorties sur une valeur élevée ou faible
Interrogations/Interruptions logicielles

Configuration requise des GPIO

Les applications qui communiquent avec des GPIO doivent inclure les fichiers d’en-tête appropriés pour GPIO et ajouter des paramètres GPIO au manifeste de l’application.

Toutes les applications doivent définir leur matériel cible et inclure le fichier d’en-tête de définition matérielle correspondant.

Fichiers d'en-tête

 #include <applibs/gpio.h>
 #include "path-to-your-target-hardware.h"

Remplacez « path-to-your-target-hardware.h » par le chemin du fichier d’en-tête de votre matériel.

Paramètres de manifeste de l’application

Dans le manifeste de l’application, les paramètres GPIO listent les GPIO qui sont accessibles par l’application. Un GPIO peut être utilisé par une seule application à la fois. Pour configurer ces paramètres, ajoutez la fonctionnalité Gpio au manifeste de l’application, puis ajoutez chaque GPIO à la fonctionnalité. Le manifeste d’application Azure Sphere contient plus de détails.

Dans votre code, utilisez les constantes définies pour votre matériel afin d’identifier les GPIO. Le compilateur convertit ces valeurs en valeurs brutes lorsque vous générez l’application.

Par exemple, voici un extrait d’un manifeste d’une application qui cible une carte de développement de référence (RDB) MT3620 et qui acquiert trois de ses GPIO (1, 8 et 12) :

"Gpio": [ "$MT3620_RDB_HEADER1_PIN6_GPIO", "$MT3620_RDB_LED1_RED", "$MT3620_RDB_BUTTON_A" ]

L’extrait suivant montre comment spécifier les mêmes GPIO dans une application qui cible le starter kit Avnet-MT3620 :

"Gpio": [ "$AVNET_MT3620_SK_GPIO1", "$AVNET_MT3620_SK_USER_LED_RED", "$AVNET_MT3620_SK_USER_BUTTON_A" ]

Ouvrir un GPIO en tant qu’entrée

Si vous avez besoin de lire les données d’un GPIO mais pas d’y écrire des données, vous pouvez l’ouvrir en tant qu’entrée. Appelez GPIO_OpenAsInput pour ouvrir un GPIO, puis configurez-le en tant qu’entrée. Cette opération récupère un descripteur de fichier pour les opérations à effectuer sur le GPIO. Si un GPIO est défini comme entrée, vous pouvez lire les données qu’il contient, mais pas y écrire des données. Lorsqu’un GPIO est défini comme entrée, vous devez le fermer avant de le définir comme sortie.

Ouvrir un GPIO en tant que sortie

Si vous avez besoin d’écrire des données dans un GPIO, vous devez l’ouvrir en tant que sortie. Appelez GPIO_OpenAsOutput pour ouvrir un GPIO, puis configurez-le en tant que sortie. Cette opération récupère un descripteur de fichier pour les opérations à effectuer sur le GPIO, puis définit le mode de sortie et la valeur initiale. Quand un GPIO est défini en tant que sortie, vous pouvez y écrire et y lire des données. Lorsqu’un GPIO est défini comme sortie, vous devez le fermer avant de le définir comme entrée.

Interroger un GPIO

Quand le GPIO est ouvert, vous pouvez superviser ses événements, tels qu’un clic de bouton. Pour ce faire, vous devez configurer un minuteur pour interroger le GPIO. Les interruptions matérielles ne sont pas prises en charge sur Azure Sphere pour les GPIO. Vous devez donc utiliser l’interrogation. L’exemple GPIO montre comment interroger un GPIO.

Lire les données d’un GPIO

Pour lire les données d’un GPIO, appelez GPIO_GetValue.

Écrire des données dans un GPIO

Pour écrire des données dans un GPIO, appelez GPIO_SetValue.

Définir la puissance du lecteur d’un GPIO

La puissance du lecteur d’une broche GPIO fait référence à la quantité de courant utilisée pour la conduire. En règle générale, cette valeur actuelle est définie sur une valeur par défaut. Toutefois, certains scénarios, tels que des LED plus brillantes ou une puissance accrue pour les capteurs, nécessitent le réglage de la puissance du lecteur sur certaines broches GPIO.

Pour définir la force du lecteur, utilisez d’abord la structure gpiopin_request pour spécifier la configuration de la puissance du lecteur pour une ou plusieurs broches GPIO. Ensuite, passez gpiopin_request et GPIO_SET_PIN_CONFIG_IOCTL dans un appel IOCTL.

L’extrait de code suivant montre comment définir la puissance du lecteur de deux broches GPIO, qui sont spécifiées dans le lineoffsets tableau de la gpiopin_request structure.

//get chip file descriptor
int chipfd = __z_azsp_open("/dev/gpiochip0", O_CLOEXEC);

//set drive strength for the requested pins
struct gpiopin_request pinreq;
memset(&pinreq, 0, sizeof(pinreq));
pinreq.linecount = 2;
pinreq.lineoffsets[0] = SAMPLE_RGBLED_BLUE;
pinreq.lineoffsets[1] = SAMPLE_RGBLED_RED;
pinreq.config_type = PIN_CONFIG_DRIVE_STRENGTH;
pinreq.config_arg = 16;

result = ioctl(chipfd, GPIO_SET_PIN_CONFIG_IOCTL, &pinreq);
if (result < 0) {
    close(chipfd);
    return -1;
}

//do other work like setting pins as output
struct gpiohandle_request request;
memset(&request, 0, sizeof(request));
request.flags = GPIOHANDLE_REQUEST_OUTPUT;
request.lines = 2;
request.lineoffsets[0] = SAMPLE_RGBLED_BLUE;
request.lineoffsets[1] = SAMPLE_RGBLED_RED;
request.default_values[0] = 1;
request.default_values[1] = 1;

result = ioctl(chipfd, GPIO_GET_LINEHANDLE_IOCTL, &request);
if (result < 0) {
    close(chipfd);
    return -1;
}

Fermer un GPIO

Pour fermer le GPIO, appelez la fonction POSIX close().

Prise en charge de la carte MT3620

Pour la puce MT3620, les fonctionnalités GPIO prises en charge sont listées dans État de la prise en charge du MT3620. Le guide de l’utilisateur pour la carte de développement MT3620 décrit la disposition des broches ainsi que leurs fonctions sur cette carte.

Le dossier HardwareDefinitions du répertoire d’installation du Kit de développement logiciel (SDK) Microsoft Azure Sphere contient des définitions pour les cartes de développement, modules et puces Azure Sphere courants. Il contient des fichiers d’en-tête et JSON qui définissent les interfaces principales pour la base de données RDB MT3620, MT3620, ainsi que d’autres matériels MT3620. L’emplacement par défaut du dossier HardwareDefinitions se trouve C:\Program Files (x86)\Microsoft Azure Sphere SDK\Hardware Definitions sur Windows et /opt/azurespheresdk/HardwareDefinitions sur Linux.

Le référentiel d’exemples Azure Sphere sur GitHub contient des fichiers d’en-tête et JSON qui définissent des interfaces principales SPI pour la puce MT3620 et MT3620 RDB, ainsi que d’autres matériels MT3620.-->

Partage via