Raspberry Pi Arduino Comunicazione seriale-Tutto quello che c’è da sapere

BY admin
|

In questo tutorial vi mostrerò come comunicare tra un Raspberry Pi e una scheda Arduino tramite comunicazione seriale.

Innanzitutto, spiegherò rapidamente cos’è la comunicazione seriale. Poi vedrete come impostare l’hardware e il software, e ci tufferemo nel codice Python (Cpp per Arduino). Un esempio di base in un primo momento, che porta ad un’applicazione più completa utilizzando un Raspberry Pi, un Arduino, e altri dispositivi elettronici.

Questo tutorial funziona con una scheda Raspberry Pi 4 (e versioni precedenti: 3B, 3B+) e qualsiasi scheda Arduino. Userò principalmente Arduino Uno ma fornirò maggiori dettagli sulle differenze tra le schede Arduino quando si tratta di comunicazione seriale.

Quando si lavora con dispositivi elettronici, la comunicazione è fondamentale. Ogni dispositivo – oltre a fare bene quello che dovrebbe fare-deve essere in grado di comunicare chiaramente con altri dispositivi. Questa è una delle cose più importanti su cui lavorare per passare da un’applicazione di base a quelle più complesse.

Indice

Cos’è la comunicazione seriale (con UART)

La comunicazione seriale è semplicemente un modo per trasferire dati. I dati verranno inviati in sequenza, un bit alla volta (1 byte = 8 bit), contrariamente alla comunicazione parallela, dove vengono inviati molti bit contemporaneamente.

Protocollo UART

Più specificamente, quando si utilizza seriale con Arduino e Raspberry Pi, si sta utilizzando il protocollo UART. UART significa “Ricezione e trasmissione asincrona universale”.

Si sta imparando come utilizzare Raspberry Pi per costruire i propri progetti?

Scopri Raspberry Pi per i principianti e imparare passo dopo passo.

Fondamentalmente è un protocollo multi-master asincrono basato sulla comunicazione seriale, che ti permetterà di comunicare tra le 2 schede. Sii rassicurato, ci sono librerie che gestiranno tutti i livelli bassi per te.

Multi-master significa che tutti i dispositivi collegati saranno liberi di inviare i dati quando vogliono. Questa è una delle principali differenze con i protocolli master-slave, in cui solo il dispositivo master può avviare una comunicazione. Di solito userai altri protocolli come I2C e SPI quando hai bisogno di configurazioni master-slave: ad esempio quando hai una scheda Arduino e più sensori o attuatori.

La scheda Arduino Uno ha un UART che è possibile utilizzare sia con un cavo USB o dai pin RX / TX (non usarlo con entrambi allo stesso tempo). Alcune schede hanno più UART disponibili. Ad esempio, Arduino Mega ha diversi Serial (Serial, Serial1, Serial2, Serial3) e Arduino Zero ha solo una porta USB nativa (usa SerialUSB invece di Serial).

Sul Raspberry Pi, è possibile collegare molti dispositivi seriali sulle porte USB. Ognuno avrà un nome di dispositivo diverso (vedremo come trovarli più avanti in questo tutorial). Puoi anche usare i GPIO (RX0/TX0) per un UART aggiuntivo.

Probabilmente conosci già la comunicazione seriale

Hai sicuramente già usato la comunicazione seriale molte volte. Sono sicuro che conosci già la libreria seriale Arduino, che ti consente di registrare ciò che sta accadendo nel tuo codice e ottenere l’input dell’utente. Quando usi il monitor seriale, beh, fondamentalmente il tuo IDE Arduino avvia una comunicazione seriale con il tuo Arduino. È possibile ricevere e inviare dati direttamente dal monitor seriale.

Quello che faremo qui è quasi lo stesso, tranne che al posto del tuo IDE Arduino, l’altro lato della comunicazione seriale sarà una scheda Raspberry Pi. Dovremo fare un po ‘ di configurazione e scrivere del codice per farlo funzionare. Quindi, sia Raspberry Pi che Arduino saranno in grado di inviare messaggi l’uno all’altro.

Vediamo ora come collegare fisicamente le 2 schede insieme.

Configurazione hardware per la comunicazione seriale

Ci sono 2 modi per collegare il Raspberry Pi e Arduino per la comunicazione seriale.

Seriale via USB

Il modo più semplice è quello di utilizzare un cavo USB tra entrambe le schede.

Sul lato Raspberry Pi, un semplice connettore USB è tutto ciò che serve. È possibile scegliere una qualsiasi delle 4 porte USB disponibili sulla scheda.

Per Arduino, si utilizzerà la porta USB che si utilizza per caricare il codice dal computer (con l’IDE Arduino) alla scheda. Qui il connettore USB dipenderà dalla versione che hai. Per schede come Arduino Uno e Mega, il connettore sarà diverso da Arduino Nano e da Arduino Zero.

Per questo esempio ho usato una scheda Arduino Uno.

Come puoi vedere, è la connessione hardware più semplice che puoi fare tra Raspberry Pi e Arduino.

Nota: per prima cosa è necessario collegare il vostro Arduino al computer, in modo da poter caricare il codice nella scheda. Successivamente, collegare il cavo USB al Raspberry Pi. Il Raspberry Pi alimenterà l’Arduino tramite questo cavo.

Seriale tramite GPIOs

Per effettuare una connessione seriale è anche possibile utilizzare fili semplici tra i GPIOs Raspberry Pi e i pin Arduino.

A seconda della scheda Arduino potrebbe essere necessario utilizzare un livello di tensione-shifter. Il Raspberry Pi funziona a 3.3 V. Per le schede Arduino come Due, 101, andrà bene perché usano anche 3.3 V.

Ma, per molti Arduino, come Uno, Mega, Leonardo, Nano, e molti altri, la scheda è in funzione a 5 V. Così, avete bisogno di un 3.3 V/5 V level-shifter per proteggere il Raspberry Pi quando si collega RX e TX (maggiori informazioni su Raspberry Pi pin e Arduino Uno pin).

Per il resto di questo tutorial useremo il setup con il cavo USB. Questo sarà più facile da gestire e se non si dispone di una buona ragione non troppo, si dovrebbe preferire utilizzando il cavo USB invece di gpio pianura per la comunicazione seriale.

Raspberry Pi Software setup

Non è necessario alcun setup speciale per Arduino. Basta assicurarsi di aver scaricato e installato l’IDE Arduino.

Ora, sul tuo Raspberry Pi, sono necessarie alcune cose per far funzionare la comunicazione.

Collegare al Raspberry Pi, sia tramite ssh, o dal plugin uno schermo + mouse + tastiera, e aprire un terminale. Se non hai ancora installato un sistema operativo sul tuo Pi, puoi installare Raspbian o Ubuntu molto facilmente su una scheda SD.

Rilevare la scheda Arduino

Quando si collega l’Arduino con un cavo USB, si dovrebbe vedere apparire come /dev/ttyACM0, o /dev/ttyUSB0 (a volte il numero può essere diverso, per esempio /dev/ttyACM1).

Esegui semplicemente ls /dev/tty* e dovresti vederlo. A questo punto, se non siete sicuri di quale dispositivo è la scheda Arduino, è sufficiente scollegare la scheda (rimuovere il cavo USB), ed eseguire ls /dev/tty* di nuovo. In questo modo potrete facilmente individuare il nome del dispositivo seriale del vostro Arduino.

Autorizzazioni hardware per Serial

Inoltre, è possibile aggiungere l’utente al gruppo dialout, per evitare errori come: serial.serialutil.SerialException: impossibile aprire la porta / dev / ttyACM0: Autorizzazione negata: ‘/ dev / ttyACM0’

$ sudo adduser your_username dialout

Questo ti assicurerà di avere accesso ai dispositivi seriali (/dev /ttyACMx,/dev / ttyUSBx, …).

Dopo aver aggiunto te stesso al gruppo dialout, è necessario riavviare il Pi (o almeno logout/login) per applicare la modifica – ulteriori informazioni sulle autorizzazioni hardware Raspberry Pi.

Installare Python Serial library su Raspberry Pi

È necessario installare una libreria per poter utilizzare l’interfaccia seriale con Python.

Per questo tutorial useremo la libreria pySerial (documentazione per Python 3). Per installarlo:

python3 -m pip install pyserial

Questa libreria Python è ben nota e utilizzata in molte applicazioni.

Durante l’installazione, se si ottiene un errore come “/usr/bin/python3: Nessun modulo denominato pip”, è necessario installare prima pip con sudo apt install python3-pip.

Semplice comunicazione seriale da Arduino a Raspberry Pi

Iniziamo con un programma molto semplice.

Codice Arduino

Carica questo codice dal tuo computer al tuo Arduino, usando l’IDE Arduino.

void setup() { Serial.begin(9600);}void loop() { Serial.println("Hello from Arduino!"); delay(1000);}

In primo luogo, abbiamo inizializzare la comunicazione seriale, e scegliere un baud rate, qui 9600. 9600 è un baud rate comunemente usato e anche piuttosto basso. Nelle applicazioni future è possibile utilizzare una velocità di trasmissione di 57600 o anche 115200 senza alcun problema. Per questo tutorial continueremo con 9600.

Ogni secondo facciamo l’Arduino inviare una stringa con seriale.println (). la funzione println () aggiungerà un carattere di nuova riga ‘\n’ alla fine della stringa.

È possibile aprire il monitor seriale per vedere la stringa sul computer.

Raspberry Pi Codice Python 

#!/usr/bin/env python3import serialif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

Quindi, cosa fa questo codice?

#!/usr/bin/env python3import serial

In primo luogo, importiamo la libreria seriale che abbiamo precedentemente installato.

if __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)

La comunicazione seriale viene inizializzata chiamando serial.Serial () insieme ad alcuni parametri:

  • Nome del dispositivo seriale per Arduino: di solito ‘/ dev / ttyACM0’, ‘/dev / ttyUSB0’, o simili.
  • Baud rate: questo parametro è molto importante. Devi usare la stessa velocità di trasmissione di quella che hai usato su Arduino, altrimenti tutto ciò che leggerai e scriverai sarà spazzatura. Quindi, scegliamo 9600 come abbiamo fatto nello schizzo di Arduino.
  • timeout: questo è un timeout per le operazioni di lettura. Qui lo impostiamo su 1 secondo. Significa che quando leggiamo da seriale, il programma non sarà bloccato per sempre se i dati non arrivano. Dopo 1 secondo o la lettura, se non tutti i byte vengono ricevuti, la funzione restituirà i byte già ricevuti.

Quindi, seriale.Serial () restituisce un oggetto che è possibile utilizzare per tutte le operazioni seriali. Lo memorizziamo nella variabile’ ser’.

 ser.flush()

Quindi usiamo la funzione flush (). Questo svuoterà qualsiasi buffer di input e output, quindi eviterà di ricevere o inviare dati strani/non utili/non completi all’inizio della comunicazione.

 while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

In un ciclo infinito (si pensi alla funzione loop() nello schizzo di Arduino), controlliamo se alcuni dati sono disponibili con l’attributo in_waiting (non mettere parentesi, questa non è una funzione). Se sì, possiamo leggere i dati.

La funzione readline () leggerà tutti i byte finché non viene rilevato un carattere di nuova riga.

Se abbiamo appena stampato quello che abbiamo ricevuto avremmo visto b’Hello da Arduino!rn’. Ricevi byte quando leggi da seriale e devi convertire (decodificare) quei byte nel tipo di dati appropriato. Quindi, usiamo decode (‘utf-8’) – puoi anche usare decode (‘ascii’) – per decodificare i dati ricevuti in una stringa.

Infine, la funzione rstrip () è specifica per le stringhe, consente di rimuovere eventuali caratteri finali (nuova riga, ritorno a capo). In questo modo possiamo rimuovere ‘\r’ e ‘\n’ e ottenere una stringa corretta.

Nota: qui leggiamo ogni volta una riga completa. Se si desidera leggere una certa quantità di byte, uno o più, utilizzare la funzione read(size=1).

Test di comunicazione seriale

Ora, scollegare la scheda Arduino dal computer e collegarlo alla scheda Raspberry Pi.

Il codice Arduino è già in esecuzione, non appena è acceso.

Sul Raspberry Pi, rendere eseguibile il file Python e lanciarlo.

$ chmod +x receive_serial_data_from_arduino.py$ ./receive_serial_data_from_arduino.py Hello from Arduino!Hello from Arduino!Hello from Arduino!

Funziona! La stringa inviata da Arduino ogni secondo viene visualizzata sul terminale Raspberry Pi.

Comunicazione seriale bidirezionale tra Raspberry Pi e Arduino

Rendiamo le cose un po ‘ più interessanti. Hai visto come inviare dati da Arduino a Raspberry Pi. In questa parte vedrai come parlare da Raspberry Pi ad Arduino. In questo modo avrai entrambi i lati della comunicazione e sarai in grado di creare programmi che aspettano l’input l’uno dell’altro.

Codice Arduino 

void setup() { Serial.begin(9600);}void loop() { if (Serial.available() > 0) { String data = Serial.readStringUntil('\n'); Serial.print("You sent me: "); Serial.println(data); }}

Qui controlliamo se Arduino ha ricevuto dati con seriale.disponibile(). Questo ti darà il numero di byte già arrivati e memorizzati nel buffer di ricezione.

Se alcuni dati sono arrivati, usiamo Seriale.readStringUntil () con un carattere di nuova riga ‘\ n ‘ per ottenere la riga successiva. Questo è simile alla funzione readline (). Tutti i byte ricevuti fino a ‘\ n ‘ vengono automaticamente convertiti e aggiunti in un oggetto Stringa Arduino.

Quindi, stampiamo i dati che abbiamo ricevuto, con un ulteriore pezzo di testo.

Nota: se si desidera leggere i byte uno per uno, è possibile farlo con il seriale.leggere () funzione. Quindi dovrai convertire questo(quei) byte (s) se necessario: int, String, ecc.

Raspberry Pi Python codice 

#!/usr/bin/env python3import serialimport timeif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: ser.write(b"Hello from Raspberry Pi!\n") line = ser.readline().decode('utf-8').rstrip() print(line) time.sleep(1)

Utilizzare la funzione Pyserial write () per inviare dati al Arduino. Qui puoi vedere che ho aggiunto una ‘ b ‘ prima della stringa da inviare. Questo codificherà la stringa in byte, perché è possibile inviare solo byte tramite seriale. Tutti i dati che non sono un byte o un array di byte devono essere convertiti prima di essere inviati. Se si tenta di inviare la stringa in questo modo, si otterrà questo errore “TypeError: le stringhe unicode non sono supportate, si prega di codificare in byte:’ Ciao da Raspberry Pi!'”

Nota: invece di ser.write(b"Hello from Raspberry Pi!\n") potresti aver scritto ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) o ser.write("Hello from Raspberry Pi!\n".encode('ascii')). Questo farà la stessa cosa. La funzione encode () prenderà la stringa e la codificherà per Seriale.

Inoltre, aggiungiamo un carattere di nuova riga ‘\ n ‘ perché è quello che Arduino dovrebbe terminare la sua lettura con Seriale.readStringUntil (‘\n’).

Quindi, facciamo la stessa cosa di prima: leggiamo una riga, la decodifichiamo in stringa e rimuoviamo qualsiasi carattere finale. Non useremo il ser.in_waiting qui, perché per questa specifica applicazione sappiamo che l’Arduino invierà indietro alcuni dati subito dopo aver ricevuto la stringa. Inoltre, abbiamo un timeout di 1 secondo per evitare di rimanere bloccati su questa linea.

Infine, stampiamo la stringa ricevuta e aspettiamo 1 secondo con il tempo.sleep() prima di inviare la stringa successiva su Seriale.

Test di comunicazione seriale bidirezionale

Sul vostro Raspberry Pi, rendere il vostro file eseguibile Python e lanciarlo.

$ chmod +x bidirectional_serial_communication.py $ ./bidirectional_serial_communication.py You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!

Successo! Arduino ha ricevuto la stringa e l’ha rispedita con qualche parola in più. Poi il Raspberry Pi ha ricevuto e stampato la stringa finale.

Raspberry Pi Arduino Comunicazione seriale: Esempio di applicazione

Ora che sapete come impostare il vostro Arduino e Raspberry Pi per la comunicazione seriale, e scrivere programmi per parlare tra ogni scheda, cerchiamo di creare un’applicazione più complessa.

In questa applicazione, 4 LED e un pulsante saranno collegati alla scheda Arduino.

Il Raspberry Pi e Arduino sarà collegato con un cavo USB e utilizzare la comunicazione seriale per parlare tra di loro.

Ecco il risultato che vogliamo ottenere:

  • Quando viene premuto il pulsante, Arduino invierà una notifica al Raspberry Pi (un semplice byte).
  • Il Raspberry Pi calcolerà quindi un numero intero casuale compreso tra 1 e 4 e lo invierà all’Arduino.
  • L’Arduino accenderà il LED relativo a questo numero e spegnerà gli altri LED.

Questo vi farà pratica sulla comunicazione e la sincronizzazione delle attività tra Arduino e Raspberry Pi.

Se sei arrivato a questo punto del tutorial (congratulazioni!) Ti incoraggio a provare a scrivere il codice da solo prima di leggere il codice che ho fornito di seguito. Inoltre, non esiste un solo codice possibile per soddisfare tali requisiti, quindi il tuo codice potrebbe essere diverso dal mio, è totalmente OK. È possibile ottenere aiuto dal riferimento seriale Arduino e dal riferimento API pySerial.

Schemi

Per fare questo circuito:

  • Collegare 4 LED ai pin 9-12. Aggiungere un resistore da 220 Ohm per ogni LED tra la gamba più lunga e il pin digitale. La gamba più corta è collegata a terra.
  • Aggiungere un pulsante con un resistore da 10kOhm collegato a terra (resistenza di pull-down). Un lato del pulsante è collegato a 5V, l’altro al pin digitale 5 per la lettura.
  • Non dimenticare di fare un terreno comune tra tutti i componenti: la scheda Arduino, i 4 LED e il pulsante. Non aggiungere alcun alimentatore se non hai almeno collegato correttamente i motivi.
  • Collegare Arduino e Raspberry Pi tramite un cavo USB, per la comunicazione seriale (il cavo USB gestisce già il collegamento a terra tra le 2 schede).

Codice Arduino 

#define LED_1_PIN 9#define LED_2_PIN 10#define LED_3_PIN 11#define LED_4_PIN 12#define BUTTON_PIN 5byte lastButtonState = LOW;byte currentButtonState = LOW;unsigned long lastButtonDebounceTime = 0;unsigned long buttonDebounceDelay = 20;void powerOffAllLEDs(){ digitalWrite(LED_1_PIN, LOW); digitalWrite(LED_2_PIN, LOW); digitalWrite(LED_3_PIN, LOW); digitalWrite(LED_4_PIN, LOW);}void setup(){ Serial.begin(9600); pinMode(LED_1_PIN, OUTPUT); pinMode(LED_2_PIN, OUTPUT); pinMode(LED_3_PIN, OUTPUT); pinMode(LED_4_PIN, OUTPUT); pinMode(BUTTON_PIN, INPUT); powerOffAllLEDs();}void loop(){ byte readValue = digitalRead(BUTTON_PIN); if (readValue != lastButtonState) { lastButtonDebounceTime = millis(); } if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } } } lastButtonState = readValue; if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }}

Nella funzione setup() inizializziamo le modalità pin per tutti e 4 i LED e il pulsante. Ci assicuriamo inoltre che tutti i LED siano spenti.

Poi nel loop() facciamo 2 cose: gestire il pulsante e gestire i 4 LED. Entrambe le azioni sono fatte una per una, ma sono gestite molto velocemente, quindi è come se stessero accadendo allo stesso tempo. Questo è un caso di multitasking di un programma Arduino.

Prima azione: manipolazione del pulsante.

byte readValue = digitalRead(BUTTON_PIN);if (readValue != lastButtonState) { lastButtonDebounceTime = millis();}if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } }}lastButtonState = readValue;

Dobbiamo debounce il pulsante per evitare valori indesiderati. Quando scopriamo che il pulsante è premuto, possiamo inviare alcuni dati al Raspberry Pi via seriale.

Qui ho usato il seriale.funzione write (): invia un byte o una serie di byte. Questo è diverso dal seriale.print () che renderà l’output piacevole da vedere sul monitor seriale. Mentre stiamo parlando con un’altra macchina e non un essere umano, nessun problema con quello.

Il numero che inviamo qui è 18. Questo è solo un numero casuale che assoceremo allo stato “il pulsante è stato premuto”, quindi quando il Raspberry Pi riceverà un numero, controllerà se è uguale a 18. Si potrebbe immaginare l’invio di azioni o messaggi diversi tramite seriale, utilizzando numeri diversi.

Nota: di solito è anche possibile utilizzare Arduino interrupt per sapere quando un pulsante è stato premuto. In tal caso, non utilizzare la libreria seriale nell’interrupt. Se devi assolutamente usare gli interrupt, imposta un flag all’interno dell’interrupt (una semplice variabile booleana) e usa Serial all’interno della funzione loop ().

E la seconda azione: gestire i 4 LED.

 if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }

Per prima cosa controlliamo se Arduino ha ricevuto alcuni dati dal Raspberry Pi sulla comunicazione seriale.

Se sì, leggiamo il byte successivo con Seriale.leggere(). Qui puoi notare un piccolo trucco, consistente nel sottrarre con ‘0’, che convertirà il carattere nel numero che rappresenta – in questo caso un numero intero.

Dopo di che è abbastanza semplice. Spegniamo tutti i LED, quindi accendiamo solo il LED associato al numero: 1, 2, 3 o 4. Nel caso in cui un valore errato viene inviato, nessun LED sarà acceso.

Raspberry Pi Codice Python 

#!/usr/bin/env python3import serialimport randomif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: number = ser.read() if number != b'': if int.from_bytes(number, byteorder='big') == 18: led_number = random.randint(1,4) print("Button has been pressed.") print("Sending number " + str(led_number) + " to Arduino.") ser.write(str(led_number).encode('utf-8'))

Per prima cosa aggiungiamo una riga di importazione: la libreria casuale Python.

Nel ciclo infinito (“while True”), leggiamo prima un byte dal seriale. Il timeout è impostato su 1 secondo. Se non viene ricevuto nulla dopo un secondo, la funzione read() restituirà b”.

Quindi controlliamo se ciò che abbiamo ricevuto è semplicemente vuoto (b”) o se c’era davvero qualcosa. In quest’ultimo caso, convertiamo i dati che abbiamo ricevuto in un numero intero in modo da poter utilizzare nel codice. Per questo usiamo la funzione int.from_bytes (), che decodificherà b’ 0x12 ‘ (la rappresentazione esadecimale di 18 è 0x12) a 18.

Come puoi vedere controlliamo che il numero sia 18 per continuare l’azione. Se si dispone di comandi diversi da gestire, utilizzare un numero diverso per ogni comando è una buona pratica.

Scegliamo un numero casuale tra 1 e 4 per determinare quale LED accendere. Quindi lo inviamo con la funzione Pyserial write (). Per inviare un int via seriale, prima lo convertiamo come una stringa con str (), e poi lo codifichiamo con encode (‘utf-8’).

Testare l’applicazione

Ora è possibile collegare l’Arduino al Raspberry Pi utilizzando il cavo USB. Il Raspberry Pi fornirà quindi l’alimentazione sia per Arduino che per i 4 LED.

Se hai molte cose collegate al tuo Arduino, potresti voler aggiungere un alimentatore esterno sul connettore di alimentazione Arduino. Ad esempio, se si desidera utilizzare un motore passo-passo, il Raspberry Pi non avrà mai abbastanza corrente per se stesso + l’Arduino + il motore. In questo caso, con 4 LED va bene.

Esegui lo script Python e premi il pulsante. Vedrete un registro e uno dei LED sul Arduino sarà acceso.

$ chmod +x arduino_raspberry_pi_leds_button.py$ ./arduino_raspberry_pi_leds_button.py Button has been pressed.Sending number 3 to Arduino.Button has been pressed.Sending number 2 to Arduino.Button has been pressed.Sending number 4 to Arduino.Button has been pressed.Sending number 1 to Arduino.Button has been pressed.Sending number 3 to Arduino.Button has been pressed.Sending number 3 to Arduino.

Ogni volta che si preme il pulsante:

  • L’Arduino lo rileverà e invierà 18 al Raspberry Pi.
  • Il Raspberry Pi riceverà alcuni dati da seriale. Controllerà se il numero è uguale a 18. Se sì, viene scelto un numero casuale (tra 1-4). Il Raspberry Pi invierà questo numero al Arduino.
  • L’Arduino riceverà questo numero e accenderà il LED associato.

Nota: per fare questa applicazione più veloce e con meno codice, si può anche scegliere di utilizzare il protocollo Firmata, con ad esempio la libreria pyFirmata su Raspberry e la libreria StandarfFirmata su Arduino. Dai un’occhiata a quei tutorial per saperne di più.

Conclusione

In questo tutorial hai imparato come comunicare tra il Raspberry Pi e la scheda Arduino via seriale.

Ora, nella vita reale, questo ti sarà utile? La risposta è sì, e abbastanza spesso.

Il Raspberry Pi è grande per avere un sacco di potenza di calcolo incorporato nella vostra applicazione. È possibile eseguire software completi in molte lingue, server web, applicazioni di robotica,ecc. Il Raspberry Pi ha certamente alcuni GPIO che è possibile utilizzare, ma non sono buoni come quelli Arduino. Inoltre, hai più possibilità di bruciare il tuo Pi se fai qualcosa di sbagliato con l’hardware.

L’Arduino è più appropriato per gestire direttamente sensori e attuatori hardware: IMU, servomotori, motori passo-passo, tutto ciò che richiede più potenza, ecc. – maggiori informazioni su Quando utilizzare Arduino vs Raspberry Pi.

Tutto sommato, le 2 schede possono funzionare perfettamente insieme: il Raspberry Pi come ” cervello “dell’applicazione e l’Arduino come” muscoli”, con una comunicazione seriale per farli parlare tra loro.