Lutas de robôs - Nossos projetos em ação

Neste post, em ordem cronológica, do mais novo para o mais velho, colocaremos nossas disputas internas...
A começar pelo Torneio Juvenil de Robótica (USP) 2013 a luta de sumô Inácio vs Osiris. Talvez a luta mais lenta de todo o torneio pois os robôs já estavam sem baterias:

Quem viu o primeiro vídeo não vai acreditar no segundo: Após carregar as baterias, a luta entre o Inácio vs Artemis, a grande surpresa da nossa equipe, no cabo de guerra.

Antes do Torneio tivemos a luta Osiris vs Artemis que terminou 4 a 4. Quem viu o primeiro vídeo nem acredita que é o mesmo robô, isso porque nessa luta a bateria estava com 70% da capacidade.

Luta de robôs de Sumô

Luta realizada pela equipe Orion usando o programa Kamikaze - suicida: este programa foi utilizado porque os sensores não geravam corrente suficiente para detectar o objeto. Foi uma boa ideia na hora mas se provou ineficiente. A medida corretiva foi baixar o programa do Robô Titan - equipe Pequenos Cientistas que, como no posto anterior, lutou e venceu um round.

Nós ainda temos problemas com o sensores mas, nos últimos testes, os sensores mostraram resultados melhores. A hipótese levantada está associada a corrente gerada pelos sensores é muito pequenos, visto que usamos pilhas (usadas) ou alcalinas de baixa corrente para alimentar os sensores. Nesta quarta-feira, 05/09, estaremos realizando teste de sensores usando fontes de alimentação e comparando o resultado com o obtido usando pilhas alcalinas.

Com o adiamento para 08/09 da Mostra Nacional de Robótica (MNR), cujo vídeo está ficando muito legal e em breve postaremos no blog, temos mais tempo para trabalhar nos sensores e realizar testes mais apurados.

Ainda temos o problema de verba - apesar do dinheiro ter vindo de diversas fontes (prefeitura, governo do estado), esta verba não incluiu o atual problema do nosso projeto - baterias competitivas. Os alunos já arrecadaram metade da verba para as baterias e carregador de 2 robôs (R$50,00) mas ainda falta R$70,00. Estaremos tentando arrecadar em nossas fileiras e, com pelo menos 2 baterias - uma de 7,7V e uma 11V - temos uma chance de competir de igual para igual com outras equipes. No total, o custo de um robô usando nossa metodologia (descontando o frete) seria em torno de R$300,00, com boas chances de competir. Para feiras de ciências e diversão pessoal, o custo é muito menor - em torno de R$50,00.

Nossa meta este ano é construir 5 chassis - 3 lutadores de sumô (2 small 15x15, 20x20, Large-40x40), 1 seguidor de linha de alta velocidade (1 roda de tração e 1 eixo de giro) e 1 seguidor de linha de alto torque. Desses projetos 2 estão prontos e estão recebendo os sensores e baterias (que ainda não compramos) - 20x20 Titan I, Large Orion. Além destes, aguardando o Arduino, Placas, Baterias e sensores, sendo que só chassi está pronto temos o carro da Fenix (seguidor de linha) e o novo modelo que a equipe Orion está construindo, usando esteiras e motores de passo, que em breve estará com fotos no blog.

Além disso, abrimos inscrições para montar uma nova equipe na EE Elza Facca Martins Bonilha e temos 2 vagas na EE Frei Dagoberto Romag para alunos de Ensino Fundamental - 5ª e 6ª série. Esta semana convidamos 3 alunos do EE Elza Facca da 5ª Série C que tem potencial para desenvolver o trabalho e um aluno da 7ª série G da EE Frei Dagoberto Romag que se candidatou. Fora esses 3, temos mais um colega de um dos alunos que se prontifica a ir mas está com problemas de transporte.

Nossa primeira vitória no sumô

Melhor de 3 rounds, o nosso não tem proteção na frente, vencemos o 2° round.

Torneio Juvenil de Robótica - ENIAC vs Orion

Sumo 20x20 - Pequenos Cientistas

Aqui estão os rascunhos de construção da estrutura do robô de sumô e viagem ao centro da Terra e as fotos da montagem, de responsabilidade do Daniel. Estas estruturas estão sem medidas pois se baseiam no projeto original e as adaptações foram feitas conforme os problemas foram surgindo. As fotos foram realizadas pelo celular do Daniel.

 Base do chassi e suporte para os servo-motores

 Suporte do Arduíno e Protoboard

 Rodas

Rampa de proteção

Bom depois de elaborar os rascunhos começou a construção:

Arduino sobre o suporte e Protoboard:

Montagem final do robô com a base, rodas, suporte e rampa de defesa. Agora só falta os sensores:

Programa usado no pré-teste dos motores, para testar o L297N (ponte H) e os servo motores:

/* Este código permite o passo de 2 motores*/

//motor direito

int motorPin1 = 7;

int motorPin2 = 8;

//motor esquerdo

int motorPin3 = 3;

int motorPin4 = 4;

int delayTime = 3000;

void setup() {

  //configura os pinos digitais do motor direito

  pinMode(motorPin1, OUTPUT);

  pinMode(motorPin2, OUTPUT);

  //configura os pinos digitais do motor esquerdo

  pinMode(motorPin3, OUTPUT);

  pinMode(motorPin4, OUTPUT);

  }

void loop() {

//motor direito

  digitalWrite(motorPin1, HIGH);

  digitalWrite(motorPin2, LOW);

  digitalWrite(motorPin3, HIGH);

  digitalWrite(motorPin4, LOW);

  delay(delayTime);

  digitalWrite(motorPin1, LOW);

  digitalWrite(motorPin2, HIGH);

  digitalWrite(motorPin3, LOW);

  digitalWrite(motorPin4, HIGH);

  delay(delayTime);

  digitalWrite(motorPin1, LOW);

  digitalWrite(motorPin2, HIGH);

  digitalWrite(motorPin3, HIGH);

  digitalWrite(motorPin4, LOW);

  delay(delayTime);

  digitalWrite(motorPin1, HIGH);

  digitalWrite(motorPin2, LOW);

  digitalWrite(motorPin3, LOW);

  digitalWrite(motorPin4, HIGH);

  delay(delayTime);

  } 

Vídeo do teste dos motores com L297:

Vídeos da montagem final com baterias, falta apenas a instalação dos sensores. O programa usado foi o mesmo do teste anterior mas agora somente

Vídeo do sistema completo embarcado, sem alimentação por fonte ligada a tomada.

Boas notícias:

- O chassi está quase pronto, faltando detalhes de regulagem

- Temos 7 sensores e falta apenas 7 sensores que ficam prontos nesta quarta-feira

- A bateria que montamos de 2 baterias chumbo-ácidas doadas estão "pegando" carga o que quer dizer uma economia de R$ 30 reais e uma bateria de 8V com 400 mAh

- Conseguimos, graças ao Paulo da Equipe Orion, uma broca de 1,5 mm que pode funcionar para fazer as placas de sensores que faltam, testaremos amanhã, por um módico preço de R$2,60.

- Estamos no prazo com todas as equipes.

Problemas a resolver ainda:

- Comprar L298N para a equipe Orion.

- Instalar os sensores de linha e distância e testar.

- Melhorar os sensores de distância pois o alcance está limitado a 5 cm.

- Testar as 2 configurações novas de sensores - aumentando a distância entre os led´s emissores e receptores para 2cm e usando resistores de 170 ohm no emissor e 4k7 no receptor.

Em breve postaremos as fotos dos sensores IR e o chassi com eles embarcados.

Estamos quase lá, força pessoal.

PS: Ainda não postamos nada da equipe Orion pois o material está no celular da Coordenadora Vani do Elza Facca. 

Pequenos Cientistas - Lógica de Programação

Análise de programação do projeto de robô de sumô para o Torneio Juvenil de Robótica 2012:

M1 motor direito: 8–FRENTE, 9–RÉ

M2 motor esquerdo: 10-FRENTE, 11–RÉ

S1 – sensor de linha dianteiro

S2 -  sensor de linha traseiro

S3 – sensor de objeto dianteiro

S4 – sensor de objeto traseiro

S5 – sensor de objeto direito

S6 – sensor de objeto esquerdo

---------------------------------------------------

S1 - ↓ - 9, 11

S2 - ↑ - 8, 10

S3 - ↑ - 8, 10

S4 - ↓ - 9, 11 

S5 - ←90° ↑ - 9, 10 DELAY 8,10

S6 - →90º ↑ - 8, 11 DELAY 8,10

S1 + S3 - ↑ - 8, 10

S1 + S4 - ↓ - 9, 11

S2 + S3 - →90°↑→90°↑ - 8, 11 DELAY 8,10 - 8, 11 DELAY 8,10

Programa elaborado na IDE do Arduíno:

/* Projeto desenvolvido para robô de sumô no Torneio Juvenil de robótica 2012 pela equipe Pequenos Cientistas*/

// —————————————————————————  Pinos dos Motores

int direito_frente = 7;

int direito_re = 8;

int esquerdo_frente = 9;

int esquerdo_re = 10;

//--------------------------------------------- giro de 90°

int giro = 200;

//--------------------------------------------- Pinos sensores

int IR1 = 0;

int IR2 = 1;

int IR3 = 2;

int IR4 = 3;

int IR5 = 4;

int IR6 = 5;

//--------------------------------------------Variaveis de leitura dos sensores

int maximo = 3; // tensão de detecção do sensor IR

int VR1;

int VR2;

int VR3;

int VR4;

int VR5;

int VR6;

// ————————————————————————— Setup

void setup() {

// Seleciona motores

pinMode(direito_frente, OUTPUT);

pinMode(direito_re, OUTPUT);

pinMode(esquerdo_frente, OUTPUT);

pinMode(direito_re, OUTPUT);

//Ativa sensores

pinMode(IR1, INPUT);

pinMode(IR1, INPUT);

pinMode(IR2, INPUT);

pinMode(IR3, INPUT);

pinMode(IR4, INPUT);

pinMode(IR5, INPUT);

}

// ————————————————————————— Loop

void loop() {

  //faz a leitiura dos sensores e converte o valor lido (de 0 a 1024) em valores de tensão 

VR1 = analogRead(IR1) * 0.0049;//sensor de linha dianteiro

VR2 = analogRead(IR2) * 0.0049;//sensor de linha traseiro

VR3 = analogRead(IR3) * 0.0049;//sensor de objeto dianteiro

VR4 = analogRead(IR4) * 0.0049;//sensor de objeto traseiro

VR5 = analogRead(IR5) * 0.0049;//sensor de objeto direito

VR6 = analogRead(IR6) * 0.0049;//sensor de objeto esquerdo

//leitura de sensores e comparação com limite de leitura (variável máximo), com resposta

//S1 - ↓ - 9, 11

if (VR1 < maximo) {

digitalWrite (direito_frente,  LOW);

digitalWrite (direito_re, HIGH);

digitalWrite (esquerdo_frente, LOW);

digitalWrite (esquerdo_re, HIGH);

}

//S2 - ↑ - 8, 10

if (VR2 < maximo){

digitalWrite (direito_frente, HIGH);

digitalWrite (direito_re, LOW);

digitalWrite (esquerdo_frente, HIGH);

digitalWrite (esquerdo_re, LOW);

}

//S3 - ↑ - 8, 10

if (VR3 < maximo){

digitalWrite (direito_frente, HIGH);

digitalWrite (direito_re, LOW);

digitalWrite (esquerdo_frente, HIGH);

digitalWrite (esquerdo_re, LOW);

}

//S4 - ↓ - 9, 11 

if (VR4 < maximo){

digitalWrite (direito_frente,  LOW);

digitalWrite (direito_re, HIGH);

digitalWrite (esquerdo_frente, LOW);

digitalWrite (esquerdo_re, HIGH);

}

//S5 - ←90° ↑ - 9, 10 DELAY 8,10

if (VR5 < maximo){

digitalWrite (direito_frente, LOW);

digitalWrite (direito_re, HIGH);

digitalWrite (esquerdo_frente, HIGH);

digitalWrite (esquerdo_re, LOW);

delay(giro);

digitalWrite (direito_frente, HIGH);

digitalWrite (direito_re, LOW);

digitalWrite (esquerdo_frente, HIGH);

digitalWrite (esquerdo_re, LOW);

}

//S6 - →90º ↑ - 8, 11 DELAY 8,10

if (VR6 < maximo){

digitalWrite (direito_frente, HIGH);

digitalWrite (direito_re, LOW);

digitalWrite (esquerdo_frente, LOW);

digitalWrite (esquerdo_re, HIGH);

delay(giro);

digitalWrite (direito_frente, HIGH);

digitalWrite (direito_re, LOW);

digitalWrite (esquerdo_frente, HIGH);

digitalWrite (esquerdo_re, LOW);

}

//S1 + S3 - ↑ - 8, 10

if (VR1 < maximo && VR3 < maximo){

digitalWrite (direito_frente, HIGH);

digitalWrite (direito_re, LOW);

digitalWrite (esquerdo_frente, HIGH);

digitalWrite (esquerdo_re, LOW);

}

//S1 + S4 - ↓ - 9, 11

if (VR1 < maximo && VR4 < maximo){

digitalWrite (direito_frente,  LOW);

digitalWrite (direito_re, HIGH);

digitalWrite (esquerdo_frente, LOW);

digitalWrite (esquerdo_re, HIGH);

}

//S2 + S3 - →90°↑→90°↑ - 8, 11 DELAY 8,10 delay 8, 11 DELAY 8,10

if (VR2 < maximo && VR3 < maximo){

digitalWrite (direito_frente, HIGH);

digitalWrite (direito_re, LOW);

digitalWrite (esquerdo_frente, LOW);

digitalWrite (esquerdo_re, HIGH);

delay(giro);

digitalWrite (direito_frente, HIGH);

digitalWrite (direito_re, LOW);

digitalWrite (esquerdo_frente, HIGH);

digitalWrite (esquerdo_re, LOW);

delay(giro);

digitalWrite (direito_frente, HIGH);

digitalWrite (direito_re, LOW);

digitalWrite (esquerdo_frente, LOW);

digitalWrite (esquerdo_re, HIGH);

delay(giro);

digitalWrite (direito_frente, HIGH);

digitalWrite (direito_re, LOW);

digitalWrite (esquerdo_frente, HIGH);

digitalWrite (esquerdo_re, LOW);

}

}

/*FIM*/

Bom, salvo os problemas (o simulino não consegue ligar as 4 saídas digitais ao mesmo tempo e, as saídas analógicas não funcionam corretamente - a 4 e 5 não ativam e eu não sei porquê) o simulino pode demonstrar este programa funcionando, conforme vídeo abaixo:

Projeto de Chassi

Para construir o chassi da equipe pequenos cientistas, conforme o esquema e o vídeo abaixo, recomendamos a leitura dos seguintes artigos:

Como fazer as rodas:
http://lusorobotica.com/index.php/topic,1808.0.html
Material: 2 impressoras HP 6X0 - total 6 rodas mais o eixo
Uma opção é procurar casas de manutenção de impressoras ou quem arrume e ver se ele tem as peças lá.

Como fazer os motores:
http://www.roboticasimples.com/artigos.php?acao=16
Material: 2 servos motores de parabólica (procure casas de manutenção de parabólicas, eles costumam doar esses servos).

Sugerimos substituir o Horne de papel por Horne feito com placa de circuito impresso usada, funciona bem. Coloque o Horne dos dois lados da roda pois isso mantém melhor a estabilidade.

O projeto:

A versão original deste projeto foi usada no 6° Grande Desafio com rodas feitas de CD que causava o deslizamento do chassi. Esta segunda versão utiliza as rodas de impressora, que melhorou muito o deslizar, além da estabilidade.

Esta versão usa madeira e conseguiu carregar 2,5 kg, com velocidade de 0,1 m/s, conforme especificações do projeto.

Olha o vídeo do robô funcionando (não usamos baterias, ligamos  uma fonte 6V/400mA):

Alguns projetos

Fotos de alguns projetos que desenvolvemos em 2012:

Robô seguidor de luz

Projeto:

Mousebot (http://www.instructables.com/id/Mousebot-Revisited/)

Robô seguidor de Luz - Luzbô mecatrônica fácil

Sensores de IR

Sensor de Contato - Mecatrônica Fácil

Bug - Robô Inseto

Circuitos amplificadores - BC548/TIP120

Nosso laboratório - Sala compartilhada com Educação Física

Sensor IR com função

O código de sensor IR anterior, mas agora com função, o que torna o código mais eficiente e limpo:

int IR[]={0,1,2,3,4,5};

int L[] ={6,7,8,9,10,11};

int maximo = 3;
int VR[]={1,2,3,4,5,6};

void setup() {
// configura o pino como saida
int a;
for (a=0; a<6; a++){
pinMode(L[a], OUTPUT);

// configura o pino como entrada
pinMode(IR[a], INPUT);
}

}
void loop(){
int a;
for (a=0; a<6; a++){
 
  // le o estado do botao
VR[a] = analogRead(IR[a])*0.0049;
// verifica se o sensor está ativo
if (VR[a] >= maximo) {
// se sim, acende o LED
digitalWrite(L[a], HIGH);
}
else{
  digitalWrite(L[a], LOW);
}
}
}

Teste - Sensores de IR

 Este teste usa o Simulino, simulador do Arduino no Proteus, com o código fonte abaixo, para simular a leitura de sensores IR. Estes sensores serão utilizados no TITAN I e outros robôs, sendo o código adaptado para cada situação em particular. Os botões atuam fechando o circuito, ou seja, se um objeto refletir a luz IR o Arduíno recebe um sinal acendendo um led específico. O fator de multiplicação converte o sinal analógico do Arduíno em tensão.

/* Programa para leitura de 6 sensores IR - Projeto Robô Lutador de Sumô
Equipe Pequenos Cientistas 2012
*/
int IR1=0;
int IR2=1;
int IR3=2;
int IR4=3;
int IR5=4;
int IR6=5;

int L1 = 5;
int L2 = 6;
int L3 = 7;
int L4 = 8;
int L5 = 9;
int L6 = 10;


int maximo = 2;
int VR1;
int VR2;
int VR3;
int VR4;
int VR5;
int VR6;

void setup() {
// configura o pino como saida
pinMode(L1, OUTPUT);
pinMode(L2, OUTPUT);
pinMode(L3, OUTPUT);
pinMode(L4, OUTPUT);
pinMode(L5, OUTPUT);
pinMode(L6, OUTPUT);

// configura o pino como entrada
pinMode(IR1, INPUT);
pinMode(IR1, INPUT);
pinMode(IR2, INPUT);
pinMode(IR3, INPUT);
pinMode(IR4, INPUT);
pinMode(IR5, INPUT);

Serial.begin (9600);
}
void loop(){

  // le o estado do botao
VR1 = analogRead(IR1) * 0.0049;
VR2 = analogRead(IR2) * 0.0049;
VR3 = analogRead(IR3) * 0.0049;
VR4 = analogRead(IR4) * 0.0049;
VR5 = analogRead(IR5) * 0.0049;
VR6 = analogRead(IR6) * 0.0049;

// verifica se o sensor está ativo
if (VR1 > maximo) {
// se sim, acende o LED
digitalWrite(L1, HIGH);
}
else {
digitalWrite(L1, LOW);
}

if (VR2 > maximo){
// caso contrario, apaga o LED
digitalWrite(L2, HIGH);
}
else {
digitalWrite(L2, LOW);
}


if (VR3 > maximo) {
// se sim, acende o LED
digitalWrite(L3, HIGH);
}
else {
digitalWrite(L3, LOW);
}

if (VR4 > maximo) {
// se sim, acende o LED
digitalWrite(L4, HIGH);
}
else {
digitalWrite(L4, LOW);
}

if (VR5 > maximo) {
// se sim, acende o LED
digitalWrite(L5, HIGH);
}
else {
digitalWrite(L5, LOW);
}

if (VR6 > maximo) {
// se sim, acende o LED
digitalWrite(L6, HIGH);
}
else {
digitalWrite(L6, LOW);
}

}

O vídeo abaixo ilustra a execução do código.

Sensores Infravermelho para Robôs de Sumo

 O projeto de robôs de sumo envolve o uso de sensores de linha, que normalmente são Infravermelhos (IR) e, sensores de distância, para identificar objetos. Os sensores de distância podem ser ultrassônicos (utilizam sons com frequências acima da audição humana) ou sensores de infravermelho. A escolha de infravermelho se deve ao custo deste em relação aos sensores de som - R$60,00 os de ultrassom, R$12,00 os IR e para fazer o sensor IR, cerca de R$5,00. A questão de fazer os sensores IR envolve a compra (TIL32 e TIL78 sofrem interferência da luza ambiente) e a montagem - o fototransistor é invertido, coisa que descobrimos do pior jeito (errando que se aprende).

 É importante destacar que o ideal é testar os sensores antes de utilizar. A estática da mão pode queimar o fototransistor e a temperatura do ferro de solda pode fazer o mesmo. O sistema proposto abaixo economiza, e muito, energia durante os combates. Não pode ser usado para medir distâncias, apesar das informações deste esquema no Multisim ter indicado que o LED IR "pisca" com uma frequencia de 24Khz. Sem um osciloscópio não arriscaria usar esse valor como referência. Se bem isolado, consegue até 10 cm de sensibilidade. 

O código abaixo pode ser utilizado para calcular a distância, mas o objetivo inicial deste código é apenas testar os 6 sensores.

/* Programa para leitura de 6 sensores IR - Projeto Robô Lutador de Sumô Equipe Pequenos Cientistas 2012

*/

int IR1=0;

int IR2=1;

int IR3=2;

int IR4=3;

int IR5=4;

int IR6=5;

int L1 = 5;

int L2 = 6;

int L3 = 7;

int L4 = 8;

int L5 = 9;

int L6 = 10;

int maximo = 400;

int VR1;

int VR2;

int VR3;

int VR4;

int VR5;

int VR6;

void setup() {

// configura o pino como saida

pinMode(L1, OUTPUT);

pinMode(L2, OUTPUT);

pinMode(L3, OUTPUT);

pinMode(L4, OUTPUT);

pinMode(L5, OUTPUT);

pinMode(L6, OUTPUT);

// configura o pino como entrada

pinMode(IR1, INPUT);

pinMode(IR1, INPUT);

pinMode(IR2, INPUT);

pinMode(IR3, INPUT);

pinMode(IR4, INPUT);

pinMode(IR5, INPUT);

Serial.begin (9600);

}

void loop(){

  

  // le o estado do botao

VR1 = analogRead(IR1);

VR2 = analogRead(IR2);

VR3 = analogRead(IR3);

VR4 = analogRead(IR4);

VR5 = analogRead(IR5);

VR6 = analogRead(IR6);

// verifica se o sensor está ativo

if (VR1 >= maximo) {

// se sim, acende o LED

digitalWrite(L1, HIGH);

}

if (VR2 >= maximo){

// caso contrario, apaga o LED

digitalWrite(L2, LOW);

}

if (VR3 >= maximo) {

// se sim, acende o LED

digitalWrite(L3, HIGH);

}

if (VR4 >= maximo) {

// se sim, acende o LED

digitalWrite(L4, HIGH);

}

if (VR5 >= maximo) {

// se sim, acende o LED

digitalWrite(L5, HIGH);

}

if (VR6 >= maximo) {

// se sim, acende o LED

digitalWrite(L6, HIGH);

}

}

Aliás, é possível utilizar este código para controlar o robô bastando substituir os leds com seus resistores por pontes H. Caso se interesse verifique nosso post anterior.

Abaixo uma sugestão de como montar uma placa com sensores IR para um robô de sumô 20x20 cm.

Consultando o site www.lusorobotica.com encontrei um procedimentos em que eles descrevem como fazer uma lagarta com correntes de bicicleta e tubos de pvc. Achei a ideia muito legal e penso em utilizar coma equipe do João Gabriel - Fenix, para o Torneio Jovem de Robótica.
http://lusorobotica.com/index.php?topic=2638.0