Motor DC no Arduino: sentido e velocidade com ponte H, sem queimar a placa

Você liga o motorzinho amarelo direto no pino 9, manda digitalWrite(9, HIGH) e ele dá um tranco, para, e a placa reinicia. Se insistir, o pino deixa de funcionar. Um pino do Uno tem limite absoluto de 40 mA, e o recomendado é bem menos; um motor pequeno pede centenas de miliampères para arrancar. O pino não empurra motor. Ele derrete tentando.

A resposta curta: entre o Arduino e o motor vai uma ponte H, como o módulo L298N ou um driver TB6612FNG. Dois pinos digitais escolhem o sentido, um pino com PWM no habilitador escolhe a velocidade, e o motor bebe de uma fonte separada que divide o terra com o Arduino. O Arduino só manda sinal.

Por que a ponte H existe

Um motor DC gira para um lado com a tensão num sentido e para o outro com os fios trocados. Trocar fios na mão é fácil; trocar com um programa exige quatro chaves dispostas como a letra H, com o motor no traço do meio. Fechando a chave de cima à esquerda e a de baixo à direita, a corrente passa num sentido. Fechando as outras duas, passa no sentido oposto.

No módulo pronto, essas chaves são transistores comandados pelos pinos IN1 e IN2, e a corrente vem da fonte do motor, não do Arduino. O pino ENA liga ou desliga a ponte inteira daquele motor. É nele que o PWM entra: ligando e desligando centenas de vezes por segundo, o motor sente uma média. Mais tempo ligado, mais velocidade.

Uma ponte montada à mão com transistores avulsos tem um perigo que o módulo resolve: fechar as duas chaves do mesmo lado ao mesmo tempo liga a fonte direto no terra. Num L298N, IN1 e IN2 iguais com ENA ligado não é curto; é freio, porque os dois terminais do motor ficam no mesmo potencial. Leia a tabela do seu driver antes de testar combinações.

Como ligar o L298N no Arduino Uno

O exemplo que vai atravessar o texto: um carrinho com um motor de 3 a 6 V com caixa de redução, alimentado por quatro pilhas AA (6 V), controlado por um Uno.

1. Fonte do motor: positivo das pilhas no borne de alimentação do motor do módulo (geralmente marcado 12V ou VCC), negativo no GND do módulo.
2. Terra comum: um fio do GND do módulo ao GND do Arduino. Sem ele, os sinais de IN1, IN2 e ENA não têm referência.
3. Motor nos bornes OUT1 e OUT2.
4. Sinais: IN1 no pino 8, IN2 no pino 7, ENA no pino 9 (que tem PWM no Uno).
5. Retire o jumper do ENA. Com ele no lugar, o habilitador fica sempre ligado e o PWM do pino 9 não chega.
6. Alimente o Arduino pelo USB enquanto testa.

Uma conta que muda o resultado: o L298N usa transistores bipolares e perde alguns volts no caminho; é comum o motor receber perto de 2 V a menos do que a fonte entrega. Com 6 V nas pilhas, o motor pode ver uns 4 V. Se ele ficar fraco, a causa pode ser essa, não o código. Drivers com MOSFET, como o TB6612FNG, perdem muito menos, mas aguentam menos corrente; confira a folha de dados do que você tem contra a corrente do seu motor travado.

O código: sentido, velocidade e parada

const int PINO_IN1 = 8;
const int PINO_IN2 = 7;
const int PINO_ENA = 9;   // precisa ser um pino com PWM

void frente(int velocidade) {
  digitalWrite(PINO_IN1, HIGH);
  digitalWrite(PINO_IN2, LOW);
  analogWrite(PINO_ENA, constrain(velocidade, 0, 255));
}

void tras(int velocidade) {
  digitalWrite(PINO_IN1, LOW);
  digitalWrite(PINO_IN2, HIGH);
  analogWrite(PINO_ENA, constrain(velocidade, 0, 255));
}

// Terminais no mesmo nível com a ponte ligada: o motor freia.
void frear() {
  digitalWrite(PINO_IN1, LOW);
  digitalWrite(PINO_IN2, LOW);
  analogWrite(PINO_ENA, 255);
}

// Ponte desligada: o motor gira solto até parar.
void soltar() {
  analogWrite(PINO_ENA, 0);
}

void rampa(bool paraFrente, int de, int ate) {
  int passo = (ate > de) ? 5 : -5;
  for (int v = de; v != ate; v += passo) {
    if (paraFrente) frente(v); else tras(v);
    delay(20);
  }
  if (paraFrente) frente(ate); else tras(ate);
}

void setup() {
  pinMode(PINO_IN1, OUTPUT);
  pinMode(PINO_IN2, OUTPUT);
  pinMode(PINO_ENA, OUTPUT);
  soltar();
}

void loop() {
  rampa(true, 0, 200);    // acelera para a frente
  delay(2000);
  rampa(true, 200, 0);    // desacelera
  frear();
  delay(500);             // espera parar antes de inverter

  rampa(false, 0, 200);   // acelera para trás
  delay(2000);
  rampa(false, 200, 0);
  soltar();
  delay(1500);
}

Os passos de 5 na rampa dividem 200 sem sobra, então o laço termina exatamente no valor pedido. Se você mudar os limites, mantenha os valores múltiplos do passo.

Frear, soltar e inverter sem tranco

Inverter o sentido com o motor girando rápido faz a corrente disparar: o motor, ainda girando, gera tensão contra a nova alimentação, e a ponte recebe a soma. Por isso o código desacelera, freia e espera meio segundo antes de inverter. A fonte agradece, e o Arduino deixa de reiniciar por queda de tensão.

Soltar e frear não são a mesma coisa. Soltar desliga a ponte, e o carrinho rola até parar. Frear segura o eixo, útil para parar num ponto. Escolha conforme o projeto, e saiba qual das duas o seu stop() faz.

O motor também devolve energia quando você corta a corrente, na forma de um pico de tensão. Módulos comuns já trazem diodos para escoar esse pico; numa ponte montada à mão, eles são obrigatórios. Um fio do motor ligado direto num pino não tem proteção nenhuma.

Velocidade baixa que não arranca

Com analogWrite em 60, o motor zumbe e não sai do lugar. Abaixo de certo ciclo, a força média não vence o atrito da caixa de redução. Descubra o mínimo do seu motor subindo de 10 em 10 até ele girar, e use esse valor como piso. O zumbido em si vem da frequência do PWM: no pino 9 do Uno ela fica perto de 490 Hz, dentro da faixa audível. Para o que o PWM faz e não faz com a tensão, veja PWM muda o esforço médio do motor, não a voltagem.

Erros comuns

• Motor direto no pino: o pino passa do limite, a placa reinicia e o pino pode morrer de vez.
• Motor alimentado pelo 5 V do Arduino: o regulador ou a porta USB não aguentam o pico de partida e tudo reinicia.
• Esquecer o terra comum: o motor gira de forma errática ou não responde aos sinais.
• Deixar o jumper no ENA: o motor só tem velocidade máxima e o PWM parece não funcionar.
• Inverter o sentido em plena velocidade: pico de corrente, fonte caindo e driver esquentando.
• PWM num pino sem PWM: no Uno, só 3, 5, 6, 9, 10 e 11 geram PWM; em outro pino o motor só liga ou desliga.

Checklist

• O motor recebe corrente de uma fonte própria, não do Arduino.
• GND da fonte, do driver e do Arduino estão interligados.
• ENA está num pino com PWM e o jumper do ENA foi retirado.
• Você sabe o que o seu driver faz com IN1 e IN2 iguais.
• O código desacelera e espera antes de inverter o sentido.
• Você mediu a tensão nos terminais do motor girando e sabe quanto o driver perde.
• Conhece o valor mínimo de PWM em que o motor arranca.

Encoste o dedo no regulador da placa e no driver depois de dois minutos de motor rodando. Qual dos dois está quente? Se for o Arduino, o motor ainda está bebendo do lugar errado.