La communication I2C (Inter-Integrated Circuit) est un protocole de communication utilisé pour connecter des composants électroniques. Il permet à plusieurs dispositifs de communiquer entre eux en utilisant deux fils uniques. Cette communication est utilisée pour connecter des capteurs, des mémoires et d’autres composants à un microcontrôleur central.
L’un des avantages de l’utilisation de la communication I2C est que les dispositifs peuvent être connectés en série sur un même bus, ce qui permet une réduction du nombre de fils nécessaires pour connecter les différents composants. De plus, le protocole I2C utilise une adressage 7 bits, ce qui permet à jusqu’à 128 dispositifs de communiquer sur un même bus.
- Qu’est-ce que la communication I2C ?
I2C signifie Inter Integrated Circuit Communication et est un protocole de communication qui permet à plusieurs dispositifs électroniques de communiquer entre eux en utilisant un seul bus de données et une seule horloge. Il est souvent utilisé pour connecter des périphériques tels que des capteurs, des écrans LCD, des mémoires EEPROM, des horloges RTC, etc.
- Avantages de la communication I2C
La communication I2C présente plusieurs avantages par rapport à d’autres protocoles de communication tels que SPI ou UART :
- Peu de fils nécessaires : I2C n’utilise que deux fils pour transmettre les données, ce qui signifie qu’il est possible de connecter plusieurs périphériques sans utiliser beaucoup de fils.
- Peu de consommation d’énergie : I2C utilise une faible quantité d’énergie, ce qui en fait un excellent choix pour les projets à faible consommation d’énergie.
- Faible complexité : I2C est un protocole relativement simple et facile à utiliser.
- Fonctionnement de la communication I2C
La communication I2C utilise deux fils pour transmettre les données. Le fil SDA (Serial Data Line) est utilisé pour transmettre les données, tandis que le fil SCL (Serial Clock Line) est utilisé pour synchroniser les données.
Chaque périphérique connecté à l’I2C bus est identifié par un numéro d’adresse unique. Le microcontrôleur envoie d’abord l’adresse du périphérique avec lequel il souhaite communiquer, puis envoie les données à ce périphérique. Le périphérique peut également envoyer des données au microcontrôleur.
- Utiliser la communication I2C avec Arduino
Arduino offre un soutien intégré pour la communication I2C grâce à la bibliothèque Wire. La bibliothèque Wire permet de communiquer avec les périphériques I2C en utilisant une syntaxe simple.
a fonction begin() pour initialiser la communication I2C et la fonction requestFrom() pour demander des données à un périphérique. La fonction write() peut être utilisée pour envoyer des données à un périphérique, tandis que la fonction read() peut être utilisée pour recevoir des données d’un périphérique.
Voici un exemple simple de code pour utiliser la communication I2C avec Arduino :
#include <Wire.h>
void setup() {
Wire.begin();
Serial.begin(9600);
}
void loop() {
Wire.requestFrom(8, 6);
while(Wire.available()) {
char c = Wire.read();
Serial.print(c);
}
delay(500);
}
Dans cet exemple, la fonction Wire.begin() initialise la communication I2C et la fonction Wire.requestFrom() demande des données à l'adresse 8. Les données reçues sont alors affichées sur le moniteur série.Pour utiliser la communication I2C avec Arduino, il suffit de connecter les fils SDA et SCL à la carte Arduino et de charger la bibliothèque Wire. Vous pouvez alors utiliser
Pour utiliser la communication I2C avec Arduino, il est nécessaire d’avoir connaissance des différents termes et concepts clés associés à ce protocole. Les concepts clés à connaître comprennent les adresses I2C, les horloges I2C, les signaux d’acknowledgement et les réponses NACK.
Lors de la communication I2C, chaque dispositif connecté au le bus a une adresse unique. Cette adresse est utilisée pour identifier le dispositif lors de la communication avec d’autres dispositifs sur le bus. Lors de la communication, un dispositif peut envoyer ou recevoir des données en utilisant les fils SDA et SCL.
L’horloge I2C est un signal généré par le dispositif maître sur le bus. Ce signal est utilisé pour synchroniser les transferts de données entre les dispositifs sur le bus. Le signal d’acknowledgement est un signal généré par le dispositif esclave pour signaler au dispositif maître que les données ont été correctement reçues. Les réponses NACK sont générées par le dispositif esclave pour signaler au dispositif maître qu’il y a eu une erreur de transmission de données.
En utilisant la bibliothèque Wire pour Arduino, vous pouvez facilement communiquer avec des dispositifs I2C en utilisant une variété de fonctions. Par exemple, la fonction begin transmettra l’adresse du dispositif esclave à l’horloge I2C. La fonction write permettra d’envoyer des données à un dispositif esclave sur le bus. La fonction requestFrom permettra de recevoir des données d’un dispositif esclave sur le bus.
Il est également possible d’utiliser la communication I2C pour connecter plusieurs microcontrôleurs entre eux. Dans ce cas, un microcontrôleur peut agir en tant que maître et un autre comme esclave.
La bibliothèque Wire.h
La bibliothèque Wire.h est la bibliothèque standard d’Arduino pour la communication I2C. Elle fournit un ensemble de fonctions pour communiquer avec des périphériques I2C en utilisant le bus I2C d’Arduino. Voici les fonctions les plus couramment utilisées :
- begin() : Cette fonction initialise le bus I2C et commence à écouter pour les transmissions I2C.
- beginTransmission(address) : Cette fonction démarre une transmission de données à un périphérique I2C à l’adresse spécifiée.
- write(data) : Cette fonction envoie des données au périphérique I2C lors d’une transmission en cours.
- endTransmission() : Cette fonction termine une transmission de données et envoie les données accumulées au périphérique I2C.
- requestFrom(address, quantity) : Cette fonction demande une quantité de données à un périphérique I2C à l’adresse spécifiée.
- available() : Cette fonction renvoie le nombre de données disponibles pour lecture à partir du périphérique I2C.
- read() : Cette fonction lit une donnée reçue à partir du périphérique I2C.
- onReceive(callback) : Cette fonction définit une fonction de rappel qui sera appelée chaque fois que des données sont reçues à partir d’un périphérique I2C.
- onRequest(callback) : Cette fonction définit une fonction de rappel qui sera appelée chaque fois qu’un périphérique I2C demande des données.
- end() : Cette fonction arrête le bus I2C et empêche toutes les transmissions futures.
Pour utiliser la bibliothèque Wire.h dans votre programme Arduino, vous devez d’abord l’inclure en ajoutant cette ligne en haut de votre code :
#include <Wire.h>
Ensuite, vous pouvez commencer à utiliser les fonctions de la bibliothèque pour communiquer avec des périphériques I2C. Voici un exemple simple d’utilisation de la bibliothèque Wire.h pour envoyer des données à un périphérique I2C :
#include <Wire.h>
void setup() {
Wire.begin(); // Initialise le bus I2C
}
void loop() {
Wire.beginTransmission(0x40); // Démarre une transmission à l'adresse 0x40
Wire.write(100); // Envoie la valeur 100
Wire.endTransmission(); // Termine la transmission
}
Ce code initialise le bus I2C à l’aide de la fonction begin(), puis démarre une transmission à l’adresse 0x40 à l’aide de la fonction beginTransmission(). La valeur 100 est ensuite envoyée à ce périphérique à l’aide de la fonction write(). La transmission est ensuite terminée à l’aide de la fonction endTransmission().
Vous pouvez également utiliser la bibliothèque Wire.h pour recevoir des données d’un périphérique I2C. Par exemple, voici un exemple de code pour recevoir des données d’un périphérique I2C :
#include <Wire.h>
void setup() {
Wire.begin(); // Initialise le bus I2C
}
void loop() {
int data;
Wire.requestFrom(0x40, 1); // Demande une donnée à l'adresse 0x40
while (Wire.available()) { // Attend que des données soient disponibles
data = Wire.read(); // Lit la donnée reçue
}
}
Ce code initialise également le bus I2C à l’aide de la fonction begin(), puis utilise la fonction requestFrom() pour demander une donnée à l’adresse 0x40. La fonction available() est utilisée pour vérifier si des données sont disponibles pour lecture, et la fonction read() est utilisée pour lire la donnée reçue.
Exemples de code communication I2C avec Arduino :
Exemple 1 : Envoi de données à un périphérique I2C
#include <Wire.h>
void setup() {
Wire.begin();
Serial.begin(9600);
}
void loop() {
Wire.beginTransmission(8);
Wire.write("Hello");
Wire.endTransmission();
delay(1000);
}Dans cet exemple, la fonction beginTransmission() démarre une transmission de données à l’adresse 8, la fonction write() envoie les données « Hello », et la fonction endTransmission() termine la transmission.
Exemple 2 : Réception de données d’un périphérique I2C:
#include <Wire.h>
void setup() {
Wire.begin();
Serial.begin(9600);
}
void loop() {
Wire.requestFrom(8, 6);
while(Wire.available()) {
char c = Wire.read();
Serial.print(c);
}
delay(500);
}Dans cet exemple, la fonction requestFrom() demande 6 octets de données à l’adresse 8. La fonction read() lit les données reçues, une par une, et les affiche sur le moniteur série.
Exemple 3 : Communication bidirectionnelle avec un périphérique I2C:
#include <Wire.h>
void setup() {
Wire.begin();
Serial.begin(9600);
}
void loop() {
Wire.beginTransmission(8);
Wire.write("Hello");
Wire.endTransmission();
Wire.requestFrom(8, 6);
while(Wire.available()) {
char c = Wire.read();
Serial.print(c);
}
delay(1000);
}Dans cet exemple, nous utilisons les fonctions beginTransmission(), write() et endTransmission() pour envoyer des données à l’adresse 8, puis les fonctions requestFrom() et read() pour recevoir des données de cette même adresse. Cela permet une communication bidirectionnelle avec un périphérique I2C.
- Conclusion
La communication I2C est un protocole de communication très utile pour les projets complexes qui impliquent plusieurs périphériques. Il est facile à utiliser avec Arduino grâce à la bibliothèque Wire, et offre de nombreux avantages, notamment une faible consommation d’énergie et une faible complexité.
