Écho série avec Arduino : Apprenez la communication USART

Introduction

La communication série est l’une des compétences les plus fondamentales en électronique embarquée. Que vous déboguiez un capteur, dialoguiez avec un module GPS ou envoyiez des données à un PC, l’humble USART (Universal Synchronous/Asynchronous Receiver/Transmitter) est votre outil de prédilection. Dans ce tutoriel, nous allons construire un simple projet d’Écho série en utilisant un Arduino Uno dans le simulateur Velxio. Chaque caractère que vous tapez dans le Moniteur série est renvoyé avec sa valeur ASCII et un compteur. C’est le “Hello, World!” de la communication série.

Présentation du circuit

Ce projet est remarquablement simple — il utilise uniquement la carte Arduino Uno elle-même. Aucun composant externe n’est nécessaire car la communication série se fait via le convertisseur USB-série intégré à l’Uno. Dans Velxio, le Moniteur série est intégré à la barre d’outils de l’éditeur, vous pouvez donc interagir immédiatement avec votre code.

Composants

C’est tout ! Les broches TX (broche 1) et RX (broche 0) de l’Arduino Uno sont connectées en interne à l’interface USB, que Velxio émule parfaitement. Aucun câblage n’est requis.

Explication du code

Plongeons dans le code. Ouvrez l’éditeur Velxio et vous verrez le sketch suivant :

// Serial Echo — USART Protocol Test
// Open the Serial Monitor to send and receive data.
// Everything you type is echoed back with extra info.

void setup() {
  Serial.begin(9600);
  Serial.println("=============================");
  Serial.println("  Serial Echo Test (USART)");
  Serial.println("=============================");
  Serial.println("Type something and press Send.");
  Serial.println();

  // Print system info
  Serial.print("CPU Clock: ");
  Serial.print(F_CPU / 1000000);
  Serial.println(" MHz");
  Serial.print("Baud rate: 9600");
  Serial.println();
  Serial.println();
}

unsigned long charCount = 0;

void loop() {
  if (Serial.available() > 0) {
    char c = Serial.read();
    charCount++;

    Serial.print("[");
    Serial.print(charCount);
    Serial.print("] Received: '");
    Serial.print(c);
    Serial.print("' (ASCII ");
    Serial.print((int)c);
    Serial.println(")");
  }

  // Periodic heartbeat
  static unsigned long lastBeat = 0;
  if (millis() - lastBeat >= 5000) {
    lastBeat = millis();
    Serial.print("Uptime: ");
    Serial.print(millis() / 1000);
    Serial.print("s | Chars received: ");
    Serial.println(charCount);
  }
}

Comment ça fonctionne

1. Configuration : Nous initialisons la communication série à 9600 bauds avec Serial.begin(9600). Ensuite, nous affichons une bannière et des informations système : la vitesse d’horloge du CPU (F_CPU / 1000000 donne la fréquence en MHz) et le débit en bauds.

2. Variable globale : unsigned long charCount = 0; garde la trace du nombre de caractères reçus.

3. Boucle :

   • if (Serial.available() > 0) vérifie si des données sont en attente dans le tampon de réception.
   • char c = Serial.read(); lit un caractère.
   • Nous incrémentons charCount et affichons un message formaté : [compteur] Reçu : 'c' (ASCII 99).
   • Toutes les 5 secondes, nous affichons un signal de vie avec la durée de fonctionnement et le nombre total de caractères reçus.

Concepts clés pour les étudiants

• Débit en bauds : La vitesse de la communication série. Les deux parties doivent se mettre d’accord sur le même débit (ici 9600).
• Serial.available() : Retourne le nombre d’octets en attente de lecture. Vérifiez toujours avant de lire pour éviter d’obtenir -1.
• Serial.read() : Lit un seul octet (caractère) depuis le tampon.
• ASCII : Chaque caractère a un code numérique. Par exemple, ‘A’ est 65. Le code convertit c en int pour l’afficher.
• millis() : Retourne le nombre de millisecondes écoulées depuis le démarrage du programme. Utile pour un timing non bloquant.
• Variables statiques : static unsigned long lastBeat conserve sa valeur entre les itérations de la boucle, contrairement aux variables locales.

Pièges courants et conseils de débogage

• Le Moniteur série n’affiche rien ? Assurez-vous d’avoir ouvert le Moniteur série dans Velxio (cliquez sur le bouton “Moniteur série” dans la barre d’outils). Vérifiez également que le débit en bauds dans le moniteur correspond à 9600.
• Caractères illisibles ? Une différence de débit en bauds est la cause la plus fréquente. Revérifiez Serial.begin(9600) et le paramètre du moniteur.
• Rien ne se passe quand vous tapez ? Assurez-vous d’appuyer sur “Envoyer” ou Entrée après avoir tapé. Le code lit un caractère à la fois.
• Le signal de vie ne s’affiche pas ? La condition if (millis() - lastBeat >= 5000) utilise >= pour éviter de manquer l’intervalle. Si vous ne voyez pas de signal de vie, vérifiez que lastBeat est mis à jour correctement.

Extensions suggérées

Une fois que vous maîtrisez l’écho de base, essayez ces améliorations :

1. Écho de lignes entières : Au lieu de renvoyer chaque caractère, accumulez les caractères jusqu’à un saut de ligne, puis renvoyez la ligne entière.
2. Analyseur de commandes : Interprétez des commandes spéciales comme “LED ON” pour allumer une LED (ajoutez une LED au circuit).
3. Sortie binaire : Affichez le caractère reçu au format binaire.
4. Plusieurs débits en bauds : Permettez à l’utilisateur de changer le débit en bauds via une commande.
5. Journalisation dans l’EEPROM virtuelle : Stockez les données reçues dans l’EEPROM simulée.

Conclusion

Vous venez de construire votre premier projet de communication série ! L’Écho série est une démonstration simple mais puissante de la façon dont les microcontrôleurs communiquent avec le monde extérieur. Avec Velxio, vous pouvez expérimenter sans aucun matériel — ouvrez simplement le simulateur, écrivez du code et testez instantanément.

Prêt à essayer par vous-même ? Ouvrez l’exemple en direct dans Velxio et commencez à taper : Écho série sur Velxio. Bon codage !