Communication entre 2 Arduino

Liaison entre deux cartes via des PINs :

Utile pour lire l’état d’un PIN d’une carte par une autre carte.

Sketch de la carte « émettrice » :

const int OutPin = 7;
int val = 0;

void setup() {
pinMode(OutPin, OUTPUT);
}

void loop() {
delay (2000);
digitalWrite(OutPin, HIGH);
delay (2000);
digitalWrite(OutPin, LOW);
}

Sketch de la carte « réceptrice » :

const int ledPin = 13; // the number of the LED pin
const int inPin = 6;
int val = 0;

void setup() {
pinMode(inPin, INPUT);
pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
delay (100);
val = digitalRead(inPin);
digitalWrite(LED_BUILTIN, val);
}

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   
 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 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   
 //-- 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 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 là

Réception de commande « stricte » avec valeur :

Les commandes reçues soit via le port série ou via le moniteur sont entre ‘<‘ ‘>’ Exemple : . Une commande peut être composée de deux parties <cmd=valeur>. Exemple :<led=on>

 const byte numChars = 32;  
 char receivedChars[numChars];  
 boolean newData = false;  
 const int ledPin = 13;  
 void setup() {  
  Serial.begin(9600);  
  Serial.println("Ready, enter <led=on> or <led=off>");  
  pinMode(ledPin, OUTPUT);  
 }  
 void loop() {  
  recvWithStartEndMarkers();  
  showNewData();  
 }  
 void recvWithStartEndMarkers() {  
  static boolean recvInProgress = false;  
  static byte ndx = 0;  
  char startMarker = '<';  
  char endMarker = '>';  
  char rc;  
  while (Serial.available() > 0 && newData == false) {  
   rc = Serial.read();  
   if (recvInProgress == true) {  
    if (rc != endMarker) {  
     receivedChars[ndx] = rc;  
     ndx++;  
     if (ndx >= numChars) {  
      ndx = numChars - 1;  
     }  
    }  
    else {  
     receivedChars[ndx] = '\0'; // terminate the string  
     recvInProgress = false;  
     ndx = 0;  
     newData = true;  
    }  
   }  
   else if (rc == startMarker) {  
    recvInProgress = true;  
   }  
  }  
 }  
 void showNewData() {  
  if (newData == true) {  
   Serial.print("Commande recue : ");  
   String sCmd = String(receivedChars);  
   sCmd.toLowerCase();  
   sCmd.trim();  
   Serial.println(sCmd);  
   int ind1 = sCmd.indexOf('=');  
   String sComd = sCmd.substring(0, ind1);  
   String sVal = sCmd.substring(ind1 + 1);  
   Serial.println("Commande : " + sComd + " ; Valeur : " + sVal);  
   if (sComd.equals("led"))  
   { if (sVal.equals("on"))  
     digitalWrite(ledPin, HIGH);  
    else if (sVal.equals("off"))  
     digitalWrite(ledPin, LOW);  
   }  
   newData = false;  
  }  
 }  

 

Liaison via I2C :

Réception de données 

  #include 
  #include 
 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   
 #include   
 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

http://forum.arduino.cc/index.php?topic=396450.0