Activité pratique: Liaison I2C entre 2 Arduino UNO [Classes]

Activité pratique: Liaison I2C entre 2 Arduino UNO⚓

Circuit

Pour réaliser cette liaison il est nécessaire de relié les deux cartes par de simple fils. Les broches dédiées à la communication I2C au sein des cartes Arduino sont les broches :

A5 pour l'horloge SCL
A4 pour les données SDA

Le schéma de câblage est le suivant :

NB : Les masses de chaque carte doivent également être reliées garantissant ainsi une référence unique au deux systèmes.

Programmation : Master Writer / Slave Receiver

Dans cet exemple (directement disponible depuis le logiciel Arduino), le maître envoie (Writer) une chaîne de caractères à l'esclave (Receiver). A l'aide des documents suivant :

Document de synthèse des fonctions principales de la librairie Wire (I2C)
Documentation complète (site arduino.cc) de la librairie Wire : http://arduino.cc/en/Reference/Wire
De l'exemple : http://arduino.cc/en/Tutorial/MasterWriter

Reprendre l'exemple et le tester.

Ajouter vos commentaires en français et sauvegarder ces croquis dans votre espace personnel

NB : L'esclave doit resté connecté via l'USB à l'ordinateur, le maître lui sera alimenté via une alimentation externe : Une fois programmé il ne sera plus connecté en USB. Il restera juste relié par la masse et le bus I2C à l'escalve.

// Wire Master Writer
// by Nicholas Zambetti <http://www.zambetti.com>
// Demonstrates use of the Wire library
// Writes data to an I2C/TWI slave device
// Refer to the "Wire Slave Receiver" example for use with this
// Created 29 March 2006
// This example code is in the public domain.
#include <Wire.h>
void setup() {
  Wire.begin(); // join I2C bus (address optional for master)
}
byte x = 0;
void loop() {
  Wire.beginTransmission(8); // transmit to device #8
  Wire.write("x is ");        // sends five bytes
  Wire.write(x);              // sends one byte
  Wire.endTransmission();    // stop transmitting
  x++;
  delay(500);
}

// Wire Master Writer
// by Nicholas Zambetti <http://www.zambetti.com>

// Demonstrates use of the Wire library
// Writes data to an I2C/TWI slave device
// Refer to the "Wire Slave Receiver" example for use with this

// Created 29 March 2006

// This example code is in the public domain.


#include <Wire.h>

void setup() {
  Wire.begin(); // join I2C bus (address optional for master)
}

byte x = 0;

void loop() {
  Wire.beginTransmission(8); // transmit to device #8
  Wire.write("x is ");        // sends five bytes
  Wire.write(x);              // sends one byte
  Wire.endTransmission();    // stop transmitting

  x++;
  delay(500);
}

// Wire Slave Receiver
// by Nicholas Zambetti <http://www.zambetti.com>
// Demonstrates use of the Wire library
// Receives data as an I2C/TWI slave device
// Refer to the "Wire Master Writer" example for use with this
// Created 29 March 2006
// This example code is in the public domain.
#include <Wire.h>
void setup() {
  Wire.begin(8);                // join I2C bus with address #8
  Wire.onReceive(receiveEvent); // register event
  Serial.begin(9600);           // start serial for output
}
void loop() {
  delay(100);
}
// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEvent(int howMany) {
  while (1 < Wire.available()) { // loop through all but the last
    char c = Wire.read(); // receive byte as a character
    Serial.print(c);         // print the character
  }
  int x = Wire.read();    // receive byte as an integer
  Serial.println(x);         // print the integer
}

// Wire Slave Receiver
// by Nicholas Zambetti <http://www.zambetti.com>

// Demonstrates use of the Wire library
// Receives data as an I2C/TWI slave device
// Refer to the "Wire Master Writer" example for use with this

// Created 29 March 2006

// This example code is in the public domain.


#include <Wire.h>

void setup() {
  Wire.begin(8);                // join I2C bus with address #8
  Wire.onReceive(receiveEvent); // register event
  Serial.begin(9600);           // start serial for output
}

void loop() {
  delay(100);
}

// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEvent(int howMany) {
  while (1 < Wire.available()) { // loop through all but the last
    char c = Wire.read(); // receive byte as a character
    Serial.print(c);         // print the character
  }
  int x = Wire.read();    // receive byte as an integer
  Serial.println(x);         // print the integer
}

Visualisation d'une trame I2C

Modifier le programme du maître pour qu'il n'envoie plus qu'un seul octet, par exemple : 0b10011100
Modifier également le programme de l'esclave en conséquence : L'esclave devra cette fois afficher en binaire via le terminal série la valeur de l'octet transmis par l'esclave.
Proposer un schéma de câblage ci-dessous pour visualiser à l'oscilloscope cette trame I2C (2 signaux SCL et SDA)

Représenter dans le cadre ci-dessus les chronogrammes (SDA et SCL en correspondance de temps) visualisés à l'oscilloscope en indiquant bien les échelles (en tension et en temps) :

D'après les chronogrammes ci-dessus, mesurer la vitesse de transmission ?

Repérer sur les graphique l'adresse de l'esclave en binaire puis en hexa :

Repérer également l'octet de donnée en binaire puis en hexadécimal :

Modifier dans les deux programmes l'adresse de l'esclave, que se passe-t-il sur la trame ?

Visualiser la trame à l'aide de l'analyseur logique

Programmer le maître pour qu'il envoie "bonjour" à l'esclave toutes les 100ms

A l'aide du professeur, câblé L'analyseur logique de façon à analyser les signaux qui circulent.