In questo tutorial, ti fornirò tutte le informazioni necessarie per controllare la velocità e la direzione di un motore DC con un driver motore L293D utilizzando una scheda Arduino UNO.
Ho incluso uno schema di collegamento e dettagli del codice Arduino per controllare il motore DC inviando caratteri dal Serial Monitor dell’IDE Arduino con diversi esempi.
Materiali
Componenti hardware
| Arduino Uno Rev3 | × 1 | Amazon |
| Cavo USB tipo A/B | × 1 | Amazon |
| Motore DC con riduttore | × 1 | Amazon |
| Driver IC L293D | × 1 | Amazon |
| Breadboard | × 1 | Amazon |
| Cavi jumper | × 15 | Amazon |
| Alimentatore (5V) | × 1 | Amazon |
Software
| Arduino IDE | Arduino_IDE |
Makerguides.com partecipa al Programma di Affiliazione Amazon Services LLC, un programma di pubblicità affiliata progettato per fornire ai siti un modo per guadagnare commissioni pubblicitarie promuovendo e collegandosi a prodotti su Amazon.com.
Informazioni sul driver motore L293D
L293D è un driver IC quadruplo a mezzo ponte H ad alta corrente, adatto per il controllo di motori DC. Può fornire una corrente bidirezionale fino a 1 A a tensioni da 4,5 V a 36 V. Di seguito puoi trovare il datasheet del chip.
Pinout del driver L293D
L293D è un driver motore a 16 pin, e puoi controllare due motori DC o un motore stepper con corrente fino a 600mA.
Pin di alimentazione
Il pin 8 (VCC_2) e il pin 16 (VCC_1) sono usati per alimentare il driver motore L293D.
VCC_2 fornisce l’alimentazione al ponte H interno del driver, e può variare da 4,5V a 36V. VCC_1 è usato per la logica interna e deve essere a 5 V. I pin 4, 5, 12 e 13 (GND) sono la massa del dispositivo e i pin per il dissipatore di calore.
Pin di controllo direzione
Il pin 2 (Input_1), pin 7 (Input_2), pin 10 (Input_3) e pin 15 (Input_4) controllano gli interruttori del circuito ponte H all’interno del L293D.
Input_1 e Input_2 sono collegati ai due terminali del motore DC_1 e servono a controllarne la direzione. Analogamente, Input_3 e Input_4 controllano la direzione del motore_2.
Userò un Arduino UNO per generare i segnali di direzione per tutti i pin Input e, in base al livello di questi pin (Alto o Basso), il motore girerà in avanti o indietro.
Puoi vedere i dettagli nella tabella sottostante per il controllo della direzione del motore.
| Input_1 / Input_3 | Input_2 / Input_4 | Direzione motore |
| Basso | Basso | Freno, motore spento |
| Basso | Alto | Indietro (antiorario) |
| Alto | Basso | Avanti (orario) |
| Alto | Alto | Freno, motore spento |
Pin di controllo velocità
I motori DC possono ruotare a una velocità specifica in base al valore impostato da Arduino UNO sul Pin 1 (Enable_A) per il Motore_1 e sul Pin 9 (Enable_B) per il Motore_2.
Un segnale alto attivo sul pin enable attiva il canale driver del L293D, permettendo al motore di girare alla massima velocità.
Un segnale basso attivo sul pin enable disattiva il canale driver del L293D, fermando il motore. Per controllare la velocità del motore DC, devi inviare segnali PWM sul pin enable del L293D. La velocità del motore varierà in base al duty cycle del segnale PWM.
I dettagli sono spiegati nella sezione del codice.
Pin di uscita motore
Il driver motore L293D fornisce una corrente di uscita fino a 600mA al motore DC tramite il Pin 3 (Output_1), Pin 6 (Output_2) per il Motore_1 e Pin 11 (Output_3), Pin 14 (Output_4) per il Motore_2.
Specifiche del motore DC
Tensione
Sul mercato sono disponibili vari motori DC con tensioni da 3V a 100V; tuttavia, per applicazioni robotiche, sono comunemente usati motori DC da 6V, 12V o 24V. In questo tutorial considereremo motori DC con riduttore da 3V a 6V.
Corrente
Devi scegliere un motore DC con una corrente massima di 600mA perché oltre questa corrente il driver L293D si surriscalderà e potrebbe danneggiarsi.
Coppia
La coppia del motore è un fattore importante quando si ha un carico sul motore; se la tua applicazione richiede un carico maggiore, devi acquistare un motore con coppia più elevata. Un altro modo per aumentare la coppia è usare un riduttore con il motore.
In questo tutorial uso un motore DC con riduttore con rapporto di trasmissione 1:48.
Collegamento del driver motore L293D con Arduino UNO
In questa sezione imparerai come interfacciare i motori DC con il driver L293D e la scheda Arduino UNO.
Passo 1: Collegamenti motori al driver L293D
Inizia collegando i fili dei motori ai pin di uscita del driver L293D.
Collega i fili del Motore_1 ai pin 3 (Output_1) e 6 (Output_2) e i fili del Motore_2 ai pin 11 (Output_3) e 14 (Output_4).
Passo 2: Collegamenti Arduino UNO al driver L293D
Ora collega il pin digitale 10 e 9 di Arduino ai pin 2 (Input_1) e 7 (Input_2) del L293D per il Motore_1.
Allo stesso modo, collega i pin digitali 4 e 3 di Arduino ai pin 10 (Input_3) e 15 (Input_4) del L293D per il Motore_2.
Inoltre, devi fornire segnali PWM sui pin Enable per il controllo della velocità dei motori DC.
Collega il pin PWM 11 di Arduino UNO al pin 1 (Enable_A) del L293D per il Motore_1 e il pin PWM 5 di Arduino UNO al pin 9 (Enable_B).
Passo 3: Collegamenti alimentazione al driver L293D
Ora puoi fornire un’alimentazione a 5V al driver L293D collegando il pin 8 (VCC_2) e il pin 16 (VCC_1) al positivo dell’alimentazione da 5V.
Collega tutte le masse del driver a una massa comune sulla breadboard.
Tutti i collegamenti sono mostrati nell’immagine.
Codice Arduino – Controllo di un motore DC tramite terminale seriale
Se vuoi testare il tuo motore DC, devi poterlo controllare.
Il codice seguente ti permette di controllare la velocità e la direzione di entrambi i motori DC singolarmente e simultaneamente inviando caratteri dal Serial Monitor dell’IDE Arduino.
Puoi copiare il codice cliccando sul pulsante in alto a destra nel campo del codice e caricarlo sulla tua scheda Arduino UNO.
Ora spiegherò come funziona il codice.
// Motor_1 Connection
#define ENABLE_1 11
#define MOTOR_1_A 10
#define MOTOR_1_B 9
// Motor_2 Connection
#define ENABLE_2 5
#define MOTOR_2_A 4
#define MOTOR_2_B 3
// other variables
char serial_data;
int speed_value_m1;
int speed_value_m2;
void setup() {
Serial.begin(9600);
Serial.println("Motor Init..");
motor_1_init();
motor_2_init();
speed_value_m1 = 0;
speed_value_m2 = 0;
}
void loop() {
motor_speed_dir_control();
}
void motor_1_init() {
pinMode(MOTOR_1_A, OUTPUT);
pinMode(MOTOR_1_B, OUTPUT);
pinMode(ENABLE_1, OUTPUT);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
analogWrite(ENABLE_1, LOW);
}
void motor_2_init() {
pinMode(MOTOR_2_A, OUTPUT);
pinMode(MOTOR_2_B, OUTPUT);
pinMode(ENABLE_2, OUTPUT);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_2, LOW);
}
void motor_speed_dir_control() {
while (Serial.available()) {
serial_data = Serial.read();
switch (serial_data) {
case 's':
analogWrite(ENABLE_1, 255);
Serial.println("Enable Motor_1");
break;
case 'S':
analogWrite(ENABLE_2, 255);
Serial.println("Enable Motor_2");
break;
case 'h':
analogWrite(ENABLE_1, 0);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
speed_value_m1 = 0;
Serial.println("Stop Motor_1");
break;
case 'H':
analogWrite(ENABLE_2, 0);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
speed_value_m2 = 0;
Serial.println("Stop Motor_2");
break;
case 'f':
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
Serial.println("Motor_1 Forward Direction");
break;
case 'F':
digitalWrite(MOTOR_2_A, HIGH);
digitalWrite(MOTOR_2_B, LOW);
Serial.println("Motor_2 Forward Direction");
break;
case 'b':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, HIGH);
Serial.println("Motor_1 Backward Direction");
break;
case 'B':
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, HIGH);
Serial.println("Motor_2 Backward Direction");
break;
case 'a':
for (int i = 0; i < 256; i++) {
analogWrite(ENABLE_1, i);
}
Serial.println("Motor_1 acceleration");
break;
case 'A':
for (int i = 0; i < 256; i++) {
analogWrite(ENABLE_2, i);
}
Serial.println("Motor_2 acceleration");
break;
case 'd':
for (int i = 255; i > 1; i--) {
analogWrite(ENABLE_1, i);
delay(5);
}
Serial.println("Motor_1 deceleration");
break;
case 'D':
for (int i = 255; i > 1; i--) {
analogWrite(ENABLE_2, i);
delay(5);
}
Serial.println("Motor_2 deceleration");
break;
case 'i':
if (speed_value_m1 <= 245) {
speed_value_m1 += 10;
analogWrite(ENABLE_1, speed_value_m1);
Serial.println("Motor_1 increased Speed value: ");
Serial.print(speed_value_m1);
} else {
Serial.println("Maximum Speed Limit Reached for Motor_1: ");
Serial.print(speed_value_m1);
}
break;
case 'I':
if (speed_value_m2 <= 245) {
speed_value_m2 += 10;
analogWrite(ENABLE_2, speed_value_m2);
Serial.println("Motor_2 increased Speed value: ");
Serial.print(speed_value_m2);
} else {
Serial.println("Maximum Speed Limit Reached for Motor_2: ");
Serial.print(speed_value_m2);
}
break;
case 'r':
if (speed_value_m1 >= 10) {
speed_value_m1 -= 10;
analogWrite(ENABLE_1, speed_value_m1);
Serial.println("Motor_1 reduced Speed value: ");
Serial.print(speed_value_m1);
} else {
Serial.println("Minimum Speed Limit Reached for Motor_1: ");
Serial.print(speed_value_m1);
}
break;
case 'R':
if (speed_value_m2 >= 10) {
speed_value_m2 -= 10;
analogWrite(ENABLE_2, speed_value_m2);
Serial.println("Motor_2 reduced Speed value: ");
Serial.print(speed_value_m2);
} else {
Serial.println("Minimum Speed Limit Reached for Motor_2: ");
Serial.print(speed_value_m2);
}
break;
case 'X':
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
digitalWrite(MOTOR_2_A, HIGH);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_1, 255);
analogWrite(ENABLE_2, 255);
Serial.println("Motor_1 and Motor_2 Forward Direction");
break;
case 'Y':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, HIGH);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, HIGH);
analogWrite(ENABLE_1, 255);
analogWrite(ENABLE_2, 255);
Serial.println("Motor_1 and Motor_2 Backward Direction");
break;
case 'Z':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_1, 0);
analogWrite(ENABLE_2, 0);
Serial.println("Motor_1 and Motor_2 Stop");
break;
default:
break;
}
}
}
Come funziona il codice
Per prima cosa ho definito le variabili per i pin di Arduino UNO in base ai collegamenti e altre variabili per memorizzare i dati seriali e il valore di velocità.
//Motor_1 Connection #define ENABLE_1 11 #define MOTOR_1_A 10 #define MOTOR_1_B 9 //Motor_2 Connection #define ENABLE_2 5 #define MOTOR_2_A 4 #define MOTOR_2_B 3 //other variables char serial_data; int speed_value_m1; int speed_value_m2;
Poiché testerò i motori DC con comandi dal Serial Monitor, devo inizializzare la connessione seriale della scheda Arduino UNO. Ho impostato la velocità di comunicazione a 9600 baud.
Serial.begin(9600);
Successivamente ho impostato i pin di Arduino UNO come output per fornire segnali al driver L293D, e inizialmente tutti i pin sono impostati a basso livello.
void motor_1_init() {
pinMode(MOTOR_1_A, OUTPUT);
pinMode(MOTOR_1_B, OUTPUT);
pinMode(ENABLE_1, OUTPUT);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
analogWrite(ENABLE_1, LOW);
}
void motor_2_init() {
pinMode(MOTOR_2_A, OUTPUT);
pinMode(MOTOR_2_B, OUTPUT);
pinMode(ENABLE_2, OUTPUT);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_2, LOW);
}
Infine, nel void loop(), che è un ciclo infinito, chiamo la funzione motor_speed_dir_control() per eseguire diverse operazioni sui motori DC in base al carattere ricevuto dal Serial Monitor.
Ho usato la funzione Serial.read() per leggere il pin Rx di Arduino UNO, e il carattere ricevuto viene memorizzato in serial_data.
Ora sono scritti diversi casi per controllare i motori DC tramite switch case.
Puoi usare i seguenti comandi seriali per il controllo di velocità e direzione dei motori DC:
| Motore_1 | Motore_2 | Output |
| s | S | Abilita motore DC |
| h | H | Ferma motore DC |
| f | F | Imposta direzione avanti per motore DC |
| b | B | Imposta direzione indietro per motore DC |
| a | A | Accelera motore DC da zero alla massima velocità |
| d | D | Decelera motore DC da massima velocità a zero |
| i | I | Aumenta la velocità del motore DC di 10 |
| r | R | Riduci la velocità del motore DC di 10 |
| X | Fai girare entrambi i motori DC in avanti |
| Y | Fai girare entrambi i motori DC indietro |
| Z | Ferma entrambi i motori DC |
Come si controlla la posizione di un motore DC con Arduino?
Per controllare la posizione in una direzione specifica, devi prima impostare la direzione del motore DC e poi applicare il segnale PWM sui pin enable.
Facciamo un esempio: far muovere il Motore_1 in avanti a piena velocità. Prima devi impostare la direzione avanti nel codice Arduino.
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
Ora imposta il pin enable a HIGH per far muovere il Motore_1 in avanti.
analogWrite(ENABLE_1, 255);
Allo stesso modo, puoi impostare direzioni diverse per entrambi i motori e cambiare la loro posizione come fatto nei vari casi.
Come si controlla la velocità di un motore DC con Arduino?
Per controllare la velocità del motore DC, devi fornire una modulazione di larghezza di impulso (PWM) sul pin enable.
| Enable_A / Enable_B | Velocità motore |
| Basso | Zero (fermo) |
| Alto | Massima velocità |
| PWM | Controllo velocità in base al valore del segnale PWM |
analogWrite(pin, value) è usato per impostare il PWM sui pin Enable del L293D. Con Arduino UNO puoi impostare la velocità da zero (0) a massimo (255). Vedi i casi ‘a’, ‘A’, ‘d’, ‘D’, ‘i’, ‘I’, ‘r’ e ‘R’ nel codice.
Test dei motori DC
Una volta caricato il codice sulla scheda Arduino UNO, nell’IDE Arduino vai su “Tools” e clicca su “Serial Monitor” oppure usa la scorciatoia “Ctrl+Shift+M.”
Prima assicurati di aver selezionato la velocità di comunicazione corretta, cioè 9600 baud. Ora, nel Serial Monitor, puoi testare il tuo codice con i motori DC collegati ad Arduino inviando comandi dal Serial Monitor.
Esempio 1: Fai girare il Motore_1 in avanti, poi decelera, accelera, aumenta, riduci la velocità, inverti la direzione e infine ferma il motore.
Invia i seguenti caratteri uno alla volta in minuscolo dal Serial Monitor:
f, s, d, a, i, i, i, i, i, i, i, i, i, i, i, i, r, r, r, r, r, r, r, r, r, r, r, r, b, s, h
Allo stesso modo puoi controllare il Motore_2 inviando i caratteri sopra in maiuscolo. Nota che puoi far girare entrambi i motori inviando i caratteri secondo le tue esigenze.
Esempio 2: Fai girare contemporaneamente Motore_1 e Motore_2 in avanti, poi indietro, e ferma entrambi i motori.
Invia i seguenti caratteri:
X, Y, Z
Conclusione
Dopo questo tutorial, potrai applicare la logica usata per controllare velocità e direzione dei motori DC per realizzare progetti elettronici innovativi e creativi con motori DC e scheda Arduino.
Se hai domande, suggerimenti o pensi che manchi qualcosa in questo tutorial, lascia un commento qui sotto.
