Padroneggiare la comunicazione seriale con Arduino

Quando si lavora su grandi progetti Arduino, è abbastanza comune esaurire i pin disponibili per collegare i componenti. Supponi di voler collegare più sensori/attuatori con l'urgente necessità di conservare ancora pin extra per alimentare un modulo display affamato di pin.

A meno che tu non faccia qualche magia, a volte è difficile gestire tutte queste connessioni su una singola scheda Arduino, specialmente quando decidi di utilizzare schede più piccole perché hai poco spazio. È qui che entra in gioco la comunicazione seriale.

Esploriamo cos'è la comunicazione seriale e i modi in cui è possibile configurarla con Arduino per attività come l'elaborazione distribuita e l'integrazione generale.

Cos'è la comunicazione seriale?

La comunicazione seriale è un metodo di invio e ricezione di dati tra due o più dispositivi elettronici, un bit alla volta su un'unica linea di comunicazione. Come suggerisce il nome, i dati vengono inviati in "serie

".

Anche solo essere in grado di caricare schizzi sulla tua scheda Arduino preferita utilizza la comunicazione seriale tramite USB.

Protocolli di comunicazione seriale su Arduino

Le schede Arduino sono incredibilmente versatili e possono comunicare con una vasta gamma di dispositivi. Supportano quattro protocolli di comunicazione seriale: Soft Serial, SPI (Serial Peripheral Interface), UART standard (Universal Asynchronous Receiver-Transmitter) e I2C (Inter-Integrated Circuit). Per maggiori dettagli, consulta la nostra guida completa su come funzionano le comunicazioni seriali UART, SPI e I2C.

Questo tutorial utilizza schizzi di base per mostrare come impostare una connessione seriale tra due schede Arduino Uno utilizzando vari protocolli. Adatta il codice per soddisfare i tuoi requisiti specifici.

SPI (interfaccia periferica seriale)

SPI è un protocollo di comunicazione seriale sincrono che consente la comunicazione ad alta velocità tra microcontrollori e dispositivi periferici. Questo protocollo richiede quattro fili per la comunicazione: SCK (orologio seriale), MOSI (Master Out Slave In), MISO (Master In Slave Out), e SS (Selezione schiavo).

IL SPI.h library è molto utile per questo tipo di comunicazione e deve essere inclusa nella parte superiore del tuo sketch.

#includere

Ecco i pin SPI sulla scheda Arduino Uno:

Dopo aver inizializzato la comunicazione seriale, dovrai configurare i pin di comunicazione.

vuotoimpostare(){
SPI.inizio(115200);
// Imposta le modalità pin per SS, MOSI, MISO e SCK
pinMode(SS, PRODUZIONE);
pinMode(MOSI, PRODUZIONE);
pinMode(MISO, INGRESSO);
pinMode(SCK, PRODUZIONE);
// Imposta il pin di selezione slave (SS) alto per disabilitare il dispositivo slave
digitalWrite(SS, ALTO);
}

Il segnale SS viene utilizzato per comunicare al dispositivo slave quando i dati vengono trasferiti.

// Seleziona lo schiavo
digitalWrite(SS, BASSO);
// Invia i dati al dispositivo slave
SPI.trasferimento(dati);
// Deseleziona il dispositivo slave
digitalWrite(SS, ALTO);

Ecco come collegare due schede Arduino usando SPI.

Codice per la scheda master:

#includere
costint slaveSelectPin = 10;
vuotoimpostare(){
SPI.inizio(115200);
pinMode(slaveSelectPin, PRODUZIONE);
}
vuotociclo continuo(){
digitalWrite(slaveSelectPin, BASSO);
SPI.trasferimento('H');
digitalWrite(slaveSelectPin, ALTO);
ritardo(1000);
}

Codice per la scheda slave:

#includere
costint slaveSelectPin = 10;
vuotoimpostare(){
SPI.inizio(115200);
pinMode(slaveSelectPin, PRODUZIONE);
}
vuotociclo continuo(){
Se (digitaleLeggi(slaveSelectPin) == BASSO) {
char ricevutiDati = SPI.trasferimento('L');
Seriale.println(Dati ricevuti);
 }
}

Assicurati che i tuoi dispositivi condividano un terreno comune per una corretta configurazione.

UART (ricevitore-trasmettitore asincrono universale)

UART è un protocollo di comunicazione seriale asincrono che consente la comunicazione tra dispositivi utilizzando solo due fili: TX (trasmissione) e RX (ricezione). UART è comunemente usato per la comunicazione con dispositivi come moduli GPS, moduli Bluetooth e altri microcontrollori. Ogni scheda Arduino è dotata di almeno una porta per UART.

I pin UART sulle popolari schede Arduino includono:

Puoi ottenere il tavolo completo da La documentazione online di Arduino sulla comunicazione seriale.

Innanzitutto, collega le tue schede in questo modo:

Quindi utilizzare questo codice per la scheda mittente:

vuotoimpostare(){
Seriale.inizio(9600);
}
vuotociclo continuo(){
// Invia un messaggio via seriale ogni secondo
Seriale.println("Ciao dalla bacheca del mittente!");
ritardo(1000);
}

Codice per la scheda ricevente:

vuotoimpostare(){
Seriale.inizio(9600);
}
vuotociclo continuo(){
// Controlla se ci sono dati in entrata
Se (Seriale.disponibile() > 0) {
// Legge i dati in arrivo e li stampa sul monitor seriale
Corda dati in arrivo = Seriale.readString();
Seriale.println(Dati in entrata);
 }
}

L'Arduino Uno funziona su un livello logico 5V mentre la porta RS232 di un computer utilizza un livello logico +/-12V.

Il collegamento diretto di un Arduino Uno a una porta RS232 può e danneggerà la tua scheda.

I2C (circuito inter-integrato)

I2C è un protocollo di comunicazione seriale sincrono che consente la comunicazione tra più dispositivi utilizzando solo due fili: SDA (Serial Data) e SCL (Serial Clock). I2C è comunemente utilizzato per la comunicazione con sensori, EEPROM e altri dispositivi che devono trasferire dati su brevi distanze.

I pin I2C su Arduino Uno lo sono SDA (A4) E SCL (A5).

Creeremo un semplice programma per stabilire una connessione tra due schede Arduino utilizzando la comunicazione I2C. Ma prima, collega le tue schede in questo modo:

Codice per la scheda master:

#includere
vuotoimpostare(){
Filo.inizio(); // unisciti al bus I2C come master
Seriale.inizio(9600);
}
vuotociclo continuo(){
Filo.beginTransmission(9); // trasmette al dispositivo slave con indirizzo 9
Filo.scrivere('UN'); // invia 'a' byte al dispositivo slave
Filo.endTransmission(); // interrompe la trasmissione
ritardo(500);
}

Codice per la scheda slave:

#includere
vuotoimpostare(){
Filo.inizio(9); // entra nel bus I2C come slave con indirizzo 9
Filo.onRicevi(ricevereEvento);
Seriale.inizio(9600); 
}
vuotociclo continuo(){
ritardo(100);
}
vuotoricevereEvento(int byte){
Mentre(Filo.disponibile()) { // scorre tutti i byte ricevuti
char byte ricevuto = Filo.Leggere(); // legge ogni byte ricevuto
Seriale.println(ricevutoByte); // stampa il byte ricevuto sul monitor seriale
 }
}

Cos'è SoftwareSerial?

La libreria Arduino SoftwareSerial è stata sviluppata per emulare la comunicazione UART, consentendo la comunicazione seriale attraverso due pin digitali qualsiasi sulle schede Arduino. È utile quando l'UART hardware è già utilizzato da altri dispositivi.

Per impostare SoftwareSerial, includi prima la libreria SoftwareSerial nello sketch.

#includere

Quindi creare un'istanza dell'oggetto SoftwareSerial specificando il file RX E TX pin da utilizzare per la comunicazione.

SoftwareSerialmySerial(2, 3); // Pin RX, TX

Ecco un codice di esempio per Arduino che dimostra l'uso di SoftwareSerial:

#includere
SoftwareSerialmySerial(2, 3); // Pin RX, TX
vuotoimpostare(){
Seriale.inizio(9600); // avvia la seriale hardware
 mySerial.inizio(9600); // avvia il soft seriale
}
vuotociclo continuo(){
Se (mioSerial.disponibile()) {
Seriale.scrivere(mioSerial.Leggere()); // invia i dati ricevuti alla seriale hardware
 }
Se (Seriale.disponibile()) {
 mySerial.scrivere(Seriale.Leggere()); // invia i dati dalla seriale hardware alla seriale software
 }
}

La Biblioteca Seriale

La libreria seriale è un potente strumento in Arduino che consente la comunicazione tra il microcontrollore e un computer o altri dispositivi tramite una connessione seriale. Alcune funzioni comuni includono:

Velocità di trasmissione e formato dei dati seriali

La velocità di trasmissione si riferisce alla velocità con cui i dati vengono trasferiti tramite la connessione seriale. Rappresenta il numero di bit trasmessi al secondo. La velocità di trasmissione deve essere impostata allo stesso modo su entrambi i dispositivi mittente e destinatario, altrimenti la comunicazione potrebbe essere confusa o non funzionare affatto. Le velocità di trasmissione comuni per Arduino includono 9600, 19200, 38400 e 115200.

Il formato dei dati seriali si riferisce alla struttura dei dati inviati tramite la connessione seriale. Ci sono tre componenti principali nel formato dei dati seriali: bit di inizio, bit di dati e bit di stop.

• Bit di dati: il numero di bit utilizzati per rappresentare un singolo byte di dati.
• Parità: Un bit facoltativo utilizzato per il controllo degli errori. Può essere impostata su nessuna, parità pari o dispari, a seconda dei requisiti del canale di comunicazione.
• Bit di arresto: il numero di bit utilizzati per segnalare la fine di un byte di dati.

Il formato dei dati deve essere lo stesso su entrambi i dispositivi di trasmissione e ricezione per garantire una comunicazione corretta. Di seguito è riportato un esempio di come è possibile impostare formati di dati specifici:

vuotoimpostare(){
// Imposta la comunicazione seriale con 9600 baud rate, 8 bit di dati, nessuna parità e 1 bit di stop
Seriale.inizio(9600, SERIALE_8N1); 
}

Qui, SERIALE_8N1 rappresenta il formato dei dati con 8 bit di dati, nessuna parità e 1 fermati un po'. Altre opzioni come SERIALE_7E1, SERIALE_8O2, ecc., possono essere utilizzati a seconda dei requisiti specifici del progetto.

Discorsi seriali

Le schede Arduino forniscono varie opzioni di comunicazione seriale che consentono uno scambio di dati efficiente e affidabile tra i dispositivi. Comprendendo come impostare i protocolli di comunicazione seriale sull'IDE di Arduino, puoi sfruttare la potenza dell'elaborazione distribuita o ridurre notevolmente il numero di cavi utilizzati nei tuoi progetti.