SEGUIDOR DE LINHA

https://www.youtube.com/watch?v=GAOU1sZnY7U

Olá a todos, sou novo aqui no lab de garagem, mas nem por isso deixo a imensa gratidão e admiração por tudo que fizeram por mim. Gostaria de escrever esse artigo como uma forma de poder demostrar minha dificuldade e retribuir minha gratidão.

A partir daqui postarei todo o conteúdo do meu robô seguidor de linha, também controlado por bluetooth.

[ATENÇÃO] SOU NOVO NA ELETRONICA, (AGRADEÇO SE PODEREM ME  CORRIGIR  NOS cOMENTÁRIOS).

MATERIAIS:

1x Arduino mega;

2x servos motores de rotação continua 360° (SM-S4306R);

8x sensores óptico reflexivos, recomendo TCRT5000 pelo seu alcance maior, mas podendo usar (QRE1113) ou equivalente;

1x modulo bluetooth (HC-05, HC-06) ou equivalente;

1x placa fenolite 10x9 ;

1x placa fenolite 3x9 ;

Percoreto de ferro para a corrosão

2x borne de 2 vias (para a alimentação);

4x capacitores (usei de 16v por 470uf);

3x diodos 1N4007;

3x botões liga desliga;

8x resistores de 330 ohm's;

8x resistores de 10 k ;

2x rodas;

1x roda boba;

Barra de pinos 180°;

2x baterias recarregáveis de celular.

1x sensor ultra-sônicos (na placa, a capacidade é de 3 sensores);

além de materiais como o ferro de solda, estanho, sugador de solda e outros.

                     CONSTRUÇÃO:

Placa dos sensores:

Placa do robô:

Primeiramente começaremos com as placas:

baixar:

placa_pci_robô.pdf

ldr_todos.pdf

Essas placas são já para a transferência para a placa, o método utilizado é a de transferência térmica, o papel é o de foto A4, e  A impressora tem que ser obrigatoriamente de tonner. (Não entrarei nos detalhes de como é feito a transferência, qualquer duvida pergunte nos comentários).

E imprimir a dos sensores e fazer o mesmo processo.

(Quanto mais a impressão escura melhor).

Furar as placas, e instalar os componentes:

Para testar use esse código :

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

const int sensora1 = A0;
const int sensora2 = A1;
const int sensora3 = A2;
const int sensora4 = A3;
const int sensora5 = A4;
const int sensora6 = A5;
const int sensora7 = A6;
const int sensora8 = A7;
int valora1, valora2, valora3, valora4, valora5, valora6, valora7, valora8 = 0;
void setup() {
Serial.begin(9600);
}

void loop() {

valora1 = analogRead(sensora1);
valora2 = analogRead(sensora2);
valora3 = analogRead(sensora3);
valora4 = analogRead(sensora4);
valora5 = analogRead(sensora5);
valora6 = analogRead(sensora6);
valora7 = analogRead(sensora7);
valora8 = analogRead(sensora8);
Serial.print(valora1);
Serial.print(" ");
Serial.print(valora2);
Serial.print(" ");
Serial.print(valora3);
Serial.print(" ");
Serial.print(valora4);
Serial.print(" ");
Serial.print(valora5);
Serial.print(" ");
Serial.print(valora6);
Serial.print(" ");
Serial.print(valora7);
Serial.print(" ");
Serial.print(valora8);
Serial.println(" ");
delay(100);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Na placa foram feitas algumas adaptações : na imagem do modulo foi introduzido esse switch para ligar e desligar o modulo pelo fato do programa não fazer o uploud com ele ligado.

R1- resistor ligando na saída analógica para o arduino saber quando o bluethooth esta ligado

FIO no GND ligando nas saídas .

E resistores na ligação do modulo na placa:

Ligue o modulo e instale algum aplicativo de terminal no celular, e teste para ver se esta tudo ok.

teste a ligação dos motores:

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <Servo.h>
Servo motore;
Servo motord;
void parar()
{
  motore.write(92);
  motord.write(90);
}
void frente()
{
  motore.write(0);
  motord.write(180);
}
void direita_canto()
{
  motore.write(105);
  motord.write(180);
}
void esquerda_canto()
{
  motore.write(0);
  motord.write(82);
}
void esquerdap()
{
  motore.write(82);
  motord.write(82);
}
void direitap()
{
  motore.write(105);
  motord.write(105);
}
void tras()
{
  motore.write(105);
  motord.write(82);
}
void setup()
{
  motore.attach(53); //declarando qual porta o motor estará ligado
  motord.attach(51);
}
void loop ()
{
    frente(); //aqui vc muda para qual função que chamar, assim verifica se esta tudo ok.
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Motores ok, agora instale as rodas e as baterias, use cola quente.(Nessa parte fica ao seu critério como montar porque depende do seus materiais ).

Veja que coloquei leds RGB, isso fica ao seu critério.

Depois de todos os testes o código final :

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
seguidor de linha, neste mesmo programa o controle pelo modulo blueethoot.
Criado por CARLOS HENRIQUE ANTONIO DA SERRA
CARLOSFILHOH@GOTMAIL.COM
10/04/2016
*/
#include "Ultrasonic.h"
Ultrasonic ultrasonic(31, 29);
#include <Servo.h>
Servo motore;
Servo motord;
const int sensord4 = A0;
const int sensord3 = A1;
const int sensord2 = A2;
const int sensord1 = A3;
const int sensore1 = A4;
const int sensore2 = A5;
const int sensore3 = A6;
const int sensore4 = A7;
const int blu      = A8;
int valord4, valord3, valord2, valord1, valore1, valore2, valore3, valore4 = 0;
int valorcorte = 400;
int estado = 0;
void parar()
{
  motore.write(92);
  motord.write(90);
}
void frente()
{
  motore.write(0);
  motord.write(180);
}
void direita_canto()
{
  motore.write(105);
  motord.write(180);
}
void esquerda_canto()
{
  motore.write(0);
  motord.write(82);
}
void esquerdap()
{
  motore.write(82);
  motord.write(82);
}
void direitap()
{
  motore.write(105);
  motord.write(105);
}
void tras()
{
  motore.write(105);
  motord.write(82);
}
void setup()
{
  motore.attach(53); //declarando qual porta o motor estará ligado
  motord.attach(51);
  Serial.begin(9600);
  estado = 1;
}
void loop ()
{

  while (analogRead(A8) > 600 ) { // se o modulo bluethoot estiver ligado

      int distancia = (ultrasonic.Ranging(CM));  // ficará lendo o sensor ultra-sonico
    if (Serial.available()) //se byte pronto para leitura
    {
      switch (Serial.read())     //verifica qual caracter recebido
      {
        case 'F':                  //caso 'A'
          frente();
          break;

        case 'B':                  //caso 'A'
            tras();
            break;
     
        case 'L':                  //caso 'A'
          direitap();
          break;
      
        case 'H' :                  //caso 'A'
          direitap();
          break;

        case 'G' :                  //caso 'A'
          direitap();
          break;

        case 'R' :               //caso 'A'
          esquerdap();
          break;

        case 'I' :                  //caso 'A'
          esquerdap();
          break;

        case  'J' :                  //caso 'A'
          esquerdap();
          break;

        case 'S' :
          parar();
          break;
      }

      if (distancia < 8 )
      {
        tras();
      }

    }

  }
 
  while (analogRead(A8) < 600 ) // enquanto o bluethoot estiver desligado seguir a linha
  {
    valord4 = analogRead(sensord4); //
    valord3 = analogRead(sensord3); //
    valord2 = analogRead(sensord2); //
    valord1 = analogRead(sensord1); //
    valore1 = analogRead(sensore1); //
    valore2 = analogRead(sensore2); //
    valore3 = analogRead(sensore3); //
    valore4 = analogRead(sensore4); //
    //  // nessas condiçoes é testado quando todos os sensores estao no branco, com estados diferentes.
    //  // 1 é quando sai da linha e os ultimos sensores lidos foram os da direita ( d4, d3, d2, d1 ).
    if ((valore4 < valorcorte) && (valore3 < valorcorte) && (valore2 < valorcorte) && (valore1 < valorcorte) &&
        (valord1 < valorcorte) && (valord2 < valorcorte) && (valord3 < valorcorte) && (valord4 < valorcorte) && (estado == 2))
    {
      direita_canto();
      estado = 2;
    }
    //  // 2 é quando sai da linha e os ultimos sensores lidos foram os da esquerda ( e4, e3, e2, e1 ).
    if ((valore4 < valorcorte) && (valore3 < valorcorte) && (valore2 < valorcorte) && (valore1 < valorcorte) &&
        (valord1 < valorcorte) && (valord2 < valorcorte) && (valord3 < valorcorte) && (valord4 < valorcorte) && (estado == 3))
    {
      esquerda_canto();
      estado = 3;
    }
    //  //  // 2 é quando sai da linha e os ultimos sensores lidos foram os do meio ( e2, e1, d1, d2 ).
    if ((valore4 < valorcorte) && (valore3 < valorcorte) && (valore2 < valorcorte) && (valore1 < valorcorte) &&
        (valord1 < valorcorte) && (valord2 < valorcorte) && (valord3 < valorcorte) && (valord4 < valorcorte) && (estado == 1))
    {
      frente();
      estado = 1;
    }

    //apartir daqui começa a testar as condiçoes de seguir a linha onde o objetivo é fazer q os sensores do meio vao para frente enquando os laterais giram para centralizar os sensores

    if ((valore1 > valorcorte) && (valord1 > valorcorte)) {                                                                                                //1                                                                                                 //4
      frente();
      estado = 1;
    }
    if ((valord1 > valorcorte) && (valord2 > valorcorte)) {                                                                                                //2
      esquerdap();
      estado = 1;
    }
    if ((valore2 > valorcorte) && (valore1 > valorcorte)) {                                                                                               //3
      direitap();
      estado = 1;
    }
    if ((valord2 > valorcorte) && (valord3 > valorcorte)) {                                                                                               //4
      esquerdap();
    }
    if ((valore3 > valorcorte) && (valore2 > valorcorte)) {                                                                                              //5
      direitap();
    }
    if ((valore3 > valorcorte) && (valore2 > valorcorte) && (valore1 > valorcorte)) {                                                                     //6
      direitap();
    }
    if ((valord3 > valorcorte) && (valord2 > valorcorte) && (valord1 > valorcorte)) {                                                                     //7
      esquerdap();
    }
    if ((valore2 > valorcorte) || (valore1 > valorcorte) || (valord1 > valorcorte) || (valord2 > valorcorte)) {                                           //8
      estado = 1;
    }
    if (((valord2 > valorcorte) || (valord1 > valorcorte) || (valore1 > valorcorte) || (valore2 > valorcorte) || (valore3 > valorcorte)) && (valore4 > valorcorte)) {                                       //14
      estado = 2;
    }
    if (((valore2 > valorcorte) || (valore1 > valorcorte) || (valord1 > valorcorte) || (valord2 > valorcorte) || (valord3 > valorcorte)) && (valord4 > valorcorte)) {                                       //15
      estado = 3;
    }
  }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

O controle pelo modulo bluethooth é feito pelo aplicativo Arduino Bluetooth RC Car, ele tem os botões e o giroscópio e é bem fácil de controlar.

E é isso qualquer duvida é só perguntar, terei o prazer em responder.

Espero que tenha te ajudado. :)