Arduino - Circuit intégré inter

Le circuit inter-intégré (I2C) est un système d'échange de données série entre les microcontrôleurs et les circuits intégrés spécialisés d'une nouvelle génération. Il est utilisé lorsque la distance entre eux est courte (le récepteur et l'émetteur sont généralement sur la même carte imprimée). La connexion est établie via deux conducteurs. L'un est utilisé pour le transfert de données et l'autre est utilisé pour la synchronisation (signal d'horloge).

Comme le montre la figure suivante, un appareil est toujours un maître. Il effectue l'adressage d'une puce esclave avant le début de la communication. De cette manière, un microcontrôleur peut communiquer avec 112 appareils différents. Le débit en bauds est généralement de 100 Kb / s (mode standard) ou de 10 Kb / s (mode de débit en bauds lent). Des systèmes avec un débit en bauds de 3,4 Mb / s sont récemment apparus. La distance entre les appareils qui communiquent via un bus I2C est limitée à plusieurs mètres.

Cartes I2C Pins

Le bus I2C se compose de deux signaux - SCL et SDA. SCL est le signal d'horloge et SDA est le signal de données. Le maître de bus actuel génère toujours le signal d'horloge. Certains périphériques esclaves peuvent parfois forcer l'horloge à un niveau bas pour retarder l'envoi de plus de données par le maître (ou pour exiger plus de temps pour préparer les données avant que le maître tente de les synchroniser). C'est ce qu'on appelle «l'étirement de l'horloge».

Voici les broches pour différentes cartes Arduino -

  • Uno, Pro Mini A4 (SDA), A5 (SCL)
  • Mega, dû 20 (SDA), 21 (SCL)
  • Leonardo, Yun 2 (SDA), 3 (SCL)

Arduino I2C

Nous avons deux modes - code maître et code esclave - pour connecter deux cartes Arduino en utilisant I2C. Ils sont -

  • Émetteur maître / récepteur esclave
  • Récepteur maître / émetteur esclave

Émetteur maître / récepteur esclave

Voyons maintenant ce que sont l'émetteur maître et le récepteur esclave.

Émetteur maître

Les fonctions suivantes sont utilisées pour initialiser la bibliothèque Wire et rejoindre le bus I2C en tant que maître ou esclave. Ceci n'est normalement appelé qu'une seule fois.

  • Wire.begin(address) - L'adresse est l'adresse de l'esclave 7 bits dans notre cas car le maître n'est pas spécifié et il rejoindra le bus en tant que maître.

  • Wire.beginTransmission(address) - Commencer une transmission vers l'appareil esclave I2C avec l'adresse indiquée.

  • Wire.write(value) - Met en file d'attente les octets pour la transmission d'un périphérique maître à esclave (entre les appels à beginTransmission () et endTransmission ()).

  • Wire.endTransmission() - Met fin à une transmission vers un périphérique esclave qui a été commencée par beginTransmission () et transmet les octets mis en file d'attente par wire.write ().

Example

#include <Wire.h> //include wire library

void setup() //this will run only once { 
   Wire.begin(); // join i2c bus as master
} 

short age = 0; 

void loop() {   
   Wire.beginTransmission(2); 
   // transmit to device #2
   Wire.write("age is = ");
   Wire.write(age); // sends one byte
   Wire.endTransmission(); // stop transmitting
   delay(1000); 
}

Récepteur esclave

Les fonctions suivantes sont utilisées -

  • Wire.begin(address) - L'adresse est l'adresse de l'esclave 7 bits.

  • Wire.onReceive(received data handler) - Fonction à appeler lorsqu'un appareil esclave reçoit des données du maître.

  • Wire.available() - Renvoie le nombre d'octets disponibles pour la récupération avec Wire.read (). Cela doit être appelé dans le gestionnaire Wire.onReceive ().

Example

#include <Wire.h> //include wire library

void setup() {  //this will run only once
   Wire.begin(2); // join i2c bus with address #2
   Wire.onReceive(receiveEvent); // call receiveEvent when the master send any thing 
   Serial.begin(9600); // start serial for output to print what we receive 
}

void loop() {   
   delay(250); 
}

//-----this function will execute whenever data is received from master-----//

void receiveEvent(int howMany) { 
   while (Wire.available()>1) // loop through all but the last {
      char c = Wire.read(); // receive byte as a character
      Serial.print(c); // print the character
   }
}

Récepteur maître / émetteur esclave

Voyons maintenant ce que sont le récepteur maître et l'émetteur esclave.

Récepteur principal

Le maître est programmé pour demander, puis lire les octets de données qui sont envoyés à partir de l'esclave Arduino à adresse unique.

La fonction suivante est utilisée -

Wire.requestFrom(address,number of bytes)- Utilisé par le maître pour demander des octets à un appareil esclave. Les octets peuvent ensuite être récupérés avec les fonctions wire.available () et wire.read ().

Example

#include <Wire.h> //include wire library void setup() { 
   Wire.begin(); // join i2c bus (address optional for master) 
   Serial.begin(9600); // start serial for output
} 

void loop() { 
   Wire.requestFrom(2, 1); // request 1 bytes from slave device #2
   while (Wire.available()) // slave may send less than requested {
      char c = Wire.read(); // receive a byte as character
      Serial.print(c); // print the character
   } 
   delay(500); 
}

Émetteur esclave

La fonction suivante est utilisée.

Wire.onRequest(handler) - Une fonction est appelée lorsqu'un maître demande des données à cet appareil esclave.

Example

#include <Wire.h> 

void setup() { 
   Wire.begin(2); // join i2c bus with address #2
   Wire.onRequest(requestEvent); // register event
} 

Byte x = 0;

void loop() { 
   delay(100); 
} 

// function that executes whenever data is requested by master
// this function is registered as an event, see setup()

void requestEvent() { 
   Wire.write(x); // respond with message of 1 bytes as expected by master
   x++; 
}