Communication série
Programmation - 3ème
Communication série
Objectifs
- Comprendre le principe de la transmission de données bit par bit
- Savoir utiliser le moniteur série de l'IDE Arduino pour envoyer et recevoir des données
- Programmer une communication bidirectionnelle simple entre l'Arduino et l'ordinateur
Introduction
Imaginez que votre Arduino puisse parler avec votre ordinateur, avec un capteur de température ou même avec un autre Arduino. C'est exactement ce que permet la communication série ! C'est comme si votre carte électronique avait une bouche et des oreilles pour échanger des informations avec le monde extérieur.
Comment un microcontrôleur comme l'Arduino peut-il échanger des données de manière fiable avec d'autres appareils numériques ?
Le principe de la communication série
La communication série est un mode de transmission où les bits d'information (les 0 et les 1) voyagent les uns à la suite des autres sur un seul fil de données. C'est l'opposé de la communication parallèle où plusieurs bits voyagent en même temps sur plusieurs fils. Sur Arduino, nous utilisons principalement la communication série asynchrone. Cela signifie qu'il n'y a pas de signal d'horloge partagé pour synchroniser l'émetteur et le récepteur. À la place, les deux appareils doivent être préalablement réglés sur la même vitesse de communication, appelée le débit en bauds (baud rate), par exemple 9600 bauds. Cela correspond au nombre de symboles (ici, des bits) transmis par seconde. Pour qu'un récepteur sache où commence et où finit un octet (un groupe de 8 bits), chaque transmission est encadrée par un bit de START (toujours à 0) et un ou deux bits de STOP (toujours à 1). C'est comme si on envoyait une lettre dans une enveloppe : le bit START est le début de l'enveloppe, les 8 bits sont la lettre, et le bit STOP est la fermeture de l'enveloppe. Sur une carte Arduino Uno, les broches dédiées à cette communication sont la broche 0 (RX, pour Recevoir) et la broche 1 (TX, pour Transmettre).
Points clés
- Transmission bit par bit sur un seul fil
- Communication asynchrone : pas d'horloge commune, mais un débit (baud rate) commun
- Format d'un message : bit START + 8 bits de données + bit(s) STOP
- Broches RX (0) et TX (1) sur Arduino pour la communication série matérielle
Programmer la communication avec l'IDE Arduino
L'IDE Arduino simplifie énormément l'utilisation de la communication série grâce à sa bibliothèque 'Serial'. Pour initialiser la communication, on utilise la commande `Serial.begin(9600);` dans la fonction `setup()`. Le nombre 9600 est le débit en bauds ; il doit être identique dans le code et dans le moniteur série de l'IDE. Pour envoyer des données de l'Arduino vers l'ordinateur, on utilise principalement `Serial.print("texte");` pour envoyer du texte ou `Serial.println(variable);` pour envoyer la valeur d'une variable et passer à la ligne suivante. Pour recevoir des données depuis l'ordinateur (quand vous tapez dans le moniteur), on utilise `Serial.available()` qui renvoie le nombre de caractères reçus et en attente de lecture. On peut ensuite lire ces caractères un par un avec `Serial.read()`. Par exemple, pour allumer une LED quand on appuie sur 'A' dans le moniteur, on vérifie d'abord si un caractère est disponible (`if(Serial.available() > 0)`), on le lit (`char recu = Serial.read();`), et on compare (`if(recu == 'A') { digitalWrite(LED, HIGH); }`). Le moniteur série de l'IDE est l'outil indispensable pour cette communication : c'est une fenêtre qui affiche ce qu'envoie l'Arduino et qui permet d'envoyer des commandes ou des valeurs vers lui.
Points clés
- Initialisation avec `Serial.begin(vitesse)` dans le `setup()`
- Envoyer des données avec `Serial.print()` et `Serial.println()`
- Recevoir des données avec `Serial.available()` et `Serial.read()`
- Le Moniteur Série est l'interface de dialogue entre l'ordinateur et la carte
Applications pratiques et protocoles simples
La communication série ouvre la porte à de nombreux projets. Un exemple classique est la supervision : on peut connecter un capteur (de température DHT11, une photorésistance) à l'Arduino et envoyer ses mesures en temps réel vers l'ordinateur pour les afficher dans le moniteur série, créant ainsi un petit système d'acquisition de données. Inversement, on peut piloter des actionneurs depuis le clavier : allumer/éteindre une LED, contrôler la vitesse d'un moteur avec une valeur numérique, ou déplacer un servomoteur. Pour des échanges plus complexes que de simples caractères, on définit un mini-protocole. Par exemple, on peut convenir qu'envoyer 'L,1' signifie 'allumer la LED' et 'L,0' l'éteindre. Le code Arduino devra alors analyser la chaîne de caractères reçue. Une autre application avancée est la communication entre deux Arduino. Il suffit de connecter le TX de l'un au RX de l'autre (et vice-versa) et de partager la masse (GND). Chaque carte utilise son `Serial` pour parler à l'autre, permettant de créer des réseaux simples, comme une télécommande pour un robot.
Points clés
- Supervision : envoyer des valeurs de capteurs vers l'ordinateur
- Pilotage : contrôler des actionneurs depuis le moniteur série
- Création de protocoles simples pour structurer les échanges (ex: 'L,1')
- Communication entre deux cartes Arduino en reliant RX/TX
À retenir
La communication série asynchrone permet à l'Arduino d'échanger des données bit par bit avec un ordinateur ou un autre périphérique. Elle est rendue simple par la bibliothèque Serial et le moniteur série de l'IDE. En maîtrisant l'envoi (`Serial.print`) et la réception (`Serial.read`), on peut créer des systèmes interactifs de supervision et de pilotage.
- La communication série est asynchrone et nécessite un débit commun (ex: 9600 bauds).
- On initialise avec `Serial.begin()`, on envoie avec `Serial.print()`, et on lit avec `Serial.read()` si `Serial.available()` est supérieur à 0.
- Les broches RX (0) et TX (1) sont utilisées pour la communication série matérielle sur Arduino Uno.
