Communication entre 2 Arduino

Liaison Série :

Le but est de transférer  des informations entre deux cartes arduino. Nous avons réalisé le test entre une carte Leonardo (émission) et une carte Nano (réception). Bien entendu la communication peut être bi-directionnelle. Il n’y a que 3 fils à connecter : RX / TX et ne pas oublier la masse ! Les deux sketchs sont ici.

Envoi de données

 /**********************************************  
 // Transfert de données d'une carte arduino à une autre  
 // Ce sketch envoie le message Hello à une carte connectée  
 // via le port série logiciel  
 // Branchements :  
 // * RX connecté sur pin 10 (connecté à TX sur l'autre carte)  
 // * TX connecté sur pin 11 (connect à RX sur l'autre carte)  
 // * Et ne pas oublier de relier les masses des 2 cartes (GND)  
 // Remarque :  
 // Sur la MEGA utilisez uniquement pour RX:   
 // 10, 11, 12, 13, 50, 51, 52, 53, 62, 63, 64, 65, 66, 67, 68, 69  
 // Sur la Leonardo utilisez uniquement pour RX:  
 // 8, 9, 10, 11, 14 (MISO), 15 (SCK), 16 (MOSI).  
 ****************************************/  
 #include <SoftwareSerial.h>  
 int led = 13;  
 SoftwareSerial mySerial(10, 11); // RX, TX  
 void setup()   
 { //-- définition du port Série Logiciel  
  mySerial.begin(57600);   
  pinMode(led, OUTPUT);  
 }  
 void loop() //-- Toutes les 2 secondes envoi d'un message  
 {if (mySerial.available())  
  {digitalWrite(led, HIGH); //-- Pendant l'envoi allume la LED  
  mySerial.write("Hello");  
  }  
  digitalWrite(led, LOW);  
  delay(2000); //-- Attente de 2 secondes avant de recommencer  
 }  

Réception

 /**************  
 // Réception de données via le port Série Logiciel :  
 // Testé avec une NANO 328   
 // Attention les câbles RX et TX doivent être croisés   
 // Ne pas oublier de relier les masses des 2 cartes (GND)  
 // entre la carte émitrice et la carte réceptrice !  
 ***************/  
 //-- Déclaration du port Série Logiciel  
 #include <SoftwareSerial.h>  
 SoftwareSerial mySerial(10, 11); // RX, TX  
 //-- Mise en fonction de la LED lorsqu'un message est reçu  
 int led = 13;  
 //-- Setup  
 void setup() {          
  //-- Initialisation de la LED  
  pinMode(led, OUTPUT);  
  //-- Ouverture du port Série de la carte pour le moniteur  
  Serial.begin(9600);  
  while (!Serial) {;} //-- Pour Leonaro nécessaire  
  Serial.println("Attente réception !");  
  //-- Définition et ouverture du port logiciel  
  mySerial.begin(57600);   
 }  
 //-- Affichage de la communication  
 void loop() {  
  //-- Si des données sont présentes  
  if (mySerial.available())  
   {//-- Affichage sur la console des données  
    Serial.write(mySerial.read());}  
 }  

Remarque : Avant 1.0.x Serial.flush() vidait le buffer entrant, depuis 1.0.x Serial.flush() vide le buffer sortant. Application : pour envoyer via le port Série des données et écouter en même temps si il y a des données en réception :

Serial3.print(« enon »);
//– On purge le buffer
while (Serial3.available () > 0) {
char inChar = (char)Serial3.read();
Serial.println(« -> » + inChar);
}
//– Ou
//Serial3.flush(); //– On vide le buffer sortant

 

Envoi de commandes avec accusé de réception :

Ici une carte Arduino MEGA envoie à une carte UNO, suite à l’appui sur un bouton soit une commande ON ou une commande OFF, cette commande déclenche sur l’UNO l’allumage ou l’extinction de la LED et l’envoi d’une commande ON ou OFF à la carte MEGA qui allume ou éteins sa LED en fonction de la commande reçue. Deux port série sont utilisés.

MEGA :

 //-- Déclaration du port Série Logiciel  
 #include <SoftwareSerial.h>  
 //-- Inversez les ports sur la 2ième carte !  
 SoftwareSerial mySerial1(10, 11); // RX, TX : Envoi commandes  
 SoftwareSerial mySerial2(12, 13); // RX, TX : Lecture commandes  
 #define led 13 //-- Témoin LED   
 #define inPin1 22  
 int val;  
 int i;  
 boolean dpAlarme = false;  
 /////////////  
 void setup() {  
  Serial.begin(9600);  
  //-- Définition et ouverture du port logiciel  
  mySerial1.begin(9600);  
  mySerial2.begin(9600);  
  pinMode(led, OUTPUT);  
  pinMode(inPin1, INPUT); //-- Pour le bouton  
  digitalWrite(led, LOW); //-- LED OFF  
  Serial.println("Appuyez sur le bouton !");  
 }  
 /////////////////  
 void loop() {  
  //-- Lecture statut bouton  
  val = digitalRead(inPin1);  
  //-- Action en fonction de l'état  
  if (val == HIGH)  
  { mySerial1.listen(); //-- Activation du port 1  
   //-- Si Bouton 1 appuyé  
   if (!dpAlarme)  
   {  
    Serial.println("Bouton ON");  
    mySerial1.write("AON]"); //-- Envoi de la commande  
    dpAlarme = true;  
    //-- Ecoute de l'accusé de la réception  
    i = 0;  
    while (!TestRecep() && i < 1000)  
    { //Serial.print(i);  
     delay(10);  
     i++;  
    }  
   }  
   else  
   {  
    Serial.println("Bouton OFF");  
    mySerial1.write("AOFF]"); //-- Envoi de la commande  
    dpAlarme = false;  
    //-- Ecoute de l'accusé de la réception  
    i = 0;  
    while (!TestRecep() && i < 1000)  
    { delay(10);  
     i++;  
    }  
   }  
  }  
  //-- Ecoute si on recoit une commande  
  TestRecep();  
 }  
 ///////////////////////////  
 boolean TestRecep() {  
  String sRecu = "";  
  mySerial2.listen(); //-- Ecoute du port2  
  if (mySerial2.available())  
  {  
   sRecu = mySerial2.readStringUntil(']');  
   if (sRecu == "AON") {  
    Serial.println("Alarme -> On");  
    digitalWrite(led, HIGH);  
    delay(100);  
    return (true);  
   }  
   else if (sRecu == "AOFF")  
   {  
    Serial.println("Alarme -> Off");  
    digitalWrite(led, LOW);  
    delay(100);  
    return (true);  
   }  
  }  
  return (false);  
 }  

UNO :

 /*  
 Attente du message en provenance d'une carte  
 Si Alarme ON alors envoi à la carte émitrice l'ordre d'allumer la LED  
 Si Alarme OFF alors envoi l'ordre d'éteindre la LED  
 */  
 #define led 13 //-- Témoin LED   
 //-- Déclaration du port Série Logiciel  
 #include <SoftwareSerial.h>  
 SoftwareSerial mySerial(10, 11); // RX, TX  
 SoftwareSerial mySerial2(8, 9); // RX, TX  
 //////////////  
 void setup() {  
  Serial.begin(9600);  
  //-- Initialisation de la LED  
  pinMode(led, OUTPUT);  
  digitalWrite(led, LOW);  
  Serial.println("Attente réception !");  
  //-- Définition et ouverture du port logiciel  
  mySerial.begin(9600);  
  mySerial2.begin(9600);  
 }  
 //////////////  
 void loop()  
 {  
  TestRecep();  
 }  
 ///////////////////////////  
 boolean TestRecep() {  
  String sRecu = "";  
  mySerial.listen();  
  if (mySerial.available())  
  { delay(100); //-- Recup tous car  
   sRecu = mySerial.readStringUntil(']');  
   //Serial.println("=" + sRecu + "=");  
   if (sRecu == "AON") {  
    mySerial2.listen();  
    Serial.println("Alarme -> On");  
    mySerial2.print("AON]");  
    digitalWrite(led, HIGH);  
    delay(100);  
    return (true);  
   }  
   else if (sRecu == "AOFF")  
   {  
    mySerial2.listen();  
    Serial.println("Alarme -> Off");  
    mySerial2.print("AOFF]");  
    digitalWrite(led, LOW);  
    delay(100);  
    return (true);  
   }  
  }  
  return (false);  
 }  

Le sketch pour la carte MEGA est ici, celui pour la carte UNO

Liaison via I2C :

Réception de données 

  #include <SPI.h>
  #include <Wire.h>
 void setup()  
 {  
  Wire.begin(4);                // join i2c bus with address #4  
  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  
 }  

Envoi de données 

 #include <SPI.h>  
 #include <Wire.h>  
 void setup() {  
  Wire.begin();  
  Wire.beginTransmission(4); // transmit to device #4  
  Wire.write("Hour is");    // sends five bytes  
  Wire.write("10:12:00");       // sends one byte  
  Wire.endTransmission();  // stop transmitting  
 }  
 void loop() {  
  // put your main code here, to run repeatedly:  
 }  

Références

http://www.arduino.cc/en/Tutorial/MasterWriter

http://robotic-controls.com/learn/arduino/arduino-arduino-serial-communication

6 comments on “Communication entre 2 Arduino
  1. simon dit :

    bonjours j’aime beaucoups votre tuto , j’ai une question entre mes 2 carte mes fils de communication j’aimerais avoir une longeur de , 100pied , sais tu posible ou ? Merci

  2. imuley Fiston dit :

    Bonjour, c’est super votre tuto il m’a inspiré alors comment faire avec une communication sans fils exemple bluetooth normal (et bluetooth Low energy de Adafruit.com), wifi,.. je travaille sur un robot humanoïde que je dois programmer les foction comme marché, prendre de chose avec les main, .. Enrichissez moi le max que vous pouvez merci

  3. fonteneau dit :

    Bonjour et merci pour votre tuto

    J’aurais une question , dans votre programme vous envoyé une chaine de caractère , mais si je souhaite envoyer des valeurs c’est la même chose ? j’ai juste a ne pas mettre les guillemet ? exemple Serial.println(1) ; pour l’envoie de la valeur 1

    merci

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s

Articles récents
Commentaires récents
fatima sur Bienvenue !
AdminDroid sur Bienvenue !
fatima sur Bienvenue !
Archives
Catégories
%d blogueurs aiment cette page :