=====Competição=====

====  Introdução  ====

Para a competição, depois de alguns testes, implementamos um robô que utilizava do mesmo sistema de tiro do TP3 para derrubar as torres adversárias e, depois, avançar para o campo adversário.

==== Montagem ====

A estrutura do robô passou pro algumas mudanças. Tentamos implementar um sistema de garra, que pegasse os blocos adversários. O sistema até chegou a funcionar, mas não se mostrou eficiente para o objetivo da competição. Então a montagem do sistema de tiro implementada no TP3 foi retomada, com o acréscimo de um local para armazenar as bolas e um escudo que protegia as torres.

{{ :cursos:introrobotica:2011-2:grupo01:2011-12-12-171949.jpg?500 }}

{{ :cursos:introrobotica:2011-2:grupo01:2011-12-12-171904.jpg?500 }}

{{ :cursos:introrobotica:2011-2:grupo01:2011-12-12-171949.jpg?500 }}

====  Sensores  ====

A parte dos sensores não teve nenhum acréscimo para a competição. Continuamos com os shaft-encoders, um sensor para a linha de partida, um sensor para a luz polarizada e um sensor que identificava a cor dos blocos

{{ :cursos:introrobotica:2011-2:grupo01:09112011267.jpg?500 }}


==== Estratégia ====

A estratégia adotada pela equipe foi:

 
- Ligar apartir da luz de partida

 - Se orientar de frente para o campo adversário, pela luz polarizada

 - Se deslocar para a direita, desviando das torres

 - Andar para a frente, próximo a linha da ponte

 - Atirar as bolas, girando levemente a cada bola atirada

==== Conclusão ====

Na hora da competição, o robô dava partida, ia para a direita mas, no 1o giro, a Handyboard desligava. Esse erro nunca tinha dado antes. Testamos a carga da bateria, o atrito com o campo, o peso do robô e nada adiantava. Depois de removido o escudo e o motor que o acionava o robô voltou a funcionar o que, nos leva a crer, que o motor do escudo estava prejudicando o funcionamento da Handyboard. Retirado o escudo o robô executava todas as tarefas propostas com relativo sucesso.

Arquivo da apresentação
{{:cursos:introrobotica:2011-2:grupo01:robotica.odp|}}

==== Código ====
<code>

#include fencdr6.icb
#include fencdr5.icb

//Motores
#define  MOTOR_ESQ 1 
#define  MOTOR_DIR 2 
#define POTENCIA 34
#define SENSOR_AMBIENTE 4
#define SENSOR_POLARIZADO 2
#define VOLTA 76
#define DIST_RETA 333
#define VEL_RETA 8

#define SENSOR_PARTIDA 3
#define SENSOR_OPTICO_DIR 15
#define SENSOR_OPTICO_ESQ 14
#define MOTOR_ESCUDO 3

#define RETA_LADO 325
#define RETA 555
#define RETA_FINAL 150

#define DIR 100
#define ESQ 100

int BOTAO_START = 3;
int BOTAO_STOP = 3;

void main()
{
    int pid1,pid_start, pid_stop, pot_dir, pot_esq, escolha, fim = 0;
    pot_dir = 85;
    pot_esq = 81;
    escolha = 0;
    pid_start = pid_stop = 0;
    
    pid_start = start_process(botao_start());
    pid_stop = start_process(botao_stop());
    
    printf("Verde->START    Azul->STOP\n");
    
    while(BOTAO_START == 3 && BOTAO_STOP == 3)
      {}
    
    kill_process(pid_start);
    kill_process(pid_stop);
    
    pid1 = start_process(movimentacao(&pot_dir, &pot_esq));
    start_process(tempo(&pid1, &fim));
    while(fim != 1)
      {}
    printf("FIM.");
}
void movimentacao(int *pot_dir, int *pot_esq)
{
    int pid_faixa, j=0;
    pid_faixa=0;
    while(analog(SENSOR_PARTIDA)> 3)
      {printf("%d\n",analog(SENSOR_PARTIDA));
        sleep(0.5);}
    
    orientacao_campo();
    parar();
    reta(pot_dir, pot_esq, RETA_LADO);
    parar();
    motor(MOTOR_DIR, 100);
    motor(MOTOR_ESQ, -96);
    encoder6_counts = 0;
    while(encoder6_counts < VOLTA)
      {        
    }
    parar();
    pid_faixa = start_process(segue_faixa(pot_dir,pot_esq));
    reta(pot_dir, pot_esq, RETA);
    kill_process(pid_faixa);
    parar();
    
    start_process(escudo());
    for(j=0;j<4;j++)
      {
        motor(0,100);
        reset_system_time();
        while(seconds() < 3.0)
          { }
        motor(0,0);
        
        motor(MOTOR_DIR,75);
        encoder6_counts=0;
        while(encoder6_counts < 22)
          {}
        parar();
    }
    
    motor(MOTOR_DIR, 100);
    motor(MOTOR_ESQ, -96);
    encoder6_counts = 0;
    while(encoder6_counts < 11)
      {        
    }
    parar();
    
    
}
void tempo(int *pid1, int *fim)
{
    reset_system_time();
    while(seconds() < 60.0)
      { }
    parar();
    kill_process(pid1);
    *fim = 1;
    beep();
    beep();
    beep();
    
}
void orientacao_campo()
{
    int min1,min2,min3,min4, parada;
    int j;
    int quadrante =0;
    j=0;
    
    min1 = analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE);
    
    motor(MOTOR_DIR, 100);
    motor(MOTOR_ESQ, -96);
    
    encoder6_counts = 0;
    while(encoder6_counts < VOLTA)
      {        
    }
    min2 = analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE);
    
    encoder6_counts = 0;
    while(encoder6_counts < VOLTA)
      {   
    }
    min3 = analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE);
    
    encoder6_counts = 0;
    while(encoder6_counts < VOLTA)
      {}
    min4 = analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE);
    
    parar();
    if(BOTAO_START == 1)
      {
        printf("CAMPO VERDE BOTAO START\n");
        if(min1 <= min2 && min1 <= min3 && min1<= min4){
            parada = min1;
            quadrante = 2;}
        else if(min2 <= min1 && min2 <= min3 && min2 <= min4){
            parada = min2;
            quadrante = 3;}
        else if(min3 <= min1 && min3 <= min2 && min3 <= min4){
            parada = min3;
            quadrante = 0;}
        else{
            parada = min4;
            quadrante = 1;}
    }
    if(BOTAO_STOP == 1)
      {
        printf("CAMPO AZUL BOTAO STOP\n");
        if(min1 >= min2 && min1 >= min3 && min1>= min4){
            parada = min1;
            quadrante = 2;}
        else if(min2 >= min1 && min2 >= min3 && min2 >= min4){
            parada = min2;
            quadrante = 3;}
        else if(min3 >= min1 && min3 >= min2 && min3 >= min4){
            parada = min3;
            quadrante = 0;}
        else{
            parada = min4;
            quadrante = 1;}
    }
    else
      {
        parar();
        printf("ERRO");
    }
    
    sleep(0.5);
    
    motor(MOTOR_DIR, 100);
    motor(MOTOR_ESQ, -96);
    
    encoder6_counts = 0;
    
    for(j=0; j< quadrante; j++)
      {
        while(encoder6_counts < VOLTA)
          { }
        encoder6_counts = 0;
    }
    
    //while(encoder6_counts < 65){}
    parar();
}
void escudo()
{
    motor(MOTOR_ESCUDO,30);
    reset_system_time();
    while(seconds() < 1.0)
      { }
    motor(MOTOR_ESCUDO,0);
}
void parar()
{
    motor(MOTOR_DIR,0);
    motor(MOTOR_ESQ,0);
}
void segue_faixa(int *pot_dir, int *pot_esq)
{
    //digital(15) corresponde ao motor da direita
    //digital(14) corresponde ao motor da esquerda
    
    int mud_pot=0;
    int ant_dir =0, ant_esq=0;
    while(1)
      {
        printf("15: %d - 14: %d\n",digital(15),digital(14));
        //ecnoder 6 velocidade da direita
        
        if(digital(SENSOR_OPTICO_DIR) == 0 && digital(SENSOR_OPTICO_ESQ) == 0)
          {
            ant_dir = *pot_dir;
            *pot_dir = *pot_esq;
            *pot_esq = ant_dir;
            motor(MOTOR_DIR, *pot_esq);
            motor(MOTOR_ESQ, *pot_dir);
        }
        else if(digital(SENSOR_OPTICO_DIR) == 1 && digital(SENSOR_OPTICO_ESQ) == 0)
          {
            ant_dir = 1;
            ant_esq=0;
            if(*pot_dir >=99)
              {
                *pot_esq=*pot_esq-2;
            }
            else if(*pot_esq==1)
              {
                *pot_dir=*pot_dir+2;
            }
            else
            {
                *pot_dir=*pot_dir+2;
                *pot_esq=*pot_esq-2;
            }
        }
        else if(digital(SENSOR_OPTICO_ESQ) == 1 && digital(SENSOR_OPTICO_DIR) == 0)
          {
            ant_dir = 0;
            ant_esq = 1;
            if(*pot_esq >= 99)
              {
                *pot_dir=*pot_dir-2;
            }
            else if(*pot_dir == 1)
              {
                *pot_esq=*pot_esq+2;
            }
            else
            {
                *pot_dir=*pot_dir-2;
                *pot_esq=*pot_esq+2;
            }
        }
        //Realimenta o motor com os novos valores de potencia calculados
        motor(MOTOR_ESQ,*pot_esq);
        motor(MOTOR_DIR,*pot_dir);
    }
}


int captura_media()
{
    int valor=0;
    int i;
    valor = analog(SENSOR_AMBIENTE);
    
    for(i=0;i<100;i++)
      {
        valor = valor + analog(SENSOR_AMBIENTE);
        valor = valor/2;
    }
    return valor;
}
void reta(int *pot_dir, int *pot_esq, int dist)
{
    int sub=0;
    
    encoder6_counts = 0;
    
    //Estou considerando apenas um encoder, pois se considerar os dois pode haver conflito de valores
    //O valor 628 primeiramente foi calculado com base na mecanica do robo e depois realizado experimentos para adequar
    //Este ajuste seria interessante melhorar-lo, mas esta bem proximo, com esta condicao no while que ele anda os 30cm
    while(encoder6_counts<dist)
      {
        
        sub = encoder5_velocity - encoder6_velocity;
        //ecnoder 6 velocidade da direita
        //printf("D:%d  E:%d\n",encoder6_velocity, encoder5_velocity);
        //sleep(0.8);
        /*
             Realiza o controle da velocidade dos motores para andar em linha reta, este controle ficou bem simples.
             Tentei fazer com outras formulas para chegar ao valor otimo mas rapido, mas elas funcionavam bem em um primeiro instante e depois falhavam.
             Este metodo ficou simples mas funcional.
        */
        if(sub > 0)
          {
            if(*pot_dir == 100)
              {
                *pot_esq--;
            }
            else if(*pot_esq==1)
              {
                *pot_dir++;
            }
            else
            {
                *pot_dir++;
                *pot_esq--;
            }
        }
        else if(sub < 0)
          {
            if(*pot_esq == 100)
              {
                *pot_dir--;
            }
            else if(*pot_dir == 1)
              {
                *pot_esq++;
            }
            else
            {
                *pot_dir--;
                *pot_esq++;
            }
        }
        if(encoder6_velocity > VEL_RETA)
          {
            *pot_dir--;
            
        }
        else if(encoder6_velocity < VEL_RETA)
          {
            *pot_dir++;
        }
        if(encoder5_velocity > VEL_RETA)
          {
            *pot_esq--;
        }
        else if(encoder5_velocity < VEL_RETA)
          {
            *pot_esq++;
        }
        
        //Realimenta o motor com os novos valores de potencia calculados
        motor(MOTOR_ESQ,*pot_esq);
        motor(MOTOR_DIR,*pot_dir);
    }
}
int botao_start()
{
    while(1)
      {
        start_press();
        BOTAO_START = 1;
    }
}
int botao_stop()
{
    while(1)
      {
        stop_press();
        BOTAO_STOP = 1;
    }
}

</code>