Sistema GPS: 7 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

Creador del proyecto: Carlos Gomez

Tener un sistema de navegación confiable es primordial para cualquiera que intente viajar y explorar el mundo.

El aspecto más importante que permite que el sistema de navegación funcione es la capacidad GPS incorporada dentro del sistema. El sistema GPS permite a cualquier persona realizar un seguimiento de su ubicación y velocidad para mostrar información precisa sobre el usuario y brindarle una representación precisa de dónde se encuentra y qué tan lejos está de su ubicación.

El Sistema de Posicionamiento Global (GPS) es una red de satélites que orbitan la Tierra a una altitud de unos 20 000 km. Cualquiera que tenga un dispositivo GPS puede recibir las señales de radio que emiten los satélites y puede utilizarlas de cualquier forma que sea necesaria. Dondequiera que se encuentre en el planeta, al menos cuatro GPS deben estar disponibles para usted en cualquier momento. Usando un método llamado trilateración 3-D, un dispositivo GPS puede usar tres satélites para determinar la ubicación del dispositivo en la Tierra. Cada uno de los tres satélites envía una señal al dispositivo y el dispositivo determina su distancia del satélite. Usando cada uno de los tres cálculos de distancia, el dispositivo ahora puede señalar su ubicación en la Tierra y se la devuelve al usuario.

El sistema GPS que crearemos podrá rastrear las ubicaciones del usuario obteniendo las coordenadas del usuario en la Tierra y haciendo algunos cálculos para devolver la velocidad, la ubicación y la distancia recorrida del usuario.

Paso 1: Comenzando

Para comenzar este proyecto, primero necesitaremos reunir todos los materiales correctos

1: frambuesa Pi Zero W

2: receptor de GPS

Pantalla LCD SPI 3: 1.8 TFT 128 x 160

4: ~ 11 cables

5: 2 botones

6: 2x resistencias de 1k y 2x 10k para botones desplegables

7: tabla de pan

Este proyecto utilizará los pines GPIO de la Raspberry Pi y, como tal, necesitaremos conectar todo con una placa de pruebas para poder desarrollar nuestro proyecto. También se asume que la soldadura en todos los pines está hecha y terminada antes de continuar y conectar todas nuestras partes.

Paso 2: Conecte el módulo GPS a Raspberry Pi

Para el uso de nuestro sistema GPS, deberá conectar los pines Tx y Rx del módulo GPS al pin GPIO 14 y 15 en la Raspberry Pi. El pin Tx del receptor GPS va al pin Rx del Pi y el pin Rx del receptor GPS va al pin Tx del Raspberry pi.

El receptor GPS que se muestra en las imágenes requiere 3.3V para ser utilizado y puede conectar los pines de 3.3V al voltaje correcto, mientras conecta el pin de tierra a tierra.

Paso 3: Reciba los datos del módulo receptor de GPS

Para recibir datos del receptor GPS a la Raspberry Pi, necesitamos permitir que los enchufes correctos lean desde los puertos UART. La lectura de los datos sin procesar requeriría que creemos nuestra propia biblioteca de análisis, pero en este escenario podemos aprovechar un demonio GPS que se ejecuta en segundo plano para ayudar a usar el análisis de los datos y transmitirlos a la Raspberry Pi.

Para lograr esto, podemos abrir una terminal en la Raspberry Pi y ejecutar el código:

sudo apt-get update

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

Esto debería encargarse de la descarga por nosotros.

Una vez que se completa, necesitamos deshabilitar el servicio del sistema gpsd ejecutando los siguientes comandos:

sudo systemctl detener gpsd.socket

sudo systemctl deshabilitar gpsd.socket

Si alguna vez desea habilitar el servicio del sistema gpsd predeterminado, puede ejecutar los siguientes comandos para restaurarlo:

sudo systemctl habilitar gpsd.socket

sudo systemctl iniciar gpsd.socket

Ahora necesitamos iniciar el demonio gpsd y apuntarlo a los puertos UART ingresando

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

¡Ahora podemos ejecutar el comando a continuación y ver todos los datos flotando!

cgps -s

Paso 4: Conecte la pantalla a Raspberry Pi

Una vez que tenemos nuestro receptor GPS en funcionamiento con la Raspberry Pi, podemos conectar la pantalla a la Raspberry Pi. Usaremos 5 cables para conectar nuestra pantalla LCD a la Raspberry Pi y otros 4 pines para conectar la alimentación principal y el LED. en la pantalla.

He incluido una foto de la pantalla TFT que estoy usando, pero debería funcionar con pantallas de tamaño y estructura similares.

Conecte LED- y GND a tierra y conecte LED + y VCC a 3.3V.

Conecte el pin RESET en la pantalla al pin 25 en la placa Pi.

Conecte A0 al pin 24 en la placa Pi.

Conecte el pin SDA al pin MOSI en la placa Pi.

Conecte el pin SCK en la pantalla LCD a la placa Pi.

Conecte el pin CS al pin 8 en la placa Pi.

Paso 5: Configurar la pantalla para que funcione con Raspberry Pi

Para configurar la pantalla, necesitamos usar la biblioteca ST7735 que se encuentra en este repositorio:

Biblioteca de pantallas Python ST7735

Una vez que tengamos esta biblioteca de pantalla instalada en nuestro sistema Raspberry Pi, ahora podemos proceder a configurar un archivo de ejemplo para confirmar que nuestro cableado anterior funciona correctamente.

Cree un archivo titulado example.py e inserte el siguiente texto allí junto con una imagen de muestra de su elección en la misma carpeta

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

ANCHO = 128

ALTURA = 160 VELOCIDAD_HZ = 4000000

# Configuración de Raspberry Pi.

# Estos son los pines necesarios para conectar la pantalla LCD a la Raspberry Pi

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

# Crear clase de pantalla TFT LCD.

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

# Inicializar la pantalla.

disp.begin () disp.reset ()

# Cargue una imagen.

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

# Cambie el tamaño de la imagen y gírela para que coincida con la pantalla.

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

# Imprimirá al terminal que nuestro programa está dibujando nuestra Imagen en la pantalla

print ('Imagen de dibujo')

# Esta función mostrará nuestra imagen en la pantalla

disp.display (imagen)

Este archivo configurará la configuración de Raspberry Pi para la pantalla LCD y la biblioteca convertirá nuestra imagen en la carpeta y la mostrará en la pantalla.

Paso 6: Configure las máquinas de estado para mostrar información de GPS en la pantalla

Usaremos 5 máquinas de estado diferentes, mientras implementamos nuestro diagrama de tareas para configurar nuestro sistema gps.

Mostrar máquina de estado de cambio:

Esta máquina de estado controlará cuál mostrar en función de la entrada de nuestro botón. Lo hace cambiando una variable que permite que Python aproveche la escritura pato y llamando a la función correcta para que se muestre dependiendo de la función llamada

Máquina de estado de velocidad:

Esta máquina de estado ejecutará la velocidad actual dependiendo de la ubicación de las personas. Esto ejecutará cada ciclo de reloj para el sistema GPS.

Máquina de estado de salida:

Esta máquina de estado determinará la salida en función de la variable que la máquina de estado de cambio de pantalla determina que es la pantalla actual.

Máquina de estado de distancia

Esta máquina de estado ejecuta cada ciclo de reloj y determina la distancia total recorrida por el usuario y una vez que se presiona el botón de reinicio, reiniciará la distancia recorrida actual.

Máquina de estado de ubicación:

Esta máquina de estado devuelve la ubicación actual del usuario, utilizando las coordenadas que el módulo GPS devuelve sobre el usuario. Esta máquina de estado depende de la conexión a Internet de los usuarios.

Paso 7: ¡Implementemos nuestro sistema GPS

Una vez que tenemos nuestro módulo GPS enviando información a nuestra Raspberry Pi y nuestra pantalla LCD mostrando información, podemos comenzar a programar nuestro sistema GPS. Usaré las máquinas de estado finito del paso anterior para codificar nuestro sistema GPS

## Archivo principal para el sistema de navegación # # # #

# Bibliotecas para dibujar imágenes

de PIL importar Imagen de PIL importar ImageDraw de PIL importar ImageFont

# Biblioteca para controlador ST7737

importar ST7735 como TFT

# Biblioteca de GPIO para Raspberry Pi

importar Adafruit_GPIO como GPIO importar Adafruit_GPIO. SPI como SPI

# Biblioteca para GPS

#importar gpsd desde gps3 importar gps3

# Biblioteca por tiempo

tiempo de importación

# Biblioteca para encontrar la distancia entre dos puntos

de la importación matemática sin, cos, sqrt, atan2, radianes

# Importar biblioteca Rpi para usar botones para cambiar menús y restablecer

# importar RPi. GPIO como bGPIO

# Configuración de pines para botones

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)

# importar biblioteca geopy para geocodificación

# # El acceso a Internet es necesario para que esto funcione

desde geopy.geocoders import Nominatim

geolocalizador = Nominatim ()

# Constantes para el sistema

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

ANCHO = 128

ALTURA = 160 VELOCIDAD_HZ = 4000000

# Pines de configuración de Raspberry Pi

DC = 24 # A0 en la pantalla TFT RST = 25 # Reset pin en la pantalla TFT SPI_PORT = 0 # Puerto SPI en raspberry pi, SPI0 SPI_DEVICE = 0 # Selección de esclavo en rapsberry pi, CE0

# Crear objeto de pantalla TFT LCD

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

# Inicializar pantalla

disp.begin ()

# El fondo se establecerá en verde

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

# Limpiar la pantalla a blanco y mostrar

# disp.clear ((255, 255, 255)) dibujar = disp.draw () # dibujar.rectángulo ((0, 10, 127, 150), contorno = (255, 0, 0), relleno = (0, 0, 255)) # disp.display ()

# Variables de ubicación de velocidad, latitud y longitud

#currentS = "Velocidad actual:" # Cadena de velocidad #totalDis = "Distancia total:" # Cadena de distancia #currentLoc = "Ubicación actual:" # Cadena de ubicación

# Coordenadas xey de la distancia

distX = 10 distY = 20

pointsList =

# Coordenadas xey de velocidad

velocidadX = 10 velocidadY = 20

# Ubicación xey coordiantes

locX = 10 locY = 20

# Convierte de m / sa mph

conversionVal = 2,24

# Función de actualización de velocidad, devuelve cadena

SpeedVar = 0

def speedFunc (): SpeedVar global 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

ubicación = geolocator.reverse (reverseString)

return (location.address)

# Función de actualización de latitud, devuelve valor flotante

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

# Función de actualización de longitud, devuelve cadena

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

# La función de distancia devuelve la distancia TOTAL recorrida

totalDistance = 0

def distFunc ():

global totalDistance newLat = latFunc () newLon = lonFunc () if (newLat == 0 or 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

# Restablece la distancia total

def resDistance ():

global totalDistance totalDistance = 0

# Función utilizada para encontrar la distancia entre dos coordenadas

# usa la fórmula de Haversine para encontrar. # Los puntos de entrada son una tupla

def coorDistance (punto1, punto2):

# Radio aproximado de la Tierra en kilómetros EarthRadius = 6373.0

lat1 = punto1 [0]

lon1 = punto1 [1]

lat2 = punto2 [0]

lon2 = punto2 [1]

distanciaLon = lon2 - lon1

distanciaLat = lat2 - lat1

# Haversine a

a = sin (distanciaLat / 2) ** 2 + cos (lat1) * cos (lat2) * sin (distanciaLon / 2) ** 2

# Haversine c

c = 2 * atan2 (raíz cuadrada (a), raíz cuadrada (1-a))

# Convertir km a millas

distancia = (earthRadius * c) * 0.62137

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

# Función para mostrar la velocidad en pantalla

def dispSpeed ():

SpeedVar global # Coloque la distancia en la variable en la pantalla draw.text ((speedX, speedY), str (SpeedVar), font = ImageFont.truetype ("Lato-Medium.ttf", 72))

# Función para mostrar la distancia en la pantalla

def dispDistance ():

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

# La función muestra la ubicación en la pantalla, requiere Internet para funcionar

def dispLocation ():

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

# Uso de diccionario para imitar declaraciones de cambio

dispOptions = {

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

# Función de salida de pantalla

def salida ():

# Usando la variable global para displayIndex global displayIndex # Borrando la pantalla y aplicando el fondo disp.clear ((255, 255, 255)) draw.rectangle ((0, 10, 127, 150), outline = (255, 0, 0), llenar = (255, 0, 0))

# Función de llamadas dependiendo del valor de displayIndex

dispOptions [displayIndex] ()

# Se borrará si otro método funciona

# colocar la variable de distancia en la pantalla

# draw.text ((distX, distY), str (distFunc ()), font = ImageFont.load_default ()) # colocar la variable de velocidad en la pantalla # draw.text ((speedX, speedY), speedFunc (), font = ImageFont.load_default ()) # Mostrar actualizaciones a la pantalla disp.display ()

displayButton = 18 # BCM Pin en raspberry pi

resetButton = 23 # Pin BCM en raspberry pi

buttonPress = Falso

def checkDisplay ():

botón global Presione global displayIndex if (bGPIO.input (displayButton) y no buttonPress): displayIndex + = 1 buttonPress = True if (displayIndex == 2): displayIndex = 0 elif (bGPIO.input (displayButton) y buttonPress): imprimir (" Aún presionado ") else: buttonPress = False

# Configurar gps

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

timerPeriod =.5

# Valor de índice para display displayIndex = 0 try: para new_data en 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 () salida () checkDisplay () if (bGPIO.input (resetButton)): resDistance () else: salida () checkDisplay () if (bGPIO.input (resetButton)): resDistance () print ('GPS no conectado todavía') time.sleep (.1) time.sleep (.8) excepto KeyboardInterrupt: gps_socket.close () print (' / nTerminado por el usuario ctrl + c ')

El código anterior es solo un ejemplo de cómo codificar nuestro sistema y he incorporado un video sobre cómo funciona este sistema.