Oggetto Serial.
Iniziamo con uno degli strumenti per sviluppatori Arduino più utili - Serial, che viene fornito con le librerie standard. Serial ti consente di ricevere e inviare semplicemente dati tramite una porta seriale. Eredita interessanti funzionalità dalla classe Stream:
- Serial.begin(speed): Avvia la comunicazione Serial a velocità - speed (misurata in baud, bit al secondo). È possibile impostare qualsiasi velocità, ma esistono diversi valori "standard". Elenco velocità per monitor porta IDE Arduino: 300, 1200, 4800, 9600(più comunemente usato), 19200, 38400, 57600, 115200(spesso si incontra), 230400, 250000, 500000, 1000000, 2000000(velocità massima, non funziona su alcune schede).
- Serial.end(): Termina la comunicazione su Serial. Libera anche i pin RX e TX.
- Serial.available(): Restituisce il numero di byte nel buffer di ricezione 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);.
- Serial.print(val), Serial.print(val, format): Invia un valore val alla porta - un numero o una stringa. A differenza della write mostra il testo, ad es. inviando 88 otterrai 88: Serial.print(88);. Invia qualsiasi tipo di dati standard: numerico, carattere, stringa. Inoltre, i metodi print()/println() hanno diverse impostazioni per dati diversi, il che li rende uno strumento di debug molto utile. formato consente di personalizzare l'output dei dati: BIN, OCT, DEC, HEX visualizzeranno il numero nel sistema numerico corrispondente: binario, ottale, decimale (predefinito) ed esadecimale. La cifra dopo l'output float consente di regolare il numero di caratteri di output dopo il punto.
- Serial.println(), Serial.println(val), Serial.println(val, format): Un analogo completo di print(), ma traduce automaticamente la riga dopo l'output. Permette anche di essere chiamato senza argomenti (con parentesi vuote) solo per spostare il cursore su una nuova riga.
- 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 verrà rimosso dal buffer.
- Serial.read(): Legge e restituisce l'ultimo carattere dal buffer.
- Serial.setTimeout(time): Imposta time (millisecondi) il timeout per la ricezione dei dati per le seguenti funzioni. Il valore predefinito è 1000 ms (1 secondo).
- Serial.find(target), Serial.find(target, length): Legge i dati dal buffer e cerca il set di caratteri target (tipo char), opzionalmente puoi specificare la lunghezza length. Restituisce true se trova i caratteri specificati. In attesa di trasmissione per timeout.
- Serial.findUntil(target, terminal): Legge i dati dal buffer e cerca il set di caratteri target (tipo char) o la stringa del terminale terminal. Attende la fine della trasmissione entro il timeout o termina la ricezione dopo aver letto terminal.
- Serial.readBytes(buffer, length): Legge i dati dalla porta e li inserisce in un buffer (un array di char[] o byte[]). Viene indicato anche il numero di byte da scrivere - length (per non overflow del 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 terminale character. La fine della ricezione nel buffer si verifica quando viene raggiunto il numero di length specificato, quando viene ricevuto un carattere terminale character (non va nel buffer) o per timeout.
- Serial.readString(): Legge la porta, forma una String dai dati e la restituisce. Finisce il lavoro in timeout.
- Serial.readStringUntil(terminator): Legge la porta, forma una String di dati e la restituisce. Termina al timeout o dopo aver ricevuto il carattere terminator (carattere char).
- Serial.parseInt(), Serial.parseInt(skipChar): Legge un valore intero dalla porta e lo restituisce (tipo 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 ignorare, ad esempio la virgoletta di separazione delle migliaia (10'325'685) per accettare tale numero.
- Serial.parseFloat(): Legge un valore in virgola mobile dalla porta e lo restituisce. Finisce il lavoro in timeout.
Esempi:
Serial.print(val);
Serial.print(32); // visualizza 32
Serial.print(3.14); // 3.14 (predefinito 2 caratteri)
Serial.print('A'); // visualizza A
Serial.print("Hello world."); //visualizza
Hello world.
// puoi fare output formattato.
Serial.print("Electron" + String(32)); // stampa la stringa Electron32
// È possibile utilizzare variabili al posto dei numeri.
byte number = 32;
Serial.print("Electron" + String(number)); //restituisce lo stesso.
Serial.print(val, format);
Serial.print(32, BIN); // visualizza
"100000"
Serial.print(32, OCT); // visualizza
"40"
Serial.print(32, DEC); // visualizza
"32"
Serial.print(32, HEX); // visualizza
"20"
Serial.print(3,14159, 0); // visualizza
"3"
Serial.print(3,14159, 2); // visualizza
"3,14
"
Serial.print(3,14159, 4); // visualizza
"3,1415"
Serial.find(target);
// cercheremo la parola ciao.
char target[] = "ciao";
void setup()
{
Serial.begin(9600);
}
void loop()
{
if (Serial.available() > 0)
{
if (Serial.find(target)) //restituisce true se trova i caratteri specificati.
Serial.println("trovato"); //visualizza trovato
}
}
Serial.available();
Serial.readString();
void setup()
{
Serial.begin(9600);
}
void loop()
{
if (Serial.available()) //la lettura verrà eseguita solo se sono presenti dei dati nel buffer.
{
String str = Serial.readString(); //legge la porta, forma una String dai dati...
Serial.println(str); //...e la restituisce.
}
}