Início / Projetos Arduino / Projetos Squids / Intermediário / I09 - Motores DC com Driver Ponte H L9110 e Arduino - Controle de velocidade pelo teclado

---

I09 - Motores DC com Driver Ponte H L9110 e Arduino - Controle de velocidade pelo teclado

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

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 comunicação serial (teclado do computador). No projeto os motores terão 4 velocidades: 25%, 50%, 75% e 100% da velocidade máxima. Também usaremos opções através de um menu no Monitor Serial para frear e mudar o sentido de rotação dos motores.

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 e I08 - Como controlar motores DC com o Driver Ponte H - L9110 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.

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
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, o nosso módulo ponte H será alimentado por uma fonte externa com 9V que por consequência alimentará os dois motores de corrente contínua (5V/130mA).

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 por fonte externa (driver ponte H)

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

3. 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 deseje utilizar apenas um motor, escolha o lado para a conexão e siga os procedimentos abaixo.

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

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

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

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

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

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

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

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

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

     Projeto I09 - 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); 
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

     Projeto I09 - Controlando motores DC com drive ponte H L9190 - 4 velocidades
     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)

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

//Inicializa Pinos e Comunicação Serial (setup)
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
 // inicia com os motores desligados
 motorBreak();
}

// loop infinito 
void loop() {  
  menu(); // inicia menu no monitor serial  
}

// inicia menu no monitor serial
void menu() {
  boolean isValidOption;
  // desenho do menu
  Serial.println( "-----------------------------" );
  Serial.println( "MENU:" );
  Serial.println( "1) Velocidade 1 (25%)" );
  Serial.println( "2) Velocidade 2 (50%)" );
  Serial.println( "3) Velocidade 3 (75%)" );
  Serial.println( "4) Velocidade 4 (100%)" );
  Serial.println( "5) Freiar" );
  Serial.println( "6) Para frente (horário)" );
  Serial.println( "7) Para trás (anti-horário)" );
  Serial.println( "-----------------------------" );
  // ações do menu
  do {
    byte caractere;
    // aguarde o próximo caractere
    Serial.println("...");
    Serial.print("Digite a opção: ");    
    while ( !Serial.available() ) {}
    caractere = Serial.parseInt();
    if (caractere > 0 && caractere <8) {
      Serial.println(caractere);    
    } else {
      Serial.println("Opção Inválida");
    }
    //caractere = Serial.read();    
    // executa as opções do menu
    switch (caractere) {
    case 1: // velocidade 25%
      Serial.println("Velocidade 1 (25%)");
      motorSpeed = (255 * 0.25);
      motorRun(motorSpeed);
      isValidOption = true; 
      break;
    case 2: // velocidade 50%
      Serial.println("Velocidade 2 (50%)");
      motorSpeed = (255 * 0.5);
      motorRun(motorSpeed);
      isValidOption = true; 
      break; 
    case 3: // velocidade 75%
      Serial.println("Velocidade 3 (75%)");
      motorSpeed = (255 * 0.75);
      motorRun(motorSpeed);
      isValidOption = true; 
      break;
    case 4: // velocidade 100%
      Serial.println("Velocidade 4 (100%)");
      motorSpeed = 255;
      motorRun(motorSpeed);
      isValidOption = true; 
      break;     
    case 5: // frear bruscamente o motor
      Serial.println("Freiar motor");
      motorBreak();
      isValidOption = true; 
      break;
   case 6: //sentido horário (para frente)
      Serial.println("Rodar para frente");
      if (stateTurn) {
        stateTurn = 0; // muda para sentido horário (false)
        motorBreak(); // para o motor 
      }
      motorRun(motorSpeed); // roda o motor (frente) com a última velocidade
      break;  
   case 7: //sentido horário (para frente)
      Serial.println("Rodar para trás");
      if (!stateTurn) {
        stateTurn = 1; // muda para sentido horário (true)
        motorBreak(); // para o motor
      }
      motorRun(motorSpeed); // roda o motor (frente) com a última velocidade
      break;     
    default:
      isValidOption = false; // caractere inválido   
      break;   
    }

  } while( isValidOption == true );
}

// 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 {
    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); 
}

Vídeo

Como o projeto deve funcionar

1. Ao abrir o Monitor Serial o "Menu" é apresentado:

2. Digite um número de 1 a 7 referente à opção desejada:

2.1. Opções 1, 2, 3 e 4 são referentes ás 4 velocidades que os motores deverão realizar.

2.2. Opção 5 irá frear os motores imediatamente caso estejam em rotação.

2.3. Opção 6 irá definir o sentido horário de rotação dos motores. O programa por padrão já nicia nesta configuração.

2.4. Opção 7 irá definir o sentido anti-horário de rotação dos motores.

3. Se por acaso o usuário digitar um valor diferente de 1 a 7, o loop irá reiniciar com o menu aparecendo novamente.

Desafios

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

Comentários