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

---

I08 - Como controlar motores DC com o Driver Ponte H - L9110 e Arduino

Angelo Luis Ferreira | 15/12/2020 Acessos: 12.724

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 - L9110s 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.

eia também: I05 - Controlando um motor DC com Arduino, transistor e potenciômetro, I06 - Controlando um motor DC com L293D (Ponte H) e Arduino e I07 - Como controlar motores DC com o Driver Ponte H - L298N 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 L9110, baseado no chip L9110 (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. Este módulo deve ser utilizado apenas em motores de corrente contínua pequenos (3 a 12V) e com corrente de operação até 800mA. Veja abaixo algumas características do componente:

Observação: O chip L9110 (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) e o L298N(I07 - Como controlar motores DC com o Driver Ponte H - L298N e Arduino). O chip nada mais é do que uma ponte H duplo inserido em um componente integrado, ocupando um menor espaço no circuito.

Vantagens e desvantagens do driver motor ponte H L9110 em relação ao L298N:

Vantagens

– Mais compacto;
– Utiliza menos portas do Arduino para controlar o sentido e velocidade de rotação;
– Menor queda de tensão interna;
– Custo menor;

Desvantagens

– Pode ser utilizado em motores de corrente contínua de até 12V apenas;

Características do driver ponte H L298N

– Tensão de Operação: 2.5V-12V
– Chip: L9110 (datasheet)
– Controle de 2 motores DC ou motor de passo bipolar de 4 fios
– Corrente de Operação: 800mA por canal (máxima de 1,5A)
– Tensão lógica: 5v
– Temperatura de Operação: 0°C ~ 80°C

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 L9110

c1) Output to Motor 1 (A) e Motor 2 (B): Conexões de saída para alimentação dos motores A e B.

c2) Vcc (2.5V to 12V): Porta para alimentação do módulo com tensão entre 2.5 a 12V (Corrente Contínua).

c3) GND: Ligação do GND (ground), ou seja, polo negativo da fonte de alimentação.

c3) A1-A e A1-B: Portas I/O (Input/Output) que servem para receber e passar informação para o motor A. Através dessas portas conectadas ao Arduino podemos controloar a velocidade e o sentido de rotação do motor A.

c4) B1-A e B1-B: Portas I/O (Input/Output) que servem para receber e passar informação para o motor B. Através dessas portas conectadas ao Arduino podemos controloar a velocidade e o sentido de rotação do motor B.

d) 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 L9110	Módulo Driver Motor Ponte H L9110	1		– Tensão de Operação: 2.5V-12V – Chip: L9110 (datasheet) – Controle de 2 motores DC ou motor de passo bipolar de 4 fios – Corrente de Operação: 800mA por canal (máxima de 1,5A) – Tensão lógica: 5v – Temperatura de Operação: 0°C ~ 80°C
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 12V) 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 L9110 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 L9110 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 L9110 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 L9110. Em média, de acordo com as pesquisas que realizamos na internet, a queda de tensão no chip L9110 é de 1,2 a 2,0V (para 1A). Portanto, a tensão aplicada no driver ponte H deverá ser na média 1,5V superior que a tensão nominal de cada motor.

1.2.1. Portanto Vm = Va + 1,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 L9110 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 L9110.

1.2.2.1. Como a queda de tensão pelo chip L9110 é relativamente pequena, podemos até alimentarmos o driver com uma tensão equivalente à tensão de trabalho do motor, porém ele irá funcionar mas sem atingir a potência máxima pelo qual foi construido.

1.2.3. No nosso projeto utilizamos um motor de 5V e portanto podemos alimentar o driver motor ponte H com uma fonte externa de 6,5V a 9V. Escolhemos para o projeto uma fonte de 9V que com certeza será mais do que suficiente para fazer com que o motor atinja a máxima potência.

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 imagem abaixo, ou seja, usar a porta Vcc (2.5V a 12V) e a porta GND do módulo.

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) ou  6V (4 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 L9110.

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.

1.3.5. Se você não quiser utilizar o pino Vin do Arduino, poderá usar uma fonte de alimentação externa de 6 a 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.

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 L9110 deverá ser alimentada por uma fonte externa de 6,5 a 9V (mínimo 6,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).

7. Agora vamos fazer as conexões dos motores. Primeiro conectamos os motores A e B nas saídas de alimentação Motor A e Motor B do driver ponte H L9110. 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 A-IA, A-IB, B-IA e B-IB do driver ponte H L9120, sendo que os pinos A-IA e A-IB controlam o motor A (a esquerda) e os pinos B-IA e B-IB o motor B (a direita).

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. Copie o código abaixo e cole no IDE do Arduino. Faça o upload e rode o programa.

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

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

*******************************************************************************/
//motor A
const byte A_IA = 13 ; // Motor A Input A --> MOTOR A +
const byte A_IB = 11 ; // Motor A Input B --> MOTOR A -

//motor B
const byte B_IA = 12; // Motor B Input A --> MOTOR B +
const byte B_IB = 10; // Motor B Input B --> MOTOR B -
 
//Inicializa Pinos
void setup(){
 pinMode(A_IA,OUTPUT); // motor A
 pinMode(A_IB,OUTPUT); // motor A
 pinMode(B_IA,OUTPUT); // motor B
 pinMode(B_IB,OUTPUT); // motor B
}
 
void loop(){
 
 //*Inicio dos Estados do motor A*/ 
 //Sentido Horário
 digitalWrite(A_IA,HIGH);
 digitalWrite(A_IB,LOW);
 
 /*Inicio dos Estados do motor B*/ 
 //Sentido Horário
 digitalWrite(B_IA, HIGH);
 digitalWrite(B_IB,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.

7.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

9. 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.

9.1. Para criarmos as nossas rampas de aceleração e desaceleração, vamos definir as entradas A-IB (motor A) e B-IB (motor B) que estão conectadas às portas PWM (Pulse Width Modulation) do Arduino como controladoras de velocidade de rotação dos motores.

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 11 e 10.

9.1.2. Neste projeto optamos por utilizar apenas 2 entradas do driver ponte H (A-IB e B-IB) como controladores da velocidade. Desta forma, precisaremos de apenas de 2 saídas PWM do Arduino. Entretanto, você poderá utilizar as 4 entradas do driver ponte H L9190 (A-IA, A-IB, B-IA e B-IB), necessitando neste caso de 4 saídas PWM do Arduino.

9.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 A-IB e para o entrada B-IB do módulo L9110. 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 programada.

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

9.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.

9.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().

9.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%.

9.3.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.

9.3.2.1. Assim, no sentido 1 (horário), quando 255, o motor estará desligado e quando zero o motor estará na máxima velocidade, pois o sinal digital na entrada A-IB e B-IB é LOW.

9.3.2.1. Já no sendito 2 (anti-horário), quando zero, o motor estará desligado e quando 255 o motor estará na máxima velocidade, pois o sinal digirtal na entrada A-IB e B-IB é HIGH.

9.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.

9.4.1. Copie o código abaixo e cole no IDE do Arduino. Faça o upload e rode o programa para fazer o teste.

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

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

*******************************************************************************/
//motor A
const byte A_IA = 13 ; // Motor A Input A --> MOTOR A (+)
const byte A_IB = 11 ; // Motor A Input B --> MOTOR A (-) (PWM)

//motor B
const byte B_IA = 12; // Motor B Input A --> MOTOR B (+)
const byte B_IB = 10; // Motor B Input B --> MOTOR B (-) (PWM)

 
//Inicializa Pinos
void setup(){
 // configuração dos pinos como saída do Arduino
 pinMode(A_IA,OUTPUT); // motor A
 pinMode(A_IB,OUTPUT); // motor A
 pinMode(B_IA,OUTPUT); // motor B
 pinMode(B_IB,OUTPUT); // motor B


 // inicia com os motores desligados
 digitalWrite(A_IA,LOW);
 digitalWrite(A_IB,LOW);
 digitalWrite(B_IA, LOW);
 digitalWrite(B_IB,LOW);
}
 
void loop() {
  // configura o mesmo sentido de rotaçao para os dois motores
 digitalWrite(A_IA,HIGH);
 digitalWrite(B_IA, HIGH);

 // acelera suavemente
 for (byte i=0; i<255; i++) {
  Serial.println(i);
  analogWrite(A_IB, 255-i); //(PWM) - varia a velocidade
  analogWrite(B_IB, 255-i); // (PWM) - varia a velocidade
  delay(30);
 }

 delay(2000); // aguarde 2 segundos

// desacelera suavemente
for (byte i=255; i>0; i--) {
  Serial.println(i);
  analogWrite(A_IB, 255-i); //(PWM) - varia a velocidade
  analogWrite(B_IB, 255-i); // (PWM) - varia a velocidade
  delay(30);
}

 delay(2000); // aguarde 2 segundos
 
}

10. 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.

10.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 projetoI08.ino no IDE do Arduino:  DOWNLOAD - projetoI08.ino

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

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

     Projeto I08 - Controlando motores DC com drive ponte H L9190
     Autor: Angelo Luis Ferreira
     Data: 16/12/2020
             http://squids.com.br/arduino

*******************************************************************************/
//motor A
const byte A_IA = 13 ; // Motor A Input A --> MOTOR A (+)
const byte A_IB = 11 ; // Motor A Input B --> MOTOR A (-) (PWM)

//motor B
const byte B_IA = 12; // Motor B Input A --> MOTOR B (+)
const byte B_IB = 10; // Motor B Input B --> MOTOR B (-) (PWM)

// 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 pinos como saída do Arduino
 pinMode(A_IA,OUTPUT); // motor A
 pinMode(A_IB,OUTPUT); // motor A
 pinMode(B_IA,OUTPUT); // motor B
 pinMode(B_IB,OUTPUT); // motor B
 // define pinos dos leds como saída
 pinMode(ledGreen, OUTPUT);
 pinMode(ledYellow, OUTPUT); 
 pinMode(ledRed, OUTPUT);
 // define botões como entrada (pullup interno)
 pinMode(switchPin, INPUT_PULLUP);
 pinMode(turnPin, INPUT_PULLUP);

 // inicia com os motores desligados
 motorBreak();
}
 
void loop() {
  turnOnOff(); // verifica o botão liga/desliga
  if (stateTurn) { // ligado
    // 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 (para trás)
      digitalWrite(A_IA,LOW);
      digitalWrite(B_IA, LOW);
      // define a velocidade de 0 a 255 (máxima velocidade = 255)
      analogWrite(A_IB, motorSpeed);
      analogWrite(B_IB, motorSpeed);
    } else {
      // gira no sentido horário (para frente)
      digitalWrite(A_IA,HIGH);
      digitalWrite(B_IA, HIGH);
      // define a velocidade de 255 a 0 (máxima velocidade = 0)
      analogWrite(A_IB, 255-motorSpeed);
      analogWrite(B_IB, 255-motorSpeed);      
    } 
  } else { // desligado
    //apaga os leds
    turnOffLeds();   
    // freia os motores    
    motorBreak();
 }   
}

// 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
    motorBreak(); // sempre parar o motor antes de mudanças bruscas
    stateSwitch = !stateSwitch;
    while(!digitalRead(switchPin)) {}
    delay(50);
  }
}

// freio do motor
void motorBreak() {
   digitalWrite(A_IA,LOW);
   digitalWrite(A_IB,LOW);
   digitalWrite(B_IA, LOW);
   digitalWrite(B_IB,LOW); 
}

// 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 80

Comentários