Olá Garagistas! Neste tutorial mostraremos como montar um seguidor de linha utilizando o Dual Motor Garagino! Como demonstração, além de seguir a linha preta (pista), ele irá identificar o obstáculo e com a utilização de um pedaço de madeira acoplado a um servo o removerá do caminho para continuar seguindo seu trajeto.

Material Utilizado:

1x Dual Motor Garagino

1x Kit Garagino Rev 1 Básico

1x Zumo Chassis Kit

2x Micro motor com caixa de redução de metal 75:1 ou 2x Micro motor com caixa de redução de metal 100:1

2x Sensor de Refletância QTR-1RC (Digital) ou 1x Breakout de Sensor de Linha QRE1113 - Digital

1x Sensor de distância por ultrassom - Maxbotix LV-EZ1 ou 1x Sensor de distância por ultrassom - LV-EZ3

1x Servo - Motor Pequeno

2x Fita Hellermann (Enforca Gato)

1x Fita Dupla Face Esponjosa

Alguns Jumpers F/F

Alguns Pedaços de Madeira

1. Dual Motor Garagino

Imagem 1 - Dual Motor Garagino

O Dual Motor Garagino é um Shield para Garagino muito prático, com ele você pode utilizar a mesma biblioteca desenvolvida pelo Laboratório de Garagem para o Dual Motor Shield (DualMotor.h). É uma excelente solução para quem quer controlar plataformas robóticas como o  Zumo, o Magician, Esteira Tamiya e o  Multi Chassis utilizando o Garagino, além disso, o Dual Motor Garagino possui 6 headers destinados à conexão de até 6 sensores (A0 a A6) e 2 headers destinado a servo motores (D4 e D9) e também é compatível com o Mini Ethernet Shield, e com os Mini RF Shields, permitindo que você faça acionamentos via comunicação Ethernet e também por comunicação RF.

OBS: Os 8 headers disponíveis podem ser utilizados para qualquer outra finalidade, eles são extensões dos pinos do Garagino para facilitar a conexão de sensores ou servomotores

Características:

- Jumper de alimentação para o Garagino: 5V
- Tensão máxima (Motor): 30V
- Corrente máxima (Motor): 600mA
- Shields Compatíveis: Mini Ethernet Shield e Mini RF Shields (Transmitter e Receiver)

Biblioteca:

A download da biblioteca DualMotor.h pode ser efetuado clicando aqui.

2. Funcionamento

Detalhes sobre o funcionamento e teoria sobre um seguidor de linha podem ser encontrados nos tutoriais abaixo:

Tutorial: Seguidor de linha com plataforma Zumo e Garagino

Tutorial: Carrinho seguidor de linha que desvia de obstáculos com plataforma Zumo e Arduino

Como pode ser visto nesses tutoriais, é necessário uma montagem um mais elaborada por conta da indisponibilidade de conexões para os sensores e/ou motores, com o Dual Motor Garagino essas conexões são bem mais fáceis, pois seus headers permitem a conexão de vários sensores e servomotores:

Imagem 2 - Headers do Dual Motor Garagino

3. Montagem

1) Faça a montagem dos pedaços de madeira ao servo utilizando fita dupla face e fita hellermann, conforme a imagem abaixo:

Imagem 3 - Alavanca com servomotor

2) Prenda ou Cole o pedaço que foi montado abaixo da Dual Motor Garagino, do outro lado prenda também outro pedaço para não dar diferença de altura entre os lados:

Imagem 4 - Colando alavanca ao Dual Motor Garagino

3) Cole também do outro lado dos pedaços de madeira, mais fita dupla face para que seja possível colar o Dual Motor Garagino a plataforma, conforme as imagens abaixo:

Imagens 5 e 6 - Colando a alavanca com o Dual Motor Garagino no Zumo Chassis

4) Posicione os sensores de refletância, certifique-se que a distância entre eles seja pouco maior que a linha a qual o carrinho irá seguir, no nosso caso uma fita isolante, e também posicione o sensor de ultrassom a frente da plataforma, conforme a imagem abaixo:

Imagem 7 - Posicionamento dos sensores

5) Faça as ligações dos sensores, motores e do servomotor conforme a figura abaixo:

Imagem 8 - Conexões a serem feitas no Dual Motor Garagino

6) Faça as ligações dos motores e do case de bateria do Zumo ao Dual Motor Garagino

Imagem 9 - Conexão dos motores do case de pilhas do Zumo Chassis

7) Por fim, a imagem abaixo mostra a montagem completa que foi utilizada neste tutorial:

Imagem 10 - Montagem completa

4. Sketch

#define sensorE A0 //Define sensorE como A0
#define sensorD A1 //Define sensorD como A1

#include span style="color: #cc6600;">DualMotor.h> //Inclui a biblioteca DualMotor.h
#include span style="color: #cc6600;">Servo.h> //Inclui a biblioteca Servo.h
#include "Maxbotix.h" //Inclui a biblioteca Maxbotix.h

DualMotor dualmotor; //Instância a biblioteca DualMotor
Servo servod9; //Instância a biblioteca Servo
Maxbotix rangeSensorPW(4, Maxbotix::PW, Maxbotix::LV); //Instância o pino PW do sensor LV para ser utilizado com o pino 8 do Arduino

int confirm_dist; //Variável para confirmar a distância até o obstáculo

void setup()
{
  servod9.attach(9); //Configura o servo para ser utilizado com o pino D9
  servod9.write(179); //Posiciona o servo em 179º
  delay(5000); //Aguarda 5 segundos
}


void loop()
{
  int val_sensores = lesensores(); //Executa a função para a leitura dos sensores
  switch(val_sensores)
  {
  case 0: //Caso os 2 sensores estejam refletindo movimenta a plataforma para frente
    dualmotor.M1move(200,0);
    dualmotor.M2move(200,0);
    verifica_dist();
    break;
  case 1: //Caso somente o sensor da direita esteja refletindo movimenta a plataforma para esquerda
    dualmotor.M1move(200,1);
    dualmotor.M2move(200,0);
    break;
  case 2: //Caso somente o sensor da esquerda esteja refletindo movimenta a plataforma para direita
    dualmotor.M1move(200,0);
    dualmotor.M2move(200,1);
    break;
  case 3: //Caso os 2 sensores NÃO estejam refletindo movimenta a plataforma para trás
    dualmotor.M1move(200,1);
    dualmotor.M2move(200,1);
    delay(100);
    break;
  }
}




void verifica_dist()
{
  if(rangeSensorPW.getRange() < 16) confirm_dist++; //Verifica a distância até o obstáculo
  //Se a distância for menor que 16cm
  //Incrementa a variável confirm_dist
  else confirm_dist = 0; //Senão zera a variável de confirmação

  if(confirm_dist >=5) //Se houve mais que 5 confirmações da distância, executa rotina para movimentar o servo
  {
    //Para a plataforma por 1 segundo
    dualmotor.M1move(0,0);
    dualmotor.M2move(0,0);
    delay(1000);
    //Move a plataforma para frente por 200 milissegundo e movimenta o servo
    dualmotor.M1move(255,0);
    dualmotor.M2move(255,0);
    delay(200);
    for (int i=179; i>=0; i--) servod9.write(i);
    //Para a plataforma por 500 milissegundos
    dualmotor.M1move(0,1);
    dualmotor.M2move(0,1);
    delay(500);
    //Move a plataforma para trás por 500 milissegundo e movimenta a alavanca do servo
    dualmotor.M1move(200,1);
    dualmotor.M2move(200,1);
    delay(500);
    //Para a plataforma por 500 milissegundos
    dualmotor.M1move(0,1);
    dualmotor.M2move(0,1);
    delay(500);
    //Retorna a alavanca do servo
    for (int i=0; i<=179; i++) servod9.write(i);
    confirm_dist =0;
  }
}



int lesensores()
{
  int sensores = 0; //Zera a variável sensores

  //######################
  //Ler Sensor da Direita
  //######################
  pinMode( sensorD, OUTPUT );
  digitalWrite( sensorD, HIGH );
  delayMicroseconds(10);
  pinMode( sensorD, INPUT );
  long time = micros();

  while (digitalRead(sensorD) == HIGH && micros() - time < 3000);
  int diff = micros() - time;
  if (diff > 1600) sensores += 1;
  //######################
  //======================
  //######################


  //######################
  //Ler Sensor da Esquerda
  //######################
  pinMode( sensorE, OUTPUT );
  digitalWrite( sensorE, HIGH );
  delayMicroseconds(10);
  pinMode( sensorE, INPUT );
  long time1 = micros();

  while (digitalRead(sensorE) == HIGH && micros() - time1 < 3000);
  int diff1 = micros() - time1;

  if (diff1 > 1600) sensores += 2;
  //######################
  //======================
  //######################

  return sensores; //Retorna os valores lidos pelos sensores
}

Então é isso Garagistas! Esperamos que tenham gostado desse tutorial! Abraços Garagísticos =D

Referências:

http://labdegaragem.com/profiles/blogs/tutorial-carrinho-seguidor-de-linha-que-desvia-de-obstaculos-com-

http://labdegaragem.com/profiles/blogs/tutorial-seguidor-de-linha-com-plataforma-zumo