sábado, 31 de agosto de 2013

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

domingo, 25 de agosto de 2013

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

sexta-feira, 23 de agosto de 2013

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:
MicrocontrollerATmega328
Operating Voltage5V
Input Voltage (recommended)7-12V
Input Voltage (limits)6-20V
Digital I/O Pins14 (of which 6 provide PWM output)
Analog Input Pins6
DC Current per I/O Pin40 mA
DC Current for 3.3V Pin50 mA
Flash Memory32 KB (ATmega328) of which 0.5 KB used by bootloader
SRAM2 KB (ATmega328)
EEPROM1 KB (ATmega328)
Clock Speed16 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. 

quarta-feira, 21 de agosto de 2013

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.


domingo, 11 de agosto de 2013

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:


sábado, 10 de agosto de 2013

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

segunda-feira, 5 de agosto de 2013

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 -  c = \pi d = 2 r\ \pi, (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.