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.

¿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ística | Motor TT amarillo (1:48, valores típicos) |
|---|---|
| Tensión de trabajo | 3–6 V CC |
| Relación de reducción | 1:48 (también hay versiones 1:120 y 1:220) |
| Velocidad de salida en vacío | Unas 90–120 rpm a 3 V, unas 200–250 rpm a 6 V |
| Corriente en vacío | Unos 150 mA |
| Corriente de bloqueo | Unos 1,2 A a 4,5 V, unos 1,5 A a 6 V |
| Par de bloqueo | Unos 0,4 kg·cm a 3 V, unos 0,8 kg·cm a 6 V |
| Eje | Eje de plástico de doble salida con dos caras planas |
| Cuerpo y engranajes | Plástico; unos 70 × 22 × 18 mm, 30 g |
| Rueda | Unos 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ón | Velocidad de salida (6 V, en vacío) | Par | Uso adecuado |
|---|---|---|---|
| 1:48 | Unas 200–250 rpm | Medio | Coche robot, siguelíneas, robot que evita obstáculos |
| 1:120 | Unas 80–100 rpm | Alto | Coche con carga pesada, movimiento lento y controlado |
| 1:220 | Unas 45–55 rpm | Muy alto | Puerta, cortina, plataforma giratoria, seguidor solar |
¿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.
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ón | Corriente típica (6 V) | ¿Qué significa? |
|---|---|---|
| Rueda al aire, en vacío | 150–170 mA | Rozamiento de engranajes y escobillas; el motor está sano |
| Robot circulando por suelo liso | 200–350 mA | Funcionamiento normal; usa este valor para calcular la batería |
| Rampa o alfombra | 400–700 mA | El motor sufre; plantéate la relación 1:120 o un chasis más ligero |
| Rueda bloqueada | 1,2–1,5 A | Peor caso para el driver y la batería; si dura, el motor se calienta |
| Momento del arranque | Brevemente hasta 1 A | Puede 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

| Driver | Corriente por canal | Caída de tensión | Nota |
|---|---|---|---|
| L298N | 2 A | Unos 1,5–2,5 V | Robusto 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 V | Se monta sobre el Uno y mueve cuatro motores; justo para TT |
| L9110S | 0,8 A | Baja | Pequeño y barato; sufre con la corriente de bloqueo |
| TB6612FNG | 1,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ón | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| L298N ENA (velocidad motor izquierdo, PWM) | D5 | GPIO 25 | GP15 |
| L298N IN1 / IN2 | D7 / D8 | GPIO 27 / GPIO 33 | GP14 / GP13 |
| L298N ENB (velocidad motor derecho, PWM) | D6 | GPIO 26 | GP10 |
| L298N IN3 / IN4 | D9 / D4 | GPIO 32 / GPIO 4 | GP12 / GP11 |
| Salida encoder izquierdo / derecho (LM393) | D2 / D3 | GPIO 34 / GPIO 35 | GP16 / GP17 |
| VCC del módulo encoder | 5V | 3V3 | 3V3(OUT) |
| GND | Negativo de la batería, L298N y GND del Arduino comunes | Común | Comú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
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.
- Haz avanzar el robot 2–3 metros por un suelo liso con el mismo PWM y anota hacia qué lado se desvía.
- 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.
- Cambia el factor en pasos de 0,01–0,02 hasta que el coche vaya recto; suele bastar con 3–5 intentos.
- Repite la prueba marcha atrás; si la diferencia es grande, usa factores distintos para avanzar y retroceder.
- 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.
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.
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.
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?

| Característica | Motor TT (amarillo) | Micromotor N20 |
|---|---|---|
| Tamaño | Unos 70 × 22 × 18 mm | Sección de unos 12 × 10 mm, 25–35 mm de largo |
| Engranajes | Plástico | Metal |
| Versiones de tensión | 3–6 V | Versiones de 3 V, 6 V y 12 V |
| Relación de reducción | Normalmente 1:48 (1:120, 1:220) | Amplia elección de 1:10 a 1:1000 |
| Eje | De plástico con dos caras planas | Eje metálico en D de 3 mm |
| Encoder | Disco y sensor de horquilla aparte | Son habituales las versiones con encoder Hall magnético montado detrás |
| Precio y durabilidad | Muy barato, los engranajes se desgastan con el tiempo | Más caro, más preciso y más duradero |
| Proyectos adecuados | Robots educativos, kits de coche robot | Minisumo, 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íntoma | Causa probable | Solución |
|---|---|---|
| El motor zumba pero no gira | PWM por debajo de la zona muerta o batería débil | Sube MIN_PWM, mide la tensión de la batería |
| El motor siempre a toda velocidad | Jumper de ENA/ENB puesto o pin sin PWM | Quita el jumper; usa los pines 3, 5, 6, 9, 10, 11 en el Uno |
| El coche no va recto | Diferencia de fabricación entre los motores | Equilibra con un factor o monta un lazo cerrado con encoders |
| El Arduino se reinicia al arrancar el motor | La corriente de arranque hunde la tensión de la batería, ruido de escobillas | Pon 100 nF en los terminales del motor y 470 µF en la entrada del driver; alimenta el Arduino aparte |
| Una rueda gira al revés | Cables del motor invertidos | Intercambia en el driver los dos cables de ese motor |
| Velocidad menor de la esperada | 2 V perdidos en el L298N | Usa una batería de más tensión o un driver MOSFET como el TB6612FNG |
| El encoder cuenta pulsos de más | Rebotes del sensor en el borde de la ranura | Usa un filtro de 2 ms en la interrupción y centra el disco en el sensor |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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.

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.

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.

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

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.

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.

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

