Domine o Driver de Motor L298N: Controle Arduino, Esquemáticos e Código de Exemplo
Neste Tutorial Arduino, aprenderemos a controlar motores DC usando Arduino. Veremos algumas técnicas básicas para controlar motores DC e faremos dois exemplos através dos quais aprenderemos a controlar motores DC usando o driver de motor L298N e a placa Arduino.
Você pode assistir ao vídeo a seguir ou ler o tutorial escrito abaixo.
Controle de Velocidade de Motor DC
Podemos controlar a velocidade do motor DC simplesmente controlando a tensão de entrada no motor e o método mais comum de fazer isso é usando sinal PWM.

Controle de Motor DC por PWM
PWM, ou modulação por largura de pulso, é uma técnica que nos permite ajustar o valor médio da tensão que vai para o dispositivo eletrônico ligando e desligando a energia em uma taxa rápida. A tensão média depende do duty cycle, ou a quantidade de tempo que o sinal está LIGADO versus a quantidade de tempo que o sinal está DESLIGADO em um único período de tempo.

Dependendo do tamanho do motor, podemos simplesmente conectar uma saída PWM do Arduino à base de um transistor ou ao gate de um MOSFET e controlar a velocidade do motor controlando a saída PWM. O sinal PWM de baixa potência do Arduino liga e desliga o gate do MOSFET através do qual o motor de alta potência é acionado.

Controle de Motor DC por H-Bridge
Por outro lado, para controlar a direção de rotação, só precisamos inverter a direção do fluxo de corrente através do motor, e o método mais comum de fazer isso é usando uma H-Bridge. Um circuito H-Bridge contém quatro elementos de comutação, transistores ou MOSFETs, com o motor no centro formando uma configuração em H. Ativando dois interruptores particulares ao mesmo tempo, podemos mudar a direção do fluxo de corrente, assim mudando a direção de rotação do motor.

Se combinarmos estes dois métodos, PWM e H-Bridge, podemos ter controle completo sobre o motor DC. Existem muitos drivers de motor DC que têm essas características e o L298N é um deles.
Driver L298N
O L298N é um driver de motor dual H-Bridge que permite controle de velocidade e direção de dois motores DC ao mesmo tempo. O módulo pode acionar motores DC que têm tensões entre 5 e 35V, com corrente de pico de até 2A.

Vamos dar uma olhada mais de perto no pinout do módulo L298N e explicar como funciona. O módulo tem dois blocos de terminais de parafuso para motor A e B, e outro bloco de terminais para o pino Ground, VCC para motor e um pino 5V que pode ser tanto entrada quanto saída.

Isso depende da tensão usada no VCC do motor. O módulo tem um regulador 5V onboard que é habilitado ou desabilitado usando um jumper. Se a tensão de alimentação do motor for até 12V, podemos habilitar o regulador 5V e o pino 5V pode ser usado como saída, por exemplo para alimentar nossa placa Arduino. Mas se a tensão do motor for maior que 12V, devemos remover o jumper porque essas tensões causarão danos ao regulador 5V onboard. Neste caso, o pino 5V será usado como entrada, pois precisamos conectá-lo a uma fonte de alimentação 5V para que o CI funcione corretamente.
Podemos notar aqui que este CI causa uma queda de tensão de cerca de 2V. Então, por exemplo, se usarmos uma fonte de 12V, a tensão nos terminais dos motores será de cerca de 10V, o que significa que não conseguiríamos obter a velocidade máxima do nosso motor DC de 12V.

Em seguida, estão as entradas de controle lógico. Os pinos Enable A e Enable B são usados para habilitar e controlar a velocidade do motor. Se um jumper estiver presente neste pino, o motor será habilitado e funcionará na velocidade máxima, e se removermos o jumper, podemos conectar uma entrada PWM a este pino e assim controlar a velocidade do motor. Se conectarmos este pino ao Ground, o motor será desabilitado.

Em seguida, os pinos Input 1 e Input 2 são usados para controlar a direção de rotação do motor A, e os inputs 3 e 4 para o motor B. Usando estes pinos, controlamos na verdade os interruptores da H-Bridge dentro do CI L298N. Se input 1 for LOW e input 2 for HIGH, o motor moverá para frente, e vice-versa, se input 1 for HIGH e input 2 for LOW, o motor moverá para trás. Caso ambas as entradas sejam iguais, seja LOW ou HIGH, o motor parará. O mesmo se aplica para os inputs 3 e 4 e motor B.
Arduino e Driver de Motor L298N
Agora vamos fazer algumas aplicações práticas. No primeiro exemplo, controlaremos a velocidade do motor usando um potenciômetro e mudaremos a direção de rotação usando um botão. Aqui está o esquemático do circuito.

Precisamos de um driver de motor L298N, um motor DC, um potenciômetro, um botão e uma placa Arduino.
Você pode obter os componentes necessários para este Tutorial Arduino nos links abaixo:
- Driver L298N
- Motor DC High Torque 12V
- Motor DC com Roda de Plástico
- Placa Arduino
- Protoboard e Jumpers
Código Arduino
Aqui está o código Arduino:
/* Arduino DC Motor Control - PWM | H-Bridge | L298N - Example 01
by Dejan Nedelkovski, www.HowToMechatronics.com */
#define enA 9
#define in1 6
#define in2 7
#define button 4
int rotDirection = 0;
int pressed = false;
void setup() {
pinMode(enA, OUTPUT);
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
pinMode(button, INPUT);
// Define direção inicial de rotação
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
}
void loop() {
int potValue = analogRead(A0); // Lê valor do potenciômetro
int pwmOutput = map(potValue, 0, 1023, 0, 255); // Mapeia valor de 0-1023 para 0-255
analogWrite(enA, pwmOutput); // Envia sinal PWM para pino Enable do L298N
// Lê botão - Debounce
if (digitalRead(button) == true) {
pressed = !pressed;
}
while (digitalRead(button) == true);
delay(20);
// Se botão pressionado - muda direção de rotação
if (pressed == true & rotDirection == 0) {
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
rotDirection = 1;
delay(20);
}
// Se botão pressionado - muda direção de rotação
if (pressed == false & rotDirection == 1) {
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
rotDirection = 0;
delay(20);
}
}
Descrição: Primeiro precisamos definir os pinos e algumas variáveis necessárias para o programa. Na seção setup(), precisamos definir os modos de pino e a direção inicial de rotação do motor. No loop(), começamos lendo o valor do potenciômetro e então mapeamos o valor que obtemos dele (0 a 1023) para um valor de 0 a 255 para o sinal PWM, ou seja, 0 a 100% de duty cycle do sinal PWM. Então, usando a função analogWrite(), enviamos o sinal PWM para o pino Enable do L298N, que na verdade aciona o motor.
Em seguida, verificamos se pressionamos o botão, e se for verdade, mudaremos a direção de rotação do motor definindo os estados do Input 1 e Input 2 inversamente. O botão funcionará como botão toggle e cada vez que pressionarmos, mudará a direção de rotação do motor.
Controle de Carro Robô Arduino usando Driver L298N
Uma vez que aprendemos isso, agora podemos construir nosso próprio carro robô Arduino. Aqui está o esquemático do circuito:

Tudo que precisamos são 2 motores DC, o driver de motor L298N, uma placa Arduino e um joystick para o controle. Quanto à alimentação, escolhi usar três baterias Li-ion 3.7V, fornecendo total de 11V. Fiz o chassi de compensado de 3mm, fixei os motores nele usando suportes metálicos, fixei rodas nos motores e na frente fixei uma roda giratória.

Agora vamos ver o código Arduino e como ele funciona. (Abaixo você encontra o código completo)
int xAxis = analogRead(A0); // Lê eixo X do Joystick
int yAxis = analogRead(A1); // Lê eixo Y do Joystick
Após definir os pinos, na seção loop(), começamos lendo os valores dos eixos X e Y do joystick. O joystick é na verdade feito de dois potenciômetros conectados às entradas analógicas do Arduino e eles têm valores de 0 a 1023. Quando o joystick fica na posição central, o valor de ambos os potenciômetros, ou eixos, é cerca de 512.

Adicionaremos uma pequena tolerância e consideraremos os valores de 470 a 550 como centro. Então, se movemos o eixo Y do joystick para trás e o valor vai abaixo de 470, definiremos a direção de rotação dos dois motores para trás usando os quatro pinos de entrada. Então, converteremos os valores decrescentes de 470 a 0 em valores PWM crescentes de 0 a 255, que é na verdade a velocidade do motor.
// Eixo Y usado para controle frente/trás
if (yAxis < 470) {
// Motor A para trás
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
// Motor B para trás
digitalWrite(in3, HIGH);
digitalWrite(in4, LOW);
// Converte leituras decrescentes do eixo Y para ir para trás de 470 a 0 em valor 0-255 para sinal PWM
motorSpeedA = map(yAxis, 470, 0, 0, 255);
motorSpeedB = map(yAxis, 470, 0, 0, 255);
}
Similarmente, se movemos o eixo Y do joystick para frente e o valor vai acima de 550, definiremos os motores para mover para frente e converteremos as leituras de 550 a 1023 em valores PWM de 0 a 255. Se o joystick fica no centro, a velocidade dos motores será zero.
Em seguida, vamos ver como usamos o eixo X para controle esquerda/direita do carro.
// Eixo X usado para controle esquerda/direita
if (xAxis < 470) {
// Converte leituras decrescentes do eixo X de 470 a 0 em valor crescente 0-255
int xMapped = map(xAxis, 470, 0, 0, 255);
// Move para esquerda - diminui velocidade motor esquerdo, aumenta motor direito
motorSpeedA = motorSpeedA - xMapped;
motorSpeedB = motorSpeedB + xMapped;
// Limita intervalo de 0 a 255
if (motorSpeedA < 0) { motorSpeedA = 0; }
if (motorSpeedB > 255) { motorSpeedB = 255; }
}
Novamente, primeiro precisamos converter as leituras do eixo X em valores de velocidade de 0 a 255. Para mover para esquerda, usamos este valor para diminuir a velocidade do motor esquerdo e aumentar a do motor direito. Aqui, por causa das funções aritméticas, usamos dois statements "if" adicionais para limitar o intervalo da velocidade do motor de 0 a 255.

O mesmo método é usado para mover o carro para a direita.
Relacionado: Como Fazer um Controlador de Velocidade PWM Motor DC usando CI 555 Timer
Dependendo da tensão aplicada e do próprio motor, em baixas velocidades o motor não consegue começar a mover e produz um zumbido. No meu caso, os motores não conseguiam mover se o valor do sinal PWM fosse abaixo de 70. Portanto, usando estes dois statements if, eu realmente limitei o intervalo de velocidade de 70 a 255. No final, apenas enviamos as velocidades finais dos motores ou sinal PWM para os pinos enable do driver L298N.
// Evita zumbido em baixas velocidades (Ajuste conforme seus motores. Meus motores não conseguiam começar a mover se valor PWM abaixo de 70)
if (motorSpeedA < 70) { motorSpeedA = 0; }
if (motorSpeedB < 70) { motorSpeedB = 0; }
analogWrite(enA, motorSpeedA); // Envia sinal PWM para motor A
analogWrite(enB, motorSpeedB); // Envia sinal PWM para motor B
Aqui está o código completo do exemplo do carro robô Arduino:
/* Arduino DC Motor Control - PWM | H-Bridge | L298N
Example 02 - Arduino Robot Car Control
by Dejan Nedelkovski, www.HowToMechatronics.com */
#define enA 9
#define in1 4
#define in2 5
#define enB 10
#define in3 6
#define in4 7
int motorSpeedA = 0;
int motorSpeedB = 0;
void setup() {
pinMode(enA, OUTPUT);
pinMode(enB, OUTPUT);
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
pinMode(in3, OUTPUT);
pinMode(in4, OUTPUT);
}
void loop() {
int xAxis = analogRead(A0); // Lê eixo X do Joystick
int yAxis = analogRead(A1); // Lê eixo Y do Joystick
// Eixo Y usado para controle frente/trás
if (yAxis < 470) {
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
digitalWrite(in3, HIGH);
digitalWrite(in4, LOW);
motorSpeedA = map(yAxis, 470, 0, 0, 255);
motorSpeedB = map(yAxis, 470, 0, 0, 255);
} else if (yAxis > 550) {
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
digitalWrite(in3, LOW);
digitalWrite(in4, HIGH);
motorSpeedA = map(yAxis, 550, 1023, 0, 255);
motorSpeedB = map(yAxis, 550, 1023, 0, 255);
} else {
motorSpeedA = 0;
motorSpeedB = 0;
}
// Eixo X usado para controle esquerda/direita
if (xAxis < 470) {
int xMapped = map(xAxis, 470, 0, 0, 255);
motorSpeedA = motorSpeedA - xMapped;
motorSpeedB = motorSpeedB + xMapped;
if (motorSpeedA < 0) { motorSpeedA = 0; }
if (motorSpeedB > 255) { motorSpeedB = 255; }
}
if (xAxis > 550) {
int xMapped = map(xAxis, 550, 1023, 0, 255);
motorSpeedA = motorSpeedA + xMapped;
motorSpeedB = motorSpeedB - xMapped;
if (motorSpeedA > 255) { motorSpeedA = 255; }
if (motorSpeedB < 0) { motorSpeedB = 0; }
}
// Evita zumbido em baixas velocidades
if (motorSpeedA < 70) { motorSpeedA = 0; }
if (motorSpeedB < 70) { motorSpeedB = 0; }
analogWrite(enA, motorSpeedA);
analogWrite(enB, motorSpeedB);
}
Isso seria tudo para este tutorial, e no meu próximo vídeo atualizaremos este carro robô Arduino, adicionando dispositivos Bluetooth e Radio para permitir controle por smartphone e wireless.
Sinta-se à vontade para fazer qualquer pergunta na seção de comentários abaixo e não se esqueça de conferir minha coleção de Projetos Arduino.
Processo de manufatura
- Construa um Controle Remoto IR Universal com Arduino: Guia Passo a Passo
- Criar Robô Seguidor de Linha Autônomo com Arduino UNO
- Conectando Arduino Mega ao Módulo GPS NEO‑6M: Guia Passo a Passo
- Kit de Treinamento Arduino Completo com Mega 2560, Sensores, Motores e PCB Personalizada
- Usando Termistor Facilmente: Guia Passo a Passo com Arduino
- Braço Robótico Arduino Controlado por Gestos Manuais – Construção Passo a Passo
- Biblioteca Arduino de Alto Desempenho para Controle de Motor DC
- Mini Plotter CNC 2D com Drive de DVD Reciclado e Shield L293D
- Interfaces Cérebro-Computador: Reconectando Pensamento à Ação
- Motores de Acionamento Direto: Benefícios, Tipos e Princípios de Funcionamento