Plusieurs variables d'impression série Arduino

Pour afficher plusieurs valeurs de variables dans le moniteur série Arduino, initialisez la communication série avec Serial.begin(), puis envoyez chaque valeur avec Serial.print() ou Serial.println(). Des appels successifs à Serial.print() continuent d’écrire sur la ligne en cours ; Serial.println() termine la valeur par un saut de ligne. Ajoutez du texte entre les valeurs pour rendre le résultat plus lisible. Réglez le moniteur série sur le même débit que celui utilisé par Serial.begin().

L’exemple complet ci-dessous montre comment afficher des valeurs séparées sur une même ligne, régler la précision des nombres à virgule flottante, afficher des valeurs sur des lignes distinctes et faire varier une paire de valeurs. Une petite couche d’adaptation pour l’hôte permet d’exécuter le même code source en C++ standard : sur une carte Arduino, le cœur de la carte fournit Serial et delay() ; sur un ordinateur, cette couche écrit sur la sortie standard et exécute deux itérations d’exemple. Lorsque vous utilisez une carte, réglez le moniteur série sur le même débit que Serial.begin().

Afficher plusieurs valeurs sur une même ligne avec Serial.print()

Serial.print() convertit une valeur en texte et l’écrit sans ajouter de saut de ligne. Appelez cette fonction successivement pour chaque champ et affichez un séparateur entre les champs. L’exemple utilise une tabulation ("\t") entre une mesure de température et une mesure d’humidité : la sortie contient donc un caractère de tabulation, et non les deux caractères visibles barre oblique inverse et t.

Pour les nombres à virgule flottante, le deuxième argument facultatif indique le nombre de chiffres à afficher après la virgule. Ici, Serial.print(temperature, 2) demande deux chiffres après la virgule. Cela modifie le format affiché, mais pas la valeur stockée dans la variable. Un appel final à Serial.println() termine la ligne. L’argument facultatif de précision s’applique au formatage des nombres à virgule flottante ; les nombres entiers s’affichent sans décimales.

Afficher les valeurs sur des lignes distinctes avec Serial.println()

Utilisez Serial.println(value) lorsque chaque valeur doit commencer sur sa propre ligne. La fonction écrit la valeur, puis un saut de ligne : des appels successifs créent donc une liste verticale. Dans le programme, le libellé et sa valeur restent ensemble, car chaque libellé est affiché avec Serial.print() et la valeur correspondante avec Serial.println().

Ouvrez le moniteur série à 9 600 bauds pour qu’il corresponde à Serial.begin(9600). Si le moniteur utilise un débit différent, les caractères reçus peuvent sembler brouillés, même si le programme envoie les valeurs attendues. Chaque appel à Serial.println() écrit la valeur suivie d’un saut de ligne ; l’appel suivant commence donc sur une nouvelle ligne.

Combiner les deux fonctions pour afficher des valeurs changeantes

Pour afficher des mesures répétées, utilisez Serial.print() pour la première valeur et un séparateur, puis Serial.println() pour la dernière valeur de la ligne. La boucle ci-dessous affiche une paire de valeurs qui change, avec une tabulation entre les valeurs et un saut de ligne après chaque paire. Elle augmente la valeur d’humidité avant l’itération suivante ; la deuxième valeur reste toujours supérieure de cinq. Sur une carte, la boucle se répète et marque une courte pause entre les lignes. La couche d’adaptation pour l’hôte exécute deux itérations afin de rendre le changement visible. Les sections précédentes sur l’affichage sur une même ligne et sur des lignes distinctes renvoient à cet exemple complet, qui regroupe les déclarations de variables et l’initialisation série.

Lorsque vous adaptez le programme, conservez le même ordre de champs et le même séparateur si un autre programme doit analyser les lignes ; toute modification de l’un ou de l’autre peut affecter ce programme. La couche d’adaptation pour l’hôte montre uniquement le formatage : elle ne simule ni une carte ni le moniteur série.

Les libellés et les sorties visibles dans l’exemple restent en anglais, car le bloc de code et sa sortie sont conservés à l’identique.

Exécutez cet exemple. La couche d’adaptation pour l’hôte écrit sur la sortie standard ; sur une carte, le cœur Arduino fournit les mêmes appels à Serial et la fonction loop() qui se répète.

#ifndef ARDUINO
#include <iostream>
class HostSerial {
public:
  void begin(unsigned long) {}
  void print(const char* value) { std::cout << value; }
  void print(int value) { std::cout << value; }
  void print(double value, int digits = 2) {
    std::cout.setf(std::ios::fixed);
    std::cout.precision(digits);
    std::cout << value;
    std::cout.unsetf(std::ios::fixed);
  }
  void println(const char* value) { print(value); std::cout << '\n'; }
  void println(int value) { print(value); std::cout << '\n'; }
  void println(double value, int digits = 2) { print(value, digits); std::cout << '\n'; }
};
HostSerial Serial;
void delay(unsigned long) {}
#endif

int humidity = 40;

void setup() {
  Serial.begin(9600);
}

void loop() {
  float temperature = 23.456;

  Serial.print("Temperature: ");
  Serial.print(temperature, 2);
  Serial.print("\t");
  Serial.print("Humidity: ");
  Serial.println(humidity);

  Serial.print("Temperature on its own line: ");
  Serial.println(temperature, 2);
  Serial.print("Humidity on its own line: ");
  Serial.println(humidity);

  int first = humidity;
  int second = humidity + 5;
  Serial.print(first);
  Serial.print("\t");
  Serial.println(second);

  humidity++;
  delay(1000);
}

#ifndef ARDUINO
int main() {
  setup();
  loop();
  loop();
}
#endif

Temperature: 23.46	Humidity: 40
Temperature on its own line: 23.46
Humidity on its own line: 40
40	45
Temperature: 23.46	Humidity: 41
Temperature on its own line: 23.46
Humidity on its own line: 41
41	46