Pequenos Cientistas se destacam em torneio de robótica

Reportagem: Jornal A Tribuna Regional 31/08/2013

Link para o Jornal: http://www.jornaltribunaregional.com.br/images/stories/edicoes/tribunareg-ed013.pdf

Resultado Torneio Juvenil de Robótica 2013 - São Paulo

Das 7 modalidades que participamos, ganhamos medalhas em 5 modalidades - 71% de eficência - e 6 medalhas - eficiência de 85%. Um resultado inesperado e acima das nossas expectativas. Só faltou a medalha de ouro...

Resultado: TJR Torneio Juvenil de Robótica 2013 - São Paulo
Sumô Tradicional - Nível II
Ouro - SPECTRUS
Prata - SDS
Bronze - TRON

Sumô MMA - Nível II
Ouro - CHALLENGERS 4
Prata - TIME 3.2
Bronze - TIME 4.1

Resgate de Alto Risco - Nível II
Ouro - SPECTRUS
Prata - LEGENDÁRIOS

Dança - Nível II
Ouro - NOVA GERAÇÃO TIAOZINHO 3

Sumô Large - Nível II
Ouro - CHALLENGERS 2
Prata - TIME 4
Bronze - TIME 3.1

Cabo de Guerra - Nível II
Ouro - FOURC1
Prata - CHALLENGERS 7
Bronze - FOURC2

Resgate no Plano - Nível II
Ouro - TRON
Prata - LCA
Bronze - SPECTRUS

Viagem - Nível II
Ouro - LEGOTEEN VCT
Prata - CHALLENGERS 13
Bronze - WINNERS JUNIOR C
Bronze - SPECTRUS

Sumô Tradicional - Nível III
Ouro - CHALLENGERS N
Prata - l1I2
Bronze - LEGOTEEN HS
*participamos mas não ganhamos medalha

Sumô MMA - Nível III
Ouro - CHALLENGERS 5
Prata - PEQUENOS CIENTISTAS EF

Resgate de Alto Risco - Nível III
Ouro - EQUIPE SHARK'S LITORAL
Prata - JAGUAR IFRJ - RESGATE
Bronze - LEGENDÁRIOS

Dança - Nível III
Ouro - PSYTRON
Prata - JAGUAR IFRJ - DANÇA
Bronze - CHALLENGERS 11

Viagem - Nível III
Ouro - CHALLENGERS 14
Prata - VIAJANTES DE VERNE
Bronze - LEGOTEEN HS VCT

Sumô Large - Nível III
Ouro - CHALLENGERS 88
Prata - TITAN

Cabo de Guerra - Nível III
Ouro - TIME 1
Prata - IFRJ JAGUAR - CABO DE GUERRA
Bronze - CHALLENGERS 8
*participamos mas não ganhamos medalha

Resgate no Plano - Nível III
Ouro - EQUIPE SHARK'S LITORAL
Prata - JAGUAR IFRJ - DONATELO

Labirinto - Nível III
Ouro - IFRJ JAGUAR - LABIRINTO

Sumô Tradicional - Nível IV
Ouro - CHALLENGERS 1
Prata - FEG-ROBÓTICA
Bronze - PEQUENOS CIENTISTAS 2

Sumô Large - Nível IV
Ouro - CHALLENGERS 3
Prata - PEQUENOS CIENTISTAS

Cabo de Guerra - Nível IV
Ouro - CHALLENGERS 9
Prata - PEQUENOS CIENTISTAS

Viagem - Nível IV
Ouro - VIAJANTES DE VERNE 2
Prata - GER
Bronze - CHALLENGERS 15

Sumô MMA - Nível IV
Ouro - CHALLENGERS 6
Prata - PEQUENOS CIENTISTAS 2
Bronze - PEQUENOS CIENTISTAS 1

Dança - Nível IV
Ouro - CHALLENGERS 12

Super Time - Cabo de Guerra
Ouro - FOURC1 e SPECTRUS
Prata - FOURC2 e CERBERUS

Prêmio de Incentivo
B.I.N.O

fonte: torneiojrobotica.org

Quanto durará a bateria em que conectamos o Arduino?

Bom primeiro precisamos buscar as informações sobre o consumo do Arduino. Para isso basta consultar o site do arduino (www.arduino.cc) e buscar o modelo, que no nosso caso é o Arduino UNO REV.3:

Microcontroller	ATmega328
Operating Voltage	5V
Input Voltage (recommended)	7-12V
Input Voltage (limits)	6-20V
Digital I/O Pins	14 (of which 6 provide PWM output)
Analog Input Pins	6
DC Current per I/O Pin	40 mA
DC Current for 3.3V Pin	50 mA
Flash Memory	32 KB (ATmega328) of which 0.5 KB used by bootloader
SRAM	2 KB (ATmega328)
EEPROM	1 KB (ATmega328)
Clock Speed	16 MHz

Pela tabela vemos que cada pino que usamos do Arduino consome 40mA. Usamos, por exemplo o Artemis, 4 pinos para os motores (l298n), 2 pinos para os sensores IR, 2 pinos para o sensor de ultrassom e 1 pino para acender um led de alerta, num total de 9 pinos, ou seja, 9 pinos vezes 40mA resultam em 360mA. 

Continuando nosso caso, temos a bateria 9V/350mAh e, usando os cálculos previstos neste post (http://cienciaemconsciencia.blogspot.com.br/2013/08/quanto-tempo-o-robo-ficara-ligado.html), temos:

Corrente     Tempo

350mA          1h

360mA            x

Uma regra de três inversamente proporcional pois quanto menor a corrente maior o tempo de duração:

x= 350/360

x= 0,97h

Partindo das informações acima temos que o Arduino funcionará com eficiência até 7V (recomendada) o que dá um consumo de 2V da bateria. Com uma outra regra de 3 chegamos ao tempo máximo de duração da bateria a cada ciclo de uso, baseado no consumo do motor:

Tensão        Tempo

 9V           0,97h

2V               x

x = 2*0,97/9

x=0,22 h

Convertendo em minutos

x = 0,22*60 = 13 min

Ou seja, usando as baterias recarregáveis que temos atualmente temos uma previsão de uso de 13 minutos.

Quanto tempo o robô ficará ligado?

Em primeiro lugar deve-se levantar as informações sobre a bateria (capacidade e corrente) e sobre a corrente do motor. Para nosso exemplo, vamos usar:

Bateria

Tensão: 11V

Corrente: 1000 mAh

Motores

Tensão: 11V

Corrente: 0,6A

A bateria lipo de 11V/1A não pode chegar a tensões menores que 3V por célula, sendo que, a bateria 11V tem 3 células (3S), portanto limite mínimo de 9V. Subtraindo a tensão máxima da bateria 11V pela tensão mínima 9V chegamos a 2V. Aplicando uma regra de 3 para calcular o tempo que o motor levaria para consumir toda a bateria chegamos em:

Corrente     Tempo

  1A              1h

  0,6A            x

Uma regra de três inversamente proporcional pois quanto menor a corrente maior o tempo de duração:

x= 1/0,6

x= 1,67h

Com uma outra regra de 3 chegamos ao tempo máximo de duração da bateria a cada ciclo de uso, baseado no consumo do motor:

Tensão        Tempo

 11V           1,67h

2V               x

x = 2*1,67/11

x=0,30 h

Convertendo em minutos

x = 0,3*60 = 18 minutos

Ou seja, para dois motores que consomem 0,6A, uma bateria 11V/1000mAh duraria 18 minutos, considerando que a bateria alimente apenas os motores diretamente. 

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.

Como fazer um robô seguidor de linha com motores de passo usando Arduino?

Um dos problemas que encontramos quando usamos o Arduino é que a biblioteca do motor de passo roda um motor de cada vez e não roda motores sincronizados. Para tanto, desenvolvemos um programa usando o While que sincronizava dois motores de passo:
/*Uso do While em motores de passo */
    //pinos de saída digital
    //passo direito
    int passo1 = 8;
    int passo3 = 9;
    int passo2 = 10;
    int passo4 = 11;
    //passo esquerdo
    int passo5 = 4;
    int passo6 = 5;
    int passo7 = 6;
    int passo8 = 7;
    //tempo de passo
    int passo = 25;
    //tempo para girar 90°
    int giro = 0;
   
    // ————————————————————————— Setup
    void setup() {
    // Seleciona motores
    //motor direito
    pinMode(passo1, OUTPUT);
    pinMode(passo2, OUTPUT);
    pinMode(passo3, OUTPUT);
    pinMode(passo4, OUTPUT);
    //motor esquerdo
    pinMode(passo5, OUTPUT);
    pinMode(passo6, OUTPUT);
    pinMode(passo7, OUTPUT);
    pinMode(passo8, OUTPUT);
    }
    // ————————————————————————— Loop
    void loop () {
while(giro<5){
      //para frente
    digitalWrite (passo4, HIGH);
    digitalWrite (passo5, HIGH);
    delay (passo);
    digitalWrite (passo4, LOW);
    digitalWrite (passo5, LOW);
    digitalWrite (passo3, HIGH);
    digitalWrite (passo6, HIGH);
    delay (passo);
    digitalWrite (passo3, LOW);
    digitalWrite (passo6, LOW);
    digitalWrite (passo2, HIGH);
    digitalWrite (passo7, HIGH);
    delay (passo);
    digitalWrite (passo2, LOW);
    digitalWrite (passo7, LOW);
    digitalWrite (passo1, HIGH);
    digitalWrite (passo8, HIGH);
    delay (passo);
    digitalWrite (passo1, LOW);
    digitalWrite (passo8, LOW);
    giro++;
}
    while (giro<5){
    //frente
    digitalWrite (passo1, HIGH);
    digitalWrite (passo8, HIGH);
    delay (passo);
    digitalWrite (passo1, LOW);
    digitalWrite (passo8, LOW);
    digitalWrite (passo2, HIGH);
    digitalWrite (passo7, HIGH);
    delay (passo);
    digitalWrite (passo2, LOW);
    digitalWrite (passo7, LOW);
    digitalWrite (passo3, HIGH);
    digitalWrite (passo6, HIGH);
    delay (passo);
    digitalWrite (passo3, LOW);
    digitalWrite (passo6, LOW);
    digitalWrite (passo4, HIGH);
    digitalWrite (passo5, HIGH);
    delay (passo);
    digitalWrite (passo4, LOW);
    digitalWrite (passo5, LOW);
  giro++;
  }
    }  

Este programa funciona bem mas a variável giro não retorna a 0 e, portanto, os motores não são reiniciados. quando colocamos isso nos comandos para seguir linha não funcionava direito, o motor ficava vibrando e não se mexia.

Para corrigir o problema, após o fim do while colocamos um comando para retornar o valor do giro a 0, permitindo que o motor de passo recomeçasse o giro:

...

    digitalWrite (passo3, LOW);
    digitalWrite (passo6, LOW);
    digitalWrite (passo4, HIGH);
    digitalWrite (passo5, HIGH);
    delay (passo);
    digitalWrite (passo4, LOW);
    digitalWrite (passo5, LOW);
  giro++;
  }//fim do while
giro=0;
    }    //fim do comando do motor

Depois disso, inserimos comandos para que o motor tivesse o passo simples (1000, 0100, 0010 e 0001) e o passo completo (1010, 0110, 0101 e 1001).
Assim temos o programa abaixo para seguir linha:
/* Programa para Projeto Robô Seguidor de Linha com 2 motores de passo sincronizados
Equipe Pequenos Cientistas 2012
*/
//variavel dos pinos analogicos
int IR1=2;
int IR2=3;
//int IR3=12;
//variáveis que armazenam os dados dos pinos
int VR1;
int VR2;
int VR3;

//variavel dos pinos digitais
//pinos de ativação dos motores
int L1 = 4;
int L2 = 5;
int L3 = 6;
int L4 = 7;
//pinos do passo
int L5 = 8;
int L6 = 9;
int L7 = 10;
int L8 = 11;
//tempo do passo
int passo = 20; //aumenta ou diminui a velocidade do motor

//valor de leitura do ir para branco
int maximo = 900;

//varíaveis que controlam o motor de passo
int passosporvolta=48;//distância que o motor percorre
int giro=0;

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);
pinMode(L7, OUTPUT);
pinMode(L8, OUTPUT);

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

Serial.begin (9600);
}
void loop(){
giro==0;
// Faz a leitura do sensor
VR1 = digitalRead(IR1);
VR2 = digitalRead(IR2);
//VR3 = digitalRead (IR3);

Serial.print (VR1);
Serial.print (" ,");
Serial.print (VR2);
Serial.print (" ,");
//Serial.print (VR3);
//Serial.print (" ,");
Serial.println (giro);

if (VR1 < maximo||VR2 < maximo) {// if para branco
Serial.println ("Branco");
Serial.println ("Frente");
frente();
}//fim do if para branco

if (VR2 >= maximo||VR2 >= maximo){//if para preto
Serial.println ("Preto");
Serial.println ("Re");
re();
Serial.println ("Direita");
direita();
}//fim do if preto
}//fim do loop

void frente(){
while (giro<passosporvolta){
digitalWrite(L1, HIGH);
digitalWrite(L5, HIGH);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, HIGH);
digitalWrite(L6, HIGH);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, HIGH);
digitalWrite(L7, HIGH);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, HIGH);
digitalWrite(L8, HIGH);
delay (passo);
giro++;
  }//fim do while
  giro=0;
}//fim da função frente
void re(){
while (giro<2*passosporvolta){
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, HIGH);
digitalWrite(L8, HIGH);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, HIGH);
digitalWrite(L7, HIGH);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, HIGH);
digitalWrite(L6, HIGH);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, HIGH);
digitalWrite(L5, HIGH);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
giro++;
Serial.println (giro);
  }//fim do while
giro=0;
}//fim da função re

void direita(){
while (giro<2*passosporvolta){
digitalWrite(L1, HIGH);
digitalWrite(L5, LOW);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, LOW);
digitalWrite(L8, HIGH);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, HIGH);
digitalWrite(L6, LOW);
digitalWrite(L3, LOW);
digitalWrite(L7, HIGH);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, LOW);
digitalWrite(L6, HIGH);
digitalWrite(L3, HIGH);
digitalWrite(L7, LOW);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, HIGH);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, HIGH);
digitalWrite(L8, LOW);
delay (passo);
giro++;
Serial.println (giro);
  }//fim do while
  giro=0;
}//fim da função direita

void esquerda(){
  while (giro<2*passosporvolta){
digitalWrite(L1, LOW);
digitalWrite(L5, HIGH);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, HIGH);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, LOW);
digitalWrite(L6, HIGH);
digitalWrite(L3, HIGH);
digitalWrite(L7, LOW);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, HIGH);
digitalWrite(L6, LOW);
digitalWrite(L3, LOW);
digitalWrite(L7, HIGH);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, HIGH);
digitalWrite(L5, LOW);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, HIGH);
digitalWrite(L8, HIGH);
delay (passo);
Serial.println (giro);
  }//fim do while
 giro=0;
 }//fim da função esquerda

void ataque(){
while (giro<passosporvolta){
digitalWrite(L1, HIGH);
digitalWrite(L5, HIGH);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, HIGH);
digitalWrite(L7, HIGH);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, HIGH);
digitalWrite(L6, HIGH);
digitalWrite(L3, HIGH);
digitalWrite(L7, HIGH);
digitalWrite(L4, LOW);
digitalWrite(L8, LOW);
delay (passo);
digitalWrite(L1, LOW);
digitalWrite(L5, LOW);
digitalWrite(L2, HIGH);
digitalWrite(L6, HIGH);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, HIGH);
digitalWrite(L8, HIGH);
delay (passo);
digitalWrite(L1, HIGH);
digitalWrite(L5, HIGH);
digitalWrite(L2, LOW);
digitalWrite(L6, LOW);
digitalWrite(L3, LOW);
digitalWrite(L7, LOW);
digitalWrite(L4, HIGH);
digitalWrite(L8, HIGH);
delay (passo);
giro++;
Serial.println (giro);
  }//fim do while
  giro=0;
}//fim da função frente

Vídeo do teste:

Mostra Nacional de Robótica 2013

A Mostra Nacional de Robótica (www.mnr.org.br) é o maior evento de robótica do ano. Reúne diversos trabalhos produzidos ao longo do ano em robótica. Possui uma versão virtual e presencial. Abaixo segue a prévia do vídeo de apresentação do projeto:

Em breve postamos a versão final e o artigo produzido. A ideia do artigo é fornecer informações de como construir um robô para resgate e sumô usando reciclagem e Arduino. Este trabalho é um resumo do que foi feito ao longo de 2012/2013 no projeto.

Sumô de robôs: Artemis vs Osíris

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

Round 2

Round 3

Qual o ângulo que o robô vai virar?

Esta postagem refere-se a uma dificuldade surgida no projeto a partir de dados reais de trabalho: precisamos saber qual é o tempo para colocar no delay e, qual o ângulo correspondente deste delay. Em resumo, precisamos que o robô vire num ângulo pré-determinado. Isso afeta as manobras não só no sumô mas no resgate também.
Primeiro precisamos de algumas informações:

1- Como o robô vira?
Para responder a esta questão temos 2 situações distintas- se o robô vira um lado de cada vez (acionamento apenas de um lado do motor) ou se vira os dois lados ao mesmo tempo (um lado para frente e o outro de ré). Se ele vira uma lado de cada vez a curva sairia mais aberta, conforme a figura 1, senão, os dois lados ao mesmo tempo, o robô viraria no próprio eixo, conforme a figura 2 e, portanto, a medida (x) seria diferente.

Figura 1 - Robô virando acionando apenas um lado

Figura 2- Robô virando acionando os dois lados

A partir desta afirmações podemos concluir que, se o robô virar com apenas um motor, a curva descreverá uma circunferência igual a 2 vezes a distância de largura do robô (largura = raio), enquanto, acionando os dois motores, a distância será igual a largura do robô (largura = diâmetro). 

2- Qual a velocidade do robô?

Velocidade é o espaço percorrido em função do tempo gasto para percorrer o trajeto, portanto pode-se determinar a velocidade do robô fazendo-o percorrer um espaço de 1 metro e medindo o tempo, em segundos, com um cronometro, obtendo o valor da velocidade em metros por segundo (m/s), unidade do Sistema Internacional.

3- O ângulo desejado.

A partir destas informações em fazendo o uso da equação que mede o comprimento da circunferência -   (fonte:wikipedia) e regra de três simples, conseguimos determinar o delay a ser inserido no robô para que ele vire no ângulo desejado. 

Para tanto vamos estudar 2 casos:

Caso 1- Robô virando de um lado apenas

Dados:

Velocidade: 0,102 m/s

Ângulo: 60º

Largura do robô: 20 cm

Convertendo velocidade de m/s em cm/s: 

0,102 x 100=10,2cm/s

Comprimento da circunferência: 

20 x 2 x 3,14 = 125,6 cm.

Ou seja, para dar uma volta completa na circunferência (360º), o robô terá de percorrer 125,6 cm, entra a regra de 3 para determinar, qual distância ele precisa percorrer para o ângulo desejado (60º):

ângulo (º)           Distância (cm)

360                     125,6

60                          x

x = (125,6 x 60)/360

x = 20,93 cm

Desta forma o robô deve percorrer 20,93cm para fazer uma curva de 60º. Basta então, dividir o a distância pela velocidade para obter o tempo e, multiplicar por mil para obter em milissegundos. Desta forma temos:

delay = (20,93/10,2) x 1000

delay = 2,052*1000

delay = 2052 ms

Ou seja, no programa deste robô, para fazer ele virar num ângulo de 60°, basta colocar um delay de 2052 ms.

Caso 2 - Robô que vira os lados

 Dados:

Velocidade: 0,102 m/s

Ângulo: 60º

Largura do robô: 20 cm

Convertendo velocidade de m/s em cm/s: 

0,102 x 100=10,2cm/s

Comprimento da circunferência: (lembrando que aqui o valor de diâmetro é igual a largura do robô)

20  x 3,14 = 62,8 cm.

Ou seja, para dar uma volta completa na circunferência (360º), o robô terá de percorrer 125,6 cm, entra a regra de 3 para determinar, qual distância ele precisa percorrer para o ângulo desejado (60º):

ângulo (º)           Distância (cm)

360                     62,8

60                          x

x = (62,8 x 60)/360

x = 10,46 cm

Desta forma o robô deve percorrer 10,46cm para fazer uma curva de 60º. Basta então, dividir o a distância pela velocidade para obter o tempo e, multiplicar por mil para obter em milissegundos. Desta forma temos:

delay = (10,46/10,2) x 1000

delay = 1,026 *1000

delay = 1026 ms

Ou seja, no programa deste robô, para fazer ele virar num ângulo de 60°, basta colocar um delay de 1026 ms.

Comparando os delays podemos concluir que um robô que aciona os dois lados para virar é mais rápido e que, em algumas situações, um ou outro sistema de curva, pode ser mais adequado.