Come costruire un rover robotico Bluetooth con Arduino
Descrizione
Questo progetto è un’auto Arduino controllata tramite Bluetooth costruita con una scheda Arduino, un modulo seriale Bluetooth, un driver motori e due motori DC. Il robot riceve comandi di movimento da uno smartphone o computer attraverso Bluetooth e li usa per muoversi avanti, indietro, a sinistra, a destra o fermarsi. Il codice usa anche pin di velocità PWM per impostare velocità diverse per i due motori, cosa utile per bilanciare l’auto se un motore è più forte o più veloce dell’altro. Questo progetto è utile per imparare il controllo wireless, la comunicazione SoftwareSerial, la logica del driver motori, il controllo della velocità PWM e la robotica Arduino di base.
Componenti e schema:
Codice:
// https://nemiatools.com
#include <SoftwareSerial.h> // Importa libreria seriale software
SoftwareSerial bluetooth(9, 12); // Crea porta seriale Bluetooth
// Pin di controllo motori
const int leftMotorForwardPin = 3; // Definisce pin avanti sinistro
const int leftMotorBackwardPin = 2; // Definisce pin indietro sinistro
const int rightMotorForwardPin = 5; // Definisce pin avanti destro
const int rightMotorBackwardPin = 4; // Definisce pin indietro destro
const int rightMotorSpeedPin = 6; // Definisce velocità motore destro
const int leftMotorSpeedPin = 11; // Definisce velocità motore sinistro
char command = 'S'; // Memorizza comando Bluetooth corrente
unsigned long lastCommandTime = 0; // Memorizza tempo ultimo comando
void setup() {
pinMode(rightMotorForwardPin, OUTPUT); // Imposta uscita avanti destra
pinMode(leftMotorForwardPin, OUTPUT); // Imposta uscita avanti sinistra
pinMode(leftMotorBackwardPin, OUTPUT); // Imposta uscita indietro sinistra
pinMode(rightMotorBackwardPin, OUTPUT); // Imposta uscita indietro destra
pinMode(leftMotorSpeedPin, OUTPUT); // Imposta uscita velocità sinistra
pinMode(rightMotorSpeedPin, OUTPUT); // Imposta uscita velocità destra
analogWrite(rightMotorSpeedPin, 110); // Imposta velocità motore destro
analogWrite(leftMotorSpeedPin, 97); // Imposta velocità motore sinistro
bluetooth.begin(9600); // Avvia comunicazione Bluetooth
Serial.begin(9600); // Avvia comunicazione seriale
Serial.println("START"); // Stampa messaggio iniziale
}
void stopMotors() { // Ferma entrambi i motori
digitalWrite(rightMotorForwardPin, LOW); // Disattiva avanti destra
digitalWrite(leftMotorForwardPin, LOW); // Disattiva avanti sinistra
digitalWrite(rightMotorBackwardPin, LOW); // Disattiva indietro destra
digitalWrite(leftMotorBackwardPin, LOW); // Disattiva indietro sinistra
} // Termina funzione arresto
void driveForward() { // Muove il robot avanti
digitalWrite(leftMotorForwardPin, HIGH); // Attiva avanti sinistra
digitalWrite(rightMotorForwardPin, HIGH); // Attiva avanti destra
digitalWrite(leftMotorBackwardPin, LOW); // Disattiva indietro sinistra
digitalWrite(rightMotorBackwardPin, LOW); // Disattiva indietro destra
}
void driveBackward() { // Muove il robot indietro
digitalWrite(leftMotorBackwardPin, HIGH); // Attiva indietro sinistra
digitalWrite(rightMotorBackwardPin, HIGH); // Attiva indietro destra
digitalWrite(leftMotorForwardPin, LOW); // Disattiva avanti sinistra
digitalWrite(rightMotorForwardPin, LOW); // Disattiva avanti destra
}
void turnRobotLeft() { // Gira il robot sinistra
digitalWrite(leftMotorForwardPin, HIGH); // Attiva avanti sinistra
digitalWrite(rightMotorBackwardPin, HIGH); // Attiva indietro destra
digitalWrite(leftMotorBackwardPin, LOW); // Disattiva indietro sinistra
digitalWrite(rightMotorForwardPin, LOW); // Disattiva avanti destra
}
void turnRobotRight() { // Gira il robot destra
digitalWrite(leftMotorBackwardPin, HIGH); // Attiva indietro sinistra
digitalWrite(rightMotorForwardPin, HIGH); // Attiva avanti destra
digitalWrite(leftMotorForwardPin, LOW); // Disattiva avanti sinistra
digitalWrite(rightMotorBackwardPin, LOW); // Disattiva indietro destra
}
void loop() {
if (bluetooth.available()) { // Controlla dati Bluetooth disponibili
command = bluetooth.read(); // Legge comando Bluetooth
Serial.print(command); // Stampa comando ricevuto
lastCommandTime = millis(); // Aggiorna tempo ultimo comando
}
if(command == 'F') // Controlla comando avanti
driveForward(); // Muove il robot avanti
else if(command == 'B') // Controlla comando indietro
driveBackward(); // Muove il robot indietro
else if(command == 'L') // Controlla comando sinistra
turnRobotLeft(); // Gira il robot sinistra
else if(command == 'R') // Controlla comando destra
turnRobotRight(); // Gira il robot destra
else if(command == 'S') // Controlla comando arresto
stopMotors(); // Ferma entrambi i motori
if(millis() - lastCommandTime > 1000) { // Controlla scadenza comando
command = 'S'; // Imposta comando arresto
}
}Come funziona:
Questo progetto controlla una piccola auto robot tramite Bluetooth. Un modulo Bluetooth riceve comandi da un dispositivo esterno, come un’app per smartphone, e li invia ad Arduino. Arduino poi controlla il driver motori per muovere l’auto nella direzione richiesta.
La riga #include <SoftwareSerial.h> aggiunge la libreria SoftwareSerial. Questa libreria permette ad Arduino di creare una seconda porta di comunicazione seriale usando normali pin digitali, invece di usare solo i pin seriali hardware 0 e 1.
La riga SoftwareSerial bluetooth(9, 12); crea una porta seriale Bluetooth. In questo caso, il pin 9 è usato come RX e il pin 12 è usato come TX. Il pin TX del modulo Bluetooth dovrebbe essere collegato al pin 9 di Arduino, mentre il pin RX dell’HC-05 deve essere collegato al pin 12 di Arduino tramite un partitore di tensione o un adattatore di livello da 5 V a 3,3 V, con massa in comune.
I pin dei motori definiscono come Arduino controlla il driver motori. Le righe leftMotorForwardPin e leftMotorBackwardPin controllano la direzione del motore sinistro, mentre rightMotorForwardPin e rightMotorBackwardPin controllano la direzione del motore destro.
I pin rightMotorSpeedPin = 6 e leftMotorSpeedPin = 11 sono usati per il controllo della velocità dei motori. Questi pin dovrebbero essere collegati agli ingressi enable o PWM del driver motori. Usando analogWrite(), Arduino può controllare quanta potenza viene inviata a ciascun motore.
Dentro setup(), tutti i pin di direzione dei motori e i pin di velocità sono configurati come output. Questo permette ad Arduino di inviare segnali HIGH, LOW e PWM al driver motori.
Le righe analogWrite(rightMotorSpeedPin, 110); e analogWrite(leftMotorSpeedPin, 97); impostano la velocità dei due motori. I valori possono andare da 0 a 255, dove 0 significa fermo e 255 significa output PWM massimo.
Questi valori di velocità sono molto importanti in una vera auto robot perché i due motori DC spesso non sono perfettamente identici. Un motore può ruotare più velocemente dell’altro anche con lo stesso comando. In questo codice, il motore destro è impostato a 110 e il motore sinistro a 97 per aiutare a bilanciare il movimento e fare andare l’auto più dritta.
L’utente può cambiare sia i numeri dei pin sia i valori di velocità per adattare il progetto al proprio cablaggio, driver motori, telaio e comportamento dei motori. Se l’auto non si muove dritta, l’utente può aumentare leggermente la velocità del motore più lento o ridurre la velocità del motore più veloce finché il movimento è bilanciato.
La riga bluetooth.begin(9600); avvia la comunicazione Bluetooth a 9600 baud. Questo valore deve corrispondere al baud rate del modulo Bluetooth, come un HC-05 o HC-06.
La funzione stopMotors() imposta tutti i pin di direzione su LOW. Questo rimuove ogni comando avanti e indietro da entrambi i motori, quindi l’auto si ferma.
La funzione driveForward() accende i pin di direzione avanti di entrambi i motori e spegne i pin di direzione indietro. Questo fa ruotare il motore sinistro e destro in avanti alla velocità precedentemente impostata dai pin PWM.
La funzione driveBackward() fa l’opposto. Accende i pin di direzione indietro e spegne i pin di direzione avanti, quindi entrambi i motori ruotano indietro.
Le funzioni turnRobotLeft() e turnRobotRight() ruotano i motori in direzioni opposte. Questo fa girare il robot sul posto invece di muoversi semplicemente in una curva larga.
A seconda di come i motori sono montati e cablati, il movimento fisico sinistro e destro può essere invertito. Se questo succede, l’utente può scambiare i fili dei motori, cambiare le definizioni dei pin o scambiare la logica dentro le funzioni di sterzata.
Dentro loop(), la condizione if (bluetooth.available()) controlla se è arrivato un nuovo comando Bluetooth. Se un comando è disponibile, command = bluetooth.read(); legge un carattere e lo memorizza nella variabile command.
I caratteri di comando definiscono il movimento. Il carattere 'F' fa muovere il robot in avanti, 'B' lo fa muovere indietro, 'L' lo fa girare a sinistra, 'R' lo fa girare a destra e 'S' ferma i motori.
Ogni volta che viene ricevuto un nuovo comando Bluetooth, la riga lastCommandTime = millis(); salva il tempo corrente. La funzione millis() restituisce il numero di millisecondi passati da quando Arduino è stato alimentato o resettato.
La condizione if(millis() - lastCommandTime > 1000) funziona come un timeout di sicurezza. Se Arduino non riceve alcun nuovo comando Bluetooth per più di un secondo, il codice imposta automaticamente command = 'S';, quindi il robot si ferma.
Questo timeout è utile perché se la connessione Bluetooth viene persa o l’app di controllo smette di inviare dati, il robot non continuerà a muoversi per sempre con l’ultimo comando.
Nel complesso, il modulo Bluetooth riceve caratteri di movimento, Arduino li interpreta, il driver motori alimenta i motori e i valori di velocità PWM aiutano a bilanciare i due lati del robot. Regolando i pin e i valori di velocità, l’utente può adattare il codice a molte diverse configurazioni di auto robot e rendere il movimento più preciso.
Per l’hardware reale, i motori dovrebbero essere alimentati attraverso un driver motori adatto e un’alimentazione esterna. Arduino, modulo Bluetooth, driver motori e alimentazione dei motori devono condividere una massa comune. Se il pin RX del modulo Bluetooth non è tollerante a 5V, usa un partitore di tensione o un level shifter tra Arduino TX e il pin RX del modulo.