O receptor GPS é usado para obter localizações geográficas precisas, recebendo informações de satélites. Recebe informações de satélites e fornece informações de localização em termos de latitude e longitude. Fornece latitude e longitude com uma precisão de graus-minuto-segundo. Usando essas coordenadas de latitude e longitude pode-se facilmente rastrear a localização em todo o globo.
O receptor GPS fornece saída serial na forma de strings com NMEA (Associação Nacional de Eletrônica Marinha) Protocolo 0183. Essas strings são recebidas serialmente por um computador host ou processador/controlador host para exibição ou para tomar qualquer decisão ou ação. A figura a seguir mostra a saída do receptor GPS no hiperterminal do computador desktop.
Figura 1: Captura de tela do aplicativo HyperTerminal mostrando cadeias de protocolo NMEA 0183 recebidas do receptor GPS NEO-6M
Protocolo NMEA:
O protocolo NEMA fornece mensagens padrão e fornecidas pelo receptor GPS. Algumas das mensagens padrão emitidas pelo NMEA são GGA, ZDA, VTC, RMC, GSA, GSV, etc. Existem 50 mensagens do NMEA, mas apenas algumas são aplicadas ao receptor GPS. O comprimento máximo de cada mensagem é limitado a 79 caracteres. O formato do NMEA é fornecido e explicado conforme
$IDMSG,D1,D2……Dn*CS,(CR)(LF)
- $ – indica o início de cada mensagem
- EU IA – indica a fonte das informações de navegação. Neste caso será GP por causa do GPS
- MSG – descreve o conteúdo da mensagem como GGA, GSV, GSA etc.
- , – é uma separação entre dados
- D1 – Dn – são campos de dados separados por vírgula
- *– é usado para separar checksum
- CS – seu valor de soma de verificação em HEX
- (CR)(LF) – Seus retornos de carro + avanço de linha que indica o fim da mensagem
A partir da notação da tag inicial pode-se identificar que tipo de informação estará disponível na string seguinte. Como
· A string começa com a tag $GPGGA e fornece hora, latitude, longitude, altitude, qualidade do GPS e algumas outras informações
· A string começa com a tag $GPZDA e fornece informações de data e hora
O projeto em questão demonstra como obter informações de localização (latitude e longitude) do receptor GPS e se as coordenadas recebidas corresponderem a qualquer cidade indiana, também exibirá o nome da cidade. Ele usa microcontrolador AT89C51 de 8 bits para obter dados do receptor GPS e exibi-los no LCD. As coordenadas de latitude e longitude são fornecidas em duas strings diferentes que começam com a tag $GPRMC ou a tag $GPGGA. Essas strings estão destacadas na figura acima e também na string onde estão as coordenadas latitude-longitude que também estão destacadas. Pode-se extrair essas coordenadas de qualquer string. Eu extraí da string GPRMC. RMC significa dados GNSS mínimos recomendados. A string GPRMC é explicada com mais detalhes abaixo.
Formato de string GPRMC:
Fig. 2: Imagem mostrando formato de string GPRMC contendo informações de hora, latitude e longitude do módulo GPS
A string completa tem de 65 a 70 caracteres, incluindo a tag inicial. A string começa com $ e começa com a tag GPRMC. Após a etiqueta de início, o próximo horário é GMT. Depois, há informações de localização que incluem latitude com direção e longitude com direção. Existem 9 caracteres em latitude. Os dois primeiros representam o grau (33ó neste caso) o segundo representa o minuto (54' aqui) e depois da vírgula decimal os últimos 4 representam os segundos (1133” aqui). A direção da latitude segue a latitude e pode ser 'N' ou 'S'. A longitude é representada pelos próximos 10 caracteres. É semelhante à latitude, mas existem três dígitos (caracteres) em grau (151ó nesse caso). O microcontrolador extrai essa string da saída do GPS, extrai detalhes das informações de localização e os exibe no LCD no formato adequado. Em seguida, combina as coordenadas com as coordenadas de diferentes cidades indianas. Se encontrar alguma correspondência, o nome da cidade será exibido como “é Ahmedabad” ou “é Delhi”.
Diagrama de blocos do sistema:
Existem apenas quatro blocos de construção principais do sistema.
Receptor GPS – ele coleta informações do satélite e gera resultados na forma de diferentes strings. Ele fornece essas strings como saída para o microcontrolador
MÁX232 – é um chip conversor de nível. Ele converte sinais de nível RS232 fornecidos pelo receptor GPS em sinais de nível TTL que podem ser fornecidos ao microcontrolador.
Microcontrolador AT89C51 – ele recebe todas as strings do receptor GPS, mas extrai apenas uma string. Ele extrai informações de localização da string e as exibe no LCD no formato adequado
Painel LCD – é usado para exibir informações de localização e nome da cidade
Fig. 3: Diagrama de blocos do localizador GPS baseado em microcontrolador 8051
Descrição e programação do circuito
Diagrama de circuito do sistema:
(Consulte a guia do diagrama de circuito para localizador de cidades baseado em microcontrolador usando GPS e LCD)
Descrição do circuito
Conforme mostrado na figura, o circuito é construído usando apenas três componentes principais, chip conversor de nível RS232 MAX232, microcontrolador 89C51 e painel LCD 16×2.
· O módulo GPS possui três terminais para interface denominados Tx, Rx e Gnd. Ele fornece séries de strings como saída serial através de seu pino Tx. Portanto, o pino Tx está conectado ao pino de entrada lateral de nível RS232 R2IN (pino 8)
· A saída é obtida do pino de saída lateral de nível TTL R2OUT (pino nº 9) e é fornecida ao pino de recepção serial Rx (pino 10) do AT89C51
· Os capacitores C1 – C4 estão conectados ao chip MAX232 conforme circuito sugerido em sua ficha técnica
· Os pinos P2.0 – P2.7 da PORT2 acionam os pinos de dados do LCD D0 – D7. Os pinos de controle Rs, RW e En do LCD estão conectados aos pinos P3.7, P3.6 e P3.5 da PORT3 respectivamente
· Um potenciômetro de 1 KΩ é conectado ao pino 3 do LCD conforme mostrado para variar seu brilho
· Um cristal de 12 MHz junto com dois capacitores de 22 pF são conectados aos pinos de entrada de cristal 18 e 19 do AT89C51 conforme mostrado
· O circuito completo funciona com alimentação de 5 V
Operação do circuito:
A operação completa do circuito depende do módulo receptor GPS. O módulo receptor GPS fornece 10 strings diferentes como saída que contém várias informações como longitude, latitude, altitude, data, hora, velocidade, número de satélites em visibilidade, validade do sinal recebido, intensidade do sinal, etc. caractere por caractere para o microcontrolador.
O microcontrolador AT89C51 é o coração do circuito completo. Ele executa as seguintes tarefas
· Recebe séries de strings do módulo GPS
· Extrai a string necessária de um monte de strings recebidas em tempo real
· Da string extraída, extrai ainda informações de localização
· Por fim exibe esta informação no painel LCD
· Recebe continuamente dados do módulo GPS em tempo real e atualiza o LCD a cada 4 segundos
AT89C51 receberá todas as strings caractere por caractere. Dessas 10 strings, ele extrai a string que começa com $GPRMC. Todas as outras strings são simplesmente descartadas. Da string após a tag $GPRMC, o microcontrolador extrairá apenas latitude e longitude junto com sua direção.
Depois de extrair as informações, ele as exibe no painel LCD como
- Latitude – direção da latitude e graus-minuto-segundo
- Longitude – direção da longitude e graus-minuto-segundo
Essas latitudes e longitudes são comparadas com a latitude-longitude das principais cidades da ÍNDIA, como Mumbai, Delhi, Ahmedabad, channai, Calcutá, Bangluru, Bhopal, Pune, Jaipur etc. e coordenadas da cidade) a mensagem é exibida no LCD como “It's a Ahmedabad”. O nome da cidade é exibido por cerca de 5 segundos e novamente a latitude e a longitude são exibidas. Portanto, se o receptor GPS estiver estável em um local da cidade, ele exibirá o nome da cidade repetidamente.
Observação: neste projeto, para demonstração, usei coordenadas longas da maioria das cidades metropolitanas da ÍNDIA, como Mumbai, Delhi, Bangaluru, Ahmedabad, Jaipur, etc. O nome da cidade só será exibido quando as coordenadas recebidas corresponderem exatamente às coordenadas especificadas em graus e minutos. Pode-se alterar as coordenadas no programa para a mesma cidade ou inserir coordenadas completamente novas para qualquer outra cidade. Talvez seja melhor inserir coordenadas de cidades de qualquer estado apenas. Por apenas uma ligeira modificação, se alguém inserir coordenadas de diferentes marcos da cidade com nomes de lugares em vez de nomes de cidades, então este projeto pode ser usado para localizar diferentes marcos da cidade.
Programa de software:
As funcionalidades do microcontrolador se devem ao programa embutido em seu FLASH interno. O programa de software é escrito em linguagem C usando o software KEIL (IDE). O programa é compilado usando o compilador cruzado Keil. Quando o programa é compilado com sucesso, ele gera um arquivo HEX. Este arquivo HEX é carregado no AT89C51 usando um programador EEPROM adequado.
O programa C é composto por 9 funções diferentes descritas a seguir
Funções de manuseio de LCD
- LCD_cmd – esta função envia um comando de 8 bits (caractere) ao LCD para inicializá-lo ou configurá-lo
- LCD_data – esta função envia dados de 8 bits (caractere) para o LCD que serão exibidos na tela
- LCD_write_string – esta função exibe a string completa (mensagem) na tela LCD
- Init_LCD – esta função inicializa o LCD no modo de 8 bits, 8×5 pontos/caractere, etc.
Função de manipulação USART
- Init_usart – inicializa o USART integrado e define a taxa de transmissão para 4800 bps
- usart_getch – retorna um caracter (dados de 8 bits) recebido da porta serial
Funções de exibição
- display_latitude – exibe a latitude recebida no LCD no formato grau-minuto-segundo
- display_longitude – exibe a longitude recebida no LCD no formato grau-minuto-segundo
- get_city_name – calcula o valor da coordenada, combina-o com as coordenadas da cidade e quando a correspondência é encontrada exibe o nome da cidade
Junto com essas 9 funções definidas pelo usuário, existe uma função principal. Inicializa as portas como entrada ou saída. Em seguida, inicializa o LCD e o USART e entra em loop contínuo. Neste loop contínuo, primeiro espere até obter os primeiros 5 caracteres como $, G, P, R, M e C. Quando obtiver todos esses 5 caracteres em sequência, isso significa que é a string necessária com a tag $GPRMC. Dessa string, uma por uma, extrai latitude e longitude. No formato padrão de string GPS, os valores necessários são fornecidos entre duas vírgulas. Assim, o programa começará a coletar caracteres (dados) de um coma e continuará até o próximo coma. Aqui está o software completo com os comentários necessários
Código fonte do projeto
#include
//#define LCD_DATA_PORT P2 //LCD data port
sbit rs = P3^7; //enable signal
sbit rw = P3^6; //read/write signal
sbit en = P3^5 ; //resister select signal
unsigned char value,lati_value(10),lati_dir, longi_value(11), longi_dir;
unsigned int t;
void lcd_busy
{
int p;
for(p=0;p<2000;p++);
}
void LCD_cmd(unsigned char cmd)
{
lcd_busy ;
rw=0;
rs=0;
P2 = cmd;
en=1;
en=0;
}
void LCD_data(unsigned char dat)
{
lcd_busy ;
rw=0;
rs=1;
P2 = dat;
en=1;
en=0;
}
void init_LCD
{
LCD_cmd(0x38); //initialization of 16X2 LCD in 8bit mode
LCD_cmd(0x0E); //cursor ON
LCD_cmd(0x01);
LCD_cmd(0x80); // ---8 go to first line and --0 is for 0th position
}
void init_USART
{
TMOD=0x20;
SCON=0x40;
TH1=0xFD;
TL1=0xFD;
TR1=1;
REN=1;
}
unsigned char usart_getch
{
while(RI==0);
RI=0;
return(SBUF);
}
void LCD_write_string(char *str) //take address vaue of the string in pionter *str
{
int i=0;
while(str(i)!='�') // loop will go on till the NULL charaters
{
LCD_data(str(i)); // sending data on CD byte by byte
i++;
}
return;
}
void display_lat
{
LCD_cmd(0x80);
LCD_write_string("lt:");
LCD_data(lati_dir);
LCD_data(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);
}
void 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);
}
void delay_5sec
{
int i,j;
for(i=0;i<100;i++)
for(j=0;j<10000;j++);
}
void get_city_name
{
unsigned int value1,value2,value3;
unsigned int lati_degree,lati_minute,longi_degree,longi_minute;
value1 = lati_value(0)-0x30;
value2 = lati_value(1)-0x30;
lati_degree = value1*10+value2;
value1 = lati_value(2)-0x30;
value2 = lati_value(3)-0x30;
lati_minute = value1*10+value2;
value1 = longi_value(0)-0x30;
value2 = longi_value(1)-0x30;
value3 = longi_value(2)-0x30;
longi_degree = value1*100+value2*10+value3;
value1 = longi_value(3)-0x30;
value2 = longi_value(4)-0x30;
longi_minute = value1*10+value2;
if((lati_degree==28) && (lati_minute==61) && (longi_degree==77) && (longi_minute==23))
{
LCD_cmd(0x01);
LCD_write_string("It's a Delhi");
delay_5sec ;
}
else if((lati_degree==26) && (lati_minute==92) && (longi_degree==75) && (longi_minute==82))
{
LCD_cmd(0x01);
LCD_write_string("It's a Jaipur");
delay_5sec ;
}
else if((lati_degree==23) && (lati_minute==03) && (longi_degree==72) && (longi_minute==58))
{
LCD_cmd(0x01);
LCD_write_string("It's a Ahmedabad");
delay_5sec ;
}
else if((lati_degree==18) && (lati_minute==97) && (longi_degree==72) && (longi_minute==82))
{
LCD_cmd(0x01);
LCD_write_string("It's a Mumbai");
delay_5sec ;
}
else if((lati_degree==23) && (lati_minute==25) && (longi_degree==77) && (longi_minute==41))
{
LCD_cmd(0x01);
LCD_write_string("It's a Bhopal");
delay_5sec ;
}
else if((lati_degree==22) && (lati_minute==56) && (longi_degree==88) && (longi_minute==36))
{
LCD_cmd(0x01);
LCD_write_string("It's a Kolkata");
delay_5sec ;
}
else if((lati_degree==12) && (lati_minute==96) && (longi_degree==77) && (longi_minute==56))
{
LCD_cmd(0x01);
LCD_write_string("It's a Bengaluru");
delay_5sec ;
}
else if((lati_degree==13) && (lati_minute==8) && (longi_degree==80) && (longi_minute==27))
{
LCD_cmd(0x01);
LCD_write_string("It's a Channai");
delay_5sec ;
}
}
int main(void)
{
P2=0x00; //LCD_DATA port as out put port
P3=0x0F; //ctrl as out put
init_LCD ; //initialization of LCD
LCD_write_string(" GPS DEMO");
LCD_cmd(0xC0);
LCD_write_string(" using AT89C51");
init_USART ; // initialization of USART
while(1)
{
value=usart_getch ;
if(value=='$')
{
value=usart_getch ;
if(value=='G')
{
value=usart_getch ;
if(value=='P')
{
value=usart_getch ;
if(value=='R')
{
value=usart_getch ;
if(value=='M')
{
value=usart_getch ;
if(value=='C')
{
value=usart_getch ; while(value!=',') // wait upto next ","
{ value=usart_getch ; } value=usart_getch ;
while(value!=',') // wait upto next ","
{
value=usart_getch ;
} value=usart_getch ; while(value!=',') // wait upto next ","
{
value=usart_getch ;
} lati_value(0) = usart_getch ;
value = lati_value(0);
for(t=1;value!=',';t++)
{
lati_value
