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

Motor DC 12V Alto Torque 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âmetroEspecificação
ModeloJGY-370 com Encoder Magnético Hall (SKU RB2533)
Tipo de motorMotor DC escovado (série 370) com caixa redutora de rosca sem-fim
Tensão nominal de operação do motor12 V DC
Faixa de tensão de trabalho do motor6 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 ≤60 mA\le 60\,\text{mA} conforme relação de redução)
Corrente nominal com carga0,2 A a 0,7 A
Corrente de travamento (stall)0,85 A a 2,5 A (evitar travamento contínuo)
Sentido de rotaçãoBidirecional reversível (CW / CCW via inversão de polaridade em M1/M2)
Velocidades nominais da linha2,8 RPM a 210 RPM (ex.: 2,8 / 4,7 / 8 / 18 / 40 / 90 / 150 / 210 RPM, tolerância ±10%\pm 10\%)
Faixa de torque nominal1,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 engrenagensEngrenagens internas metálicas em carcaça de liga de zinco/alumínio
Eixo de saídaAço inox, diâmetro de 6 mm, perfil D (chanfrado), comprimento útil de 14 mm a 15 mm
Dimensões da caixa de redução46 mm ×\times 32 mm ×\times 25 mm
Dimensões do corpo do motor 370Diâmetro aproximado de 24 mm ×\times 30,8 mm de comprimento (sem o conjunto do encoder)
Fixação mecânica4 furos roscados M3 na face da caixa de redução
Peso aproximado160 g a 200 g
Tipo de encoderMagnético de efeito Hall bifásico (canais A e B em quadratura, defasagem de 90°)
Tensão de alimentação do encoder3,3 V ou 5 V DC (compatível com lógica CMOS/TTL de ESP32 e Arduino)
Resolução base do encoder11 PPR (pulsos por revolução no eixo traseiro do motor — anel de 22 polos magnéticos)
Conector do chicoteConector fêmea PH2.0 de 6 pinos (passo de 2,0 mm)
Temperatura de operação−10 ∘C-10\,^\circ\text{C} a +60 ∘C+60\,^\circ\text{C}

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 RR, 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 RR:

PPRsaıˊda=PPRbase×R\text{PPR}_{\text{saída}} = \text{PPR}_{\text{base}} \times R

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 (CPRsaıˊda\text{CPR}_{\text{saída}}) passa a ser:

CPRsaıˊda=4×PPRbase×R\text{CPR}_{\text{saída}} = 4 \times \text{PPR}_{\text{base}} \times R

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 (RR)Velocidade sem carga (±10%\pm 10\%)Velocidade nominal com cargaTorque nominalTorque máximo (stall)Resolução saída (1x / 4x)
40:1~150 RPM~100 a 120 RPM1,2 kgf·cm2,5 kgf·cm440 PPR / 1.760 CPR
65:1~90 RPM~70 RPM2,0 kgf·cm4,0 kgf·cm715 PPR / 2.860 CPR
150:1~40 RPM~30 RPM4,5 kgf·cm9,0 kgf·cm1.650 PPR / 6.600 CPR
200:1~30 RPM~22 RPM6,0 kgf·cm12,5 kgf·cm2.200 PPR / 8.800 CPR
260:1~23 RPM~17 RPM8,0 kgf·cm16,0 kgf·cm2.860 PPR / 11.440 CPR
340:1~18 RPM~13 RPM12,0 kgf·cm21,0 kgf·cm3.740 PPR / 14.960 CPR
600:1~10 RPM~7 RPM17,0 kgf·cm35,0 kgf·cm6.600 PPR / 26.400 CPR
1000:1~6 RPM~4 RPM25,0 kgf·cm35,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 ΔN\Delta N medida durante uma janela de amostragem Δt\Delta t (em segundos):

RPM=ΔNCPRsaıˊda×60Δt\text{RPM} = \frac{\Delta N}{\text{CPR}_{\text{saída}}} \times \frac{60}{\Delta t}

De forma análoga, o deslocamento angular acumulado θ\theta (em graus) no eixo de saída é obtido por:

θ=NCPRsaıˊda×360∘\theta = \frac{N}{\text{CPR}_{\text{saída}}} \times 360^\circ

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 PCBFunçãoTipo de sinalCor mais comum (padrão A)Faixa elétrica
1M1 (ou M+)Alimentação do Motor (+)Entrada de potênciaVermelho6 V a 12 V DC (via Ponte H)
2GNDTerra do EncoderReferência lógicaPreto ou Verde0 V (GND comum ao MCU)
3C1 (ou A)Saída do Encoder — Canal ASaída digital (onda quadrada)Amarelo0 V a VCC (3,3 V ou 5 V)
4C2 (ou B)Saída do Encoder — Canal BSaída digital (onda quadrada, defasagem 90°)Branco ou Verde0 V a VCC (3,3 V ou 5 V)
5VCCAlimentação do Encoder (+)Entrada lógicaAzul ou Verde3,3 V a 5 V DC
6M2 (ou M-)Alimentação do Motor (-)Entrada de potênciaPreto, Branco ou Azul6 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 (C1 vai de LOW para HIGH), o Canal B (C2) encontra-se em nível lógico LOW (ou HIGH, 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:

  1. 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.
  2. 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.
  3. Alimentação lógica do encoder (3,3 V ou 5 V): alimente o pino VCC do 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 pinos C1 e C2 sem necessidade de conversor de nível.
  4. Referência de terra comum (GND): interligue o GND da fonte de 12 V, o GND do driver ponte H, o GND do encoder e o GND do microcontrolador em um ponto comum para que os sinais PWM e os pulsos do encoder tenham a mesma referência elétrica.
  5. Bitola de cabos e desacoplamento: utilize cabos de 20 AWG a 22 AWG nos trechos de potência (fonte →\to ponte H →\to 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

Diagrama de ligação elétrica do Motor DC 12V JGY370 com Encoder

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, C1 ou C2 do encoder, nem inverta a polaridade entre VCC e GND. 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/C2 em nível de 5 V podem danificar o microcontrolador.

⚠️ Atenção: Remova o jumper de habilitação do pino ENA no módulo L298N antes de conectá-lo ao pino PWM do microcontrolador. Caso utilize a saída regulada 5V interna do módulo L298N para alimentar o Arduino via pino 5V, 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 C1 e C2 com INPUT_PULLUP no código. Embora muitas placas de encoder do JGY-370 já incluam resistores de pull-up SMD de 10 kΩ10\,\text{k}\Omega, versões com saída em coletor aberto (open-collector) exigem pull-up ativo para produzir bordas nítidas em nível HIGH.


Como usar

Guia de operação passo a passo

  1. 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.
  2. 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 fios M1/M2 com limitação de corrente e verifique a contagem incrementando e decrementando no Monitor Serial ao inverter a polaridade.
  3. Integração com o driver ponte H: faça todas as conexões da tabela De →\to Para com a alimentação desligada, conferindo especialmente o GND comum entre fonte, driver e placa controladora.
  4. 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 C1 com C2 no código ou na fiação.
  5. Calibração empírica do CPRsaıˊda\text{CPR}_{\text{saída}}: 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_SAIDA do seu firmware para eliminar divergências entre a relação nominal anunciada e a relação real do trem de engrenagens.
  6. 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)IN1IN2Comportamento do motor
0 (0%)XXRoda livre (coast): ponte H em alta impedância; o eixo para rapidamente auxiliado pelo autotravamento da caixa sem-fim
1 a 255HIGHLOWRotação Horária (CW): velocidade proporcional ao ciclo de trabalho PWM
1 a 255LOWHIGHRotação Anti-horária (CCW): velocidade proporcional ao ciclo de trabalho PWM
HIGH (255)HIGHHIGHFrenagem ativa (brake): curto-circuita os terminais do motor através da ponte H para parada imediata
HIGH (255)LOWLOWFrenagem 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 (RISING em C1) e lê o estado de C2 dentro 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 CHANGE em C1, dobrando a resolução sem ocupar um segundo pino de interrupção.
  • Decodificação 4x: utiliza interrupção CHANGE em C1 e C2 simultaneamente (ou periférico dedicado PCNT no ESP32), oferecendo a máxima resolução angular (4×PPRbase×R4 \times \text{PPR}_{\text{base}} \times R).

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 (KdK_d) para amortecimento e limite o ganho KpK_p 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 (PPRsaıˊda\text{PPR}_{\text{saída}} e CPRsaıˊda\text{CPR}_{\text{saída}}), 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.