GPS-System - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Projektschöpfer: Carlos Gomez

Ein zuverlässiges Navigationssystem ist für alle, die reisen und die Welt erkunden möchten, von größter Bedeutung.

Der wichtigste Aspekt, der das Funktionieren des Navigationssystems ermöglicht, ist die im System integrierte GPS-Fähigkeit. Das GPS-System ermöglicht es jedem, seinen Standort und seine Geschwindigkeit zu verfolgen, um genaue Informationen über den Benutzer anzuzeigen und dem Benutzer eine genaue Vorstellung davon zu geben, wo er sich befindet und wie weit er von seinem Standort entfernt ist.

Das Global Positioning System (GPS) ist ein Netzwerk von Satelliten, die die Erde in einer Höhe von etwa 20.000 km umkreisen. Jeder, der ein GPS-Gerät besitzt, kann die von den Satelliten ausgestrahlten Funksignale empfangen und beliebig nutzen. Wo auch immer Ihr Standort auf dem Planeten ist, sollten Ihnen zu jeder Zeit mindestens vier GPS zur Verfügung stehen. Mit einer Methode namens 3-D-Trilateration kann ein GPS-Gerät drei Satelliten verwenden, um den Standort des Geräts auf der Erde zu bestimmen. Jeder der drei Satelliten sendet ein Signal an das Gerät und das Gerät bestimmt seine Entfernung zum Satelliten. Mit jeder der drei Entfernungsberechnungen kann das Gerät nun seinen Standort auf der Erde bestimmen und an den Benutzer zurückgeben.

Das von uns erstellte GPS-System wird in der Lage sein, die Standorte des Benutzers zu verfolgen, indem es die Koordinaten des Benutzers auf der Erde erhält und einige Berechnungen durchführt, um die Geschwindigkeit, den Standort und die zurückgelegte Entfernung des Benutzers zurückzugeben.

Schritt 1: Erste Schritte

Um dieses Projekt zu starten, müssen wir zuerst alle richtigen Materialien sammeln

1: Raspberry Pi Zero W

2: GPS-Empfänger

3: 1,8 TFT 128 x 160 LCD SPI-Bildschirm

4: ~11 Drähte

5: 2 Tasten

6: 2x 1k und 2x 10k Widerstände für Pull-Down-Tasten

7: Brotbrett

Dieses Projekt verwendet die GPIO-Pins des Raspberry Pi und als solche müssen wir alles mit einem Steckbrett verbinden, um unser Projekt zu entwickeln. Es wird auch davon ausgegangen, dass das Löten an allen Stiften abgeschlossen und abgeschlossen ist, bevor Sie alle unsere Teile anschließen und verbinden.

Schritt 2: GPS-Modul mit Raspberry Pi verbinden

Für die Verwendung unseres GPS-Systems müssen Sie die Tx- und Rx-Pins des GPS-Moduls mit den GPIO-Pins 14 und 15 des Raspberry Pi verbinden. Der Tx-Pin des GPS-Empfängers geht an den Rx-Pin des Pi und der Rx-Pin des GPS-Empfängers geht an den Tx-Pin des Raspberry Pi.

Der in den Bildern gezeigte GPS-Empfänger benötigt 3,3 V und Sie können die 3,3 V-Pins mit der richtigen Spannung verbinden, während Sie den Masse-Pin mit Masse verbinden.

Schritt 3: Daten vom GPS-Empfängermodul empfangen

Um Daten vom GPS-Empfänger zum Raspberry Pi zu empfangen, müssen wir die richtigen Sockets zum Lesen der UART-Ports ermöglichen. Um die Rohdaten zu lesen, müssten wir unsere eigene Parsing-Bibliothek erstellen, aber in diesem Szenario können wir einen GPS-Daemon nutzen, der im Hintergrund läuft, um die Daten zu analysieren und an den Raspberry Pi zu übertragen

Dazu können wir auf dem Raspberry Pi ein Terminal öffnen und den Code ausführen:

sudo apt-get update

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

Dieser sollte sich um den Download für uns kümmern.

Sobald es abgeschlossen ist, müssen wir den gpsd-Systemdienst deaktivieren, indem wir die folgenden Befehle ausführen:

sudo systemctl stop gpsd.socket

sudo systemctl deaktivieren gpsd.socket

Wenn Sie den standardmäßigen GPSD-Systemdienst jemals aktivieren möchten, können Sie die folgenden Befehle ausführen, um ihn wiederherzustellen:

sudo systemctl aktivieren gpsd.socket

sudo systemctl start gpsd.socket

Jetzt müssen wir den gpsd-Daemon starten und ihn auf die UART-Ports verweisen, indem wir eingeben

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

Wir können jetzt den folgenden Befehl ausführen und sehen, wie alle Daten einfließen!

cgps -s

Schritt 4: Display mit Raspberry Pi verbinden

Sobald wir unseren GPS-Empfänger eingerichtet haben und mit dem Raspberry Pi arbeiten, können wir das Display an den Raspberry Pi anschließen. Wir verwenden 5 Drähte, um unser LCD-Display an den Raspberry Pi anzuschließen, und weitere 4 Pins, um die Hauptstromversorgung und die LED anzuschließen auf dem Bildschirm.

Ich habe ein Foto des TFT-Bildschirms beigefügt, den ich verwende, aber dies sollte mit Bildschirmen ähnlicher Größe und Bauart funktionieren.

Verbinden Sie LED- und GND mit Masse und verbinden Sie LED+ und VCC mit 3.3V.

Verbinden Sie den RESET-Pin auf dem Bildschirm mit Pin 25 auf der Pi-Platine.

Verbinden Sie A0 mit Pin 24 auf der Pi-Platine.

Verbinden Sie den SDA-Pin mit dem MOSI-Pin auf der Pi-Platine.

Verbinden Sie den SCK-Pin auf dem LCD-Bildschirm mit der Pi-Platine.

Verbinden Sie den CS-Pin mit Pin 8 auf der Pi-Platine.

Schritt 5: Einrichten des Displays für die Arbeit mit Raspberry Pi

Um das Display einzurichten, müssen wir die ST7735-Bibliothek verwenden, die in diesem Repository enthalten ist:

Python ST7735-Bildschirmbibliothek

Sobald wir diese Display-Bibliothek auf unserem Raspberry Pi-System installiert haben, können wir nun mit dem Einrichten einer Beispieldatei fortfahren, um zu bestätigen, dass unsere vorherige Verkabelung ordnungsgemäß funktioniert.

Erstellen Sie eine Datei mit dem Titel example.py und fügen Sie dort den folgenden Text zusammen mit einem Beispielbild Ihrer Wahl in denselben Ordner ein

ST7735 als TFT importieren Adafruit_GPIO als GPIO importieren Adafruit_GPIO. SPI als SPI importieren

BREITE = 128

HÖHE = 160 GESCHWINDIGKEIT_HZ = 4000000

# Raspberry Pi-Konfiguration.

# Dies sind die Pins, die benötigt werden, um das LCD mit dem Raspberry Pi zu verbinden

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

# TFT-LCD-Display-Klasse erstellen.

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

# Anzeige initialisieren.

disp.begin() disp.reset()

# Laden Sie ein Bild.

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

# Ändern Sie die Größe des Bildes und drehen Sie es so, dass es der Anzeige entspricht.

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

# Druckt auf dem Terminal, dass unser Programm unser Bild auf dem Bildschirm zeichnet

print('Zeichnungsbild')

# Diese Funktion zeigt unser Bild auf dem Bildschirm an

Anzeige(Bild)

Diese Datei richtet die Raspberry Pi-Konfiguration für den LCD-Bildschirm ein und die Bibliothek konvertiert unser Bild im Ordner und zeigt es auf dem Bildschirm an.

Schritt 6: Einrichten von Zustandsautomaten zur Anzeige von GPS-Informationen auf dem Display

Wir werden 5 verschiedene Zustandsautomaten verwenden, während wir unser Aufgabendiagramm implementieren, um unser GPS-System einzurichten.

Anzeige Change State Machine:

Diese Zustandsmaschine steuert, was angezeigt wird, abhängig von unserer Schaltflächeneingabe. Dies geschieht, indem eine Variable geändert wird, die es Python ermöglicht, die Duck-Eingabe zu nutzen und die richtige Funktion aufzurufen, die abhängig von der aufgerufenen Funktion angezeigt wird

Geschwindigkeitszustandsmaschine:

Diese Zustandsmaschine führt die aktuelle Geschwindigkeit abhängig vom Standort der Person aus. Dadurch wird jeder Taktzyklus für das GPS-System ausgeführt

Ausgabezustandsmaschine:

Diese Zustandsmaschine bestimmt die Ausgabe basierend auf der Variablen, die die Anzeigeänderungs-Zustandsmaschine als die aktuelle Anzeige bestimmt.

Abstandszustandsautomat

Diese Zustandsmaschine führt jeden Taktzyklus aus und bestimmt die vom Benutzer zurückgelegte Gesamtstrecke und setzt die aktuell zurückgelegte Strecke zurück, sobald die Reset-Taste gedrückt wird.

Standortzustandsmaschine:

Diese Zustandsmaschine gibt den aktuellen Standort des Benutzers unter Verwendung von Koordinaten zurück, die das GPS-Modul über den Benutzer zurückgibt. Diese Zustandsmaschine ist von der Internetverbindung des Benutzers abhängig.

Schritt 7: Lassen Sie uns unser GPS-System implementieren

Sobald unser GPS-Modul Informationen an unseren Raspberry Pi sendet und unser LCD-Bildschirm Informationen darauf anzeigt, können wir mit der Programmierung unseres GPS-Systems beginnen. Ich werde die endlichen Automaten des vorherigen Schritts verwenden, um unser GPS-System zu codieren

## Hauptdatei für Navigationssystem # # # #

# Bibliotheken zum Zeichnen von Bildern

aus PIL-Import Bild aus PIL-Import ImageDraw aus PIL-Import ImageFont

# Bibliothek für ST7737-Controller

ST7735 als TFT importieren

# Bibliothek für GPIO für Raspberry Pi

Adafruit_GPIO als GPIO importieren Adafruit_GPIO. SPI als SPI importieren

# Bibliothek für GPS

#gpsd von gps3 importieren gps3 importieren

# Bibliothek für Zeit

Importzeit

# Bibliothek zum Finden der Entfernung zwischen zwei Punkten

aus mathe import sin, cos, sqrt, atan2, radians

# Importieren Sie die Rpi-Bibliothek, um Schaltflächen zum Wechseln von Menüs und zum Zurücksetzen zu verwenden

# RPi. GPIO als bGPIO importieren

# Pins für Buttons einrichten

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)

# Geopy-Bibliothek für Geocoding importieren

# # Internetzugang ist dafür notwendig

von geopy.geocoders importieren Nominatim

Geolokalisierer = Nominatim()

# Konstanten für System

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

BREITE = 128

HÖHE = 160 GESCHWINDIGKEIT_HZ = 4000000

# Raspberry Pi-Konfigurationspins

DC = 24 # A0 auf dem TFT-Bildschirm RST = 25 # Reset-Pin auf dem TFT-Bildschirm SPI_PORT = 0 # SPI-Port auf Himbeer-Pi, SPI0 SPI_DEVICE = 0 # Slave-Auswahl auf Himbeer-Pi, CE0

# TFT-LCD-Anzeigeobjekt erstellen

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

# Anzeige initialisieren

disp.begin()

# Hintergrund wird auf Grün gesetzt

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

# Bildschirm auf Weiß löschen und anzeigen

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

# Platzierungsvariablen für Geschwindigkeit, Breitengrad und Längengrad

#currentS = "Aktuelle Geschwindigkeit: " # Geschwindigkeitsstring #totalDis = "Gesamtdistanz: " # Distanzstring #currentLoc = "Aktueller Standort: " # Standortstring

# Entfernung x- und y-Koordinaten

distX = 10 distY = 20

Punkteliste =

# Geschwindigkeit x- und y-Koordinaten

GeschwindigkeitX = 10 GeschwindigkeitY = 20

# Position x und y Koordinaten

locX = 10 locY = 20

# Konvertiert von m/s in mph

Umrechnungswert = 2,24

# Geschwindigkeitsaktualisierungsfunktion, gibt String zurück

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)

zurück (location.address)

# Breitengrad-Aktualisierungsfunktion, gibt den Float-Wert zurück

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

# Längengrad-Aktualisierungsfunktion, gibt String zurück

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

# Distanzfunktion gibt die GESAMTE gefahrene Distanz zurück

Gesamtdistanz = 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

# Setzt die Gesamtstrecke zurück

def resDistance():

global totalDistance totalDistance = 0

# Funktion zum Ermitteln der Entfernung zwischen zwei Koordinaten

# verwendet die Formel von Haversine, um zu finden. # Eingabepunkte sind ein Tupel

def coorDistance(point1, point2):

# Ungefährer Radius der Erde in Kilometern earthRadius = 6373.0

lat1 = point1[0]

lon1 = Punkt1[1]

lat2 = point2[0]

lon2 = Punkt2[1]

AbstandLon = lon2 - lon1

distanceLat = lat2 - lat1

# Haversine a

a = sin(AbstandLat/2)**2 + cos(Lat1) * cos(Lat2) * sin(AbstandLon/2)**2

# Haversine c

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

# Kilometer in Meilen umrechnen

Entfernung = (ErdRadius * c) * 0,62137

if(Abstand <= 0,01): Rückgabe 0,00 else: Rückgabe Runde(Abstand, 3)

# Funktion zur Anzeige der Geschwindigkeit auf dem Bildschirm

def dispSpeed():

global SpeedVar # Abstand auf Variable auf dem Bildschirm platzieren draw.text((speedX, speedY), str(SpeedVar), font=ImageFont.truetype("Lato-Medium.ttf", 72))

# Funktion zum Anzeigen der Entfernung auf dem Bildschirm

def dispDistance():

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

# Funktion zur Anzeige des Standorts auf dem Bildschirm, erfordert Internet, um zu funktionieren

def dispLocation():

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

# Verwenden eines Wörterbuchs, um Switch-Anweisungen nachzuahmen

dispOptions = {

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

# Bildschirmausgabefunktion

def-Ausgabe():

# Globale Variable für displayIndex verwenden global displayIndex # Bildschirm löschen und Hintergrund anwenden disp.clear((255, 255, 255)) draw.rectangle((0, 10, 127, 150), outline=(255, 0, 0), füllen=(255, 0, 0))

# Ruft die Funktion abhängig vom displayIndex-Wert auf

dispOptions[displayIndex]()

# Wird gelöscht, wenn andere Methode funktioniert

# Abstandsvariable auf dem Bildschirm platzieren

#draw.text((distX, distY), str(distFunc()), font=ImageFont.load_default()) # Geschwindigkeitsvariable auf dem Bildschirm platzieren #draw.text((speedX, speedY), speedFunc(), font=ImageFont.load_default()) # Aktualisierungen des Bildschirms anzeigen disp.display()

displayButton = 18 # BCM Pin auf himbeer pi

resetButton = 23 # BCM Pin auf himbeer pi

buttonPress = False

def checkDisplay():

global buttonPress global displayIndex if(bGPIO.input(displayButton) und nicht buttonPress): displayIndex += 1 buttonPress = True if(displayIndex == 2): displayIndex = 0 elif(bGPIO.input(displayButton) and buttonPress): print (" Noch gedrückt") sonst: buttonPress = False

# GPS einrichten

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

TimerPeriode =.5

# Indexwert für die Anzeige displayIndex = 0 try: for new_data in 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 noch nicht verbunden') time.sleep(.1) time.sleep(.8) außer KeyboardInterrupt: gps_socket.close() print(' \nBeendet durch Benutzer Strg+c')

Der obige Code ist nur ein Beispiel für die Codierung unseres Systems und ich habe ein Video zur Funktionsweise dieses Systems eingebettet.