Testes de verde: OBR 2016

Para quem está nos ajudando através do Vakinha, fizemos os testes de verde do robô e o GAP (interrupção de linha). São 7 meses pesquisando como fazer um sensor de cor para verde e, no final, bastou usar uma solução simples que encontramos o Laboratório de Garagem.
"Se eu vi mais longe, foi por estar sobre ombros de gigantes."
Issac Newton

Fonte: http://arduino.labdegaragem.com/Guia_preview/SPK_9_cores_ldr.html

Desviar do Akira

#include <Servo.h>

// Teste de motor
Servo motor_d;
Servo motor_e;

void setup() {
  // put your setup code here, to run once:
motor_d.attach (4);
motor_e.attach (5);
pare();
}

void loop() {
  // put your main code here, to run repeatedly;
  delay (3000);
  direita();
  delay (870);
  pare ();
  frente();
  delay (1538);
  esquerda();
  delay (800);
  frente();
  delay (3207);
  esquerda();
  delay (800);
  pare();
  frente();
  delay (1538);
  direita();
  pare();
  delay (5000);
}

void re(){
  motor_d.write (180);
  motor_e.write (70);
}
void frente(){
  motor_d.write (0);
  motor_e.write (110);
}
void direita(){
  motor_d.write (180);
  motor_e.write (130);
}
void esquerda(){
  motor_d.write (0);
  motor_e.write (50);
}
void pare(){
  motor_d.write (90);
  motor_e.write (90);
}

Controle do aspirador com sensor de ultrassom

//Controle do aspirador com sensor de ultrassom
#include <Servo.h>

Servo braco;

int const abaixar = 140;
int const levantar = 5;

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

void setup() {
  // put your setup code here, to run once:
pinMode (12, OUTPUT);
braco.attach (7);

pinMode (emissor, OUTPUT);
pinMode (receptor, INPUT);
braco.write (levantar);
Serial.begin (9600);
}

void loop() {
  sonar();
  delay (100);
  Serial.println (cm);
  if (cm==12){
  // baixar
  for (int x=levantar; x<abaixar; x++){
  braco.write (x);
  delay (6);
  Serial.println (braco.read());
  }
 
//Liga o ventilador
digitalWrite (12, HIGH);
delay (2500);

// levantar
 for (int x=abaixar; x>levantar; x--){
  braco.write (x);
  delay (6);
  Serial.println (braco.read());
  }

//desliga o ventilador
digitalWrite (12, LOW);
delay (2500);
/*
//abaixar
for (int x=levantar; x<abaixar; x++){
  braco.write (x);
  delay (6);
  }
delay (7000);
*/  }

}

int sonar(){
  digitalWrite(emissor, LOW);
  delayMicroseconds(2);
  digitalWrite(emissor, HIGH);
  delayMicroseconds(5);
  digitalWrite(emissor, LOW);
 
  duration = pulseIn(receptor, HIGH);

  cm = microsecondsToCentimeters(duration);

return cm;
}


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

Calibração de sensores - Wall-e e Akira

long duration, inches, cm;
 int emissor = 9;
 int receptor=10;

void setup() {
Serial.begin (9600);
 pinMode(emissor, OUTPUT);
  pinMode(receptor, INPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  delay (250);
  int ir_d = analogRead(A1);
  int ir_e = analogRead(A2);
  int sensor_d = analogRead(A3);
  int sensor_e = analogRead(A4);
  sonar();
   Serial.print(ir_d);
  Serial.print(", ");
 Serial.print(ir_e);
  Serial.print(", ");
  Serial.print(sensor_d);
  Serial.print(", ");
 Serial.println(sensor_e);
 Serial.print(", ");
 Serial.println(cm);
  Serial.println();
}

  int sonar(){
  digitalWrite(emissor, LOW);
  delayMicroseconds(2);
  digitalWrite(emissor, HIGH);
  delayMicroseconds(10);
  digitalWrite(emissor, LOW);
  duration = pulseIn(receptor, HIGH);

  // convert the time into a distance

  cm = microsecondsToCentimeters(duration);
return cm;
 }

long microsecondsToCentimeters(long microseconds)
{
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  return microseconds / 29 / 2;
}

Wall - e: teste de motores e primeiro seguidor de linha

//Programa de teste dos motores
// pinos dos motores
int motor_d1 = 4;
int motor_d2 = 5;
int motor_e1 = 6;
int motor_e2 = 7;

//controles dos motores
int veloc = 255; //usar valores de 0 a 255 para controlar a velocidade
int virar = 30; // este valor controla a curva que o robô faz

void setup() {
 //controle de motores
 pinMode (motor_d1, OUTPUT);
 pinMode (motor_d2, OUTPUT);
 pinMode (motor_e1, OUTPUT);
 pinMode (motor_e2, OUTPUT);
}

void loop() {
frente();
delay (3000);
direita();
delay (3000);
esquerda();
delay (3000);
pare();
delay (3000);
}// fim do loop  

// controles dos motores
void frente (){
  analogWrite (motor_d1, veloc);
  analogWrite (motor_d2, 0);
  analogWrite (motor_e1, veloc);
  analogWrite (motor_e2, 0);
}
void re (){
  analogWrite (motor_d1, 0);
  analogWrite (motor_d2, veloc);
  analogWrite (motor_e1, 0);
  analogWrite (motor_e2, veloc);
}

void direita (){
  analogWrite (motor_d1, veloc);
  analogWrite (motor_d2, 0);
  analogWrite (motor_e1, 0);
  analogWrite (motor_e2, veloc);
  delay (virar);
}

void esquerda (){
  analogWrite (motor_d1, 0);
  analogWrite (motor_d2, veloc);
  analogWrite (motor_e1, veloc);
  analogWrite (motor_e2, 0);
 delay (virar);
}

void pare (){
  analogWrite (motor_d1, 0);
  analogWrite (motor_d2, 0);
  analogWrite (motor_e1, 0);
  analogWrite (motor_e2, 0);
}

//---------------------------------------------------------------------------//

// Programa de seguidor de linha inicial

int preto_d_min = 1023;

int preto_e_min = 1023;

int preto_d = 0;

int preto_e = 0;

int x = 0;

int botao;

int t = 45; //regulagem que varia de 0 a 90 - controla o quanto vira

int margem = 0; //regulagem que varia de 0 a 1023

// pinos dos motores

int motor_d1 = 4;

int motor_d2 = 5;

int motor_e1 = 6;

int motor_e2 = 7;

//controles dos motores

int veloc = 255; //usar valores de 0 a 255 para controlar a velocidade

int virar = 30; // este valor controla a curva que o robô faz

void setup() {

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

  pinMode (2, INPUT);

  pinMode (3, INPUT);

  pinMode (A0, INPUT);

  pinMode (13, OUTPUT);

 //controle de motores

 pinMode (motor_d1, OUTPUT);

 pinMode (motor_d2, OUTPUT);

 pinMode (motor_e1, OUTPUT);

 pinMode (motor_e2, OUTPUT);

 

  Serial.begin (9600);

  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);

preto_d = analogRead (A1);

preto_e = analogRead (A2);

if (preto_d<preto_d_min){

  preto_d_min=preto_d;

}

if (preto_e<preto_e_min){

  preto_e_min=preto_e;

}

Serial.println (x);

}

digitalWrite (13, LOW);

Serial.print ("direito= ");

Serial.print (preto_d_min);

Serial.print ("\t");

Serial.print (" esquerdo= ");

Serial.println (preto_e_min);

for (int y=0; y<10; y++){

digitalWrite (13, HIGH);

delay (100);

digitalWrite (13, LOW);

delay (100);

}

delay (3000);

}

void loop() {

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

int sensor_d = analogRead (A1);

int sensor_e = analogRead (A2);

Serial.print ("direito= ");

Serial.print (sensor_d);

Serial.print ("\t");

Serial.print (" esquerdo= ");

Serial.println (sensor_e);

//siga em frente

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

frente();

}

//vire a direita

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

direita();

}

//vire a esquerda

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

esquerda();

}

//cruzamento

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

pare();

}

}// fim do loop    

// controles dos motores

void frente (){

  analogWrite (motor_d1, veloc);

  analogWrite (motor_d2, 0);

  analogWrite (motor_e1, veloc);

  analogWrite (motor_e2, 0);

}

void re (){

  analogWrite (motor_d1, 0);

  analogWrite (motor_d2, veloc);

  analogWrite (motor_e1, 0);

  analogWrite (motor_e2, veloc);

}

void direita (){

  analogWrite (motor_d1, veloc);

  analogWrite (motor_d2, 0);

  analogWrite (motor_e1, 0);

  analogWrite (motor_e2, veloc);

  delay (virar);

}

void esquerda (){

  analogWrite (motor_d1, 0);

  analogWrite (motor_d2, veloc);

  analogWrite (motor_e1, veloc);

  analogWrite (motor_e2, 0);

 delay (virar);

}

void pare (){

  analogWrite (motor_d1, 0);

  analogWrite (motor_d2, 0);

  analogWrite (motor_e1, 0);

  analogWrite (motor_e2, 0);

}

Teste Akira com calibração para mínimo

int preto_d_min = 1023;
int preto_e_min = 1023;
int preto_d = 0;
int preto_e = 0;

int x = 0;

int botao;

int t = 45; //regulagem que varia de 0 a 90 - controla o quanto vira
int margem = 0; //regulagem que varia de 0 a 1023


#include <Servo.h>

Servo motor_d;  // create servo object to control a servo
Servo motor_e;              // twelve servo objects can be created on most boards

// controle dos motores
int frente_d = 12;
int frente_e = 118;
int re_d = 118;
int re_e = 12;
int pare = 90;

void setup() {
  // put your setup code here, to run once:
  pinMode (A4, INPUT);
  pinMode (A5, INPUT);
  pinMode (A0, INPUT);
  pinMode (13, OUTPUT);
 //controle de motores
 motor_d.attach(4);  // attaches the servo on pin 9 to the servo object
 motor_e.attach(5);
 motor_d.write (90);
 motor_e.write (90);

  Serial.begin (9600);
  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);
preto_d = analogRead (A1);
preto_e = analogRead (A2);
if (preto_d<preto_d_min){
  preto_d_min=preto_d;
}
if (preto_e<preto_e_min){
  preto_e_min=preto_e;
}
Serial.println (x);
}
digitalWrite (13, LOW);

Serial.print ("direito= ");
Serial.print (preto_d_min);
Serial.print ("\t");
Serial.print (" esquerdo= ");
Serial.println (preto_e_min);

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

void loop() {
  // put your main code here, to run repeatedly:
int sensor_d = analogRead (A1);
int sensor_e = analogRead (A2);
Serial.print ("direito= ");
Serial.print (sensor_d);
Serial.print ("\t");
Serial.print (" esquerdo= ");
Serial.println (sensor_e);

//siga em frente
if(sensor_d<preto_d_min-margem&&sensor_e<preto_e_min-margem){
motor_d.write(frente_d);
motor_e.write(frente_e);
}
//vire a direita
if(sensor_d>preto_d_min-margem&&sensor_e<preto_e_min-margem){
motor_d.write(re_d);
motor_e.write(frente_e);
delay(t);
}
//vire a esquerda
if(sensor_d<preto_d_min-margem&&sensor_e>preto_e_min-margem){
motor_d.write(frente_d);
motor_e.write(re_e);
delay(t);
}
//cruzamento
if(sensor_d>preto_d_min-margem&&sensor_e>preto_e_min-margem){
motor_d.write(pare);
motor_e.write(pare);
}


}// fim do loop  

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;
}