GPS-systeem: 7 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Projectmaker: Carlos Gomez

Het hebben van een betrouwbaar navigatiesysteem is van het grootste belang voor iedereen die probeert te reizen en de wereld te verkennen.

Het belangrijkste aspect dat ervoor zorgt dat het navigatiesysteem werkt, is de GPS-mogelijkheid die in het systeem is ingebouwd. Met het GPS-systeem kan iedereen zijn locatie en snelheid bijhouden om nauwkeurige informatie over de gebruiker weer te geven en de gebruiker een nauwkeurige weergave te geven van waar ze zich bevinden en hoe ver ze van hun locatie verwijderd zijn.

Het Global Positioning System (GPS) is een netwerk van satellieten die op een hoogte van ongeveer 20.000 km rond de aarde cirkelen. Iedereen met een GPS-apparaat kan de radiosignalen ontvangen die de satellieten uitzenden en kan ze op elke gewenste manier gebruiken. Waar ter wereld uw locatie ook is, er moeten op elk moment ten minste vier GPS-systemen voor u beschikbaar zijn. Met behulp van een methode die 3D-trilateratie wordt genoemd, kan een GPS-apparaat drie satellieten gebruiken om de locatie van het apparaat op aarde te bepalen. Elk van de drie satellieten stuurt een signaal naar het apparaat en het apparaat bepaalt de afstand tot de satelliet. Met behulp van elk van de drie afstandsberekeningen is het apparaat nu in staat om zijn locatie op de aarde te bepalen en die aan de gebruiker terug te geven.

Het GPS-systeem dat we zullen maken, kan de locaties van de gebruiker volgen door de coördinaten van de gebruiker op aarde te verkrijgen en enkele berekeningen uit te voeren om de snelheid, locatie en de afgelegde afstand van de gebruiker te retourneren.

Stap 1: Aan de slag

Om dit project op gang te krijgen, moeten we eerst alle juiste materialen verzamelen

1: Raspberry Pi Nul W

2: GPS-ontvanger:

3: 1.8 TFT 128 x 160 LCD SPI-scherm

4: ~11 draden

5: 2 knoppen

6: 2x 1k en 2x 10k weerstanden voor pull-down buttons

7: Broodplank

Dit project zal de GPIO-pinnen van de Raspberry Pi gebruiken en daarom zullen we alles met een breadboard moeten verbinden om ons project te ontwikkelen. Er wordt ook aangenomen dat het solderen op alle pinnen is voltooid en voltooid voordat we verder gaan en al onze onderdelen aansluiten.

Stap 2: Sluit de GPS-module aan op de Raspberry Pi

Voor het gebruik van ons GPS-systeem moet u de Tx- en Rx-pinnen van de GPS-module verbinden met GPIO-pin 14 en 15 op de Raspberry Pi. De Tx-pin van de GPS-ontvanger gaat naar de Rx-pin van de Pi en de Rx-pin van de GPS-ontvanger gaat naar de Tx-pin van de Raspberry pi.

De GPS-ontvanger die in de afbeeldingen wordt getoond, heeft 3,3 V nodig om te worden gebruikt en u kunt de 3,3 V-pinnen aansluiten op de juiste spanning, terwijl u de aardingspin met aarde verbindt.

Stap 3: Ontvang gegevens van de GPS-ontvangermodule

Om gegevens van de GPS-ontvanger naar de Raspberry Pi te ontvangen, moeten we de juiste sockets van de UART-poorten laten lezen. Als we de onbewerkte gegevens lezen, moeten we onze eigen parseerbibliotheek maken, maar in dit scenario kunnen we profiteren van een GPS-daemon die op de achtergrond draait om de gegevens te helpen ontleden en naar de Raspberry Pi te verzenden

Om dit te bereiken kunnen we een terminal op de Raspberry Pi openen en de code uitvoeren:

sudo apt-get update

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

Dit zou de download voor ons moeten regelen.

Zodra het is voltooid, moeten we de gpsd-systeemservice uitschakelen door de volgende opdrachten uit te voeren:

sudo systemctl stop gpsd.socket

sudo systemctl gpsd.socket uitschakelen

Als u ooit de standaard gpsd-systeemservice wilt inschakelen, kunt u de volgende opdrachten uitvoeren om deze te herstellen:

sudo systemctl gpsd.socket inschakelen

sudo systemctl start gpsd.socket

Nu moeten we de gpsd-daemon starten en naar de UART-poorten wijzen door in te voeren

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

We kunnen nu de onderstaande opdracht uitvoeren en alle gegevens zien binnenzweven!

cgps -s

Stap 4: Sluit het scherm aan op de Raspberry Pi

Zodra we onze GPS-ontvanger hebben geïnstalleerd en werken met de Raspberry Pi, kunnen we het scherm aansluiten op de Raspberry Pi. We zullen 5 draden gebruiken om ons LCD-scherm op de Raspberry Pi aan te sluiten en nog eens 4 pinnen om de hoofdvoeding en LED aan te sluiten op het scherm.

Ik heb een foto bijgevoegd van het TFT-scherm dat ik gebruik, maar dit zou moeten werken met schermen van vergelijkbare grootte en constructie.

Verbind LED- en GND met massa en sluit LED+ en VCC aan op 3.3V.

Verbind de RESET-pin op het scherm met pin 25 op het Pi-bord.

Sluit A0 aan op pin 24 op het Pi-bord.

Verbind de SDA-pin met de MOSI-pin op het Pi-bord.

Verbind de SCK-pin op het LCD-scherm met het Pi-bord.

Sluit de CS-pin aan op pin 8 op het Pi-bord.

Stap 5: Stel het display in om met Raspberry Pi te werken

Om het display in te stellen, moeten we de ST7735-bibliotheek gebruiken die in deze repo te vinden is:

Python ST7735 Schermbibliotheek

Zodra we deze weergavebibliotheek op ons Raspberry Pi-systeem hebben geïnstalleerd, kunnen we nu doorgaan met het opzetten van een voorbeeldbestand om te bevestigen dat onze vorige bedrading correct werkt.

Maak een bestand met de titel example.py en voeg de volgende tekst daarin samen met een voorbeeldafbeelding naar keuze in dezelfde map in

importeer ST7735 als TFTimporteer Adafruit_GPIO als GPIO importeer Adafruit_GPIO. SPI als SPI

BREEDTE = 128

HOOGTE = 160 SNELHEID_HZ = 4000000

# Raspberry Pi-configuratie.

# Dit zijn de pinnen die nodig zijn om het LCD-scherm op de Raspberry Pi aan te sluiten

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

# Creëer TFT LCD-schermklasse.

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

# Initialiseer de weergave.

disp.begin() disp.reset()

# Laad een afbeelding.

newData = 0x42 disp.command(newData) print('Bezig met laden van afbeelding…') image = Image.open('cat.jpg')

# Pas het formaat van de afbeelding aan en draai deze zodat deze overeenkomt met het scherm.

afbeelding = afbeelding.rotate(270).resize((BREEDTE, HOOGTE))

# Zal naar de terminal afdrukken dat ons programma onze afbeelding op het scherm tekent

print('Tekening afbeelding')

# Deze functie toont onze afbeelding op het scherm

disp.display(afbeelding)

Dit bestand zal de Raspberry Pi-configuratie voor het LCD-scherm instellen en de bibliotheek zal onze afbeelding in de map converteren en op het scherm weergeven.

Stap 6: State Machines instellen om GPS-informatie op het display weer te geven

We zullen 5 verschillende staatsmachines gebruiken, terwijl we ons taakdiagram implementeren om ons gps-systeem in te stellen.

Display Verander staat machine:

Deze statusmachine bepaalt welke wordt weergegeven, afhankelijk van onze knopinvoer. Het doet dit door een variabele te wijzigen waarmee python kan profiteren van het typen van eenden en de juiste functie aanroept om weer te geven, afhankelijk van de aangeroepen functie

Snelheid staat machine:

Deze statusmachine voert de huidige snelheid uit, afhankelijk van de locatie van de persoon. Dit zal elke klokcyclus voor het GPS-systeem uitvoeren

Uitgangsstatus machine:

Deze toestandsmachine bepaalt de uitvoer op basis van de variabele waarvan de weergaveveranderingstoestandsmachine bepaalt dat dit de huidige weergave is.

Afstand staat machine:

Deze statusmachine voert elke klokcyclus uit en bepaalt de totale afstand die de gebruiker heeft afgelegd en zodra de resetknop wordt ingedrukt, wordt de huidige afgelegde afstand gereset.

Locatie staat machine:

Deze statusmachine retourneert de huidige locatie van de gebruiker, met behulp van coördinaten die de GPS-module over de gebruiker retourneert. Deze statusmachine is afhankelijk van de internetverbinding van de gebruiker.

Stap 7: Laten we ons GPS-systeem implementeren

Zodra onze GPS-module informatie naar onze Raspberry Pi stuurt en ons LCD-scherm informatie erop weergeeft, kunnen we beginnen met het programmeren van ons GPS-systeem. Ik zal de eindige-toestandsmachines van de vorige stap gebruiken om ons GPS-systeem te coderen

## Hoofdbestand voor navigatiesysteem # # # #

# Bibliotheken voor het tekenen van afbeeldingen

uit PIL import Afbeelding uit PIL import ImageDraw uit PIL import ImageFont

# Bibliotheek voor ST7737-controller

importeer ST7735 als TFT

# Bibliotheek voor GPIO voor Raspberry Pi

importeer Adafruit_GPIO als GPIO importeer Adafruit_GPIO. SPI als SPI

# Bibliotheek voor GPS

#import gpsd van gps3 importeer gps3

# Bibliotheek voor tijd

import tijd

# Bibliotheek voor het vinden van de afstand tussen twee punten

uit wiskunde import sin, cos, sqrt, atan2, radialen

# Importeer Rpi-bibliotheek om knoppen te gebruiken om van menu te wisselen en opnieuw in te stellen

# importeer RPi. GPIO als bGPIO

# Stel pinnen voor knoppen in

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)

# importeer geopy-bibliotheek voor geocodering

# # Internettoegang is nodig om dit te laten werken

van geopy.geocoders import Nominatim

geolocator = Nominaat()

# Constanten voor systeem

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

BREEDTE = 128

HOOGTE = 160 SNELHEID_HZ = 4000000

# Raspberry Pi-configuratiepinnen

DC = 24 # A0 op het TFT-scherm RST = 25 # Reset pin op TFT-scherm SPI_PORT = 0 # SPI-poort op raspberry pi, SPI0 SPI_DEVICE = 0 # Slave select op rapsberry pi, CE0

# Maak een TFT LCD-weergaveobject

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

# Scherm initialiseren

disp.begin()

# Achtergrond wordt op groen gezet

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

# Wis het scherm naar wit en geef weer

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

# Plaatsingsvariabelen voor snelheid, breedtegraad, lengtegraad

#currentS = "Huidige snelheid: " # Snelheidsreeks #totalDis = "Totale afstand: " # Afstandsreeks #currentLoc = "Huidige locatie: " # Locatiereeks

# Afstand x- en y-coördinaten

distX = 10 distY = 20

puntenLijst =

# Snelheid x- en y-coördinaten

snelheidX = 10 snelheidY = 20

# Locatie x en y coördinaten

locX = 10 locY = 20

# Converteert van m/s naar mph

conversieVal = 2.24

# Snelheidsupdatefunctie, retourneert string

SnelheidVar = 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 locatieFunc():

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

reverseString = latLoc + ", " + lonLoc

locatie = geolocator.reverse(reverseString)

retour (locatie.adres)

# Latitude-updatefunctie, retourneert float-waarde

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

# Longitude update-functie, retourneert string

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

# Afstandsfunctie retourneert TOTAL afgelegde afstand

totale afstand = 0

def distFunc():

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

# Reset totale afstand

def resDistance():

globaal totaalAfstand totaalAfstand = 0

# Functie die wordt gebruikt om de afstand tussen twee coördinaten te vinden

# gebruikt de formule van Haversine om te vinden. # Invoerpunten zijn een tupel

def coorAfstand (punt1, punt2):

# Geschatte straal van de aarde in kilometers earthRadius = 6373.0

lat1 = punt1[0]

lon1 = punt1[1]

lat2 = punt2[0]

lon2 = punt2[1]

afstandLon = lon2 - lon1

afstandLat = lat2 - lat1

# Haversine en

a = sin(afstandLat/2)**2 + cos(lat1) * cos(lat2) * sin(afstandLon/2)**2

# Haversine c

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

# Converteer km naar Miles

afstand = (aardstraal * c) * 0,62137

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

# Functie om snelheid op het scherm weer te geven

def dispSpeed():

global SpeedVar # Plaats afstand op variabele op scherm draw.text((speedX, speedY), str(SpeedVar), font=ImageFont.truetype("Lato-Medium.ttf", 72))

# Functie om afstand op het scherm weer te geven

def dispDistance():

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

# Functie om locatie op het scherm weer te geven, vereist internet om te werken

def dispLocation():

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

# Woordenboek gebruiken om schakelinstructies na te bootsen

dispOptions = {

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

# Schermuitvoerfunctie

def-uitvoer():

# Globale variabele gebruiken voor displayIndex global displayIndex # Scherm wissen en achtergrond toepassen disp.clear((255, 255, 255)) draw.rectangle((0, 10, 127, 150), outline=(255, 0, 0), vullen=(255, 0, 0))

# Oproepen functie afhankelijk van displayIndex waarde

dispOptions[displayIndex]()

# Zal wissen als een andere methode werkt

# plaats afstandsvariabele op scherm

#draw.text((distX, distY), str(distFunc()), font=ImageFont.load_default()) # plaats snelheidsvariabele op het scherm #draw.text((speedX, speedY), speedFunc(), font=ImageFont.load_default()) # Display-updates naar scherm disp.display()

displayButton = 18 # BCM Pin op Raspberry Pi

resetButton = 23 # BCM Pin op raspberry pi

knopDruk = False

def checkDisplay():

global buttonDruk global displayIndex if(bGPIO.input(displayButton) en niet buttonPress): displayIndex += 1 buttonPress = True if(displayIndex == 2): displayIndex = 0 elif(bGPIO.input(displayButton) en buttonPress): print (" Nog steeds ingedrukt") else: buttonDruk = False

# GPS instellen

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

timerPeriode =.5

# Indexwaarde voor display 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 nog niet verbonden') time.sleep(.1) time.sleep(.8) behalve KeyboardInterrupt: gps_socket.close() print(' \nBeëindigd door gebruiker ctrl+c')

De bovenstaande code is slechts één voorbeeld van hoe ons systeem te coderen en ik heb een video ingesloten over hoe dit systeem werkt.