Shield motori L293D Arduino: AFMotor, 4 motori, stepper e servo

Lo shield motori L293D (L293D motor shield) è una scheda driver per motori che si innesta direttamente sopra un Arduino Uno e ti permette di pilotare 4 motori DC, 2 motori passo-passo e 2 servo da un'unica scheda. I suoi due chip L293D forniscono la corrente che serve ai motori, ne invertono il verso di rotazione e ne regolano la velocità con il PWM: così puoi controllare tutti i motori di una macchinina robot a quattro ruote senza un solo cavetto jumper. Quasi tutte le schede in commercio sono copie del vecchio Motor Shield V1 di Adafruit e si programmano con la stessa libreria: AFMotor.

In questa guida scoprirai cosa c'è sullo shield, quali pin di Arduino occupa e quali restano liberi per i sensori, come funziona il famigerato jumper PWR in tre diversi schemi di alimentazione, i comandi della libreria AFMotor e il codice completo di una macchinina robot a quattro ruote guidata dal telefono. Nelle ultime sezioni parliamo del limite di corrente di 0,6 A, del perché il chip scalda, del confronto con l'L298N e di tutte le cause note del problema "i motori non girano", raccolte in un'unica tabella.

Cos'è lo shield motori L293D e come funziona?

Per far girare un motore DC nei due versi serve un circuito a quattro interruttori chiamato ponte H; spieghiamo il principio in dettaglio in Controllo di motori DC con l'L298N. Il chip L293D contiene due ponti H e, siccome lo shield ne monta due, hai in tutto quattro canali motore. La "D" nel nome indica che i diodi di protezione, che assorbono i picchi di tensione inversa prodotti da un motore allo spegnimento, sono integrati nel chip. Inoltre l'L293D spegne da solo le uscite quando si surriscalda.

Il vero trucco dello shield è il registro a scorrimento 74HC595 al centro. Ognuno dei quattro motori richiede due segnali per il verso e uno per la velocità, per un totale di 12 pin di Arduino. Lo shield invia gli otto segnali di verso in serie al 74HC595 e per questo usa solo 4 pin (D4, D7, D8, D12), più 4 pin PWM per la velocità (D3, D5, D6, D11). Questo progetto fa risparmiare pin, ma ha un prezzo: non puoi pilotare i motori direttamente con digitalWrite, serve una libreria che carichi i bit di verso nel registro. Quella libreria è AFMotor.

Cosa c'è sulla scheda? Morsettiere, connettori e jumper

Quali pin usa lo shield e quali restano liberi?

I sei pin analogici liberi bastano e avanzano per i sensori, perché A0–A5 dell'Uno funzionano all'occorrenza anche come pin digitali 14–19. Una distribuzione pratica può essere: un sensore di distanza HC-SR04 o un modulo Bluetooth con SoftwareSerial su A0 e A1, sensori di linea o di ostacoli su A2 e A3 e il bus I2C (OLED, LCD, MPU6050) su A4 e A5. Per un encoder sulla ruota o un pulsante con attachInterrupt() l'unico pin libero è D2; l'altro pin di interrupt dell'Uno, D3, è il pin di velocità di M2. Se non usi servo, anche D9 e D10 restano liberi. Puoi vedere la piedinatura della tua scheda nello strumento Pinout e cosa fa ogni pin in Pinout Arduino Uno.

Alimentazione e jumper PWR: tre modi corretti di collegarlo

La morsettiera a due viti EXT_PWR sul bordo inferiore della scheda è l'ingresso di alimentazione dei motori; il polo positivo di solito è marcato "+M" o "+" e il negativo "GND". Il jumper PWR subito accanto collega questa linea motori al pin Vin di Arduino. Con il jumper inserito le due schede si alimentano da un'unica sorgente: la tensione che dai a EXT_PWR alimenta anche Arduino tramite Vin, oppure un alimentatore collegato al jack DC di Arduino alimenta anche i motori. Senza jumper le due linee sono del tutto separate. Il LED PWR sulla scheda si accende solo quando arriva l'alimentazione dei motori; è la prima cosa da controllare prima di occuparti dei motori.

Nelle macchinine robot la soluzione più comune è la sorgente unica: colleghi un pacco di due celle 18650 a EXT_PWR, inserisci il jumper e sia Arduino sia i motori funzionano con la stessa batteria. È semplice, ma quando i motori partono e assorbono molta corrente la tensione della batteria può calare per un attimo e Arduino può riavviarsi. Se ti succede, la soluzione definitiva è togliere il jumper e alimentare Arduino da una sorgente separata (power bank, USB o un alimentatore da 9 V). Per le prove sul banco il secondo schema è il più pratico: Arduino resta collegato al computer, i motori vanno a batteria e il jumper è rimosso.

Quale batteria scegliere? A seconda della corrente, i transistor di uscita dell'L293D si mangiano circa 1,5–2,6 V, quindi il motore riceve altrettanto meno della tensione della batteria. Per i motori TT gialli da 3–6 V dei kit robotici, due celle al litio 18650 (7,4 V nominali, 8,4 V a piena carica) sono l'ideale: i motori ricevono circa 5,5–6 V e, con il jumper inserito, anche il regolatore di Arduino lavora tranquillo. Quattro pile AA (6 V) lasciano ai motori solo 4 V circa e non bastano ad alimentare Arduino tramite Vin. Una pila da 9 V non eroga più di qualche centinaio di milliampere: i motori non girano affatto oppure la pila si scarica in pochi minuti. Puoi stimare l'autonomia con il calcolatore di durata della batteria e leggere tutte le opzioni di alimentazione in Alimentare Arduino con batteria.

Installare la libreria AFMotor

1. Apri il Gestore librerie dell'Arduino IDE (Strumenti > Gestisci librerie oppure Ctrl+Maiusc+I).
2. Scrivi Adafruit Motor Shield nella ricerca. Compaiono due risultati: Adafruit Motor Shield library, con "V1 firmware" nella descrizione, e Adafruit Motor Shield V2 Library.
3. Per lo shield L293D installa la V1. La libreria V2 è per una scheda completamente diversa che comunica via I2C e usa chip TB6612.
4. Aggiungi la riga #include <AFMotor.h> all'inizio del tuo sketch.
5. Se vuoi, apri File > Esempi > Adafruit Motor Shield library > MotorTest e prova la scheda con un motore su M1.

Primo sketch: far girare un motore DC avanti, indietro e a velocità diverse

Fissa i due fili del motore alle due viti esterne della morsettiera M1 e lascia libera la vite GND centrale. Collega il pacco batterie a EXT_PWR, collega Arduino al computer via USB e togli il jumper PWR (il secondo schema qui sopra). Se il LED PWR è acceso, carica il codice qui sotto: il motore prima accelera e rallenta dolcemente, poi gira all'indietro per due secondi e si ferma.

1#include <AFMotor.h>                  // Adafruit Motor Shield V1 kütüphanesi / library
2
3AF_DCMotor motor(1);                  // M1 klemensi / M1 terminal
4
5void setup() {
6  Serial.begin(9600);
7  Serial.println(F("L293D motor testi / motor test"));
8  motor.setSpeed(200);                // 0–255; bunu unutursan motor dönmez / skip this and the motor won't turn
9  motor.run(RELEASE);                 // başlangıçta dur / start stopped
10}
11
12void loop() {
13  motor.run(FORWARD);                 // ileri / forward
14  for (int s = 60; s <= 255; s++) {   // yavaşça hızlan / ramp up
15    motor.setSpeed(s);
16    delay(10);
17  }
18  for (int s = 255; s >= 60; s--) {   // yavaşça yavaşla / ramp down
19    motor.setSpeed(s);
20    delay(10);
21  }
22  motor.run(RELEASE);                 // dur / stop
23  delay(500);
24
25  motor.setSpeed(180);
26  motor.run(BACKWARD);                // geri / backward
27  delay(2000);
28  motor.run(RELEASE);
29  delay(1000);
30}

La velocità si regola accendendo e spegnendo l'alimentazione del motore migliaia di volte al secondo; i dettagli sono in Cos'è il PWM?. Poiché M1 e M2 usano il Timer2, puoi sceglierne la frequenza: MOTOR12_64KHZ, MOTOR12_8KHZ (predefinita), MOTOR12_2KHZ e MOTOR12_1KHZ. A 64 kHz il fischio del motore non si sente più, ma l'L293D scalda di più. M3 e M4 invece dipendono dal Timer0; dato che questo timer fa funzionare anche millis() e delay(), la libreria non ne tocca la frequenza e questi due canali lavorano sempre a circa 1 kHz.

Codice della macchinina robot a quattro ruote (4WD)

L'uso preferito dello shield motori L293D è la macchinina robot a quattro ruote, perché ciascuno dei quattro motori ha la sua morsettiera e non c'è un groviglio di fili. Queste macchinine non hanno lo sterzo; curvano come un carro armato: se le due ruote di sinistra girano in un verso e le due di destra nell'altro, la macchinina ruota sul posto. Per questo il codice non controlla i motori uno per uno, ma in due gruppi: lato sinistro e lato destro. Per il controllo dal telefono colleghiamo un modulo Bluetooth HC-05 ai pin liberi A0 e A1 con SoftwareSerial; il modulo è spiegato nel dettaglio in Modulo Bluetooth HC-05.

1#include <AFMotor.h>
2#include <SoftwareSerial.h>
3
4AF_DCMotor frontLeft(1);              // M1: sol ön / front left
5AF_DCMotor rearLeft(2);               // M2: sol arka / rear left
6AF_DCMotor rearRight(3);              // M3: sağ arka / rear right
7AF_DCMotor frontRight(4);             // M4: sağ ön / front right
8
9SoftwareSerial bt(A0, A1);            // RX = A0 (HC-05 TXD), TX = A1 (HC-05 RXD, bölücüyle / via a divider)
10
11int speed = 200;                      // 0–255 arası sürüş hızı / driving speed 0–255
12
13void setSide(AF_DCMotor &a, AF_DCMotor &b, int value) {   // -255 … 255
14  uint8_t dir = value > 0 ? FORWARD : (value < 0 ? BACKWARD : RELEASE);
15  uint8_t pwm = constrain(abs(value), 0, 255);
16  a.setSpeed(pwm);
17  b.setSpeed(pwm);
18  a.run(dir);
19  b.run(dir);
20}
21
22void drive(int left, int right) {     // sol ve sağ taraf / left and right side
23  setSide(frontLeft, rearLeft, left);
24  setSide(frontRight, rearRight, right);
25}
26
27void setup() {
28  Serial.begin(9600);                 // hata ayıklama / debugging
29  bt.begin(9600);                     // HC-05 varsayılan hızı / default baud rate
30  drive(0, 0);
31}
32
33void loop() {
34  if (!bt.available()) return;
35  char c = bt.read();
36  Serial.println(c);
37
38  switch (c) {
39    case 'F': drive(speed, speed);        break;   // ileri / forward
40    case 'B': drive(-speed, -speed);      break;   // geri / backward
41    case 'L': drive(-speed, speed);       break;   // yerinde sola / spin left
42    case 'R': drive(speed, -speed);       break;   // yerinde sağa / spin right
43    case 'G': drive(speed / 3, speed);    break;   // ileri-sola kavis / curve forward-left
44    case 'I': drive(speed, speed / 3);    break;   // ileri-sağa kavis / curve forward-right
45    case 'S': drive(0, 0);                break;   // dur / stop
46    case 'q': speed = 255;                break;   // tam hız / full speed
47    default:
48      if (c >= '0' && c <= '9') speed = map(c - '0', 0, 9, 90, 240);   // hız kademesi / speed step
49  }
50}

Il cuore del codice è la funzione drive(sinistra, destra): riceve per ogni lato un valore da -255 a 255; positivo significa avanti, negativo indietro e zero fermo. setSide() dà la stessa velocità e lo stesso verso ai due motori di un lato. I comandi sono le singole lettere inviate dalle app del tipo "Arduino Bluetooth RC Car" degli store: F avanti, B indietro, L e R rotazione sul posto, G e I curva, S stop. Il cursore di velocità dell'app invia una cifra da 0 a 9; il codice la trasforma in un valore PWM tra 90 e 240 e, visto che il minimo è 90, i motori partono anche al livello più basso. Se una ruota gira al contrario non cambiare il codice: scambia i due fili di quel motore nella morsettiera. Per il montaggio del telaio e una versione a due motori vedi Macchinina robot Arduino.

Pilotare motori passo-passo: 28BYJ-48 e NEMA 17

Lo shield può pilotare due motori passo-passo contemporaneamente: la porta 1 usa le morsettiere M1 e M2 e la porta 2 usa M3 e M4. Con un motore bipolare (4 fili, come un NEMA 17) colleghi una bobina a M1 e l'altra a M2. Con un motore unipolare (5 o 6 fili) le due bobine vanno sempre a M1 e M2 e il filo comune va alla vite GND al centro della morsettiera. Per il diffusissimo 28BYJ-48 il collegamento è: fili blu e giallo su M1, rosa e arancione su M2, filo comune rosso su GND. L'uso di questo motore con la scheda ULN2003 è spiegato in Cos'è un motore passo-passo?.

Il 28BYJ-48 è un motore da 5 V; per questa prova alimenta i motori con 4 pile AA (6 V), togli il jumper e alimenta Arduino da USB. A causa del riduttore interno, un giro completo è di 2048 passi interi:

1#include <AFMotor.h>
2
3// 28BYJ-48: tam adımda tur başına 2048 adım / 2048 full steps per revolution
4AF_Stepper stepper(2048, 1);          // 1 = M1 + M2, 2 = M3 + M4
5
6void setup() {
7  stepper.setSpeed(10);               // dakikada 10 tur / 10 RPM
8}
9
10void loop() {
11  stepper.step(2048, FORWARD, DOUBLE);       // bir tur ileri, güçlü tork / one turn forward, more torque
12  delay(500);
13  stepper.step(4096, BACKWARD, INTERLEAVE);  // yarım adımla bir tur geri / one turn back in half steps
14  stepper.release();                         // bobinleri kapat, ısınmasın / de-energise the coils
15  delay(1000);
16}

setSpeed() imposta i giri al minuto; per via del riduttore, il 28BYJ-48 non supera i 10–15 giri/min circa. Il punto a cui fare attenzione è che step() è bloccante: finché il motore non ha completato i passi richiesti, loop() non fa nient'altro. Se vuoi leggere sensori o pilotare motori DC mentre il passo-passo gira, usa la funzione onestep() della libreria insieme alla libreria AccelStepper; l'esempio AFMotor_ConstantSpeed incluso nella libreria mostra proprio questo. Chiamare release() durante le pause spegne le bobine ed evita il riscaldamento, ma intanto l'albero perde la coppia di tenuta.

Collegare i servo: i connettori SER1 e SERVO_2

I due connettori a tre pin nell'angolo dello shield sono per i servo. Secondo le serigrafie della scheda i pin sono − (GND), + (5 V) e S (segnale): il filo marrone del servo va su −, quello rosso su + e quello arancione su S. Secondo lo schema della scheda, SER1 è collegato a D10 e SERVO_2 a D9 (alcune fonti riportano i numeri al contrario; se il servo non si muove, prova l'altro pin nel codice). I servo si pilotano con la libreria standard Servo, e il Timer1 che usa sull'Uno non entra in conflitto con i timer dei motori: motori DC e servo funzionano insieme senza problemi.

I servo non sono alimentati dalla batteria dei motori, ma dalla linea 5 V di Arduino. Per un SG90 non è un problema, ma servo grandi come l'MG996R possono assorbire più di 1 A mentre si muovono; il regolatore di Arduino scalda, la tensione crolla e la scheda si riavvia. Con i servo grandi collega al connettore solo il filo di segnale, alimenta + e − del servo da una sorgente separata da 5–6 V e unisci le masse. Trovi i dettagli in Servo MG996R con Arduino e Che cos'è un servomotore?. Il codice qui sotto fa oscillare a destra e a sinistra il servo su SER1 mentre il motore su M3 gira:

1#include <AFMotor.h>
2#include <Servo.h>
3
4AF_DCMotor motor(3);                  // M3 klemensi / M3 terminal
5Servo servo1;                         // SER1 başlığı / SER1 header
6
7void setup() {
8  servo1.attach(10);                  // SER1 = D10, SERVO_2 = D9
9  motor.setSpeed(170);
10  motor.run(FORWARD);                 // motor dönerken servo tarar / servo sweeps while the motor runs
11}
12
13void loop() {
14  for (int a = 20; a <= 160; a += 2) {   // sağa tara / sweep right
15    servo1.write(a);
16    delay(15);
17  }
18  for (int a = 160; a >= 20; a -= 2) {   // sola tara / sweep left
19    servo1.write(a);
20    delay(15);
21  }
22}

Limite di corrente (0,6 A) e riscaldamento

La riga più importante del datasheet dell'L293D è 0,6 A continui e 1,2 A di picco per canale. Il valore di picco vale solo per impulsi molto brevi; se un motore assorbe 1 A per diversi secondi, il chip va in sofferenza. Un semplice calcolo mostra perché scalda: l'L293D è un driver di vecchio tipo a transistor bipolari e, a 0,6 A, perde tipicamente 1,4 V sul transistor superiore e 1,2 V su quello inferiore. Quando un motore assorbe 0,6 A, nel chip si producono quindi 0,6 A × 2,6 V ≈ 1,6 W di calore; due motori sullo stesso chip ne producono il doppio, circa 3 W. Un piccolo chip DIP senza dissipatore non riesce a smaltire quel calore, la sua temperatura sale rapidamente e alla fine la protezione termica spegne le uscite. Il sintomo è noto: i motori girano per un po', si fermano e ripartono quando il chip si è raffreddato.

I motori TT gialli assorbono circa 150 mA a vuoto e 200–300 mA mentre avanzano sul pavimento, valori entro i limiti dello shield. Il problema sono i momenti in cui una ruota spinge contro un ostacolo o la macchinina ruota sul posto: un motore TT bloccato può assorbire 1–1,5 A, e in una 4WD tutti e quattro i motori sforzano insieme durante la rotazione sul posto. Per conoscere la corrente reale del tuo motore, collega un multimetro in serie al motore e misura tenendo ferma la ruota con la mano per un attimo; come fare è spiegato in Come usare il multimetro. Per tenere fresco lo shield:

• Partenza dolce: non saltare da 0 a 255 di colpo; aumenta la velocità gradualmente in 200–300 ms e la corrente di spunto cala nettamente.
• Non bloccare il motore: nei robot che evitano ostacoli, ferma la macchinina prima che urti; un motore bloccato è quello che scalda di più.
• Incolla dissipatori sui chip: piccoli dissipatori in alluminio con nastro termico abbassano un po' la temperatura dell'L293D.
• Salda un secondo L293D sopra: anche Adafruit indica che, per aumentare la capacità di corrente, si può saldare un secondo L293D sopra i chip esistenti, piedino su piedino; i due chip si dividono la corrente.
• Non usare più tensione del necessario: dare 12 V a motori da 6 V aumenta corrente e calore.
• Passa al driver giusto: se il tuo motore assorbe in modo continuo più di 0,6 A, usa un driver basato su L298N o TB6612FNG.

Shield motori L293D o L298N?

In breve, se costruisci una 4WD con motori TT su un Arduino Uno, lo shield L293D riduce al minimo i cablaggi e riunisce i quattro motori su un'unica scheda. Se i tuoi motori sono più potenti, se la tua scheda è un ESP32 o un Pico o se ci tieni a scegliere i pin, l'L298N è più flessibile; i dettagli sono in Controllo di motori DC con l'L298N. Se cerchi qualcosa di più efficiente di entrambi, il TB6612FNG a MOSFET ha una caduta di tensione molto bassa e allunga la durata delle batterie. Confrontiamo quale tipo di motore è adatto a quale lavoro in Motore DC, servomotore e motore passo-passo.

Funziona con ESP32, Raspberry Pi Pico o Mega?

Con l'Arduino Mega 2560 funziona senza problemi: lo shield si innesta sui primi pin digitali e analogici del Mega e AFMotor conosce i timer del Mega. Con Uno R4, Leonardo, ESP32 e Raspberry Pi Pico, invece, non funziona, perché AFMotor scrive direttamente nei registri dei timer di ATmega328P e ATmega2560. Con un ESP32 selezionato la compilazione si interrompe con 'DC_MOTOR_PWM_RATE' was not declared in this scope, con un Leonardo con #error "This chip is not supported!". Le schede ESP32 in formato Uno (come l'ESPDuino-32) si innestano fisicamente sullo shield, ma i numeri dei pin e il livello di segnale a 3,3 V sono diversi. Con queste schede è molto più semplice usare un L298N, un TB6612FNG o un singolo chip L293D al posto dello shield. Gli ingressi dell'L293D considerano HIGH tutto ciò che supera 2,3 V, quindi funzionano direttamente con schede a 3,3 V:

1from machine import Pin, PWM
2import time
3
4en = PWM(Pin(15))                 # L293D pin 1 (1,2EN): hız / speed
5en.freq(1000)
6in1 = Pin(14, Pin.OUT)            # L293D pin 2 (1A): yön / direction
7in2 = Pin(13, Pin.OUT)            # L293D pin 7 (2A): yön / direction
8
9def motor(speed):                 # -100 … 100
10    in1.value(1 if speed > 0 else 0)
11    in2.value(1 if speed < 0 else 0)
12    en.duty_u16(int(abs(speed) * 655.35))
13
14while True:
15    motor(80)                     # ileri / forward
16    time.sleep(2)
17    motor(0)                      # dur / stop
18    time.sleep(0.5)
19    motor(-60)                    # geri / backward
20    time.sleep(2)
21    motor(0)
22    time.sleep(0.5)

Le masse del Pico e della batteria devono assolutamente essere collegate. Sull'ESP32 costruisci la stessa logica nel linguaggio di Arduino: verso con digitalWrite e velocità con analogWrite sui pin della tabella. Se queste schede sono nuove per te, comincia da Cos'è l'ESP32? e Cos'è il Raspberry Pi Pico?.

I motori non girano: errori frequenti e soluzioni

Idee di progetto con lo shield motori L293D

• Macchinina 4WD comandata via Bluetooth: un robot a trazione integrale che guidi dal telefono con il codice qui sopra.
• Robot evita ostacoli: una macchinina che scandaglia davanti a sé con un HC-SR04 montato sul servo di SER1 e svolta verso la direzione più libera; la guida completa è in Robot evita ostacoli con Arduino.
• Robot seguilinea: segui una linea nera sul pavimento con sensori a infrarossi su A0–A3; la taratura PID è in Robot seguilinea con Arduino.
• Slider per fotocamera: fai scorrere lentamente una fotocamera su una guida con un motore passo-passo e gira dei timelapse.
• Testa pan-tilt: collega due servo ai due connettori per servo e orienta una fotocamera o un laser su due assi; per più servo vedi Braccio robotico Arduino.
• Tenda automatica o nastro trasportatore: apri e chiudi una tenda con un motore DC in base alla luce, oppure costruisci un piccolo nastro trasportatore.

Riassumendo, per usare bene lo shield motori L293D: installa la libreria V1, controlla il LED PWR, imposta il jumper in base allo schema di alimentazione, non dimenticare setSpeed(), collega i sensori ad A0–A5 e tieni i motori sotto il limite di 0,6 A. Con queste regole un piccolo shield porta da solo tutta la forza di un robot a quattro motori. Nell'app BlueGrays trovi la macchinina comandata via Bluetooth, il robot evita ostacoli e progetti con motori passo-passo e servo, passo dopo passo, con schemi elettrici e codice.