Sistema GPS: 7 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

Criador do Projeto: Carlos Gomez

Ter um sistema de navegação confiável é fundamental para qualquer pessoa que queira viajar e explorar o mundo.

O aspecto mais importante que permite que o sistema de navegação funcione é a capacidade do GPS embutido no sistema. O sistema GPS permite que qualquer pessoa acompanhe sua localização e velocidade para exibir informações precisas sobre o usuário e fornecer ao usuário uma representação precisa de onde está e a que distância está de sua localização.

O Sistema de Posicionamento Global (GPS) é uma rede de satélites orbitando a Terra a uma altitude de cerca de 20.000 km. Qualquer pessoa com um dispositivo GPS pode receber os sinais de rádio que os satélites transmitem e pode utilizá-los da maneira que for necessária. Em qualquer lugar do planeta, pelo menos quatro GPS devem estar disponíveis a qualquer momento. Usando um método chamado trilateração 3-D, um dispositivo GPS é capaz de usar três satélites para determinar a localização do dispositivo na Terra. Cada um dos três satélites envia um sinal para o dispositivo e o dispositivo determina sua distância do satélite. Usando cada um dos três cálculos de distância, o dispositivo agora é capaz de apontar sua localização na Terra e retornar isso ao usuário.

O sistema GPS que criaremos será capaz de rastrear a localização do usuário, obtendo as coordenadas do usuário na Terra e fazendo alguns cálculos para retornar a velocidade do usuário, a localização e a distância percorrida.

Etapa 1: primeiros passos

Para iniciar este projeto, primeiro precisamos reunir todos os materiais corretos

1: Raspberry Pi Zero W

2: Receptor GPS

Tela LCD SPI 3: 1.8 TFT 128 x 160

4: ~ 11 fios

5: 2 botões

6: 2 resistores de 1k e 2x 10k para botões suspensos

7: Tábua de pão

Este projeto usará os pinos GPIO do Raspberry Pi e, como tal, precisaremos conectar tudo com uma placa de pão para desenvolver nosso projeto. Também presume-se que a solda em todos os pinos esteja feita e terminada antes de prosseguirmos e conectarmos todas as nossas peças.

Etapa 2: conectar o módulo GPS ao Raspberry Pi

Para usar nosso sistema GPS, você precisará conectar os pinos Tx e Rx do módulo GPS ao GPIO pino 14 e 15 no Raspberry Pi. O pino Tx do receptor GPS vai para o pino Rx do Pi e o pino Rx do receptor GPS vai para o pino Tx do pi do Raspberry.

O receptor GPS mostrado nas imagens requer 3,3 V para ser usado e você pode conectar os pinos de 3,3 V à tensão correta, enquanto conecta o pino de aterramento ao aterramento.

Etapa 3: receber dados do módulo receptor GPS

Para receber dados do receptor GPS para o Raspberry Pi, precisamos permitir que os soquetes corretos façam a leitura das portas UART. Ler os dados brutos exigiria que criássemos nossa própria biblioteca de análise, mas neste cenário podemos tirar proveito de um daemon de GPS que é executado em segundo plano para ajudar a analisar os dados e transmiti-los para o Raspberry Pi

Para fazer isso, podemos abrir um terminal no Raspberry Pi e executar o código:

sudo apt-get update

sudo apt-get install gpsd gpsd-clients python-gps

Isso deve cuidar do download para nós.

Depois de concluído, precisamos desativar o serviço do sistema gpsd executando os seguintes comandos:

sudo systemctl stop gpsd.socket

sudo systemctl disable gpsd.socket

Se você quiser habilitar o serviço do sistema gpsd padrão, execute os seguintes comandos para restaurá-lo:

sudo systemctl enable gpsd.socket

sudo systemctl start gpsd.socket

Agora precisamos iniciar o daemon gpsd e apontá-lo para as portas UART inserindo

sudo gpsd / dev / ttyAMA0 -F /var/run/gpsd.sock

Agora podemos executar o comando abaixo e ver todos os dados flutuando!

cgps -s

Etapa 4: conectar o monitor ao Raspberry Pi

Assim que tivermos nosso receptor GPS ligado e funcionando com o Raspberry Pi, podemos conectar o monitor ao Raspberry Pi. Usaremos 5 fios para conectar nosso monitor LCD ao Raspberry Pi e outros 4 pinos para conectar a alimentação principal e o LED na tela.

Incluí uma foto da tela TFT que estou usando, mas deve funcionar com telas de tamanho e construção semelhantes.

Conecte o LED- e o GND ao aterramento e conecte o LED + e VCC a 3,3V.

Conecte o pino RESET na tela ao pino 25 na placa Pi.

Conecte A0 ao pino 24 na placa Pi.

Conecte o pino SDA ao pino MOSI na placa Pi.

Conecte o pino SCK na tela LCD à placa Pi.

Conecte o pino CS ao pino 8 na placa Pi.

Etapa 5: configure a tela para funcionar com Raspberry Pi

Para configurar a exibição, precisamos usar a biblioteca ST7735 encontrada neste repositório:

Biblioteca de tela Python ST7735

Assim que tivermos essa biblioteca de exibição instalada em nosso sistema Raspberry Pi, podemos agora prosseguir com a configuração de um arquivo de exemplo para confirmar se a fiação anterior está funcionando corretamente.

Crie um arquivo intitulado example.py e insira o seguinte texto nele junto com uma imagem de amostra de sua escolha na mesma pasta

importar ST7735 como TFTimportar Adafruit_GPIO como GPIO importar Adafruit_GPIO. SPI como SPI

WIDTH = 128

HEIGHT = 160 SPEED_HZ = 4000000

# Configuração do Raspberry Pi.

# Estes são os pinos necessários para conectar o LCD ao Raspberry Pi

DC = 24 RST = 25 SPI_PORT = 0 SPI_DEVICE = 0

# Crie uma classe de exibição TFT LCD.

disp = TFT. ST7735 (DC, rst = RST, spi = SPI. SpiDev (SPI_PORT, SPI_DEVICE, max_speed_hz = SPEED_HZ))

# Inicialize a exibição.

disp.begin () disp.reset ()

# Carregue uma imagem.

newData = 0x42 disp.command (newData) print ('Carregando imagem…') image = Image.open ('cat.jpg')

# Redimensione a imagem e gire-a de acordo com a exibição.

image = image.rotate (270).resize ((WIDTH, HEIGHT))

# Irá imprimir no terminal que nosso programa está desenhando nossa imagem na tela

imprimir ('Desenho de imagem')

# Esta função exibirá nossa imagem na tela

disp.display (imagem)

Este arquivo definirá a configuração do Raspberry Pi para a tela LCD e a biblioteca converterá nossa imagem na pasta e a exibirá na tela.

Etapa 6: Configurar máquinas de estado para exibir informações de GPS no visor

Usaremos 5 máquinas de estado diferentes, enquanto implementamos nosso diagrama de tarefas para configurar nosso sistema GPS.

Exibir máquina de estado de mudança:

Esta máquina de estado controlará qual exibir, dependendo de nossa entrada de botão. Ele faz isso alterando uma variável que permite ao python tirar vantagem da digitação de pato e chamar a função correta para exibir dependendo da função chamada

Máquina de estado de velocidade:

Esta máquina de estado irá executar a velocidade atual dependendo da localização dos indivíduos. Isso executará cada ciclo de relógio para o sistema GPS

Máquina de estado de saída:

Esta máquina de estado determinará a saída com base na variável que a máquina de mudança de estado de exibição determina como a exibição atual.

Máquina de estado de distância

Esta máquina de estado executa cada ciclo de clock e determina a distância total percorrida pelo usuário e, uma vez que o botão de reset é pressionado, irá resetar a distância atual percorrida.

Máquina de estado de localização:

Esta máquina de estado retorna a localização atual do usuário, usando as coordenadas que o módulo GPS retorna sobre o usuário. Esta máquina de estado depende da conexão do usuário com a Internet.

Etapa 7: Vamos implementar nosso sistema GPS

Assim que tivermos nosso módulo GPS enviando informações para nosso Raspberry Pi e nossa tela LCD exibindo informações sobre ele, podemos então começar a programar nosso sistema GPS. Usarei as máquinas de estado finito da etapa anterior para codificar nosso sistema GPS

## Arquivo principal para o sistema de navegação # # # #

# Bibliotecas para desenhar imagens

de PIL importar Imagem de PIL importar ImageDraw de PIL importar ImageFont

# Biblioteca para controlador ST7737

importar ST7735 como TFT

# Biblioteca para GPIO para Raspberry Pi

importar Adafruit_GPIO como GPIO importar Adafruit_GPIO. SPI como SPI

# Biblioteca para GPS

#import gpsd de gps3 import gps3

# Biblioteca para o tempo

tempo de importação

# Biblioteca para encontrar distância entre dois pontos

da matemática importar sin, cos, sqrt, atan2, radianos

# Importar biblioteca Rpi para usar botões para alternar menus e redefinir

# import RPi. GPIO como bGPIO

# Pinos de configuração para botões

bGPIO.setmode (bGPIO. BCM)

bGPIO.setup (18, bGPIO. IN, pull_up_down = bGPIO. PUD_DOWN)

bGPIO.setup (23, bGPIO. IN, pull_up_down = bGPIO. PUD_DOWN)

# import biblioteca de geopy para geocodificação

# # O acesso à Internet é necessário para que isso funcione

de geopy.geocoders import Nominatim

Geolocator = Nominatim ()

# Constantes para o sistema

#################################

WIDTH = 128

HEIGHT = 160 SPEED_HZ = 4000000

# Pinos de configuração do Raspberry Pi

DC = 24 # A0 na tela TFT RST = 25 # Redefinir pino na tela TFT SPI_PORT = 0 # Porta SPI no raspberry pi, SPI0 SPI_DEVICE = 0 # Seleção escrava no rapsberry pi, CE0

# Criar objeto de exibição TFT LCD

disp = TFT. ST7735 (DC, rst = RST, spi = SPI. SpiDev (SPI_PORT, SPI_DEVICE, max_speed_hz = SPEED_HZ))

# Inicializar tela

disp.begin ()

# O fundo será definido como verde

# disp.clear ((0, 255, 0))

# Limpar tela para branco e exibir

# disp.clear ((255, 255, 255)) draw = disp.draw () # draw.rectangle ((0, 10, 127, 150), contorno = (255, 0, 0), preencher = (0, 0, 255)) # disp.display ()

# Variáveis de posicionamento de velocidade, latitude, longitude

#currentS = "Velocidade atual:" # Speed string #totalDis = "Distância total:" # Distance string #currentLoc = "Localização atual:" # Location string

# Coordenadas de distância xey

distX = 10 distY = 20

pointsList =

# Coordenadas de velocidade xey

speedX = 10 speedY = 20

# Localização xey coordiantes

locX = 10 locY = 20

# Converte de m / s para mph

conversionVal = 2,24

# Função de atualização de velocidade, retorna string

SpeedVar = 0

def speedFunc (): global SpeedVar SpeedText = data_stream. TPV ['speed'] if (SpeedText! = "n / a"): SpeedText = float (SpeedText) * conversionVal SpeedVar = round (SpeedText, 1) # return (SpeedText)

def locationFunc ():

latLoc = str (latFunc ()) lonLoc = str (lonFunc ())

reverseString = latLoc + "," + lonLoc

location = geolocator.reverse (reverseString)

return (location.address)

# Função de atualização de latitude, retorna o valor flutuante

def latFunc (): Latitude = data_stream. TPV ['lat'] if (Latitude == "n / a"): return 0 else: return float (round (Latitude, 4))

# Função de atualização de longitude, retorna string

def lonFunc (): Longitude = data_stream. TPV ['lon'] if (Longitude == "n / a"): return 0 else: return float (round (Longitude, 4))

# A função de distância retorna TOTAL distância percorrida

totalDistance = 0

def distFunc ():

global totalDistance newLat = latFunc () newLon = lonFunc () if (newLat == 0 ou newLon == 0): totalDistance = totalDistance # return (totalDistance) else: pointsList.append ((newLat, newLon)) last = len (pointsList) -1 if (last == 0): return else: totalDistance + = coorDistance (pointsList [last-1], pointsList [last]) # return totalDistance

# Redefine a distância total

def resDistance ():

global totalDistance totalDistance = 0

# Função usada para encontrar a distância entre duas coordenadas

# usa a fórmula de Haversine para encontrar. # Os pontos de entrada são uma tupla

def coorDistance (ponto1, ponto2):

# Raio aproximado da Terra em quilômetros earthRadius = 6373.0

lat1 = ponto1 [0]

lon1 = ponto1 [1]

lat2 = ponto2 [0]

lon2 = ponto2 [1]

distanceLon = lon2 - lon1

distanceLat = lat2 - lat1

# Haversine a

a = sin (distanceLat / 2) ** 2 + cos (lat1) * cos (lat2) * sin (distanceLon / 2) ** 2

# Haversine c

c = 2 * atan2 (sqrt (a), sqrt (1-a))

# Converter km em milhas

distância = (earthRadius * c) * 0,62137

if (distance <= 0.01): return 0.00 else: return round (distance, 3)

# Função para exibir a velocidade na tela

def dispSpeed ():

global SpeedVar # Coloque a distância na variável na tela draw.text ((speedX, speedY), str (SpeedVar), font = ImageFont.truetype ("Lato-Medium.ttf", 72))

# Função para exibir a distância na tela

def dispDistance ():

draw.text ((distX, distY), str (totalDistance), font = ImageFont.truetype ("Lato-Medium.ttf", 60))

# Função para exibir a localização na tela, requer internet para funcionar

def dispLocation ():

draw.text ((locX, locY), locationFunc (), font = ImageFont.truetype ("Lato-Medium.ttf", 8))

# Usando o dicionário para imitar as declarações de troca

dispOptions = {

0: dispSpeed, 1: dispDistance, 2: dispLocation}

# Função de saída da tela

saída def ():

# Usando a variável global para displayIndex global displayIndex # Limpando a tela e aplicando disp.clear de fundo ((255, 255, 255)) draw.rectangle ((0, 10, 127, 150), outline = (255, 0, 0), preencher = (255, 0, 0))

# Função de chamadas dependendo do valor displayIndex

dispOptions [displayIndex] ()

# Apaga se outro método funcionar

# coloque a variável de distância na tela

# draw.text ((distX, distY), str (distFunc ()), font = ImageFont.load_default ()) # coloque a variável de velocidade na tela # draw.text ((speedX, speedY), speedFunc (), font = ImageFont.load_default ()) # Exibir atualizações na tela disp.display ()

displayButton = 18 # BCM Pin em framboesa pi

resetButton = 23 # BCM Pin em raspberry pi

buttonPress = False

def checkDisplay ():

global buttonPress global displayIndex if (bGPIO.input (displayButton) e não buttonPress): displayIndex + = 1 buttonPress = True if (displayIndex == 2): displayIndex = 0 elif (bGPIO.input (displayButton) e buttonPress): imprimir (" Ainda pressionado ") else: buttonPress = False

# Configurar GPS

gps_socket = gps3. GPSDSocket () data_stream = gps3. DataStream () gps_socket.connect () gps_socket.watch ()

timerPeriod = 0,5

# Valor de índice para display displayIndex = 0 try: for new_data em gps_socket: if new_data: data_stream.unpack (new_data) if data_stream. TPV ['lat']! = 'N / a': print (data_stream. TPV ['speed'], data_stream. TPV ['lat'], data_stream. TPV ['lon']) distFunc () speedFunc () output () checkDisplay () if (bGPIO.input (resetButton)): resDistance () else: output () checkDisplay () if (bGPIO.input (resetButton)): resDistance () print ('GPS ainda não conectado') time.sleep (.1) time.sleep (.8) exceto KeyboardInterrupt: gps_socket.close () print (' / n Terminado pelo usuário ctrl + c ')

O código acima é apenas um exemplo de como codificar nosso sistema e incluí um vídeo sobre como esse sistema funciona.