Moniteur série Arduino : bauds, envoi de données et traceur

Le moniteur série Arduino (Serial Monitor) est la fenêtre de l'Arduino IDE qui permet à ta carte et à ton ordinateur d'échanger du texte par le câble USB. C'est là que tu lis la sortie de chaque ligne Serial.println() de ton croquis, et c'est de là que tu renvoies des commandes à la carte. C'est le moyen le plus rapide de voir quelle valeur un capteur mesure à l'instant, jusqu'à quelle ligne ton programme est allé ou si un bouton-poussoir est vraiment enfoncé, ce qui en fait l'outil de débogage numéro un sur Arduino. Pour t'en servir, il suffit d'avoir Serial.begin(9600) dans ton code, le bon port sélectionné dans le sélecteur de carte et la même vitesse dans le moniteur que dans le code.

Dans ce guide, tu commences par ouvrir le moniteur série, puis tu verras ce que signifie vraiment le débit en bauds, comment afficher des nombres en décimal, hexadécimal et binaire avec print et println, comment régler le nombre de décimales et comment construire des lignes propres avec snprintf. Avec des croquis d'exemple qui compilent vraiment, nous passons en revue toutes les causes des caractères bizarres, l'effet du réglage de fin de ligne sur ton code, l'envoi de nombres et de commandes texte de l'ordinateur vers la carte (Serial.read, parseInt, readStringUntil), le tracé de courbes en direct avec le traceur série et des techniques de débogage qui te simplifieront la vie. Les dernières sections montrent ce qui change pour la sortie série sur l'ESP32 et la Raspberry Pi Pico (avec Arduino et MicroPython) et comment résoudre des problèmes courants comme un moniteur vide.

Qu'est-ce que le moniteur série Arduino et comment fonctionne-t-il ?

L'ATmega328P, le cerveau de l'Arduino Uno, communique avec l'extérieur grâce à une unité de communication série appelée UART : il envoie les données bit par bit sur une ligne (TX) et les reçoit sur une autre (RX). Les ordinateurs actuels n'ont plus ce type de port série, donc une deuxième puce sur la carte (un ATmega16U2 sur l'Uno d'origine, le plus souvent un CH340 sur les clones) convertit le signal en USB. L'ordinateur voit la carte comme un port série virtuel : par exemple COM3 sous Windows, /dev/ttyACM0 ou /dev/ttyUSB0 sous Linux, et un nom commençant par /dev/cu.usbmodem ou /dev/cu.usbserial sous macOS. Le moniteur série ouvre ce port, affiche les octets reçus sous forme de texte et renvoie ce que tu tapes à la carte par le même chemin. Par défaut, Arduino utilise le format 8N1 : pour chaque octet, un bit de start, 8 bits de données, pas de bit de parité et un bit de stop. Un seul caractère occupe donc 10 bits sur la ligne ; nous utiliserons ce chiffre dans les calculs de vitesse.

Comment ouvrir et utiliser le moniteur série

1. Ajoute la ligne Serial.begin(9600); dans la partie setup() de ton croquis et téléverse-le. Sans cette ligne, la carte n'écrit rien sur le port série.
2. Choisis le port auquel ta carte est reliée dans le sélecteur de la barre du haut ou dans le menu Outils > Port. Si aucun port n'est sélectionné, le moniteur série affiche l'avertissement Déconnecté. Sélectionnez une carte ainsi qu'un port pour vous connecter automatiquement. (dans l'interface anglaise : Not connected. Select a board and a port to connect automatically.)
3. Clique sur l'icône de loupe en haut à droite, utilise le menu Outils > Moniteur série ou appuie sur Ctrl+Maj+M (Cmd+Shift+M sur macOS). Dans l'IDE 2, le moniteur s'ouvre dans le panneau du bas, à côté de la section Sortie.
4. Dans le menu de vitesse à droite du panneau, choisis le même débit en bauds que dans ton code ; ici 9600. Si la vitesse est différente, des caractères bizarres s'affichent.
5. Pour envoyer des données à la carte, tape dans la zone de message en haut du panneau et appuie sur Entrée. Dans le menu juste à côté, tu choisis la fin de ligne ; nous expliquons plus bas pourquoi ce réglage compte.
6. Avec les boutons en haut à droite, tu peux suspendre le défilement automatique (pratique pour relire les anciennes lignes), activer l'horodatage qui ajoute l'heure de ton ordinateur au début de chaque ligne, et effacer la sortie.

Dans l'ancien Arduino IDE 1.8, le moniteur série s'ouvre dans une fenêtre séparée ; les commandes font le même travail, elles sont seulement placées ailleurs : les cases de défilement automatique et d'horodatage sont en bas à gauche, les menus de fin de ligne et de vitesse en bas à droite. Tu peux aussi surveiller le port série sans l'IDE : PuTTY ou CoolTerm sous Windows, la commande screen /dev/ttyUSB0 115200 sous Linux et macOS, et arduino-cli monitor -p COM3 -c baudrate=115200 sur tous les systèmes font la même chose. Retiens une chose : un port série ne peut être ouvert que par un seul programme à la fois. Tant qu'un script Python ou PuTTY occupe le port, tu ne peux pas téléverser de code depuis l'IDE ; l'installation de l'IDE et le reste de son interface sont décrits dans le guide installer l'Arduino IDE.

Serial.begin() et débit en bauds : 9600 ou 115200 ?

Serial.begin(vitesse) démarre le port série à la vitesse indiquée et s'appelle presque toujours une seule fois dans setup(). La vitesse s'exprime en bauds, c'est-à-dire en bits par seconde sur la ligne. Comme chaque caractère occupe 10 bits, 9600 bauds représentent au maximum 960 caractères par seconde ; l'envoi d'un seul caractère prend environ 1,04 milliseconde. Une ligne de 30 caractères prend 31 ms à cette vitesse, donc dès que tu veux afficher des centaines de mesures par seconde, tu atteins cette limite. À 115200 bauds, la même ligne ne prend que 2,6 ms. La valeur du croquis et celle du moniteur série doivent être identiques, car il n'y a pas de signal d'horloge commun et le récepteur lit les bits uniquement d'après le temps.

L'horloge 16 MHz de l'Uno ne peut pas produire toutes les vitesses exactement : 115200 bauds fonctionnent en réalité avec un écart d'environ 2 %, à 117647 bauds. Cet écart ne pose aucun problème dans le moniteur série, mais il peut provoquer des erreurs quand tu dialogues avec un autre microcontrôleur par un long câble ; dans ce cas, 57600 bauds ou 250000 bauds, produits sans erreur, sont plus sûrs. Si tu débutes, utilise 9600 pour l'Uno et le Nano, et 115200 pour l'ESP32 et la Pico. Si tu relies deux cartes par des fils TX-RX, la vitesse doit être la même des deux côtés, les GND doivent être communes et une ligne TX en 5 V doit être abaissée avec un pont diviseur de tension avant d'arriver sur une entrée RX en 3,3 V (ESP32, Pico). Tu trouveras les détails dans l'article communication série UART.

Serial.print() et Serial.println() : afficher et formater

Serial.print() écrit la valeur que tu lui donnes et laisse le curseur sur la même ligne ; Serial.println() ajoute en plus les caractères de fin de ligne (\r\n), de sorte que la sortie suivante commence sur une nouvelle ligne. Pour afficher plusieurs valeurs sur une ligne, écris les premiers morceaux avec print et le dernier avec println. Ces fonctions acceptent presque tous les types, comme int, long, float, char, texte et String, et le second paramètre facultatif fixe le format. Pour les entiers, tu peux choisir DEC, HEX, BIN et OCT ; pour les nombres à virgule, le second paramètre est le nombre de décimales. Les nombres à virgule s'affichent par défaut avec 2 décimales, arrondis. Dans le code ci-dessous, nous avons écrit la sortie de chaque ligne en commentaire :

1// Biçimlendirme örnekleri: çıktılar yorumlarda / Formatting examples: output in the comments
2void setup() {
3  Serial.begin(9600);
4  int sayi = 78;
5  float pi = 3.14159;
6
7  Serial.println(sayi);           // 78
8  Serial.println(sayi, HEX);      // 4E
9  Serial.println(sayi, BIN);      // 1001110
10  Serial.println(sayi, OCT);      // 116
11  Serial.println(pi);             // 3.14 (varsayılan 2 basamak / 2 decimals by default)
12  Serial.println(pi, 4);          // 3.1416
13  Serial.write(65);               // A (ham bayt / raw byte)
14  Serial.println();               // yalnız satır sonu / line break only
15
16  Serial.print("Sicaklik:\t");    // \t = sekme / \t = tab
17  Serial.print(23.46, 1);         // 23.5
18  Serial.println(" C");           // Sicaklik:  23.5 C
19
20  char satir[32];
21  int saat = 9, dakika = 5;
22  snprintf(satir, sizeof(satir), "Saat %02d:%02d", saat, dakika);
23  Serial.println(satir);          // Saat 09:05
24
25  char metin[10];
26  dtostrf(pi, 6, 2, metin);       // Uno'da %f yerine / instead of %f on the Uno
27  Serial.println(metin);          // "  3.14"
28}
29
30void loop() {
31}

Au lieu d'afficher les longues lignes morceau par morceau, tu peux préparer un seul texte avec snprintf() : %d pour un entier, %02d pour un entier sur deux chiffres avec zéro de tête, %s pour du texte et %lu pour un unsigned long comme millis(). Pour économiser la mémoire, la bibliothèque C de l'Uno ne prend pas en charge %f ; si tu essaies d'afficher un nombre à virgule, tu verras un ? à sa place. Convertis donc d'abord les nombres à virgule en texte avec dtostrf(nombre, largeur, décimales, tampon). Sur l'ESP32 et la Pico, tu peux utiliser directement Serial.printf(). L'Uno n'a que 2 Ko de RAM ; écrire les textes fixes avec la macro F(), comme Serial.println(F("Bonjour")), les garde en mémoire flash au lieu de la RAM et évite les problèmes de mémoire insuffisante dans les gros projets.

Caractères bizarres dans le moniteur série : causes et solution

Si tu vois ⸮⸮⸮, � ou des tas de lettres et de symboles aléatoires, les données arrivent bien à l'ordinateur mais sont mal décodées. Comme la communication série n'a pas de signal d'horloge commun, le récepteur calcule le milieu de chaque bit selon sa propre vitesse, à partir du moment où il voit le bit de start. Si la vitesse est fausse ou si l'horloge de la carte n'est pas celle prévue, les bits sont lus au mauvais moment et chaque octet devient un autre caractère. La cause est presque toujours un seul réglage ; le tableau ci-dessous classe les cas les plus fréquents par symptôme. Pour les cartes qui existent avec plusieurs horloges, comme la Pro Mini, jette aussi un œil à l'article Arduino Pro Mini.

Réglage de fin de ligne : No Line Ending, New Line, Carriage Return, Both NL & CR

Quand tu tapes dans la zone de message et que tu appuies sur Entrée, le moniteur série n'envoie pas seulement les caractères tapés, mais aussi un ou deux caractères invisibles selon la fin de ligne choisie. Si ton code ne les attend pas, par exemple s'il traite chaque octet reçu comme une commande, '\n' (valeur 10) et '\r' (13) sont lus eux aussi comme des commandes. À l'inverse, si ton code attend une fin de ligne et que le réglage est No Line Ending, la ligne ne se termine jamais ; readStringUntil() attend jusqu'à l'expiration du délai. Le tableau montre les octets envoyés à la carte quand tu tapes 42 puis Entrée :

Une règle pratique : pour un code qui lit ligne par ligne, choisis New Line et applique trim() au texte lu ; ainsi ton code fonctionne quel que soit le réglage choisi par l'utilisateur. Pour des commandes d'un seul caractère comme 1, 0 ou a, No Line Ending est le choix le plus propre. L'IDE retient ton choix, alors pense à le vérifier quand tu passes à un autre projet.

Envoyer des données de l'ordinateur vers Arduino : Serial.read(), parseInt(), readStringUntil()

Les octets que tu envoies depuis le moniteur série s'alignent dans le tampon de réception de la carte (64 octets sur l'Uno). Serial.available() t'indique combien d'octets y attendent, Serial.read() prend l'octet suivant et le retire du tampon, en renvoyant -1 s'il n'y a pas de données, et Serial.peek() regarde l'octet suivant sans le retirer. N'oublie pas que tout ce qui vient du clavier arrive sous forme de caractères ASCII : quand tu tapes 7, la carte ne reçoit pas le nombre 7 mais 55, le code du caractère '7'. Tu trouveras un exemple de commandes simples à une touche dans l'article commandes Arduino ; ici, nous traitons des nombres à plusieurs chiffres et des commandes faites de mots. Si le tampon se remplit, les octets qui arrivent sont perdus ; gérer le temps avec millis() plutôt que d'attendre longtemps avec delay() dans loop() rend donc aussi la lecture série plus sûre.

Serial.parseInt() extrait le premier entier des caractères reçus : il saute les lettres et espaces de tête, assemble les chiffres et s'arrête au premier caractère qui n'est pas un chiffre ; il comprend aussi le signe moins. Le texte "128" devient ainsi le nombre 128. Pour les nombres à virgule, Serial.parseFloat() fait la même chose. Ces fonctions ont une habitude à connaître : si aucun nombre n'arrive, elles attendent par défaut 1000 ms puis renvoient 0. Le bug classique se produit ainsi : avec le réglage sur New Line, tu envoies 42, parseInt lit 42 mais le '\n' reste dans le tampon. Au tour suivant, loop() voit available() supérieur à 0 et rappelle parseInt, qui attend une seconde et renvoie 0. Résultat : un 0 arrive après chaque nombre, et tu ne comprends pas pourquoi la LED s'éteint une seconde après chaque nombre. Le code ci-dessous règle le problème à la racine en jetant le caractère suivant s'il n'est pas un chiffre, et raccourcit l'attente avec setTimeout().

1// Seri Port Ekranı'ndan sayı al: LED parlaklığı 0-255
2// Read a number from the Serial Monitor: LED brightness 0-255
3const int LED_PIN = 9;   // ~9 PWM pini + 220 ohm direnç / ~9 PWM pin + 220 ohm resistor
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7  Serial.begin(9600);
8  Serial.setTimeout(100);   // parseInt en fazla 100 ms bekler / parseInt waits at most 100 ms
9  Serial.println(F("0-255 arasi bir sayi yaz / Type a number from 0 to 255"));
10}
11
12void loop() {
13  if (Serial.available() > 0) {
14    char c = Serial.peek();               // sıradakine bak, silme / look at the next byte, keep it
15    if (isDigit(c) || c == '-') {
16      int deger = Serial.parseInt();      // "128" -> 128
17      deger = constrain(deger, 0, 255);   // aralığın dışına çıkma / stay within range
18      analogWrite(LED_PIN, deger);
19      Serial.print(F("Parlaklik / Brightness: "));
20      Serial.println(deger);
21    } else {
22      Serial.read();                      // '\r', '\n' ve harfleri at / drop '\r', '\n' and letters
23    }
24  }
25}

Pour des commandes faites de mots, le plus simple est de lire toute la ligne sous forme de String. Serial.readStringUntil('\n') lit jusqu'à l'arrivée d'un '\n', jette le caractère de fin de ligne et renvoie le reste. Si le réglage est Both NL & CR, un '\r' reste à la fin du texte, ta commande "on" devient "on\r" et la comparaison échoue. Applique donc tout de suite trim() à la ligne lue : il supprime les espaces de début et de fin ainsi que les caractères '\r' et '\n'. toLowerCase() rend ON, On et on identiques. L'exemple ci-dessous comprend les commandes on, off, blink 250 et status ; utilise le moniteur série à 115200 bauds avec New Line. Comme il fait clignoter la LED avec millis() au lieu de delay(), il répond instantanément à une nouvelle commande à tout moment.

1// Metin komutları: on, off, blink 250, status
2// Text commands: on, off, blink 250, status
3const int LED_PIN = LED_BUILTIN;   // Uno'da pin 13 / pin 13 on the Uno
4bool ledAcik = false;              // LED'in şu anki durumu / current LED state
5bool yanipSon = false;             // yanıp sönme modu / blink mode
6unsigned long aralik = 500;        // yanıp sönme aralığı (ms) / blink interval (ms)
7unsigned long sonDegisim = 0;      // LED'in son değiştiği an / last time the LED changed
8
9void ledYaz(bool acik) {
10  ledAcik = acik;
11  digitalWrite(LED_PIN, acik ? HIGH : LOW);
12}
13
14void komutuIsle(String komut) {
15  if (komut == "on") {
16    yanipSon = false;
17    ledYaz(true);
18    Serial.println(F("LED: on"));
19  } else if (komut == "off") {
20    yanipSon = false;
21    ledYaz(false);
22    Serial.println(F("LED: off"));
23  } else if (komut.startsWith("blink")) {
24    long ms = komut.substring(5).toInt();       // "blink 250" -> 250
25    aralik = (ms >= 50) ? ms : 500;             // çok küçükse 500 ms / fall back to 500 ms
26    yanipSon = true;
27    Serial.print(F("Blink (ms): "));
28    Serial.println(aralik);
29  } else if (komut == "status") {
30    Serial.print(F("LED: "));
31    Serial.print(ledAcik ? F("on") : F("off"));
32    Serial.print(F(", blink: "));
33    Serial.println(yanipSon ? F("yes") : F("no"));
34  } else {
35    Serial.print(F("Bilinmeyen komut / Unknown command: "));
36    Serial.println(komut);
37  }
38}
39
40void setup() {
41  pinMode(LED_PIN, OUTPUT);
42  Serial.begin(115200);
43  Serial.setTimeout(100);   // satır sonu gelmezse 100 ms sonra bırak / give up after 100 ms without a line ending
44  Serial.println(F("Komutlar / Commands: on, off, blink 250, status"));
45}
46
47void loop() {
48  if (Serial.available() > 0) {
49    String komut = Serial.readStringUntil('\n');   // Enter'a kadar oku / read up to Enter
50    komut.trim();                                  // '\r' ve boşlukları sil / strip '\r' and spaces
51    komut.toLowerCase();                           // ON ile on aynı olsun / treat ON like on
52    if (komut.length() > 0) {
53      komutuIsle(komut);
54    }
55  }
56
57  if (yanipSon && millis() - sonDegisim >= aralik) {   // delay() olmadan yanıp sön / blink without delay()
58    sonDegisim = millis();
59    ledYaz(!ledAcik);
60  }
61}

Tracer des courbes en direct avec le traceur série

Le traceur série (Serial Plotter) transforme les nombres qui arrivent sur le port série en une courbe en direct ; on l'ouvre avec l'icône en forme d'onde en haut à droite de l'IDE ou par le menu Outils > Traceur série. Le format est très simple : sépare les valeurs d'une ligne par des virgules, des espaces ou des tabulations, et termine la ligne avec println. Chaque ligne devient un pas de temps sur le graphique et chaque valeur de la ligne une courbe de couleur différente. Si tu mets un nom devant les valeurs au format étiquette:valeur, les courbes portent ce nom et peuvent être masquées ou affichées une à une grâce aux cases au-dessus du graphique ; sans étiquette, elles s'appellent value 1, value 2, etc. Ici aussi, le menu de vitesse doit correspondre à ton code. Le code ci-dessous trace sur le même graphique la mesure brute de A0 et sa version lissée :

1// Seri Çizici: ham değer ve yumuşatılmış değer / Serial Plotter: raw and smoothed value
2const int SENSOR_PIN = A0;   // potansiyometre ya da LDR bölücü çıkışı / potentiometer or LDR divider output
3float yumusak = 0;           // üstel ortalama / exponential moving average
4
5void setup() {
6  Serial.begin(115200);
7}
8
9void loop() {
10  int ham = analogRead(SENSOR_PIN);           // 0-1023
11  yumusak = yumusak * 0.9 + ham * 0.1;        // yeni ölçümün payı %10 / the new reading weighs 10%
12
13  Serial.print("Min:0,Max:1023,");            // dikey ekseni sabitler / keeps the y-axis fixed
14  Serial.print("Ham:");
15  Serial.print(ham);
16  Serial.print(",Yumusak:");
17  Serial.println(yumusak);                    // satırı bitir: bir ölçüm / end the line: one sample
18  delay(20);                                  // saniyede yaklaşık 50 satır / about 50 lines per second
19}

• Fixe l'échelle : le traceur série ajuste sans cesse l'axe vertical aux valeurs reçues, si bien que de petites variations paraissent énormes. Ajouter à chaque ligne deux valeurs constantes comme Min:0,Max:1023, fige l'axe.
• Pas d'espaces dans les étiquettes : comme les espaces et les virgules servent de séparateurs, "Temp Salon:24" est coupé en deux morceaux ; utilise des noms avec tiret bas comme Temp_Salon.
• Seulement des étiquettes et des nombres sur la ligne : les unités et descriptions comme "Temp 24 C" perturbent le graphique ; affiche les descriptions pour le moniteur série dans un code séparé.
• Règle le rythme d'envoi : delay(20) correspond à environ 50 lignes par seconde. Trop rapide, le graphique défile en un instant ; trop lent, la courbe ressemble à un escalier.
• Vois le filtre de tes propres yeux : tracer la valeur brute et la moyenne sur le même graphique montre immédiatement à quel point un filtre réduit le bruit ; les méthodes sont dans l'article filtrer les données de capteurs.
• Pour enregistrer, utilise un autre outil : le traceur série n'enregistre rien dans un fichier. Pour de longues mesures, affiche les valeurs en lignes CSV et importe-les dans Excel ou lis-les avec Python.

Techniques de débogage avec le moniteur série

L'Arduino Uno n'a pas de débogueur capable d'exécuter ton code pas à pas ; c'est le moniteur série qui fait ce travail. Mais des lignes print semées au hasard dans le code deviennent vite un tas de texte illisible. Ces habitudes t'aideront à trouver les bugs beaucoup plus vite :

• Affiche d'abord un message depuis setup() : si tu vois la ligne "Started" une fois à chaque démarrage, la carte fonctionne. Si cette ligne revient sans arrêt, la carte redémarre en boucle et le problème vient plutôt de l'alimentation que du code ; consulte le guide Arduino qui redémarre tout seul.
• Affiche les valeurs avec leur nom : au lieu d'écrire seulement 512, écris temp=24.5 hum=40 ; tu n'auras pas à te demander plus tard à quoi correspond chaque nombre.
• Marque où tu en es : si le programme se fige quelque part, place de courts repères comme A, B, C avant les étapes importantes. Le dernier repère affiché indique où le programme est bloqué.
• Affiche au changement, pas à chaque tour : loop() tourne des milliers de fois par seconde. Afficher à chaque tour inonde l'écran et ralentit le programme ; affiche une valeur seulement quand elle change, ou une fois par seconde avec millis().
• Mesure le temps : pour savoir combien de temps prend une opération, note la valeur de micros() avant et après, puis affiche la différence. C'est ainsi que tu repères une lecture de capteur lente ou une longue boucle.
• N'affiche rien dans les interruptions : la sortie série prend du temps ; utiliser Serial.print dans une fonction d'interruption l'allonge inutilement et peut te faire rater d'autres événements. Dans l'interruption, positionne seulement une variable drapeau et fais l'affichage dans loop() ; détails dans l'article interruptions Arduino.
• Place les lignes de débogage derrière un seul interrupteur : avec les macros ci-dessous, tu peux retirer complètement toute la sortie de débogage du code en mettant DEBUG à 0 ; dans le projet terminé, tu gagnes de la mémoire flash et du temps.

1// Hata ayıklama makroları: tek satırla aç ya da kapat
2// Debug macros: switch all debug output on or off with one line
3#define DEBUG 1                  // 0 yaparsan debug satırları koddan çıkar / set to 0 to strip debug lines
4
5#if DEBUG
6  #define DBG(x)   Serial.print(x)
7  #define DBGLN(x) Serial.println(x)
8#else
9  #define DBG(x)
10  #define DBGLN(x)
11#endif
12
13const int SENSOR_PIN = A0;
14const int ESIK = 800;            // uyarı eşiği / warning threshold
15bool esikUstunde = false;        // son durum / last state
16unsigned long sonRapor = 0;
17unsigned long turSayisi = 0;     // saniyedeki loop() turu / loop() passes per second
18
19void setup() {
20  Serial.begin(115200);
21  DBGLN(F("Basladi / Started"));
22}
23
24void loop() {
25  turSayisi++;
26  int deger = analogRead(SENSOR_PIN);
27
28  bool simdi = deger > ESIK;
29  if (simdi != esikUstunde) {          // yalnız değişince yaz / print only on change
30    esikUstunde = simdi;
31    DBG(F("[esik / threshold] "));
32    DBG(simdi ? F("ustunde / above") : F("altinda / below"));
33    DBG(F(", deger / value = "));
34    DBGLN(deger);
35  }
36
37  if (millis() - sonRapor >= 1000) {   // saniyede bir özet / one summary per second
38    sonRapor = millis();
39    DBG(F("t = "));
40    DBG(sonRapor);
41    DBG(F(" ms, tur/s / loops/s = "));
42    DBGLN(turSayisi);
43    turSayisi = 0;
44  }
45}

N'oublie pas que la sortie série a un coût. Sur l'Uno, le tampon d'émission fait lui aussi 64 octets ; quand il est plein, Serial.print() attend qu'il y ait de la place et loop() ralentit. Tu peux le mesurer toi-même avec le compteur de tours du code ci-dessus : si tu ajoutes une ligne de 25 caractères affichée à chaque tour, à 9600 bauds le programme tombe à environ quarante tours par seconde, alors qu'afficher seulement au changement en conserve des milliers. Si tu veux voir à coup sûr ce que la carte a affiché juste avant de se figer ou de redémarrer, appelle Serial.flush() après la ligne critique ; il attend que tout le contenu du tampon soit envoyé. Dans les programmes plus complexes, passer à une structure de machine à états et n'afficher qu'une ligne à chaque changement d'état facilite beaucoup la traque des bugs.

Sortie série sur l'ESP32

Sur les cartes ESP32 DevKit, Serial est l'UART0 des broches GPIO 1 (TX) et GPIO 3 (RX), reliée à l'USB par la puce CP2102 ou CH340 de la carte. La vitesse habituelle est 115200 bauds, car la ROM interne de la puce affiche elle aussi au démarrage des lignes comme rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT) à cette vitesse ; si tu laisses le moniteur sur 115200, ces lignes deviennent lisibles. Le cœur Arduino de l'ESP32 propose Serial.printf() et sait afficher les nombres à virgule avec %f. Les ports série supplémentaires Serial1 et Serial2 peuvent être attribués aux broches de ton choix ; pour brancher un module, on utilise souvent Serial2 sur GPIO 16 et 17. Sur les cartes à USB intégré comme l'ESP32-S3 et l'ESP32-C3, si le moniteur série reste vide, règle Outils > USB CDC On Boot sur Enabled. Pour voir les avertissements du cœur lui-même, choisis Error, Warn, Info, Debug ou Verbose dans le menu Outils > Core Debug Level ; dans ton propre code, tu peux afficher des journaux avec le fichier et la ligne grâce aux macros log_e, log_w et log_i.

1// ESP32: Serial (USB), Serial2 (GPIO16/17), printf ve log
2// ESP32: Serial (USB), Serial2 (GPIO16/17), printf and logging
3const int POT_PIN = 34;              // ADC1, yalnız giriş pini / ADC1, input-only pin
4unsigned long sonYazdirma = 0;
5
6void setup() {
7  Serial.begin(115200);                       // açılış mesajlarıyla aynı hız / same rate as the boot messages
8  delay(500);
9  Serial2.begin(9600, SERIAL_8N1, 16, 17);    // RX = GPIO16, TX = GPIO17
10
11  Serial.printf("Model: %s, CPU: %lu MHz\n", ESP.getChipModel(), (unsigned long)ESP.getCpuFreqMHz());
12  Serial.printf("Bos RAM / Free heap: %lu bayt / bytes\n", (unsigned long)ESP.getFreeHeap());
13  log_i("Core Debug Level en az Info ise gorunur / shown when Core Debug Level is Info or higher");
14}
15
16void loop() {
17  while (Serial2.available() > 0) {           // Serial2'den geleni USB'ye aktar / forward Serial2 data to USB
18    Serial.write(Serial2.read());
19  }
20
21  if (millis() - sonYazdirma >= 1000) {       // delay() yok, tampon taşmaz / no delay(), no buffer overflow
22    sonYazdirma = millis();
23    float volt = analogReadMilliVolts(POT_PIN) / 1000.0;          // kalibre gerilim / calibrated voltage
24    Serial.printf("t=%lu ms, GPIO34=%.2f V\n", millis(), volt);   // ESP32'de %f çalışır / %f works on ESP32
25  }
26}

En cas de problème de connexion Wi-Fi, de redémarrages inattendus ou d'erreurs Guru Meditation, le moniteur série est le premier endroit à regarder : le type d'erreur, la cause du redémarrage et les lignes de backtrace s'y affichent. Nous expliquons comment interpréter ces messages dans les guides ESP32 brownout et Guru Meditation et l'ESP32 ne se connecte pas au Wi-Fi. Si tu utilises l'ESP32 pour la première fois, commence par l'article Qu'est-ce que l'ESP32 ?.

Sortie série sur la Raspberry Pi Pico : Arduino et MicroPython

La Raspberry Pi Pico n'a pas de puce pont USB-série ; le RP2040 gère lui-même l'USB et apparaît directement sur l'ordinateur comme un port série (USB CDC). Dans le cœur Arduino-Pico d'Earle Philhower, Serial est ce port USB et, comme les données circulent à la vitesse de l'USB, la valeur de vitesse de Serial.begin() est ignorée. Cela a deux conséquences : la vitesse choisie dans le moniteur n'a plus d'importance, mais la carte ne redémarre pas comme un Uno quand tu ouvres le moniteur série. Les premiers messages affichés dans setup() sont déjà envoyés et perdus quand tu ouvres le moniteur ; attends donc brièvement que l'ordinateur ouvre le port, comme ci-dessous. C'est la même chose pour les cartes à ATmega32U4 comme la Leonardo, la Micro et la Pro Micro. Le vrai UART de la Pico, sur les broches GP0 et GP1, s'utilise sous le nom Serial1.

1// Raspberry Pi Pico (Arduino-Pico çekirdeği): USB seri port
2// Raspberry Pi Pico (Arduino-Pico core): USB serial port
3void setup() {
4  Serial.begin(115200);                  // USB'de hız değeri önemsiz / the baud value is ignored over USB
5  unsigned long baslangic = millis();
6  while (!Serial && millis() - baslangic < 3000) {
7    delay(10);                           // port açılana kadar en çok 3 sn bekle / wait up to 3 s for the port
8  }
9  Serial1.begin(9600);                   // UART0: GP0 = TX, GP1 = RX
10  Serial.println("Pico hazir / Pico ready");
11}
12
13void loop() {
14  Serial.print("Sicaklik / Temperature (C): ");
15  Serial.println(analogReadTemp(), 1);   // dahili sensör, yaklaşık / internal sensor, approximate
16  Serial1.println(millis());             // aynı anda UART0'a da yaz / also write to UART0
17  delay(1000);
18}

En MicroPython, c'est encore plus simple : tout ce que tu affiches avec print() part vers l'ordinateur par l'USB et apparaît dans le Shell de Thonny ; il n'y a pas de débit en bauds à régler. Si tu ouvres le menu View > Plotter de Thonny, les nombres des lignes deviennent une courbe en direct, comme dans le traceur série. Pour recevoir des données de l'ordinateur, tu peux utiliser input(), mais input() bloque le programme jusqu'à l'arrivée d'une ligne. Pour écouter des commandes tout en continuant à mesurer, vérifie avec select.poll() si des données attendent sur stdin, comme ci-dessous ; il suffit de taper on ou off dans le Shell et d'appuyer sur Entrée. Nous présentons la Pico et l'installation de MicroPython dans l'article Qu'est-ce que la Raspberry Pi Pico ?.

1# Pico MicroPython: print() ile yazdır, programı durdurmadan komut al
2# Pico MicroPython: print with print(), read commands without blocking
3import sys
4import select
5import time
6from machine import ADC, Pin
7
8led = Pin(25, Pin.OUT)            # Pico'da dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
9sensor = ADC(4)                   # dahili sıcaklık sensörü / internal temperature sensor
10poll = select.poll()
11poll.register(sys.stdin, select.POLLIN)
12
13while True:
14    volt = sensor.read_u16() * 3.3 / 65535
15    sicaklik = 27 - (volt - 0.706) / 0.001721
16    print("Sicaklik:{:.1f}".format(sicaklik))    # Thonny Plotter da çizer / Thonny's Plotter can graph it
17    if poll.poll(0):                              # bekleyen veri var mı? / is input waiting?
18        komut = sys.stdin.readline().strip()      # satırı al, boşlukları sil / read the line, strip spaces
19        if komut == "on":
20            led.value(1)
21        elif komut == "off":
22            led.value(0)
23        print("Komut / Command:", komut)
24    time.sleep(1)

Moniteur série vide, port occupé : erreurs fréquentes et solutions

Idées de projets avec la communication série

• LED et relais pilotés depuis l'ordinateur : étends l'analyseur de commandes de cet article pour piloter un relais ou un moteur avec les commandes on, off et blink.
• Enregistreur de données de capteurs : affiche la température et l'humidité en lignes CSV séparées par des virgules, puis transforme-les en tableau et en graphique sur l'ordinateur ; le DHT11 est un bon capteur pour commencer.
• Courbe de lumière en direct : observe la valeur d'une photorésistance LDR ou d'un potentiomètre dans le traceur série et vois l'effet du filtre sur le même graphique.
• Panneau de bureau en Python : lis les données envoyées par l'Arduino avec un programme Python et crée une interface avec des boutons ; détails dans l'article communication série entre Arduino et Python.
• Banc de test de modules : les modules GPS, Bluetooth et GSM utilisent eux aussi un port série ; redirige les données brutes du module vers le moniteur série pour vérifier qu'il fonctionne (HC-05, GPS NEO-6M).
• Essayer sans carte : si tu n'as pas de carte sous la main, Tinkercad propose lui aussi un moniteur série ; tu peux lancer le code de cet article dans une simulation Tinkercad.

Une fois à l'aise avec le moniteur série, chercher les bugs sur Arduino n'est plus une affaire de devinettes mais de mesures. Pour aller plus loin, lis l'article communication série UART pour faire dialoguer deux cartes par TX et RX, et l'article convertisseur USB-TTL pour programmer des cartes sans USB. Dans l'application BlueGrays, tu trouveras des projets comme l'affichage dans le moniteur série de la distance mesurée par un HC-SR04, la lecture de l'intensité lumineuse avec une LDR, la mesure de la température et de l'humidité avec un DHT11 et la liaison de deux Arduino par une ligne série, pas à pas avec schémas de câblage et code prêt à l'emploi.