Communication I2C entre deux planches Arduino
Cet article couvre:
- Qu'est-ce que la communication I2C à Arduino
- I2c épingles à Arduino
- Qu'est-ce que la bibliothèque de fils I2C
- Connexion de deux cartes Arduino en utilisant I2C comme maître et esclave
- Schématique
- Code maître
- Code d'esclaves
- Sortir
- Conclusion
Qu'est-ce que la communication I2C à Arduino
I2C (Circuit inter-intégré) est un protocole populaire pour connecter les microcontrôleurs à des périphériques tels que des capteurs et des écrans. Arduino Uno, une carte de microcontrôleur largement utilisée, peut être configurée pour communiquer avec d'autres appareils à l'aide du protocole de communication I2C.
Certains points forts principaux de la communication I2C comprennent:
Capacité multi-maître et multi-esclaves: I2C prend en charge plusieurs appareils maîtres et plusieurs appareils d'esclaves sur un seul bus, permettant une communication entre plusieurs appareils en même temps.
Comptage de broches: I2C utilise seulement deux lignes, SDA et SCL, pour la communication, qui réduit le nombre de connexions requises et simplifie le câblage.
Dispositifs adressables: Chaque appareil I2C dans le bus a une adresse unique, permettant une identification et une communication faciles avec des appareils spécifiques.
Grande vitesse: I2C est capable de débits de données élevés jusqu'à 3.4 Mbps, ce qui le rend adapté aux applications de transfert de données à grande vitesse.
Economie d'énergie: I2C permet une communication à faible puissance entre les appareils en permettant aux appareils d'être mis en modes à faible puissance lorsqu'ils ne communiquent pas et ne se réveillent pas sur demande.
I2c épingles à Arduino
Dans la communication I2C, deux lignes sont utilisées:
- Ligne de données (SDA): Ligne de données pour échanger des données entre les appareils maître et esclaves.
- Ligne d'horloge (SCL): Ligne d'horloge pour synchroniser la communication I2C entre les appareils.
Le maître Arduino contrôle la ligne d'horloge I2C et commence la communication avec les périphériques, tandis que les appareils esclaves répondent aux demandes du maître.
Dans le tableau ci-dessous, vous trouverez les épingles de l'interface I2C sur diverses cartes Arduino:
| Conseil | I2c épingles |
|---|---|
| Arduino nano | SDA-A4 | SCL-A5 |
| Arduino mega | SDA-A4 | SCL-A5 et SDA-20 | SCL-21 |
| Arduino Leonardo | SDA-A4 | SCL-A5 |
| Arduino Uno | SDA-A4 | SCL-A5 |
| Arduino Micro | SDA-02 | SCL-03 * |
* Les broches I2C peuvent varier en fonction de la version de la carte que vous utilisez avec aimablement voir la fiche technique respective pour plus de détails.
Qu'est-ce que la bibliothèque de fils I2C
La bibliothèque I2C Wire est préinstallée dans un IDE qui établit la communication entre les appareils I2C. La bibliothèque contient des fonctions de configuration et de communication sur le bus I2C, y compris des fonctions pour initialiser le bus en tant qu'appareil maître ou esclave, envoyer et recevoir des données, et contrôler la vitesse d'horloge.
La bibliothèque facilite la communication avec les appareils I2C en abstraction des détails de bas niveau du protocole I2C et en fournissant des fonctions simples et de haut niveau qui peuvent être utilisées dans les croquis Arduino. Par exemple, le commencer() La fonction est utilisée pour initialiser le bus I2C en tant qu'appareil maître ou esclave
La bibliothèque prend également en charge l'utilisation de plusieurs bus I2C, permettant une communication avec plusieurs appareils en même temps. Si vous avez affaire à plusieurs capteurs ou écrans pour un projet, cela est utile.
Connexion de deux cartes Arduino en utilisant I2C comme maître et esclave
Pour établir la communication I2C entre deux conseils Arduino Uno, les broches SDA et SCL des deux conseils doivent être connectées et partager un terrain commun. La communication peut être réalisée en utilisant la bibliothèque de fils intégrés dans Arduino qui contient des fonctions de configuration et de communication sur le bus I2C.
Schématique
L'image ci-dessous montre deux cartes Arduino Uno connectées dans la configuration maître-esclave:
Code maître
Téléchargez le code ci-dessous sur Master Arduino Board:
#include / * bibliothèque de fils pour la communication I2C * /
int x = 0; / * Initialiser une variable pour stocker un nombre * /
void setup()
/ * Démarrez le bus I2C en tant que maître * /
Fil.commencer();
VOID LOOP ()
/ * L'adresse de bus I2C est définie comme 9 pour l'appareil esclave * /
Fil.BeginTransmission (9);
Fil.écrire (x); / * Envoie x * /
Fil.endtransmission (); / * Arrêtez de transmettre * /
x ++; / * Incrément x * /
if (x> 5) x = 0; / * réinitialiser x une fois qu'il obtient 6 * /
retard (1000);
Code démarré par inclut la bibliothèque maître I2C. Une variable est initialisée qui stockera les valeurs entières à partir de 0 à 5. L'adresse I2C pour le dispositif esclave est définie comme 9. Utilisation de la fonction de bibliothèque de fils
Sur le tableau principal, le commencer() La fonction initialisera le bus I2C en tant que dispositif maître
Une fois les planches configurées, ils peuvent communiquer entre eux sur le bus I2C. Le Master Arduino demande les données de l'esclave Arduino Board et l'esclave peut répondre avec les données demandées.
Code d'esclaves
Téléchargez le code ci-dessous sur la carte Arduino esclave à laquelle la LED est connectée:
#inclure
int led = 13; / * Broche LED pour la sortie * /
int x = 0; / * Variable pour recevoir la valeur de Master Arduino * /
void setup()
PinMode (LED, sortie); / * LED PIN SET comme sortie * /
Fil.commencer (9); / * Le périphérique esclave I2C lira les données de Master à l'adresse # 9 * /
Fil.onreceive (recevant); / * Attachez une fonction pour déclencher lorsque quelque chose est reçu * /
void recevant (int octets)
x = fil.lire(); / * Lire un personnage du maître i2c * /
VOID LOOP ()
/ * Si la valeur reçue est de 0 Link LED pour 200 ms * /
if (x == 0)
DigitalWrite (LED, High);
Delay (200);
DigitalWrite (LED, bas);
Delay (200);
/ * Si la valeur reçue est de 3 clignotants LED pour 400 ms * /
if (x == 3)
DigitalWrite (LED, High);
retard (400);
DigitalWrite (LED, bas);
retard (400);
Code commencé par inclure la bibliothèque de câbles et ensuite nous définissons la LED intégrée à la broche 13 de l'esclave arduino en sortie. Suivant une variable X est défini qui recevra des données du maître Arduino. En utilisant cette valeur entière, nous clignotons des yeux LED à un caractère particulier une fois qu'il sera reçu.
Dans boucle(), Le caractère reçu est ensuite traduit par une vitesse différente de clignotant LED en fonction du caractère reçu. Si la condition est utilisée lorsque le caractère reçu du périphérique maître est 0, la LED clignote avec 200 ms et si le caractère reçu est 3 LED clignote avec un retard de 400 ms.
Dans le cas de tout autre personnage, la LED restera éteinte.
Sortir
En sortie, nous pouvons voir LED connecté avec des clignotements arduino esclaves chaque fois que Master envoie un caractère 0 ou 3.
Conclusion
La communication I2C permet à plusieurs appareils de communiquer entre eux en utilisant un bus commun. Les planches Arduino peuvent être configurées pour communiquer entre elles en utilisant I2C en connectant les broches SDA et SCL et en configurant les planches en tant que maître et esclave à l'aide de la bibliothèque de fils dans Arduino. L'utilisation de la communication I2C multiple dans un projet est donc plus facile et plus efficace.