Início / Projetos Arduino / Projetos Squids / Intermediário / I10 - Controlando motores DC com Driver Ponte H - L9110, sensor de toque capacitivo 4 teclas e Arduino

---

I10 - Controlando motores DC com Driver Ponte H - L9110, sensor de toque capacitivo 4 teclas e Arduino

Angelo Luis Ferreira | 29/12/2020 Acessos: 3.002

Objetivo

Neste tutorial vamos mostrar como controlar a velocidade de 2 motores CC (corrente contínua) através um driver motor ponte H L9110s e o Arduino acionados por um sensor de toque capacitivo 4 teclas TTP224. No projeto os motores terão 4 velocidades: 30%, 50%, 75% e 100% da velocidade máxima. Também usaremos um comando para frear os motores ao tocarmos 2 teclas simultaneamente. Para alterar o sentido de rotação utilizaremos um push button.

Leia também: I05 - Controlando um motor DC com Arduino, transistor e potenciômetro, I06 - Controlando um motor DC com L293D (Ponte H) e Arduino, I07 - Como controlar motores DC com o Driver Ponte H - L298N e Arduino,  I08 - Como controlar motores DC com o Driver Ponte H - L9110 e Arduino e I09 - Motores DC com Driver Ponte H L9110 e Arduino - Controle de 4 velocidades pelo teclado.

Definições

Sensor de toque capacitivo 4 teclas TTP224: Sensor que utiliza a alteração da capacitância do seu próprio circuito para determinar o toque de uma pessoa em uma região sensível da placa. Ao encostar o dedo no sensor de toque capacitivo, a capacitância que existe no mesmo será alterada, possibilitando assim a uma fácil e rápida leitura. O sensor TTP224 conta com 4 teclas capacitivas, o que possibilita um comando exclusivo para cada tecla ou até mesmo uma sequência de comandos. O sensor 4 teclas TTP224 pode ser aplicado como um componente de comando para uma determinada ação, como por exemplo, ligar e desligar lâmpadas, acionar um robô, abrir portas eletrônicas, acionar motores, entre muitas outras.

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	1		– 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
Sensor de Toque 4 Teclas (opcional)	Sensor de Toque Capacitivo 4 Teclas TTP224	1		- Tensão de funcionamento: 2,4 - 5,5V - Possui 4 teclas capacitivas - Dimensões (CxLxA): 29x35x11mm Observação: Item opcional, você pode excluí-lo e usar somente o controle por teclado ou substituílo por 4 push buttons.
Fonte chaveada ou Bateria	fonte chaveada de 9V (plug p4) ou Bateria 9V	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 os botões de controle e o sensor de toque se utilizado. É 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 ou utilizar o Monitor Serial 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. Veja na imagem abaixo a pinagem do sensor capacitvo de 4 teclas (4 saídas, GND e Vcc) :

2.1. Para seguir o nosso exemplo, faça a conexão com com as portas digitais do Arduino, conforme a tabela abaixo:

3. 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 veja Como usar push button com Arduino (programação).

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

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

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

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

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

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

6.1.1. Neste projeto vamos conectar todos pinos de entrada do módulo ponte H L9110 com portas PWM (Pulse Width Modulation) do Arduino.

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 I09 e I10 - 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 = 9 ; // Motor A Input A --> MOTOR A +
const byte A_IB = 6 ; // Motor A Input B --> MOTOR A -

//motor B
const byte B_IA = 11; // 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 ou Modulação por Largura de Pulso) do Arduino. No nosso projeto vamos usar as portas 6,9,10,11.

9.1.2. Neste projeto optamos por utilizar as 4 entradas do driver ponte H (A-IB, A-IA, B-IB e B-IA) como controladores da velocidade. Desta forma, precisaremos 4 saídas PWM do Arduino. Entretanto, caso necessite de portas PWM disponíveis, você poderá utilizar 2 entradas do driver ponte H L9190 para controlar a velocidade, necessitando neste caso de apenas 2 saídas PWM do Arduino, como mostramos no I08 - Como controlar motores DC com o Driver Ponte H - L9110 e 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 as entradas A-IA, A-IB, B-IA e B-IB do módulo L9110, quando os sinais lógicos programados forem HIGH. 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. Em ambos os sentidos, quando zero, o motor estará desligado e quando 255 o motor estará na máxima velocidade, pois o sinal digital na entrada A-IA, AIB, B-IA e B-IB é HIGH. Veja a tabela abaixo:

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 I09 e I10 - Teste variação velocidade - rampa aceleração e desaceleração (dois sentidos)
     Autor: Angelo Luis Ferreira
     Data: 30/12/2020
             http://squids.com.br/arduino

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

//motor B
const byte B_IA = 11; // Motor B Input A --> MOTOR B (+) (PWM)
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() {
//============================= HORÁRIO =======================================  
  // configura o mesmo sentido de rotaçao para os dois motores 
  digitalWrite(A_IB,LOW);
  digitalWrite(B_IB, LOW);

  // acelera suavemente
  for (byte i=0; i<255; i++) {
    analogWrite(A_IA, i); //(sinal PWM) - varia a velocidade
    analogWrite(B_IA, i); // (sinal PWM) - varia a velocidade
    delay(30);
 }
  delay(2000); // aguarda 2 segundos

  // desacelera suavemente
  for (byte i=255; i>0; i--) {
    analogWrite(A_IA, i); //(sinal PWM) - varia a velocidade
    analogWrite(B_IA, i); // (sinal PWM) - varia a velocidade
    delay(30);
}
  delay(2000); // aguarda 2 segundos

//============================ ANTI-HORÁRIO ====================================
  // inverte sentido de rotação (anti-horário)
  digitalWrite(A_IA, LOW);
  digitalWrite(B_IA, LOW);

  // acelera suavemente
  for (byte i=0; i<255; i++) {
    analogWrite(A_IB, i); // varia velocidade (PWM)
    analogWrite(B_IB, i); // varia velocidade (PWM)
    delay(30);
  }
  delay(2000); // aguarda 2 segundos

  // desacelera suavemente
  for (byte i=255; i>0; i--) {
    analogWrite(A_IB, i); // varia velocidade (PWM)
    analogWrite(B_IB, i); // varia velocidade (PWM)
    delay(30);
}
  delay(2000); // aguarda 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 projetoI10.ino no IDE do Arduino: DOWNLOAD - projetoI10.ino

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

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

     Projeto I10 - Controlando motores DC com sensor capacitivo - 4 velocidades
     Autor: Angelo Luis Ferreira
     Data: 26/01/2021
             http://squids.com.br/arduino

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

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

// controle
#define setTurn 2 // Entrada da botão que altera o sentido de rotação

//variáveis
int motorSpeed = 0; // armazenar o valor de velocidade atual
boolean stateBreak = 0; // armazenar breack (0 ou 1) - 0: em movimento / 1: parado
boolean stateTurn = 0; // armazenar rotação (0 ou 1) - 0: horário / 1: anti-horário

// conexão pinos do sensor capacitivo 
const byte tecla1 = 4; 
const byte tecla2 = 5;
const byte tecla3 = 12;
const byte tecla4 = 13;
 
// Inicializa Pinos e Comunicação Serial
void setup(){
 Serial.begin(9600); // inicia a comunicação serial
 // 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 botões como entrada (pullup interno)
 pinMode(setTurn, INPUT_PULLUP);
 // define teclados do sensor capacitivo
 pinMode(tecla1, INPUT);
 pinMode(tecla2, INPUT);
 pinMode(tecla3, INPUT);
 pinMode(tecla4, INPUT);
 // inicia com os motores desligados
 motorBreak();
 // exibe valores e sentido de rotação
 printMonitor();
}

// loop infinito 
void loop() {
 rotation(); //verifica se o pushbutton foi pressionao
 if (!stateBreak) {
  menuSensor(); // inicia teclado sensor capacitivo
 } else {
  motorBreak();
 } 
}

// menu do sensor capacitivo 4 teclas
void menuSensor() {
  // Marcha 1 - velocidade 30% da velocidade máxima
  if (digitalRead(tecla1)) { //
    motorSpeed = (255 * 0.30);
    motorRun(motorSpeed);
    printMonitor(); 
  }
  // Marcha 2 - velocidade 50% da velocidade máxima
  if (digitalRead(tecla2)) { //
    motorSpeed = (255 * 0.50);
    motorRun(motorSpeed);
    printMonitor();
  }
    // Marcha 3 - velocidade 75% da velocidade máxima
  if (digitalRead(tecla3)) { //
    motorSpeed = (255 * 0.75);
    motorRun(motorSpeed); 
    printMonitor();
  }
  // Marcha 4 - velocidade 50% da velocidade máxima
  if (digitalRead(tecla4)) { //
    motorSpeed = 255;
    motorRun(motorSpeed);
    printMonitor();  
  }
  // break rápido
  if (digitalRead(tecla1) && digitalRead(tecla4)) {    
    stateBreak = 1;
    motorSpeed = 0;
    printMonitor();
  }
}

// verifica se o push button foi acionado e altera o estado
void rotation() {
  if (!digitalRead(setTurn)) { // verifica se o botão foi acionado    
    stateTurn = !stateTurn;
    motorBreak();
    motorRun(motorSpeed); // roda motor na velocidade programada
    printMonitor();
    while(!digitalRead(setTurn)) {} // espera soltar o botão
    delay(50);// reduzir bouncing do push button   
  }
}

// função para rodar o motor na velocidade e sentido de rotação definidos
void motorRun(int velocidade) {
  if (!stateTurn) { // sentido horário (frente)
    digitalWrite(A_IB,LOW);
    digitalWrite(B_IB, LOW);
    analogWrite(A_IA, velocidade); // velocidade em função do sinal PWM
    analogWrite(B_IA, velocidade); // velocidade em função do sinal PWM
  } else { // sentido anti-horário (backward)
    digitalWrite(A_IA,LOW);
    digitalWrite(B_IA, LOW);
    analogWrite(A_IB, velocidade); // velocidade em função do sinal PWM
    analogWrite(B_IB, velocidade); // velocidade em função do sinal PWM
  }
}

// freio do motor
void motorBreak() {
   digitalWrite(A_IA,LOW);
   digitalWrite(A_IB,LOW);
   digitalWrite(B_IA, LOW);
   digitalWrite(B_IB,LOW);
   delay(300); 
   stateBreak = 0;
}

// imprime no monitor serial
void printMonitor() {
    Serial.print("Sentido: ");
    if (!stateTurn) {
    Serial.print("Horário - Para frente");
  } else {
    Serial.print("Anti Horário - Para trás");
  }
  Serial.print(" | ");
  Serial.print("Velocidade: ");
  Serial.println(motorSpeed);  
}

Vídeo

Como o projeto deve funcionar

1. Após rodar o programa, toque em qualquer tecla (1,2,3 ou 4) para acionar os motores, conforme as velocidades abaixo:

2. Para frear os motores, toque as teclas 1 e 4 simultaneamente.

3. Para inverter o sentido de rotação dos motores, clique no push button. O programa é iniciado com o sentido de rotação definido como horário.

4. Ao abrir o Monitor Serial, é possível visualizar o sentido de rotação e a velocidade dos motores toda vez que o freio ou o botão (push button) for pressionado:

Comentários