Lavorare con Serial.
Serial.begin(speed);
Avvia la comunicazione seriale a velocità (baud rate, bit al secondo). Elenco velocità per monitor porta IDE Arduino: 300, 1200, 2400, 4800, 9600 (più comunemente usato, può essere definito standard per la maggior parte dei dispositivi con comunicazione TTL), 19200, 38400, 57600, 115200 (è anche comune), 230400, 250000, 500000,
1000000, 2000000.
Serial.end();
Termina la comunicazione su Seriale. Per UNO/NANO (ATmega328) ciò consente di liberare i pin 0 e 1 per scopi normali (lettura/scrittura).
Serial.available();
Restituisce il numero di byte memorizzati nel buffer (dimensione del buffer 64 byte) e disponibili per la lettura.
Serial.availableForWrite();
Restituisce il numero di byte che possono essere scritti nel buffer della porta seriale senza bloccare la funzione di scrittura.
Serial.write(val);, Serial.write(buf, len);
Invia un valore numerico o una stringa alla porta: val o invia un numero di len byte dal buffer buf. Importante! Invia i dati come byte (vedi tabella ASCII), ovvero inviando 88 otterrà la lettera X: Serial.write(88); stamperà la lettera X.
Serial.print(val);, Serial.print(val, format);
Invia un valore val, un numero o una stringa, alla porta. A differenza della write, restituisce esattamente i caratteri, ad es. inviando 88 otterrai 88: Serial.print(88); visualizzerà 88.
Serial.print(78); // visualizzerà 78.
Serial.print(1.23456); // 1.23 (predefinito 2 caratteri).
Serial.print('N'); // visualizzerà
N.
Serial.print("Hello world."); // Hello world.
// puoi fare output formattato.
Serial.print("i have " + String(50) + " apples");
// visualizzerà
la stringa i have 50 apples.
// variabili invece di numeri.
byte appls = 50;
Serial.print("i have " + String(appls) + " apples");
// verrà visualizzato come prima.
format consente di personalizzare l'output dei dati: BIN, OCT, DEC, HEX visualizzeranno il numero nel sistema numerico corrispondente e il numero dopo l'output float consente di configurare il numero di caratteri di output dopo il punto.
Serial.print(78, BIN); // output "1001110"
Serial.print(78, OTT); // output "116"
Serial.print(78, DEC); // output "78"
Serial.print(78, HEX); // uscita "4E"
Serial.print(1.23456, 0); // output "1"
Serial.print(1.23456, 2); // output "1.23"
Serial.print(1.23456, 4); // output "1.2345"
Serial.println();, Serial.println(val);, Serial.println(val, format);
Un completo analogo di print(), ma passa automaticamente la riga dopo l'output. Permette anche di essere chiamato senza argomenti (con parentesi vuote) solo per le nuove righe.
Serial.flush();
In attesa della fine del trasferimento dei dati.
Serial.peek();
Restituisce il byte corrente dal bordo del buffer senza rimuoverlo dal buffer. Quando si chiama Serial.read();, verrà letto lo stesso byte, ma sarà già rimosso dal buffer.
Serial.read();
Legge e restituisce un byte come codice carattere da una tabella ASCII.
Serial.setTimeout(time);
Imposta il timeout (millisecondi) per la ricezione dei dati per le seguenti funzioni. Il valore predefinito è 1000 ms (1 secondo).
Serial.find(target);, Serial.find(target, length);
// будем искать слово hello
char target[] = "hello";
void setup()
{
Serial.begin(9600);
}
void loop()
{
if (Serial.available() > 0)
{
if (Serial.find(target))
Serial.println("found");
// output found se inviato
}
}
Serial.findUntil(target, terminal);
Legge i dati dal buffer e cerca il set di caratteri target (tipo char) o la stringa del terminal. Attende la fine della trasmissione per timeout o termina la ricezione dopo aver letto il terminal.
Serial.readBytes(buffer, length);
Legge i dati dalla porta e li lancia nel buffer (array char [] o byte []), indica anche il numero di byte da scrivere - length (per non sovraccaricare il buffer).
Serial.readBytesUntil(character, buffer, length);
Legge i dati dalla porta e li getta nel buffer (array char [] o byte []), indica anche il numero di byte da scrivere - length (per non sovraccaricare il buffer) e il carattere del character del terminale. La fine della ricezione nel buffer si verifica quando viene raggiunta la quantità di length specificata, quando viene ricevuto un carattere di character terminale (non va al buffer) o per timeout.
Serial.readString();
Legge il buffer della porta e forma una String dai dati, che restituisce. Termina al timeout.
Serial.readStringUntil(terminator);
Legge il buffer della porta e forma una String dai dati, che restituisce. Termina al timeout o dopo aver ricevuto un carattere terminator (carattere char).
Serial.parseInt();, Serial.parseInt(skipChar);
Legge un valore intero dal buffer della porta e lo restituisce (long). Finisce il lavoro in timeout. Interrompe la lettura di tutti i segni tranne il segno - (meno). Puoi anche specificare separatamente il carattere skipChar da saltare, ad esempio una virgoletta di separazione delle migliaia (10'325'685) per accettare un tale numero.
Serial.parseFloat();
Legge un valore in virgola mobile dal buffer della porta e lo restituisce. Termina al timeout.
Per lavorare con Serial, leggi di più qui.