El receptor GPS se utiliza para obtener ubicaciones geográficas precisas al recibir información de los satélites. Recibe información de satélites y proporciona información de ubicación en términos de latitud y longitud. Proporciona latitud y longitud con precisión de grados, minutos y segundos. Usando estas coordenadas de latitud y longitud uno puede rastrear fácilmente la ubicación en todo el mundo.
El receptor GPS proporciona salida en serie en forma de cadenas con el protocolo 0183 NMEA ( Asociación Nacional de Electrónica Marina ). Estas cadenas son recibidas en serie por una computadora host o un procesador/controlador host para mostrarlas o tomar cualquier decisión o acción. La siguiente figura muestra la salida del receptor GPS en el hiperterminal de la computadora de escritorio.
Figura 1: captura de pantalla de la aplicación HyperTerminal que muestra las cadenas del protocolo NMEA 0183 recibidas desde el receptor GPS NEO-6M
Protocolo NMEA:
El protocolo NEMA proporciona mensajes estándar y proporcionados por el receptor GPS. Algunos de los mensajes estándar emitidos por NMEA son GGA, ZDA, VTC, RMC, GSA, GSV, etc. Hay 50 mensajes NMEA, pero sólo unos pocos se aplican al receptor GPS. La longitud máxima de cada mensaje está limitada a 79 caracteres. El formato NMEA se proporciona y explica como
$IDMSG,D1,D2……Dn*CS,(CR)(LF)
- $ – indica el comienzo de cada mensaje
- ID : indica la fuente de información de navegación. En este caso será GP por el GPS.
- MSG : describe el contenido del mensaje como GGA, GSV, GSA, etc.
- , – es una separación entre datos
- D1 – Dn – son campos de datos separados por comas
- * – se utiliza para separar la suma de comprobación
- CS : el valor de la suma de comprobación en HEX
- (CR)(LF) – Su carro regresa + avance de línea que indica el final del mensaje
A partir de la notación de etiqueta inicial es posible identificar qué tipo de información estará disponible en la siguiente cadena. Como
· La cadena comienza con la etiqueta $GPGGA y proporciona hora, latitud, longitud, altitud, calidad del GPS y alguna otra información.
· La cadena comienza con la etiqueta $GPZDA y proporciona información de fecha y hora.
El proyecto en cuestión demuestra cómo obtener información de ubicación (latitud y longitud) del receptor GPS y si las coordenadas recibidas coinciden con alguna ciudad india, también mostrará el nombre de la ciudad. Utiliza un microcontrolador AT89C51 de 8 bits para obtener datos del receptor GPS y mostrarlos en la pantalla LCD. Las coordenadas de latitud y longitud se proporcionan en dos cadenas diferentes que comienzan con la etiqueta $GPRMC o la etiqueta $GPGGA. Estas cadenas están resaltadas en la figura anterior y también en la cadena donde también están resaltadas las coordenadas de latitud y longitud. Puede extraer estas coordenadas de cualquier cadena. Lo extraje de la cadena GPRMC. RMC significa Datos GNSS mínimos recomendados . La cadena GPRMC se explica con más detalle a continuación.
Formato de cadena GPRMC:
Fig. 2: Imagen que muestra el formato de cadena GPRMC que contiene información de hora, latitud y longitud del módulo GPS
La cadena completa tiene entre 65 y 70 caracteres, incluida la etiqueta de inicio. La cadena comienza con $ y comienza con la etiqueta GPRMC. Después de la etiqueta de salida, la próxima hora es GMT. Luego está la información de ubicación que incluye latitud con dirección y longitud con dirección. Hay 9 caracteres en latitud. Los dos primeros representan el grado (33 en este caso), el segundo representa el minuto (54' aquí) y después del punto decimal los últimos 4 representan los segundos (1133” aquí). La dirección de latitud sigue a la latitud y puede ser 'N' o 'S'. La longitud está representada por los siguientes 10 caracteres. Es similar a la latitud, pero hay tres dígitos (caracteres) en grado (151 en este caso). El microcontrolador extrae esta cadena de la salida del GPS, extrae detalles de la información de ubicación y la muestra en la pantalla LCD en el formato adecuado. Luego hace coincidir las coordenadas con las coordenadas de diferentes ciudades de la India. Si se encuentra una coincidencia, el nombre de la ciudad se mostrará como "es Ahmedabad" o "es Delhi".
Diagrama de bloques del sistema:
Sólo hay cuatro componentes principales del sistema.
Receptor GPS: recopila información del satélite y genera resultados en forma de diferentes cadenas. Proporciona estas cadenas como salida al microcontrolador.
MAX232 – es un chip convertidor de nivel. Convierte señales de nivel RS232 proporcionadas por el receptor GPS en señales de nivel TTL que se pueden proporcionar al microcontrolador.
Microcontrolador AT89C51: recibe todas las cadenas del receptor GPS, pero extrae solo una. Extrae información de ubicación de la cadena y la muestra en la pantalla LCD en el formato adecuado.
Panel LCD: se utiliza para mostrar información de ubicación y el nombre de la ciudad.
Fig. 3: Diagrama de bloques del rastreador GPS basado en microcontrolador 8051
Descripción y programación del circuito.
Diagrama del circuito del sistema:
( Consulte la Guía de diagramas de circuitos para el buscador de ciudades basado en microcontrolador mediante GPS y LCD )
Descripción del circuito
Como se muestra en la figura, el circuito se construye utilizando solo tres componentes principales, el chip convertidor de nivel RS232 MAX232, el microcontrolador 89C51 y el panel LCD de 16×2.
· El módulo GPS tiene tres terminales de interfaz llamados Tx, Rx y Gnd. Proporciona series de cadenas como salida en serie a través de su pin Tx. Por lo tanto, el pin Tx está conectado al pin de entrada lateral de nivel RS232 R2IN (pin 8)
· La salida se toma del pin de salida del lado de nivel TTL R2OUT (pin no. 9) y se suministra al pin de recepción en serie Rx (pin 10) del AT89C51.
· Los condensadores C1 – C4 se conectan al chip MAX232 según el circuito sugerido en su ficha técnica.
· Los pines PORT2 P2.0 – P2.7 conducen los pines de datos LCD D0 – D7. Los pines de control LCD Rs, RW y En están conectados a los pines P3.7, P3.6 y P3.5 de PORT3 respectivamente.
· Un potenciómetro de 1 KΩ está conectado al pin 3 de la pantalla LCD como se muestra para variar su brillo
· Un cristal de 12 MHz junto con dos condensadores de 22 pF están conectados a los pines de entrada del cristal 18 y 19 de AT89C51 como se muestra
· El circuito completo funciona con alimentación de 5 V
Operación del circuito:
El funcionamiento completo del circuito depende del módulo receptor GPS. El módulo receptor GPS proporciona 10 cadenas diferentes como salida que contienen diversa información como longitud, latitud, altitud, fecha, hora, velocidad, número de satélites visibles, validez de la señal recibida, intensidad de la señal, etc. carácter por carácter al microcontrolador.
El microcontrolador AT89C51 es el corazón del circuito completo. Realiza las siguientes tareas
· Recibe series de cadenas del módulo GPS.
· Extrae la cadena requerida de un montón de cadenas recibidas en tiempo real
· De la cadena extraída, también extrae información de ubicación
· Finalmente muestra esta información en el panel LCD
· Recibe continuamente datos del módulo GPS en tiempo real y actualiza la pantalla LCD cada 4 segundos
AT89C51 recibirá todas las cadenas carácter por carácter. De estas 10 cadenas, extrae la cadena que comienza con $GPRMC. Todas las demás cadenas simplemente se descartan. De la cadena después de la etiqueta $GPRMC, el microcontrolador extraerá solo la latitud y la longitud junto con su dirección.
Después de extraer la información, la muestra en el panel LCD como
- Latitud: dirección de latitud y grados-minutos-segundos
- Longitud – dirección de longitud y grados-minuto-segundo
Estas latitudes y longitudes se comparan con la latitud y longitud de las principales ciudades de la INDIA como Mumbai, Delhi, Ahmedabad, Channai, Kolkata, Bangluru, Bhopal, Pune, Jaipur, etc. y coordenadas de la ciudad), el mensaje se muestra en la pantalla LCD como "Es Ahmedabad". El nombre de la ciudad se muestra durante unos 5 segundos y nuevamente se muestran la latitud y la longitud. Por lo tanto, si el receptor GPS está estable en una ubicación de la ciudad, mostrará el nombre de la ciudad repetidamente.
Nota: En este proyecto, a modo de demostración, he utilizado coordenadas largas de la mayoría de las ciudades metropolitanas de la INDIA como Mumbai, Delhi, Bangaluru, Ahmedabad, Jaipur, etc. El nombre de la ciudad solo se mostrará cuando las coordenadas recibidas coincidan exactamente con las coordenadas especificadas en grados y minutos. Puede cambiar las coordenadas en el programa para la misma ciudad o ingresar coordenadas completamente nuevas para cualquier otra ciudad. Puede que sea mejor ingresar las coordenadas de las ciudades de cualquier estado únicamente. Por solo una ligera modificación, si uno ingresa coordenadas de diferentes puntos de referencia de la ciudad con nombres de lugares en lugar de nombres de ciudades, entonces este proyecto se puede utilizar para ubicar diferentes puntos de referencia de la ciudad.
Programa de software:
Las funcionalidades del microcontrolador se deben al programa embebido en su FLASH interno. El programa de software está escrito en lenguaje C utilizando el software KEIL (IDE). El programa se compila utilizando el compilador cruzado Keil. Cuando el programa se compila correctamente, genera un archivo HEX. Este archivo HEX se carga en el AT89C51 utilizando un programador EEPROM adecuado.
El programa C se compone de 9 funciones diferentes que se describen a continuación
Funciones de manejo de LCD
- LCD_cmd: esta función envía un comando de 8 bits (caracteres) a la pantalla LCD para inicializarla o configurarla.
- LCD_data: esta función envía datos de 8 bits (caracteres) a la pantalla LCD que se mostrarán en la pantalla.
- LCD_write_string: esta función muestra la cadena completa (mensaje) en la pantalla LCD
- Init_LCD: esta función inicializa la pantalla LCD en modo de 8 bits, 8×5 puntos/caracteres, etc.
Función de manipulación USART
- Init_usart: inicializa el USART integrado y establece la velocidad en baudios a 4800 bps
- usat_getch – devuelve un carácter (datos de 8 bits) recibido desde el puerto serie
Funciones de visualización
- display_latitude: muestra la latitud recibida en la pantalla LCD en formato de grados, minutos y segundos.
- display_longitude: muestra la longitud recibida en la pantalla LCD en formato de grados, minutos y segundos.
- get_city_name: calcula el valor de las coordenadas, lo relaciona con las coordenadas de la ciudad y, cuando se encuentra la coincidencia, muestra el nombre de la ciudad.
Junto con estas 9 funciones definidas por el usuario, existe una función principal. Inicializa los puertos como entrada o salida. Luego inicializa la pantalla LCD y USART y entra en un bucle continuo. En este bucle continuo, primero espere hasta obtener los primeros 5 caracteres como $, G, P, R, M y C. Cuando obtenga todos estos 5 caracteres en secuencia, eso significa que es la cadena requerida con la etiqueta $GPRMC. De esta cadena, una por una, extraiga la latitud y la longitud. En el formato de cadena GPS estándar, los valores requeridos se dan entre dos comas. Entonces el programa comenzará a recopilar caracteres (datos) de un coma y continuará hasta el siguiente coma. Aquí está el software completo con los comentarios necesarios.
Código fuente del proyecto
#incluir
//#definir LCD_DATA_PORT P2 //Puerto de datos LCD
bits rs = P3^7; //habilitar señal
bit rw = P3^6; //señal de lectura/escritura
sbit es = P3^5 ; // señal de selección de resistencia
valor de carácter sin firmar, lati_value(10),lati_dir, longi_value(11), longi_dir;
int sin signo t;
anular lcd_busy
{
intp;
para(p=0;p<2000;p++);
}
void LCD_cmd (cmd de carácter sin firmar)
{
lcd_busy;
rw=0;
rs=0;
P2 = cmd;
es=1;
en=0;
}
anular LCD_data (dato de caracteres sin firmar)
{
lcd_busy;
rw=0;
rs=1;
P2 = fecha;
es=1;
en=0;
}
vacío init_LCD
{
LCD_cmd(0x38); //inicialización de LCD 16X2 en modo de 8 bits
LCD_cmd(0x0E); //cursor activado
LCD_cmd(0x01);
LCD_cmd(0x80); // ---8 va a la primera línea y --0 es para la posición 0
}
anular init_USART
{
TMOD=0x20;
SCON=0x40;
TH1=0xFD;
TL1=0xFD;
TR1=1;
REN=1;
}
carácter sin firmar user_getch
{
mientras(RI==0);
IR=0;
retorno(SBUF);
}
void LCD_write_string(char *str) //tomar el valor de dirección de la cadena en pioneer *str
{
int i=0;
while(str(i)!='�') // el bucle continuará hasta que aparezcan los caracteres NULL
{
LCD_data(cadena(i)); // envío de datos en CD byte a byte
yo ++;
}
devolver;
}
vacío display_lat
{
LCD_cmd(0x80);
LCD_write_string("lt:");
LCD_data(lati_dir);
LCD_datos(0x20);
LCD_data(lati_value(0));
LCD_data(lati_value(1));
LCD_data(0xDF);
LCD_data(lati_value(2));
LCD_data(lati_value(3));
LCD_data(0x27);
LCD_data(lati_value(5));
LCD_data(lati_value(6));
LCD_data(lati_value(7));
LCD_data(lati_value(8));
LCD_data(0x22);
}
anular display_logn
{
LCD_cmd(0xC0);
LCD_write_string("lg:");
LCD_data(longi_dir);
LCD_data(longi_value(0));
LCD_data(longi_value(1));
LCD_data(longi_value(2));
LCD_data(0xDF);
LCD_data(longi_value(3));
LCD_data(longi_value(4));
LCD_data(0x27);
LCD_data(longi_value(6));
LCD_data(longi_value(7));
LCD_data(longi_value(8));
LCD_data(longi_value(9));
LCD_data(0x22);
}
retraso nulo_5sec
{
int i,j;
para(i=0;i<100;i++)
para(j=0;j<10000;j++);
}
anular get_city_name
{
valor int sin signo1, valor2, valor3;
unsigned int lati_grado,lati_minuto,longi_grado,longi_minuto;
valor1 = lati_valor(0)-0x30;
valor2 = lati_valor(1)-0x30;
lati_grado = valor1*10+valor2;
valor1 = lati_valor(2)-0x30;
valor2 = lati_valor(3)-0x30;
lati_minuto = valor1*10+valor2;
valor1 = longi_value(0)-0x30;
valor2 = longi_value(1)-0x30;
valor3 = longi_value(2)-0x30;
longi_grado = valor1*100+valor2*10+valor3;
valor1 = longi_value(3)-0x30;
valor2 = longi_value(4)-0x30;
longi_minuto = valor1*10+valor2;
if((lati_grados==28) && (lati_minutos==61) && (longi_grados==77) && (longi_minutos==23))
{
LCD_cmd(0x01);
LCD_write_string("Es una Delhi");
retraso_5seg;
}
else if((lati_grados==26) && (lati_minutos==92) && (longi_grados==75) && (longi_minutos==82))
{
LCD_cmd(0x01);
LCD_write_string("Es un Jaipur");
retraso_5seg;
}
else if((lati_grado==23) && (lati_minuto==03) && (longi_grado==72) && (longi_minuto==58))
{
LCD_cmd(0x01);
LCD_write_string("Es Ahmedabad");
retraso_5seg;
}
else if((lati_grados==18) && (lati_minutos==97) && (longi_grados==72) && (longi_minutos==82))
{
LCD_cmd(0x01);
LCD_write_string("Es Mumbai");
retraso_5seg;
}
else if((lati_grado==23) && (lati_minuto==25) && (longi_grado==77) && (longi_minuto==41))
{
LCD_cmd(0x01);
LCD_write_string("Es un Bhopal");
retraso_5seg;
}
else if((lati_grados==22) && (lati_minutos==56) && (longi_grados==88) && (longi_minutos==36))
{
LCD_cmd(0x01);
LCD_write_string("Es Calcuta");
retraso_5seg;
}
else if((lati_grados==12) && (lati_minutos==96) && (longi_grados==77) && (longi_minutos==56))
{
LCD_cmd(0x01);
LCD_write_string("Es Bangalore");
retraso_5seg;
}
else if((lati_grados==13) && (lati_minutos==8) && (longi_grados==80) && (longi_minutos==27))
{
LCD_cmd(0x01);
LCD_write_string("Es un Channai");
retraso_5seg;
}
}
int principal (vacío)
{
P2=0x00; // Puerto LCD_DATA como puerto de salida
P3=0x0F; //ctrl como salida
inicio_LCD; //inicialización de LCD
LCD_write_string("DEMOSTRACIÓN DE GPS");
LCD_cmd(0xC0);
LCD_write_string("usando AT89C51");
init_USART; // inicialización de USART
mientras(1)
{
valor=usart_getch;
si(valor=='$')
{
valor=usart_getch;
si(valor=='G')
{
valor=usart_getch;
si(valor=='P')
{
valor=usart_getch;
si(valor=='R')
{
valor=usart_getch;
si(valor=='M')
{
valor=usart_getch;
si(valor=='C')
{
valor=usart_getch; while(value!=',') // espera hasta el siguiente ","
{valor=usart_getch; } valor=usart_getch;
while(value!=',') // espera hasta el siguiente ","
{
valor=usart_getch;
} valor=usart_getch; while(value!=',') // espera hasta el siguiente ","
{
valor=usart_getch;
} lati_value(0) = usuario_getch;
valor = lati_value(0);
para(t=1;valor!=',';t++)
{
valor_lati
