Componenti · 12 min di lettura

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.

Motoriduttore TT giallo con ruota
Motore TT giallo e ruota da 65 mm: riduttore 1:48, tensione di lavoro 3–6 V e albero che esce da entrambi i lati.

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.

CaratteristicaMotore TT giallo (1:48, valori tipici)
Tensione di lavoro3–6 V DC
Rapporto di riduzione1:48 (esistono anche versioni 1:120 e 1:220)
Velocità d'uscita a vuotoCirca 90–120 giri/min a 3 V, circa 200–250 giri/min a 6 V
Corrente a vuotoCirca 150 mA
Corrente di stalloCirca 1,2 A a 4,5 V, circa 1,5 A a 6 V
Coppia di stalloCirca 0,4 kg·cm a 3 V, circa 0,8 kg·cm a 6 V
AlberoAlbero in plastica a doppia uscita con due facce piane
Corpo e ingranaggiPlastica; circa 70 × 22 × 18 mm, 30 g
RuotaCirca 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.

RapportoVelocità d'uscita (6 V, a vuoto)CoppiaUso adatto
1:48Circa 200–250 giri/minMediaAuto robot, inseguitore di linea, robot che evita ostacoli
1:120Circa 80–100 giri/minAltaAuto con carico pesante, movimento lento e controllato
1:220Circa 45–55 giri/minMolto altaPorta, tenda, piatto rotante, inseguitore solare
Veloce ma debole o lento ma forte: con il rapporto di riduzione non puoi avere entrambe le cose. Per un'auto da corsa basta 1:48; per un robot che deve salire una rampa o portare un carico pesante di batterie, sensori e display, 1:120 è più sicuro. Quando scegli le batterie puoi controllare la capacità totale con il calcolatore di durata della batteria.

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.

Non alimentare mai il motore direttamente dal pin 5V o da un pin digitale di Arduino. Un pin fornisce al massimo 20–40 mA; il motore TT assorbe 150 mA anche a vuoto e 1,5 A in stallo. Inoltre, quando si ferma, il motore genera una tensione inversa (forza controelettromotrice). Alimenta sempre il motore tramite un driver (L298N, L9110S, TB6612FNG) o un MOSFET con diodo, con una batteria separata il cui negativo sia collegato al GND di Arduino.

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.

SituazioneCorrente tipica (6 V)Cosa significa?
Ruota sollevata, a vuoto150–170 mAAttrito di ingranaggi e spazzole; il motore è sano
Robot in marcia su pavimento piano200–350 mAFunzionamento normale; usa questo valore per il calcolo della batteria
Rampa o tappeto400–700 mAIl motore fatica; valuta il rapporto 1:120 o un telaio più leggero
Ruota bloccata (stallo)1,2–1,5 ACaso peggiore per driver e batteria; se dura, il motore si scalda
Momento dell'avvioPer un attimo fino a 1 APuò 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

Modulo driver per due motori L298N
Il modulo L298N può pilotare due motori TT insieme; ma poiché perde circa 2 V, i motori ricevono meno della tensione della batteria.
DriverCorrente per canaleCaduta di tensioneNota
L298N2 ACirca 1,5–2,5 VRobusto 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 VSi monta sull'Uno e pilota quattro motori; al limite per i TT
L9110S0,8 ABassaPiccolo ed economico; va in difficoltà con la corrente di stallo
TB6612FNG1,2 A (picco 3,2 A)Molto bassa (MOSFET)Sfrutta bene la tensione della batteria, tra le scelte migliori per i TT
CollegamentoArduino UnoESP32Raspberry Pi Pico
L298N ENA (velocità motore sinistro, PWM)D5GPIO 25GP15
L298N IN1 / IN2D7 / D8GPIO 27 / GPIO 33GP14 / GP13
L298N ENB (velocità motore destro, PWM)D6GPIO 26GP10
L298N IN3 / IN4D9 / D4GPIO 32 / GPIO 4GP12 / GP11
Uscita encoder sinistro / destro (LM393)D2 / D3GPIO 34 / GPIO 35GP16 / GP17
VCC del modulo encoder5V3V33V3(OUT)
GNDNegativo della batteria, L298N e GND di Arduino in comuneIn comuneIn 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à

C++ (Arduino IDE)
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.

  1. Fai avanzare il robot per 2–3 metri su un pavimento piano con lo stesso PWM e annota da che parte devia.
  2. Se l'auto va a destra, il motore sinistro è più veloce; abbassa SOL_KATSAYI a 0,95 e riprova.
  3. Cambia il fattore a passi di 0,01–0,02 finché l'auto va dritta; di solito bastano 3–5 tentativi.
  4. Ripeti la prova in retromarcia; se la differenza è grande, usa fattori diversi per avanti e indietro.
  5. 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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?

Micromotoriduttore DC N20
Micromotoriduttore N20: ingranaggi metallici, albero a D da 3 mm e circa un quinto del volume di un motore TT.
CaratteristicaMotore TT (giallo)Micromotore N20
DimensioniCirca 70 × 22 × 18 mmSezione di circa 12 × 10 mm, lunghezza 25–35 mm
IngranaggiPlasticaMetallo
Versioni di tensione3–6 VVersioni da 3 V, 6 V e 12 V
Rapporto di riduzioneDi solito 1:48 (1:120, 1:220)Ampia scelta da 1:10 a 1:1000
AlberoIn plastica, con due facce pianeAlbero metallico a D da 3 mm
EncoderDisco e sensore a forcella separatiDiffuse le versioni con encoder Hall magnetico montato sul retro
Prezzo e durataMolto economico, ingranaggi che si consumano col tempoPiù caro, più preciso e più duraturo
Progetti adattiRobot didattici, kit di auto robotMini 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

SintomoCausa probabileSoluzione
Il motore ronza ma non giraPWM sotto la zona morta o batteria scaricaAumenta MIN_PWM, misura la tensione della batteria
Il motore va sempre al massimoJumper ENA/ENB inserito o pin senza PWMTogli il jumper; sull'Uno usa i pin 3, 5, 6, 9, 10, 11
L'auto non va drittaDifferenza di produzione tra i motoriBilancia con un fattore o crea un anello chiuso con gli encoder
Arduino si resetta quando parte il motoreLa corrente di avvio fa crollare la tensione, disturbi delle spazzoleMetti 100 nF sui terminali del motore e 470 µF all'ingresso del driver; alimenta Arduino a parte
Una ruota gira al contrarioFili del motore invertitiScambia sul driver i due fili di quel motore
Velocità inferiore al previsto2 V persi nell'L298NUsa una batteria a tensione più alta o un driver MOSFET come il TB6612FNG
L'encoder conta troppi impulsiRimbalzi del sensore sul bordo della fessuraUsa un filtro di 2 ms nell'interrupt e centra il disco nel sensore
Dopo aver montato il robot, prova ogni motore da solo con la ruota sollevata: verifica che avanti, indietro e stop funzionino bene e che i due motori facciano più o meno lo stesso rumore. Se uno suona chiaramente diverso, i suoi ingranaggi potrebbero avere attrito o un dente rotto; risolvere il problema prima di mettere il robot a terra fa risparmiare ore.

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.

Vedi tutti i progetti
Auto controllata via Bluetooth con L298N
AR-80Avanzato
Premium

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…

5.0(39)
66
Robot che evita gli ostacoli
AR-81Avanzato
Premium

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.

5.0(38)
49
TCRT5000 Rilevamento di superfici bianche e nere
AR-78Intermedio
Premium

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.

4.7(40)
49
Lettura della riflessione (prossimità) con TCRT5000
AR-77Intermedio
Premium

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.

4.6(33)
43
Servocomando con joystick
AR-60Intermedio
Premium

Servocomando con joystick

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

4.7(42)
58
Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
ES-13Intermedio
Premium

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.

4.5(19)
32
Dissolvenza LED ESP32 con PWM
ES-8Principiante

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.

4.8(36)
55
Raspberry Pi Pico PWM LED Fade (Effetto Respiro)
PI-14Principiante

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.

4