No tutorial anterior, aprendemos como fazer a interface de um modem SIM900 GSM-GPRS com Raspberry Pi (RPi) e um computador desktop. Nós empregamos comunicação serial UART para “conversar” com o modem SIM900. Usando comunicação de dados bidirecional com o modem através de um padrão Interface UARTpudemos fazer/receber chamadas e enviar/receber mensagens SMS no RPi e em um computador desktop.
Usando a mesma interface e protocolo UART neste tutorial, faremos a interface de um módulo de sistema de posicionamento global (GSP) com RPi.
Usamos o módulo GPS, NEO-6MV2. Este é um receptor GPS de baixo custo comumente usado em dispositivos embarcados e projetos robóticos (existem outros de vários fornecedores diferentes). Um receptor GPS fornece sua localização conectando-se aos satélites GPS disponíveis.
Um receptor GPS pode ser usado para rastrear uma localização. Por exemplo, conectando um receptor GPS (como o NEO-6) e um modem GSM (como o SIM900) a um controlador ou computador embarcado, podemos projetar um sistema de rastreamento de veículos. Neste sistema, o receptor GPS obtém a localização atual do veículo e o modem GSM-GPRS comunica essa localização a um servidor remoto através de uma rede móvel.
Da mesma forma, podemos usar um receptor GPS em um drone para rastrear sua localização e gerenciar um voo guiado por GPS. Os mesmos receptores GPS são usados em smartphones, tablets e sistemas de navegação GPS.
Agora, vamos aprender como fazer a interface de um receptor GPS com um computador embarcado como o Raspberry Pi.
O módulo GPS NEO-6MV2
O NEO-6MV2 é um receptor GPS autônomo usado para navegação. O receptor GPS se conecta a satélites GPS para obter sua própria localização. Em seguida, ele gera a latitude e a longitude de sua posição como dados seriais.
O módulo NEO-6 é baseado em um mecanismo de posicionamento Ublox-6 de 50 canais que possui um tempo para a primeira correção (TTFF) de um segundo. Este mecanismo GPS possui dois milhões de correlacionadores e é capaz de realizar pesquisas massivas de espaço em tempo/frequência paralelas. Isso permite encontrar satélites instantaneamente. O módulo também possui um formato pequeno que o torna ideal para dispositivos móveis operados por bateria.
O modem GPS NEO-6M opera com uma tensão de alimentação de 2,7 a 3,6V. Comunica dados GPS de acordo com o protocolo NMEA ou UBX. Embora NMEA seja um protocolo ASCII padrão, UBX é um protocolo binário proprietário do u-blox.
O chipset receptor possui interfaces UART, USB, SPI e DDC (compatível com I2C) para comunicar esses dados. O chipset possui três pinos de configuração. Um desses pinos de configuração — CFG-GPS0 — é usado para habilitar a configuração de inicialização do modo de energia.
Os outros dois pinos de configuração — CFG_COM0 e CFG_COM1 — são usados para decidir se os dados GPS são comunicados usando o protocolo NMEA ou o protocolo UBX.
O modem NEO-6 tem esta atribuição de pinos:
No módulo usado aqui, o modem NEO-6 é pré-configurado para enviar dados usando a interface serial (UART) e codificar dados GPS para o protocolo NMEA.
Os pinos de configuração CFG_COM0 e CFG_COM1 são colocados em HIGH e, como resultado, os dados GPS são comunicados através do protocolo NMEA a uma taxa de transmissão de 9600 bps. Como você pode ver na tabela acima, com esta configuração, os dados NMEA incluem mensagens GSV, RMC, GSA, GGA, GLL e VTG.
O módulo expõe apenas quatro canais conforme mostrado neste diagrama de pinos:
O módulo tem a seguinte atribuição de pinos:
A taxa máxima de atualização de navegação do módulo é de 5 Hz. Assim, um controlador ou computador embarcado pode ler os dados GPS do modem em no mínimo 0,2 segundos.
Quando o modem está ligado, leva 32 segundos para uma inicialização a frio, 23 segundos para uma inicialização a quente ou um segundo para uma inicialização a quente. Como o módulo está configurado para partida a frio, inicialmente leva 32 segundos para obter a leitura do GPS pela primeira vez.
O módulo também vem com uma antena externa com sensibilidade de -160dBm. O módulo possui uma EEPROM e RTC integradas com bateria reserva. O modem NEO-6M pode operar em temperaturas entre -40˚ a 85˚ C.
Interface com o módulo GPS NEO-6MV2
O módulo possui todas as conexões de hardware integradas com o modem NEO-6M, que já vem pré-configurado. De acordo com a configuração do hardware, o módulo expõe apenas quatro canais do modem:
1. O VCC (pino 23 do modem)
2. O receptor UART (pino 21 do modem)
3. O transmissor UART (pino 20 do modem)
4. O terra (que pode ser o pino 10, 12, 13 ou 24 do modem)
O módulo GPS NEO-6MV2 pode interagir facilmente com a porta serial TTL de um controlador/computador. Porém, o pino VCC deve ser alimentado com tensão máxima de 3,6V DC e o pino de aterramento deve ser conectado a um terra comum. O pino TX do módulo deve ser conectado ao Rxd da porta serial TTL do controlador/computador.
Para conectar o módulo a computadores desktop, a placa serial USB pode ser usada. Lembre-se que o módulo GPS possui tensão de operação máxima de 3,6V. Portanto, quando conectado a um controlador (como o Arduino) ou a um computador embarcado (como o RPi), o modem deve ser alimentado com o VCC de um pino de saída de energia 3V3.
Quando conectada a computadores desktop por meio de uma placa serial USB, esta placa deve primeiro ser configurada para usar os níveis de tensão 3V3 TTL, colocando o jumper no conector de 3,3V.
Protocolo NMEA
NMEA é um acrônimo para National Marine Electronics Association. No contexto de um GPS, NMEA é um formato de dados padrão suportado por todos os fabricantes de GPS. É um protocolo para dados GPS usado pelos receptores GPS e software associado.
Os dados GPS formatados em NMEA podem ser transmitidos através de uma variedade de padrões de comunicação de dados, incluindo UART, SPI, I2C, USB, Wi-Fi, UHF e Bluetooth.
No protocolo NMEA, os dados GPS são comunicados como sequências de mensagens NMEA. Existem também receptores GPS com capacidades diferentes. De acordo com as suas capacidades, eles normalmente comunicam um subconjunto de cadeias de mensagens NMEA. Todas as mensagens NMEA começam com o caractere $, seguido pelo ID da mensagem e vários campos de dados separados por vírgula. A mensagem termina com um asterisco
, seguido pelo caractere de soma de verificação. Por último, um retorno de carro e avanço de linha servem como caracteres finais.
O módulo GPS usado aqui comunica mensagens GSV, RMC, GSA, GGA, GLL e VTG NMEA. Vamos examinar as sequências de mensagens NMEA uma por uma. GPRMC –
indica a posição, velocidade e tempo. Tem este formato:
$GPRMC,hhmmss:ss,Status,Latitude,N,Longitude,E,SOG,COG,ddmmyy,MV,MVE,Modo*CS
Os campos de dados da mensagem GPRMC NMEA estão descritos nesta tabela: GPVTG –
indica a pista em bom estado e velocidade em relação ao solo. Tem este formato:
$GPVTG,cogt,T,cogm,M,sog,N,kph,K,mode*cs
Os campos de dados da mensagem GPVTG NMEA estão descritos nesta tabela: GPGA –
indica a hora, a posição e os dados relacionados à correção. Tem este formato:
$GPGGA,hhmmss:ss,Latitude,N,Longitude,E,FS,NoSV,HDOP,msl,m,Altref,m,DiffAge,DiffStation*cs
Os campos de dados da mensagem GPGGA NMEA estão descritos nesta tabela: GPGSA –
indica o GPS DOP e os satélites ativos. Tem este formato:
$GPGSA,Smode,FS{,sv},PDOP,HDOP,VDOP*cs
Os campos de dados da mensagem GPGSA NMEA estão descritos nesta tabela: GPGSV –
indica o número de SVs à vista, os números PRN, elevações, azimutes e os valores SNR. Tem este formato:
$GPGSV,NoMessages,MessageNumber,NoSV,PRN,Elevação,Azimute,SNR,
Os campos de dados da mensagem GPGSV NMEA estão descritos nesta tabela: GPGLL –
indica os dados de posição, como a posição fixa, a hora da posição fixa e seu status. Tem este formato:
$GPGLL,Latitude,DirLat,Longitude,DirLongitude,hhmmss:ss,A,cs
Os campos de dados da mensagem GPGLL NMEA estão descritos nesta tabela:
Interface do GPS NEO-6MV2 com RPi
Para fazer a interface do módulo GPS NEO-6MV2 com Raspberry Pi, alimente o módulo VCC do pino de 3,3 V do RPi (pino 1 ou 17 da placa) e, em seguida, aterre a partir de qualquer um dos pinos de aterramento no RPi (pino 6, 9, 14, 20 da placa, 25, 30, 34 ou 39).
Em seguida, conecte o TX do módulo ao UART Rxd do Raspberry Pi (pino 10 da placa). Não é necessário enviar nenhum dado serial para o modem NEO-6, o que significa que não há necessidade de conexão com o RX do módulo.
Verificando se o módulo GPS NEO-6MV2 está funcionando
Quando o módulo GPS recebe energia, inicialmente leva algum tempo para ficar pronto. Isso dependerá da configuração do módulo, se ele está configurado para partida a frio, a quente ou a quente.
Após acordar, se os satélites GPS estiverem visíveis para o receptor e ele começar a atingir sua localização, um LED de status no módulo começará a piscar.
Se este LED não piscar, o módulo não está funcionando corretamente ou o satélite não está claro. Nesse caso, você pode tentar obter dados brutos de GPS do módulo. Se você conseguir obter pelo menos algumas informações (como a hora UTC), mas não conseguir os dados de localização, isso significa que o módulo está bom, mas não há um satélite visível para o receptor GPS.
Aguarde algum tempo (digamos, alguns minutos ou meia hora) e tente obter dados brutos de GPS novamente. Se o módulo estiver funcionando corretamente, poderá obter os dados de localização após algum tempo.
Obtendo dados brutos do GPS NEO-6MV2 usando Python Os dados brutos do GPS podem ser lidos do módulo GPS NEO-6M usando o serial.ler ou métodos serial.readline dePhyton
.
- Veja como:
- Importe as bibliotecas serial, time e sys.
- Abra serial a porta TTL onde o módulo GPS faz interface usando o método serial.Serial .
- Este nome de porta será /dev/serial0. Alternativamente, /dev/ttyAMA0 ou /dev/ttyS0 pode ser usado como nome de porta, dependendo do UART primário no respectivo modelo Raspberry Pi.
- Leia os dados seriais do módulo GPS linha por linha usando o método serial.readline . Ou use o número específico de caracteres dos dados seriais do módulo GPS usando o método serial.read .
Continue lendo os dados até que as sequências de mensagens NMEA comecem a se repetir.
Aqui está um exemplo de script Python que lê os dados brutos de GPS do módulo GPS NEO-6M:
importar série
do tempo importar sono
sistema de importação
ser = serial.Serial (“/dev/ttyS0”)
tentar:
enquanto Verdadeiro:
dados_recebidos = (str)(ser.readline ) #ler string NMEA recebida
imprimir(dados_recebidos, “\n”)
exceto KeyboardInterrupt:
sys.exit(0)
Ao executar o script acima no Raspberry Pi, recebemos os seguintes dados de GPS no console do IDLE:
Obtendo a posição GPS do GPS NEO-6MV2 usando Python
Os dados brutos do GPS contêm cadeias de mensagens RMS, VTG, GGA, GSA, GSV e GLL NMEA. Há um total de nove sequências de mensagens de dados brutos de GPS por vez.
Para obter a localização GPS, podemos extrair as strings de mensagens $GPGGA ou $GPGLL. Ambas as strings contêm as informações de localização. Aqui, extraímos a localização GPS da string de mensagem $GPGGA.
Os dados brutos do GPS podem ser armazenados em uma variável do tipo string. Usando as funções de manipulação de string, como find , podemos procurar $GPGGA ou $GPGLL na string recebida.
Se os dados GPS recebidos contiverem uma dessas strings, divida a string da mensagem após $GPGGA ou $GPGLL usando a função split . Em seguida, divida os campos de dados da mensagem NMEA recebida em uma matriz usando a vírgula como delimitador na função split .
Agora, você tem os campos de dados de $GPGGA ou a string de mensagem $GPGLL NMEA em uma matriz. Você pode extrair a hora UTC, a latitude e a longitude acessando um índice diferente da matriz resultante. A latitude e longitude podem ser convertidas em graus usando operações matemáticas simples e de formatação nos valores recebidos. Os valores convertidos de latitude e longitude também podem ser impressos no console ou transferidos para uma variável.
A seguir está um exemplo de um script Python que extrai a localização GPS dos dados brutos de GPS do módulo GPS NEO-6M:
importar série
do tempo importar sono
sistema de importação
ser = serial.Serial (“/dev/ttyS0”)
gpgga_info = “$GPGGA,”
GPGGA_buffer = 0
NMEA_buff = 0
def convert_to_degrees(valor_ravo):
valor_decimal = valor_bruto/100,00
graus = int(valor_decimal)
mm_mmmm = (valor_decimal – int(valor_decimal))/0,6
posição = graus + mm_mmmm
posição = “%.4f” %(posição)
posição de retorno
tentar:
enquanto Verdadeiro:
dados_recebidos = (str)(ser.readline ) #ler string NMEA recebida
GPGGA_data_available=recebido_data.find(gpgga_info) #verifica a string NMEA GPGGA
se (GPGGA_data_available>0):
GPGGA_buffer = recebidos_data.split(“$GPGGA,”,1)(1) #armazena dados que vêm depois de “$GPGGA,” string
NMEA_buff = (GPGGA_buffer.split(','))
nmea_time=
nmea_latitude=
nmea_longitude=
nmea_time = NMEA_buff(0) #extrair tempo da string GPGGA
nmea_latitude = NMEA_buff(1) #extrai latitude da string GPGGA
nmea_longitude = NMEA_buff(3) #extrair longitude da string GPGGA
print(“Hora NMEA: “, nmea_time,'\n')
lat = (float)(nmea_latitude)
lat = convert_to_degrees(lat)
longo = (float)(nmea_longitude)
longi = convert_to_degrees(longi)
imprimir (“Latitude NMEA:”, lat,”Longitude NMEA:”, longi,'\n')
exceto KeyboardInterrupt:
sys.exit(0)
Ao executar o script acima no RPi, recebemos a seguinte localização GPS no console do IDLE:
A posição GPS no Google Maps usando Python
Para mostrar a posição GPS no Google Maps, a biblioteca do navegador Python pode ser usada. Você pode usar o método open desta biblioteca para abrir um link do Google Maps com a latitude e longitude obtidas no exemplo anterior.
Aqui está um exemplo de script Python que mostra a localização GPS do módulo GPS NEO-6M no Google Maps:
importar série
do tempo importar sono
sistema de importação
importar navegador da web
ser = serial.Serial (“/dev/ttyS0”)
gpgga_info = “$GPGGA,”
GPGGA_buffer = 0
NMEA_buff = 0
GPGGA_data_disponível = “”
def convert_to_degrees(valor_ravo):
valor_decimal = valor_bruto/100,00
graus = int(valor_decimal)
mm_mmmm = (valor_decimal – int(valor_decimal))/0,6
posição = graus + mm_mmmm
posição = “%.4f” %(posição)
posição de retorno
dados_recebidos = (str)(ser.read(200)) #ler string NMEA recebida
GPGGA_data_available=recebido_data.find(gpgga_info) #verifica a string NMEA GPGGA
se (GPGGA_data_available>0):
GPGGA_buffer = recebidos_data.split(“$GPGGA,”,1)(1) #armazena dados que vêm depois de “$GPGGA,” string
NMEA_buff = (GPGGA_buffer.split(','))
nmea_time=
nmea_latitude=
nmea_longitude=
nmea_time = NMEA_buff(0) #extrair tempo da string GPGGA
nmea_latitude = NMEA_buff(1) #extrai latitude da string GPGGA
nmea_longitude = NMEA_buff(3)
print(“Hora NMEA: “, nmea_time,'\n')
lat = (float)(nmea_latitude)
lat = convert_to_degrees(lat)
longo = (float)(nmea_longitude)
longi = convert_to_degrees(longi)
imprimir (“Latitude NMEA:”, lat,”Longitude NMEA:”, longi,'\n')
map_link = '+ lat + ',' + longi
webbrowser.open(map_link)
sys.exit(0)
Ao executar o script acima no RPi, recebemos a seguinte localização GPS no Google Maps:
No próximo tutorial, abordaremos a comunicação serial usando I2C no Raspberry Pi.