Comment fonctionne la communication I2C ? Tutoriel Arduino et I2C

Dans ce tutoriel, nous apprendrons comment fonctionne le protocole de communication I2C et nous en ferons également un exemple pratique avec la carte Arduino et un capteur qui utilise ce protocole. Vous pouvez regarder la vidéo suivante ou lire le didacticiel écrit ci-dessous.

Aperçu

Le bus de communication I2C est très populaire et largement utilisé par de nombreux appareils électroniques car il peut être facilement mis en œuvre dans de nombreuses conceptions électroniques qui nécessitent une communication entre un maître et plusieurs appareils esclaves ou même plusieurs appareils maîtres. Les implémentations faciles s'accompagnent du fait que seuls deux fils sont nécessaires pour la communication entre près de 128 (112) appareils lors de l'utilisation d'un adressage 7 bits et jusqu'à près de 1024 (1008) appareils lors de l'utilisation d'un adressage 10 bits.

Comment fonctionne I2C

Comment est-il possible, une communication entre tant d'appareils avec juste des fils ? Eh bien, chaque appareil a un ID prédéfini ou une adresse d'appareil unique afin que le maître puisse choisir avec quels appareils communiquer.

Les deux fils, ou lignes, sont appelés Serial Clock (ou SCL) et Serial Data (ou SDA). La ligne SCL est le signal d'horloge qui synchronise le transfert de données entre les appareils sur le bus I2C et il est généré par l'appareil maître. L'autre ligne est la ligne SDA qui transporte les données.

Les deux lignes sont à "drain ouvert", ce qui signifie que des résistances de rappel doivent leur être attachées afin que les lignes soient hautes car les appareils sur le bus I2C sont actifs bas. Les valeurs couramment utilisées pour les résistances vont de 2K pour des vitesses plus élevées à environ 400 kbps, à 10K pour des vitesses inférieures à environ 100 kbps.

Protocole I2C

Le signal de données est transféré en séquences de 8 bits. Ainsi, après qu'une condition de démarrage spéciale se soit produite, vient la première séquence de 8 bits qui indique l'adresse de l'esclave auquel les données sont envoyées. Après chaque séquence de 8 bits suit un bit appelé Acknowledge. Après le premier bit d'accusé de réception, dans la plupart des cas, vient une autre séquence d'adressage, mais cette fois pour les registres internes du dispositif esclave. Juste après les séquences d'adressage suivent les séquences de données jusqu'à ce que les données soient complètement envoyées et qu'elles se terminent par une condition d'arrêt spéciale.

Examinons d'encore plus près ces événements. La condition de démarrage se produit lorsque la ligne de données tombe à l'état bas alors que la ligne d'horloge est encore à l'état haut. Après cela, l'horloge démarre et chaque bit de données est transféré pendant chaque impulsion d'horloge.

La séquence d'adressage de l'appareil commence par le bit le plus significatif (MSB) et se termine par le bit le moins significatif (LSB). Elle est en fait composée de 7 bits car le 8 ^ème bit est utilisé pour indiquer si le maître va écrire sur l'esclave (logique bas) ou lire à partir de celui-ci (logique haut).

Le bit suivant AKC/NACK est utilisé par le dispositif esclave pour indiquer s'il a reçu avec succès la séquence de bits précédente. Ainsi, à ce moment, l'appareil maître transmet le contrôle de la ligne SDA à l'appareil esclave et si l'appareil esclave a reçu avec succès la séquence précédente, il ramènera la ligne SDA à la condition appelée Acknowledge. Si l'esclave ne tire pas la ligne SDA vers le bas, la condition est appelée Pas d'accusé de réception et signifie qu'il n'a pas reçu avec succès la séquence précédente, ce qui peut être dû à plusieurs raisons. Par exemple, l'esclave peut être occupé, ne pas comprendre les données ou la commande reçues, ne plus recevoir de données, etc. Dans un tel cas, l'appareil maître décide comment il procédera.

Vient ensuite l'adressage des registres internes. Les registres internes sont des emplacements dans la mémoire de l'esclave contenant diverses informations ou données. Par exemple, l'accéléromètre ADX345 a une adresse de périphérique unique et des adresses de registres internes supplémentaires pour les axes X, Y et Z. Donc, si nous voulons lire les données de l'axe X, nous devons d'abord envoyer l'adresse de l'appareil, puis l'adresse de registre interne particulière pour l'axe X. Ces adresses peuvent être trouvées dans la fiche technique du capteur.

Après l'adressage, les séquences de transfert de données commencent soit depuis le maître soit depuis l'esclave selon le mode sélectionné au bit R/W. Une fois les données complètement envoyées, le transfert se terminera par une condition d'arrêt qui se produit lorsque la ligne SDA passe de bas à haut alors que la ligne SCL est haute.

Exemple

À titre d'exemple, j'utiliserai la carte de dérivation GY-80 qui se compose de 5 capteurs différents et la carte de dérivation GY-521 qui se compose de 3 capteurs différents. Ainsi, nous pouvons obtenir des données de 8 capteurs différents avec seulement deux fils avec le bus I2C.

Vous pouvez obtenir ces composants sur l'un des sites ci-dessous :

• Accélérateur 3 axes ADXL345………………………………………………………
• 2 en 1 :Gyroscope et accéléromètre à 6 axes MPU6050 …………………
• 3 en 1 :Gyroscope d'accélération de champ magnétique GY-80 à 9 axes……… Amazon 
• 3 en 1 : Module GY-86 10DOF MS5611 HMC5883L MPU6050……… Banggood  /AliExpress

Voici comment nous allons connecter les cartes. La broche Serial Clock de la carte Arduino sera connectée aux broches Serial Clock des deux cartes de dérivation, il en va de même pour les broches Serial Data et nous alimenterons les cartes avec la broche Gnd et la broche 5V de la carte Arduino. Notez ici que nous n'utilisons pas de résistances pull-up car les cartes de dérivation en ont déjà.

Maintenant, pour communiquer avec ces puces ou capteurs, nous devons connaître leurs adresses uniques. Nous pouvons les trouver à partir des fiches techniques des capteurs. Pour la carte de dérivation GY-80, nous avons les 4 adresses suivantes :un 0x53 hexadécimal pour le capteur de l'accéléromètre à 3 axes, un 0x69 hexadécimal pour le gyroscope à 3 axes, un 0x1E hexadécimal pour le magnétomètre à 3 axes et un 0x77 hexadécimal pour le baromètre et le thermomètre. capteur.

Pour la carte de dérivation GY-521, nous n'avons qu'une seule adresse et c'est un 0x68 hexadécimal. Nous pouvons également obtenir ou vérifier les adresses à l'aide du croquis du scanner Arduino I2C qui peut être trouvé sur le site officiel d'Arduino. Donc ici, si nous téléchargeons et exécutons ce croquis, nous obtiendrons les adresses des appareils connectés sur le bus I2C.

Capteur                                           Numéro de pièce                                     Adresse I2C

Accéléromètre 3 axes                   Analog Devices ADXL345                   0x53                  Fiche technique

GyroST 3 Axes                                Microelectronics L3G4200D              0x69                  Fiche technique

Magnétomètre 3 axes                  Honeywell MC5883L                           0x1E                  Fiche technique

Baromètre + Thermomètre        Bosch BMP085                                     0x77                  Fiche technique

Après avoir trouvé les adresses des appareils, nous devons également trouver les adresses de leurs registres internes afin d'en lire les données. Par exemple, si nous voulons lire les données de l'axe X à partir du capteur d'accéléromètre à 3 axes de la carte de dérivation GY-80, nous devons trouver l'adresse du registre interne où les données de l'axe X sont stockées. D'après la fiche technique du capteur, nous pouvons voir que les données pour l'axe X sont en fait stockées dans deux registres, DATAX0 avec une adresse hexadécimale 0x32 et DATAX1 avec une adresse hexadécimale 0x33.

Code I2C Arduino

Créons maintenant le code qui obtiendra les données pour l'axe X. Nous allons donc utiliser la bibliothèque de fils Arduino qui doit être incluse dans le croquis. Ici, nous devons d'abord définir l'adresse du capteur et les deux adresses de registres internes que nous avons trouvées précédemment. Le Wire.begin() La fonction lancera la bibliothèque Wire et nous devons également lancer la communication série car nous utiliserons le moniteur série pour afficher les données du capteur.

Dans la boucle() nous allons commencer par le Wire.beginTransmission() fonction qui commencera la transmission au capteur particulier, l'accéléromètre à 3 axes dans notre cas. Puis avec le Wire.write() fonction, nous demanderons les données particulières des deux registres de l'axe X. Le Wire.endTransmission() mettra fin à la transmission et transmettra les données des registres. Maintenant avec le Wire.requestFrom() fonction, nous demanderons les données transmises ou les deux octets des deux registres.

Le Wire.available() La fonction renverra le nombre d'octets disponibles pour la récupération et si ce nombre correspond à nos octets demandés, dans notre cas 2 octets, en utilisant le Wire.read() fonction nous allons lire les octets des deux registres de l'axe X. À la fin, nous imprimerons les données dans le moniteur série. Voici ces données, mais gardez à l'esprit qu'il s'agit de données brutes et que des calculs sont nécessaires pour obtenir les bonnes valeurs de l'axe X. Vous trouverez plus de détails à ce sujet dans mon prochain tutoriel sur l'utilisation des accéléromètres avec la carte Arduino car je ne veux pas surcharger ce tutoriel car son objectif principal était d'expliquer comment fonctionne la communication Arduino I2C.

/*  
 *  How I2C Communication Protocol Works - Arduino I2C Tutorial
 *  
 *   by Dejan, www.HowToMechatronics.com 
 *   
 */

#include <Wire.h>

int ADXLAddress = 0x53; // Device address in which is also included the 8th bit for selecting the mode, read in this case.

#define X_Axis_Register_DATAX0 0x32 // Hexadecima address for the DATAX0 internal register.
#define X_Axis_Register_DATAX1 0x33 // Hexadecima address for the DATAX1 internal register.
#define Power_Register 0x2D // Power Control Register

int X0,X1,X_out;

void setup() {
  Wire.begin(); // Initiate the Wire library
  Serial.begin(9600);
  delay(100);
  // Enable measurement
  Wire.beginTransmission(ADXLAddress);
  Wire.write(Power_Register);
  // Bit D3 High for measuring enable (0000 1000)
  Wire.write(8);  
  Wire.endTransmission();
}

void loop() {
  Wire.beginTransmission(ADXLAddress); // Begin transmission to the Sensor 
  //Ask the particular registers for data
  Wire.write(X_Axis_Register_DATAX0);
  Wire.write(X_Axis_Register_DATAX1);
  
  Wire.endTransmission(); // Ends the transmission and transmits the data from the two registers
  
  Wire.requestFrom(ADXLAddress,2); // Request the transmitted two bytes from the two registers
  
  if(Wire.available()<=2) {  // 
    X0 = Wire.read(); // Reads the data from the register
    X1 = Wire.read();   
  }
  
  Serial.print("X0= ");
  Serial.print(X0);
  Serial.print("   X1= ");
  Serial.println(X1);
}Code language: Arduino (arduino)