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:

}

OBR 2015

08/08/2015
Após nossa classificação na Regional da OBR 2015, dia 08 participamos da final estadual. Infelizmente o resultado não foi o esperado: apesar de marcarmos pontos termos nos esforçado muito, tivemos problemas na detecção do verde pelos sensores e isso afetou nosso resultado na sala 1 e 2.

1- Configuração para localização e entrada na sala 3 que funcionou com precisão. Erros individuais como desligar o sensor de detecção (que funcionou) da área de descarte e de configuração no processo de localização influenciaram o resultado.

2- O tamanho do robô afetou seu desempenho na arena. Ele estava com dificuldade para subir a rampa e para fazer os redutores de velocidade, fora que deslizava na madeira utilizada. A construção afetou significativamente o resultado final.

3- Desviar funcionou muito bem, cumprindo várias vezes a etapa.

4- O sensor de ldr não cumpriu o papel. Não sabemos se foi por conta do ajuste da calibração ou por não ser eficiente (tamanho).

Com isso, nos marcamos apenas 90 pontos, ficando com o 38 e 42 lugar na competição:

38	2 – Pequenos Cientistas EM 1	50	300	10	300	40	300	90
39	2 – QUADCORE	40	300	20	300	40	300	80
40	2 – Apollo XXI	30	300	10	300	40	300	70
41	2 – BrutusM	35	300	30	300	30	300	65
42	2 – Pequenos Cientistas	25	300	10	300	40	300	65

Dia 27/06 temos a primeira fase da OBR, a seletiva para a final que será em agosto. São 600 equipes em 6 seletivas, das quais, apenas 60, 10 por seletiva, irão para a final. Nesse cenário trabalhamos em 4 robôs:
1- Monstrinho: a estrutura são chassis da Robocore que tiveram suas rampas cortadas. Quatro motores sem o drive de controle, acionados por Arduino, com uma bateria lipo nano de 3S com 1,3A. Dois sensores de IR TCRT5000 caseiros e um sensor com 2 ldr´s e um led, além de um ultrassom completam o projeto. Vamos usá-lo no EF e EM mas, como não deu tempo (queimamos 2 reguladores de tensão de 9V e outros percalços) vamos sem a garra.

2- Akira: uma versão melhorada do Ares, com uns upgrades para resolver os bug´s e evitar os danos a bateria. Dois servos de 4 kgf.cm e uma roda boba e a mesma configuração de sensores do monstrinho. O diferencial é a bateria: um LIPO 3S com 2,2 A - dura uma eternidade - que íamos usar no futebol mas acabou ficando nele por enquanto.

3- Coisinha sem nome: um chassi da robocore FLS utilizado para resgate. Devido aos problemas com redutor fizemos uma "segunda" versão de papel: