GPS -system: 7 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:24

Prosjektskapar: Carlos Gomez

Å ha et pålitelig navigasjonssystem er viktig for alle som prøver å reise og utforske verden.

Det viktigste aspektet som lar navigasjonssystemet fungere er GPS -funksjonen som er innebygd inne i systemet. GPS -systemet lar alle holde oversikt over posisjonen og hastigheten for å vise nøyaktig informasjon om brukeren og gi brukeren en nøyaktig fremstilling av hvor de er og hvor langt de er fra posisjonen.

Global Positioning System (GPS) er et nettverk av satellitter som kretser rundt jorden i en høyde på omtrent 20 000 km. Alle med en GPS -enhet kan motta radiosignalene som satellittene sender og kan bruke dem på hvilken måte som er nødvendig. Uansett hvor du befinner deg på planeten, bør minst fire GPS være tilgjengelig for deg når som helst. Ved hjelp av en metode som kalles 3D-trilaterering, kan en GPS-enhet bruke tre satellitter for å bestemme enhetens plassering på jorden. Hver av de tre satellittene sender et signal til enheten, og enheten bestemmer avstanden fra satellitten. Ved å bruke hver av de tre avstandsberegningene kan enheten nå finne posisjonen på jorden, og den returnerer den til brukeren.

GPS -systemet vi vil lage vil kunne spore brukerens posisjoner ved å hente brukerens koordinater på jorden og gjøre noen beregninger for å returnere brukerens hastighet, plassering og tilbakelagte distanse.

Trinn 1: Komme i gang

For å få dette prosjektet i gang må vi først samle alt det riktige materialet

1: Raspberry Pi Zero W

2: GPS -mottaker

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

4: ~ 11 ledninger

5: 2 knapper

6: 2x 1k og 2x 10k motstander for nedtrekksknapper

7: Brødbrett

Dette prosjektet vil bruke Raspberry Pi's GPIO -pinner, og som sådan må vi koble alt med et brødbrett for å utvikle prosjektet vårt. Det er også antatt at lodding på alle pinnene er ferdig og ferdig før du går videre og kobler alle våre deler.

Trinn 2: Koble GPS -modulen til Raspberry Pi

For bruk av vårt GPS -system må du koble Tx- og Rx -pinnene fra GPS -modulen til GPIO pin 14 og 15 på Raspberry Pi. Tx -pinnen til GPS -mottakeren går til Rx -pinnen til Pi og Rx -pinnen til GPS -mottakeren går til Tx -pinnen på Raspberry pi.

GPS -mottakeren vist på bildene krever at 3,3V brukes, og du kan koble 3,3V -pinnene til riktig spenning, mens du kobler jordpinnen til bakken.

Trinn 3: Motta data fra GPS -mottakermodul

For å motta data fra GPS -mottakeren til Raspberry Pi må vi la de riktige kontaktene lese fra UART -portene. Å lese rådata ville kreve at vi opprettet vårt eget analysebibliotek, men i dette scenariet kan vi dra nytte av en GPS -demon som kjører i bakgrunnen for å hjelpe til med å analysere dataene og overføre dem til Raspberry Pi

For å oppnå dette kan vi åpne en terminal på Raspberry Pi og utføre koden:

sudo apt-get oppdatering

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

Dette bør ta seg av nedlastingen for oss.

Når den er fullført, må vi deaktivere gpsd -systemtjenesten ved å kjøre følgende kommandoer:

sudo systemctl stopp gpsd.socket

sudo systemctl deaktiver gpsd.socket

Hvis du noen gang vil aktivere standard gpsd -systemtjeneste, kan du kjøre følgende kommandoer for å gjenopprette den:

sudo systemctl aktiver gpsd.socket

sudo systemctl start gpsd.socket

Nå må vi starte gpsd -demonen og peke den mot UART -portene ved å gå inn

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

Vi kan nå kjøre kommandoen nedenfor og se alle dataene flyte inn!

cgps -s

Trinn 4: Koble skjermen til Raspberry Pi

Når vi har GPS -mottakeren oppe og jobber med Raspberry Pi, kan vi deretter koble skjermen til Raspberry Pi. Vi bruker 5 ledninger til å koble LCD -skjermen til Raspberry Pi og ytterligere 4 pinner for å koble strøm og LED. på skjermen.

Jeg har tatt med et bilde av TFT -skjermen jeg bruker, men dette bør fungere med skjermer av lignende størrelse og bygg.

Koble LED- og GND til jord og koble LED+ og VCC til 3,3V.

Koble RESET -pinnen på skjermen til pinne 25 på Pi -kortet.

Koble A0 til pin 24 på Pi -kortet.

Koble SDA -pinnen til MOSI -pinnen på Pi -kortet.

Koble SCK -pinnen på LCD -skjermen til Pi -kortet.

Koble CS -pinnen til pinne 8 på Pi -kortet.

Trinn 5: Konfigurer skjermen for å fungere med Raspberry Pi

For å sette opp skjermen må vi bruke ST7735 -biblioteket som finnes i denne repoen:

Python ST7735 skjermbibliotek

Når vi har dette skjermbiblioteket installert på Raspberry Pi -systemet vårt, kan vi nå fortsette med å sette opp en eksempelfil for å bekrefte at våre tidligere ledninger fungerer som de skal.

Lag en fil med tittelen example.py og sett inn følgende tekst der sammen med et eksempelbilde du velger i samme mappe

import ST7735 som TFTimport Adafruit_GPIO som GPIO import Adafruit_GPIO. SPI som SPI

BREDDE = 128

HØYDE = 160 SPEED_HZ = 4000000

# Raspberry Pi -konfigurasjon.

# Dette er pinnene som trengs for å koble LCD -skjermen til Raspberry Pi

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

# Lag TFT LCD -skjermklasse.

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

# Initialiser visning.

disp.begin () disp.reset ()

# Last inn et bilde.

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

# Endre størrelsen på bildet og roter det slik at det samsvarer med skjermen.

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

# Vil skrive ut til terminalen at programmet vårt tegner bildet vårt på skjermen

print ('Tegning av bilde')

# Denne funksjonen viser bildet vårt på skjermen

disp. display (bilde)

Denne filen vil konfigurere Raspberry Pi -konfigurasjonen for LCD -skjermen, og biblioteket vil konvertere bildet vårt i mappen og vise det på skjermen.

Trinn 6: Konfigurer tilstandsmaskiner for å vise GPS -informasjon på skjermen

Vi vil bruke 5 forskjellige statlige maskiner, mens vi implementerer oppgavediagrammet for å sette opp vårt gps -system.

Display Endre tilstandsmaskin:

Denne tilstandsmaskinen vil kontrollere hvilken som skal vises, avhengig av knappens inngang. Det gjør dette ved å endre en variabel som gjør at python kan dra fordel av andetyping og kalle riktig funksjon for å vise, avhengig av den kalte funksjonen

Hastighetstilstandsmaskin:

Denne tilstandsmaskinen vil utføre gjeldende hastighet avhengig av individets beliggenhet. Dette vil utføre hver klokkesyklus for GPS -systemet

Utgangstilstandsmaskin:

Denne tilstandsmaskinen vil bestemme utgangen basert på variabelen som displayet for endringstilstandsmaskin bestemmer for å være gjeldende skjerm.

Avstandstilstandsmaskin

Denne tilstandsmaskinen utfører hver klokkesyklus og bestemmer den totale distansen som brukeren har reist, og når tilbakestillingsknappen blir trykket på, tilbakestiller den gjeldende distansen.

Plassering tilstandsmaskin:

Denne tilstandsmaskinen returnerer brukerens nåværende posisjon ved å bruke koordinater som GPS -modulen returnerer om brukeren. Denne tilstandsmaskinen er avhengig av brukernes internettforbindelse.

Trinn 7: La oss implementere vårt GPS -system

Når vi har GPS -modulen vår som sender informasjon til Raspberry Pi og LCD -skjermen som viser informasjon om den, kan vi begynne å programmere GPS -systemet vårt. Jeg vil bruke forrige trinns endelige tilstandsmaskiner for å kode vårt GPS -system

## Hovedfil for navigasjonssystem # # # #

# Biblioteker for å tegne bilder

fra PIL import Bilde fra PIL import ImageDraw fra PIL import ImageFont

# Bibliotek for ST7737 -kontrolleren

importer ST7735 som TFT

# Bibliotek for GPIO for Raspberry Pi

importer Adafruit_GPIO som GPIO import Adafruit_GPIO. SPI som SPI

# Bibliotek for GPS

#import gpsd fra gps3 import gps3

# Bibliotek for tid

importtid

# Bibliotek for å finne avstand mellom to punkter

fra matematikk import sin, cos, sqrt, atan2, radianer

# Importer Rpi -bibliotek for å bruke knapper til å bytte meny og tilbakestille

# importer RPi. GPIO som bGPIO

# Oppsettpinner for knapper

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)

# importere geopi -bibliotek for geokoding

# # Internett -tilgang er nødvendig for at dette skal fungere

fra geopy.geocoders importerer Nominatim

geolocator = Nominatim ()

# Konstanter for system

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

BREDDE = 128

HØYDE = 160 SPEED_HZ = 4000000

# Raspberry Pi -konfigurasjonsnåler

DC = 24 # A0 på TFT -skjermen RST = 25 # Tilbakestill pin på TFT -skjermen SPI_PORT = 0 # SPI -port på bringebær pi, SPI0 SPI_DEVICE = 0 # Slave select på rapsberry pi, CE0

# Lag TFT LCD -skjermobjekt

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

# Initialiser visning

disp.begin ()

# Bakgrunnen blir satt til grønt

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

# Fjern skjermen til hvit og vis den

#disp.clear ((255, 255, 255)) draw = disp.draw () #draw.rectangle ((0, 10, 127, 150), disposisjon = (255, 0, 0), fyll = (0, 0, 255)) #disp. Display ()

# Plasseringsvariabler for hastighet, breddegrad, lengdegrad

#currentS = "Current Speed:" # Speed string #totalDis = "Total Distance:" # Distance string #currentLoc = "Current Location:" # Location string

# Avstand x og y koordinater

distX = 10 distY = 20

poengListe =

# Hastighet x og y koordinater

speedX = 10 speedY = 20

# Plassering x og y koordiantene

locX = 10 locY = 20

# Konverterer fra m/s til mph

conversionVal = 2,24

# Hastighetsoppdateringsfunksjon, returnerer streng

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)

retur (location.address)

# Latitude oppdateringsfunksjon, returnerer flyteverdi

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

# Lengdegrad oppdateringsfunksjon, returnerer streng

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

# Avstandsfunksjon returnerer TOTAL tilbakelagt distanse

total avstand = 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

# Tilbakestiller total distanse

def resDistance ():

global totalDistance totalDistance = 0

# Funksjon som brukes til å finne avstand mellom to koordinater

# bruker Haversines formel for å finne. # Inngangspunkter er en tupel

def coorDistance (punkt1, punkt2):

# Omtrentlig radius av jorden i kilometer earthRadius = 6373,0

lat1 = punkt1 [0]

lon1 = punkt1 [1]

lat2 = punkt2 [0]

lon2 = punkt2 [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))

# Konverter km til Miles

avstand = (earthRadius * c) * 0,62137

hvis (avstand <= 0,01): returner 0,00 annet: returrunde (avstand, 3)

# Funksjon for å vise hastighet på skjermen

def dispSpeed ():

global SpeedVar # Plasser avstanden på variabelen på skjermen draw.text ((speedX, speedY), str (SpeedVar), font = ImageFont.truetype ("Lato-Medium.ttf", 72))

# Funksjon for å vise avstand på skjermen

def dispDistance ():

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

# Funksjon ti visningssted på skjermen, krever internett for å fungere

def dispLocation ():

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

# Bruke ordbok for å etterligne bytteuttalelser

dispOptions = {

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

# Skjermutgangsfunksjon

def output ():

# Bruke global variabel for displayIndex global displayIndex # Slette skjerm og bruke bakgrunn disp.clear ((255, 255, 255)) draw.rectangle ((0, 10, 127, 150), disposisjon = (255, 0, 0), fyll = (255, 0, 0))

# Anropsfunksjon avhengig av displayIndex -verdi

dispOptions [displayIndex] ()

# Vil slette hvis en annen metode fungerer

# plassavstandsvariabel på skjermen

#draw.text ((distX, distY), str (distFunc ()), font = ImageFont.load_default ()) #plasser hastighetsvariabel på skjermen #draw.text ((speedX, speedY), speedFunc (), font = ImageFont.load_default ()) # Vis oppdateringer til skjermdisplay ()

displayButton = 18 # BCM Pin på bringebær pi

resetButton = 23 # BCM Pin på bringebær pi

buttonPress = Falsk

def checkDisplay ():

global buttonPress global displayIndex if (bGPIO.input (displayButton) and not buttonPress): displayIndex += 1 buttonPress = True if (displayIndex == 2): displayIndex = 0 elif (bGPIO.input (displayButton) and buttonPress): print (" Fortsatt trykket ") else: buttonPress = False

# Oppsett gps

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

timerPeriod =.5

# Indeksverdi for display displayIndex = 0 prøve: for new_data i 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 not connected yet') time.sleep (.1) time.sleep (.8) unntatt KeyboardInterrupt: gps_socket.close () print (' / nTerminert av brukeren ctrl+c ')

Koden ovenfor er bare ett eksempel på hvordan vi skal kode systemet vårt, og jeg har lagt inn en video om hvordan dette systemet fungerer.