Motor TT com Arduino: velocidade, torque, PWM e encoder
O que é um motor CC com redução (motor TT amarelo)? Relação 1:48, velocidade e torque, 3–6 V, medição de corrente, ajuste de velocidade com PWM, capacitores contra ruído, encoder e N20 versus TT.
Um motor CC com redução é um pequeno motor CC de alta rotação com uma caixa de redução (redutor) acoplada ao eixo para diminuir a velocidade e aumentar o torque. O motor TT de plástico amarelo que você vê nos carrinhos robôs com Arduino é o integrante mais comum dessa família: o motor interno gira milhares de vezes por minuto, mas, graças às engrenagens, a roda gira apenas 100–250 vezes por minuto e ganha força suficiente para movimentar um carrinho com facilidade. Geralmente é vendido em um conjunto com uma roda de borracha de 65 mm e funciona com 3–6 V.
Neste guia, você vai aprender como a relação de redução (1:48) altera a velocidade e o torque, quais são os valores de tensão, corrente e velocidade do motor TT, como medir a corrente consumida pelo motor e como escolher o driver de motor adequado. Depois, vai entender por que dois motores giram em velocidades diferentes com o mesmo valor de PWM e vai igualá-las primeiro por software e depois por medição com um disco de encoder. Você também vai encontrar capacitores contra ruído, código para ESP32 e Raspberry Pi Pico e uma comparação com o micromotor N20.

O que é um motor CC com redução e como funciona?
Um pequeno motor CC comum gira a 8.000–10.000 rpm sem carga, mas seu torque é muito baixo; se você o acoplar diretamente a uma roda, ele não vai movimentar o carrinho. O redutor usa engrenagens acopladas para diminuir essa alta velocidade e aumentar o torque na mesma proporção. Com uma relação de 1:48, o eixo de saída dá uma volta a cada 48 voltas do eixo do motor: a velocidade é dividida por 48 e o torque é multiplicado por aproximadamente 48 (descontadas as perdas por atrito nas engrenagens). A potência (torque × velocidade) permanece a mesma; o redutor apenas troca velocidade por força. Por isso, motores com redução são ideais para tarefas que exigem movimentos lentos, mas fortes, como rodas, guinchos, portas ou esteiras transportadoras.
| Característica | Motor TT amarelo (1:48, valores típicos) |
|---|---|
| Tensão de operação | 3–6 V CC |
| Relação de redução | 1:48 (também existem versões 1:120 e 1:220) |
| Velocidade de saída sem carga | Cerca de 90–120 rpm a 3 V e de 200–250 rpm a 6 V |
| Corrente sem carga | Cerca de 150 mA |
| Corrente de travamento | Cerca de 1,2 A a 4,5 V e de 1,5 A a 6 V |
| Torque de travamento | Cerca de 0,4 kg·cm a 3 V e de 0,8 kg·cm a 6 V |
| Eixo | Eixo de plástico com saída dos dois lados e duas faces planas |
| Corpo e engrenagens | Plástico; cerca de 70 × 22 × 18 mm, 30 g |
| Roda | Cerca de 65 mm de diâmetro, borracha |
Cálculos de relação de redução, velocidade e torque
Alguns cálculos simples bastam para escolher um motor ou estimar a velocidade de um robô. A circunferência de uma roda é π × diâmetro: para uma roda de 65 mm, 3,14 × 6,5 ≈ 20,4 cm. Uma roda girando a 200 rpm sem carga a 6 V percorre 200 × 20,4 = 4.080 cm por minuto, cerca de 0,68 m/s; sob carga, esse valor cai 20–30%. Quanto ao torque, 0,8 kg·cm no raio de 3,25 cm da roda equivale a uma força de tração de 0,8 / 3,25 ≈ 0,25 kg; esse é o máximo que o motor consegue produzir antes de travar. Os motores não devem trabalhar por longos períodos com mais de cerca de um terço do torque de travamento.
| Relação de redução | Velocidade de saída (6 V, sem carga) | Torque | Indicado para |
|---|---|---|---|
| 1:48 | Cerca de 200–250 rpm | Médio | Carrinho robô, robô seguidor de linha, robô que desvia de obstáculos |
| 1:120 | Cerca de 80–100 rpm | Alto | Carrinho que transporta cargas pesadas, movimentos lentos e controlados |
| 1:220 | Cerca de 45–55 rpm | Muito alto | Porta, cortina, plataforma giratória, seguidor solar |
Com que tensão um motor TT funciona?
A tensão nominal do motor TT é de 3–6 V e, nessa faixa, sua velocidade varia quase proporcionalmente à tensão. A fonte de alimentação mais comum são 4 pilhas AA: pilhas alcalinas novas fornecem 6,0–6,4 V, e pilhas recarregáveis Ni-MH, 4,8–5,2 V. Duas células de íons de lítio 18650 fornecem 8,4 V quando totalmente carregadas, o que é demais para um motor de 6 V; porém, drivers como o L298N causam uma queda de cerca de 2 V, fazendo com que aproximadamente 6 V cheguem ao motor. Se você usar um driver mais eficiente, pode limitar o valor máximo de PWM: para obter uma média de 6 V a partir de 8,4 V, use no máximo 255 × 6 / 8,4 ≈ 182. Os detalhes sobre baterias estão nos artigos alimentar o Arduino com bateria e capacidade da bateria em mAh.
Medindo a corrente consumida pelo motor
Conhecer a corrente permite escolher o driver adequado e calcular a duração da bateria. A maneira mais fácil é colocar um multímetro na medição de corrente e conectá-lo em série com o motor: conecte a ponta de prova vermelha ao borne 10A, desconecte o fio que vem do positivo da bateria e insira o multímetro entre eles. Meça primeiro com o motor suspenso (sem carga), depois com o robô no chão e, por fim, segurando a roda com a mão por um breve instante. Para usar o multímetro, veja como usar um multímetro; para monitorar a corrente continuamente com um Arduino, veja o artigo sobre o sensor de corrente ACS712.
| Situação | Corrente típica (6 V) | O que significa? |
|---|---|---|
| Roda suspensa, sem carga | 150–170 mA | Atrito das engrenagens e escovas; o motor está em boas condições |
| Robô andando em piso plano | 200–350 mA | Operação normal; use esse valor nos cálculos da bateria |
| Rampa ou carpete | 400–700 mA | O motor está se esforçando; considere uma relação de 1:120 ou um chassi mais leve |
| Roda bloqueada (travamento) | 1,2–1,5 A | Pior caso para o driver e a bateria; o motor aquece se essa condição persistir |
| Momento da partida | Até 1 A por um breve instante | Pode derrubar a tensão da bateria e reiniciar o Arduino |
A autonomia da bateria é calculada facilmente a partir desses valores: um robô cujos dois motores consomem um total de 0,6 A em piso plano funciona por aproximadamente 2.000 / 600 ≈ 3,3 horas com pilhas AA Ni-MH de 2.000 mAh. Para escolher um driver, observe a corrente de travamento: o L9110S fornece cerca de 800 mA por canal, o que está no limite para motores TT; o TB6612FNG, com 1,2 A contínuo e 3,2 A de pico por canal, tem mais margem. Para calcular rapidamente a relação entre corrente, tensão e resistência, você pode usar a calculadora da lei de Ohm.
Escolha do driver de motor e conexões

| Driver | Corrente por canal | Queda de tensão | Observação |
|---|---|---|---|
| L298N | 2 A | Cerca de 1,5–2,5 V | Robusto e comum; com 4×AA, restam cerca de 4–4,5 V para o motor |
| L293D (shield) | 0,6 A (pico de 1,2 A) | Cerca de 1,5–2,5 V | Encaixa no Uno e aciona quatro motores; no limite para TT |
| L9110S | 0,8 A | Baixa | Pequeno e barato; tem dificuldade com a corrente de travamento |
| TB6612FNG | 1,2 A (pico de 3,2 A) | Muito baixa (MOSFET) | Aproveita a tensão da bateria com eficiência, uma das melhores opções para TT |
| Conexão | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| L298N ENA (velocidade do motor esquerdo, PWM) | D5 | GPIO 25 | GP15 |
| L298N IN1 / IN2 | D7 / D8 | GPIO 27 / GPIO 33 | GP14 / GP13 |
| L298N ENB (velocidade do motor direito, PWM) | D6 | GPIO 26 | GP10 |
| L298N IN3 / IN4 | D9 / D4 | GPIO 32 / GPIO 4 | GP12 / GP11 |
| Saída do encoder esquerdo / direito (LM393) | D2 / D3 | GPIO 34 / GPIO 35 | GP16 / GP17 |
| VCC do módulo encoder | 5V | 3V3 | 3V3(OUT) |
| GND | Negativo da bateria, GND do L298N e do Arduino em comum | Em comum | Em comum |
Não se esqueça de remover os jumpers ENA e ENB; se permanecerem conectados, o motor ignora o PWM e funciona sempre na velocidade máxima. Todos os pinos do L298N e seu comportamento de frenagem e parada por inércia são explicados em detalhes no artigo motor CC e L298N. Se um motor girar no sentido errado, trocar os dois fios desse motor no driver é a solução mais simples, em vez de alterar o código.
Código Arduino: avançar, recuar, virar e ajustar a velocidade
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 no código é o menor valor de PWM com que o motor vence o atrito estático e começa a girar. Os pinos 5 e 6 do Uno geram PWM a cerca de 980 Hz; motores TT normalmente apenas zumbem, sem girar, abaixo de um valor situado entre 60 e 90. Descobrir esse valor no seu motor é fácil: comece com o PWM em 0, aumente de cinco em cinco e anote o valor em que a roda começa a girar. Para entender o funcionamento do PWM e os detalhes de sua frequência, veja O que é PWM?.
Por que dois motores giram em velocidades diferentes?
Quando você aplica o mesmo PWM a dois motores TT da mesma caixa, espera que o robô siga em linha reta, mas, na maioria das vezes, o carrinho desvia para um lado. A razão está nas variações de fabricação dos motores baratos: a tolerância das escovas e dos ímãs, o atrito das engrenagens, a lubrificação e o alinhamento dos eixos de plástico variam um pouco em cada motor. A tolerância de ±10% informada pelos vendedores pode significar uma diferença de velocidade de até 20% entre dois motores. Além disso, a diferença não é constante: ela muda conforme a tensão da bateria cai, o motor aquece ou o piso muda. E, como os motores são montados de forma espelhada, um gira para a frente enquanto o outro gira para trás do ponto de vista do motor, e alguns motores têm velocidades diferentes nos dois sentidos.
- Faça o robô avançar por 2–3 metros em piso plano com o mesmo PWM e observe para que lado ele desvia.
- Se o carrinho desviar para a direita, o motor esquerdo está mais rápido; reduza SOL_KATSAYI para 0.95 e tente novamente.
- Altere o fator em passos de 0.01–0.02 até o carrinho seguir em linha reta; isso costuma levar de 3–5 tentativas.
- Faça o mesmo teste em marcha à ré; se a diferença for grande, use fatores separados para avançar e recuar.
- O ajuste pode perder a precisão quando a tensão da bateria mudar; para uma solução permanente que se corrige sozinha, passe ao método com encoder abaixo.
Eliminando ruídos: capacitores no motor
Quando motores CC com escovas giram, pequenas faíscas surgem entre as escovas e o comutador. Essas faíscas causam picos de tensão na linha de alimentação e ruído elétrico irradiado pelo ar. Os sintomas são conhecidos: o Arduino reinicia sozinho quando o motor funciona, aparecem caracteres estranhos no Monitor Serial, o sensor ultrassônico mede distâncias sem sentido ou a conexão Bluetooth cai. A solução é suprimir o ruído na origem, diretamente no motor.
- 100 nF entre os terminais do motor: Solde um capacitor cerâmico de 100 nF com a marcação 104 entre os dois terminais de cada motor. Mantenha seus terminais o mais curtos possível.
- Mais dois na carcaça: Em motores com carcaça metálica, adicionar um capacitor de 100 nF de cada terminal à carcaça reduz ainda mais o ruído. A carcaça do motor TT é de plástico, por isso um único capacitor entre os terminais costuma bastar.
- Eletrolítico na alimentação do driver: Coloque um capacitor eletrolítico de 470–1000 µF na entrada de alimentação do L298N; ele suaviza a queda da tensão da bateria na partida.
- Torça os fios: Torça os dois fios do motor um ao redor do outro; isso reduz o ruído irradiado pelos fios.
- Separe as fontes de alimentação: Se possível, alimente o Arduino e os motores com baterias separadas e una os GNDs em um único ponto.
Você encontra o funcionamento dos capacitores e como ler seus códigos em O que é um capacitor?, e outras causas de reinicialização quando o motor funciona em Arduino reiniciando sozinho.
Medindo a velocidade com um disco de encoder
O eixo do motor TT tem saída dos dois lados; na ponta que não leva a roda, geralmente se encaixa o disco de encoder de plástico com 20 fendas que acompanha o conjunto. As fendas do disco passam entre os braços de um sensor infravermelho de barreira em formato de U (um módulo óptico com comparador LM393), e cada fenda produz um pulso. Como o disco gira na mesma velocidade da roda, 20 pulsos equivalem a uma volta da roda. Se forem contados 30 pulsos em meio segundo, a roda terá girado 30 / 20 = 1,5 volta, o que significa 1,5 × 120 = 180 rpm. Multiplicar o número de voltas pela circunferência da roda também fornece a distância percorrida: cada pulso corresponde a cerca de 20,4 / 20 ≈ 1 cm.
O código abaixo mede a velocidade das duas rodas e ajusta automaticamente o PWM do motor direito até que os dois lados contem o mesmo número de pulsos. Esse é um controlador proporcional (P) simples: quanto maior a diferença, maior a correção. Como os sensores de barreira podem produzir vários pulsos durante a passagem de uma borda, a função de interrupção ignora pulsos separados por menos de 2 ms. Para detalhes sobre interrupções, veja o artigo interrupções no 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}Ao executar o código, você verá no Monitor Serial que o valor de PWM direito muda nos primeiros segundos e, depois, as velocidades das duas rodas convergem. Se KP for muito grande, o motor direito oscila, acelerando e desacelerando; se for muito pequeno, a correção é lenta; experimentar valores entre 2 e 6 é um bom começo. Para uma condução mais precisa, você também pode igualar a distância total ou escrever um controlador PID completo. O sensor do encoder funciona de maneira muito parecida com os sensores infravermelhos usados em robôs seguidores de linha; veja os detalhes no artigo sobre o sensor infravermelho TCRT5000.
Controlando um motor TT com ESP32
Os pinos de 3,3 V do ESP32 acionam as entradas do L298N e do TB6612FNG sem problemas, pois esses drivers interpretam qualquer tensão acima de 2,3 V como HIGH. O core do Arduino para ESP32 oferece suporte a analogWrite; a frequência padrão do PWM é de cerca de 1 kHz. Alimente os sensores de encoder pelo 3V3 para que suas saídas também sejam de 3,3 V; GPIO 34 e 35 são pinos somente de entrada e ideais para os encoders. Graças ao Wi-Fi e ao Bluetooth do ESP32, você pode controlar o robô pelo celular e mostrar a velocidade em uma 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 com Raspberry Pi Pico e MicroPython
Todos os GPIOs do Pico podem gerar PWM. No MicroPython, você define a frequência do objeto PWM como 1 kHz e informa a velocidade com duty_u16() na faixa de 0–65535; 65535 significa velocidade máxima. O código abaixo aciona o motor esquerdo em diferentes velocidades e mede sua velocidade com o encoder. Se quiser alimentar o Pico com a mesma bateria dos motores, você pode conectar a saída 5V do L298N ao pino 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 ou micromotor N20?

| Característica | Motor TT (amarelo) | Micromotor N20 |
|---|---|---|
| Dimensões | Cerca de 70 × 22 × 18 mm | Seção transversal de cerca de 12 × 10 mm, comprimento de 25–35 mm |
| Engrenagens | Plástico | Metal |
| Opções de tensão | 3–6 V | Versões de 3 V, 6 V e 12 V |
| Relação de redução | Geralmente 1:48 (1:120, 1:220) | Grande variedade de 1:10 a 1:1000 |
| Eixo | Plástico, com duas faces planas | Eixo D metálico de 3 mm |
| Encoder | Disco e sensor de barreira separados | São comuns as versões com encoder magnético Hall instalado na parte traseira |
| Preço e durabilidade | Muito barato, as engrenagens se desgastam com o tempo | Mais caro, mais preciso e durável |
| Projetos indicados | Robôs educativos, kits de carrinho robô | Minissumô, seguidores de linha rápidos, pequenos mecanismos |
Em resumo, o motor TT é a melhor opção para começar com um primeiro carrinho robô e projetos escolares, pois é barato e fácil de montar. Se você precisa de um mecanismo menor, mais preciso e durável, ou está construindo um robô de competição, o N20 é preferível; os N20 com encoder medem no eixo do motor, gerando centenas de pulsos por volta da roda e uma medição de velocidade muito mais precisa. Para uma visão geral de qual tipo de motor combina com cada tarefa, veja o artigo diferenças entre motor CC, servo motor e motor de passo.
Ideias de projetos com motor com redução
- Carrinho robô: Monte um carrinho controlado por Bluetooth com dois motores TT, uma roda boba e um L298N; todas as etapas estão no artigo carrinho robô com Arduino.
- Robô seguidor de linha: Siga uma linha preta com sensores infravermelhos; equilibrar a velocidade dos motores é muito importante aqui. Veja robô seguidor de linha.
- Robô que desvia de obstáculos: Detecte obstáculos à frente com um HC-SR04 e mude de direção; a montagem está no artigo robô que desvia de obstáculos.
- Roda de medição: Role uma roda com encoder pelo chão para fazer uma trena digital para cômodos; cada pulso corresponde a cerca de 1 cm.
- Cortina automática: Abra a cortina de manhã e feche à noite com um motor TT 1:220; use um LDR para acioná-la pela luz.
- Expositor giratório: Monte um suporte que gire lentamente um pequeno produto ou modelo com um motor de baixa velocidade.
Erros comuns e como corrigi-los
| Sintoma | Causa provável | Solução |
|---|---|---|
| O motor zumbe, mas não gira | PWM abaixo da zona morta ou bateria fraca | Aumente MIN_PWM e meça a tensão da bateria |
| Motor sempre na velocidade máxima | Jumper ENA/ENB conectado ou pino sem PWM | Remova o jumper; use os pinos 3, 5, 6, 9, 10, 11 no Uno |
| O carrinho não segue em linha reta | Diferença de fabricação entre os motores | Equilibre com um fator ou monte uma malha fechada com encoders |
| O Arduino reinicia quando o motor funciona | A corrente de partida derruba a tensão da bateria, ruído das escovas | Adicione 100 nF entre os terminais do motor e 470 µF na entrada do driver; alimente o Arduino separadamente |
| Uma roda gira para trás | Fios do motor conectados invertidos | Troque os dois fios desse motor no driver |
| Velocidade menor que a esperada | Perda de 2 V no L298N | Use uma bateria de tensão maior ou um driver MOSFET, como o TB6612FNG |
| O encoder conta pulsos demais | Trepidação do sensor na borda da fenda | Use um filtro de tempo morto de 2 ms na interrupção e centralize o disco no sensor |
O motor TT com redução é um componente barato, mas muito instrutivo para aprender a relação entre velocidade e torque na redução, o controle de velocidade com PWM e a realimentação com encoder. Com o driver adequado, alguns capacitores e um código simples de compensação, seu robô anda em linha reta e com confiabilidade. No app BlueGrays, você encontra projetos de carrinho controlado por Bluetooth, robô que desvia de obstáculos e sensores infravermelhos com esquemas do circuito e código passo a passo, para transformar esses motores em um projeto imediatamente.
Perguntas frequentes
O que é um motor CC com redução?
Um motor CC com redução é um pequeno motor CC de alta rotação com uma caixa de redução acoplada ao eixo. As engrenagens reduzem a velocidade e aumentam o torque na mesma proporção; em 1:48, o eixo de saída dá uma volta a cada 48 voltas do eixo do motor. Isso permite que um motor pequeno movimente um carrinho robô ou um mecanismo com facilidade.
Com que tensão um motor TT funciona?
Os motores TT amarelos funcionam com 3–6 V, e a alimentação mais comum são 4 pilhas AA. Giram a cerca de 90–120 rpm a 3 V e de 200–250 rpm a 6 V. Uma tensão acima de 6 V aumenta a velocidade do motor, mas faz com que ele aqueça e suas engrenagens se desgastem rapidamente.
Quanta corrente um motor TT consome?
Cerca de 150 mA sem carga e 200–350 mA em um robô andando em piso plano. Quando a roda é bloqueada, a corrente pode subir para 1,5 A a 6 V. Por isso, o driver de motor e a bateria devem ser escolhidos para a corrente de travamento, e o motor nunca deve ser alimentado diretamente por um pino do Arduino.
Por que dois motores CC não giram na mesma velocidade?
Motores baratos diferem nas escovas, nos ímãs, no atrito das engrenagens e na lubrificação; mesmo com o mesmo PWM, suas velocidades podem diferir em 10–20%. A tensão da bateria e a temperatura também alteram essa diferença. Aplicar um fator ao motor mais rápido por software, ou medir a velocidade das duas rodas com encoders e ajustar o PWM automaticamente, resolve o problema.
Por que se instala um capacitor em um motor CC?
Quando motores com escovas giram, pequenas faíscas nas escovas produzem ruído elétrico. Esse ruído pode reiniciar o Arduino, causar leituras erradas nos sensores e derrubar conexões sem fio. Um capacitor cerâmico de 100 nF soldado entre os terminais do motor suprime o ruído na origem.
Como medir a velocidade do motor com um disco de encoder?
Um disco com fendas acoplado ao eixo do motor passa por um sensor óptico de barreira, e cada fenda produz um pulso. O Arduino conta esses pulsos com uma interrupção; com um disco de 20 fendas, 20 pulsos equivalem a uma volta da roda. Divida o número de pulsos em um segundo por 20 e multiplique por 60 para obter as rotações por minuto.
Projetos para montar depois desta leitura
Ver todos os projetos
Carrinho controlado por Bluetooth com L298N
Transforme seu celular em um controle remoto e dirija seu próprio carrinho robô.

Robô que desvia de obstáculos
Que tal construir um veículo inteligente que encontra seu próprio caminho? O robô que desvia de obstáculos monitora o ambiente constantemente com o sensor ultrassônico na parte da frente.

Detecção de superfícies pretas e brancas com TCRT5000
Com o pequeno sensor que funciona como o olho dos robôs seguidores de linha, você identifica se o piso é preto ou branco.

Leitura de reflexão (proximidade) com TCRT5000
Com um pequeno sensor que emite luz invisível e mede quanto dela é refletido, você detecta a superfície à frente dele.

Controle de servos com joystick
Controle dois motores com um joystick, como ao girar uma câmera de segurança. Empurre a alavanca para os lados e o servo motor inferior gira lentamente; mova para cima ou para baixo e o servo…

Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
Neste projeto, controlamos o brilho de um LED de forma analógica com um potenciômetro. O pino ADC do ESP32 lê a tensão de 0-3,3V do potenciômetro e converte esse valor em um sinal PWM (modulação por largura de pulso), enviado ao LED. Assim, ao girar o potenciômetro, o brilho do LED aumenta e diminui gradualmente. Com Arduino Core 3.0+, você pode usar analogWrite() diretamente; no ESP32-S2/S3, a resolução do ADC é fixada em 12 bits.

Variação gradual do brilho do LED com PWM no ESP32
Varie suavemente o brilho do LED de 0 ao máximo e do máximo a 0. Controlamos o PWM com analogWrite(), como no Arduino. A mesma sintaxe funciona sem problemas com ESP32 Arduino Core 3.0+. Basta definir o pino e usar pinMode e analogWrite.

Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)
O LED não só pisca — ele respira! Com o PWM (modulação por largura de pulso) do Raspberry Pi Pico, o brilho do LED aumenta e diminui lentamente, como a luz de um MacBook em repouso. Aprenda a usar a classe machine.PWM, duty_u16() (brilho de 16 bits, de 0–65535), frequência PWM (freq(1000) — 1.000 ciclos de ligar/desligar por segundo, sem cintilação visível), laços com passos usando range() (crescentes e decrescentes) e saída semelhante à analógica em um pino digital.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

