Interfase GPS-Google Maps

Transcripción

1 Cátedra de Informática Electrónica Escuela de Ingeniería Electrónica Dpto. de Sistemas e Informática Informe Proyecto Final Interfase GPS-Google Maps Legajo Alumno Firma A-2165/2 Altube, Guillermo I-0328/0 Irazabal, Sebastián V-1378/1 Vercesi, Andrés

2 Introducción: El objetivo del proyecto es utilizar un módulo GPS para recibir las coordenadas de posición locales y mostrarlas utilizando la API que brinda Google Maps. El microcontrolador obtiene datos del módulo GPS de manera serial, separa y formatea los datos relevantes y los envía a la PC mediante otro puerto serie. En la PC, un programa toma los datos enviados y utiliza la API basada en servicios Web para mostrar la localización en un mapa. Diseño: Se utilizó el microcontrolador de Freescale MCF51QE, cuyo núcleo es un microprocesador Coldfire V1 a 50Mhz a 32bit, que cuenta con dos módulos SPI para la comunicación serial con el GPS y la PC. Para el módulo GPS se utilizó el módulo de Smart Design MG-S01SP cuyas características principales son que está diseñado para el bajo consumo (Low Power) y la carencia de antena externa, además de su reducido tamaño haciéndolo ideal para dispositivos portátiles. Este módulo envía la información mediante tramas que, cada una de ellas, contiene diversa información. Nos interesa en particular la trama RMC que según la hoja de datos contiene la siguiente información:

3 Esta trama es enviada por el GPS cada 1 segundo. Para comprobar que la trama enviada contiene un dato de posición válido hay que chequear el byte Status. El diagrama en bloques del sistema es el siguiente: Internet API (Google Maps) Módulo GPS MCF51QE Hardware PC Programa en la PC Comunicación serie Comunicación serie adaptada a puerto serie Visualización en pantalla

4 Programa en el microcontrolador: Consta de dos bloques fundamentales, adquisición de datos del módulo GPS y transmisión de datos válidos a la PC. La estructura del main del programa es la siguiente: void main(void) { SOPT1_COPT = 0b00; // Deshabilito el COP enable_watchdog = 1; ddr_watchdog = 1; pin_watchdog = 1; MCF51QE_clock_config(); // TIMER // MHz => nseg // si quiero 1 mseg => MCF51QE_timer1_config(); timer_count = 0; GPS_SCI_config(); ini_gps(); PC_SCI_config(); ini_pc(); // Configuro puerto serie al GPS // Configuro puerto serie PC EnableInterrupts; for(;;) { RESET_WATCHDOG(); /* feeds the dog */ extract_rmc_position(); // Extraigo datos de posicionamiento de cadena RMC send_data_pc(); // Envio datos a PC Primero inicializamos las diversas estructuras del CPU como el watchdog timer y configuraciones del reloj del sistema. Luego inicializamos el Timer1 como contador con interrupciones habilitadas para que desborde cada 1ms, base de tiempos que usaremos para el envió de tramas por el puerto serie. Luego configuramos los puertos serie a 9600 bps y habilitamos las interrupciones de Rx para el serie conectado al GPS y las interrupciones de Tx para el serie hacia el PC (en realidad no las habilitamos ahora sino cuando queremos enviar un dato). Habilitamos las interrupciones generales y entramos en el bucle principal. En el bucle realizamos siempre tres acciones: reseteamos el timer del watchdog, llamamos a la función extract_rmc_position() que analiza los datos recibidos por el GPS en busca de datos válidos, y la función send_data_pc() que envía los datos válidos a la PC. void extract_rmc_position (void){ // Esta rutina se llama desde el LOOP principal. Sólo se va a ejecutar cuando por la serie // del GPS se termine de recibir una cadena RMC if (gps_process_rmc){ gps_process_rmc = 0; // Bajo Bandera if (timer_send_data_cnt == 0){ GPS_position = getposition(rmc_data); // Obtengo Estructura de Posicion de datos RMC timer_send_data_cnt = 5; // Dispara timer de envio

5 Aquí verificamos el estado, si ya se recibió una trama válida del GPS (gps_process_rmc=1) y se cumplió el tiempo para poder enviar datos (se hace esto para que el refresco de datos sea más pausado) entonces vamos a extraer los datos útiles de la trama recibida y la guardamos en una estructura de datos GPS_position. La misma esta descripta en la definición del programa de la siguiente forma: // Estructura de Posicion typedef struct { byte status; // Indica si es valido ('1') o invalido ('0') byte latitud[10]; // Latitud en ASCII (signo + 9) byte longitud[11]; // Longitud en ASCII (signo + 10) position_type; position_type GPS_position; La recepción y confirmación de trama válida se realiza en la rutina de interrupción de recepción de datos del GPS: interrupt void GPS_Rx_ISR (void){ // El GPS esta conectado a la SCI1 GPS_sci_status; process_gps_data(gps_sci_data); // Leo Status // Proceso Dato GPS void process_gps_data (byte dato){ if (!gps_rmc_found){ // Si no encontré la cadena RMC => La busco find_rmc(dato); // Busco cadena RMC else{ // Ya encontré la cadena RMC => Recibo los datos de posicionamiento guardar_datos_rmc(dato); // Voy guardando los datos que recibo por la serie //RMC_DATA[0] = dato; Busco el encabezado de la trama que se recibe por parte del GPS en busca de la trama que nos interesa. Esto lo realizamos con la función find_rmc(dato). Una vez encontrada la trama, vamos guardando de a byte recibido en un buffer de recepción, buscando al mismo tiempo el fin de trama. Una vez encontrados los datos válidos y separados del resto de los datos de la trama, utilizamos un contador para establecer el tiempo entre tramas válidas enviadas. El GPS envía información cada 1 seg y seteamos el contador para enviar datos a la PC cada 5 segundos (timer_send_data_cnt=5). De esta manera logramos que el refresco de datos en la PC sea lo suficientemente lento como para dar tiempo a la aplicación a refrescar el mapa vía Internet. La rutina de transmisión se realiza mediante interrupciones: void send_data_pc (void){ volatile byte i; volatile byte chksum; if (PC_send_data){ PC_send_data = 0; if (!PC_transmitting){ PC_transmitting = 1; // XOR con todos los datos, desde el comando // Bajo Bandera. Evito transmisión del buffer a medias. // Estoy por transmitir algo PC_buffer[0] = 0x01; // START BYTE PC_buffer[1] = 24; // LONGITUD de datos: CHK + CMD + 1 val + 10 lat + 11 lon // ******* Dejo lugar para el CHECKSUM PC_buffer[3] = 0xCD; // COMANDO chksum = PC_buffer[3]; // Inicializo checksum PC_buffer[4] = GPS_position.status; // VALIDEZ chksum ^= PC_buffer[4];

6 for(i=0; i<10; i++){ PC_buffer[5+i] = GPS_position.latitud[i]; // LATITUD chksum ^= PC_buffer[5+i]; for(i=0; i<11; i++){ PC_buffer[15+i] = GPS_position.longitud[i]; // LONGITUD chksum ^= PC_buffer[15+i]; PC_buffer[26] = 0x03; PC_buffer[2] = chksum; // Comienzo con el envio de datos //PC_sci_data = *PC_Tx_ptr++; para q al habilitar TX salga ese dato PC_sci_TxIRQen = 1; // STOP BYTE // CHECKSUM BYTE // Cargo el registro de datos de la SCI, // Habilito Tx IRQ Cuando la bandera PC_send_data esta en alto entro a la rutina de transmisión y levanto la bandera para indicar que hay una transmisión en curso. Los datos son enviados a la PC con un determinado formato como el siguiuente: START BYTE Inicio de la trama LONGITUD COMANDO VALIDEZ LATITUD LONGITUD STOP BYTE Longitud de Fijo en este Validez de Dato Dato Fin de la trama, fija caso los datos la en este caso siguientes trama CHEKSUM BYTE Corrección de errores interrupt void PC_Tx_ISR (void){ // La PC esta conectado a la SCI2 volatile byte* fin_ptr; if (PC_sci_TxIRQ_F){ PC_sci_status; PC_sci_data = *PC_Tx_ptr++; // Leo Status // Envio siguiente dato fin_ptr = PC_buffer; fin_ptr += 27; if (PC_Tx_ptr == fin_ptr){ // FIN DE DATOS => Deshabilito la IRQ de Tx PC_sci_TxIRQen = 0; // Deshabilito Tx IRQ PC_transmitting = 0; // Deje de Transmittir datos PC_Tx_ptr = PC_buffer; // Reseteo Puntero Transmitimos byte por byte hasta completar la trama, es decir, lleguemos al fin de la trama. Bajamos la bandera de transmisión y comenzamos nuevamente con otros datos válidos.

7 Programa en la PC: Se utilizó Visual Basic para realizar una interfaz gráfica que muestra los datos recibidos por el GPS y la API de Google Maps. La API que Google Maps provee se basa en servicios web mediante código HTML: <head> <meta http-equiv="content-type" content="text/html; charset=utf-8"/> <script src=" type="text/javascript"></script> <script type="text/javascript"> function load() {if (GBrowserIsCompatible()) {var map = new GMap2(document.getElementById("map")); map.addcontrol(new GMapTypeControl()); map.addcontrol(new GLargeMapControl()); map.setcenter(new GLatLng(-32,93633, -60, ),12); map.setmaptype(g_normal_map); </script> </head> <body onload="load()" onunload="gunload()"> <div id="map" align="center" style="width: 390; height: 395px"></div> </body> Modificando los valores de latitud y longitud, campos del objeto map, que se acceden mediante el método de acceso setcenter.