Tabela de conteúdos

Trabalho Prático 2

Introdução

Esse trabalho prático visava nos familiarizar com sensores em todos os aspectos: montagem, testes de medidas, calibração e o uso correto. Além de refinar o controle PD que utilizamos no TP1 com uma nova biblioteca que aumentava a resolução na atuação dos motores. Para realizar tais tarefas devíamos adquirir um conhecimento dos tipos de sensores que utilizaríamos e comprar todos os materiais necessários para as montagens, alem de adaptar o nosso robô para poder montar os novos sensores.

Montagem dos Sensores

  1. Sensor chave óptica para seguir linha:

O primeiro passo foi a aquisição dos materiais necessários para a montagem dos sensores. Para a tarefa de seguir uma linha preta no campo, a princípio compramos um emissor de infravermelho, um receptor e um resistor de 390 ohms para montá-los em uma peça lego, porém descobrimos que esse par já era vendido montado, só precisávamos sodá-lo aos pinos e a resistência (Figura 1). Então compramos algumas chaves ópticas e resistências e as adaptamos a em algumas peças lego para podermos encaixar esses sensores em baixo do robô.

Figura(1)

  1. Sensor Diferencial:

O segundo sensor a ser montado foi o diferencial, que consiste em dois ldr's soldados de certa forma que caso um deles seja sensibilizado um tensão perto da máxima aplicada nesse sensor será posta na saída, caso o outro seja sensibilizado um tensão próxima de zero será a saída e caso ambos sejam sensibilizados haverá um valor intermediário (Figura 2). Para que esse sensor diferenciasse uma luz polarizada em um sentido de outra polarizada no sentido ortogonal a primeira, colocamos polarizadores em frente a cada um desses sensores, um polarizador na vertical e outro na horizontal (Figura 3). Além desses ldr's montados como um sensor diferencial, adicionamos um terceiro ldr apenas para captar a luz ambiente (Figura 4).

Figura(2)

Figura(3)

Figura(4)

  1. Sensor Break Beam

Com o emissor e o receptor de infravermelho que havíamos comprado para fazer o sensor de seguir linha, fizemos um sensor break beam (Figura 5) para captar a presença de um objeto na frente do nosso robô. O funcionamento desse sensor é o mesmo das chave ópticas, porem o posicionamento do emissor e receptor mudam. Eles são dispostos com o receptor de um lado e o emissor do outro assim quando algo interrompe o feixe do emissor até o receptor indica que há algum objeto na frente do robô.

Figura(5)

  1. Sensor de Identificação de Luz

Esse era o sensor mais complexo a ser montado, adotamos como modelo o sensor disponibilizado no site da disciplina. Usamos quatro leds de alta luminosidade: um azul, um vermelho e dois verdes, além de um ldr e uma resistência de 390 ohms. Então adaptamos uma peça de lego para colocarmos o ldr no centro e os quatro leds – um em cada canto (Figura 6). Contudo após realizarmos alguns testes percebemos que o ldr estava muito exposto a luz ambiente e também a luminosidade proveniente da parte de trás do sensor como um todo. Então fizemos uma nova montagem isolando completamente o ldr dentro de uma pequena peça de lego e o sensor como um todo com uma capa também feita de peças modificadas.

Figura(6)

Adaptações no robô

Após as montagens de casa sensor, adaptamos o robô para instalá-los. Os sensores para seguir a linha foram dispostos na parte frontal do robô em uma estrutura, que os posicionou bem perto do solo. O sensor break beam foi construído em dois novos “braços” montados na frente do robo. Com a montagem do break beam na frente do robô, colocamos também o sensor para identificação de cores nessa parte, para poder identificar a cor do objeto quem sensibilizasse o sensor break beam. E o sensor diferencial também foi disposto na parte fronta do robô, porem ficou acima de todos os outros para poder captar melhor as luzes polarizadas.

Estrutura frontal para receber o sensor de identificação de cor e sensores de linha.

Primeiro modelo de sensor de identificação de cor acoplado ao robô.

Sensor de identificação de cor e sensores de seguir linha montados na estrutura do robô.

Sensores para seguir linha na parte inferior do robô.

Última montagem do robô com o sensor diferencial na parte frontal superior, os sensores de seguir linha na parte inferior, o breal beam montado nos “braços” e no mesmo nível o modelo final do sensor de identificação de cor.

Caracterização do sensor

A princípio testamos nosso sensor utilizando um dos blocos amarelos, os primeiros teste foram feitos com um caixa para tentar cobrir toda a interferência da luz ambiente, depois medimos com os motores ligados e por fim medimos com a interferencia de luz ambiente.

Como podemos observar os motores influem nas medidas gerando uma pequena diferença em relação ao primeiro grafico, mas de forma bem fraca. Já quando a interferência da luz ocorre uma maior problema com as medidas. Após esses testes realizamos os testes com o objeto em distâncias diferentes.

Observamos que existe uma distãncia ideal para o sensor identificar melhor os objetos, se ele estiver muito próximo ao objeto os feixes emitidos não serão bem captas e no outro extremo se o objeto estiver muito longe os feixes emitidos se dispersarão e pouca intensidade será captada.

Tarefas

  1. Seguir linha

Para essa tarefa usamos dois sensores de chave ópticas, cada um posicionado de forma a estar em uma das extremidades da linha. Como esses sensores são digitais o programa para realizar essa tarefa foi bem simples e o primeiro a ser implementado. Quando um dos sensores passava o estado de ativo, estava na parte branca da mesa, a potência do motor desse lado onde o robô estava saindo fora da linha era incrementada em duas unidades e a outra decrementada. Assim o robô ajustava sua posição sempre para ficar dentro da linha e corrigindo de forma suave para evitar muito zigue zague.

  1. Seguir luz polarizada

Nessa tarefa usamos o sensor diferencial para que o robô pudesse identificar onde estava cada uma das luzes polarizadas, o ldr para captar a luz ambiente e os shaft encoder do primeiro trabalho prático para contar a posição e a rotação do robô. Realizava-se alguns giros em torno de uma das rodas e enquanto isso captava a intensidade da luz ambiente com o ldr e da luz polarizada com o sensor diferencial, alem de calcular a rotação. Assim da diferença entre os valores da luz ambiente e polarizada e numero de counts do encoder o robô poderia identificar em que posição estava a luz polarizada desejada e realizar um giro de volta para essa posição e seguir rumo a essa luz.

  1. Identificar cor

Essa tarefa foi a mais difícil de ser implementada, pois o nosso sensor para identificar cor a princípio estava muito susceptível a luz ambiente devido a sua montagem mal planejada. Após corrigirmos esses erros o sensor passou a ser mais confiável e a operar de forma eficiente. A princípio o robô estava em movimento (seguindo a linha) e então ao perceber que havia algum objeto em sua frente, utilizando o break beam, ele parava para medir a cor desse objeto. A principio media-se o valor da luz ambiente e então piscava-se um led de cada vez medindo os valores para cada tipo de luz emitida. Então cada medida era subtraída da luz ambiente e a porcentagem de cada tipo de luz (verde, vermelho e azul) era encontrada. Como cada objeto de um tipo de cor tem porcentagens especificas, com os valores dos testes para serem usados como comparação o robô pode identificar cada um dos objetos.

Conclusão

Ao termino do trabalho percebemos a importância dos sensores em um robô, eles são o meio pelo qual o controlador interpreta as diferentes condições do meio onde se encontra. Da mesma forma que os sensores são importantes, eles também são complexos, a calibração para o bom funcionamento dos sensores demandou muito tempo e dedicação do grupo, apesar disso realizamos bem o trabalho prático e ao fim todas as tarefas foram realizadas corretamente.

Código

#include fencdr6.icb #include fencdr5.icb

#define VEL_RETA 12 #define DIST_RETA 75 #define DIST_ANGULO 64

#define POTENCIA 34

Velocidade para cada motor #define DIR 34 #define ESQ 37 #define GIRA_C 40 Sensores e portas #define SENSOR_DIFERENCIAL 3 #define SENSOR_OPTICO_DIR 15 #define SENSOR_OPTICO_ESQ 14 #define SENSOR_OPTICO_FRONTAL 13 #define SENSOR_AMBIENTE 3 #define SENSOR_POLARIZADO 2

Motores #define MOTOR_ESQ 1 #define MOTOR_DIR 2 Endereco de memoria de cada saida para os LEDs #define END_VERDE 0b00100000 #define END_VERMELHO 0b00000100 #define END_AZUL 0b00001000 #define END 0x1009

Funcoes #define F_RETO 1 #define F_PARAR 2 #define F_ESQUERDA 3 #define F_DIREITA 4 #define VOLTA 650 int BOTAO_START = 0; int BOTAO_STOP = 0; void main() { int pot_esq = ESQ, pot_dir=DIR, pid_parada=0, pid_segue_faixa=0, pid=0, polarizada=0, amarelo, verde, vermelho, azul; float total_tempo[4], tempo=0.0; int pid_start,pid_stop; amarelo = verde = vermelho = azul = 0; sleep(1.5); pid_start = start_process(botao_start()); pid_stop = start_process(botao_stop()); while(1) { printf(“Seguir Faixa?\n”); while(1) { if(BOTAO_START == 1) { BOTAO_START = 0; parar(); sleep(1.5); motor(MOTOR_DIR, pot_dir); motor(MOTOR_ESQ, pot_esq); kill_process(pid_stop); kill_process(pid_start); pid_segue_faixa = start_process(segue_faixa(&pot_dir, &pot_esq)); } else if(BOTAO_STOP == 1) { BOTAO_STOP = 0; if(pid_segue_faixa != 0) kill_process(pid_segue_faixa); parar(); break; } } printf(“Seguir Luz Polarizada?\n”); while(1) { if(BOTAO_START) { BOTAO_START = 0; parar(); printf(“Horizontal→START Vertical→STOP”); while(1) { if(BOTAO_START) { BOTAO_START = 0; polarizada = 0; kill_process(pid_stop); kill_process(pid_start); pid = start_process(segue_luz_polarizada(polarizada,&pot_dir, &pot_esq)); printf(“Horizontal.\n”); break; } else if (BOTAO_STOP) { BOTAO_STOP = 0; polarizada = 1; kill_process(pid_stop); kill_process(pid_start); pid = start_process(segue_luz_polarizada(polarizada,&pot_dir, &pot_esq)); printf(“Vertical.\n”); break; } } } else if(BOTAO_STOP) { BOTAO_STOP = 0; if(pid != 0) kill_process(pid); pid = 0; parar(); break; } } printf(“Identificar Blocos?\n”); while(1) { if(BOTAO_START) { BOTAO_START = 0; tempo = 0.0; printf(“Bloco VERDE, funcao: Parar?\n”); verde = escolha_bloco(&tempo); total_tempo[0] = tempo; tempo = 0.0; printf(“Bloco VERMELHO, funcao: Parar?\n”); vermelho = escolha_bloco(&tempo); total_tempo[1] = tempo; tempo = 0.0; printf(“Bloco AZUL, funcao: Parar?\n”); azul = escolha_bloco(&tempo); total_tempo[2] = tempo; tempo = 0.0; printf(“Bloco AMARELO, funcao: Parar?\n”); amarelo = escolha_bloco(&tempo); total_tempo[3] = tempo; kill_process(pid_stop); kill_process(pid_start); pid_segue_faixa = start_process(segue_faixa(&pot_dir, &pot_esq)); pid_parada = start_process(sensor_parada(&pid_segue_faixa, &pot_dir, &pot_esq, verde, vermelho, amarelo, azul, total_tempo)); } else if(BOTAO_STOP) { BOTAO_STOP = 0; if(pid_segue_faixa != 0) kill_process(pid); if(pid_parada !=0) kill_process(pid_parada); parar(); break; } } } } int escolha_bloco(float *tempo) { int opcao=0; while(1) { if(BOTAO_START) { BOTAO_START = 0; opcao = F_PARAR; break; } else if(BOTAO_STOP) { BOTAO_STOP = 0; printf(“Contornar a ESQUERDA?\n”); while(1) { if(BOTAO_START) { BOTAO_START = 0; opcao = F_ESQUERDA; break; } else if (BOTAO_STOP) { BOTAO_STOP = 0; printf(“Contornar a DIREITA?\n”); while(1) { if(BOTAO_START) { BOTAO_START = 0; opcao = F_DIREITA; break; } else if(BOTAO_STOP) { BOTAO_STOP = 0; *tempo = 0.0; printf(“Seguir em frente?\n”); while(1) { if(BOTAO_START) { BOTAO_START = 0; while(1) { printf(“START(+1)- STOP - Tempo: %d\n”,*tempo); if(BOTAO_START) { BOTAO_START = 0; *tempo++; } else if(BOTAO_STOP) { BOTAO_STOP = 0; opcao = F_RETO; break; } sleep(0.3); } } else if(BOTAO_STOP) { BOTAO_STOP = 0; break; } } break; } } break; } } break; } } return opcao; } void sensor_parada(int *pid_segue_faixa, int *pot_dir, int *pot_esq, int verde, int vermelho, int amarelo, int azul, float total_tempo[]) { while(1) { if(digital(SENSOR_OPTICO_FRONTAL) == 0 && *pot_dir !=0 && *pot_esq != 0) { kill_process(*pid_segue_faixa); *pot_dir = 0; *pot_esq = 0; *pid_segue_faixa = 0; motor(MOTOR_ESQ,*pot_esq); motor(MOTOR_DIR,*pot_dir); identifica_bloco(verde, vermelho, amarelo, azul, total_tempo, pot_dir, pot_esq); } else if(*pot_dir == 0 && *pot_esq == 0 && digital(SENSOR_OPTICO_FRONTAL) == 1 && *pid_segue_faixa == 0) { *pot_esq = ESQ; *pot_dir = DIR; motor(MOTOR_ESQ,*pot_esq); motor(MOTOR_DIR, *pot_dir); *pid_segue_faixa = start_process(segue_faixa(pot_dir, pot_esq)); } } } 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) == 1 && digital(SENSOR_OPTICO_ESQ) == 1) || (digital(SENSOR_OPTICO_DIR) == 0 && digital(SENSOR_OPTICO_ESQ) == 0))
        {
          if(*pot_dir != *pot_esq && (ant_dir != ant_esq))
            {
              ant_dir =0;
              ant_esq =0;
              mud_pot = *pot_dir;                                                                                
              *pot_dir = *pot_esq;
              *pot_esq = mud_pot;
          }
          else
            {
              *pot_dir = DIR;
              *pot_esq = ESQ;
          }
      }
      else if(digital(SENSOR_OPTICO_DIR) == 0 && digital(SENSOR_OPTICO_ESQ) == 0)
        {
          *pot_dir = DIR;
          *pot_esq = ESQ;
          motor(MOTOR_DIR, *pot_dir);
          motor(MOTOR_ESQ, *pot_esq);
      }
      else if(digital(SENSOR_OPTICO_DIR) == 1)
        {
          ant_dir = 1;
          ant_esq=0;
          if(*pot_dir == 100)
            {
              *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)
        {
          ant_dir = 0;
          ant_esq = 1;
          if(*pot_esq == 100)
            {
              *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 identifica_bloco(int verde, int vermelho, int amarelo, int azul, float total_tempo[], int *pot_dir, int *pot_esq) {

  int media[4], totalmedia, comparacao[4], valor, j, opcao = 0, t;
  bit_clear(END,0b11111111);
  
  media[0] = captura_media();
  
  //Liga LED Verde
  bit_set(END, END_VERDE);
  sleep(1.0);
  
  media[1] = captura_media();
  
  bit_clear(END,0b11111111);
  
  //Liga LED Vermelho
  bit_set(END, END_VERMELHO);
  sleep(1.0);
  media[2] = captura_media();
  bit_clear(END,0b11111111);
  
  //Liga LED Azul
  bit_set(END, END_AZUL);
  sleep(1.0);
  media[3] = captura_media();
  bit_clear(END,0b11111111);
  
  media[0] = 255 - media[0];
  media[1] = 255 - media[1];
  media[2] = 255 - media[2];
  media[3] = 255 - media[3];
  
  
  comparacao[0] = media[1]+media[0]+media[2]+media[3];
  comparacao[1] = media[1]*100/comparacao[0];
  comparacao[2] = media[2]*100/comparacao[0];
  comparacao[3] = media[3]*100/comparacao[0];
  
  // printf("%d  -  %d  -  %d\n",comparacao[1], comparacao[2], comparacao[3]);
  
  
  if(comparacao[2] > comparacao[1] && comparacao[2] > comparacao[3] )
    {
      printf("Bloco VERMELHO.\n");
      opcao = vermelho;
      t = 1;
  }
  else if(comparacao[1] > comparacao[2] && comparacao[1] > comparacao[3] && (comparacao[1]-comparacao[2]) > 4)
    {
      printf("Bloco VERDE.\n");
      opcao = verde;
      t = 0;
  }
  else if(comparacao[3] >= comparacao[1] && comparacao[3] > comparacao[1] )
    {
      printf("Bloco AZUL.\n");
      opcao = azul;
      t = 2;
  }
  else if(comparacao[1] > comparacao[2] && comparacao[1] > comparacao[3] && (comparacao[1]-comparacao[2]) < 4 || comparacao[1] == comparacao[2])
    {
      printf("Bloco AMARELO.\n");
      opcao = amarelo;
      t = 3;
  }
  sleep(1.0);
  
  switch(opcao)
    {
      case F_RETO:
        reto_tempo(total_tempo[t], pot_dir, pot_esq);
      break;
      case F_DIREITA:
        contorna_direita(pot_dir, pot_esq);
      break;
      case F_ESQUERDA:
        contorna_esquerda(pot_dir, pot_esq);
      break;
      case F_PARAR:
        parar();
      break;
  }

} void parar() {

  motor(MOTOR_DIR,0);
  motor(MOTOR_ESQ,0);

} void reta(int *pot_dir, int *pot_esq) {

  int sub=0;
  
  while(1)
    {
      
      sub = encoder5_velocity - encoder6_velocity;
      //ecnoder 6 velocidade da direita
      
      /*
           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 segue_luz_polarizada(int escolha, int *pot_dir, int *pot_esq) {

  int min, max, posicao=0, pid_reta = 0;
  min=max=0;
  
  motor(MOTOR_DIR, 0);
  motor(MOTOR_ESQ, 0);
  
  encoder6_counts = 0;
  min = max = analog(SENSOR_POLARIZADO)-analog(SENSOR_AMBIENTE);
  
  motor(MOTOR_DIR,POTENCIA);
  motor(MOTOR_ESQ, 0);
  
  while(encoder6_counts < VOLTA)
    {
      if(min > (analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE)))
        {
          min = analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE);
          encoder6_counts = 0;
      }
      if(max < (analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE)))
        {
          max = analog(SENSOR_POLARIZADO)-analog(SENSOR_AMBIENTE);
      }
  }
  motor(MOTOR_DIR,0);
  motor(MOTOR_ESQ,0);
  sleep(1.5);
  posicao = encoder6_counts;
  encoder6_counts = 0;
  motor(MOTOR_ESQ,0);
  motor(MOTOR_DIR,POTENCIA);
  encoder6_counts = 0;
  
  while(encoder6_counts < VOLTA)
    {
      if(((analog(SENSOR_POLARIZADO)-analog(SENSOR_AMBIENTE)) <= min && escolha == 0) || ((analog(SENSOR_POLARIZADO)-analog(SENSOR_AMBIENTE)) == max && escolha == 1))
        {
          encoder6_counts = VOLTA+10;
      }
  }
  
  motor(MOTOR_DIR ,0);
  motor(MOTOR_ESQ ,0);
  
  *pot_dir = DIR;
  *pot_esq = ESQ;
  
  reset_system_time();
  pid_reta = start_process(reta(pot_dir, pot_esq));
  while(seconds()<= 2.1)
    { }
  kill_process(pid_reta);
  
  
  if(posicao != 0)
    return  start_process(controle_luz_polarizada(pot_dir, pot_esq, escolha));
  else
    return 0;

} int captura_media() {

  int valor=0;
  int i;
  valor = analog(SENSOR_DIFERENCIAL);
  
  for(i=0;i<100;i++)
    {
      valor = valor + analog(SENSOR_DIFERENCIAL);
      valor = valor/2;
  }
  return valor;

}

void angulo_reto(int direcao) {

  parar();
  //Desligo os motores e dou um sleep, pois percebi que sem fazer isto os motores as vezes desligavam ou davam um tranco muito forte
  //Antes e depois de "realizar" o angulo reto desligo os motores e dou um sleep para evitar deslizamentos e trancos desnecessarios que atrapalhavam o desenho
  sleep(0.5);
  encoder6_counts = 0;
  
  if(direcao == 0)
    {
      motor(MOTOR_ESQ,-76);
      motor(MOTOR_DIR, 80);
  }
  else
    {
      motor(MOTOR_ESQ, 80);
      motor(MOTOR_DIR,-76);
  }
  while(encoder6_counts<DIST_ANGULO)
    {}
  parar();
  
  sleep(0.5);

} void contorna_direita(int *pot_dir, int *pot_esq) {

  int pid=0, pid2=0;
  parar();
  sleep(0.5);
  motor(MOTOR_DIR,-DIR);
  motor(MOTOR_ESQ, -ESQ);
  
  encoder5_counts=0;
  while(encoder5_counts < (DIST_RETA/3)+10)
    { }
  
  parar();
  angulo_reto(1);
  
  encoder5_counts=0;
  pid = start_process(reta(pot_dir, pot_esq));
  while(encoder5_counts < DIST_RETA)
    {}
  kill_process(pid);
  
  parar();
  
  angulo_reto(0);
  pid = start_process(reta(pot_dir, pot_esq));
  
  encoder5_counts = 0;
  while(encoder5_counts < DIST_RETA*3)
    { }
  kill_process(pid);
  
  parar();
  
  angulo_reto(0);
  pid = start_process(reta(pot_dir, pot_esq));
  encoder5_counts = 0;
  while(encoder5_counts < DIST_RETA)
    { }
  kill_process(pid);
  
  parar();
  
  pid2 = start_process(segue_faixa(pot_dir, pot_esq));
  angulo_reto(1);

}

void contorna_esquerda(int *pot_dir, int *pot_esq) {

  int pid=0, pid2=0;
  parar();
  sleep(0.5);
  motor(MOTOR_DIR,-DIR);
  motor(MOTOR_ESQ, -ESQ);
  
  encoder5_counts=0;
  while(encoder5_counts < DIST_RETA/3)
    { }
  
  parar();
  angulo_reto(0);
  
  encoder5_counts=0;
  pid = start_process(reta(pot_dir, pot_esq));
  while(encoder5_counts < DIST_RETA)
    {}
  kill_process(pid);
  
  parar();
  
  angulo_reto(1);
  pid = start_process(reta(pot_dir, pot_esq));
  
  encoder5_counts = 0;
  while(encoder5_counts < DIST_RETA*3)
    { }
  kill_process(pid);
  
  parar();
  
  angulo_reto(1);
  pid = start_process(reta(pot_dir, pot_esq));
  encoder5_counts = 0;
  while(encoder5_counts < DIST_RETA)
    { }
  kill_process(pid);
  
  parar();
  
  pid2 = start_process(segue_faixa(pot_dir, pot_esq));
  angulo_reto(0);

} void reto_tempo(float tempo, int *pot_dir, int *pot_esq) {

  int pid_reta = 0;
  
  reset_system_time();
  pid_reta = start_process(reta(pot_dir, pot_esq));
  while(seconds ()<= tempo)
    { }
  kill_process(pid_reta);
  parar();

} void controle_luz_polarizada(int *pot_dir, int *pot_esq, int escolha) {

  int min, max, pid_reto=0;
  float t = 1.85;
  
  while(1)
    {
      reset_system_time();
      pid_reto = start_process(reta(pot_dir, pot_esq));
      while(seconds() < 2.0)
        { }
      kill_process(pid_reto);
      parar();
      sleep(0.5);
      
      motor(MOTOR_DIR, POTENCIA);
      motor(MOTOR_ESQ, 0);
      min = max = analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE);
      encoder6_counts = 0;
      while(encoder6_counts<GIRA_C)
        {
          if(min > (analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE)))
            {
              min = analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE);
              encoder6_counts = 0;
          }
          if(max < (analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE)))
            {
              max = analog(SENSOR_POLARIZADO)-analog(SENSOR_AMBIENTE);
          }
      }
      parar();
      
      motor(MOTOR_DIR, -POTENCIA);
      motor(MOTOR_ESQ, 0);
      encoder6_counts=0;
      while(encoder6_counts<GIRA_C*2)
        {
          if(min > (analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE)))
            {
              min = analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE);
              encoder6_counts = 0;
          }
          if(max < (analog(SENSOR_POLARIZADO) - analog(SENSOR_AMBIENTE)))
            {
              max = analog(SENSOR_POLARIZADO)-analog(SENSOR_AMBIENTE);
          }
      }
      parar();
      
      motor(MOTOR_DIR, POTENCIA);
      motor(MOTOR_ESQ,0);
      encoder6_counts = 0;
      while(encoder6_counts < GIRA_C*2)
        {
          if(((analog(SENSOR_POLARIZADO)-analog(SENSOR_AMBIENTE)) <= min && escolha == 0) || ((analog(SENSOR_POLARIZADO)-analog(SENSOR_AMBIENTE)) == max && escolha == 1))
            {
              encoder6_counts = (GIRA_C*2)+10;
          }
      }
      encoder6_counts;
      parar();
      
      
  }

}

int botao_start() {

  while(1)
    {
      start_press();
      BOTAO_START = 1;
  }

} int botao_stop() {

  while(1)
    {
      stop_press();
      BOTAO_STOP = 1;
  }

}