Motoriduttore DC con Arduino: motore TT, velocità ed encoder
Cos'è un motoriduttore DC (motore TT giallo)? Rapporto 1:48, velocità e coppia, 3–6 V, misura della corrente, PWM, condensatore antidisturbo, encoder e N20.
Un motoriduttore DC è un piccolo motore in corrente continua veloce a cui si aggiunge sull'albero una scatola di ingranaggi (riduttore) per abbassare la velocità e aumentare la coppia. Il motore TT giallo in plastica che vedi sulle auto robot con Arduino è il membro più diffuso di questa famiglia: il motore interno gira migliaia di volte al minuto, ma grazie agli ingranaggi la ruota fa solo 100–250 giri al minuto e acquista forza sufficiente per muovere un'auto senza fatica. Di solito si vende in kit con una ruota in gomma da 65 mm e funziona a 3–6 V.
In questa guida imparerai come il rapporto di riduzione (1:48) cambia velocità e coppia, quali sono tensione, corrente e velocità del motore TT, come misurare la corrente assorbita e come scegliere il driver giusto. Poi vedrai perché due motori girano a velocità diverse con lo stesso valore PWM e li pareggerai prima via software e poi misurando con un disco encoder. Troverai anche i condensatori antidisturbo, il codice per ESP32 e Raspberry Pi Pico e un confronto con il micromotore N20.

Che cos'è un motoriduttore DC e come funziona?
Un normale piccolo motore DC gira a vuoto a 8.000–10.000 giri/min, ma ha pochissima coppia; montato direttamente su una ruota non muove l'auto. Il riduttore, con ingranaggi che si incastrano tra loro, abbassa questa velocità elevata e aumenta la coppia nello stesso rapporto. Con un rapporto di 1:48 l'albero d'uscita fa 1 giro mentre l'albero del motore ne fa 48: la velocità viene divisa per 48 e la coppia moltiplicata per circa 48 (meno le perdite per attrito degli ingranaggi). La potenza (coppia × velocità) resta la stessa; il riduttore si limita a scambiare velocità con forza. Per questo il motoriduttore è ideale per movimenti lenti ma potenti, come ruote, argani, porte o nastri trasportatori.
| Caratteristica | Motore TT giallo (1:48, valori tipici) |
|---|---|
| Tensione di lavoro | 3–6 V DC |
| Rapporto di riduzione | 1:48 (esistono anche versioni 1:120 e 1:220) |
| Velocità d'uscita a vuoto | Circa 90–120 giri/min a 3 V, circa 200–250 giri/min a 6 V |
| Corrente a vuoto | Circa 150 mA |
| Corrente di stallo | Circa 1,2 A a 4,5 V, circa 1,5 A a 6 V |
| Coppia di stallo | Circa 0,4 kg·cm a 3 V, circa 0,8 kg·cm a 6 V |
| Albero | Albero in plastica a doppia uscita con due facce piane |
| Corpo e ingranaggi | Plastica; circa 70 × 22 × 18 mm, 30 g |
| Ruota | Circa 65 mm di diametro, in gomma |
Calcolo di rapporto, velocità e coppia
Per scegliere un motore o stimare quanto andrà veloce un robot bastano pochi calcoli semplici. La circonferenza della ruota è π × diametro: per una ruota da 65 mm, 3,14 × 6,5 ≈ 20,4 cm. Una ruota che gira a vuoto a 200 giri/min con 6 V percorre 200 × 20,4 = 4080 cm al minuto, cioè circa 0,68 m/s; sotto carico il valore scende del 20–30%. Per la coppia, 0,8 kg·cm al raggio di 3,25 cm della ruota corrispondono a una spinta di 0,8 / 3,25 ≈ 0,25 kg; è il massimo che il motore può dare prima di fermarsi. Un motore non dovrebbe lavorare a lungo oltre circa un terzo della sua coppia di stallo.
| Rapporto | Velocità d'uscita (6 V, a vuoto) | Coppia | Uso adatto |
|---|---|---|---|
| 1:48 | Circa 200–250 giri/min | Media | Auto robot, inseguitore di linea, robot che evita ostacoli |
| 1:120 | Circa 80–100 giri/min | Alta | Auto con carico pesante, movimento lento e controllato |
| 1:220 | Circa 45–55 giri/min | Molto alta | Porta, tenda, piatto rotante, inseguitore solare |
Con quanti volt funziona un motore TT?
La tensione nominale del motore TT è 3–6 V, e in questo intervallo la velocità cambia quasi in proporzione alla tensione. La fonte più comune sono 4 pile AA: le alcaline nuove danno 6,0–6,4 V, le ricaricabili Ni-MH 4,8–5,2 V. Due celle Li-ion 18650 danno 8,4 V a piena carica, troppo per un motore da 6 V; ma driver come l'L298N perdono circa 2 V, quindi al motore arrivano circa 6 V. Con un driver più efficiente puoi limitare il PWM massimo: per ottenere in media 6 V da 8,4 V usa al massimo 255 × 6 / 8,4 ≈ 182. I dettagli sulle batterie sono negli articoli alimentare Arduino a batteria e capacità della batteria in mAh.
Misurare la corrente assorbita dal motore
Conoscere la corrente ti permette di scegliere il driver giusto e di calcolare quanto durerà la batteria. Il modo più semplice è impostare il multimetro sulla corrente e collegarlo in serie al motore: inserisci il puntale rosso nella boccola 10A, scollega il filo che arriva dal positivo della batteria e metti il multimetro in mezzo. Misura prima con il motore sollevato (a vuoto), poi con il robot a terra e infine tenendo ferma la ruota con la mano per un attimo. Per l'uso del multimetro leggi come usare il multimetro, per tenere sotto controllo la corrente in continuo con Arduino l'articolo sensore di corrente ACS712.
| Situazione | Corrente tipica (6 V) | Cosa significa? |
|---|---|---|
| Ruota sollevata, a vuoto | 150–170 mA | Attrito di ingranaggi e spazzole; il motore è sano |
| Robot in marcia su pavimento piano | 200–350 mA | Funzionamento normale; usa questo valore per il calcolo della batteria |
| Rampa o tappeto | 400–700 mA | Il motore fatica; valuta il rapporto 1:120 o un telaio più leggero |
| Ruota bloccata (stallo) | 1,2–1,5 A | Caso peggiore per driver e batteria; se dura, il motore si scalda |
| Momento dell'avvio | Per un attimo fino a 1 A | Può far crollare la tensione della batteria e resettare Arduino |
Da questi valori la durata della batteria si ricava facilmente: un robot i cui due motori assorbono in tutto 0,6 A su pavimento piano funziona circa 2000 / 600 ≈ 3,3 ore con pile AA Ni-MH da 2000 mAh. Per scegliere il driver si guarda la corrente di stallo: l'L9110S fornisce circa 800 mA per canale, al limite per i motori TT; il TB6612FNG, con 1,2 A continui e 3,2 A di picco per canale, ha più margine. Per calcolare in fretta il rapporto tra corrente, tensione e resistenza puoi usare il calcolatore della legge di Ohm.
Scegliere e collegare il driver del motore

| Driver | Corrente per canale | Caduta di tensione | Nota |
|---|---|---|---|
| L298N | 2 A | Circa 1,5–2,5 V | Robusto e diffuso; con 4×AA al motore restano circa 4–4,5 V |
| L293D (shield) | 0,6 A (picco 1,2 A) | Circa 1,5–2,5 V | Si monta sull'Uno e pilota quattro motori; al limite per i TT |
| L9110S | 0,8 A | Bassa | Piccolo ed economico; va in difficoltà con la corrente di stallo |
| TB6612FNG | 1,2 A (picco 3,2 A) | Molto bassa (MOSFET) | Sfrutta bene la tensione della batteria, tra le scelte migliori per i TT |
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| L298N ENA (velocità motore sinistro, PWM) | D5 | GPIO 25 | GP15 |
| L298N IN1 / IN2 | D7 / D8 | GPIO 27 / GPIO 33 | GP14 / GP13 |
| L298N ENB (velocità motore destro, PWM) | D6 | GPIO 26 | GP10 |
| L298N IN3 / IN4 | D9 / D4 | GPIO 32 / GPIO 4 | GP12 / GP11 |
| Uscita encoder sinistro / destro (LM393) | D2 / D3 | GPIO 34 / GPIO 35 | GP16 / GP17 |
| VCC del modulo encoder | 5V | 3V3 | 3V3(OUT) |
| GND | Negativo della batteria, L298N e GND di Arduino in comune | In comune | In comune |
Non dimenticare di togliere i jumper di ENA ed ENB; se restano inseriti, il motore ignora il PWM e gira sempre alla massima velocità. Tutti i pin dell'L298N e il comportamento in frenata e a ruota libera sono spiegati in dettaglio nell'articolo motore DC e L298N. Se un motore gira al contrario, la soluzione più pulita è scambiare i suoi due fili sul driver invece di cambiare il codice.
Codice Arduino: avanti, indietro, svolta e pareggio della velocità
1// İki TT motoru L298N ile: ileri, geri, dönüş ve hız dengeleme
2// Two TT motors with an L298N: forward, reverse, turning and speed trim
3const byte ENA = 5, IN1 = 7, IN2 = 8; // sol motor / left motor
4const byte ENB = 6, IN3 = 9, IN4 = 4; // sağ motor / right motor
5const int MIN_PWM = 70; // altında motor kalkamaz / below this the motor won't start
6const float SOL_KATSAYI = 1.00; // hızlı motoru yavaşlatmak için / to slow the faster motor
7const float SAG_KATSAYI = 0.92;
8
9void motorSur(byte en, byte inA, byte inB, int hiz, float katsayi) { // hiz: -255..255
10 int pwm = abs(hiz) * katsayi;
11 if (pwm > 0 && pwm < MIN_PWM) pwm = MIN_PWM; // ölü bölgeyi atla / skip the dead zone
12 digitalWrite(inA, hiz > 0 ? HIGH : LOW);
13 digitalWrite(inB, hiz < 0 ? HIGH : LOW);
14 analogWrite(en, hiz == 0 ? 0 : pwm);
15}
16
17void sur(int sol, int sag) {
18 motorSur(ENA, IN1, IN2, sol, SOL_KATSAYI);
19 motorSur(ENB, IN3, IN4, sag, SAG_KATSAYI);
20}
21
22void setup() {
23 byte pinler[] = {ENA, IN1, IN2, ENB, IN3, IN4};
24 for (byte p : pinler) pinMode(p, OUTPUT);
25}
26
27void loop() {
28 sur(200, 200); // ileri / forward
29 delay(2000);
30 sur(0, 0); // dur / stop
31 delay(500);
32 sur(-180, -180); // geri / reverse
33 delay(1500);
34 sur(0, 0);
35 delay(500);
36 sur(180, -180); // yerinde sağa dön / spin right in place
37 delay(600);
38 sur(0, 0);
39 delay(1500);
40}Nel codice, MIN_PWM è il valore PWM più basso con cui il motore vince l'attrito statico e inizia a girare. I pin 5 e 6 dell'Uno generano un PWM a circa 980 Hz; sotto un valore compreso tra 60 e 90 i motori TT di solito ronzano soltanto, senza girare. Trovare questo valore per il tuo motore è facile: parti da PWM 0, sali di cinque in cinque e annota il valore a cui la ruota gira per la prima volta. Per capire come funziona il PWM e la sua frequenza leggi Che cos'è il PWM?.
Perché due motori girano a velocità diverse?
Quando dai lo stesso PWM a due motori TT della stessa scatola ti aspetti che il robot vada dritto, ma di solito l'auto devia da una parte. Il motivo sono le differenze di produzione dei motori economici: tolleranze di spazzole e magneti, attrito degli ingranaggi, lubrificazione e allineamento degli alberi in plastica cambiano un po' da un motore all'altro. La tolleranza di ±10% indicata dai venditori può tradursi in una differenza di velocità fino al 20% tra due motori. In più la differenza non è fissa: cambia quando cala la tensione della batteria, quando il motore si scalda o quando cambia il pavimento. E poiché i motori sono montati a specchio, uno gira in avanti e l'altro all'indietro dal punto di vista del motore, e alcuni motori hanno velocità diverse nei due sensi.
- Fai avanzare il robot per 2–3 metri su un pavimento piano con lo stesso PWM e annota da che parte devia.
- Se l'auto va a destra, il motore sinistro è più veloce; abbassa SOL_KATSAYI a 0,95 e riprova.
- Cambia il fattore a passi di 0,01–0,02 finché l'auto va dritta; di solito bastano 3–5 tentativi.
- Ripeti la prova in retromarcia; se la differenza è grande, usa fattori diversi per avanti e indietro.
- La regolazione può cambiare quando varia la tensione della batteria; per una soluzione permanente che si corregge da sola passa al metodo con encoder descritto più avanti.
Eliminare i disturbi: condensatori sul motore
Quando un motore DC a spazzole gira, tra spazzole e collettore si formano piccole scintille. Queste scintille provocano picchi di tensione sulla linea di alimentazione e disturbi elettrici irradiati nell'aria. I sintomi sono noti: Arduino si resetta da solo quando parte il motore, nel Monitor seriale compaiono caratteri strani, il sensore a ultrasuoni misura distanze assurde o la connessione Bluetooth cade. La soluzione è soffocare i disturbi alla fonte, direttamente sul motore.
- 100 nF tra i terminali del motore: salda tra i due terminali di ogni motore un condensatore ceramico da 100 nF con la sigla 104. Tieni i reofori più corti possibile.
- Altri due verso il corpo: nei motori con corpo metallico, aggiungere un 100 nF da ciascun terminale al corpo riduce ancora i disturbi. Il corpo del motore TT è in plastica, quindi di solito basta il condensatore tra i terminali.
- Elettrolitico sull'alimentazione del driver: metti un condensatore elettrolitico da 470–1000 µF sull'ingresso di alimentazione dell'L298N; attenua il calo di tensione della batteria all'avvio.
- Intreccia i fili: attorciglia tra loro i due fili del motore; così irradiano meno disturbi.
- Separa le alimentazioni: se possibile alimenta Arduino e motori con batterie separate e unisci i GND in un unico punto.
Trovi come funzionano i condensatori e come leggerne le sigle in Che cos'è un condensatore?, e altre cause dei reset quando il motore gira in Arduino si resetta da solo.
Misurare la velocità con un disco encoder
L'albero del motore TT esce da entrambi i lati; sull'estremità senza ruota si monta di solito il disco encoder in plastica a 20 fessure fornito con il kit. Le fessure passano tra i bracci di un sensore ottico a forcella a U (un modulo con comparatore LM393) e ogni fessura produce un impulso. Poiché il disco gira alla stessa velocità della ruota, 20 impulsi sono un giro di ruota. Se in mezzo secondo si contano 30 impulsi, la ruota ha fatto 30 / 20 = 1,5 giri, cioè 1,5 × 120 = 180 giri/min. Moltiplicando i giri per la circonferenza della ruota ottieni anche la distanza percorsa: ogni impulso vale circa 20,4 / 20 ≈ 1 cm.
Il codice seguente misura la velocità delle due ruote e regola automaticamente il PWM del motore destro finché i due lati contano lo stesso numero di impulsi. È un semplice regolatore proporzionale (P): più grande è la differenza, più grande è la correzione. Poiché i sensori a forcella possono dare più impulsi al passaggio di un bordo, la funzione di interrupt ignora gli impulsi distanti meno di 2 ms. Per i dettagli sugli interrupt leggi l'articolo interrupt su Arduino.
1// 20 yarıklı enkoder diskiyle devir ölçümü ve iki motoru eşitleme
2// RPM measurement with 20-slot encoder discs and matching two motors
3const byte ENA = 5, IN1 = 7, IN2 = 8; // sol motor / left motor
4const byte ENB = 6, IN3 = 9, IN4 = 4; // sağ motor / right motor
5const byte ENC_SOL = 2, ENC_SAG = 3; // LM393 yarık sensörleri / slot sensors
6const byte YARIK = 20; // disk başına yarık / slots per disc
7const int TEMEL_PWM = 180; // sol motorun sabit hızı / fixed left speed
8const float KP = 4.0; // oransal kazanç / proportional gain
9
10volatile unsigned int solSayac = 0, sagSayac = 0;
11volatile unsigned long solSon = 0, sagSon = 0;
12int sagPwm = TEMEL_PWM;
13unsigned long oncekiZaman = 0;
14
15void solDarbe() {
16 unsigned long t = micros();
17 if (t - solSon > 2000) { // 2 ms'den yakın darbeleri yok say / ignore bounces
18 solSayac++;
19 solSon = t;
20 }
21}
22
23void sagDarbe() {
24 unsigned long t = micros();
25 if (t - sagSon > 2000) {
26 sagSayac++;
27 sagSon = t;
28 }
29}
30
31void setup() {
32 Serial.begin(9600);
33 byte pinler[] = {ENA, IN1, IN2, ENB, IN3, IN4};
34 for (byte p : pinler) pinMode(p, OUTPUT);
35 pinMode(ENC_SOL, INPUT);
36 pinMode(ENC_SAG, INPUT);
37 attachInterrupt(digitalPinToInterrupt(ENC_SOL), solDarbe, RISING);
38 attachInterrupt(digitalPinToInterrupt(ENC_SAG), sagDarbe, RISING);
39 digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW); // iki motor da ileri / both forward
40 digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);
41 analogWrite(ENA, TEMEL_PWM);
42 analogWrite(ENB, sagPwm);
43}
44
45void loop() {
46 if (millis() - oncekiZaman >= 500) { // yarım saniyede bir / every half second
47 oncekiZaman = millis();
48 noInterrupts();
49 unsigned int sol = solSayac, sag = sagSayac;
50 solSayac = 0;
51 sagSayac = 0;
52 interrupts();
53
54 float solDevir = sol * 120.0 / YARIK; // 0,5 s'deki darbe -> d/dk / pulses in 0.5 s -> rpm
55 float sagDevir = sag * 120.0 / YARIK;
56 sagPwm += (int)(KP * ((int)sol - (int)sag)); // sağ geride kaldıysa hızlandır / speed up if behind
57 sagPwm = constrain(sagPwm, 70, 255);
58 analogWrite(ENB, sagPwm);
59
60 Serial.print(F("Sol / Left: "));
61 Serial.print(solDevir, 0);
62 Serial.print(F(" d/dk Sag / Right: "));
63 Serial.print(sagDevir, 0);
64 Serial.print(F(" d/dk Sag PWM: "));
65 Serial.println(sagPwm);
66 }
67}Avviando il codice vedrai nel Monitor seriale che il PWM destro cambia nei primi secondi e poi le velocità delle due ruote si avvicinano. Se KP è troppo grande il motore destro oscilla accelerando e rallentando; se è troppo piccolo la correzione è lenta; provare valori tra 2 e 6 è un buon inizio. Per una guida più precisa puoi anche pareggiare la distanza totale o scrivere un regolatore PID completo. Il sensore dell'encoder funziona in modo simile ai sensori a infrarossi dei robot inseguitori di linea; dettagli nell'articolo sensore a infrarossi TCRT5000.
Controllare un motore TT con l'ESP32
I pin a 3,3 V dell'ESP32 pilotano senza problemi gli ingressi di L298N e TB6612FNG, perché questi driver considerano HIGH tutto ciò che supera 2,3 V. Il core Arduino dell'ESP32 supporta analogWrite; la frequenza PWM predefinita è di circa 1 kHz. Alimenta i sensori dell'encoder a 3V3 così anche le loro uscite sono a 3,3 V; i GPIO 34 e 35 sono solo ingressi e perfetti per gli encoder. Grazie a Wi-Fi e Bluetooth dell'ESP32 puoi comandare il robot dal telefono e mostrare la velocità su una pagina web.
1// ESP32: iki TT motor, enkoderle devir ölçümü / two TT motors with RPM measurement
2const int ENA = 25, IN1 = 27, IN2 = 33; // sol motor / left motor
3const int ENB = 26, IN3 = 32, IN4 = 4; // sağ motor / right motor
4const int ENC_SOL = 34, ENC_SAG = 35; // yalnız giriş pinleri / input-only pins
5const int YARIK = 20;
6
7volatile uint32_t solSayac = 0, sagSayac = 0;
8portMUX_TYPE kilit = portMUX_INITIALIZER_UNLOCKED;
9
10void IRAM_ATTR solDarbe() {
11 portENTER_CRITICAL_ISR(&kilit);
12 solSayac++;
13 portEXIT_CRITICAL_ISR(&kilit);
14}
15
16void IRAM_ATTR sagDarbe() {
17 portENTER_CRITICAL_ISR(&kilit);
18 sagSayac++;
19 portEXIT_CRITICAL_ISR(&kilit);
20}
21
22void sur(int sol, int sag) { // -255..255
23 digitalWrite(IN1, sol > 0); digitalWrite(IN2, sol < 0);
24 digitalWrite(IN3, sag > 0); digitalWrite(IN4, sag < 0);
25 analogWrite(ENA, abs(sol));
26 analogWrite(ENB, abs(sag));
27}
28
29void setup() {
30 Serial.begin(115200);
31 int pinler[] = {ENA, IN1, IN2, ENB, IN3, IN4};
32 for (int p : pinler) pinMode(p, OUTPUT);
33 pinMode(ENC_SOL, INPUT);
34 pinMode(ENC_SAG, INPUT);
35 attachInterrupt(digitalPinToInterrupt(ENC_SOL), solDarbe, RISING);
36 attachInterrupt(digitalPinToInterrupt(ENC_SAG), sagDarbe, RISING);
37 sur(180, 180); // ileri / forward
38}
39
40void loop() {
41 delay(1000);
42 portENTER_CRITICAL(&kilit);
43 uint32_t sol = solSayac, sag = sagSayac;
44 solSayac = 0;
45 sagSayac = 0;
46 portEXIT_CRITICAL(&kilit);
47 Serial.printf("Sol / Left: %.0f d/dk Sag / Right: %.0f d/dk\n",
48 sol * 60.0 / YARIK, sag * 60.0 / YARIK); // 1 s'deki darbe -> d/dk / pulses in 1 s -> rpm
49}Motore TT con Raspberry Pi Pico e MicroPython
Sul Pico ogni GPIO può generare PWM. In MicroPython imposti la frequenza dell'oggetto PWM a 1 kHz e dai la velocità con duty_u16() nell'intervallo 0–65535; 65535 significa velocità massima. Il codice seguente fa girare il motore sinistro a velocità diverse e ne misura i giri con l'encoder. Se vuoi alimentare il Pico con la stessa batteria dei motori, puoi collegare l'uscita 5V dell'L298N al pin VSYS.
1from machine import Pin, PWM
2import machine
3import time
4
5ena = PWM(Pin(15)) # sol motor hızı / left motor speed
6ena.freq(1000)
7in1 = Pin(14, Pin.OUT)
8in2 = Pin(13, Pin.OUT)
9YARIK = 20
10sayac = 0
11
12def darbe(pin): # enkoder kesmesi / encoder interrupt
13 global sayac
14 sayac += 1
15
16enc = Pin(16, Pin.IN)
17enc.irq(trigger=Pin.IRQ_RISING, handler=darbe)
18
19def motor(hiz): # hiz: -100..100 (%)
20 in1.value(1 if hiz > 0 else 0)
21 in2.value(1 if hiz < 0 else 0)
22 ena.duty_u16(int(abs(hiz) * 65535 / 100))
23
24for hiz in (40, 60, 80, 100):
25 motor(hiz)
26 time.sleep(1) # hızlanmayı bekle / let it settle
27 durum = machine.disable_irq()
28 sayac = 0
29 machine.enable_irq(durum)
30 time.sleep(1) # 1 saniye say / count for 1 second
31 print("PWM %{}: {} d/dk".format(hiz, sayac * 60 // YARIK))
32motor(0)Motore TT o micromotore N20?

| Caratteristica | Motore TT (giallo) | Micromotore N20 |
|---|---|---|
| Dimensioni | Circa 70 × 22 × 18 mm | Sezione di circa 12 × 10 mm, lunghezza 25–35 mm |
| Ingranaggi | Plastica | Metallo |
| Versioni di tensione | 3–6 V | Versioni da 3 V, 6 V e 12 V |
| Rapporto di riduzione | Di solito 1:48 (1:120, 1:220) | Ampia scelta da 1:10 a 1:1000 |
| Albero | In plastica, con due facce piane | Albero metallico a D da 3 mm |
| Encoder | Disco e sensore a forcella separati | Diffuse le versioni con encoder Hall magnetico montato sul retro |
| Prezzo e durata | Molto economico, ingranaggi che si consumano col tempo | Più caro, più preciso e più duraturo |
| Progetti adatti | Robot didattici, kit di auto robot | Mini sumo, inseguitori di linea veloci, piccoli meccanismi |
In breve, il motore TT è il miglior punto di partenza per la prima auto robot e per i progetti scolastici perché è economico e facile da montare. Se ti serve un meccanismo più piccolo, preciso e duraturo, o stai costruendo un robot da gara, è preferibile l'N20; gli N20 con encoder misurano sull'albero del motore e danno centinaia di impulsi per giro di ruota, con una misura della velocità molto più precisa. Per una panoramica di quale motore va bene per quale lavoro leggi l'articolo differenze tra motore DC, servo e passo-passo.
Idee di progetto con un motoriduttore
- Auto robot: costruisci un'auto comandata via Bluetooth con due motori TT, una ruota pivottante e un L298N; tutti i passi nell'articolo costruire un'auto robot con Arduino.
- Robot inseguitore di linea: segui una linea nera con sensori a infrarossi; qui l'equilibrio di velocità dei motori è fondamentale. Vedi robot inseguitore di linea.
- Robot che evita gli ostacoli: rileva gli ostacoli con un HC-SR04 e cambia direzione; montaggio nell'articolo robot che evita gli ostacoli.
- Ruota di misura: fai rotolare a terra una ruota con encoder per creare un metro digitale per le stanze; ogni impulso vale circa 1 cm.
- Tenda automatica: apri la tenda al mattino e chiudila la sera con un motore TT 1:220; attivala in base alla luce con un LDR.
- Piatto rotante espositivo: realizza con un motore lento una base che fa girare piano un piccolo prodotto o un modellino.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il motore ronza ma non gira | PWM sotto la zona morta o batteria scarica | Aumenta MIN_PWM, misura la tensione della batteria |
| Il motore va sempre al massimo | Jumper ENA/ENB inserito o pin senza PWM | Togli il jumper; sull'Uno usa i pin 3, 5, 6, 9, 10, 11 |
| L'auto non va dritta | Differenza di produzione tra i motori | Bilancia con un fattore o crea un anello chiuso con gli encoder |
| Arduino si resetta quando parte il motore | La corrente di avvio fa crollare la tensione, disturbi delle spazzole | Metti 100 nF sui terminali del motore e 470 µF all'ingresso del driver; alimenta Arduino a parte |
| Una ruota gira al contrario | Fili del motore invertiti | Scambia sul driver i due fili di quel motore |
| Velocità inferiore al previsto | 2 V persi nell'L298N | Usa una batteria a tensione più alta o un driver MOSFET come il TB6612FNG |
| L'encoder conta troppi impulsi | Rimbalzi del sensore sul bordo della fessura | Usa un filtro di 2 ms nell'interrupt e centra il disco nel sensore |
Il motoriduttore TT è un componente economico ma molto istruttivo per imparare il compromesso tra velocità e coppia in un riduttore, il controllo di velocità con il PWM e la retroazione con un encoder. Con il driver giusto, qualche condensatore e un semplice codice di bilanciamento, il tuo robot va dritto e in modo affidabile. Nell'app BlueGrays trovi l'auto comandata via Bluetooth, il robot che evita gli ostacoli e progetti con sensori a infrarossi, con schemi e codice passo passo, per trasformare subito questi motori in un progetto.
Domande frequenti
Che cos'è un motoriduttore DC?
Un motoriduttore DC è un piccolo motore in corrente continua veloce con una scatola di ingranaggi sull'albero. Gli ingranaggi riducono la velocità e aumentano la coppia nello stesso rapporto; con 1:48 l'albero d'uscita fa 1 giro mentre quello del motore ne fa 48. Così un piccolo motore può muovere facilmente un'auto robot o un meccanismo.
Con quanti volt funziona un motore TT?
I motori TT gialli funzionano tra 3 e 6 V, e l'alimentazione più comune sono 4 pile AA. Girano a circa 90–120 giri/min a 3 V e a circa 200–250 giri/min a 6 V. Una tensione superiore a 6 V rende il motore più veloce, ma lo fa scaldare e consuma in fretta gli ingranaggi.
Quanta corrente assorbe un motore TT?
Circa 150 mA a vuoto e 200–350 mA in un robot che viaggia su pavimento piano. Con la ruota bloccata la corrente può salire a 1,5 A a 6 V. Per questo driver e batteria vanno scelti in base alla corrente di stallo, e il motore non va mai alimentato direttamente da un pin di Arduino.
Perché due motori DC non girano alla stessa velocità?
I motori economici differiscono per spazzole, magneti, attrito degli ingranaggi e lubrificazione; anche con lo stesso PWM le velocità possono variare del 10–20%. Anche tensione della batteria e temperatura cambiano la differenza. Applicare via software un fattore al motore più veloce, oppure misurare con gli encoder la velocità delle due ruote e regolare il PWM in automatico, risolve il problema.
Perché si mette un condensatore su un motore DC?
Girando, i motori a spazzole producono piccole scintille che generano disturbi elettrici. Questi disturbi possono resettare Arduino, falsare le letture dei sensori e interrompere le connessioni wireless. Un condensatore ceramico da 100 nF saldato tra i terminali del motore elimina i disturbi alla fonte.
Come si misura la velocità di un motore con un disco encoder?
Un disco con fessure montato sull'albero del motore passa in un sensore ottico a forcella e ogni fessura produce un impulso. Arduino conta questi impulsi con un interrupt; con un disco a 20 fessure, 20 impulsi sono un giro di ruota. Dividendo gli impulsi di un secondo per 20 e moltiplicando per 60 si ottengono i giri al minuto.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Auto controllata via Bluetooth con L298N
Trasforma il telefono in un telecomando e guida la tua auto robot. L'Arduino riceve tramite un modulo Bluetooth i comandi di un'app di controllo remoto sul telefono e fa girare le ruote con un driver…

Robot che evita gli ostacoli
Che ne dite di costruire un veicolo intelligente che trova la propria strada? L'Obstacle Avoiding Robot scruta costantemente l'ambiente circostante grazie al sensore a ultrasuoni posto davanti a lui.

TCRT5000 Rilevamento di superfici bianche e nere
Con il piccolo sensore che fa da occhio ai robot seguilinea capisci se il pavimento è nero o bianco.

Lettura della riflessione (prossimità) con TCRT5000
Con un piccolo sensore che manda luce invisibile e misura quanta ne torna indietro, rilevi la superficie che ha davanti.

Servocomando con joystick
Comanda due motori con un joystick, proprio come se girassi una telecamera di sicurezza.

Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
In questo progetto controlliamo in modo analogico la luminosità di un LED tramite un potenziometro. Il pin ADC dell'ESP32 legge la tensione tra 0 e 3,3 V dal potenziometro; il valore viene convertito in un segnale PWM (Pulse Width Modulation) e inviato al LED. Ruotando il potenziometro, il LED si accende e si spegne gradualmente. Con Arduino Core 3.0+ si usa direttamente analogWrite(); su ESP32-S2/S3 la risoluzione dell'ADC è fissata a 12 bit.

Dissolvenza LED ESP32 con PWM
Modificare la luminosità del LED in modo fluido da 0 a max, da max a 0. Controlliamo il PWM con analogWrite() come in Arduino - la stessa sintassi con ESP32 Arduino Core 3.0+ funziona senza problemi. La definizione del pin + pinMode + analogWrite è sufficiente.

Raspberry Pi Pico PWM LED Fade (Effetto Respiro)
Il LED non lampeggia più — respira! Con il PWM (modulazione di larghezza d'impulso) del Raspberry Pi Pico, la luminosità sale e scende lentamente. Impara la classe machine.PWM, duty_u16() (luminosità a 16 bit 0–65535), la frequenza PWM, i cicli range() e l'uscita quasi analogica. Base per miscelazione colori RGB, controllo motori, servo e buzzer.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

