Arduino stampa seriale di variabili multiple

Per visualizzare i valori di più variabili nel Monitor seriale di Arduino, inizializza la comunicazione seriale con Serial.begin() e invia ogni valore con Serial.print() o Serial.println(). Le chiamate successive a Serial.print() continuano a scrivere sulla riga corrente; Serial.println() termina il valore con un’interruzione di riga. Inserisci del testo tra i valori per rendere il risultato più leggibile. Imposta il Monitor seriale alla stessa velocità di trasmissione usata da Serial.begin().

L’esempio completo qui sotto mostra valori separati sulla stessa riga, la precisione dei numeri in virgola mobile, valori su righe distinte e una coppia di valori che cambia. Un piccolo adattatore per l’esecuzione sul computer permette di compilare lo stesso sorgente come C++ standard: su Arduino, il core della scheda fornisce Serial e delay(); sul computer, l’adattatore scrive sull’output standard ed esegue due iterazioni di esempio. Quando usi una scheda, imposta il Monitor seriale alla stessa velocità di trasmissione indicata in Serial.begin().

Stampare più valori sulla stessa riga con Serial.print()

Serial.print() converte un valore in testo e lo scrive senza aggiungere un’interruzione di riga. Chiamala in successione per ogni campo e stampa un separatore tra un campo e l’altro. L’esempio usa una tabulazione ("\t") tra una lettura della temperatura e una dell’umidità: nell’output compare quindi un carattere di tabulazione, non i due caratteri visibili barra rovesciata e t.

Per i valori in virgola mobile, il secondo argomento facoltativo specifica quante cifre mostrare dopo il separatore decimale. In questo caso, Serial.print(temperature, 2) richiede due cifre decimali. Modifica la formattazione visualizzata, non il valore memorizzato nella variabile. Una chiamata finale a Serial.println() conclude la riga. L’argomento facoltativo della precisione si applica alla formattazione dei valori in virgola mobile; i valori interi vengono stampati senza cifre decimali.

Stampare i valori su righe separate con Serial.println()

Usa Serial.println(value) quando vuoi che ogni valore inizi su una riga propria. La funzione scrive il valore e poi un’interruzione di riga, perciò chiamate successive producono un elenco verticale. Nello sketch, l’etichetta resta sulla stessa riga del valore corrispondente: per ogni etichetta si usa Serial.print() e per il relativo valore Serial.println().

Apri il Monitor seriale a 9600 baud, come indicato da Serial.begin(9600). Se il monitor usa una velocità diversa, i caratteri ricevuti possono risultare illeggibili anche se lo sketch invia i valori previsti. Ogni chiamata a Serial.println() scrive il valore seguito da un’interruzione di riga, quindi la chiamata successiva inizia una nuova riga.

Combinare le due funzioni per formattare valori che cambiano

Per visualizzare letture ripetute, usa Serial.print() per il primo valore e un separatore, poi Serial.println() per l’ultimo valore della riga. Il ciclo qui sotto stampa una coppia di valori che cambia, con una tabulazione tra i valori e un’interruzione di riga dopo ogni coppia. Prima dell’iterazione successiva incrementa il valore dell’umidità; il secondo valore è sempre cinque unità maggiore del primo. Su una scheda, il ciclo si ripete e fa una breve pausa tra le righe. L’adattatore per l’esecuzione sul computer esegue due iterazioni, così da rendere visibile il cambiamento dei valori. Le sezioni precedenti sulla stampa sulla stessa riga e su righe separate fanno riferimento a questo unico esempio completo, che mantiene le dichiarazioni delle variabili e l’inizializzazione seriale in un solo punto.

Quando adatti lo sketch, mantieni coerenti l’ordine dei campi e il delimitatore se un altro programma deve elaborare le righe: modificarli può influire su quel programma. L’adattatore per il computer mostra solo la formattazione; non simula una scheda né il Monitor seriale.

Esegui questo esempio. L’adattatore per il computer scrive sull’output standard; su una scheda, il core Arduino fornisce le stesse chiamate a Serial e il ciclo loop() ripetuto.

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

#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