Use I2C em aplicações de alto nível

Artigo
11/05/2024

Importante

Esta é a documentação do Azure Sphere (Legado). O Azure Sphere (Legado) 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 suporta Circuito Interintegrado (I2C) no modo mestre. I2C é um barramento serial que conecta periféricos de baixa velocidade a microcontroladores. O I2C usa um modelo multi-mestre/multi-subordinado onde um dispositivo mestre controla um conjunto de dispositivos subordinados. O I2C é frequentemente usado com periféricos que exigem apenas uma comunicação leve simples com um microcontrolador, como controles de configuração, interruptores de energia e sensores.

Os aplicativos podem acessar periféricos por meio do I2C chamando APIs do Applibs I2C para executar operações em uma interface mestre I2C. O exemplo LSM6DS3 I2C descreve como configurar o hardware para I2C em um dispositivo MT3620 e usar I2C em um aplicativo.

Requisitos I2C

Os aplicativos que usam I2C devem incluir os arquivos de cabeçalho apropriados para I2C e adicionar configurações I2C ao manifesto do aplicativo.

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

Arquivos de cabeçalho

 #define I2C_STRUCTS_VERSION 1
 #include <applibs/i2c.h>
 #include "path-to-your-target-hardware.h"

Declare a definição do I2C_STRUCTS_VERSION pré-processador antes de incluir o arquivo de cabeçalho. Isso especifica a versão struct que é usada pelo aplicativo.

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

Configurações de manifesto do aplicativo

Para usar as APIs I2C, você deve adicionar o I2cMaster recurso ao manifesto do aplicativo e, em seguida, adicionar cada interface mestre I2C ao recurso. Isso permite que o aplicativo acesse a interface. O manifesto do aplicativo Azure Sphere tem mais detalhes sobre o manifesto do aplicativo.

No código, use as constantes definidas para o hardware para identificar as interfaces I2C. O compilador traduzirá esses valores em valores brutos quando você criar o aplicativo.

Por exemplo, aqui está um trecho de um manifesto de aplicativo que tem como alvo uma placa de desenvolvimento de referência (RDB) MT3620 e configura duas interfaces mestre I2C:

"I2cMaster": [ "$MT3620_RDB_HEADER2_ISU0_I2C", "$MT3620_RDB_HEADER4_ISU1_I2C" ],

O trecho a seguir mostra como especificar as mesmas interfaces mestras I2C em um aplicativo destinado ao Avnet MT3620 Starter Kit:

"I2cMaster": [ "$AVNET_MT3620_SK_ISU0_I2C", "$AVNET_MT3620_SK_ISU1_I2C" ]

Abrir uma interface mestre I2C

Antes de executar operações em uma interface mestre I2C, você deve abri-la chamando a função I2CMaster_Open .

Atualizar as configurações de uma interface mestre I2C

Depois de abrir a interface principal, você pode alterar as configurações:

Para alterar a velocidade do barramento para operações na interface mestre, chame I2CMaster_SetBusSpeed
Para alterar o tempo limite das operações, chame I2CMaster_SetTimeout

Executar operações de leitura e gravação na interface mestre I2C

O Azure Sphere suporta várias opções para executar operações de leitura e escrita com I2C. Essas opções são todas operações síncronas de bloqueio.

Para operações unidirecionais de gravação ou leitura, você pode chamar I2CMaster_Write ou I2CMaster_Read. Esta é a maneira mais simples de executar operações em uma interface mestre I2C porque especifica apenas uma operação e inclui o endereço do dispositivo subordinado na chamada de função.

Você pode chamar I2CMaster_WriteThenRead para executar uma operação combinada de gravação e leitura em uma única transação de barramento sem interrupção de outra transação.

Para interoperabilidade com algumas interfaces POSIX, você pode chamar as funções de leitura(2) e gravação(2) POSIX para executar transações unidirecionais. Você deve chamar I2CMaster_SetDefaultTargetAddress para definir o endereço do dispositivo subordinado antes de chamar read(2) ou write(2).

Você pode chamar essas funções para executar operações de gravação de 0 bytes para verificar a presença de um dispositivo subordinado. Se uma operação de leitura ou gravação falhar, seu aplicativo deverá lidar com a reemissão da solicitação.

Feche a interface I2C

Para fechar a interface, você deve chamar a função POSIX padrão close().

Suporte MT3620

Esta seção descreve as opções I2C que só se aplicam ao executar o Azure Sphere no MT3620.

As especificações I2C para o chip MT3620 estão listadas em MT3620 Support Status. O guia do usuário da placa de desenvolvimento MT3620 descreve o layout do pino e as funções da fiação.

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 Azure Sphere Samples no GitHub contém arquivos de cabeçalho e JSON que definem interfaces mestras SPI para o chip MT3620 e RDB MT3620, juntamente com outro hardware MT3620.-->

Ao configurar a placa de desenvolvimento MT3620, você pode usar qualquer porta ISU como uma interface mestre I2C. Quando você usa uma porta ISU como uma interface mestre I2C, você não pode usar a mesma porta que uma interface SPI ou UART.
Endereços de dispositivo subordinados de 10 bits não são suportados no MT3620; apenas endereços de 7 bits são suportados.
O MT3620 suporta velocidades de barramento de 100 KHz, 400 KHz e 1 MHz, mas não 3,4 Mhz.
Leituras I2C de 0 bytes não são suportadas no MT3620.
Ao usar I2C em um aplicativo de alto nível, apenas os pinos SCL e SDA no bloco periférico ISU são usados pelo periférico I2C, e os outros pinos podem ser usados como GPIOs pelo mesmo aplicativo de alto nível. Consulte Periféricos de E/S para obter uma lista dos pinos ISU não utilizados que podem ser reutilizados para GPIO.

Partilhar via