Componentes · 13 min de lectura

Motor reductor DC con Arduino: motor TT, velocidad y encoder

¿Qué es un motor reductor DC (motor TT amarillo)? Relación 1:48, velocidad y par, 3–6 V, medir corriente, igualar con PWM, condensador, encoder y N20.

Un motor reductor DC es un motor de corriente continua pequeño y rápido al que se le añade una caja de engranajes (reductora) en el eje para bajar la velocidad y subir el par. El motor TT amarillo de plástico que ves en los coches robot con Arduino es el miembro más común de esta familia: el motor interior gira miles de veces por minuto, pero gracias a los engranajes la rueda solo da 100–250 vueltas por minuto y gana fuerza de sobra para mover un coche. Suele venderse en kit con una rueda de goma de 65 mm y funciona con 3–6 V.

En esta guía aprenderás cómo la relación de reducción (1:48) cambia la velocidad y el par, qué valores de tensión, corriente y velocidad tiene el motor TT, cómo medir la corriente que consume y cómo elegir el driver adecuado. Después verás por qué dos motores giran a distinta velocidad con el mismo valor de PWM y los igualarás primero por software y luego midiendo con un disco encoder. También encontrarás los condensadores antirruido, el código para ESP32 y Raspberry Pi Pico y una comparación con el micromotor N20.

Motor reductor TT amarillo con rueda
Motor TT amarillo y rueda de 65 mm: reductora 1:48, tensión de trabajo de 3–6 V y un eje que sale por ambos lados.

¿Qué es un motor reductor DC y cómo funciona?

Un motor DC pequeño normal gira en vacío a 8.000–10.000 rpm, pero su par es muy bajo; si lo pones directamente en una rueda no moverá el coche. La reductora, con engranajes que encajan entre sí, baja esa velocidad tan alta y sube el par en la misma proporción. Con una relación de 1:48, el eje de salida da 1 vuelta por cada 48 vueltas del eje del motor: la velocidad se divide entre 48 y el par se multiplica por unos 48 (menos las pérdidas por rozamiento de los engranajes). La potencia (par × velocidad) no cambia; la reductora solo cambia velocidad por fuerza. Por eso el motor reductor es ideal para trabajos que necesitan un movimiento lento pero fuerte, como ruedas, cabrestantes, puertas o cintas transportadoras.

CaracterísticaMotor TT amarillo (1:48, valores típicos)
Tensión de trabajo3–6 V CC
Relación de reducción1:48 (también hay versiones 1:120 y 1:220)
Velocidad de salida en vacíoUnas 90–120 rpm a 3 V, unas 200–250 rpm a 6 V
Corriente en vacíoUnos 150 mA
Corriente de bloqueoUnos 1,2 A a 4,5 V, unos 1,5 A a 6 V
Par de bloqueoUnos 0,4 kg·cm a 3 V, unos 0,8 kg·cm a 6 V
EjeEje de plástico de doble salida con dos caras planas
Cuerpo y engranajesPlástico; unos 70 × 22 × 18 mm, 30 g
RuedaUnos 65 mm de diámetro, de goma

Cálculo de reducción, velocidad y par

Para elegir un motor o estimar a qué velocidad irá un robot bastan unos cálculos sencillos. La circunferencia de la rueda es π × diámetro: en una rueda de 65 mm, 3,14 × 6,5 ≈ 20,4 cm. Una rueda que gira en vacío a 200 rpm con 6 V recorre 200 × 20,4 = 4080 cm por minuto, unos 0,68 m/s; con carga el valor baja un 20–30 %. En cuanto al par, 0,8 kg·cm en el radio de 3,25 cm de la rueda equivalen a una fuerza de empuje de 0,8 / 3,25 ≈ 0,25 kg; es lo máximo que el motor puede dar antes de pararse. Un motor no debería trabajar mucho tiempo con más de un tercio de su par de bloqueo.

RelaciónVelocidad de salida (6 V, en vacío)ParUso adecuado
1:48Unas 200–250 rpmMedioCoche robot, siguelíneas, robot que evita obstáculos
1:120Unas 80–100 rpmAltoCoche con carga pesada, movimiento lento y controlado
1:220Unas 45–55 rpmMuy altoPuerta, cortina, plataforma giratoria, seguidor solar
Rápido pero débil o lento pero fuerte: con la relación de reducción no puedes tener las dos cosas. Para un coche de carreras basta con 1:48; para un robot que tenga que subir una rampa o cargar baterías, sensores y pantalla, 1:120 es más seguro. Al elegir las pilas puedes comprobar la capacidad total con la calculadora de duración de batería.

¿Con cuántos voltios funciona un motor TT?

La tensión nominal del motor TT es de 3–6 V, y en ese rango la velocidad cambia casi en proporción a la tensión. La fuente más habitual son 4 pilas AA: las alcalinas nuevas dan 6,0–6,4 V y las recargables Ni-MH 4,8–5,2 V. Dos celdas Li-ion 18650 dan 8,4 V cargadas del todo, demasiado para un motor de 6 V; pero drivers como el L298N pierden unos 2 V, así que al motor llegan unos 6 V. Si usas un driver más eficiente, puedes limitar el PWM máximo: para obtener 6 V de media a partir de 8,4 V, usa como mucho 255 × 6 / 8,4 ≈ 182. Tienes los detalles sobre baterías en los artículos alimentar Arduino con pilas y capacidad de batería en mAh.

Nunca alimentes el motor directamente desde el pin de 5V o un pin digital del Arduino. Un pin da como mucho 20–40 mA; el motor TT consume 150 mA incluso en vacío y 1,5 A bloqueado. Además, al pararse el motor genera una tensión inversa (fuerza contraelectromotriz). Alimenta siempre el motor a través de un driver (L298N, L9110S, TB6612FNG) o de un MOSFET con diodo, con una batería aparte cuyo negativo vaya al GND del Arduino.

Medir la corriente que consume el motor

Conocer la corriente te permite elegir el driver adecuado y calcular cuánto durará la batería. Lo más fácil es poner el multímetro en modo corriente y conectarlo en serie con el motor: pon la punta roja en la entrada de 10A, suelta el cable que viene del positivo de la batería y coloca el multímetro en medio. Mide primero con el motor al aire (en vacío), luego con el robot en el suelo y por último sujetando la rueda con la mano un instante. Para usar el multímetro consulta cómo usar un multímetro, y para vigilar la corriente de forma continua con Arduino el artículo sensor de corriente ACS712.

SituaciónCorriente típica (6 V)¿Qué significa?
Rueda al aire, en vacío150–170 mARozamiento de engranajes y escobillas; el motor está sano
Robot circulando por suelo liso200–350 mAFuncionamiento normal; usa este valor para calcular la batería
Rampa o alfombra400–700 mAEl motor sufre; plantéate la relación 1:120 o un chasis más ligero
Rueda bloqueada1,2–1,5 APeor caso para el driver y la batería; si dura, el motor se calienta
Momento del arranqueBrevemente hasta 1 APuede hundir la tensión de la batería y reiniciar el Arduino

A partir de estos valores la duración de la batería sale sola: un robot cuyos dos motores consumen 0,6 A en total sobre suelo liso funciona unas 2000 / 600 ≈ 3,3 horas con pilas AA Ni-MH de 2000 mAh. Para elegir el driver se mira la corriente de bloqueo: el L9110S da unos 800 mA por canal, justo para motores TT; el TB6612FNG, con 1,2 A continuos y 3,2 A de pico por canal, va más holgado. Para calcular rápido la relación entre corriente, tensión y resistencia puedes usar la calculadora de la ley de Ohm.

Elegir el driver de motor y conectarlo

Módulo driver de dos motores L298N
El módulo L298N puede mover dos motores TT a la vez; pero como pierde unos 2 V, los motores reciben menos que la tensión de la batería.
DriverCorriente por canalCaída de tensiónNota
L298N2 AUnos 1,5–2,5 VRobusto y muy usado; con 4×AA al motor le quedan unos 4–4,5 V
L293D (shield)0,6 A (pico 1,2 A)Unos 1,5–2,5 VSe monta sobre el Uno y mueve cuatro motores; justo para TT
L9110S0,8 ABajaPequeño y barato; sufre con la corriente de bloqueo
TB6612FNG1,2 A (pico 3,2 A)Muy baja (MOSFET)Aprovecha bien la tensión de la batería, de las mejores opciones para TT
ConexiónArduino UnoESP32Raspberry Pi Pico
L298N ENA (velocidad motor izquierdo, PWM)D5GPIO 25GP15
L298N IN1 / IN2D7 / D8GPIO 27 / GPIO 33GP14 / GP13
L298N ENB (velocidad motor derecho, PWM)D6GPIO 26GP10
L298N IN3 / IN4D9 / D4GPIO 32 / GPIO 4GP12 / GP11
Salida encoder izquierdo / derecho (LM393)D2 / D3GPIO 34 / GPIO 35GP16 / GP17
VCC del módulo encoder5V3V33V3(OUT)
GNDNegativo de la batería, L298N y GND del Arduino comunesComúnComún

No olvides quitar los jumpers de ENA y ENB; si se quedan puestos, el motor ignora el PWM y gira siempre a toda velocidad. Todos los pines del L298N y su comportamiento al frenar y en marcha libre se explican en detalle en el artículo motor DC y L298N. Si un motor gira al revés, lo más limpio es intercambiar sus dos cables en el driver en lugar de cambiar el código.

Código Arduino: avanzar, retroceder, girar e igualar velocidad

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}

MIN_PWM en el código es el valor de PWM más bajo con el que el motor vence el rozamiento estático y empieza a girar. Los pines 5 y 6 del Uno generan PWM a unos 980 Hz; los motores TT suelen limitarse a zumbar sin girar por debajo de un valor de entre 60 y 90. Encontrar ese valor para tu motor es fácil: empieza con PWM a 0, súbelo de cinco en cinco y apunta el valor en el que la rueda empieza a girar. Para entender el PWM y su frecuencia, consulta ¿Qué es PWM?.

¿Por qué dos motores giran a distinta velocidad?

Cuando das el mismo PWM a dos motores TT de la misma caja esperas que el robot vaya recto, pero lo normal es que el coche se desvíe hacia un lado. La razón son las diferencias de fabricación de los motores baratos: la tolerancia de escobillas e imanes, el rozamiento de los engranajes, la lubricación y la alineación de los ejes de plástico cambian un poco en cada motor. La tolerancia de ±10 % que indican los vendedores puede suponer hasta un 20 % de diferencia de velocidad entre dos motores. Además, la diferencia no es fija: cambia al bajar la tensión de la batería, al calentarse el motor o al cambiar el suelo. Y como los motores van montados en espejo, uno gira hacia delante y el otro hacia atrás desde el punto de vista del motor, y algunos motores van a distinta velocidad en cada sentido.

  1. Haz avanzar el robot 2–3 metros por un suelo liso con el mismo PWM y anota hacia qué lado se desvía.
  2. Si el coche se va a la derecha, el motor izquierdo es más rápido; baja SOL_KATSAYI a 0,95 y vuelve a probar.
  3. Cambia el factor en pasos de 0,01–0,02 hasta que el coche vaya recto; suele bastar con 3–5 intentos.
  4. Repite la prueba marcha atrás; si la diferencia es grande, usa factores distintos para avanzar y retroceder.
  5. El ajuste puede desviarse cuando cambia la tensión de la batería; para una solución permanente que se corrija sola, pasa al método con encoder de más abajo.

Eliminar el ruido: condensadores en el motor

Mientras giran, los motores DC con escobillas producen pequeñas chispas entre las escobillas y el colector. Estas chispas provocan picos de tensión en la línea de alimentación y ruido eléctrico que se irradia al aire. Los síntomas son conocidos: el Arduino se reinicia solo al arrancar el motor, salen caracteres extraños en el Monitor Serie, el sensor de ultrasonidos mide distancias absurdas o se corta la conexión Bluetooth. La solución es atajar el ruido en su origen, justo en el motor.

  • 100 nF entre los terminales del motor: Suelda entre los dos terminales de cada motor un condensador cerámico de 100 nF marcado como 104. Deja las patas lo más cortas posible.
  • Dos más hacia la carcasa: En motores con carcasa metálica, añadir un 100 nF desde cada terminal a la carcasa reduce aún más el ruido. La carcasa del motor TT es de plástico, así que normalmente basta con el condensador entre terminales.
  • Electrolítico en la alimentación del driver: Pon un condensador electrolítico de 470–1000 µF en la entrada de alimentación del L298N; suaviza la caída de tensión de la batería en el arranque.
  • Trenza los cables: Enrolla entre sí los dos cables del motor; así irradian menos ruido.
  • Separa las alimentaciones: Si puedes, alimenta el Arduino y los motores con baterías distintas y une los GND en un solo punto.

Encontrarás cómo funcionan los condensadores y cómo leer sus códigos en ¿Qué es un condensador?, y otras causas de reinicios al arrancar el motor en Arduino se reinicia solo.

Medir la velocidad con un disco encoder

El eje del motor TT sale por los dos lados; en el extremo que no lleva la rueda se suele montar el disco encoder de plástico de 20 ranuras que viene con el kit. Las ranuras pasan entre los brazos de un sensor óptico de horquilla en forma de U (un módulo con comparador LM393), y cada ranura produce un pulso. Como el disco gira a la misma velocidad que la rueda, 20 pulsos son una vuelta de rueda. Si en medio segundo se cuentan 30 pulsos, la rueda ha dado 30 / 20 = 1,5 vueltas, es decir, 1,5 × 120 = 180 rpm. Multiplicando las vueltas por la circunferencia de la rueda obtienes también la distancia recorrida: cada pulso son unos 20,4 / 20 ≈ 1 cm.

El código siguiente mide la velocidad de las dos ruedas y ajusta automáticamente el PWM del motor derecho hasta que ambos lados cuentan los mismos pulsos. Es un sencillo controlador proporcional (P): cuanto mayor es la diferencia, mayor es la corrección. Como los sensores de horquilla pueden dar varios pulsos al pasar un borde, la función de interrupción ignora los pulsos separados menos de 2 ms. Para los detalles de las interrupciones consulta el artículo interrupciones en 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}

Al ejecutar el código verás en el Monitor Serie que el PWM derecho cambia durante los primeros segundos y después las velocidades de las dos ruedas se acercan. Si KP es demasiado grande, el motor derecho oscila acelerando y frenando; si es demasiado pequeño, la corrección es lenta; probar valores entre 2 y 6 es un buen punto de partida. Para una conducción más precisa también puedes igualar la distancia total o escribir un controlador PID completo. El sensor del encoder funciona de forma parecida a los sensores infrarrojos de los robots siguelíneas; detalles en el artículo sensor infrarrojo TCRT5000.

Controlar un motor TT con un ESP32

Los pines de 3,3 V del ESP32 manejan sin problemas las entradas del L298N y del TB6612FNG, porque estos drivers toman como HIGH cualquier valor por encima de 2,3 V. El núcleo Arduino del ESP32 admite analogWrite; la frecuencia PWM por defecto es de aproximadamente 1 kHz. Alimenta los sensores del encoder con 3V3 para que sus salidas también sean de 3,3 V; los GPIO 34 y 35 son solo de entrada y van perfectos para los encoders. Gracias a la Wi-Fi y el Bluetooth del ESP32 puedes manejar el robot desde el móvil y mostrar la velocidad en una página 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}

Motor TT con Raspberry Pi Pico y MicroPython

En la Pico todos los GPIO pueden generar PWM. En MicroPython fijas la frecuencia del objeto PWM en 1 kHz y das la velocidad con duty_u16() en el rango 0–65535; 65535 es velocidad máxima. El código siguiente hace girar el motor izquierdo a distintas velocidades y mide sus rpm con el encoder. Si quieres alimentar la Pico con la misma batería que los motores, puedes conectar la salida de 5V del 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)

¿Motor TT o micromotor N20?

Micromotor reductor DC N20
Micromotor reductor N20: engranajes metálicos, eje en D de 3 mm y aproximadamente una quinta parte del volumen de un motor TT.
CaracterísticaMotor TT (amarillo)Micromotor N20
TamañoUnos 70 × 22 × 18 mmSección de unos 12 × 10 mm, 25–35 mm de largo
EngranajesPlásticoMetal
Versiones de tensión3–6 VVersiones de 3 V, 6 V y 12 V
Relación de reducciónNormalmente 1:48 (1:120, 1:220)Amplia elección de 1:10 a 1:1000
EjeDe plástico con dos caras planasEje metálico en D de 3 mm
EncoderDisco y sensor de horquilla aparteSon habituales las versiones con encoder Hall magnético montado detrás
Precio y durabilidadMuy barato, los engranajes se desgastan con el tiempoMás caro, más preciso y más duradero
Proyectos adecuadosRobots educativos, kits de coche robotMinisumo, siguelíneas rápidos, mecanismos pequeños

En resumen, el motor TT es el mejor comienzo para un primer coche robot y para proyectos escolares porque es barato y fácil de montar. Si necesitas un mecanismo más pequeño, preciso y duradero, o vas a construir un robot de competición, conviene el N20; los N20 con encoder miden en el eje del motor y dan cientos de pulsos por vuelta de rueda, con una medida de velocidad mucho más precisa. Para ver qué tipo de motor encaja en cada trabajo, consulta el artículo diferencias entre motor DC, servo y paso a paso.

Ideas de proyectos con motores reductores

  • Coche robot: Monta un coche controlado por Bluetooth con dos motores TT, una rueda loca y un L298N; todos los pasos en el artículo cómo hacer un coche robot con Arduino.
  • Robot siguelíneas: Sigue una línea negra con sensores infrarrojos; aquí el equilibrio de velocidad de los motores es clave. Ver robot siguelíneas.
  • Robot que evita obstáculos: Detecta obstáculos con un HC-SR04 y cambia de dirección; montaje en el artículo robot evita obstáculos.
  • Rueda medidora: Haz rodar por el suelo una rueda con encoder para crear un metro digital para habitaciones; cada pulso es aproximadamente 1 cm.
  • Cortina automática: Abre la cortina por la mañana y ciérrala por la noche con un motor TT 1:220; actívala según la luz con una LDR.
  • Plataforma giratoria de exposición: Construye con un motor lento una base que gire despacio un producto pequeño o una maqueta.

Errores frecuentes y cómo solucionarlos

SíntomaCausa probableSolución
El motor zumba pero no giraPWM por debajo de la zona muerta o batería débilSube MIN_PWM, mide la tensión de la batería
El motor siempre a toda velocidadJumper de ENA/ENB puesto o pin sin PWMQuita el jumper; usa los pines 3, 5, 6, 9, 10, 11 en el Uno
El coche no va rectoDiferencia de fabricación entre los motoresEquilibra con un factor o monta un lazo cerrado con encoders
El Arduino se reinicia al arrancar el motorLa corriente de arranque hunde la tensión de la batería, ruido de escobillasPon 100 nF en los terminales del motor y 470 µF en la entrada del driver; alimenta el Arduino aparte
Una rueda gira al revésCables del motor invertidosIntercambia en el driver los dos cables de ese motor
Velocidad menor de la esperada2 V perdidos en el L298NUsa una batería de más tensión o un driver MOSFET como el TB6612FNG
El encoder cuenta pulsos de másRebotes del sensor en el borde de la ranuraUsa un filtro de 2 ms en la interrupción y centra el disco en el sensor
Después de montar el robot, prueba cada motor por separado con la rueda al aire: comprueba que avanzar, retroceder y parar funcionan bien y que los dos motores suenan más o menos igual. Si uno suena claramente distinto, puede tener rozamiento o un diente roto en los engranajes; resolverlo antes de poner el robot en el suelo ahorra horas.

El motor reductor TT es una pieza barata pero muy didáctica para aprender la relación entre velocidad y par en una reductora, el control de velocidad con PWM y la realimentación con un encoder. Con el driver adecuado, unos cuantos condensadores y un sencillo código de equilibrado, tu robot irá recto y de forma fiable. En la app BlueGrays encontrarás el coche controlado por Bluetooth, el robot que evita obstáculos y proyectos con sensores infrarrojos, con esquemas y código paso a paso, para convertir estos motores en un proyecto enseguida.

Preguntas frecuentes

¿Qué es un motor reductor DC?

Un motor reductor DC es un motor de corriente continua pequeño y rápido con una caja de engranajes en el eje. Los engranajes bajan la velocidad y suben el par en la misma proporción; con 1:48 el eje de salida da 1 vuelta por cada 48 del motor. Así un motor pequeño puede mover con facilidad un coche robot o un mecanismo.

¿Con cuántos voltios funciona un motor TT?

Los motores TT amarillos funcionan entre 3 y 6 V, y la alimentación más habitual son 4 pilas AA. Giran a unas 90–120 rpm a 3 V y a unas 200–250 rpm a 6 V. Una tensión superior a 6 V hace el motor más rápido, pero lo calienta y desgasta pronto los engranajes.

¿Cuánta corriente consume un motor TT?

En vacío unos 150 mA, y en un robot que circula por suelo liso 200–350 mA. Con la rueda bloqueada la corriente puede subir a 1,5 A a 6 V. Por eso el driver y la batería deben elegirse según la corriente de bloqueo, y el motor nunca debe alimentarse directamente desde un pin del Arduino.

¿Por qué dos motores DC no giran a la misma velocidad?

Los motores baratos tienen diferencias en escobillas, imanes, rozamiento de engranajes y lubricación; incluso con el mismo PWM sus velocidades pueden variar un 10–20 %. La tensión de la batería y la temperatura también cambian la diferencia. Aplicar un factor al motor más rápido por software, o medir con encoders la velocidad de las dos ruedas y ajustar el PWM automáticamente, resuelve el problema.

¿Por qué se pone un condensador en un motor DC?

Los motores con escobillas generan pequeñas chispas al girar que producen ruido eléctrico. Ese ruido puede reiniciar el Arduino, falsear las lecturas de los sensores y cortar las conexiones inalámbricas. Un condensador cerámico de 100 nF soldado entre los terminales del motor elimina el ruido en su origen.

¿Cómo se mide la velocidad de un motor con un disco encoder?

Un disco ranurado montado en el eje del motor pasa por un sensor óptico de horquilla, y cada ranura produce un pulso. Arduino cuenta esos pulsos con una interrupción; con un disco de 20 ranuras, 20 pulsos son una vuelta de rueda. Dividiendo los pulsos de un segundo entre 20 y multiplicando por 60 se obtienen las revoluciones por minuto.

Ver todos los proyectos
Coche controlado por Bluetooth con L298N
AR-80Avanzado
Premium

Coche controlado por Bluetooth con L298N

Convierte tu móvil en un mando y conduce tu propio coche robot. El Arduino recibe por un módulo Bluetooth las órdenes de una app de control remoto en el móvil y mueve las ruedas con un controlador de…

5.0(39)
66
Robot para evitar obstáculos
AR-81Avanzado
Premium

Robot para evitar obstáculos

¿Qué le parece construir un vehículo inteligente que encuentre su propio camino? El Robot Evitador de Obstáculos explora constantemente su entorno gracias al sensor ultrasónico que lleva delante.

5.0(38)
49
TCRT5000 Detección de superficie blanca y negra
AR-78Intermedio
Premium

TCRT5000 Detección de superficie blanca y negra

Con el pequeño sensor que hace de ojo en los robots sigue líneas, sabrás si el suelo es negro o blanco.

4.7(40)
49
Lectura de reflexión (proximidad) con TCRT5000
AR-77Intermedio
Premium

Lectura de reflexión (proximidad) con TCRT5000

Con un pequeño sensor que emite luz invisible y mide cuánta rebota, detectas la superficie que tiene delante.

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

Servocontrol con joystick

Controla dos motores con un joystick, igual que si giraras una cámara de seguridad.

4.7(42)
58
Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
ES-13Intermedio
Premium

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)

En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.

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

ESP32 LED Fade con PWM

Cambiar el brillo del LED suavemente de 0 a max, de max a 0. Controlamos PWM con analogWrite() como en Arduino - la misma sintaxis con ESP32 Arduino Core 3.0+ funciona sin problemas. Pin definición + pinMode + analogWrite es suficiente.

4.8(36)
55
Raspberry Pi Pico PWM LED Fade (Efecto Respiración)
PI-14Principiante

Raspberry Pi Pico PWM LED Fade (Efecto Respiración)

¡El LED ya no solo parpadea — respira! Con el PWM (modulación por ancho de pulso) del Raspberry Pi Pico, el brillo sube y baja lentamente. Aprende la clase machine.PWM, duty_u16() (brillo de 16 bits 0–65535), la frecuencia PWM, bucles range() y salida tipo analógica. Base para mezcla de color RGB, control de motores, servos y buzzer.

4