Início / Projetos Arduino / Projetos Squids / Intermediário / I07 - Como controlar motores DC com o Driver Ponte H - L298N e Arduino

---

I07 - Como controlar motores DC com o Driver Ponte H - L298N e Arduino

Angelo Luis Ferreira | 18/11/2020 Acessos: 13.462

Objetivo

Neste tutorial vamos mostrar como controlar a velocidade e o sentido de rotação de 2 pequenos motores CC (motor de corrente contínua) através de um driver motor ponte H - L298N e o Arduino. A velocidade dos motores serão controladas por um potenciômetro através do sinal PWM (Pulse Width Modulation) gerado pelo Arduino. O sentido de rotação dos motores será alterado toda vez que o usuário clicar em um botão (push button). Também utilizaremos um botão (push button) como freio, ou seja, para ligar e desligar os motores. Leia também: I05 - Controlando um motor DC com Arduino, transistor e potenciômetro e I06 - Controlando um motor DC com L293D (Ponte H) e Arduino.

Definições

Motores CC (DC motor): De forma geral, os motores CC, de corrente contínua, são dispositivos que convertem energia elétrica em energia mecânica, gerando uma rotação no seu eixo. Este tutorial deve ser utilizado apenas para motores que consomem menos que 2A quando alimentados por uma tensão de 5 a 12V. No nosso projeto, vamos utilizar um motor de corrente contínua de 130mA para uma tensão de 5V com potência e rendimento máximo.

ATENÇÃO:

a) Nunca ligue o motor CC diretamente no Arduino, pois poderá danificar irreversivelmente o seu microcontrolador. Os pinos digitais do Arduino oferecem no máximo 40mA e um motor CC, mesmo que pequeno, consome muito mais que isto. Portanto, para controlar um motor CC é necessário a utilização de correntes mais altas que as do Arduino e por isso você deverá utilizar transistores ou circuitos chamados de Ponte H (ver wikipedia) como os circuitos integrados controladores de motores L293D ou SN754410. Esses componentes irão garantir correntes satisfatórias para operar o motor em vazio ou em plena carga. Também podemos utilizar módulos (conjunto de componentes montados) denominados de Driver Ponte H desenvolvidos especificamente para controlar cargas indutivas como: relés, solenoides, motores DC e motores de passo.

b) Neste projeto escolhemos o Driver Motor Ponte H L298N, baseado no chip L298N (datasheet). Com este módulo podemos controlar a velocidade e o sentido de rotação de ate dois motores DC ao mesmo tempo, de forma simultânea ou independente. Veja abaixo algumas características do componente:

Observação: O chip L298N (datasheet), base do driver motor ponte H que usaremos neste projeto. Este componente é muito utilizado no controle de motores, assim como o L293D (I06 - Controlando um motor DC com L293D (Ponte H) e Arduino). O chip nada mais é do que uma ponte H duplo inserido em um componente integrado, ocupando um menor espaço no circuito.

Características do driver ponte H L298N

– Tensão de Operação: 4~35v
– Tensão máxima de alimentação externa  7 - 35V
– Chip: ST L298N (datasheet)
– Controle de 2 motores DC ou 1 motor de passo
– Corrente de Operação máxima: 2A por canal ou 4A max
– Tensão lógica: 5v
– Corrente lógica por entrada: 0~36mA
– Limites de Temperatura: -20 a +135°C
– Potência Máxima: 25W

c) Abaixo vamos entender a função de cada pino de entrada e saída do driver motor ponte H L298N:

Entradas e saídas do módulo Driver motor com Ponte H L298n

c1) Motor A e Motor B: Conexões para alimentação dos motores A e B.

c2) Porta 6-35V: Porta para alimentação do módulo com tensão entre 6 a 35V (Corrente Contínua).

c3) Conexão Ativa 5V: Quando jumpeada, a placa ativará o regulador de tensão integrado para fornecer 5v (max. 200mA) na porta 5v (Vlogic). quando a porta 6-35V estiver recebendo energia. A tensão regulada fornecida pela porta Vlogic 5V  poderá ser usada para alimentar um componente eletrônico ou o próprio Arduino, por exemplo.

Atenção: Quando a conexão Ativa 5V estiver jumpeada, recomenda-se utilizar tensões na porta 6-35V de até 20V. Tensões maiores que 20V poderá sobreaquecer o driver. Isto acontece porque o regulador de tensão interno do módulo trabalha com uma margem segura de 6 a 20V.

c4) Porta 5v (Vlogic): Quando o regulador de tensão estiver ativado (conexão Ativa 5V jumpeada), a tensão Vlogic será regulada para 5V automaticamente, e poderá ser utilizada por algum circuito ou componente eletrônico que utilize uma tensão de até 5V e corrente máxima de 200mA.

Atenção: Se o regulador de tensão estiver ativado (conexão Ativa 5V jumpeada), JAMAIS alimente o pino Vlogic 5V, pois isso poderá causar danos irreversíveis ao driver ponte H L298N.

Obs.: Em casos de não haver fonte de alimentação disponível com mais de 6V pode-se alimentar o driver com 5V por este pino. Para isso, é necessário remover o jumper Ativa 5V. Mas,  por segurança da placa Arduino e do driver, não recomendamos essa configuração. Em projetos com motores DC, procure sempre utilizar fontes independentes: fonte para alimentação do Arduino e fonte externa para alimentação do driver ponte H.

c5) Conexão Ativa MA: Quando jumpeada aciona o motor A com velocidade máxima. Para controlar a velocidade do motor A basta remover o jumper e alimentar o pino com uma tensão entre 0 e 5v, onde 0V é a velocidade mínima (parado) e 5V a velocidade máxima.

c6) Conexão Ativa MB: Quando jumpeada aciona o motor B com velocidade máxima. Para controlar a velocidade do motor B basta remover o jumper e alimentar o pino com uma tensão entre 0 e 5v, onde 0V é a velocidade mínima (parado) e 5V a velocidade máxima.

d) Como definimos a utilização de uma fonte externa para alimentar o nosso driver ponte H L298N no nosso projeto, devemos seguir a configuração abaixo:

d1) Manter o jumper (Ativa 5V) para ativar o regulador de tensão 5V do driver sempre que utilizarmos uma fonte externa de 6 a 35V (recomendada de 6 a 20V).

d2) Quando mantemos o jumper (Ativa 5V), ativamos o regulador de tensão interno do módulo ponte H. Este regulador por sua vez, disponibiliza uma saída regulada de 5V na porta Vlogic 5V, podendo alimentar por exemplo outro componente eletrônico qualquer. Obs.: No nosso projeto não utilizaremos esta porta.

Atenção: Quando o jumper estiver mantido, jamais alimente este pino (Vlogic) com qualquer tensão, pois poderá danificar a placa.

e) Preste bem atenção na montagem do circuito antes de ligar na energia elétrica. Qualquer erro poderá causar danos irreversíveis nos componentes e na placa do Arduino.

Aplicação

Para fins didáticos e projetos de automação, robótica e máquinas eletrônicas em geral.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 pontos	1
Jumpers	Kit cabos ligação macho / macho	1
Micro Motor DC	Micro Motor de corrente contínua (CC) 6000rpm / 5V	2		– Tensão nominal: 3,0 a 5,0V - Corrente sem carga: 90mA - Corrente em plena carga: 130mA - Rotação sem carga: 6.000 rpm - Rotação máximo rendimento: 5.800 rpm - Potência Máxima: 0,35W (datasheet)
Driver Motor Ponte H L298N	Módulo Driver Motor Ponte H L298N	1		– Tensão de Operação: 4~35v – Tensão máxima de alimentação externa  7 - 35V – Chip: ST L298N (datasheet) – Controle de 2 motores DC ou 1 motor de passo – Corrente de Operação máxima: 2A por canal ou 4A max – Tensão lógica: 5v – Corrente lógica por entrada: 0~36mA – Limites de Temperatura: -20 a +135°C – Potência Máxima: 25W
Push Button	Push button 6X6X5mm	2
Potenciômetro	Potenciômetro 10K	1		Você poderá experimentar valores diferentes do potenciômetro, entre 1K a 100K. A tensão resultante do potenciômetro aumenta quando giramos o eixo do componente no sentido do polo negativo para o polo positivo
Led 5mm	Led 5mm	3		3 LEDs alto brilho ou difuso No projeto utilizamos 1 led verde, 1 led amarelo e 1 led vermelho Você poderá utilizar também LEDs de 3 mm e as cores que desejar.
Resistor	Resistor 150Ω	3		3 Resistores de 150Ω ou superiores (leds)
Fonte chaveada	fonte chaveada de 9V (plug p4)	1		A fonte foi utilizada no projeto para alimentar o Arduino e o driver ponte H L298N. Utilizamos o pino Vin do Arduino como fonte externa para o driver ponte H. – Tensão de saída: 7,5 a 9 VDC (usamos 9V) – Corrente máxima de saída: 1A A fonte externa deverá ser definida conforme as características do motor utilizado (entre 3 a 20V) Você poderá utilizar baterias, pilhas e reguladores de tensão para alimentar o Arduino e/ou o driver ponte H.
Arduino UNO	Arduino UNO R3	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Montagem do Circuito

Conecte os componentes no Protoboard como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da energia elétrica enquanto você monta o circuito.

Atenção

1. Como já mencionamos, é recomendável sempre utilizar uma fonte externa para alimentar driver ponte H L298N de forma independente da alimentação do Arduino. Placas Arduino, além de caras, são susceptíveis quando conectadas a dispositivos de correntes elevadas, como os motores de corrente contínua. Além disso, os motores utilizados poderão exigir tensões e correntes acima do que o Arduino pode fornecer. Lembre-se que o Arduino possui um regulador de tensão para 5V ou 3,3V.

1.1. Partindo da premissa que é recomendável separarmos as fontes de alimentação, no nosso projeto vamos dividir o circuito em 2 partes:

1.1.1. A primeira parte será alimentada diretamente pelo Arduino (Vcc = 5V) que inclui o potenciômetro, leds e os botões de controle. É importante lembrar que a placa de Arduino deverá ser alimentada de forma independente por meio do USB de um computador, baterias ou pilhas (7 a 12V) ou por uma fonte chaveada de 7 a 12V (plug P4), por exemplo.

1.1.2. A segunda parte é formada basicamente pelo drver ponte H L298H e pelos dois motores DC (5V/130mA). O módulo ponte H será alimentado por uma fonte externa com 9V que por consequência alimentará os motores de corrente contínua.

Cálculo da tensão de alimentação para o Driver Motor Ponte H L298N

1.2. Para calcularmos a tensão mínima necessária para alimentar o driver niotor ponte H L928N e fazer funcionar o(s) motor(es) adequadamente, devemos levar em conta a queda de tensão gerada pelo acionamento dos transistores internos do chip L298N. Em média, de acordo com as pesquisas que realizamos na internet, a queda de tensão no chip L298N é de 2,5V (para 1A). Portanto a tensão aplicada no driver ponte H deverá ser 2,5V superior que a tensão nominal de cada motor.

1.2.1. Portanto Vm = Va + 2,5V (Vm = tensão mínima necessária para alimentar o motor, Va = tensão aplicada no driver ponte H). Veja abaixo uma tabela onde definimos os valores práticos para a tensão de alimentação mínima que deverá ser aplicada no driver ponte H L298N de acordo com o(s) motor(es) utilizado(s):

1.2.2. É importante ressaltarmos que a velocidade do motor depende diretamente da tensão recebida. Portanto, a alimentação do driver poderá ser um limitante caso não considerarmos a queda de tensão que ocorre no chip L298N.

1.2.3. Como no nosso projeto vamos utilizar um motor de 5V, podemos alimentar o driver motor ponte H com uma fonte externa de no mínimo 7,5V.

1.2.4.  A fonte de alimentação externa deverá ter tensão e corrente suficientes para acionar e controlar os motores CC utilizados. Para evitar a queima do motor, não devemos utilizar fonte externa com tensões muito superiores à tensão de operação do motor. As características do motor podem ser obtidas no datasheet do componente. (Para saber mais sobre dimensionamento de motores, leia Motor CC: Saiba como Funciona e de que forma Especificar).

Fonte de alimentação externa (utilizado para alimentação do driver ponte H L298N)

1.3. Como vimos na tabela acima, devemos utilizar fontes de alimentação com tensões adequadas para fazer com que o driver motor ponte H forneça tensão e corrente suficientes para o funcionamento correto dos motores. Essas fontes deverão estar conectadas diretamente no driver conforme configuração que mostramos no início do tutorial, ou seja, usar a porta 6-35V e a porta GND do módulo com a conexão Ativa 5V jumpeada.

1.3.1. Existem vários tipos de fontes de alimentação que poderão ser utilizados neste projeto, como por exemplo: bateria 9V, conjunto de pilhas com 7,5V (5 pilhas de 1,5V) e o pino Vin do próprio Arduino, entre outros.

1.3.2. Escolhemos usar o próprio Arduino como uma fonte externa (pino Vin). Mas como assim? Não temos que ter duas fontes independentes?

1.3.2.1. A rigor, quando utilizamos o pino Vin do Arduino junto com uma fonte de alimentação conectada no plugue P4 (conexão Jack), obteremos uma fonte externa com o mesmo valor da fonte de alimentação utilizada. Veja no exemplo abaixo que a fonte de alimentação é uma bateria de 9V, portanto, a saída no pino Vin será também de 9V. Isto é muito útil em protótipos de robótica, pois a mesma bateria irá alimentar o Arduino e os motores de corrente contínua através do driver ponte H.

Obs.: O pino Vin também pode ser utilizado como entrada de energia para a placa Arduino. Mas cuidado, essa configuração deverá ser utilizado em casos especiais, quando usamos "shields" acoplados por exemplo.

Atenção: A tensão de alimentação feita através do conector Jack deverá estar entre os limites de 7 a 12V. Abaixo de 7V a tensão de funcionamento da placa Arduino poderá ficar instável e acima de 12V o regulador de tensão integrado da placa poderá sobreaquecer.

1.3.3. Portanto, vamos utilizar neste projeto uma fonte de alimentação de 9V (bateria ou fonte de alimentação chaveada) conectada no plugue P4 (Jack) do Arduino. Desta forma, alimentaremos a placa do Arduino e teremos um pino Vin de saída com 9V que servirá como fonte de alimentação externa e independente para o driver motor ponte H L298N.

Obs.: Se você não quiser utilizar o pino Vin do Arduino, poderá usar uma fonte de alimentação externa de 7,5 ou 9V conectada diretamente no driver ponte H. Neste caso, será necessário você alimentar o Arduino também via USB ou através do conector Jack da placa.

1.3.4. Posso utilizar a conexão USB e o conector Jack ao mesmo tempo? Sim, não existe problema algum em usar a sua placa Arduino conectada ao computador (USB) mesmo quando conectada à uma fonte de alimentação via conector Jack (plugue P4). O Arduino automaticamente irá regular a tensão interna para 5V e ainda liberar a tensão de alimentação no pino Vin. Desta forma, você poderá fazer o upload dos códigos (sketch) normalmente para o IDE sem se preocupar com a alimentação externa da placa, desde que a tensão aplicada no conector Jack esteja entre 7 e 12V.

Parte do circuito alimentada diretamente pelo Arduino

2. Lembre-se que o LED tem polaridade: O terminal maior tem polaridade positiva e o lado do chanfro tem polaridade negativa.

2.1. Portanto, faça a conexão do Arduino no terminal positivo do led (anodo) e o GND no terminal negativo (catodo).

2.2. Para evitar danos ao led é necessário a inclusão de um resistor no circuito. Como o resistor é um limitador da corrente elétrica, ele poderá estar conectado no anodo (terminal maior) ou no catodo (terminal menor) do led, tanto faz.

3. Determinamos o valor do resistor através da tabela prática: Tabela prática de utilização de leds 3mm e 5mm. Entretanto, o mais correto é sempre verificar o datasheet do fabricante do LED para você ter os exatos valores de tensão e corrente do mesmo - leia Leds ligados em série e em paralelo.

3.1. Valores mínimos utilizados para nossos projetos: LEDs difusos ou de alto brilho: Vermelho, Laranja e Amarelo: 150 Ω | Led Verde e Azul: 100 Ω

4. Observe que o potenciômetro foi montado como um divisor de tensão, onde utilizamos os 3 terminais do componente. Desta forma, o potenciômetro funciona como um divisor de tensão que pode ser lido pelo IDE do Arduino através do conversor analógico digital (ADC ou DAC em inglês). Girando o eixo do polo negativo (GND) para o polo positivo (Vcc) aumentamos o valor da tensão e portanto aumentamos a velocidade do motor, e ao contrário, diminuiremos portanto a velocidade de rotação do motor.

4.1. O potenciômetro utilizado no projeto é um componente mecânico analógico, e por este fato o terminal "b", veja a imagem acima, deverá estar conectado à uma porta analógica do Arduino. No nosso exemplo, conectamos o potenciômetro na porta analógica A0 do Arduino.

4.2. O conversor analógico-digital (frequentemente abreviado por conversor A/D ou ADC) é um dispositivo eletrônico capaz de gerar uma representação digital a partir de uma grandeza analógica, normalmente um sinal representado por um nível de tensão ou intensidade de corrente elétrica. O Arduino UNO (microcontrolador ATmega328) possui um conversor analógico digital interno de 10 bits de resolução (2¹⁰ = 1024), ou seja, podendo variar seus valores entre 0 e 1023.

5. Monte os botões (push button) sem o resistor, pois através da programação vamos habilitar o resistor pull-up interno do Arduino. Desta forma, quando o botão estiver pressionado, o Arduino retornará "LOW" ou "0". Veja o projeto Projeto 02b - Led apaga com push button pressionado (pull-up interno do Arduino) ou assista o vídeo Arduino: Botão e Resistor de Pull Up Interno

Parte do circuito alimentada por fonte externa (driver ponte H)

6. Como vimos anteriormente, a placa ponte H L298N deverá ser alimentada por uma fonte externa de 7,5 a 9V (mínimo 7,5 para motores de 5V). No nosso exemplo utilizamos o pino Vin do Arduino como fonte de alimentação externa, onde alimentamos o microcontrolador com uma fonte de alimentação chaveada 9V (plugue P4 - jack). É importante lembrar que a conexão Ativa 5V da placa ponte H deverá permanecer jumpeada.

7. Agora vamos fazer as conexões dos motores. Primeiro conectamos os motores A e B nas saídas de alimentação do driver ponte H L298N. A posição do motor em relação à ligação com a placa definirá o sentido de rotação, ou seja, se invertermos os fios de conexão com a placa inverteremos o sentido de rotação também. Obs.: Caso precise utilizar apenas um motor, escolha o lado para a conexão e siga os procedimentos abaixo.

7.1. Não se preocupe nesse momento com a polaridade de ligação dos motores à placa ponte H, pois verificaremos depois o sentido de rotação do eixo.

8. Para conectarmos nossos motores ao Arduino e definirmos o sentido de rotação do motor precisaremos utilizar os pinos IN1, IN2, IN3 e IN4 do driver ponte H L298N, sendo que os pinos IN1 e IN2 controlam o motor A (a direita) e os pinos IN3 e IN4 o motor B (a esquerda).

8.1. Abaixo mostraremos uma tabela com as conexões entre o driver ponte H e o Arduino do nosso exemplo:

Teste 01 - Rotação dos motores

9. Definindo sentido de rotação dos eixos dos motores através da programação: Vamos ajustar os motores para que tenham o mesmo sentido anti-horário de rotação.

9.1. Primeiro vamos entender a lógica dos pinos de conexão do driver com o Arduino. Como em todo sistema digital, podemos enviar um sinal HIGH (1) ou um sinal LOW (0) para obtermos um resultado. Portanto a tabela abaixo mostra os resultados quando enviamos esses sinais das portas de saída do Arduino para os pinos de entrada do driver ponte H.

Obs.: O sentidos de rotação 1 e 2 vão depender da forma como você conectou os motores, podendo ser sentido horário ou sentido anti-horário.

 9.2. Agora que entendemos a lógica de programação, vamos rodar um teste para ajustar os sentidos de rotação dos eixos do motores. Neste teste vamos fazer com que os dois motores rodem no mesmo sentido de rotação.

9.2.1. Primeiro, mantenha os jumps das conexões Ativa MA e Ativa MB. Isto fará com que os motores girem na velocidade máxima. Sem esses jumps, os motores ficarão desligados.

 9.2.2. Copie o código abaixo e cole no IDE do Arduino. Faça o upload e rode o programa.

/*******************************************************************************

     Projeto I07 - Teste configuração sentido de rotação
     Autor: Angelo Luis Ferreira
     Data: 30/11/2020
             http://squids.com.br/arduino

*******************************************************************************/
//motor A
const byte IN1 = 13 ;
const byte IN2 = 12 ;

//motor B
const byte IN3 = 11;
const byte IN4 = 10;
 
//Inicializa Pinos
void setup(){
 pinMode(IN1,OUTPUT); // motor A
 pinMode(IN2,OUTPUT); // motor A
 pinMode(IN3,OUTPUT); // motor B
 pinMode(IN4,OUTPUT); // motor B
}
 
void loop(){
 
 /*Inicio dos Estados do motor A*/ 
 digitalWrite(IN1,HIGH);
 digitalWrite(IN2,LOW);
 
 /*Inicio dos Estados do motor B*/ 
 digitalWrite(IN3, HIGH);
 digitalWrite(IN4,LOW); 
}

9.2.3. Se a fonte externa que alimenta o driver ponte H estiver ligada, os motores deverão funcionar na velocidade máxima. Os motores deverão rodar no mesmo sentido de rotação (horário).

9.2.4. Observe qual o sentido de rotação do eixo do Motor A: Se estiver rodando no sentido anti-horário, pode ser que a conexão do motor esteja invertida. Inverta a polaridade na conexão dos motores com o drive.

9.2.5. Repita a verificação acima, agora para o Motor B. Se estiver rodando no sentido horário, inverta a polaridade de conexão com o drive. Desta forma, faça com que os dois motores girem no mesmo sentido.

Teste 02 - Variação da velocidade

10. Configurando para controlar a velocidade dos motores: Vamos fazer com que a velocidade de rotação do eixo do motor varie ao longo do templo. Para isso vamos criar uma rampa de aceleração e desaceleração como exemplo. Obs.: A rampa de aceleração é muito utilizada em projetos de robótica, pois evita que o motor atinja um pico de corrente muito alto quando é partido.

10.1. Para criarmos as nossas rampas de aceleração e desaceleração, vamos primeiro fazer as conexões dos pinos responsáveis pelo controle de velocidade.

10.1.1. Para fazer variar a velocidade dos eixos dos motores é necessário remover os jumpers Ativa MA e ativa MB do drive ponte H e conectá-los no Arduino, conforme tabela abaixo:

Atenção: Para controlar a velocidade do motor é necessário utilizar as portas as PWM (Pulse Width Modulation) do Arduino. No nosso projeto vamos usar as portas 9 e 3.

10.1.2. Veja na imagem abaixo quais os pinos que vamos usar para o controle da velocidade dos motores.

10.2. Para ativarmos o controle de velocidade do motor vamos usar a técnica PWM (Pulse Width Modulation), onde o Arduino irá modular o sinal que será enviado para a entrada ENA e para o entrada ENB do módulo L298N. Esta modulação gerada pelo Arduino vai fazer com que o motor ligue e desligue muitas vezes por segundo, aumentando ou diminuindo a velocidade de acordo com o ciclo de trabalho (duty cycle) da onda que foi previamente programado.

PWM (Pulse Width Modulation) - Modulação por Largura de Pulso

10.3. Refere-se ao conceito de pulsar rapidamente um sinal digital em um condutor. Quando geramos a modulação através da largura do pulso em uma onda quadrada podemos controlar a potência ou a frequência de um circuito.

10.3.1. A técnica de PWM é empregada em diversas áreas da eletrônica e, por meio da largura do pulso de uma onda quadrada, é possível o controle de potência ou velocidade nas aplicações de motores elétricos, aquecedores elétricos, leds e luzes nas diferentes intensidades e frequências. O Projeto 14 - Led com efeito dimmer usando potenciômetro é um ótimo exemplo de como utilizar o PWM para controlar a intensidade luminosa de um led utilizando a função analogWrite().

10.3.1.1. Veja abaixo um gráfico que mostra alguns exemplos de PWM de acordo com o ciclo de trabalho (duty cycle) entre 0% e 100%.

10.3.1.2. É importante entendermos também que a modulação PWM para o Arduino UNO (microcontrolador ATmega328) tem resolução de 8 bits (2⁸ = 256), variando, portanto, de 0 a 255. Quando zero, o motor estará desligado e quando 255 o motor estará na máxima velocidade.

10.4. Agora que estamos com o nosso circuito finalizado (todas as portas do drive estão conectadas no Arduino), podemos fazer o nosso teste de variação de velocidade.

10.4.1. Copie o código abaixo e cole no IDE do Arduino. Faça o upload e rode o programa.

/*******************************************************************************

     Projeto I07 - Teste variação de velocidade - rampa aceleração e desaceleração
     Autor: Angelo Luis Ferreira
     Data: 30/11/2020
             http://squids.com.br/arduino

*******************************************************************************/
//motor A
const byte IN1 = 13 ;
const byte IN2 = 12 ;

//motor B
const byte IN3 = 11;
const byte IN4 = 10;

//pinos utilizados para controlar a velocidade de rotacao
const int ENA = 9; 
const int ENB = 3;
 
void setup(){
 // configuração dos pinos como saída do Arduino
 pinMode(IN1,OUTPUT); // motor A
 pinMode(IN2,OUTPUT); // motor A
 pinMode(IN3,OUTPUT); // motor B
 pinMode(IN4,OUTPUT); // motor B
 pinMode(ENA,OUTPUT); // controle velocidade motor A
 pinMode(ENB,OUTPUT); // controle velocidade motor B

 // inicia com os motores desligados
 digitalWrite(IN1,LOW);
 digitalWrite(IN2,LOW);
 digitalWrite(IN3, LOW);
 digitalWrite(IN4,LOW);

 // incia com velocidade 0
 digitalWrite(ENA, LOW);
 digitalWrite(ENB,LOW); 
}
 
void loop() {
  // configura o mesmo sentido de rotaçao para os dois motores
 digitalWrite(IN1,HIGH);
 digitalWrite(IN2,LOW);
 digitalWrite(IN3, HIGH);
 digitalWrite(IN4,LOW);

 // acelera suavemente
 for (byte i=0; i<255; i++) {
  Serial.println(i);
  analogWrite(ENA, i);
  analogWrite(ENB, i);
  delay(30);
 }

 delay(2000); // aguarda 2 segundos

// desacelera suavemente
for (byte i=255; i>0; i--) {
  Serial.println(i);
  analogWrite(ENA, i);
  analogWrite(ENB, i);
  delay(30);
}

 delay(2000); // aguarda 2 segundos
 
}

10.5. Assista abaixo o vídeo que mostra como deverá funcionar o teste acima.

10.5.1. Observe que no vídeo nós medimos a tensão em um dos motores (motor B). Assim, podemos mostrar que a velocidade de rotação do eixo varia de acordo com a tensão aplicada no motor. No entanto, não podemos esquecer que essa variação de tensão ocorre devido ao sinal modulado (PWM) gerado pelo microcontrolador Arduino, via programação, e enviado para os pinos ENA e ENB do drive.

11. A montagem do nosso projeto foi realizada em um protoboard com linhas de alimentação contínuas. Verifique se o seu protoboard possui linhas de alimentação contínuas ou separadas.

11.1. Veja a imagem abaixo que mostra a montagem completa do circuito.

Código do Projeto (Sketch)

1) Faça o dowload e abra o arquivo projetoI07.ino no IDE do Arduino:  DOWNLOAD - projetoI07.ino

Se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************

     Projeto I07 - Controlando motores DC com drive ponte H L298N
     Autor: Angelo Luis Ferreira
     Data: 01/12/20
             http://squids.com.br/arduino

*******************************************************************************/
//motor A
const byte IN1 = 13 ;
const byte IN2 = 12 ;

//motor B
const byte IN3 = 11;
const byte IN4 = 10;

//pinos utilizados para controlar a velocidade de rotacao
const int ENA = 9; // motor A
const int ENB = 3; // motor B

// controle
#define switchPin 2 // Entrada da botão que inverte a rotação
#define turnPin 8 // Entrada do botão liga e desliga o circuito
#define potPin 0 // Potenciômetro no pino analógico 0

//variáveis
int motorSpeed = 0; // armazenar o valor de velocidade atual
boolean stateSwitch = 0; // armazenar o status do switchPin (0 ou 1)
boolean stateTurn = 0; // armazenar rotação (0 ou1)

// leds
const byte ledGreen = 7;
const byte ledYellow = 6;
const byte ledRed = 5;
 
//Inicializa Pinos
void setup(){
 // define os pinos do drive como saída do Arduino
 pinMode(IN1,OUTPUT); // motor A
 pinMode(IN2,OUTPUT); // motor A
 pinMode(IN3,OUTPUT); // motor B
 pinMode(IN4,OUTPUT); // motor B
 pinMode(ENA,OUTPUT); // controle velocidade motor A
 pinMode(ENB,OUTPUT); // controle velocidade motor B
 // define pinos dos leds como saída
 pinMode(ledGreen, OUTPUT);
 pinMode(ledYellow, OUTPUT); 
 pinMode(ledRed, OUTPUT);
 // defini botões como entrada (pullup interno)
 pinMode(switchPin, INPUT_PULLUP);
 pinMode(turnPin, INPUT_PULLUP);

 // inicia com os motores desligados
 digitalWrite(IN1,LOW);
 digitalWrite(IN2,LOW);
 digitalWrite(IN3, LOW);
 digitalWrite(IN4,LOW);
}
 
void loop() {
  turnOnOff();
  if (stateTurn) {
    // velocidade a partir do potenciômetro (0 a 255)
    motorSpeed = analogRead(potPin)/4;
    // verifica se os botões foram acionados
    turnLed(motorSpeed);
    turnRotation();

    if(stateSwitch) {
      // gira no sentido anti-horário
      digitalWrite(IN1,LOW);
      digitalWrite(IN2,HIGH);
      digitalWrite(IN3, LOW);
      digitalWrite(IN4,HIGH);
    } else {
      // gira no sentido horário
      digitalWrite(IN1,HIGH);
      digitalWrite(IN2,LOW);
      digitalWrite(IN3, HIGH);
      digitalWrite(IN4,LOW);
    }

    // define a velocidade 
    analogWrite(ENA, motorSpeed);
    analogWrite(ENB, motorSpeed);
        
  } else {    
    // deslig os motores 
    digitalWrite(IN1,LOW);
    digitalWrite(IN2,LOW);
    digitalWrite(IN3, LOW);
    digitalWrite(IN4,LOW);    
  } 
  
}

// controle para ligar e desligar motores
void turnOnOff() {
  if (!digitalRead(turnPin)) { // verifica se o botão foi acionado
    stateTurn = !stateTurn;
    while(!digitalRead(turnPin)) {}
    delay(50);
  }
}

// controle sentido de rotação
void turnRotation() {
  if (!digitalRead(switchPin)) { // verifica se o botão foi acionado
    stateSwitch = !stateSwitch;
    while(!digitalRead(switchPin)) {}
    delay(50);
  }
}

// controle para acender leds de acordo com a velocidade
void turnLed(byte j) {
  turnOffLeds();
  if (j<=+85) {    
    digitalWrite(ledGreen, HIGH);
  } else if ((85< j) && (j<= 170)) {
     digitalWrite(ledYellow, HIGH);
  } else if (j>=170) {
    digitalWrite(ledRed, HIGH);
  }
}

// apaga todos leds
void turnOffLeds() {
    digitalWrite(ledGreen, LOW);
    digitalWrite(ledRed, LOW);
    digitalWrite(ledYellow, LOW);
}

Vídeo

Como o projeto deve funcionar

1. Ao clicar no botão (push button) à esquerda, o motor é ligado. Para desligar, basta clicar o botão novamente.

2. Ao girar o eixo do potenciômetro no sentido horário (do polo negativa para o positivo) aumentamos a velocidade do motor até atingir a velocidade máxima.

3. Ao girar o eixo do potenciômetro no senti anti-horário (do polo positivo para o negativo) reduzimos a velocidade do motor até desligar o componente.

4. Os leds verde, amarelo e vermelho acenderão conforme a velocidade do motor. Velocidade baixa acende o led verde, velocidade média, o amarelo e velocidade alta o led vermelho, conforme os seguintes valores: 0 a 85 - velocidade baixa, 86 a 170 - velocidade média, e 170 a 255 velocidade alta.

5. Clicando no botão à direita, alteramos o sentido de rotação do motor.

Desafios

Com base neste projeto, resolva o seguinte desafio:  Desafio 79

Comentários