Motor Corrente Contínua 12V DC Alto Torque com Encoder JGY370: Manual Técnico Completo

Introdução
Neste manual, será apresentado como instalar, configurar e utilizar o Motor Corrente Contínua 12V DC Alto Torque com Encoder JGY370 (SKU RB2533). Se desejar adquirir este produto, clique aqui. O conjunto combina um motor de corrente contínua (DC — Direct Current) escovado de 12 V, uma caixa de redução metálica do tipo rosca sem-fim (worm gear) com saída perpendicular de 90° e efeito autotravante, e um encoder magnético de efeito Hall em quadratura acoplado diretamente ao eixo traseiro do motor para leitura precisa de velocidade em RPM (rotações por minuto), sentido de giro e deslocamento angular.
Este documento técnico foi estruturado para estudantes, técnicos e engenheiros que precisam integrar atuadores de alto torque com realimentação em malha fechada em projetos de robótica, automação industrial, sistemas de posicionamento e máquinas de bancada. Ao longo das próximas seções, são detalhadas as especificações elétricas e mecânicas da família JGY370, o mapeamento completo dos terminais do conector de 6 pinos, o esquema de ligação com driver ponte H e microcontroladores, além de rotinas completas em C++ para leitura do encoder e controle por PWM (Pulse Width Modulation — modulação por largura de pulso) em Arduino e ESP32.
Especificações técnicas
Principais especificações
| Parâmetro | Especificação |
|---|---|
| Modelo | JGY-370 com Encoder Magnético Hall (SKU RB2533) |
| Tipo de motor | Motor DC escovado (série 370) com caixa redutora de rosca sem-fim |
| Tensão nominal de operação do motor | 12 V DC |
| Faixa de tensão de trabalho do motor | 6 V a 12 V DC (com redução proporcional de velocidade e torque) |
| Corrente sem carga (a 12 V) | 35 mA a 200 mA (típico conforme relação de redução) |
| Corrente nominal com carga | 0,2 A a 0,7 A |
| Corrente de travamento (stall) | 0,85 A a 2,5 A (evitar travamento contínuo) |
| Sentido de rotação | Bidirecional reversível (CW / CCW via inversão de polaridade em M1/M2) |
| Velocidades nominais da linha | 2,8 RPM a 210 RPM (ex.: 2,8 / 4,7 / 8 / 18 / 40 / 90 / 150 / 210 RPM, tolerância ) |
| Faixa de torque nominal | 1,2 kgf·cm a 25 kgf·cm (inversamente proporcional à rotação de saída) |
| Autotravamento (self-locking) | Sim (eixo de saída trava mecanicamente quando desenergizado) |
| Tipo de engrenagens | Engrenagens internas metálicas em carcaça de liga de zinco/alumínio |
| Eixo de saída | Aço inox, diâmetro de 6 mm, perfil D (chanfrado), comprimento útil de 14 mm a 15 mm |
| Dimensões da caixa de redução | 46 mm 32 mm 25 mm |
| Dimensões do corpo do motor 370 | Diâmetro aproximado de 24 mm 30,8 mm de comprimento (sem o conjunto do encoder) |
| Fixação mecânica | 4 furos roscados M3 na face da caixa de redução |
| Peso aproximado | 160 g a 200 g |
| Tipo de encoder | Magnético de efeito Hall bifásico (canais A e B em quadratura, defasagem de 90°) |
| Tensão de alimentação do encoder | 3,3 V ou 5 V DC (compatível com lógica CMOS/TTL de ESP32 e Arduino) |
| Resolução base do encoder | 11 PPR (pulsos por revolução no eixo traseiro do motor — anel de 22 polos magnéticos) |
| Conector do chicote | Conector fêmea PH2.0 de 6 pinos (passo de 2,0 mm) |
| Temperatura de operação | a |
Características elétricas e operacionais
A linha JGY-370 utiliza o mesmo núcleo eletromecânico DC 370 de 12 V acoplado a diferentes relações de redução na caixa de rosca sem-fim. Quanto maior a taxa de redução , menor é a rotação no eixo de saída e maior é o torque entregue à carga. Como o anel magnético do encoder está montado no eixo de alta velocidade do motor (antes da caixa redutora), a resolução efetiva no eixo de saída é multiplicada diretamente pela taxa de redução :
Quando o firmware realiza a decodificação completa em quadratura (modo 4x, contabilizando bordas de subida e descida nos canais A e B), o número total de contagens por volta completa no eixo de saída () passa a ser:
A tabela a seguir reúne os valores de referência do datasheet da família JGY-370 (12 V) para as relações de redução mais comuns, considerando um encoder base de 11 PPR:
| Relação de redução () | Velocidade sem carga () | Velocidade nominal com carga | Torque nominal | Torque máximo (stall) | Resolução saída (1x / 4x) |
|---|---|---|---|---|---|
| 40:1 | ~150 RPM | ~100 a 120 RPM | 1,2 kgf·cm | 2,5 kgf·cm | 440 PPR / 1.760 CPR |
| 65:1 | ~90 RPM | ~70 RPM | 2,0 kgf·cm | 4,0 kgf·cm | 715 PPR / 2.860 CPR |
| 150:1 | ~40 RPM | ~30 RPM | 4,5 kgf·cm | 9,0 kgf·cm | 1.650 PPR / 6.600 CPR |
| 200:1 | ~30 RPM | ~22 RPM | 6,0 kgf·cm | 12,5 kgf·cm | 2.200 PPR / 8.800 CPR |
| 260:1 | ~23 RPM | ~17 RPM | 8,0 kgf·cm | 16,0 kgf·cm | 2.860 PPR / 11.440 CPR |
| 340:1 | ~18 RPM | ~13 RPM | 12,0 kgf·cm | 21,0 kgf·cm | 3.740 PPR / 14.960 CPR |
| 600:1 | ~10 RPM | ~7 RPM | 17,0 kgf·cm | 35,0 kgf·cm | 6.600 PPR / 26.400 CPR |
| 1000:1 | ~6 RPM | ~4 RPM | 25,0 kgf·cm | 35,0 kgf·cm (limite mecânico) | 11.000 PPR / 44.000 CPR |
⚠️ Atenção: Nas versões de redução muito elevada (abaixo de 10 RPM, como 2,8 RPM, 4,7 RPM e 6 RPM), o torque gerado no bloqueio do eixo pode superar a resistência mecânica dos dentes das engrenagens metálicas. Nunca permita que o motor opere travado (stall) e respeite o limite máximo recomendado de 25 kgf·cm contínuos.
A velocidade angular em RPM pode ser calculada em tempo real a partir da variação de pulsos medida durante uma janela de amostragem (em segundos):
De forma análoga, o deslocamento angular acumulado (em graus) no eixo de saída é obtido por:
Descrição do produto
O que é o Motor DC 12V JGY370 com Encoder?
O JGY-370 com Encoder é um moto-redutor eletromecânico compacto composto por três subsistemas integrados em uma única unidade: um motor de corrente contínua escovado de 12 V (carcaça padrão 370), uma caixa de redução de ângulo reto (90°) baseada em engrenagem tipo rosca sem-fim e coroa metálica, e uma placa circular traseira contendo dois sensores de efeito Hall posicionados diante de um disco magnético multipolar solidário ao eixo do rotor.
A disposição perpendicular entre o corpo cilíndrico do motor e o eixo de saída em perfil D de 6 mm reduz drasticamente a profundidade de montagem em painéis e chassis, enquanto o mecanismo de rosca sem-fim impede que forças externas aplicadas ao eixo de saída consigam girar o rotor quando a alimentação é cortada (efeito de freio mecânico passivo). O encoder traseiro gera duas ondas quadradas digitais defasadas em 90° elétricos (sinais A e B), possibilitando que microcontroladores como Arduino, ESP32, STM32 ou controladores industriais acompanhem a posição angular e a velocidade real do eixo sob carga variável.
Para que serve?
- Robótica móvel e manipuladores articulados: tração de robôs pesados, juntas de braços robóticos, plataformas pan-tilt e elevadores de carga com medição de odometria e controle de posição em malha fechada.
- Automação de acessos, válvulas e atuadores lineares: acionamento de fechaduras elétricas, comportas, persianas, válvulas de esfera motorizadas, dosadores e fusos trapezoidais onde o travamento sem energia é indispensável.
- Equipamentos de bancada, CNC auxiliar e impressoras 3D: mesas giratórias indexadas, alimentadores automáticos, bobinadeiras com contagem de voltas e sistemas didáticos de controle PID (Proportional-Integral-Derivative).
Por que devo usar?
- Autotravamento mecânico sem consumo em repouso: a caixa redutora de rosca sem-fim sustenta cargas verticais ou inclinadas mesmo com o motor totalmente desenergizado, economizando energia e evitando o aquecimento do driver.
- Alta resolução efetiva em malha fechada: como o encoder Hall de 11 PPR lê o eixo do motor antes da redução, a multiplicação pela taxa da caixa redutora gera centenas a dezenas de milhares de pulsos por volta completa no eixo de saída.
- Construção compacta em 90° com engrenagens metálicas: o formato em L economiza espaço útil no chassi e o trem de engrenagens metálicas suporta esforços elevados sem folga excessiva ou desgaste prematuro típico de redutores plásticos.
Quando devo usar?
- Quando usar: em projetos que demandam alto torque em baixa ou média rotação (2,8 a 210 RPM), manutenção de posição sem energia aplicada, inversão eletrônica de sentido e controle preciso de velocidade ou ângulo via realimentação de encoder.
- Quando não usar: em aplicações que exigem alta velocidade contínua acima de 300 RPM, resposta ultrarrápida sem inércia de engrenagem ou movimentação manual livre do eixo quando desligado (back-drivability). Nesses cenários, prefira motores DC com caixa planetária reta, motores de passo NEMA (para posicionamento em malha aberta sem folga de engrenagem sem-fim) ou motores brushless (BLDC) com controle FOC.
Pinout e diagrama de entradas/saídas
O JGY-370 com encoder possui um chicote de 6 vias terminado em conector PH2.0-6P (passo de 2,0 mm), reunindo em um único cabo os dois condutores de potência do motor e os quatro condutores de alimentação e sinal do encoder Hall.
| Pino (sequência típica PCB) | Serigrafia na PCB | Função | Tipo de sinal | Cor mais comum (padrão A) | Faixa elétrica |
|---|---|---|---|---|---|
| 1 | M1 (ou M+) | Alimentação do Motor (+) | Entrada de potência | Vermelho | 6 V a 12 V DC (via Ponte H) |
| 2 | GND | Terra do Encoder | Referência lógica | Preto ou Verde | 0 V (GND comum ao MCU) |
| 3 | C1 (ou A) | Saída do Encoder — Canal A | Saída digital (onda quadrada) | Amarelo | 0 V a VCC (3,3 V ou 5 V) |
| 4 | C2 (ou B) | Saída do Encoder — Canal B | Saída digital (onda quadrada, defasagem 90°) | Branco ou Verde | 0 V a VCC (3,3 V ou 5 V) |
| 5 | VCC | Alimentação do Encoder (+) | Entrada lógica | Azul ou Verde | 3,3 V a 5 V DC |
| 6 | M2 (ou M-) | Alimentação do Motor (-) | Entrada de potência | Preto, Branco ou Azul | 6 V a 12 V DC (via Ponte H) |
⚠️ Atenção: A sequência de cores dos fios do chicote PH2.0 não é padronizada entre diferentes fabricantes e lotes do JGY-370 (há lotes em que o fio verde é GND, outros em que o verde é VCC ou Canal B). Antes de energizar o conjunto, inspecione obrigatoriamente a serigrafia gravada na placa PCB traseira (
M1,M2,GND,VCC,C1,C2) ou verifique a continuidade dos dois terminais soldados diretamente na tampa do motor DC.
A leitura da direção de giro é determinada pela relação de fase entre C1 (Canal A) e C2 (Canal B):
- Sentido Horário (CW): na borda de subida do Canal A (
C1vai deLOWparaHIGH), o Canal B (C2) encontra-se em nível lógicoLOW(ouHIGH, conforme a convenção de montagem). - Sentido Anti-horário (CCW): na mesma borda de subida do Canal A, o Canal B apresenta o estado lógico oposto, permitindo incrementar ou decrementar o contador de posição com precisão absoluta.
Como fazer a ligação
Requisitos de instalação e alimentação
Para garantir operação estável, sem reinicializações do microcontrolador nem danos ao encoder Hall, observe os seguintes requisitos de bancada:
- Fonte de alimentação de potência (12 V DC): utilize uma fonte chaveada ou bateria de 12 V DC com capacidade mínima de 2 A a 3 A por motor. Embora a corrente nominal fique abaixo de 0,7 A, o pico de partida (inrush) e as reversões rápidas exigem folga de corrente para evitar queda brusca de tensão.
- Driver Ponte H compatível: o motor nunca deve ser ligado diretamente aos pinos de saída de um microcontrolador. Utilize um driver ponte H capaz de suportar pelo menos 2 A por canal em 12 V, como o módulo L298N, TB6612FNG (mais eficiente e com menor queda de tensão), DRV8871 ou BTS7960.
- Alimentação lógica do encoder (3,3 V ou 5 V): alimente o pino
VCCdo encoder com a mesma tensão lógica do microcontrolador — 5 V para Arduino Uno/Nano/Mega ou 3,3 V para ESP32/STM32. Isso garante compatibilidade direta de nível lógico nos pinosC1eC2sem necessidade de conversor de nível. - Referência de terra comum (
GND): interligue oGNDda fonte de 12 V, oGNDdo driver ponte H, oGNDdo encoder e oGNDdo microcontrolador em um ponto comum para que os sinais PWM e os pulsos do encoder tenham a mesma referência elétrica. - Bitola de cabos e desacoplamento: utilize cabos de 20 AWG a 22 AWG nos trechos de potência (fonte ponte H
M1/M2). Caso os fios do encoder precisem ser estendidos acima de 30 cm, mantenha-os afastados dos cabos de potência do motor para minimizar interferência eletromagnética (EMI).
Diagrama de ligação elétrica

O diagrama divide o circuito em dois domínios bem definidos: o circuito de potência (fonte de 12 V DC conectada aos bornes +12V e GND do driver ponte H L298N, com as saídas OUT1 e OUT2 ligadas aos fios M1 e M2 do motor) e o circuito de controle e realimentação (pinos digitais e PWM do Arduino Uno conectados às entradas ENA, IN1 e IN2 do driver, enquanto a placa do encoder recebe 5V e GND do Arduino e envia os sinais C1 e C2 para os pinos de interrupção externa D2 e D3).
Tabela de conexões dos terminais
Configuração 1: Arduino Uno + Driver Ponte H L298N
| Origem (Componente / Pino) | Destino (Componente / Pino) | Função |
|---|---|---|
Fonte 12 V DC (+12V) | Driver L298N (+12V / VMS) | Alimentação de potência da ponte H |
Fonte 12 V DC (GND) | Driver L298N (GND) e Arduino Uno (GND) | Referência de terra comum |
Driver L298N (OUT1) | Motor JGY-370 (M1) | Terminal positivo/chaveado do motor |
Driver L298N (OUT2) | Motor JGY-370 (M2) | Terminal negativo/chaveado do motor |
Arduino Uno (D5 — PWM) | Driver L298N (ENA, sem jumper) | Controle de velocidade via PWM |
Arduino Uno (D7) | Driver L298N (IN1) | Controle de sentido (bit 1) |
Arduino Uno (D8) | Driver L298N (IN2) | Controle de sentido (bit 2) |
Arduino Uno (5V) | Encoder JGY-370 (VCC) | Alimentação lógica dos sensores Hall |
Arduino Uno (GND) | Encoder JGY-370 (GND) | Terra do circuito do encoder |
Encoder JGY-370 (C1 — Canal A) | Arduino Uno (D2 — INT0) | Leitura de pulsos por interrupção externa |
Encoder JGY-370 (C2 — Canal B) | Arduino Uno (D3 — INT1) | Leitura de fase/quadratura por interrupção externa |
Configuração 2: ESP32 DevKit + Driver Ponte H (L298N ou TB6612FNG)
| Origem (Componente / Pino) | Destino (Componente / Pino) | Função |
|---|---|---|
Fonte 12 V DC (+12V / GND) | Driver Ponte H (VM / GND) e ESP32 (GND) | Alimentação de potência e terra comum |
Driver Ponte H (OUT1 / OUT2) | Motor JGY-370 (M1 / M2) | Acionamento bidirecional do motor |
ESP32 (GPIO 25 — PWM) | Driver Ponte H (ENA / PWMA) | Controle de velocidade PWM |
ESP32 (GPIO 26) | Driver Ponte H (IN1 / AIN1) | Controle de sentido (bit 1) |
ESP32 (GPIO 27) | Driver Ponte H (IN2 / AIN2) | Controle de sentido (bit 2) |
ESP32 (3V3) | Encoder JGY-370 (VCC) | Alimentação lógica em 3,3 V (protege GPIOs do ESP32) |
ESP32 (GND) | Encoder JGY-370 (GND) | Referência de terra do encoder |
Encoder JGY-370 (C1 — Canal A) | ESP32 (GPIO 32) | Entrada digital com interrupção de hardware |
Encoder JGY-370 (C2 — Canal B) | ESP32 (GPIO 33) | Entrada digital com interrupção de hardware |
Cuidados e observações de segurança
⛔ Perigo: Nunca aplique 12 V DC nos terminais
VCC,C1ouC2do encoder, nem inverta a polaridade entreVCCeGND. Os sensores de efeito Hall integrados à placa traseira sofrem dano permanente instantâneo em caso de inversão ou sobretensão, podendo também queimar as portas digitais do microcontrolador.
⛔ Perigo: No ESP32, alimente o encoder exclusivamente com 3,3 V (nunca com 5 V). Os pinos GPIO do ESP32 não são tolerantes a 5 V, e sinais de saída
C1/C2em nível de 5 V podem danificar o microcontrolador.
⚠️ Atenção: Remova o jumper de habilitação do pino
ENAno módulo L298N antes de conectá-lo ao pino PWM do microcontrolador. Caso utilize a saída regulada5Vinterna do módulo L298N para alimentar o Arduino via pino5V, certifique-se de manter o jumper regulador instalado apenas quando a tensão de entrada for de até 12 V.
💡 Dica: Configure sempre os pinos ligados a
C1eC2comINPUT_PULLUPno código. Embora muitas placas de encoder do JGY-370 já incluam resistores de pull-up SMD de , versões com saída em coletor aberto (open-collector) exigem pull-up ativo para produzir bordas nítidas em nívelHIGH.
Como usar
Guia de operação passo a passo
- Conferência visual da pinagem: localize a marcação impressa na pequena placa traseira do encoder (
M1,M2,GND,VCC,C1,C2) e anote a correspondência exata das cores do seu chicote PH2.0. - Teste isolado do encoder (sem 12 V): com a fonte de 12 V ainda desligada, conecte apenas os 4 fios do encoder ao microcontrolador (
VCC,GND,C1,C2), carregue o sketch de leitura e gire o eixo de saída (ou observe o eixo traseiro se acessível em versões sem tampa fechada). Nota: devido ao autotravamento da rosca sem-fim, o eixo de saída não deve ser forçado manualmente; para testar os pulsos sem driver, aplique brevemente 5 V a 6 V nos fiosM1/M2com limitação de corrente e verifique a contagem incrementando e decrementando no Monitor Serial ao inverter a polaridade. - Integração com o driver ponte H: faça todas as conexões da tabela De Para com a alimentação desligada, conferindo especialmente o
GNDcomum entre fonte, driver e placa controladora. - Energização e teste de sentido: ligue a alimentação lógica (USB) e, em seguida, a fonte de 12 V DC. Envie um PWM moderado (ex.: 50% de ciclo de trabalho) e verifique se o sentido de rotação coincide com o sinal positivo ou negativo da contagem do encoder. Caso a contagem decremente quando você espera incremento, inverta
C1comC2no código ou na fiação. - Calibração empírica do : marque uma referência visual no eixo D de 6 mm com fita adesiva, zere o contador, acione o motor em baixa velocidade até completar exatamente 1 volta inteira (360°) e registre o valor exato exibido no Monitor Serial. Utilize esse valor medido na constante
CPR_SAIDAdo seu firmware para eliminar divergências entre a relação nominal anunciada e a relação real do trem de engrenagens. - Operação em malha fechada: com o valor calibrado de
CPR_SAIDA, habilite o controle de velocidade (RPM) ou o controle proporcional/PID de posição angular conforme a aplicação.
Modos de operação e ajustes
Controle de sentido e frenagem via Ponte H
A tabela verdade abaixo resume os quatro estados elétricos de controle do motor através dos pinos IN1, IN2 e ENA (PWM):
ENA (PWM) | IN1 | IN2 | Comportamento do motor |
|---|---|---|---|
0 (0%) | X | X | Roda livre (coast): ponte H em alta impedância; o eixo para rapidamente auxiliado pelo autotravamento da caixa sem-fim |
1 a 255 | HIGH | LOW | Rotação Horária (CW): velocidade proporcional ao ciclo de trabalho PWM |
1 a 255 | LOW | HIGH | Rotação Anti-horária (CCW): velocidade proporcional ao ciclo de trabalho PWM |
HIGH (255) | HIGH | HIGH | Frenagem ativa (brake): curto-circuita os terminais do motor através da ponte H para parada imediata |
HIGH (255) | LOW | LOW | Frenagem ativa (brake): curto-circuita os terminais do motor ao GND para parada imediata |
Seleção da resolução de decodificação (1x, 2x e 4x)
- Decodificação 1x: usa interrupção em apenas um canal (
RISINGemC1) e lê o estado deC2dentro da rotina de interrupção (ISR — Interrupt Service Routine). Consome menos processamento, ideal para motores de maior RPM ou quando há apenas um pino de interrupção disponível. - Decodificação 2x: usa interrupção
CHANGEemC1, dobrando a resolução sem ocupar um segundo pino de interrupção. - Decodificação 4x: utiliza interrupção
CHANGEemC1eC2simultaneamente (ou periférico dedicadoPCNTno ESP32), oferecendo a máxima resolução angular ().
Bibliotecas oficiais recomendadas
Além da implementação direta com interrupções de hardware apresentada nos exemplos a seguir (sem dependências externas), duas bibliotecas consagradas de código aberto facilitam projetos maiores:
- Arduino (AVR / SAMD / Teensy): biblioteca Encoder (por Paul Stoffregen), disponível no Gerenciador de Bibliotecas da Arduino IDE, com decodificação 4x otimizada em Assembly.
- ESP32: biblioteca ESP32Encoder (por Kevin Harrington), que utiliza os contadores de pulso por hardware (PCNT — Pulse Counter) integrados ao chip ESP32, lendo pulsos em altíssima frequência com carga praticamente nula na CPU.
Exemplos práticos de uso
Exemplo 1 — Leitura de encoder em quadratura, cálculo de RPM e controle PWM via Serial (Arduino Uno + L298N)
Este código completo utiliza as interrupções externas INT0 (D2) e INT1 (D3) do Arduino Uno para decodificação em quadratura 4x, calcula a velocidade real em RPM e o ângulo em graus a cada 250 ms, e permite controlar sentido e velocidade pelo Monitor Serial (115200 bps).
/*
* Motor DC 12V Alto Torque JGY370 com Encoder Hall
* Exemplo 1: Leitura de quadratura 4x, RPM, ângulo e controle PWM (Arduino Uno + L298N)
* Comandos via Monitor Serial (115200 bps):
* F = Girar sentido horário (CW)
* R = Girar sentido anti-horário (CCW)
* S = Parar motor (freio ativo)
* + = Aumentar PWM em 25
* - = Reduzir PWM em 25
* Z = Zerar contador de posição
*/
// Pinos do Encoder Hall (INT0 e INT1 no Arduino Uno)
const uint8_t PIN_ENC_A = 2;
const uint8_t PIN_ENC_B = 3;
// Pinos do Driver Ponte H (L298N)
const uint8_t PIN_PWM_ENA = 5;
const uint8_t PIN_IN1 = 7;
const uint8_t PIN_IN2 = 8;
// Parâmetros do conjunto (ajuste conforme a relação de redução do seu JGY370)
// Exemplo: 11 PPR (motor) x 150 (redução 40 RPM) x 4 (quadratura 4x) = 6600 CPR
const float CPR_SAIDA = 6600.0f;
// Variáveis voláteis atualizadas nas interrupções
volatile long contadorPulsos = 0;
volatile uint8_t estadoAnterior = 0;
// Tabela de transição em quadratura (4x)
const int8_t TABELA_QUAD[16] = {
0, -1, 1, 0,
1, 0, 0, -1,
-1, 0, 0, 1,
0, 1, -1, 0
};
// Variáveis de controle e telemetria
int pwmAtual = 150; // 0 a 255
int direcaoAtual = 0; // 0 = parado, 1 = CW, -1 = CCW
long pulsosAnteriores = 0;
unsigned long ultimoTempoMs = 0;
const unsigned long INTERVALO_MS = 250;
void atualizarEncoder() {
uint8_t a = digitalRead(PIN_ENC_A);
uint8_t b = digitalRead(PIN_ENC_B);
uint8_t estadoAtual = (a << 1) | b;
uint8_t indice = (estadoAnterior << 2) | estadoAtual;
contadorPulsos += TABELA_QUAD[indice];
estadoAnterior = estadoAtual;
}
void aplicarMotor(int direcao, int pwm) {
pwm = constrain(pwm, 0, 255);
if (direcao > 0) {
digitalWrite(PIN_IN1, HIGH);
digitalWrite(PIN_IN2, LOW);
analogWrite(PIN_PWM_ENA, pwm);
} else if (direcao < 0) {
digitalWrite(PIN_IN1, LOW);
digitalWrite(PIN_IN2, HIGH);
analogWrite(PIN_PWM_ENA, pwm);
} else {
// Frenagem ativa
digitalWrite(PIN_IN1, HIGH);
digitalWrite(PIN_IN2, HIGH);
analogWrite(PIN_PWM_ENA, 0);
}
}
void setup() {
Serial.begin(115200);
pinMode(PIN_ENC_A, INPUT_PULLUP);
pinMode(PIN_ENC_B, INPUT_PULLUP);
pinMode(PIN_PWM_ENA, OUTPUT);
pinMode(PIN_IN1, OUTPUT);
pinMode(PIN_IN2, OUTPUT);
// Inicializa o estado anterior do encoder
estadoAnterior = (digitalRead(PIN_ENC_A) << 1) | digitalRead(PIN_ENC_B);
// Interrupções em ambas as bordas dos canais A e B (quadratura 4x)
attachInterrupt(digitalPinToInterrupt(PIN_ENC_A), atualizarEncoder, CHANGE);
attachInterrupt(digitalPinToInterrupt(PIN_ENC_B), atualizarEncoder, CHANGE);
aplicarMotor(0, 0);
ultimoTempoMs = millis();
Serial.println(F("JGY370 Encoder Pronto. Comandos: F (CW), R (CCW), S (Parar), +, -, Z (Zerar)"));
}
void loop() {
// Processa comandos recebidos via Serial
while (Serial.available() > 0) {
char cmd = Serial.read();
if (cmd == 'F' || cmd == 'f') {
direcaoAtual = 1;
aplicarMotor(direcaoAtual, pwmAtual);
} else if (cmd == 'R' || cmd == 'r') {
direcaoAtual = -1;
aplicarMotor(direcaoAtual, pwmAtual);
} else if (cmd == 'S' || cmd == 's') {
direcaoAtual = 0;
aplicarMotor(0, 0);
} else if (cmd == '+') {
pwmAtual = min(255, pwmAtual + 25);
aplicarMotor(direcaoAtual, pwmAtual);
} else if (cmd == '-') {
pwmAtual = max(0, pwmAtual - 25);
aplicarMotor(direcaoAtual, pwmAtual);
} else if (cmd == 'Z' || cmd == 'z') {
noInterrupts();
contadorPulsos = 0;
interrupts();
pulsosAnteriores = 0;
}
}
// Cálculo periódico de velocidade (RPM) e posição angular
unsigned long agora = millis();
if (agora - ultimoTempoMs >= INTERVALO_MS) {
float dtSegundos = (agora - ultimoTempoMs) / 1000.0f;
ultimoTempoMs = agora;
// Leitura atômica de variável de 32 bits em MCU de 8 bits (AVR)
noInterrupts();
long pulsosAtuais = contadorPulsos;
interrupts();
long deltaPulsos = pulsosAtuais - pulsosAnteriores;
pulsosAnteriores = pulsosAtuais;
float rpm = ((float)deltaPulsos / CPR_SAIDA) * (60.0f / dtSegundos);
float anguloGraus = ((float)pulsosAtuais / CPR_SAIDA) * 360.0f;
Serial.print(F("Pulsos: "));
Serial.print(pulsosAtuais);
Serial.print(F(" | Angulo: "));
Serial.print(anguloGraus, 1);
Serial.print(F(" deg | Vel: "));
Serial.print(rpm, 2);
Serial.print(F(" RPM | PWM: "));
Serial.println(direcaoAtual == 0 ? 0 : pwmAtual);
}
}
Exemplo 2 — Posicionamento angular em malha fechada (controle proporcional) no ESP32
Este exemplo demonstra como utilizar o JGY370 como um servo atuador de alto torque no ESP32. Ao digitar um ângulo em graus no Monitor Serial (por exemplo, 90, 180, -90 ou 0), o firmware calcula o erro de posição em relação à leitura do encoder em tempo real e modula o PWM na ponte H até atingir o ângulo alvo com parada travada.
/*
* Motor DC 12V Alto Torque JGY370 com Encoder Hall
* Exemplo 2: Controle de Posição Angular em Malha Fechada (ESP32)
* Envie o ângulo desejado em graus pelo Monitor Serial (115200 bps), ex: 90, 180, -45, 0
*/
#include <Arduino.h>
// Pinos do Encoder Hall (alimentar o encoder em 3,3 V no ESP32!)
const uint8_t PIN_ENC_A = 32;
const uint8_t PIN_ENC_B = 33;
// Pinos do Driver Ponte H
const uint8_t PIN_PWM_ENA = 25;
const uint8_t PIN_IN1 = 26;
const uint8_t PIN_IN2 = 27;
// Ajuste CPR_SAIDA para a redução real do seu motor (4x = 4 * 11 * R)
const float CPR_SAIDA = 6600.0f;
// Parâmetros do controlador proporcional
const float KP_POSICAO = 0.8f; // Ganho proporcional (ajuste em bancada)
const long ZONA_MORTA_CNT = 15; // Tolerância de parada em pulsos
const int PWM_MINIMO = 75; // PWM mínimo para vencer atrito estático
const int PWM_MAXIMO = 220; // Limite superior de velocidade
volatile long contadorPulsos = 0;
volatile uint8_t estadoAnterior = 0;
portMUX_TYPE muxEncoder = portMUX_INITIALIZER_UNLOCKED;
const int8_t TABELA_QUAD[16] = {
0, -1, 1, 0,
1, 0, 0, -1,
-1, 0, 0, 1,
0, 1, -1, 0
};
long alvoPulsos = 0;
unsigned long ultimoPrintMs = 0;
void IRAM_ATTR isrEncoder() {
uint8_t a = digitalRead(PIN_ENC_A);
uint8_t b = digitalRead(PIN_ENC_B);
uint8_t estadoAtual = (a << 1) | b;
uint8_t indice = (estadoAnterior << 2) | estadoAtual;
portENTER_CRITICAL_ISR(&muxEncoder);
contadorPulsos += TABELA_QUAD[indice];
estadoAnterior = estadoAtual;
portEXIT_CRITICAL_ISR(&muxEncoder);
}
long lerEncoderSeguro() {
portENTER_CRITICAL(&muxEncoder);
long valor = contadorPulsos;
portEXIT_CRITICAL(&muxEncoder);
return valor;
}
void acionarPonteH(int sinalControle) {
if (sinalControle == 0) {
// Freio ativo na ponte H + autotravamento da rosca sem-fim
digitalWrite(PIN_IN1, HIGH);
digitalWrite(PIN_IN2, HIGH);
analogWrite(PIN_PWM_ENA, 0);
return;
}
int pwm = abs(sinalControle);
if (pwm < PWM_MINIMO) pwm = PWM_MINIMO;
if (pwm > PWM_MAXIMO) pwm = PWM_MAXIMO;
if (sinalControle > 0) {
digitalWrite(PIN_IN1, HIGH);
digitalWrite(PIN_IN2, LOW);
} else {
digitalWrite(PIN_IN1, LOW);
digitalWrite(PIN_IN2, HIGH);
}
analogWrite(PIN_PWM_ENA, pwm);
}
void setup() {
Serial.begin(115200);
pinMode(PIN_ENC_A, INPUT_PULLUP);
pinMode(PIN_ENC_B, INPUT_PULLUP);
pinMode(PIN_PWM_ENA, OUTPUT);
pinMode(PIN_IN1, OUTPUT);
pinMode(PIN_IN2, OUTPUT);
estadoAnterior = (digitalRead(PIN_ENC_A) << 1) | digitalRead(PIN_ENC_B);
attachInterrupt(digitalPinToInterrupt(PIN_ENC_A), isrEncoder, CHANGE);
attachInterrupt(digitalPinToInterrupt(PIN_ENC_B), isrEncoder, CHANGE);
acionarPonteH(0);
Serial.println("ESP32 + JGY370 Controle de Posicao pronto. Digite um angulo em graus (ex: 180):");
}
void loop() {
// Leitura de novo ângulo alvo pela porta Serial
if (Serial.available() > 0) {
float anguloAlvo = Serial.parseFloat();
while (Serial.available() > 0) {
Serial.read();
}
alvoPulsos = lround((anguloAlvo / 360.0f) * CPR_SAIDA);
Serial.print("Novo alvo definido: ");
Serial.print(anguloAlvo, 1);
Serial.print(" deg (");
Serial.print(alvoPulsos);
Serial.println(" pulsos)");
}
// Malha de controle proporcional
long posicaoAtual = lerEncoderSeguro();
long erro = alvoPulsos - posicaoAtual;
if (labs(erro) <= ZONA_MORTA_CNT) {
acionarPonteH(0);
} else {
int comando = (int)(erro * KP_POSICAO);
if (comando == 0) {
comando = (erro > 0) ? PWM_MINIMO : -PWM_MINIMO;
}
acionarPonteH(comando);
}
// Telemetria a cada 300 ms
if (millis() - ultimoPrintMs >= 300) {
ultimoPrintMs = millis();
float anguloAtual = ((float)posicaoAtual / CPR_SAIDA) * 360.0f;
float anguloAlvo = ((float)alvoPulsos / CPR_SAIDA) * 360.0f;
Serial.print("Atual: ");
Serial.print(anguloAtual, 1);
Serial.print(" deg | Alvo: ");
Serial.print(anguloAlvo, 1);
Serial.print(" deg | Erro: ");
Serial.print(erro);
Serial.println(" pulsos");
}
delay(5);
}
💡 Dica: Para suavizar a aproximação em aplicações de alta inércia ou evitar oscilações (overshoot) ao redor do ângulo alvo, evolua o controlador proporcional acima adicionando o termo derivativo () para amortecimento e limite o ganho conforme a relação de redução da sua caixa sem-fim.
Conclusão
Neste manual técnico, foram reunidas as referências essenciais para dimensionar, conectar e programar o Motor Corrente Contínua 12V DC Alto Torque com Encoder JGY370 em sistemas de automação e robótica:
- Especificações técnicas: apresentação dos limites elétricos do motor de 12 V, da tabela de relação entre redução, velocidade e torque da família JGY-370 e das equações de cálculo de resolução ( e ), RPM e deslocamento angular.
- Descrição e pinagem: detalhamento do funcionamento da caixa redutora de rosca sem-fim autotravante, do encoder magnético Hall em quadratura (canais A e B) e dos cuidados críticos na conferência da serigrafia do conector PH2.0 de 6 pinos.
- Ligação elétrica segura: dimensionamento da fonte de 12 V DC, integração com drivers ponte H (L298N / TB6612FNG), separação correta dos níveis lógicos de 5 V (Arduino) e 3,3 V (ESP32) e aterramento comum.
- Operação e programação: procedimento de calibração empírica em bancada e dois códigos completos em C++ para leitura em quadratura 4x, medição de RPM e controle de posição angular em malha fechada.
Seguindo rigorosamente a conferência da serigrafia do encoder, o uso de driver ponte H adequado e a calibração da constante CPR_SAIDA para a taxa de redução escolhida, o JGY370 entrega acionamento robusto, silencioso e de alta precisão posicional.
Solução de problemas
Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Motor Corrente Contínua 12V DC Alto Torque com Encoder JGY370: Manual Técnico Completo e eu ajudarei a encontrar a solução.
O assistente usa IA e pode errar. Confirme informações críticas no datasheet oficial do fabricante.