Usar GPIOs em aplicativos de alto nível

Artigo
11/05/2024

Importante

Esta é a documentação do Azure Sphere (herdado). O Azure Sphere (herdado) será desativado em 27 de setembro de 2027 e os usuários devem migrar para o Azure Sphere (integrado) até esse momento. Use o seletor de versão localizado acima do sumário para exibir a documentação do Azure Sphere (Integrado).

O Azure Sphere dá suporte para GPIOs (entrada/saída de uso geral). Um GPIO é um tipo de pino digital programável em um circuito integrado. Os GPIOs não têm funcionalidade predefinida e o comportamento deles pode ser personalizado por um aplicativo. Alguns usos comuns dos GPIOs são alterar o estado dos dispositivos de hardware, controlar LEDs e ler o estado dos comutadores.

Observação

Este tópico descreve como usar GPIOs em um aplicativo de alto nível. Confira Usar periféricos em um aplicativo com funcionalidade de tempo real para obter informações sobre o uso de GPIO em RTApps.

Os aplicativos de alto nível do Azure Sphere podem se comunicar com GPIOs chamando as APIs de GPIO de Applibs. O exemplo de GPIO_HighLevelApp demonstra como comunicar-se com GPIOs em um dispositivo MT3620.

Há suporte para as operações a seguir no GPIO:

Ler entrada
Definir saída como alta ou baixa
Sondagem/interrupções de software

Requisitos do GPIO

Os aplicativos que se comunicam com os GPIOs devem incluir os arquivos de cabeçalho apropriados para GPIO e adicionar as configurações de GPIO ao manifesto do aplicativo.

Todos os aplicativos devem definir hardware de destino deles e incluir o arquivo de cabeçalho da definição de hardware correspondente.

Arquivos de cabeçalho

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

Substitua "path-to-your-target-hardware.h" pelo caminho para o arquivo de cabeçalho do seu hardware.

Configurações do manifesto do aplicativo

As configurações de GPIO no manifesto do aplicativo listam os GPIOs que são acessados pelo aplicativo. Apenas um aplicativo pode usar um GPIO por vez. Para definir essas configurações, adicione a funcionalidade Gpio ao manifesto do aplicativo e, em seguida, adicione cada GPIO à funcionalidade. O manifesto do aplicativo do Azure Sphere tem mais detalhes.

Em seu código use as constantes definidas para seu hardware para identificar os GPIOs. O compilador converterá esses valores em valores brutos quando você criar o aplicativo.

Por exemplo, há um trecho de um manifesto para um aplicativo que direciona uma RDB (placa de desenvolvimento de referência) MT3620 e adquire três de seus GPIOs (1, 8 e 12):

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

O trecho a seguir mostra como especificar os mesmos GPIOs em um aplicativo que direciona o Kit de Início do Avnet MT3620:

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

Abrir um GPIO como entrada

Se você precisar ler um GPIO, mas não gravar nele, abra-o como uma entrada. Chame GPIO_OpenAsInput para abrir um GPIO e defina-o como entrada. Isso recuperará um descritor de arquivo para operações no GPIO. É possível ler em um GPIO enquanto ele está definido como entrada, mas não pode gravar nele. Se um GPIO estiver definido como entrada, você deverá fechá-lo para poder defini-lo como saída.

Abrir um GPIO como saída

Se você precisar gravar em um GPIO, deverá abri-lo como uma saída. Chame GPIO_OpenAsOutput para abrir um GPIO e defina-o como saída. Isso recuperará um descritor de arquivo para operações no GPIO, definirá o modo de saída e o valor inicial. Quando um GPIO está definido como saída, é possível ler e gravar nele. Se um GPIO estiver definido como saída, você deverá fechá-lo para poder defini-lo como entrada.

Sondar um GPIO

Quando o GPIO está aberto, você pode monitorar eventos pressionando um botão. Para isso, você precisa configurar um temporizador para sondar o GPIO. Não há suporte para interrupções de hardware nos GPIOs, no Azure Sphere; portanto, você precisa usar sondagem. O exemplo de GPIO demonstra como sondar um GPIO.

Ler em um GPIO

Para ler no GPIO, chame GPIO_GetValue.

Gravar em um GPIO

Para gravar no GPIO, chame GPIO_SetValue.

Definir a força motriz de um GPIO

A força de acionamento de um pino GPIO refere-se à quantidade de corrente usada para acioná-lo. Normalmente, essa quantidade de corrente é definida como um valor padrão. No entanto, alguns cenários, como LEDs mais brilhantes ou aumento de potência para sensores, exigem o ajuste da força da unidade para determinados pinos GPIO.

Para definir a força da unidade, primeiro use a estrutura gpiopin_request para especificar a configuração da força da unidade para um ou mais pinos GPIO. Em seguida, passe gpiopin_request e GPIO_SET_PIN_CONFIG_IOCTL em uma chamada IOCTL.

O snippet de código a seguir demonstra como definir a força de acionamento de dois pinos GPIO, que são especificados na lineoffsets matriz da gpiopin_request estrutura.

//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;
}

Fechar um GPIO

Para fechar o GPIO, chame a função POSIX close().

Suporte à placa de desenvolvimento MT3620

Os recursos do GPIO compatíveis do chip do MT3620 são listados em Status de Suporte do MT3620. O guia do usuário da placa de desenvolvimento do MT3620 descreve o layout e as funções do pino na RDB do MT3620.

A pasta HardwareDefinitions no diretório de instalação do SDK do Microsoft Azure Sphere contém definições para placas, módulos e chips de desenvolvimento comuns do Azure Sphere. Ele contém arquivos de cabeçalho e JSON que definem as interfaces mestras para o MT3620, MT3620 RDB, juntamente com outro hardware MT3620. O local padrão para a pasta HardwareDefinitions é C:\Program Files (x86)\Microsoft Azure Sphere SDK\Hardware Definitions no Windows e /opt/azurespheresdk/HardwareDefinitions no Linux.

O repositório de Exemplos do Azure Sphere no GitHub contém arquivos de cabeçalho e JSON que definem interfaces mestras SPI para o chip MT3620 e o RDB MT3620, juntamente com outro hardware MT3620.-->

Compartilhar via