Maîtriser la communication série avec Arduino

Lorsque l’on travaille sur des projets Arduino de grande envergure, il est fréquent de se retrouver à court de broches disponibles pour connecter des composants. Supposons que vous souhaitiez connecter plusieurs capteurs/actionneurs avec le besoin urgent de conserver des broches supplémentaires pour alimenter un module d’affichage gourmand en broches.

À moins de faire de la magie, il est parfois difficile de gérer toutes ces connexions sur une seule carte Arduino – en particulier lorsque vous décidez d’utiliser des cartes plus petites parce que vous manquez de place. C’est alors que la communication série entre en jeu.

Voyons ce qu’est la communication série et comment vous pouvez la mettre en place avec Arduino pour des tâches telles que le traitement distribué et l’intégration générale.

Qu’est-ce que la communication série ?

La communication en série est une méthode d’envoi et de réception de données entre deux ou plusieurs appareils électroniques, un bit à la fois sur une seule ligne de communication. Comme son nom l’indique, les données sont envoyées en « série ».« .

Le simple fait de pouvoir télécharger des esquisses sur votre carte Arduino préférée utilise une communication série via USB.

Protocoles de communication série sur Arduino

Les cartes Arduino sont incroyablement polyvalentes et peuvent communiquer avec un grand nombre de dispositifs. Elles prennent en charge quatre protocoles de communication série : Soft Serial, SPI (Serial Peripheral Interface), UART standard (Universal Asynchronous Receiver-Transmitter) et I2C (Inter-Integrated Circuit). Pour plus de détails, consultez notre guide complet sur le fonctionnement des communications série UART, SPI et I2C.

SPI (Serial Peripheral Interface)

SPI est un protocole de communication série synchrone qui permet une communication à grande vitesse entre les microcontrôleurs et les périphériques. Ce protocole nécessite quatre fils pour la communication : SCK (Horloge série), MOSI (Master Out Slave In), MISO (Master In Slave Out), et SS (Sélection esclave).

Le SPI.h est très pratique pour ce type de communication et doit être incluse au début de votre croquis.

 #include <SPI.h> 

Voici les broches SPI sur la carte Arduino Uno :

Après avoir initialisé la communication série, vous devez configurer les broches de communication.

 void setup() {
  SPI.begin(115200);
  // Set pin modes for SS, MOSI, MISO, and SCK
  pinMode(SS, OUTPUT);
  pinMode(MOSI, OUTPUT);
  pinMode(MISO, INPUT);
  pinMode(SCK, OUTPUT);

  // Set slave select (SS) pin high to disable the slave device
  digitalWrite(SS, HIGH);
} 

Le signal SS est utilisé pour indiquer à l’appareil esclave que des données sont en cours de transfert.

 // Select the slave
digitalWrite(SS, LOW);

// Send data to the slave device
SPI.transfer(data);

// Deselect the slave device
digitalWrite(SS, HIGH); 

Voici comment connecter deux cartes Arduino en utilisant SPI.

Code pour la carte maîtresse :

 #include <SPI.h>
const int slaveSelectPin = 10;
void setup() {
  SPI.begin(115200);
  pinMode(slaveSelectPin, OUTPUT);
}

void loop() {
  digitalWrite(slaveSelectPin, LOW);
  SPI.transfer('H');
  digitalWrite(slaveSelectPin, HIGH);
  delay(1000);
} 

Code de la carte esclave :

 #include <SPI.h>
const int slaveSelectPin = 10;
void setup() {
  SPI.begin(115200);
  pinMode(slaveSelectPin, OUTPUT);
}

void loop() {
  if (digitalRead(slaveSelectPin) == LOW) {
    char receivedData = SPI.transfer('L');
    Serial.println(receivedData);
  }
} 

Assurez-vous que vos appareils partagent une masse commune pour une configuration correcte.

UART (Récepteur-Transmetteur Asynchrone Universel)

UART est un protocole de communication série asynchrone qui permet de communiquer entre des appareils en utilisant seulement deux fils : TX (transmission) et RX (réception). UART est couramment utilisé pour la communication avec des dispositifs tels que les modules GPS, les modules Bluetooth et d’autres microcontrôleurs. Chaque carte Arduino est équipée d’au moins un port UART.

Les broches UART sur les cartes Arduino les plus courantes sont les suivantes :

Vous pouvez obtenir le tableau complet dans la documentation en ligne d’Arduino sur la communication série.

Tout d’abord, connectez vos cartes comme suit :

Utilisez ensuite ce code pour la carte émetteur :

 void setup() {
   Serial.begin(9600);
}

void loop() {
  // Send a message over serial every second
  Serial.println("Hello from the sender board!");
  delay(1000);
} 

Code pour la carte réceptrice :

 void setup() {
    Serial.begin(9600);
}

void loop() {
  // Check if there is any incoming data
  if (Serial.available() > 0) {
    // Read the incoming data and print it to the serial monitor
    String incomingData = Serial.readString();
    Serial.println(incomingData);
  }
} 

L’Arduino Uno fonctionne sur un niveau logique de 5V alors que le port RS232 d’un ordinateur utilise un niveau logique de +/-12V.

I2C (Circuit Inter-Intégré)

I2C est un protocole de communication série synchrone qui permet la communication entre plusieurs appareils en utilisant seulement deux fils : SDA (données série) et SCL (horloge série). Le protocole I2C est couramment utilisé pour la communication avec des capteurs, des EEPROM et d’autres dispositifs qui doivent transférer des données sur de courtes distances.

Les broches I2C sur l’Arduino Uno sont les suivantes SDA (A4) et SCL (A5).

Nous allons créer un programme simple pour établir une connexion entre deux cartes Arduino en utilisant la communication I2C. Mais tout d’abord, connectez vos cartes comme suit :

Code pour la carte maîtresse :

 #include <Wire.h>
void setup() {
  Wire.begin(); // join I2C bus as master
  Serial.begin(9600);
}

void loop() {
  Wire.beginTransmission(9); // transmit to slave device with address 9
  Wire.write('a'); // sends 'a' byte to slave device
  Wire.endTransmission(); // stop transmitting

  delay(500);
} 

Code de la carte esclave :

 #include <Wire.h>
void setup() {
  Wire.begin(9); // join I2C bus as a slave with address 9
  Wire.onReceive(receiveEvent);
  Serial.begin(9600); 
}

void loop() {
  delay(100);
}

void receiveEvent(int bytes) {
  while(Wire.available()) { // loop through all received bytes
    char receivedByte = Wire.read(); // read each byte received
    Serial.println(receivedByte); // print received byte on serial monitor
  }
} 

Qu’est-ce que SoftwareSerial ?

La bibliothèque Arduino SoftwareSerial a été développée pour émuler la communication UART, permettant une communication série à travers deux broches numériques sur les cartes Arduino. Elle est utile lorsque l’UART matériel est déjà utilisé par d’autres périphériques.

Pour configurer SoftwareSerial, il faut d’abord inclure la bibliothèque SoftwareSerial dans le sketch.

 #include <SoftwareSerial.h> 

Créez ensuite une instance de l’objet SoftwareSerial en spécifiant le paramètre RX et TX broches à utiliser pour la communication.

 SoftwareSerial mySerial(2, 3); // RX, TX pins 

Voici un exemple de code pour Arduino qui démontre l’utilisation de SoftwareSerial :

 #include <SoftwareSerial.h>
SoftwareSerial mySerial(2, 3); // RX, TX pins
void setup() {
  Serial.begin(9600); // start hardware serial
  mySerial.begin(9600); // start soft serial
}

void loop() {
  if (mySerial.available()) {
    Serial.write(mySerial.read()); // send received data to hardware serial
  }
  if (Serial.available()) {
    mySerial.write(Serial.read()); // send data from hardware serial to soft serial
  }
} 

La bibliothèque série

La bibliothèque Serial est un outil puissant d’Arduino qui permet la communication entre le microcontrôleur et un ordinateur ou d’autres appareils via une connexion série. Les fonctions les plus courantes sont les suivantes :

Vitesse de transmission et format des données série

Le débit en bauds fait référence à la vitesse à laquelle les données sont transférées sur la connexion série. Il représente le nombre de bits transmis par seconde. La vitesse de transmission doit être la même pour l’émetteur et le récepteur, sinon la communication risque d’être brouillée ou de ne pas fonctionner du tout. Les vitesses de transmission courantes pour Arduino sont 9600, 19200, 38400 et 115200.

Le format des données série fait référence à la structure des données envoyées par la connexion série. Le format de données série comporte trois éléments principaux : les bits de départ, les bits de données et les bits d’arrêt.

• Bits de données: Nombre de bits utilisés pour représenter un seul octet de données.
• Parité: Bit facultatif utilisé pour le contrôle des erreurs. Il peut être réglé sur une parité nulle, paire ou impaire, en fonction des exigences du canal de communication.
• Bits d’arrêt: Nombre de bits utilisés pour signaler la fin d’un octet de données.

Le format de données doit être le même sur l’appareil émetteur et sur l’appareil récepteur pour garantir une communication correcte. Voici un exemple de la manière dont vous pouvez définir des formats de données spécifiques :

 void setup() {
  // Set up serial communication with 9600 baud rate, 8 data bits, no parity, and 1 stop bit
  Serial.begin(9600, SERIAL_8N1); 
} 

Ici, SERIAL_8N1 représente le format de données avec 8 bits de données, pas de parité, et 1 bit d’arrêt. D’autres options telles que SERIAL_7E1, SERIAL_8O2etc., peuvent être utilisés en fonction des exigences spécifiques du projet.

Parler en série

Les cartes Arduino offrent diverses options de communication série qui permettent un échange de données efficace et fiable entre les périphériques. En comprenant comment configurer les protocoles de communication série sur l’IDE Arduino, vous pouvez tirer parti de la puissance du traitement distribué ou réduire considérablement le nombre de fils utilisés dans vos projets.