Utiliser I2C dans les applications de haut niveau

Azure Sphere prend en charge I2C (Inter-Integrated Circuit) en mode maître. I2C est un bus série qui connecte des périphériques à faible débit à des microcontrôleurs. I2C utilise un modèle multimaître/multisubordonné dans lequel un appareil maître contrôle un ensemble d’appareils subordonnés. I2C est souvent utilisé avec des périphériques qui n’exigent qu’une communication légère et simple avec un microcontrôleur, notamment la définition de contrôles, de commutateurs d’alimentation et de capteurs.

Les applications accèdent aux périphériques par le bais de I2C en appelant des API I2C de bibliothèques d’applications pour effectuer des opérations sur une interface maître I2C. L’exemple I2C LSM6DS3 montre comment configurer le matériel pour I2C sur un appareil MT3620 et comment utiliser I2C dans une application.

Configuration requise pour I2C

Les applications qui utilisent I2C doivent inclure les fichiers d’en-tête appropriés pour I2C et ajouter des paramètres I2C 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

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

Déclarez la définition du préprocesseur I2C_STRUCTS_VERSION avant d’inclure le fichier d’en-tête. Cette entrée spécifie la version de struct qui est utilisée par l’application.

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

Pour utiliser les API I2C, vous devez ajouter la fonctionnalité I2cMaster au manifeste de l’application, puis ajouter chaque interface maître I2C à la fonctionnalité. Cela permet à l’application d’accéder à l’interface. Le manifeste d’application Azure Sphere contient plus de détails sur le manifeste de l’application.

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

Par exemple, voici un extrait du manifeste d’une application qui cible une carte de développement de référence (RDB) MT3620 et configure deux interfaces maîtres I2C :

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

L’extrait suivant montre comment spécifier les mêmes interfaces maîtres I2C dans une application qui cible le starter kit Avnet MT3620 :

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

Ouvrir une interface maître I2C

Avant d’effectuer des opérations sur une interface maître I2C, vous devez l’ouvrir en appelant la fonction I2CMaster_Open.

Mettre à jour les paramètres d’une interface maître I2C

Une fois que vous ouvrez l’interface maître, vous pouvez modifier les paramètres :

• Pour changer la vitesse du bus pour les opérations sur l’interface maître, appelez I2CMaster_SetBusSpeed
• Pour changer le délai d’expiration des opérations, appelez I2CMaster_SetTimeout

Effectuer des opérations de lecture et d’écriture sur l’interface maître I2C

Azure Sphere prend en charge plusieurs options pour effectuer des opérations de lecture et d’écriture avec I2C. Ces options sont toutes des opérations de blocage synchrones.

Pour les opérations d’écriture ou de lecture à sens unique, vous pouvez appeler I2CMaster_Write ou I2CMaster_Read. Il s’agit de la façon la plus simple d’effectuer des opérations sur une interface maître I2C, car elle ne spécifie qu’une seule opération et inclut l’adresse de l’appareil subordonné dans l’appel de fonction.

Vous pouvez appeler I2CMaster_WriteThenRead pour effectuer une opération combinée d’écriture puis de lecture dans une transaction de bus unique tout en assurant la continuité avec une autre transaction.

Pour une interopérabilité avec certaines interfaces POSIX, vous pouvez appeler les fonctions POSIX read(2) et write(2) pour effectuer des transactions à sens unique. Vous devez appeler I2CMaster_SetDefaultTargetAddress pour définir l’adresse de l’appareil subordonné avant d’appeler read(2) ou write(2).

Vous pouvez appeler ces fonctions pour effectuer des opérations d’écriture à 0 octet afin de vérifier la présence d’un appareil subordonné. Si une opération de lecture ou d’écriture échoue, votre application doit gérer la réémission de la demande.

Fermer l’interface I2C

Pour fermer l’interface, vous devez appeler la fonction POSIX standard close().

Prise en charge de la carte MT3620

Cette section décrit les options I2C applicables uniquement lors de l’exécution d’Azure Sphere sur l’appareil MT3620.

Pour la puce MT3620, les spécifications I2C 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 et leurs fonctions pour le câblage.

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.-->

• Quand vous configurez la carte de développement MT3620, vous avez la possibilité d’utiliser n’importe quel port ISU comme interface maître I2C. Si vous utilisez un port ISU comme interface maître I2C, vous ne pouvez pas utiliser le même port comme interface SPI ou UART.
• Les adresses d’appareils subordonnés à 10 bits ne sont pas prises en charge sur la carte MT3620 ; seules les adresses à 7 bits le sont.
• La carte MT3620 prend en charge des vitesses de bus de 100 KHz, 400 KHz et 1 MHz, mais pas de 3,4 MHz.
• Les lectures I2C à 0 octet ne sont pas prises en charge sur la carte MT3620.
• Lorsque vous utilisez I2C dans une application de haut niveau, seules les broches SCL et SDA du bloc périphérique ISU sont utilisées par le périphérique I2C, et les autres broches peuvent être utilisées en tant que GPIOs par la même application de haut niveau. Consultez les périphériques d’E/S pour obtenir la liste des broches ISU inutilisées qui peuvent être réutilisées pour GPIO.