site;
http://wiki.t-o-f.info/index.php?n=Arduino.I2C
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1235582397
http://arduino.cc/en/Tutorial/MasterWriter
http://www.gammon.com.au/forum/?id=10896
Les questions:
1-/Comment brancher les 2 aduinos en i2c?
2-/Comment transformer un des arduinos en maitre et esclave?
Comment lire les données sur l'un des arduino et vérifier qu'il récupère bien les bonnes données?
Réponses:
1-/Sur la plupart des cartes Arduino:
SDA : broche analogique 4
SCL : broche analogique 5
Un bus I2C (pour Inter Integrated Circuit) est un bus série et synchrone composé de trois fils :
un signal de donnée (SDA) ;
un signal d'horloge (SCL) ;
un signal de référence (masse).
Le périphérique qui gère la communication est le maître, c'est lui qui génère l'horloge (SCL) et qui envoie les données (SDA) mis à part l'acknowledge (acquittement en français).
source : http://fr.wikipedia.org/wiki/I2C
2-/Le brochage est toujours le même pour l'esclave et le maitre. Pas encore bien compris pourquoi.
Exemple maitre/esclave
Code:
#include
void setup()
{
// initialise la liaison I2C en tant que maitre (pas de paramètre à begin)
Wire.begin();
}
void loop()
{
// commence à parler à la carte slave qui a déclaré l'adresse 0x01
Wire.beginTransmission(0x01);
Wire.send("Salut"); // envoie une chaine de caractères (pourrait être un tableau de byte ou...)
Wire.endTransmission(); // arrête
delay(500);
}
Sur l'esclave :
Code:
#include
void setup()
{
// initialise l'I2C en tant que slave (puisque il précise l'adresse 0x01
Wire.begin(0x01);
// déclare une fonction (ci-dessous) pour recevoir ce que le maitre envoit
Wire.onReceive(recevoir);
// pour pouvoir dire ce qui se passe
Serial.begin(9600);
}
void loop()
{
// rien de particulier, le code normal de la carte
delay(100);
}
// déclenché par un envoi du maitre
void recevoir(int qty)
{
Serial.print("> J'ai reçu ");
Serial.print(qty);
Serial.println(" octets.");
// on lit octet par octet
Serial.print("Le maitre dit : ");
while(Wire.available() > 0)
{
char c = Wire.receive();
Serial.print(c);
}
// dernier retour à la ligne
Serial.println();
}
Exemple de transmssion pour un capteur an i2C. Ca peut toujours servir
/*
SRF02 sensor reader
language: Wiring/Arduino Reads data from a Devantech SRF02 ultrasonic sensor.
Should also work for the SRF08 and SRF10 sensors as well.
Sensor connections:
SDA - Analog pin 4
SCL - Analog pin 5
created 5 Mar. 2007
by Tom Igoe
*/
// include Wire library to read and write I2C commands:
#include
// the commands needed for the SRF sensors:
#define sensorAddress 0x70
#define readInches 0x50
// use these as alternatives if you want centimeters or microseconds:
#define readCentimeters 0x51
#define readMicroseconds 0x52
// this is the memory register in the sensor that contains the result:
#define resultRegister 0x02
void setup()
{
// start the I2C bus
Wire.begin();
// open the serial port:
Serial.begin(9600);
}
void loop()
{
// send the command to read the result in inches:
sendCommand(sensorAddress, readInches);
// wait at least 70 milliseconds for a result:
delay(70);
// set the register that you want to reas the result from:
setRegister(sensorAddress, resultRegister);
// read the result:
int sensorReading = readData(sensorAddress, 2);
// print it:
Serial.print("distance: ");
Serial.print(sensorReading);
Serial.println(" inches");
// wait before next reading:
delay(70);
}
/*
SendCommand() sends commands in the format that the SRF sensors expect
*/
void sendCommand (int address, int command) {
// start I2C transmission:
Wire.beginTransmission(address);
// send command:
Wire.send(0x00);
Wire.send(command);
// end I2C transmission:
Wire.endTransmission();
}
/*
setRegister() tells the SRF sensor to change the address pointer position
*/
void setRegister(int address, int thisRegister) {
// start I2C transmission:
Wire.beginTransmission(address);
// send address to read from:
Wire.send(thisRegister);
// end I2C transmission:
Wire.endTransmission();
}
/*
readData() returns a result from the SRF sensor
*/
int readData(int address, int numBytes) {
int result = 0; // the result is two bytes long
// send I2C request for data:
Wire.requestFrom(address, numBytes);
// wait for two bytes to return:
while (Wire.available() < 2 ) {
// wait for result
}
// read the two bytes, and combine them into one int:
result = Wire.receive() * 256;
result = result + Wire.receive();
// return the result:
return result;
}
resultat
