terça-feira, 16 de agosto de 2016

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















domingo, 19 de junho de 2016

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

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

segunda-feira, 13 de junho de 2016

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





sexta-feira, 3 de junho de 2016

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

quinta-feira, 2 de junho de 2016

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

quinta-feira, 19 de maio de 2016

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