Communication série

UART : le protocole de communication asynchrone

L'UART (Universal Asynchronous Receiver-Transmitter) est le protocole utilisé par l'Arduino pour communiquer avec ton ordinateur via le câble USB. Contrairement aux protocoles synchrones (I2C, SPI), l'UART n'a pas de signal d'horloge partagé : les deux parties se mettent d'accord à l'avance sur la vitesse de transmission, appelée baud rate (bauds par seconde).

Sur l'Arduino Uno, les pins dédiées à la communication série matérielle sont :

• Pin 0 (RX) — Receive : reçoit les données
• Pin 1 (TX) — Transmit : envoie les données

Ces deux pins sont connectées en interne au chip USB-série de la carte, ce qui permet la communication via le câble USB branché à ton ordinateur. Attention : évite d'utiliser les pins 0 et 1 pour autre chose quand la communication série est active.

Serial.begin() — initialiser le port série

Avant d'envoyer ou de recevoir des données, tu dois initialiser la communication série dans setup() avec Serial.begin() en précisant le baud rate.

void setup() {
  // Initialiser la communication série à 9600 bauds
  Serial.begin(9600);

  // Attendre que le port série soit prêt (utile sur Arduino Leonardo/Due)
  while (!Serial) {
    ; // attendre
  }

  Serial.println("Arduino prêt !");
}

void loop() {
  // rien pour l'instant
}

Envoyer des données — print, println, write

L'objet Serial propose plusieurs méthodes pour envoyer des données vers l'ordinateur :

• Serial.print(val) — envoie val sans saut de ligne
• Serial.println(val) — envoie val suivi de \r\n (saut de ligne)
• Serial.write(val) — envoie un octet brut (valeur 0–255), pas une chaîne lisible

int temperature = 24;
float tension = 3.14;

// Envoie "Temperature : 24 °C" + saut de ligne
Serial.print("Temperature : ");
Serial.print(temperature);
Serial.println(" degC");

// Envoie un float avec 2 décimales : "3.14"
Serial.println(tension, 2);

// Envoie l'octet brut 65 (caractère ASCII 'A')
Serial.write(65);

// Envoie le temps écoulé depuis le démarrage (ms)
Serial.print("Uptime : ");
Serial.print(millis());
Serial.println(" ms");

Recevoir des données — available, read, readString

L'Arduino peut aussi recevoir des données depuis l'ordinateur. Les méthodes clés :

• Serial.available() — retourne le nombre d'octets en attente dans le buffer de réception (0 si rien)
• Serial.read() — lit et retourne le prochain octet du buffer (-1 si vide)
• Serial.readString() — lit tous les octets disponibles et les retourne sous forme de String

void setup() {
  Serial.begin(9600);
  Serial.println("Envoie une commande : ON ou OFF");
}

void loop() {
  // Si des données sont disponibles dans le buffer
  if (Serial.available() > 0) {
    String commande = Serial.readString();
    commande.trim(); // supprimer les espaces et \n

    if (commande == "ON") {
      digitalWrite(13, HIGH);
      Serial.println("LED allumee");
    } else if (commande == "OFF") {
      digitalWrite(13, LOW);
      Serial.println("LED eteinte");
    } else {
      Serial.print("Commande inconnue : ");
      Serial.println(commande);
    }
  }
}

Le moniteur série et le traceur série

L'Arduino IDE inclut deux outils intégrés pour interagir avec le port série :

• Moniteur série (Ctrl+Maj+M) — terminal texte bidirectionnel. Tu vois ce que l'Arduino envoie, et tu peux lui taper des commandes. Assure-toi que le baud rate en bas du moniteur correspond à celui déclaré dans Serial.begin().
• Traceur série (Ctrl+Maj+L) — affiche les valeurs numériques sous forme de graphique en temps réel. Très pratique pour visualiser un signal de capteur ou une courbe de température. Envoie juste des nombres avec Serial.println(valeur).

SoftwareSerial — port série logiciel sur d'autres pins

L'Arduino Uno ne dispose que d'un seul port série matériel (pins 0/1). Si tu as besoin de communiquer avec plusieurs périphériques série en même temps (module GPS, module Bluetooth HC-05…), tu peux créer un port série logiciel sur n'importe quelles autres pins numériques grâce à la bibliothèque SoftwareSerial.

// Inclure la bibliothèque (incluse avec l'IDE Arduino)
#include <SoftwareSerial.h>

// SoftwareSerial(RX, TX) — pins à utiliser
SoftwareSerial mySerial(10, 11);

void setup() {
  Serial.begin(9600);       // port série matériel (USB)
  mySerial.begin(9600);    // port série logiciel (module BT)
  Serial.println("SoftwareSerial prêt");
}

void loop() {
  // Relayer ce qui arrive du module BT vers le moniteur série
  if (mySerial.available()) {
    Serial.write(mySerial.read());
  }
  // Relayer ce qui est tapé dans le moniteur vers le module BT
  if (Serial.available()) {
    mySerial.write(Serial.read());
  }
}

Communiquer avec Python via pyserial

L'une des applications les plus puissantes de la communication série est de piloter l'Arduino depuis un script Python sur l'ordinateur. La bibliothèque pyserial permet d'ouvrir le port COM/tty de l'Arduino, d'envoyer des commandes et de lire les réponses.

Installation de pyserial :

pip install pyserial

Exemple complet : le script Python envoie "ON" ou "OFF" à l'Arduino toutes les 2 secondes, et affiche la réponse reçue.

import serial
import time

# Adapter le port selon ton système
# Windows : "COM3", "COM4"…
# Linux/macOS : "/dev/ttyUSB0", "/dev/ttyACM0"
PORT = "COM3"
BAUD = 9600

# Ouvrir le port série (timeout = 2s pour la lecture)
arduino = serial.Serial(PORT, BAUD, timeout=2)

# Attendre que l'Arduino démarre (il se réinitialise à la connexion)
time.sleep(2)

# Lire le message de démarrage de l'Arduino
demarrage = arduino.readline().decode("utf-8").strip()
print(f"Arduino dit : {demarrage}")

commandes = ["ON", "OFF", "ON", "OFF"]

for cmd in commandes:
    print(f"Envoi : {cmd}")
    arduino.write((cmd + "\n").encode("utf-8"))
    time.sleep(0.1)  # laisser le temps à l'Arduino de répondre
    reponse = arduino.readline().decode("utf-8").strip()
    print(f"Arduino répond : {reponse}")
    time.sleep(2)

arduino.close()
print("Port série fermé.")