Controlando Motores com o Shield Motor Driver 2x2A

This tutorial is not available in English

Introdução

Assim como o driver L298N, do tutorial Controlando Motores com o Módulo L298N, o shield Motor Driver 2x2A também possui um chip L298, porém no modelo SMD. Entretanto, diferentemente do módulo L298N, o Motor Driver 2x2A utiliza apenas 4 portas digitais da placa Arduino para controlar tanto o sentido de rotação do motor, quanto a velocidade do mesmo. Além de possuir bornes destacáveis, o shield é acoplado diretamente à placa, o que facilita a prototipagem.

Neste tutorial você vai aprender como realizar uma rampa de aceleração e desaceleração de dois motores nos dois sentidos.

Lista de Materiais

Lista completa de produtos

comprar

BlackBoard UNO R3

R$ 94,90 no PIX

Cabo USB AB 1.50m

R$ 10,35 no PIX

Shield para Arduino - Motor Driver 2x2A

R$ 94,05 no PIX

Motor 12V 11400RPM 24mm

R$ 18,05 no PIX

Fonte Chaveada 12V 1A

R$ 14,15 no PIX

Jumpers Macho-Macho x40 Unidades

R$ 7,50 no PIX

Circuito

Para realizar o experimento deste tutorial, acople o shield à sua BlackBoard e conecte os motores, como na imagem abaixo.

Vale lembrar que o shield pode ser alimentado juntamente com a BlackBoard UNO, ou separadamente. Esse controle é feito através do jumper de alimentação, próximo ao borne de alimentação do shield. Quando o jumper está conectado ao shield, a alimentação do shield e da BlackBoard são interligadas. Ao remover o jumper do circuito, a alimentação do shield é separada da alimentação da BlackBoard.

Código

Para realizar o experimento da rampa de aceleração e desaceleração dos motores, carregue o código a seguir para a BlackBoard UNO.

/*******************************************************************************
* Shield Motor Driver 2x2A - Primeiros Passos (v1.0)
* 
* Rampa de aceleracao e desaceleracao de dois motores utilizando o Shield Motor
* Driver 2x2A. Os motores irao acelerar de 0 rpm ate a sua rotacao maxima e 
* entao reduzir a velocidade ate parar, com o mesmo intervalo de tempo. Entao 
* os motores irao rotacionar no sentido contrario com a mesma aceleracao e 
* desaceleracao.
* 
* Copyright 2019 RoboCore.
* Escrito por Giovanni de Castro (26/05/2019).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//declaracao dos pinos utilizados para controlar a velocidade de rotacao
const int PINO_ENA = 5; 
const int PINO_ENB = 6;

//declaracao dos pinos utilizados para controlar o sentido do motor
const int PINO_IN1 = 7; 
const int PINO_IN2 = 8;


int i = 0; //declaracao da variavel para as rampas

const int TEMPO_ESPERA = 1000; //declaracao do intervalo de 1 segundo entre os sentidos de rotacao do motor

const int TEMPO_RAMPA = 30; //declaracao do intervalo de 30 ms para as rampas de aceleracao e desaceleracao

void setup() {

  //configuracao dos pinos como saida
  pinMode(PINO_ENA, OUTPUT); 
  pinMode(PINO_ENB, OUTPUT);
  pinMode(PINO_IN1, OUTPUT);
  pinMode(PINO_IN2, OUTPUT);

  //inicia o codigo com os motores parados
  digitalWrite(PINO_IN1, LOW); 
  digitalWrite(PINO_IN2, LOW);
  digitalWrite(PINO_ENA, LOW);
  digitalWrite(PINO_ENB, LOW);

}

void loop() {

  //configura os motores para o sentido horario
  digitalWrite(PINO_IN1, HIGH); 
  digitalWrite(PINO_IN2, HIGH);

  //rampa de aceleracao
  for (i = 0; i < 256; i=i+10){ 
    analogWrite(PINO_ENA, i);
    analogWrite(PINO_ENB, i);
    delay(TEMPO_RAMPA); //intervalo para incrementar a variavel i
  }

  //rampa de desaceleracao
  for (i = 255; i >= 0; i=i-10){ 
    analogWrite(PINO_ENA, i);
    analogWrite(PINO_ENB, i);
    delay(TEMPO_RAMPA); //intervalo para incrementar a variavel i
  }

  delay(TEMPO_ESPERA); //intervalo de um segundo

  //configura os motores para o sentido anti-horario
  digitalWrite(PINO_IN1, LOW); 
  digitalWrite(PINO_IN2, LOW);

  //rampa de aceleracao
  for (i = 0; i < 256; i=i+10){ 
    analogWrite(PINO_ENA, i);
    analogWrite(PINO_ENB, i);
    delay(TEMPO_RAMPA); //intervalo para incrementar a variavel i
  }

  //rampa de desaceleracao
  for (i = 255; i >= 0; i=i-10){ 
    analogWrite(PINO_ENA, i); 
    analogWrite(PINO_ENB, i);
    delay(TEMPO_RAMPA); //intervalo para incrementar a variavel i
  }

  delay(TEMPO_ESPERA); //intervalo de um segundo
  
}

Após carregar o código para a placa, conecte a placa (ou o shield) à fonte de 12 V para alimentar o conjunto.

O Que Deve Acontecer

Ao alimentar o conjunto através da fonte, é possível observar os motores realizando rampas de aceleração e desaceleração rápidas para os dois sentidos, como no GIF abaixo.

Resultado Final

Indo Além

Agora, se o seu projeto já foi facilitado pela utilização do shield, imagine utilizar a BlackBoard UNO R3, juntamente com o Motor Driver 2x2A, em apenas uma placa. A Julieta é uma BlackBoard UNO com o mesmo chip utilizado para controle dos motores do Motor Driver 2x2A, tudo isso em um único circuito. Além disso, como ela consegue fornecer até 3 A em 5 V, a Julieta é uma ótima placa para embarcar no seu robô.