Utiliser des GPIOs dans des applications de haut niveau

Article
08/09/2023

Azure Sphere prend en charge les GPIO (entrée/sortie à usage général). Un GPIO est un type de broche numérique programmable sur un circuit intégré. Les GPIOs n’ont pas de fonctionnalités prédéfinies et leur comportement peut être personnalisé par une application. Certaines utilisations courantes des GPIOs sont de modifier l’état des périphériques matériels, de contrôler les VOYANTs et de lire l’état des commutateurs.

Note

Cette rubrique explique comment utiliser les GPIOs dans une application de haut niveau. Pour plus d’informations sur l’utilisation de GPIO dans rtApps, consultez Utiliser des périphériques dans une application compatible temps réel .

Les applications de haut niveau Azure Sphere peuvent communiquer avec les API GPIO des bibliothèques d’applications. L’exemple GPIO_HighLevelApp montre comment communiquer avec les GPIO sur un appareil MT3620.

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

Entrée en lecture
Définir la sortie sur haut ou faible
Interrogation / interruptions logicielles

Configuration requise pour GPIO

Les applications qui communiquent avec les GPIOs 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 de matériel 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 d’accès au fichier d’en-tête de votre matériel.

Paramètres du manifeste d’application

Les paramètres GPIO dans le manifeste de l’application répertorient les GPIO auxquels l’application accède. Une seule application peut utiliser un GPIO à la fois. Pour configurer ces paramètres, ajoutez la Gpio fonctionnalité 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 GPIOs. Le compilateur traduit ces valeurs en valeurs brutes lorsque vous générez l’application.

Par exemple, voici un extrait d’un manifeste d’application pour une application qui cible une carte de développement de référence (RDB) MT3620 et acquiert trois de ses GPIOs (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 GPIOs 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 devez lire à partir d’un GPIO mais pas y écrire, vous pouvez l’ouvrir en tant qu’entrée. Appelez GPIO_OpenAsInput pour ouvrir un GPIO et définissez-le sur entrée. Cela permet de récupérer un descripteur de fichier pour les opérations sur le GPIO. Vous pouvez lire à partir d’un GPIO lorsqu’il est défini sur entrée, mais vous ne pouvez pas y écrire. Si un GPIO est défini sur entrée, vous devez le fermer avant de pouvoir le définir sur sortie.

Ouvrir un GPIO en tant que sortie

Si vous avez besoin d’écrire dans un GPIO, vous devez l’ouvrir en tant que sortie. Appelez GPIO_OpenAsOutput pour ouvrir un GPIO et définissez-le sur sortie. Cela permet de récupérer un descripteur de fichier pour les opérations sur le GPIO, de définir le mode de sortie et la valeur initiale. Lorsqu’un GPIO est défini sur sortie, vous pouvez y écrire et lire à partir de celui-ci. Si un GPIO est défini sur sortie, vous devez le fermer avant de pouvoir le définir sur entrée.

Interroger un GPIO

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

Lecture à partir d’un GPIO

Pour lire à partir du GPIO, appelez GPIO_GetValue.

Écrire dans un GPIO

Pour écrire 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 le piloter. En règle générale, cette quantité de current est définie sur une valeur par défaut. Toutefois, certains scénarios, tels que les VOYANTs plus lumineux ou l’augmentation de la puissance des capteurs, nécessitent d’ajuster la puissance du lecteur à certaines broches GPIO.

Pour définir la force du lecteur, utilisez d’abord la structure gpiopin_request pour spécifier la configuration de la force 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 force 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 MT3620

Les fonctionnalités GPIO prises en charge pour la puce MT3620 sont répertoriées dans État du support MT3620. Le guide de l’utilisateur de la carte de développement MT3620 décrit la disposition des broches et les fonctions de broche sur le RDB MT3620.

Le dossier HardwareDefinitions du répertoire d’installation du Kit de développement logiciel (SDK) Microsoft Azure Sphere contient les définitions des 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 master pour mt3620, MT3620 RDB, ainsi que d’autres matériels MT3620. L’emplacement par défaut du dossier HardwareDefinitions est C:\Program Files (x86)\Microsoft Azure Sphere SDK\Hardware Definitions sur Windows et /opt/azurespheresdk/HardwareDefinitions sur Linux.

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

Partage via