Comment utiliser plusieurs appareils I2C avec Arduino

Arduino est une carte électronique construite pour la conception de projets. Tout en construisant des projets Arduino, la communication joue un rôle majeur. Arduino a plusieurs protocoles de communication tels que Serial Usart, SPI et I2C. Ces protocoles améliorent la fonctionnalité et l'utilisation d'Arduino sur une grande gamme de produits. Si notre appareil ne prend pas en charge un protocole spécifique, nous avons un avantage d'utiliser les deux autres. Parmi tous ces I2C, il y a l'un des protocoles les plus avancés utilisés dans les cartes Arduino. Discutons de la façon de configurer le protocole I2C pour plusieurs appareils.

I2c avec arduino

I2C également connu sous le nom de circuit inter intégré est un protocole de communication utilisé dans les cartes Arduino. Il n'utilise que deux lignes pour la communication et l'un des protocoles les plus complexes à mettre en œuvre avec une carte Arduino. En utilisant I2C, nous pouvons connecter jusqu'à 128 appareils avec une carte Arduino sur une seule ligne de données.

I2C utilise deux lignes qui sont SDA et SCL. Avec ces deux lignes, une résistance de traction est utilisée pour maintenir à la fois la ligne SDA et SCL.

Les protocoles I2C prennent en charge la configuration des esclaves multiples, ce qui signifie qu'en utilisant un seul maître Arduino, nous pouvons contrôler plusieurs appareils esclaves.

Comment utiliser plusieurs I2C avec Arduino

Comme I2C a une prise en charge de configuration maître-esclave afin que nous puissions contrôler plusieurs appareils à la fois. Dans certains projets, nous utilisons différents modules, capteurs et matériel qui prennent en charge la communication I2C, tous ces éléments peuvent être connectés sur un seul bus I2C s'ils ont une adresse I2C unique. Mais si nous avons plus d'un appareil qui partage la même adresse I2C, cela peut causer des problèmes pour les deux appareils et nous ne pouvons pas les contrôler en utilisant le même bus I2C. Cependant, ce problème peut être résolu en utilisant un TCA9548A Multiplexeur I2C, ce MUX utilise un seul bus I2C d'Arduino et se convertit en 8 canaux différents avec toutes les adresses distinctes.

Toutes les adresses I2C sont principalement de deux types soit 7 bits ou 10 bits. La plupart des dispositifs de temps utilisent 7 bits I2C, mais le 10 bits I2C est rarement utilisé dans les appareils. Donc, cela signifie que l'utilisation d'une adresse 7 bits Arduino peut connecter 128 appareils.

Nous allons maintenant connecter deux appareils différents ayant des protocoles I2C uniques avec les lignes Arduino Uno I2C.

Schéma

La figure ci-dessous montre un écran OLED attaché à Arduino en utilisant les lignes I2C SDA et SCL. Tandis qu'un écran LCD 16x2 est également connecté en utilisant le même bus I2C parallèle avec l'écran OLED. Une chose importante à noter ici est que l'écran LCD 16x2 n'utilise que 4 fils I2C au lieu de 8 fils pour son contrôle. Avec LCD, nous avons utilisé un module I2C avec Arduino qui n'a besoin que de 4 broches pour l'affichage LCD: VCC, GND, SDA, SCL. En utilisant le module I2C avec LCD, nous avons enregistré 4 broches numériques sur Arduino, ce qui réduira tout le câblage et améliorera la fonctionnalité Arduino.

Comment vérifier les adresses des appareils I2C

Avant de connecter tout appareil I2C à Arduino, il est important de noter à quelle adresse cet appareil spécifique est connecté. Certains modules ont des adresses I2C par défaut écrites alors que certaines d'entre elles n'ont aucune instruction pour vérifier les adresses I2C. Pour résoudre ce problème, nous avons un fil Code de bibliothèque qui vérifie tous les appareils I2C connectés et à quelle adresse ils sont connectés à Arduino. Cela aidera à déboguer et à améliorer le circuit Arduino.

Code

#include / * Inclure du fil.H Library H * /
void setup()

Fil.commencer(); / * Wire I2C Communication Start * /
En série.commencer (9600); / * Ensemble de taux de bauds pour la communication série * /
alors que (!En série); / * En attente de sortie série sur moniteur série * /
En série.println ("\ ni2c scanner");

VOID LOOP ()

octet err, ADR; / * L'erreur de variable est définie avec l'adresse de i2c * /
int number_of_devices;
En série.println ("Scanning.");
Number_Of_Devices = 0;
pour (ADR = 1; ADR < 127; adr++ )

Fil.BeginTransmission (ADR);
err = fil.endtransmission ();
if (err == 0)

En série.print ("périphérique I2C à l'adresse 0x");
si (ADR < 16)
En série.print ("0");
En série.imprimer (ADR, hex);
En série.println (" !");
numéro_of_devices ++;

else if (err == 4)

En série.print ("Erreur inconnue à l'adresse 0x");
si (ADR < 16)
En série.print ("0");
En série.println (adr, hex);


if (number_of_devices == 0)
En série.println ("Non dispositifs I2C attachés \ n");
autre
En série.println ("Done \ n");
retard (5000); / * attendez 5 secondes pour le prochain scan I2C * /

Ce code aidera à trouver le numéro de périphériques I2C et leur adresse à laquelle ils sont connectés. Ce code est communément appelé code de scanner I2C.

Tout d'abord, nous avons inclus un "Fil.h ” bibliothèque. Ensuite, dans la partie de configuration du code, nous avons commencé cette bibliothèque. Après cela, nous initialisons la communication série en définissant le taux de bauds 9600. Cela aidera à voir la sortie sur le moniteur en série.

Dans la section Loop, nous avons défini deux variables "se tromper" et «ADR». Ensuite, nous avons défini une autre variable "Dispositifs" et le régler sur zéro. Après ça un pour la boucle est initialisée avec des valeurs comprises entre 0 et 127.

Ensuite, nous entrons l'adresse au fil en utilisant fil.BeginTransmission (), Le scanner I2C recherchera la reconnaissance des appareils et leur adresse. La valeur lecture sera stockée dans la variable "erreur". La valeur de retour sera égale à 0 si le périphérique reconnaît que l'adresse autrement deviendra 4. Ensuite, nous avons utilisé une condition IF qui imprimera l'adresse du périphérique I2C si la valeur est <16. Final address of the device is printed in Hexadecimal form.

Circuit

Sortir

La sortie des dispositifs attachés à Arduino sur les protocoles I2C ressemblera comme indiqué dans le diagramme ci-dessous. Ici 0x3c est l'adresse de l'écran LCD I2C alors que 0x27 est l'adresse de l'OLED filtrer.

Conclusion

Les appareils de connexion à l'aide de I2C dans Arduino peuvent enregistrer un certain nombre d'épingles. Plusieurs appareils peuvent être connectés à l'aide de I2C dans la configuration maître-esclave, mais la principale chose à considérer est que tous les appareils doivent avoir une adresse I2C unique, il n'y a pas deux appareils ayant la même adresse. Donc, nous suggérons qu'une solution à ce problème consiste à utiliser un TCA9548A Multiplexeur I2C, il peut convertir un seul bus I2C en 8 canaux différents.