"Interfase GPS-Google Maps" - Informe Proyecto Final
←
→
Transcripción del contenido de la página
Si su navegador no muestra la página correctamente, lea el contenido de la página a continuación
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
Informática Electrónica – Proyecto Final - 2009 Altube – Irazabal – VercesiIntroducció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:
Informática Electrónica – Proyecto Final - 2009 Altube – Irazabal – VercesiEsta 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 MCF51QE Hardware Programa
GPS PC en la PC
Comunicación Comunicación
serie serie adaptada a Visualización
puerto serie en pantalla
Informática Electrónica – Proyecto Final - 2009 Altube – Irazabal – VercesiPrograma 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
// 16.777216 MHz => 59.6046 nseg
// si quiero 1 mseg => 16777
MCF51QE_timer1_config();
timer_count = 0;
GPS_SCI_config(); // Configuro puerto serie al GPS
ini_GPS();
PC_SCI_config(); // Configuro puerto serie PC
ini_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
}
}
}
Informática Electrónica – Proyecto Final - 2009 Altube – Irazabal – VercesiAquí 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; // Leo Status
process_GPS_data(GPS_sci_data); // 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; // XOR con todos los datos, desde el comando
if (PC_send_data){
PC_send_data = 0; // Bajo Bandera. Evito transmisión del buffer a medias.
if (!PC_transmitting){
PC_transmitting = 1; // 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];
Informática Electrónica – Proyecto Final - 2009 Altube – Irazabal – Vercesifor(i=0; i
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:
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,6789001),12);
map.setMapType(G_NORMAL_MAP);
}}
Modificando los valores de latitud y longitud, campos del objeto map, que se acceden
mediante el método de acceso setCenter.
Informática Electrónica – Proyecto Final - 2009 Altube – Irazabal – VercesiTambién puede leer
