CHRONOS

 Introducción

Se  propone armar, a fin de ensamblar con la fabricación de la pista para competencia de robótica en la categoría velocistas, un sistema de cronometrado, contador de vueltas, semáforo de largada, a fin de obtener  información más precisa del rendimiento de cada uno de los robots que correrán y participarán de la competencia pudiendo así, mejorar el funcionamiento de cada uno de ellos, dándole una inmejorable posibilidad a cada diseñador y/o dueño del robot de tener en su poder, datos concretos y precisos del rendimiento de su corredor, con la posibilidad de corregir y mejorar cada robot.

Esto le dará también a la escuela un aporte fundamental ya que la misma participa de competencias nacionales donde allí se necesita el mejor funcionamiento posible del robot, pondrá a la escuela en una situación de privilegio ya que esta es una idea innovadora y muy poco aplicada a este tipo de competencias y beneficiará exponencialmente el rendimiento de los robots.

Objetivos

Nuestro proyecto son dos semáforos para la pista de robots. Se basa en un dispositivo que mida los tiempos totales, el tiempo de vuelta  y las vueltas que realice cada robot en dicha pista.

En dicha práctica se realizaron dos tipos de semáforos de diferentes tamaños, uno para que sea visible por los competidores que se colocara en la línea de largada para sensar tiempos y demás y un “semáforo central” que se encontrara en el centro de la pista para que sea visible para el público presente. Este semáforo además poseerá un parlante en la parte superior del mismo que emitirá pitidos cuando las luces del semáforo cambien de estado (de color).

Otra función de nuestro semáforo es que mediante sensores colocados en el semáforo de pista se pueden observar los tiempos y el número de vueltas de cada robot en una pantalla para que el público pueda observar lo que sucede en la pista donde se realiza dicha carrera.

Diagrama en Bloques

   La “placa central”, como su nombre lo indica es la plaqueta madre del proyecto, de allí salen todas las conexiones para que puedan funcionar de la manera más eficiente y cómoda todas las etapas que componen al proyecto, ahorrando así el espacio necesario para que la pista no sea excesivamente “invadida” con cables, plaquetas o cualquier otro elemento que pueda perjudicar el normal desarrollo de la competencia. Esta placa se ubica en el interior del semáforo principal y de allí salen todos los cables necesarios para lograr el efectivo funcionamiento de cada etapa.

El bloque “lámparas semáforo” está conectado a través de 5 cables (dos para las lámparas rojas, uno para la amarilla, uno para la verde y uno para masa) y el bloque “parlante” está conectado a través de 2 cables (alimentación), estas dos etapas forman parte del semáforo central donde la última se encuentra en la parte superior de la estructura del semáforo y la primera en su interior.

Luego se encuentra la etapa del sensado, donde está el bloque “roseta” conectado a través de un cable de ocho hilos en su interior a la placa central, de este bloque se derivan dos bloques más, uno es el de “ojos de buey” conectado a la “roseta” con cinco cables (dos para los leds rojos, uno para el amarillo, uno para el verde, y uno para GND), y el otro es el bloque “sensores” conectado a través de cuatro cables (uno para cada sensor, uno para Vcc y uno para GND), cabe destacar que esta etapa forma parte del “semáforo de la largada” cuya visibilidad estará solo afectada a los participantes de la competencia.

Por último se encuentra la etapa “conversor USB a RS-232” que de esta se deriva otra etapa llamada “PC”, esta parte del circuito será fundamental ya que todos los datos obtenidos por los sensores serán enviados a una computadora que a través del programa “Visual Basic” podrán mostrarse los tiempos de cada robot.

Diseño de Estructuras en 3D

Puente:

Usando el programa lightwave 3D hicimos un diseño de la estructura del puente. Al comienzo, el diseño era recto y robusto, con 5 varillas roscadas a 45° grados, una varilla de madera para poner las 4 luces y otra varilla de madera para poner los 2 sensores.

Luego el diseño se retoco para que tenga una curva de madera con el fin de aproximar la distancia entre las luces y los sensores. Deja de ser robusto y se usan maderas mas finas porque el tamaño era excesivo, y se achico la base para que coincida con la pista. Este fue el diseño final:

Semáforo:

El primer diseño del semáforo era un tubo cilíndrico de 125 mm de diámetro con una estructura que consta de 3 varillas roscadas que sostienen 4 estantes de madera. En cada estante hay un portalámparas.

En el siguiente diseño le agregamos una base rectangular para mantener el equilibrio del tubo y reemplazamos los portalámparas por 4 lámparas LED de auto ya que mejoramos el consumo y rendimiento. También se modifico el tubo, que ahora es de 110 mm, ya que el anterior no se conseguía. Este es el diseño final:

 Placas

Comenzamos el diseñando la placa base, primero realizamos un diagrama en bloques antes mencionado, y luego fuimos viendo cómo resolver cada parte del diagrama.

El bloque “Roseta”, se convenio utilizar un el ULN2003, que se utiliza para adaptar la corriente a la salida, hasta 500mA por línea, saliendo directamente al semáforo, y con unas resistencias a el puente.

En las salidas hacia el puente se pusieron leds en paralelo, el cálculo del mismo                             Rled= (5V – 3V) / 40mA = 50Ω = 47Ω (valor comercial)

Los leds que van al semáforo se alimentan con 12V, además del parlante, en cambio el resto se alimentan  con 5V, por lo que se utilizó un 7805 para reducir la misma.

El parlante tiene un 7809, para poder alimentar el parlante con 9V, se conectó a la salida del micro/PWM un octoacoplador 4n35 para conformar la señal cuadrara del micro, y también separ la fase

Para la comunicación por puerto RS-232 se utilizó un MAX232, conectando los capacitores de 1µF respetando las polaridades indicadas.

Le agregamos también  ICSP (In Circuit Serial Programmer), para poder programarlo mediante un programador, a través del RJ12.

Para la conexión del puente, se utilizó RJ45, conectado mediante pines a la placa, para así poder quitar los mismos si es necesario arreglar el semáforo.

Luego de realizar el circuito, y probarlo, observamos que había varios problemas por lo que, debido al poco tiempo, pusimos puentes en la placa en los siguientes lugares:

Luego de realizado la placa base, se realizaron 2 placas adicionales para los sensores, las mismas son idénticas modularmente.

                                                                         

El funcionamiento del sensor se basa en un detector de frecuencias lm567, se utilizó inicialmente un lm555 para elevar la potencia del TX infrarrojo, para aumentar el alcance del mismo, enviado así una frecuencia X, la misma rebota en la superficie, y la señal es recibida por el lm567, que detectara a partida del valor RC la frecuencia del 555, y enviara un 1 a la salida, a través de una Schmitt trigger.

Se conectará en el 567 un multivuelta de 10K para así regular con precisión la frecuencia que se recibe. También hay otro potenciómetro que regula el alcance del RX. El otro Sensor realizará lo mismo pero tendrá otra frecuencia, para así que no haya problemas de interferencias.

Luego de realizado los sensores, observamos un comportamiento inestable en relación al sensado, para solucionar este inconveniente, se optó por eliminar el lm555, y utilizar la misma frecuencia del 567 (pata 5), pasándola por un darlington, conformados por 2 transistores 2N3904 que excitan asi al TX infrarrojo, de esta manera evitamos tener que calibrar la frecuencia del lm567, basada en la frecuencia del 555, con la mejora de estabilidad de frecuencia, al no tener que calibrar la misma. Para mejorar la precisión del 567 se utilizaron resistencias al 1% y capacitores multicapa.

La frecuencia del primer sensor es de 1,4KHz y la frecuencia del segundo sensor es de 4KHz.    5,15K      2,27K 

Para el cálculo de las resistencias se utilizó la fórmula del 567   f= 1 / (1,1 . R . C)

f1= 1 / ( 1,1 . 5,15K . 100nF) ≈ 1,4KHz

ff2= 1 / (1,1 . 2,27K . 100nF) ≈ 4KHz

Quedando el circuito de la siguiente manera:

Panel de conexión

Este panel se encuentra en la parte inferior del semáforo y allí se encuentran 4 conectores: 2 RJ45, 1 DB9 y una ficha de alimentación.

Los RJ45 se utilizan, uno para programación (negro) y otro para conectarlo con la roseta del puente.

El DB9 se encarga de transmitir los datos al conversor que es conectado por USB a la PC.

La ficha de alimentación conecta el transformador de 220v rectificado, para que este nos entregue 12v 1A. Este alimenta directamente a las lámparas de led, y el resto de la placa a través de un 7805.

Programa de C

La rutina del microcontrolador, se divide en 4 pasos:

1.       Modo de calibración: Se apoyan los robots en la pista debajo de los sensores, y se van arrimando hacia adelante, hasta que el sensor lo detecte. Al detectarlo, se nos enciende una luz en el semáforo, lo que indica que hay que retroceder el robot hasta que esta se apague. Una vez apagada, esta será la posición de largada. Este paso termina al recibir las configuraciones desde la pc.

#zero_ram
void main()
{  int8 i;
   setup_adc(ADC_CLOCK_DIV_2);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_4);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DIV_BY_16,255,1);
   setup_comparator(NC_NC_NC_NC);
   disable_interrupts(INT_TIMER0);
   disable_interrupts(INT_RB);
   disable_interrupts((INT_RB0) | (INT_RB1));
   disable_interrupts(INT_EXT);
   enable_interrupts(INT_RDA);
   enable_interrupts(GLOBAL);
   setup_oscillator(OSC_4MHZ|OSC_NORMAL);  

//prueba de robot en sensor (apoyo robot en pista hasta que se apague el led correspondiente)

   flag_rx = FALSE;
   output_low(LR1);
   output_low(LR2);
   output_low(LA1);
   output_low(LV1);
  
   while(flag_rx == FALSE){
      output_high(LA1);
     
      if(input(SENSOR_A)== TRUE){
         output_high(LR1);
      }else{
         output_low(LR1);
      }
     
      if(input(SENSOR_B) == TRUE){
         output_high(LV1);
      }else{
         output_low(LV1);
      }
   }              // se repite hasta que recibo las configuraciones
   output_low(LA1); 

2.       Guardar las configuraciones: Las configuraciones constan de la duración de competencia por vueltas y por tiempo. Al recibirlas, microcontrolador las decodifica y las guarda en variables que luego van a ser utilizadas.

//espero configuración y guardo los valores
   do{
      if ((flag_rx==TRUE)&&(bufferrx[0]=='<')&&(bufferrx[5]=='>')){
         tiempo = ((bufferrx[1] - 48)*10) + (bufferrx[2] - 48);
         vueltas = ((bufferrx[3] - 48)*10) + (bufferrx[4] - 48);                                     
         printf("CONFIGURACION ELEGIDA: Minutos:%u, Vueltas:%u.\r\n",tiempo,vueltas);
         flag_configlista = TRUE;   
      }
   }while (flag_configlista == FALSE);   

3.       Largada: El dispositivo, se queda esperando el comando de largada de la computadora. Al recibirlo, se inicia la secuencia de luces del semáforo, con señales auditivas. Durante la secuencia, también se está sensando la posición del robot, para que no se adelante antes de tiempo. Si algún corredor se adelanta, la secuencia del semáforo se detiene, y se envía un comando a la pc que avisa esto, para que este nos envíe el comando de largada nuevamente.

// Si recibo el comando <L>, da comienzo la rutina de semaforo y habilito la cuenta de tiempo.
   flag_largadalista == FALSE;
   while(flag_largadalista == FALSE){     
      flag_rx = FALSE;     
      while(flag_rx == FALSE){}                        //Espera la rx de 232
      flag_temprano = FALSE;
      do{
         if(flag_temprano == TRUE){
            printf ("<T>\r\n");                   // AVISO AL MICRO PARA VOLVER A HABILITAR EL BOTON LARGADA
            flag_temprano = FALSE;
         }
         output_a(0);
         while((bufferrx[1]!='L') || flag_rx == FALSE){}         //Se larga la competencia.
         bufferrx[1]= ' ';   
         enable_interrupts((INT_RB0) | (INT_RB1));
         i = 1;
         for( i=1 ;  i<16 ; i *= 2){
            if(flag_temprano == FALSE){
               output_a(i);
                delay_ms(2000);                 
              }
            else{
                break;
            }
         }          
      }while(flag_temprano == TRUE);
                   
      enable_interrupts(INT_TIMER0);
      disable_interrupts(INT_RB0 | INT_RB1);
      flag_largadalista = TRUE;
      set_timer0(0);
      vueltascumplidasizq = 0;
      vueltascumplidasder = 0;
      delay_ms(3000);
      output_a(0);
   }
        

4.       Principal: En esta etapa, el programa se encarga de contar tiempo, y sensar las pasadas de los sensores. Cuando se sensa un corredor, se envía por el puerto serie hacia la pc el tiempo en el que cruzo el mismo con precisión de una décima de segundo.
       También se encarga revisar las variables de configuración, y chequear si cumplió la duración de carrera, o si alguno llego a la cantidad de vueltas requeridas.
       El terminar la competencia, se envía hacia la pc un comando que indica quien es el ganador y si gano por tiempo o por vueltas.

 //bucle de trabajo
   while(TRUE){
      if ((flag_rx == TRUE) && (bufferrx[1] == 'S')){    // PARADA DE EMERGENCIA ¿ LA HAGO EN INTERRUPCION?
         reset_cpu();
      }
      if(flag_sensorA == TRUE){
         flag_sensorA = FALSE;
         delay_ms(20);
         vueltascumplidasder ++; 
         printf ("<%02u:%02u:%u.0>\r\n",minutos,segundos,decimas);
         printf ("vueltas corredor der: %u\r\n",vueltascumplidasder);
      }
      if(flag_sensorB == TRUE){
         flag_sensorB = FALSE;
         delay_ms(20);
         vueltascumplidasizq ++;
         printf ("<%02u:%02u:%u.1>\r\n",minutos,segundos,decimas);
         printf ("vueltas corredor izq: %u\r\n",vueltascumplidasizq);
      }
      if(vueltas > 0){
         if (vueltascumplidasizq == vueltas){
            printf ("<W0V>\r\n");     // WIN 0 (izquierdo) por vueltas
            reset_cpu();
         }
         if (vueltascumplidasder == vueltas){
            printf ("<W1V>\r\n");     // WIN 1 (derecho) por vueltas
            reset_cpu();
         }
      }
      if (tiempo > 0){
         if(minutos >= tiempo){
            if (vueltascumplidasder > vueltascumplidasizq){
               printf ("<W1T>\r\n");     // WIN 1 (derecho) por tiempo
            }else{
               printf ("<W0T>\r\n");     // WIN 0 (izquierdo) por tiempo             
            }
            reset_cpu();
         }
      }
   }
}