Prestação de Contas OBR 2016

Mantendo nossa política de transparência no projeto, postamos os gastos/investimentos feitos durante a participação no evento Olimpíada Regional de Robótica, na etapa regional e final estadual. As doações feitas por inúmeras pessoas e a campanha de promoção encabeçada pelos inúmeros parceiros - e são inúmeros mesmos: Yumi, Fábio, Denise, Izilda, professores do Elza Facca, Renata e todo o pessoal do face resultaram numa arrecadação superior ao esperado.

Selfie da galera trabalhando até 22hs.

Nós somos humanos e também almoçamos
Com o que recebemos a mais de dinheiro depois da fase regional investimos em 3 aspectos que foram nossos principais problemas durante a regional:
1- Vencer a rampa: para isso estudamos 3 frentes diferentes. A primeira foram rodas - compramos um jogo de rodas de gel para melhorar a aderência (sem sucesso). A segunda frente foi identificar a rampa usando sensores de mercúrio - compramos e montamos 5 sensores de mercúrio para os robôs (eram 3 robôs mais um robô reserva, Silfo, e um sensor caso algum acidente acontecesse - gato escaldado tem medo de água à distância). A terceira e última frente foi mexer no centro de gravidade do robô aumentando a altura da traseira e forçando a massa em direção ao eixo da roda.

Fig 1 - Detalhe do robô com sensor de Tilt

2- Melhoria nos robôs com a compra de novos sensores: vamos começar a pesquisar e desenvolver um novo sensor de linha utilizando os sensores da Sharp. O objetivo destes testes é maior rapidez na resposta do sensor e assim podermos trabalhar com robôs com maior velocidade. Além disso, compramos mais TCRT´s para completar os robôs e começarmos a desenvolver nosso seguidor de linha com PID (Afonso que se prepare).

3- Reposição dos reguladores de tensão queimados durante os testes para preparação da competição, bem como, no desenvolvimento de um sistema para evitar a queima dos reguladores utilizando diodos de proteção, que aliás se mostrou muito eficiente.

Além deste material gastamos com fita isolante (muita) para desenvolver as duas pistas de teste e a nossa "arena" - feita com pedaços de mesa e quadros de aviso da escola - que nos permitiu uma melhor preparação para a competição.




Hoje temos 3 projetos completos - robôs de resgate de alto risco montados completos: Akira, Protheus e Toth. Em montagem: Apolo e Sifo - robôs que serão utilizados para viagem ao centro da terra e resgate no plano. Em adaptação para uso e melhoria: projeto de robô redondo que seria usado para futebol e Hércules.
(em breve as fotos).

Abaixo segue nossa planilha de gastos/investimento:

Fonte	Objetivo	Valor arrecadado	Gastos	Saldo
Vakinha 61133	Regional da OBR	200,00	14,30	185,70
Doação da escola		200,00		385,70
Doação Profs		200,00		585,70
Arrecadado		200,00		785,70
Transporte			500,00	285,70
Alimentação			70,00	215,70
Componentes eletrônicos			219,50	-3,80
Vakinha 72321	Final da OBR	350,00	24,90	325,10
Doação Profs		200,00		525,10
Arrecadado		200,00		725,10
Transporte			600,00	125,10
Alimentação			60,00	65,10
Saldo Final				65,10

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

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:

}