Primeira luta oficial entre os projetos de robótica da equipe Pequenos Cientistas: Artemis vs Osíris.
A pontuação foi combinada da seguinte forma:
2 pontos - se o robô sai sozinho da arena
4 pontos - se o robô prender o oponente por 3 segundos em um dos cantos, impedindo o movimento
10 pontos - se o robô empurrar o oponente para fora da arena.
Na contagem geral foi 2x1 para o Artemis, apesar que, depois fizemos mais alguns testes que não gravamos e terminou 4x2 para o Osiris.
Round 1
09/09/2013 - Teste do radar
Após os testes teóricos realizamos os testes práticos. O primeiro teste consistiu no sensor de ultrassom fixo e o servo motor marcando a posição. O led verde acende quando o objeto está a menos de 20 cm e a posição do servo aumenta de 10 em 10º sem delay entre os ângulos.
A fonte de alimentação do servo foi ligada separado para evitar interferência (ruído).
No segundo teste instalamos o sensor de ultrassom sobre o servo motor (deu um trabalhão pois o suporte reciclado está com problemas) e continuamos usando o mesmo aumento e a mesma distância. Resultado extremamente positivo, com o led acendendo quando o sonar encontra o objeto.
Próximo teste será no chassi com busca do objeto e ataque.
30/08/2013
Continuando o sistema de desenvolvimento de um radar para nossos robôs usando um servo de posição e um sensor de ultrassom, desenvolvemos um programa baseado nos testes anteriores usando apenas o if como base de decisão.
Primeiro determinamos 2 variáveis que trarão as informações do servo-motor:
...
int posicao;
int m;
...
(m) corresponde a posição que o motor vai ficar (servo.write) e (posicao) a leitura de posição atual do motor. Em segundo lugar determinamos como o servo vai aumentar a posição através do comando:
Ou seja, o servo aumentará de 10 em 10 graus seu ângulo até 170 graus. Por que não 180? Porque o modelo que usamos no simulador do proteus (simulino) vai só até 180. O servo que usamos vai até 225º e portanto poderemos até aumentar estes valores na prática.
Depois inserimos a variável que irá "zerar" o motor se nada for encontrado no radar:
...
if (m==180){
radar.write (0);
Serial.println ("Zerando a posicao");
m=0;
delay (500);
}
Essa foi a mais díficil pois estávamos usando (m==0) e não (m=0) o que fazia com que o motor voltasse mas não zerasse. Opcionalmente pode-se usar:
...
if (m==180){
m=0;
radar.write (m);
Serial.println ("Zerando a posicao");
delay (500);
}
...
Os (delay) utilizados foram apenas para que pudéssemos visualizar na gravação da simulação o que ocorria pois a velocidade de processamento e do (Serial.print) não deixava claro o que estava acontecendo. No programa no final desta atualização removeremos.
Depois inserimos as variáveis de controle baseados na leitura do ultrassom:
...
if (cm1>20){
....// comandos para movimentação e zerar servo anteriores
}
if (cm1<=20){
//comandos para atacar alvo
Serial.println ("Atacar alvo");
delay (1000);
}
...
Novamente colocamos o (delay) para facilitar a visualização na gravação no proteus.
Finalmente inserimos o comando de leitura do sensor de ultrassom (sonar) e criamos uma função para leitura do sensor logo após o (void loop) para assim limitar o movimento do servo se baseando na distância do alvo, conforme o programa abaixo:
//Programa Pequenos Cientistas para sistema de radar
#include <Servo.h>//biblioteca do servo motor
//Variáveis do sensor de ultrasssom
int emissor=11;// trigger pinos do sensor de ultrassom
int receptor=10; //echo pinos do sensor de ultrassom
long cm1,duracao;
//Variáveis do servo-motor
Servo radar;
int posicao;
int m;
void setup(){
//aciona os pinos do sensor de ultrassom
pinMode (emissor, OUTPUT);
pinMode (receptor, INPUT);
//pino do servo-motor
radar.attach (9);
Serial.begin (9600);
}//fim do void setup
void loop(){
//leitura do sensor de ultrassom
sonar();
//leitura da posição do servo
posicao=radar.read();
//imprime as leituras
Serial.print (cm1);
Serial.print (", ");
Serial.print (posicao);
Serial.print (", ");
Serial.println (m);
//Se o objeto estiver a mais de 20 cm
if (cm1>20){
if (m<180){
m+=10;
radar.write (m);
Serial.println ("Procurando alvo");
delay(10);
}//fim do if para movimentar o servo
if (m==180){
radar.write (0);
Serial.println ("Zerando a posicao");
m=0;
delay (500);
}// fim do if para zerar o servo
}// fim do if de distância do alvo
//Se o objeto estiver a menos de 20 cm
if (cm1<=20){
//comandos de ataque
Serial.println ("Atacar alvo");
delay (1000);
}//fim do if atacar alvo
}//fim do void loop
//Função de leitura do sensor de ultrassom
long sonar(){
digitalWrite (emissor, LOW);
delayMicroseconds (2);
digitalWrite (emissor, HIGH);
delayMicroseconds (10);
digitalWrite (emissor, LOW);
duracao=pulseIn(receptor,HIGH);
cm1=microsecondstocentimeters(duracao);
return cm1;
}
//Converte microssegundos em centímetros - velocidade do som = 1cm/29ms
long microsecondstocentimeters(long microseconds){
return microseconds/29/2;
}
_________________________________________________________________________________
Vídeo de teste:
O primeiro número é a leitura do ultrassom, o segundo a leitura da variável (posicao) - servo.read, e o terceiro número é a leitura da variável (m) que controla a posição do servo. No teste primeiro deixamos o servo buscar até o final e retornar a zero, aí simulamos um objeto e, depois, esse objeto sai da frente do sensor de ultrassom, retornando a busca normal pelo objeto.
20/06/2013 - Início do Projeto
Objetivo: desenvolver um sistema de sensor de ultrassom que localize um objeto, sem mover o chassi e, depois, o chassi se move em direção ao objeto.
Materiais:
Servo de posição HB
Sensor de ultrassom HC-SR04
Arduino Uno
Protoboard para testes
Fios wire macho macho
Chassi de teste : robô Osíris
Planejamento dos testes
1- Teste do servo motor usando o comando for (0 a 180º)
2- Teste de programa usando o sonar e o servo-motor: o servo deve se mover parando quando encontrar o objeto.
3- Teste de programa simulando o motor: o servo deve se mover até encontrar o objeto. Após encontrar o objeto luzes se acenderão simulando os motores do robô e, depois, o servo deve se posicionar em 90º, acionando um outro conjunto de luzes.
4- Teste final: o sonar será instalado no chassi Osíris e será realizado os testes de simulação de combate contra o robô Artemis.
Fase 1- Teste de uso do servo motor
Objetivo: determinar um programa de controle do servo-motor
Neste caso usamos o comando for e as instruções contidas no modelo de programa da pasta "Examples" do Arduino.
Resultado - O motor funcionou, movendo-se de 1 em 1º.
Vídeo abaixo:
Teste 2- Montagem do radar
Neste teste fizemos 9 programas diferentes sendo que, usamos o comando for, comandos if e outros para ver se conseguíamos fazer o servo localizar o objeto e parar de se mover. O teste 1, 3 e 9 foram os únicos que chegaram próximos disso, conforme vídeos abaixo:
Teste 1
Teste 3
Teste 9
Chegamos a conclusão que o melhor programa era o do "Teste 1" e, portanto trabalharíamos em aprimorá-lo para conseguir chegar ao objetivo desta etapa. Abaixo segue imagem com o fluxograma utilizado, e os links para o programa já na linguagem do Arduino.
Teste 11 - Neste teste usamos o comando if para fazer a função dos comandos que estavam distribuídos ao longo do sketch do programa 1, deixando mais próximo do fluxograma de programa que julgamos ideal, atingindo nosso objetivo nesta etapa que era do radar se mover até encontrar o objeto. Caso o objeto saísse da frente ele voltava a rotina de busca e localização. Como padrão usamos a distância de 30 cm que era a distância ideal da mesa de teste.
13/12/2013 - Atualização da garra - feita com madeira para ficar mais leve
06/12/2013 - Vídeo do teste da Garra de acrílico
19/11/2013 - Retomada do projeto de Garra
Após as 2 experiências não completas de construção da garra retomamos o projeto de Garra Robótica para os robôs de resgate. Como uma nova abordagem adquirimos 2 servo-motores de posição de 4 kgf.cm (aproximadamente 41 N.cm) e desenvolvemos um molde de papelão para o recorte das peças em acrílico (trabalho desenvolvido pelo Roselito), conforme projeto abaixo:
A partir destes desenhos buscamos desenvolve um molde para testes em capa de caderno conforme as imagens abaixo:
O teste de funcionalidade do projeto de papelão segue no vídeo abaixo:
O processo de construção das peças de acrílico já se iniciou e, em breve, os testes da garra.
10/09/2013
Após um tempo parado nós renovamos o projeto de garra robótica. Agora usamos o mesmo sistema de tração do Osíris para gerar o torque para segurar a lata.
Fotos do projeto:
Fotos dos elementos componentes do projeto:
Rodas de tração:
Motores (retirados de drives de cd´s):
Fotos da estrutura montada segurando a lata:
Após alguns ajustes de montagem foram realizados os testes práticos e o resultado foi positivo - o motor consegue segurar e levantar a lata. Falta só o guindaste.
22/05/2013 - Ainda faltam ajustes
Após revisarmos o projeto, o Richard refez a garra com algumas mudanças para melhorar o projeto. Além de adicionarmos espuma para melhorar a capacidade de preensão da garra, encurtamos os braços para aumentar a força de tração. Em relação ao código de uso para os testes, segue após o vídeo:
Código utilizado
/*Projeto de garra robótica para a Olimpíada Brasielira de Robótica usando 1 servo de posição Gardner (parabólica) para capturar um objeto*/
#include <Servo.h>
Servo servo1; //servo de altura da garra
void setup(){
servo1.attach(8); //pino do servo de altura
}
void loop(){
servo1.write (45);
delay (500);
servo1.write (90);
}
Ainda persiste o problema de não termos o borne para colocação no motor, o que deixa a garra com pouca força para segurar objetos. Achamos que este ainda é o principal problema da mesma na hora de executar o procedimento.
08/05/2013 - Revisão de projeto
Nos testes da garra usando a estrutura atual avaliamos que ela não teria força para segurar a lata por isso, revisamos o método de apreensão da lata, reduzindo os pontos móveis e diminuindo os braços da garra, com objetivo de aumentar a força de tração.
Mesmo assim o resultado não foi eficiente. Então revisando o projeto chegamos a conclusão que o melhor seria encurtar os braços da garra para aumentar a força. A lata vazia a garra segurava mas a lata com 150 gramas não tinha torque suficiente.
24/04/2013 - Construção da garra e correções de projeto
Apesar do previsto, todo projeto precisa ser revisto em sua construção. A garra, parte menos detalhada do projeto foi a que apresentou maiores problemas, até porque não há fontes com medidas ou como fazer os cálculos da garra. Usamos a experiência anterior, o projeto do 5º Grande Desafio - Garra Hidráulica e a experiência dos alunos na construção para elaborar esta nova garra, que ainda assim , precisou ser adaptada do projeto original, já que esta estaria usando um servo para abrir e fechar.
Primeiro tentamos com acrílico de régua, nas medidas do braço com 7 cm e do apoio do braço com 5 cm e ficou péssimo. Imagem do projeto abaixo. Usamos então alumínio e ainda não ficou bom, não dava a distância para coletar a lata com segurança.
Tentamos então construir com as medidas de 9 cm e 5 cm e o resultado ficou razoável. Projeto abaixo
Fotos da montagem.
Nas figuras acima o apoio do braço está ligado a peça móvel que era pra ter 4 x 4 cm mas foi alterada para 6 x 4 cm depois de alguns testes. A ideia é retornar a 4 x 4 cm após os ajustes do braço.
Ainda assim cabe um estudo das dimensões para ajustar o projeto, conforme esquema e cálculos abaixo:
O lado de um trapézio retângulo pode ser calculado pela formula:
Substituindo os valores na fórmula chegamos aos cálculos abaixo:
L = ?cm
L = √ 92 + (6 – 4)2
L = √81+(2)2
L=√81+4
L= √85
L = 9,22 cm
18/04/2013 - Construção da estrutura e programação básica da garra
Peso atual da garra: 205,2 g
Fotos da montagem estrutural da garra, com os dois motores, faltando apenas os braços de fechamento.
Programa básico para controle da garra, incluindo sensor de ultrassom para medir a distância do objeto:
/*Projeto de garra robótica para a Olimpíada Brasielira de Robótica usando 2 servos de posição Gardner (parabólica) e um sensor de distância ultrassônico HC-SR04 para capturar um objeto*/
//biblioteca do servo
#include <Servo.h>
Servo servo1; //servo de altura da garra
Servo servo2; //servo de abertura e fechamento da garra
int emissor=6; //trigger do sensor de ultrassom
int receptor=7; //echo do sensor de ultrassom
void setup(){
servo1.attach(8); //pino do servo de altura
servo2.attach(9); //pino do servo de abertura e fechamento
pinMode (emissor, OUTPUT); //trigger
pinMode (receptor, INPUT); //echo
}
void loop(){
// variáveis dos sensores
long duration, cm;
//configura o sinal para 2 microssegundos desligados e um pulso de 5 microssegundos
digitalWrite(emissor, LOW);
delayMicroseconds(2);
digitalWrite(emissor, HIGH);
delayMicroseconds(5);
digitalWrite(emissor, LOW);
//o receptor faz a leitura do estado do pino e se retorna HIGH ele informa
duration = pulseIn(receptor, HIGH);
// converte a distância
cm = microsecondsToCentimeters(duration);
//condições da garra
//objeo distante da garra
if (cm>3){
servo1.write (15);
servo2.write (0);
}
//objeto no raio de abertura da garra
if (cm<2){
servo1.write (127);
servo2.write (180);
delay (500);
servo2.write (0);
}
}
//varável de conversão de microssegundos para centímetros 29ms/cm = velocidade do som
long microsecondsToCentimeters(long microseconds)
{
return microseconds / 29 / 2;
}
17/04/2013 - Cálculos realizados
Após a análise do projeto chegamos aos seguintes resultados:
seno X = 15/9 = 0,6
Observando na tabela, chegamos ao valor do seno de 37º, valor que será usado no programa do servo.
Além disso determinamos a altura da garra usando o Teorema de Pitágoras:
152 = 92 + h2
225 = 81+ h2
h2 = 225-81
h = √144
h = 12 cm
Com posse destes dados iniciamos a construção da garra, montando um borne para conectar o eixo do motor a base da garra com placa de circuito impresso reciclada presa no centro a um parafuso que a pressiona contra o eixo do motor, conforme as fotos abaixo:
Instalação do borne no motor:
Após a instalação dos bornes, fizemos a estrutura externa da garra, composta da base e o suporte de motor e testamos fixar no chassi:
Após essa etapa, estamos montando a estrutura de fixação e suporte da garra e as pinças.
14/04/2013 - Novo Desafio - Calcular o ângulo da garra para inserir na programação
Descrição: Se a garra tem 10 cm a partir do eixo do motor angular (que faz ela subir e descer), qual o ângulo que esse motor deve ter para a garra fechar?
- A garra deve fechar no meio da lata para estabilizar bem e evitar escorregar.
Esquema abaixo:
Para tanto será necessário calcular o seno do ângulo x e convertê-lo em graus, calculando assim o ângulo de inclinação da garra. A altura do chassi até a base da garra levou em consideração a altura da roda (5cm) e a altura que a estrutura deve ter (6 cm) por conta do tamanho do servo (comprimento).
Para os cálculos:
Após realizar o cálculo, o valor pode ser convertido em graus usando a tabela:
Podemos calcular a, que corresponderia a altura da garra em relação ao chassi, e assim determinamos as medidas de projeto. Após a próxima reunião (17/04) postamos os cálculos.
12/04/2013
Descrição do projeto: uma garra robótica para uso em chassis com baixa altura (6 cm) - Osíris, Onix, EFF1520 e EMF1520 - para competições de "Resgate de Alto Risco" (OBR e Torneio Juvenil de Robótica).
Limitações (levantadas em reunião com Marcelo em 13/04):
- Peso da garra: pode fazer com que o robô se desloque para frente.
- Tamanho da garra: os chassis, apesar do tamanho, apresentam diferenças na estrutura e portanto podem apresentar problemas relacionados a posição da garra.
- Altura: junto a garra deve ser instalado um sensor de ultrassom dianteiro que pode ser afetado pela programação e pode sofrer interferência da garra.
- Problemas de programação: como montar o programa de maneira adequada.
- Localização das baterias (tem que ser fácil de retirar), arduino e placas.
Sugestões:
- Calcular o efeito alavanca da garra, bem como, o peso da garra e levar em consideração as questões de tamanho e posição da garra na etapa de elaboração de projeto (discussão abaixo).
- Programação: estabelecer um rotina apenas para o funcionamento da garra e depois inseri-la como sub-rotina na programação principal. Realizar um período de testes antes da competição (prazo final de abril).
- Como os robôs são de tamanho aproximado, se o projeto se adequar a um deles pode ser aplicado nos outros,com alguns ajustes.
Neste caso, precisamos descontar o peso do servo que está no braço potente da massa necessária para equilibrar o braço resistente, então temos:
Massa Braço Potente = m1 - peso do servo
Massa do Braço Potente = 450 - 60
Massa do Braço Potente = 390g.
Uma das questões fundamentais levantadas pelo Marcelo em nossa reunião foi como a garra irá se comportar na estrutura do chassi pois, podemos aplicar o mesmo princípio de alavanca quando esta garra for colocada. Pensando nisso discutimos e chegamos a conclusão que o ponto de apoio do chassi seria a roda dianteira e, o Braço potente, seria a distância entre a roda e a base da garra, sendo que, o braço resistente, seria a distância da garra e, a massa, o peso da lata. Se o valor da massa do braço potente for igual a massa do braço resistente teremos equilíbrio e, assim, o chassi não empinaria. Esquematicamente, partindo do Osíris como referência, temos:
Cálculos:
Peso dos motores: 218+219 g = 437 g
Peso do servo do Braço potente de garra: 60g
Peso total aproximado do braço potente: 500g
Distância dos motores até a roda: 6 cm (medição direta)
Ou seja, a garra pode ter o peso máximo de até 300 gramas. Descontando o peso da lata (150 g), temos o peso da garra estipulado em 150 g, como limite máximo.
