GPS -system: 7 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:46

Projektskapare: Carlos Gomez

Att ha ett pålitligt navigationssystem är av största vikt för alla som försöker resa och utforska världen.

Den viktigaste aspekten som gör att navigationssystemet kan fungera är GPS -funktionen inbäddad inuti systemet. GPS -systemet tillåter vem som helst att hålla reda på sin plats och hastighet för att kunna visa korrekt information om användaren och ge användaren en korrekt bild av var de är och hur långt de är från sin plats.

Global Positioning System (GPS) är ett nätverk av satelliter som kretsar runt jorden på cirka 20 000 km höjd. Alla med en GPS -enhet kan ta emot de radiosignaler som satelliterna sänder och kan använda dem på vilket sätt som behövs. Var du än befinner dig på planeten bör minst fyra GPS vara tillgängliga för dig när som helst. Med en metod som kallas 3D-trilateration kan en GPS-enhet använda tre satelliter för att bestämma enhetens plats på jorden. Var och en av de tre satelliterna skickar en signal till enheten och enheten bestämmer dess avstånd från satelliten. Med hjälp av var och en av de tre avståndsberäkningarna kan enheten nu identifiera sin plats på jorden och den returnerar den till användaren.

GPS -systemet vi kommer att skapa kommer att kunna spåra användarens platser genom att hämta användarens koordinater på jorden och göra några beräkningar för att återställa användarens hastighet, plats och avstånd.

Steg 1: Komma igång

För att få igång detta projekt måste vi först samla in alla rätt material

1: Raspberry Pi Zero W

2: GPS -mottagare

3: 1,8 TFT 128 x 160 LCD SPI -skärm

4: ~ 11 trådar

5: 2 knappar

6: 2x 1k och 2x 10k motstånd för neddragningsknappar

7: Brödbräda

Detta projekt kommer att använda Raspberry Pi: s GPIO -stift och som sådan måste vi ansluta allt med ett brödbräda för att utveckla vårt projekt. Det antas också att lödningen på alla stiften är klar och klar innan vi går vidare och ansluter alla våra delar.

Steg 2: Anslut GPS -modulen till Raspberry Pi

För att använda vårt GPS -system måste du ansluta Tx- och Rx -stiften från GPS -modulen till GPIO -stift 14 och 15 på Raspberry Pi. GPS -mottagarens Tx -pin går till Rx -stiftet på Pi och Rx -stiftet på GPS -mottagaren går till Tx -stiftet på Raspberry pi.

GPS -mottagaren som visas på bilderna kräver att 3,3V används och du kan ansluta 3,3V -stiften till rätt spänning medan du ansluter jordstiftet till marken.

Steg 3: Ta emot data från GPS -mottagarmodulen

För att kunna ta emot data från GPS -mottagaren till Raspberry Pi måste vi låta rätt uttag läsa från UART -portarna. Att läsa rådata skulle kräva att vi skapade vårt eget analysbibliotek, men i det här scenariot kan vi dra nytta av en GPS -demon som körs i bakgrunden för att hjälpa till att analysera data och överföra den till Raspberry Pi

För att uppnå detta kan vi öppna en terminal på Raspberry Pi och köra koden:

sudo apt-get uppdatering

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

Detta borde ta hand om nedladdningen för oss.

När det är klart måste vi inaktivera gpsd -systemtjänsten genom att köra följande kommandon:

sudo systemctl stoppa gpsd.socket

sudo systemctl inaktivera gpsd.socket

Om du någonsin vill aktivera standard gpsd -systemtjänst kan du köra följande kommandon för att återställa den:

sudo systemctl aktivera gpsd.socket

sudo systemctl start gpsd.socket

Nu måste vi starta gpsd -demonen och peka den mot UART -portarna genom att ange

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

Vi kan nu köra kommandot nedan och se all data flyta in!

cgps -s

Steg 4: Anslut skärmen till Raspberry Pi

När vi har vår GPS -mottagare uppe och arbetar med Raspberry Pi kan vi sedan ansluta skärmen till Raspberry Pi. Vi kommer att använda 5 trådar för att ansluta vår LCD -skärm till Raspberry Pi och ytterligare 4 stift för att ansluta strömmen och LED på skärmen.

Jag har inkluderat ett foto av TFT -skärmen jag använder, men det här bör fungera med skärmar av liknande storlek och byggnad.

Anslut LED- och GND till jord och anslut LED+ och VCC till 3,3V.

Anslut RESET -stiftet på skärmen till stift 25 på Pi -kortet.

Anslut A0 till stift 24 på Pi -kortet.

Anslut SDA -stiftet till MOSI -stiftet på Pi -kortet.

Anslut SCK -stiftet på LCD -skärmen till Pi -kortet.

Anslut CS -stiftet till stift 8 på Pi -kortet.

Steg 5: Installera skärmen för att fungera med Raspberry Pi

För att konfigurera displayen måste vi använda ST7735 -biblioteket som finns i den här repon:

Python ST7735 skärmbibliotek

När vi har det här bildskärmsbiblioteket installerat på vårt Raspberry Pi -system kan vi nu fortsätta med att skapa en exempelfil för att bekräfta att våra tidigare kablar fungerar korrekt.

Skapa en fil med titeln example.py och infoga följande text där tillsammans med en exempelbild du väljer i samma mapp

importera ST7735 som TFTimportera Adafruit_GPIO som GPIO importera Adafruit_GPIO. SPI som SPI

BREDD = 128

HÖJD = 160 SPEED_HZ = 4000000

# Raspberry Pi -konfiguration.

# Det här är stiften som behövs för att ansluta LCD -skärmen till Raspberry Pi

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

# Skapa TFT LCD -skärmklass.

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

# Initiera displayen.

disp.begin () disp.reset ()

# Ladda en bild.

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

# Ändra storlek på bilden och rotera den så att den matchar skärmen.

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

# Kommer att skriva ut till terminalen att vårt program ritar vår bild på skärmen

print ('Rita bild')

# Denna funktion visar vår bild på skärmen

disp. display (bild)

Denna fil kommer att konfigurera Raspberry Pi -konfigurationen för LCD -skärmen och biblioteket kommer att konvertera vår bild i mappen och visa den på skärmen.

Steg 6: Konfigurera tillståndsmaskiner för att visa GPS -information på displayen

Vi kommer att använda 5 olika tillståndsmaskiner, medan vi implementerar vårt uppgiftsdiagram för att konfigurera vårt gps -system.

Display Ändra tillståndsmaskin:

Denna tillståndsmaskin kommer att styra vilken som ska visas beroende på vår knappinmatning. Det gör detta genom att ändra en variabel som gör att python kan dra nytta av anttryckning och anropa rätt funktion för att visa beroende på den uppringda funktionen

Hastighetsmaskin:

Denna tillståndsmaskin kommer att köra den aktuella hastigheten beroende på individens plats. Detta kommer att köra varje klockcykel för GPS -systemet

Utmatningstillståndsmaskin:

Denna tillståndsmaskin kommer att bestämma utsignalen baserat på variabeln som displayen för ändringsstatusmaskinen bestämmer för att vara den aktuella displayen.

Avståndstillståndsmaskin

Denna tillståndsmaskin utför varje klockcykel och bestämmer den totala sträckan som användaren rest och när återställningsknappen trycks in återställs den aktuella sträckan.

Plats tillstånd maskin:

Denna tillståndsmaskin returnerar användarens aktuella plats med hjälp av koordinater som GPS -modulen returnerar om användaren. Denna tillståndsmaskin är beroende av användarnas internetanslutning.

Steg 7: Låt oss implementera vårt GPS -system

När vi har vår GPS -modul som skickar information till vår Raspberry Pi och vår LCD -skärm som visar information om den kan vi sedan börja programmera vårt GPS -system. Jag kommer att använda föregående stegs slutliga tillståndsmaskiner för att koda vårt GPS -system

## Huvudfil för navigationssystem # # # #

# Bibliotek för att rita bilder

från PIL import Bild från PIL import ImageDraw från PIL import ImageFont

# Bibliotek för ST7737 -styrenhet

importera ST7735 som TFT

# Bibliotek för GPIO för Raspberry Pi

importera Adafruit_GPIO som GPIO importera Adafruit_GPIO. SPI som SPI

# Bibliotek för GPS

#importera gpsd från gps3 importera gps3

# Bibliotek för tiden

importtid

# Bibliotek för att hitta avstånd mellan två punkter

från matematik importera sin, cos, sqrt, atan2, radianer

# Importera Rpi -bibliotek för att använda knappar för att byta meny och återställa

# importera RPi. GPIO som bGPIO

# Inställningsnålar för knappar

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)

# importera geopi -bibliotek för geokodning

# # Internetåtkomst är nödvändigt för att detta ska fungera

från geopy.geocoders importerar Nominatim

geolocator = Nominatim ()

# Konstanter för systemet

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

BREDD = 128

HÖJD = 160 SPEED_HZ = 4000000

# Raspberry Pi -konfigurationsnålar

DC = 24 # A0 på TFT -skärmen RST = 25 # Återställ stift på TFT -skärm SPI_PORT = 0 # SPI -port på hallon pi, SPI0 SPI_DEVICE = 0 # Slavval på rapsberry pi, CE0

# Skapa TFT LCD -displayobjekt

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

# Initiera displayen

disp.begin ()

# Bakgrunden kommer att vara grön

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

# Rensa skärmen till vitt och visa

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

# Hastighets-, latitud-, longitudplaceringsvariabler

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

# Avstånd x och y koordinater

distX = 10 distY = 20

poänglista =

# Hastighet x och y koordinater

speedX = 10 speedY = 20

# Plats x och y coordiantes

locX = 10 locY = 20

# Konverterar från m/s till mph

conversionVal = 2,24

# Hastighetsuppdateringsfunktion, returnerar sträng

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 -uppdateringsfunktion, returnerar flottörvärde

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

# Uppdateringsfunktion för longitud, returnerar sträng

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

# Distansfunktion returnerar TOTAL sträcka

totalDistance = 0

def distFunc ():

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

# Återställer total distans

def resDistance ():

global totalDistance totalDistance = 0

# Funktion som används för att hitta avstånd mellan två koordinater

# använder Haversines formel för att hitta. # Inmatningspunkter är en tupel

def coorDistance (punkt1, punkt2):

# Ungefärlig radie 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))

# Konvertera km till Miles

avstånd = (earthRadius * c) * 0,62137

if (avstånd <= 0,01): retur 0,00 annars: returrunda (avstånd, 3)

# Funktion för att visa hastighet på skärmen

def dispSpeed ():

global SpeedVar # Placera avståndet på variabeln på skärmen draw.text ((speedX, speedY), str (SpeedVar), font = ImageFont.truetype ("Lato-Medium.ttf", 72))

# Funktion för att visa avstånd på skärmen

def dispDistance ():

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

# Funktion ti visa plats på skärmen, kräver internet för att fungera

def dispLocation ():

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

# Använda ordlista för att efterlikna switch -uttalanden

dispOptions = {

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

# Skärmutmatningsfunktion

def output ():

# Använda global variabel för displayIndex global displayIndex # Rensa skärm och applicera bakgrund disp.clear ((255, 255, 255)) draw.rectangle ((0, 10, 127, 150), disposition = (255, 0, 0), fyll = (255, 0, 0))

# Samtal fungerar beroende på displayIndex -värde

dispOptions [displayIndex] ()

# Raderas om annan metod fungerar

# placera avståndsvariabel på skärmen

#draw.text ((distX, distY), str (distFunc ()), font = ImageFont.load_default ()) #placera hastighetsvariabel på skärmen #draw.text ((speedX, speedY), speedFunc (), font = ImageFont.load_default ()) # Visa uppdateringar till skärmdisplayen ()

displayButton = 18 # BCM Pin på hallon pi

resetButton = 23 # BCM Pin på hallon pi

buttonPress = Falskt

def checkDisplay ():

global knapp Tryck på global displayIndex if (bGPIO.input (displayButton) och inte buttonPress): displayIndex += 1 buttonPress = True if (displayIndex == 2): displayIndex = 0 elif (bGPIO.input (displayButton) och buttonPress): print (" Fortfarande tryckt ") else: buttonPress = Falskt

# Konfigurera gps

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

timerPeriod =.5

# Indexvärde för display displayIndex = 0 försök: för 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) utom KeyboardInterrupt: gps_socket.close () print (' / nTermineras av användaren ctrl+c ')

Koden ovan är bara ett exempel på hur man kodar vårt system och jag har lagt in en video om hur detta system fungerar.