HOWTO · Arduino

Arduino stampa la nuova linea

È possibile stampare una nuova riga utilizzando la funzione Serial.print() o Serial.println().

In questa pagina

Per stampare una nuova riga in uno sketch Arduino, chiama Serial.println() dopo il testo o il valore che deve terminare la riga. Usa Serial.print() quando il valore successivo deve continuare sulla stessa riga. Puoi anche passare il carattere di nuova riga \n a Serial.print() per terminare esplicitamente una riga. Avvia la comunicazione seriale con Serial.begin(9600) in setup() prima di inviare dati.

Usa Serial.println() per terminare una riga

Serial.println() scrive il proprio argomento e poi aggiunge un terminatore di riga. Ogni chiamata fa quindi iniziare l’output successivo dopo la fine della riga precedente. È utile per mostrare letture separate, messaggi di stato e altri valori che risultano più facili da leggere uno per riga.

L’esempio C++ autonomo qui sotto usa una piccola implementazione sostitutiva di Serial, così è possibile controllare il testo acquisito senza una scheda Arduino. Su una scheda, il core Arduino fornisce Serial e richiama setup(); le chiamate dello sketch mostrate qui sono le stesse da usare sulla scheda. Esegui questo esempio:

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

#include <cassert>
#include <string>

class SerialPort {
 public:
  std::string data;

  void begin(unsigned long) {}
  void print(const char* value) { data += value; }
  void print(char value) { data += value; }
  void println(const char* value) { data += value; data += '\n'; }
  void println(int value) { data += std::to_string(value); data += '\n'; }
};

SerialPort Serial;

void setup() {
  Serial.begin(9600);
  Serial.println("Arduino is ready");
}

int main() {
  setup();
  assert(Serial.data == "Arduino is ready\n");
}

L’implementazione sostitutiva registra il testo e l’asserzione verifica che println() aggiunga un terminatore di riga. Questo è un modello C++ delle chiamate, non il firmware di una scheda. Il caso di esecuzione fornito è terminato con codice 0 e stdout vuoto: l’asserzione controlla il testo acquisito senza stamparlo su stdout.

Aggiungi un terminatore di riga con Serial.print()

Serial.print() lascia il cursore di output dopo i caratteri scritti. Per terminare esplicitamente quella riga, passa il carattere di nuova riga \n come carattere letterale dopo il testo precedente. In uno sketch, le chiamate sono Serial.print("Arduino is ready"); seguita da Serial.print('\n');. La prima scrive il messaggio; la seconda scrive un’interruzione di riga.

In C++, gli apici singoli indicano un carattere, come '\n', mentre le virgolette doppie indicano una stringa, come "Arduino is ready". La distinzione è importante: il carattere di nuova riga è un singolo carattere, mentre "\n" è una stringa che contiene quel carattere.

Stampa più valori su righe diverse

Puoi combinare le chiamate per affiancare un’etichetta e un valore, quindi terminare la riga con Serial.println(). Per esempio, usa Serial.print("Temperature: "); seguito da Serial.println(temperature);, poi ripeti con Serial.print("Humidity: "); e Serial.println(humidity);. Dichiara nello sketch i valori, ad esempio int temperature = 25; e int humidity = 60;, prima di usarli.

Ogni chiamata a Serial.print() scrive un’etichetta senza terminare la riga. La successiva chiamata a Serial.println() scrive il valore della variabile e termina quella riga. È possibile passare direttamente una variabile; le scelte di formattazione numerica sono indipendenti dal comportamento del terminatore di riga. Queste chiamate aggiuntive sono mostrate nel testo, non in un secondo programma, quindi l’articolo non dichiara che siano state eseguite.

Scegli il metodo giusto per l’output seriale

Usa Serial.println(value) quando ogni messaggio o lettura deve occupare una riga distinta. Usa Serial.print(value) per comporre una riga con più parti, poi chiama Serial.println() oppure Serial.print('\n') quando la riga è completa. Serial.begin(9600) va inserito in setup() per inizializzare la comunicazione seriale prima che lo sketch scriva sulla porta seriale.

Un approccio pratico consiste nello stampare un’etichetta con Serial.print(), stamparne il valore con Serial.println() e ripetere per la lettura successiva. In questo modo etichette e valori restano insieme e le letture successive sono più facili da consultare nel Monitor seriale. Il caso di esecuzione fornito per il modello C++ autonomo è terminato con codice 0 e stdout vuoto; verifica il testo acquisito con un’asserzione invece di mostrarlo su stdout.