ESP32 UART – Communication série, envoi et réception de données (Arduino IDE)

Ceci est un guide simple sur le protocole de communication série UART avec l’ESP32 utilisant l’IDE Arduino. Nous examinerons les bases de l’UART, les broches UART par défaut et personnalisées, les fonctions de base et la communication entre les cartes.

Table des matières:

Tout au long de ce guide, nous aborderons les sujets suivants :

Conditions préalables

Ce tutoriel se concentre sur la programmation de l’ESP32 à l’aide du noyau Arduino. Avant de continuer, vous devez avoir installé le noyau ESP32 Arduino dans votre IDE Arduino. Suivez le didacticiel suivant pour installer l’ESP32 sur l’IDE Arduino, si ce n’est pas déjà fait.

Alternativement, vous pouvez également utiliser VS Code avec l’extension PlatformIO pour programmer vos cartes à l’aide du noyau Arduino :

Présentation du protocole de communication ESP32 UART

UART (Universal Asynchronous Receiver-Transmitter) est un protocole de communication série qui permet à deux appareils de communiquer.

Contrairement à SPI ou I2C, qui sont synchrones, UART est asynchrone, ce qui signifie qu’il n’utilise pas de signal d’horloge pour synchroniser la transmission de données entre appareils. Cependant, les deux appareils doivent s’accorder sur le débit en bauds (vitesse de transmission).

Dans la communication UART, les données sont transférées en série, bit par bit (d’où le terme série), à ​​un débit en bauds prédéfini (bits par seconde). UART utilise une seule ligne de données pour la transmission (TX) et une pour la réception (RX).

Les ports UART nous permettent de communiquer avec d’autres appareils, tels que d’autres cartes microcontrôleurs (un Arduino, un ESP8266, une autre carte ESP32 ou autres), l’ordinateur, des capteurs, des modules GPS ou Bluetooth, certains types d’écrans, et bien plus encore.

Interface UART

Pour la communication UART, vous avez besoin des lignes suivantes :

• TX (Transmission) : envoie des données.
• RX (réception) : reçoit des données.
• GND : terrain d’entente

Périphériques UART ESP32

L’ESP32 prend en charge jusqu’à trois interfaces UART : UART0, UART1 et UART2, selon le modèle de carte ESP32 que vous utilisez.

• UART0 est généralement réservé à la communication avec le moniteur série pendant le téléchargement et le débogage. Cependant, vous pouvez également l’utiliser pour communiquer avec d’autres appareils après avoir téléchargé le code si le moniteur série n’est pas nécessaire.
• UART1 et UART2 : disponibles pour communiquer avec des appareils externes.

Broches UART par défaut ESP32

Comme I2C et SPI, ces broches UART peuvent être mappées sur n’importe quelle broche GPIO de l’ESP32. Cependant, ils ont une affectation de broches par défaut sur la plupart des modèles de cartes.

Pour la plupart des cartes ESP32, l’affectation des broches UART est la suivante :

À propos de UART1 (GPIO 9 et GPIO10) – ces GPIO sont connectés à la mémoire flash ESP32 SPI, vous ne pouvez donc pas les utiliser comme ça. Pour utiliser UART1 pour communiquer avec d’autres appareils, vous devez définir différentes broches à l’aide de la bibliothèque HardwareSerial.

Si vous utilisez un ESP32-S3, l’affectation est complètement différente. Le tableau suivant présente les broches RX et TX UART0, UART1 et UART2 par défaut pour l’ESP32-S3 :

Remarque : selon la carte, les broches UART par défaut peuvent être différentes. Vérifiez toujours le brochage de votre carte spécifique. Vous pouvez également réattribuer les broches UART dans le code si votre carte ne les a pas pré-attribuées.

UART0 et le moniteur série

Dans la plupart des IDE comme l’IDE Arduino ou PlatformIO, le moniteur série interagit avec l’ESP32 via une connexion USB. Ceci est mappé en interne sur UART0 sur l’ESP32, donc lorsque vous ouvrez le moniteur série, vous utilisez la communication UART pour envoyer et recevoir des messages.

Remarque : vous pouvez utiliser UART0 pour communiquer avec d’autres appareils après avoir téléchargé le code sur la carte si vous n’utilisez pas le moniteur série.

Voici un exemple de base qui montre une communication bidirectionnelle entre l’ESP32 et le Serial Monitor (votre ordinateur).

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete instructions at https://Raspberryme.com/esp32-uart-communication-serial-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*********/

String receivedMessage = "";  // Variable to store the complete message

void setup() {
  // Start the Serial Monitor at a baud rate of 115200
  Serial.begin(115200);
  
  // Print an initial message to the Serial Monitor
  Serial.println("ESP32 is ready. Please enter a message:");
}

void loop() {
  // Check if data is available in the Serial buffer
  while (Serial.available()) {
    char incomingChar = Serial.read();  // Read each character from the buffer
    
    if (incomingChar == '\n') {  // Check if the user pressed Enter (new line character)
      // Print the message
      Serial.print("You sent: ");
      Serial.println(receivedMessage);
      
      // Clear the message buffer for the next input
      receivedMessage = "";
    } else {
      // Append the character to the message string
      receivedMessage += incomingChar;
    }
  }
}

Afficher le code brut

Lorsque vous utilisez Serial.begin(115200), vous initialisez une communication série à l’aide de UART0 à un débit en bauds de 115 200.

Serial.begin(115200);

Pour écrire des données sur Serial Monitor, vous utilisez les méthodes print() ou println() sur l’instance Serial.

Serial.println("ESP32 is ready. Please enter a message:");

Vous pouvez également envoyer des données du Serial Monitor à l’ESP32. Pour lire ces données, vous pouvez utiliser la méthode read(). Pour vérifier s’il y a des octets disponibles à lire, vous pouvez utiliser la méthode available().

if (Serial.available()) {
    char incomingData = Serial.read();   // Read the incoming data from Serial Monitor

Tester l’exemple

Téléchargez le code sur votre ESP32. Après le téléchargement, ouvrez le moniteur série à une vitesse de transmission de 115 200 bauds. Ensuite, appuyez sur le bouton ESP32 RST pour lancer l’exécution du programme.

Il devrait imprimer un message « ESP32 est prêt. Veuillez saisir un message.

Il y a un champ sur le moniteur série dans lequel vous pouvez écrire des données à envoyer à l’ESP32 (surligné en jaune). Écrivez quelque chose dans ce champ et appuyez sur Entrée pour l’envoyer à l’ESP32. Il sera réimprimé.

ESP32 Définition de broches UART personnalisées

La définition de broches UART personnalisées est assez simple. Comme nous l’avons vu précédemment, l’ESP32 dispose de trois ports UART que vous pouvez utiliser : UART0, UART 1 et UART 2.

Pour utiliser l’un de ces ports, il vous suffit de créer une instance HardwareSerial sur le port UART souhaité. Par exemple, la ligne suivante crée une instance série appelée mySerial à l’aide d’UART2.

HardwareSerial mySerial(2);

Ensuite, vous pouvez utiliser les épingles de votre choix. Il vous suffit de les transmettre à la méthode start() comme ceci :

mySerial.begin(GPS_BAUD, SERIAL_8N1, RX_GPIO, TX_GPIO);

Dans lequel RX_GPIO et TX_GPIO sont les broches UART de votre choix.

Communication UART avec d’autres appareils

Voyons maintenant comment utiliser UART pour communiquer avec d’autres appareils. Nous verrons un exemple pour communiquer avec un module GPS, et un exemple pour communiquer avec un autre ESP32.

Communication série avec un module GPS

Pour démarrer une communication UART dans votre code ESP32, vous devez spécifier le port UART, la vitesse de transmission et le mappage des broches. Voici un exemple d’initialisation de la communication UART avec un module GPS. Cela peut être appliqué à d’autres modules ou appareils.

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete instructions at https://Raspberryme.com/esp32-neo-6m-gps-module-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*********/

 // Define the RX and TX pins for Serial 2
#define RXD2 16
#define TXD2 17

#define GPS_BAUD 9600

// Create an instance of the HardwareSerial class for Serial 2
HardwareSerial gpsSerial(2);

void setup(){
  // Serial Monitor
  Serial.begin(115200);
  
  // Start Serial 2 with the defined RX and TX pins and a baud rate of 9600
  gpsSerial.begin(GPS_BAUD, SERIAL_8N1, RXD2, TXD2);
  Serial.println("Serial 2 started at 9600 baud rate");
}

void loop(){
  while (gpsSerial.available() > 0){
    // get the byte data from the GPS
    char gpsData = gpsSerial.read();
    Serial.print(gpsData);
  }
  delay(1000);
  Serial.println("-------------------------------");
}

Afficher le code brut

Ce croquis suppose que vous utilisez GPIO 16 et GPIO 17 comme broches série RX et TX pour établir une communication série avec le module GPS. Si vous utilisez d’autres épingles, vous devez les modifier sur les lignes suivantes :

// Define the RX and TX pins for Serial 2
#define RXD2 16
#define TXD2 17

Ensuite, nous définissons le débit en bauds du module sur la ligne suivante.

#define GPS_BAUD 9600

Nous créons une instance de HardwareSerial pour utiliser UART 2 appelée gpsSerial.

// Create an instance of the HardwareSerial class for Serial 2
HardwareSerial gpsSerial(2);

Dans le setup(), nous lançons le Serial Monitor.

// Serial Monitor
Serial.begin(115200);

Ensuite, nous initialisons une communication série avec le module GPS en utilisant la méthode start() sur l’instance gpsSerial().

// Start Serial 2 with the defined RX and TX pins and a baud rate of 9600
gpsSerial.begin(GPS_BAUD, SERIAL_8N1, RXD2, TXD2);
Serial.println("Serial 2 started at 9600 baud rate");

La méthode start() accepte comme arguments le débit en bauds, le format de la trame de communication (données, parité et bits d’arrêt, SERIAL_8N1 est la valeur par défaut) et les broches RX et TX.

SERIAL_8N1 signifie 8 bits de données, pas de parité, 1 bit d’arrêt, ce qui est le plus couramment utilisé. Vous pouvez vérifier toutes les options ici.

Dans la boucle(), le code vérifie s’il y a des données GPS sur le port série avec la méthode available().

void loop(){
  while (gpsSerial.available() > 0){

Lorsque les données sont disponibles, nous les lisons à l’aide de la méthode read(), puis les imprimons dans Serial Monitor.

void loop(){
while (gpsSerial.available() > 0){
// get the byte data from the GPS
char gpsData = gpsSerial.read();
Serial.print(gpsData);
}
delay(1000);
Serial.println("-------------------------------");
}

Pour les instructions complètes pour tester ce code, assurez-vous de jeter un œil à notre didacticiel sur le module GPS : ESP32 avec module GPS NEO-6M (Arduino IDE).

Communication série ESP32 entre les cartes (émetteur et récepteur)

Si vous souhaitez communiquer avec un autre ESP32, ce n’est pas très différent. En gros, vous initialisez une communication série sur les GPIO souhaités, puis utilisez les fonctions pour lire et envoyer des données via série.

Pour vous montrer comment cela fonctionne, nous enverrons des données via série d’une carte ESP32 à l’autre. L’expéditeur ESP32 enverra en permanence un message avec un compteur via UART. Le récepteur de la carte récepteur ESP32 recevra le numéro de l’autre carte.

Pour tester l’exemple :

• vous avez besoin de deux cartes ESP32 ;
• une carte sera l’expéditeur et l’autre sera le destinataire
• nous utiliserons UART1 et attribuerons TX au GPIO 19 et RX au GPIO 21 (vous pouvez utiliser n’importe quelle autre broche) – nous n’utilisons pas les broches par défaut pour vous montrer comment procéder ;
• vous devez connecter le RX d’une carte au TX de l’autre et connecter les GND ensemble

Code de l’expéditeur ESP32

Voici le code de l’expéditeur ESP32. Téléchargez-le sur votre tableau.

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete instructions at https://Raspberryme.com/esp32-uart-communication-serial-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*********/

// Define TX and RX pins for UART (change if needed)
#define TXD1 19
#define RXD1 21

// Use Serial1 for UART communication
HardwareSerial mySerial(1);

int counter = 0;

void setup() {
  Serial.begin(115200);
  mySerial.begin(9600, SERIAL_8N1, RXD1, TXD1);  // UART setup
  
  Serial.println("ESP32 UART Transmitter");
}

void loop() {
  
  // Send message over UART
  mySerial.println(String(counter));
  
  Serial.println("Sent: " + String(counter));
  
  // increment the counter
  counter++;
  
  delay(1000); 
}

Afficher le code brut

Comment fonctionne le code ?

Jetons un coup d’œil au fonctionnement du code.

Commencez par définir les broches TX et RX que vous souhaitez utiliser. Nous utilisons GPIO19 et GPIO21, mais vous pouvez utiliser n’importe quelle autre broche.

#define TXD1 19
#define RXD1 21

Nous utilisons UART1, mais pour cet exemple nous aurions également pu choisir UART2. Pour utiliser UART1, nous commençons par créer une instance HardwareSerial appelée mySerial.

// UART1
HardwareSerial mySerial(1);

Ensuite, nous créons une variable pour contenir le nombre que nous voulons envoyer à l’autre tableau appelé compteur.

int counter = 0;

Dans setup(), nous initialisons la communication série sur UART1 en appelant la méthode start() sur l’objet mySerial.

mySerial.begin(9600, SERIAL_8N1, RXD1, TXD1);  // UART setup

Dans la boucle(), nous envoyons le compteur via série en utilisant la méthode println() sur notre objet mySerial. C’est ce qui enverra le numéro à l’autre tableau.

mySerial.println(String(counter));

Ensuite, on incrémente le compteur à chaque boucle.

// increment the counter
counter++;

Un nouveau message est envoyé toutes les secondes, mais vous pouvez modifier le délai si nécessaire.

delay(1000); 

Téléchargement du code

Téléchargez le code sur le tableau de l’expéditeur. Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 115 200. Vous verrez qu’il commencera à envoyer des données via UART.

Maintenant, préparons le récepteur à recevoir les données.

Code du récepteur ESP32

Voici le code du récepteur ESP32. Téléchargez-le sur votre tableau.

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete instructions at https://Raspberryme.com/esp32-uart-communication-serial-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*********/

// Define TX and RX pins for UART (change if needed)
#define TXD1 19
#define RXD1 21

// Use Serial1 for UART communication
HardwareSerial mySerial(2);

void setup() {
  Serial.begin(115200);
  mySerial.begin(9600, SERIAL_8N1, RXD1, TXD1);  // UART setup
  
  Serial.println("ESP32 UART Receiver");
}

void loop() {
  // Check if data is available to read
  if (mySerial.available()) {
    // Read data and display it
    String message = mySerial.readStringUntil('\n');
    Serial.println("Received: " + message);
  }
}

Afficher le code brut

Comment fonctionne le code ?

La configuration de la connexion série est la même que celle que nous avons vue dans l’exemple précédent. La boucle() est différente. Dans ce cas, nous écouterons les données entrantes.

Ensuite, pour recevoir les données de l’autre carte, nous commençons par vérifier s’il y a des octets disponibles à lire.

// Check if data is available to read
if (mySerial.available()) {

Ensuite, nous lisons les données entrantes et les enregistrons dans la variable de message à l’aide de la méthode readStringUntil().

String message = mySerial.readStringUntil('\n');

Cette méthode lit les données du tampon série UART sous forme de chaîne, en continuant à lire les caractères jusqu’à ce qu’elle rencontre le caractère de nouvelle ligne ‘\n’ .

Le ‘\n’ est généralement utilisé pour marquer la fin d’un message ou d’une ligne. Lorsqu’il rencontre ce caractère dans le flux de données entrant, il arrête la lecture et renvoie la chaîne jusqu’à ce point.

Téléchargez le code

Téléchargez le code précédent sur la carte réceptrice. Ouvrez une connexion Serial Monitor avec cette nouvelle carte.

L’expéditeur ESP32 enverra en continu un message avec un compteur via UART. Le récepteur de la carte ESP32 recevra le numéro de l’autre carte.

Vous avez maintenant une carte ESP32 qui envoie des données à l’autre.

Conclusion

Ce didacticiel était un guide de démarrage pour la communication UART avec l’ESP32. Nous avons vu comment fonctionne l’UART, comment utiliser les ports UART ESP32 sur les broches souhaitées et comment envoyer des données d’un ESP32 à l’autre.

Nous espérons que vous avez trouvé ce guide utile.

Nous avons des guides pour d’autres protocoles de communication avec l’ESP32 qui pourraient vous être utiles.

Apprenez-en plus sur l’ESP32 avec nos ressources :

Merci d’avoir lu.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :