I2C entre Arduinos

Peut-être que parfois nous voulons partager la charge de travail d'un Arduino avec un autre. Ou peut-être que nous voulons plus de broches numériques ou analogiques. Le circuit intégré intégré ou I2C (prononcé I au carré C) est la meilleure solution.

I2C est un protocole intéressant. Il est généralement utilisé pour communiquer entre les composants des cartes mères des caméras et de tout système électronique intégré.

Ici, nous allons faire un bus I2C en utilisant deux Arduinos. Nous programmerons un Arduino maître pour commander à l'autre Arduino esclave de faire clignoter sa LED intégrée une ou deux fois en fonction de la valeur reçue.

Pour construire cela, nous avons besoin des "ingrédients" suivants:

  • 2 Arduinos
  • Câbles de démarrage
Cette instruction et bien d'autres peuvent être trouvées dans mon livre de recettes de développement Arduino disponible ici. :RÉ

Étape 1: comment les connecter

Suivez ces étapes pour connecter deux Arduino UNO à l'aide d'I2C:

  1. Connectez les broches A4 et A5 d'un Arduino aux mêmes broches de l'autre.
  2. La ligne GND doit être commune aux deux Arduinos. Connectez-le avec un cavalier.

Nous avons également une implémentation schématique et "maquette", toutes deux faciles à suivre. Heureusement, c'est une implémentation simple.

N'oubliez pas de ne jamais connecter ensemble des Arduinos 5 V et 3, 3 V. Ce ne sera pas
blesser l'Arduino 5V, mais il va certainement ennuyer son frère 3, 3 V!

Étape 2: Code

Le code suivant est divisé en deux parties: le code maître et le code esclave, qui s'exécutent sur deux Arduinos différents. Jetons d'abord un coup d'œil au code maître :

 // Inclut la bibliothèque Wire requise pour I2C 
#include int x = 0; void setup () {// Démarrer le bus I2C en tant que Master Wire.begin (); } void loop () {Wire.beginTransmission (9); // transmet au périphérique # 9 Wire.write (x); // envoie x Wire.endTransmission (); // arrête de transmettre x ++; // Incrémente x si (x> 5) x = 0; // `réinitialise x une fois qu'il obtient 6 delay (500); }

Et voici le code esclave qui interprète les caractères envoyés par le maître:

 // Inclut la bibliothèque Wire requise pour I2C 
#include int LED = 13; int x = 0; void setup () {// Définissez la broche LED comme Output pinMode (LED, OUTPUT); // Démarrez le bus I2C en tant qu'esclave à l'adresse 9 Wire.begin (9); // Attache une fonction à déclencher quand quelque chose est reçu. Wire.onReceive (receiveEvent); } void receiveEvent (int bytes) {x = Wire.read (); // lire un caractère de la boucle vide I2C} () {// Si la valeur reçue est 0 LED clignotante pendant 200 ms si (x == '0') {digitalWrite (LED, HIGH); retard (200); digitalWrite (LED, LOW); retard (200); } // Si la valeur reçue est de 3 LED clignotantes pendant 400 ms if (x == '3') {digitalWrite (LED, HIGH); retard (400); digitalWrite (LED, LOW); retard (400); }}

Pièces jointes

  • Télécharger I2C_master.ino
  • Télécharger I2C_slave.ino

Étape 3: répartition du code

Voyons d'abord le maître . Nous devons inclure la bibliothèque Wire.h requise:

 #comprendre 

Ensuite, dans la fonction de configuration, nous commençons le bus I2C en utilisant la fonction Wire.begin () . Si aucun argument n'est fourni dans la fonction, Arduino démarrera en tant que maître.

Enfin, nous envoyons un caractère x, compris entre 0 et 5. Nous utilisons les fonctions suivantes pour
commencer une transmission vers l'appareil avec l'adresse 9, écrire le caractère, puis arrêter la transmission:

 Wire.beginTransmission (9); // transmet au périphérique # 9 Wire.write (x); // envoie x Wire.endTransmission (); // arrête de transmettre 

Explorons maintenant le code Arduino esclave . Nous incluons également la bibliothèque Wire.h ici, mais maintenant nous démarrons le bus I2C en utilisant Wire.begin (9) . Le nombre dans l'argument est l'adresse que nous voulons utiliser pour l'Arduino. Tous les appareils avec l'adresse 9 recevront la transmission.

Maintenant, nous devons réagir d'une manière ou d'une autre lorsque nous recevons une transmission I2C. La fonction suivante ajoute une fonction de déclenchement chaque fois qu'un caractère est reçu. Mieux dit, chaque fois que l'Arduino reçoit un caractère sur I2C, il exécutera la fonction que nous lui demandons d'exécuter:

 Wire.onReceive (receiveEvent); 

Et c'est la fonction. Ici, nous stockons simplement la valeur du caractère reçu:

 void receiveEvent (int bytes) {x = Wire.read (); } 

Dans loop (), nous interprétons simplement ce caractère pour faire clignoter la LED intégrée à différentes vitesses en fonction du caractère reçu.

Étape 4: En savoir plus sur I2C

Pour passer brièvement en revue la théorie, I2C nécessite deux lignes numériques: la ligne de données série ( SDA ) pour transférer les données et la ligne d'horloge série ( SCL ) pour conserver l'horloge. Chaque connexion I2C peut avoir un maître et plusieurs esclaves. Un maître peut écrire sur des esclaves et demander aux esclaves de fournir des données, mais aucun esclave ne peut directement écrire sur le maître ou sur un autre esclave. Chaque esclave a une adresse unique sur le bus, et le maître doit connaître les adresses de chaque esclave auquel il veut accéder.

Chaque bus I2C peut prendre en charge jusqu'à 112 périphériques . Tous les appareils doivent partager GND . La vitesse est d'environ 100 kb / s - pas très rapide mais toujours respectable et tout à fait utilisable. Il est possible d'avoir plus d'un maître sur un bus, mais c'est vraiment compliqué et généralement évité.

De nombreux capteurs utilisent I2C pour communiquer, généralement des unités de mesure inertielle, des baromètres,
capteurs de température et certains Sonars. N'oubliez pas que l'I2C n'est pas conçu pour les longues longueurs de câble . Selon le type de câble utilisé, 2 mètres peuvent déjà causer des problèmes.

I2C est un protocole de transmission compliqué, mais il est très utile. Tous les Arduinos l'implémentent, avec quelques différences dans les mappages de broches:

Broches de la carte I2C

Uno, Pro Mini A4 (SDA), A5 (SCL)

Mega, Due 20 (SDA), 21 (SCL)

Leonardo, Yun 2 (SDA), 3 (SCL)

Étape 5: connecter plus d'appareils

Si nous devons connecter plus de deux appareils sur un bus I2C, il suffit de connecter ensemble toutes les lignes SDA et SCL. Nous aurons besoin que l'adresse de chaque esclave soit adressée par le maître Arduino.

Voici une vidéo d'une implémentation personnelle utilisant 1 maître et 3 esclaves.

Plus de sujets concernant les communications Arduino telles que la série sans fil, les cartes SD ou Ethernet peuvent être trouvés dans mon livre de recettes de développement Arduino disponible ici. :RÉ

Articles Connexes