Motorista L298N – Interface Arduino, Como Funciona, Códigos, Esquemas

Neste tutorial do Arduino vamos aprender como controlar motores DC usando o Arduino. Vamos dar uma olhada em algumas técnicas básicas para controlar motores DC e fazer dois exemplos através dos quais aprenderemos como controlar motores DC usando o driver do motor L298N e a placa Arduino.

Você pode assistir ao vídeo a seguir ou ler o tutorial escrito abaixo.

Podemos controlar a velocidade do motor CC simplesmente controlando a tensão de entrada do motor e o método mais comum de fazer isso é usando o sinal PWM.

Controle de Motor CC PWM

PWM, ou modulação por largura de pulso, é uma técnica que nos permite ajustar o valor médio da tensão que está indo para o dispositivo eletrônico ligando e desligando a energia em uma taxa rápida. A tensão média depende do ciclo de trabalho, 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.

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

Controle de motor CC da ponte H

Por outro lado, para controlar o sentido de rotação, precisamos apenas inverter o sentido do fluxo de corrente através do motor, e o método mais comum de fazer isso é usando uma ponte H. Um circuito H-Bridge contém quatro elementos de comutação, transistores ou MOSFETs, com o motor no centro formando uma configuração tipo H. Ao acionar dois interruptores específicos ao mesmo tempo, podemos alterar a direção do fluxo de corrente, alterando assim a direção de rotação do motor.

Então, se combinarmos esses dois métodos, o PWM e o H-Bridge, podemos ter um controle completo sobre o motor CC. Existem muitos drivers de motor DC que possuem esses recursos e o L298N é um deles.

Driver L298N

O L298N é um driver de motor H-Bridge duplo que permite o controle de velocidade e direção de dois motores DC ao mesmo tempo. O módulo pode acionar motores CC que possuem tensões entre 5 e 35V, com pico de corrente de até 2A.

Vamos dar uma olhada mais de perto na pinagem do módulo L298N e explicar como ele funciona. O módulo possui dois bornes de parafuso para o motor A e B, e outro bloco de bornes de parafuso para o pino de aterramento, o VCC para o motor e um pino de 5V que pode ser entrada ou saída.

Isso depende da tensão utilizada no VCC dos motores. O módulo possui um regulador de 5V integrado que é habilitado ou desabilitado usando um jumper. Se a tensão de alimentação do motor for de até 12V, podemos habilitar o regulador de 5V e o pino de 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 desconectar o jumper, pois essas tensões causarão danos ao regulador de 5V integrado. Neste caso, o pino de 5V será usado como entrada, pois precisamos conectá-lo a uma fonte de alimentação de 5V para que o IC funcione corretamente.

Podemos notar aqui que este CI faz uma queda de tensão de cerca de 2V. Por exemplo, se usarmos uma fonte de alimentação de 12V, a tensão nos terminais dos motores será de cerca de 10V, o que significa que não poderemos obter a velocidade máxima do nosso motor de 12V DC.

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 houver um jumper 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 dessa forma controlar a velocidade do motor. Se conectarmos este pino a um terra o motor será desabilitado.

Em seguida, os pinos Input 1 e Input 2 são usados para controlar o sentido de rotação do motor A, e as entradas 3 e 4 para o motor B. Usando esses pinos, controlamos as chaves da H-Bridge dentro do IC L298N. Se a entrada 1 for BAIXA e a entrada 2 for ALTA o motor se moverá para frente, e vice-versa, se a entrada 1 for ALTA e a entrada 2 for BAIXA o motor se moverá para trás. Caso ambas as entradas sejam iguais, seja em BAIXO ou ALTO o motor irá parar. O mesmo vale para as entradas 3 e 4 e o motor B.

Driver de motor de Arduino e L298N

Agora vamos fazer algumas aplicações práticas. No primeiro exemplo vamos controlar a velocidade do motor usando um potenciômetro e mudar o sentido de rotação usando um botão de pressão. Aqui está o esquema do circuito.

Então, 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 do Arduino nos links abaixo:

Motorista L298N ………………………………..
Motor CC de alto torque de 12V …………..
Motor DC com roda de pneu de plástico …….
Placa Arduino …………………………………
Breadboard e jump wires …………

Código do Arduino

Segue o código do 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);
  // Set initial rotation direction
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
}

void loop() {
  int potValue = analogRead(A0); // Read potentiometer value
  int pwmOutput = map(potValue, 0, 1023, 0 , 255); // Map the potentiometer value from 0 to 255
  analogWrite(enA, pwmOutput); // Send PWM signal to L298N Enable pin

  // Read button - Debounce
  if (digitalRead(button) == true) {
    pressed = !pressed;
  }
  while (digitalRead(button) == true);
  delay(20);

  // If button is pressed - change rotation direction
  if (pressed == true  & rotDirection == 0) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    rotDirection = 1;
    delay(20);
  }
  // If button is pressed - change rotation direction
  if (pressed == false & rotDirection == 1) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    rotDirection = 0;
    delay(20);
  }
}
Code language: Arduino (arduino)

Descrição: Então primeiro precisamos definir os pinos e algumas variáveis necessárias para o programa. Na seção de configuração, precisamos definir os modos dos pinos e a direção de rotação inicial do motor. Na seção de loop começamos lendo o valor do potenciômetro e então mapeamos o valor que obtemos dele que é de 0 a 1023, para um valor de 0 a 255 para o sinal PWM, ou que é 0 a 100% do ciclo de trabalho do sinal PWM. Em seguida, usando a função analogWrite(), enviamos o sinal PWM para o pino Enable da placa L298N, que na verdade aciona o motor.

Em seguida, verificamos se pressionamos o botão e, se for verdade, alteraremos o sentido de rotação do motor definindo os estados de Entrada 1 e Entrada 2 inversamente. O botão de pressão funcionará como botão de alternância e cada vez que o pressionarmos, ele mudará o sentido de rotação do motor.

Arduino Robot Car Control usando L298N Motor Driver

Então, uma vez que aprendemos isso, agora podemos construir nosso próprio carro robô Arduino. Segue o esquema do circuito:

Tudo o que precisamos são 2 motores DC, o driver do motor L298N, uma placa Arduino e um joystick para o controle. Quanto à fonte de alimentação, optei por usar três baterias de 3,7V Li-ion, fornecendo um total de 11V. Eu fiz o chassi de compensado de 3 mm, prendi os motores nele usando suportes de metal, prendi rodas nos motores e na frente prendi uma roda giratória.

Agora vamos dar uma olhada no código do Arduino e ver como ele funciona. (Abaixo você pode encontrar o código completo)

int xAxis = analogRead(A0); // Read Joysticks X-axis
int yAxis = analogRead(A1); // Read Joysticks Y-axisCode language: Arduino (arduino)

Após definir os pinos, na seção de loop, começamos com a leitura dos valores dos eixos X e Y do joystick. O joystick na verdade é composto por dois potenciômetros que estão conectados às entradas analógicas do Arduino e possuem valores de 0 a 1023. Quando o joystick fica na posição central o valor de ambos os potenciômetros, ou eixos, fica em torno de 512.

Vamos adicionar um pouco de tolerância e considerar os valores de 470 a 550 como centro. Portanto, se movermos o eixo Y do joystick para trás e o valor ficar abaixo de 470, definiremos a direção de rotação dos dois motores para trás usando os quatro pinos de entrada. Em seguida, converteremos os valores decrescentes de 470 para 0 em valores crescentes de PWM de 0 a 255, que na verdade é a velocidade do motor.

// Y-axis used for forward and backward control
  if (yAxis < 470) {
    // Set Motor A backward
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Set Motor B backward
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // Convert the declining Y-axis readings for going backward from 470 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  }Code language: Arduino (arduino)

Da mesma forma, se movermos o eixo Y do joystick para frente e o valor ultrapassar 550, ajustaremos os motores para avançar e converteremos as leituras de 550 a 1023 em valores PWM de 0 a 255. Se o joystick permanecer no centro, o velocidade dos motores será zero.

Em seguida, vamos ver como usamos o eixo X para o controle esquerdo e direito do carro.

// X-axis used for left and right control
  if (xAxis < 470) {
    // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
    int xMapped = map(xAxis, 470, 0, 0, 255);
    // Move to left - decrease left motor speed, increase right motor speed
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA < 0) {
      motorSpeedA = 0;
    }
    if (motorSpeedB > 255) {
      motorSpeedB = 255;
    }
  }Code language: Arduino (arduino)

Então, novamente, primeiro precisamos converter as leituras do eixo X em valores de velocidade de 0 a 255. Para mover para a esquerda, usamos esse valor para diminuir a velocidade do motor esquerdo e aumentar a velocidade do motor direito. Aqui, por causa das funções aritméticas, usamos duas declarações “if” adicionais para limitar a faixa 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 do motor DC PWM usando o IC do temporizador 555

Dependendo da tensão aplicada e do próprio motor, em velocidades mais baixas o motor não consegue iniciar o movimento e produz um zumbido. No meu caso, os motores não conseguiam se mover se o valor do sinal PWM estivesse abaixo de 70. Portanto, usando essas duas instruções if, na verdade, limitei a faixa de velocidade de 70 a 255. No final, apenas enviamos as velocidades finais do motor ou Sinal PWM para os pinos de habilitação do driver L298N.

// Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value of 70)
  if (motorSpeedA < 70) {
    motorSpeedA = 0;
  }
  if (motorSpeedB < 70) {
    motorSpeedB = 0;
  }
  analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
  analogWrite(enB, motorSpeedB); // Send PWM signal to motor BCode language: Arduino (arduino)

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); // Read Joysticks X-axis
  int yAxis = analogRead(A1); // Read Joysticks Y-axis

  // Y-axis used for forward and backward control
  if (yAxis < 470) {
    // Set Motor A backward
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Set Motor B backward
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // Convert the declining Y-axis readings for going backward from 470 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  }
  else if (yAxis > 550) {
    // Set Motor A forward
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    // Set Motor B forward
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    // Convert the increasing Y-axis readings for going forward from 550 to 1023 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(yAxis, 550, 1023, 0, 255);
    motorSpeedB = map(yAxis, 550, 1023, 0, 255);
  }
  // If joystick stays in middle the motors are not moving
  else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }

  // X-axis used for left and right control
  if (xAxis < 470) {
    // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
    int xMapped = map(xAxis, 470, 0, 0, 255);
    // Move to left - decrease left motor speed, increase right motor speed
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA < 0) {
      motorSpeedA = 0;
    }
    if (motorSpeedB > 255) {
      motorSpeedB = 255;
    }
  }
  if (xAxis > 550) {
    // Convert the increasing X-axis readings from 550 to 1023 into 0 to 255 value
    int xMapped = map(xAxis, 550, 1023, 0, 255);
    // Move right - decrease right motor speed, increase left motor speed
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA > 255) {
      motorSpeedA = 255;
    }
    if (motorSpeedB < 0) {
      motorSpeedB = 0;
    }
  }
  // Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value of 70)
  if (motorSpeedA < 70) {
    motorSpeedA = 0;
  }
  if (motorSpeedB < 70) {
    motorSpeedB = 0;
  }
  analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
  analogWrite(enB, motorSpeedB); // Send PWM signal to motor B
}Code language: Arduino (arduino)

Então isso seria tudo para este tutorial, e no meu próximo vídeo vamos atualizar este carro robô Arduino, adicionando um Bluetooth e dispositivos de rádio para habilitar o smartphone e o controle sem fio.

Sinta-se à vontade para fazer qualquer pergunta na seção de comentários abaixo e não se esqueça de verificar minha coleção de projetos do Arduino.

Controle sem fio de carro robô Arduino usando módulos de transceptor Bluetooth HC-05, NRF24L01 e HC-12 Módulo de comunicação sem fio de longo alcance Arduino e HC-12