Akira seguidor de linha 2016 calibração branco e preto

//Versão corrigida para uso dos botões e com as informações de motor
//controles de calibração
int branco_d = 0;
int branco_e = 0;
int preto_d = 0;
int preto_e = 0;
int ldr_d;
int ldr_e;
int x = 0;
int botao;
int calibracao_d;
int calibracao_e;

int margem = 0; //controle proporcional do robô para ajuste de sensibilidade

// Controle d configuração dos motores
int frente_d = 30;
int frente_e = 150;
int re_d = 150;
int re_e = 30;
int pare = 90;

//controle de velocidade do robô
int t=15;

#include <Servo.h>
Servo motor_d;
Servo motor_e;
//pinos e variaveis
int emisor=11;
int receptor=12;
long cml,duracao;

void setup (){
Serial.begin(9600);
motor_d.attach(4);
motor_e.attach(5);
pinMode(13,OUTPUT);
pinMode(emisor,OUTPUT);
pinMode(receptor,INPUT);

//motor parado
motor_d.write(pare);
motor_e.write(pare);
//calibração
 botao = analogRead (A0);
  Serial.println (botao);
  while(botao>200){
  digitalWrite (13, HIGH);
  delay (300);
  digitalWrite (13, LOW);
  delay (300);
  botao = analogRead (A0);
  Serial.println (botao);
  }
for (x=0; x<10; x++){
  digitalWrite (13, HIGH);
delay (100);
ldr_d = analogRead (A1);
ldr_e = analogRead (A2);
branco_d = branco_d + ldr_d;
branco_e = branco_e + ldr_e;
Serial.println (x);
}
digitalWrite (13, LOW);
branco_d = branco_d/10;
branco_e = branco_e/10;
Serial.print ("branco direito= ");
Serial.print (branco_d);
Serial.print ("\t");
Serial.print ("branco esquerdo= ");
Serial.println (branco_e);
delay(5000);
Serial.println (x);
  botao = analogRead (A0);
  Serial.println (botao);
  while(botao>200){
  digitalWrite (13, HIGH);
  delay (300);
  digitalWrite (13, LOW);
  delay (300);
  botao = analogRead (A0);
  }
for (x=10; x>0; x--){
  digitalWrite (13, HIGH);
delay (100);
ldr_d = analogRead (A1);
ldr_e = analogRead (A2);
preto_d = preto_d + ldr_d;
preto_e = preto_e + ldr_e;
Serial.println (x);
}
digitalWrite (13, LOW);
preto_d = preto_d/10;
preto_e = preto_e/10;

Serial.print ("preto direito= ");
Serial.print (preto_d);
Serial.print ("\t");
Serial.print ("preto esquerdo= ");
Serial.println (preto_e);
delay(3000);

for (int y=0; y<10; y++){
digitalWrite (13, HIGH);
delay (250);
digitalWrite (13, LOW);
delay (250);
}

}


void loop (){
sonar();
int sensor_d=analogRead(A1);
int sensor_e=analogRead(A2);


Serial.print(sensor_d);
Serial.print("\t");
Serial.println(sensor_e);
Serial.print("\t");
Serial.println(cml);

//siga em frente
if(sensor_d<preto_d&&sensor_e<preto_e){
motor_d.write(frente_d);
motor_e.write(frente_e);
delay (t);
}
//vire a direita
if(sensor_d>preto_d&&sensor_e<preto_e){
motor_d.write(re_d);
motor_e.write(frente_e);
delay(t);
}
if(sensor_d<preto_d&&sensor_e>preto_e){
motor_d.write(frente_d);
motor_e.write(re_e);
delay(t);
}
if(sensor_d>preto_d&&sensor_e>preto_e){
motor_d.write(pare);
motor_e.write(pare);
}
/*inicio do desviar
if(cml<5){
 //parar
 motor_d.write(90);
 motor_e.write(90);
 delay(500);
 //virar a esquerda
 motor_d.write(0);
 motor_e.write(0);
 delay(1100);
 //andar
 motor_d.write(180);
 motor_e.write(0);
 delay(1700);
//virar a direita
 motor_d.write(180);
 motor_e.write(180);
 delay(1100);
 //andar
 motor_d.write(180);
 motor_e.write(0);
 delay(1700);
 //virar a esquerda
 motor_d.write(0);
 motor_e.write(0);
 delay(1100);
}
*/
}//fim do loop

int sonar(){
  digitalWrite(emisor,LOW);
  delayMicroseconds(2);
  digitalWrite(emisor,HIGH);
  delayMicroseconds(10);
  digitalWrite(emisor,LOW);
  duracao= pulseIn(receptor,HIGH);
  cml=microsecondstocentimeters(duracao);
  return cml;
}

long microsecondstocentimeters(long microseconds){
return microseconds/29/2;
}

Controle da garra do akira com suavização

#include <Servo.h>

Servo garra_d;
Servo garra_e;
Servo elevador;

int x =0;
float pos_d = 90;
int pos_e= 115;
int controle = 50;
int z=0;
int pos_elev=130;

void setup()
{
garra_d.attach(6);
garra_e.attach (7);
elevador.attach (8);
garra_d.write (pos_d);
garra_e.write (pos_e);
elevador.write (pos_elev);
Serial.begin (9600);
}

void loop()
{
  //abaixa a garra
for (z=0; z<=40;z++){
  elevador.write (pos_elev);
  pos_elev = pos_elev-1;
  Serial.println (pos_elev);
  delay (25);
}
delay (5000);
//subir a garra
for (z=40; z>=0;z--){
  elevador.write (pos_elev);
  pos_elev = pos_elev+1;
  Serial.println (pos_elev);
  delay (25);
}
delay (5000);
//abrir a garra
for (x=0; x<=controle;x++){
  Serial.print (pos_d);
  Serial.print ("\t");
  Serial.println (pos_e);
  garra_d.write (pos_d);
  garra_e.write (pos_e);
  delay (25);
  pos_d = pos_d+1.7;
  pos_e = pos_e-1;
}
delay (5000);
//fechar a garra
for (x=controle; x>=0;x--){
  Serial.print (pos_d);
  Serial.print ("\t");
  Serial.println (pos_e);
  garra_d.write (pos_d);
  garra_e.write (pos_e);
  delay (25);
  pos_d = pos_d-1.7;
  pos_e = pos_e+1;
}
delay (5000);
}//fim do loop

Depois de executar este programa, tornar cada for uma função void para controlar a garra:
void abrir_garra();
void fechar_garra();
void elevar_garra();
void abaixar_garra();

Acrescentar a função do servo e testar com objeto a distância de ser pego na garra.

Seguidor de linha com calibração

#include <Servo.h>

int x = 0;

int preto_d_min=1023;

int preto_e_min=1023;

// torna o sensor mais sensível

int margem= 25;

int sensor_d;

int sensor_e;

// controle dos motores: aqui tem q colocar o resultado do teste de motores

Servo motor_d;

Servo motor_e;

int frente_d = 45;

int re_d= 135;

int frente_d = 135;

int re_d= 45;

int virar = 150;

int t= 15;

void led(){

digitalWrite (13, HIGH);

delay (500);

digitalWrite (13, LOW);

delay (500);

digitalWrite (13, HIGH);

delay (500);

digitalWrite (13, LOW);

delay (500);

digitalWrite (13, HIGH);

delay (500);

digitalWrite (13, LOW);

delay (500);

}

void loop( ){

pinMode (13, OUTPUT);

led();

// aqui se realiza a calibração

for (x=0; x<10; x++){

delay (50);

sensor_d = analogRead (A6);

sensor_e = analogRead (A5);

if (sensor_d<preto_d_min){

preto_d_min = sensor_d;

}

if (sensor_e<preto_e_min){

preto_e_min = sensor_e;

}

}// fim do for

led();

motor_d.attach (4);

motor_e.attach (5);

led();

}//fim do setup

void loop( ){

sensor_d = analogRead (A6);

sensor_e = analogRead (A5);

if (sensor_d<preto_d_min+margem&&sensor_e<preto_e_min){

motor_d.write (frente_d);

motor_e.write (frente_e);

delay (t);

}

if (sensor_d>preto_d_min+margem&&sensor_e<preto_e_min){

motor_d.write (re_d);

motor_e.write (frente_e);

delay (virar);

}

if (sensor_d<preto_d_min+margem&&sensor_e>preto_e_min){

motor_d.write (frente_d);

motor_e.write (re_e);

delay (virar);

}

if (sensor_d>preto_d_min+margem&&sensor_e>preto_e_min){

motor_d.write (90);

motor_e.write (90);

delay (100);

}

}//fim do loop

cedula de votação elza

Cédula de votação Elza

Controle de abrir e fechar a garra

#include <Servo.h>

Servo garra_d;
Servo garra_e;
Servo elevador;

int emissor=10;
int receptor=9;
long cm, duracao;

int aberto_d= 0;
int aberto_e= 0;
int fechado_d=0;
int fechado_e=0;
int abaixa = 0;
int levanta = 90;

int x;
int distancia;

void setup(){
pinMode (emissor, OUTPUT);
pinMode (receptor, INPUT);

garra_d.attach (9);
garra_e.attach (10);
elevador.attach (11);

garra_d.write (aberto_d);
garra_e.write (aberto_e);
elevador.write (levanta);
}

void loop(){

distancia = sonar();
  Serial.print(inches);
  Serial.print("in, ");
  Serial.print(cm);
  Serial.print("cm");
  Serial.println();
  delay(100);

if (distancia>5 cm){
Serial.println ("sem objeto a frente");
garra_d.write (aberto_d);
garra_e.write (aberto_e);
elevador.write (levanta);
digitalWrite (13, HIGH);
}

if (distancia<5 cm){
Serial.println ("objeto a frente");
digitalWrite (13, LOW);
elevador.write (abaixa);
garra_d.write (fechado_d);
garra_e.write (fechado_e);
}

}

int sonar (){
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(pingPin, LOW);

  duracao = pulseIn(pingPin, HIGH);

  cm = microsecondsToCentimeters(duracao);


}


long microsecondsToCentimeters(long microseconds) {
  return microseconds / 29 / 2;
}

Arenas da OBR 2015

#include <Servo.h>

Servo garra_d;

Servo garra_e;

Servo elevador;

int aberto_d=0;

int aberto_e=0;

int fechado_d=90;

int fechado_e=90;

int levantar = 0;

int abaixar = 0;

int x;

void setup() {

  // put your setup code here, to run once:

garra_d.attach (8);

garra_e.attach (9);

elevador.attach (10);

garra_d.write (aberto_d);

garra_e.write (aberto_e);

elevador.write (levantar);

x=aberto+d;

}

void loop() {

  // put your main code here, to run repeatedly:

delay (1500);

for (x=aberto; x<fechado_d; x++){

garra_d.write (aberto_d+x);

garra_e.write (aberto_e-x);

delay (15);

}

delay (2000);

for (x=fechado_d; x>aberto_d; x--){

garra_d.write (fechado_d-x);

garra_e.write (fechado_e+x);

delay (15);

}

}

Teste de sensor de cor verde

Metodologia:
Foram testados dois tipos de circuito sensor:
Um sensor simples usando divisor de tensão entre um ldr e um resistor de 10kohm (ldr)
Um sensor com amplificação usando o mesmo divisor e um bc548 como amplificador (ldr com bc) e um resistor de 330 ohm (laranja laranja marrom) na base

Os sensores foram colocados sobre o branco, e após 3 segundos inicia a leitura, 10 leituras com intervalo de 0,1 seg entre elas. Após as 10 leituras, o programa calcula a média e envia os dados para o serial monitor. O processo foi repetido 5 vezes, totalizando 50 leituras e 5 médias.
O mesmo processo foi repetido colocando o sensor sobre uma etiqueta de 2,5x2,5 recoberta com fita transparente: 10 leituras com 5 repetições = 50 leituras e 5 médias.
Após este processo foi subtraído do valor de branco o valor do verde de cada teste (ldr e ldr com bc) e tirado a média das 5 repetições. O resultado indica qual processo apresentou a melhor amplitude.
Este processo foi repetido 2 vezes: na primeira vez o sensor estava em uma posição mais alta que o LED e no segundo experimento o sensor estava na mesma altura que o led.

Resultados

 Conclusão
Pelos resultados apresentados podemos concluir que o sensor com maior amplitude entre o branco e o verde é o sensor com BC548 na mesma altura do led branco.

Anexos - programação utilizada
int x = 0;
int y = 0;
int ldr=0;
int ldr2=0;
void setup() {
  // put your setup code here, to run once:
Serial.begin (9600);
delay (3000);
for (x=0; x<5; x++){
  for (y=0; y<10; y++){
    delay (100);
    int leitura1 = analogRead (A0);
    int leitura2= analogRead (A1);
    ldr = leitura1+ldr;
    ldr2=leitura2+ldr;
    Serial.print (x);
    Serial.print (", sem bc= ");
    Serial.print (ldr);
    Serial.print (", com bc= ");
    Serial.print (ldr2);
    Serial.println ();
  }
  ldr=ldr/10;
  ldr2=ldr2/10;
   Serial.print (y);
    Serial.print (", media ldr= ");
    Serial.print (ldr);
    Serial.print (", media com bc= ");
    Serial.print (ldr2);
    Serial.println ();
    ldr=0;
    ldr2=0;
}
}

void loop() {
  // put youry main code here, to run repeatedly:

}