GPS -stelsel: 7 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:27

Skepper van die projek: Carlos Gomez

Om 'n betroubare navigasiestelsel te hê, is uiters belangrik vir almal wat wil reis en die wêreld wil verken.

Die belangrikste aspek waarmee die navigasiestelsel werk, is die GPS -funksie wat in die stelsel ingebed is. Met die GPS -stelsel kan almal hul ligging en spoed byhou om akkurate inligting oor die gebruiker te vertoon en die gebruiker 'n akkurate voorstelling te gee van waar hulle is en hoe ver hulle van hul ligging is.

Die Global Positioning System (GPS) is 'n netwerk van satelliete wat om die aarde wentel op 'n hoogte van ongeveer 20 000 km. Almal met 'n GPS -toestel kan die radioseine wat die satelliete uitsaai ontvang, ontvang en kan dit op elke manier gebruik. Waar u ook al op die planeet is, moet ten minste vier GPS te alle tye beskikbaar wees. Deur 'n metode genaamd 3D-trilaterasie te gebruik, kan 'n GPS-toestel drie satelliete gebruik om die ligging van die toestel op die aarde te bepaal. Elkeen van die drie satelliete stuur 'n sein na die toestel en die toestel bepaal die afstand van die satelliet. Deur elkeen van die drie afstandberekenings te gebruik, kan die toestel nou sy ligging op die aarde bepaal en dit aan die gebruiker terugbesorg.

Die GPS -stelsel wat ons sal skep, sal die gebruiker se ligging kan opspoor deur die koördinate van die gebruiker op die aarde te kry en 'n paar berekeninge te doen om die gebruiker se spoed, ligging en die afgelegde afstand terug te gee.

Stap 1: Aan die gang

Om hierdie projek aan die gang te kry, moet ons eers al die korrekte materiaal bymekaarmaak

1: Framboos Pi Zero W

2: GPS -ontvanger

3: 1.8 TFT 128 x 160 LCD SPI -skerm

4: ~ 11 drade

5: 2 knoppies

6: 2x 1k en 2x 10k weerstande vir aftrekknoppies

7: Broodbord

Hierdie projek sal die GPIO -penne van die Raspberry Pi gebruik, en as sodanig moet ons alles met 'n broodbord verbind om ons projek te ontwikkel. Daar word ook aanvaar dat die soldeer op al die penne klaar is voordat ons verder gaan en al ons dele verbind.

Stap 2: Koppel die GPS -module aan die Raspberry Pi

Vir die gebruik van ons GPS -stelsel moet u die Tx- en Rx -penne van die GPS -module aan GPIO -pen 14 en 15 op die Raspberry Pi koppel. Die Tx -pen van die GPS -ontvanger gaan na die Rx -pen van die Pi en die Rx -pen van die GPS -ontvanger gaan na die Tx -pen van die Framboospi.

Die GPS -ontvanger wat op die beelde verskyn, vereis dat 3.3V gebruik word, en u kan die 3.3V -penne op die korrekte spanning koppel, terwyl u die grondpen aan die aarde koppel.

Stap 3: Ontvang data vanaf die GPS -ontvanger -module

Om data van die GPS -ontvanger na die Raspberry Pi te ontvang, moet ons die regte voetstukke laat lees vanaf die UART -poorte. Om die rou data te lees, sal ons ons eie ontledingsbiblioteek moet skep, maar in hierdie scenario kan ons gebruik maak van 'n GPS -demoon wat op die agtergrond loop om die data te ontleed en na die Raspberry Pi te stuur

Om dit te bereik, kan ons 'n terminale op die Raspberry Pi oopmaak en die kode uitvoer:

sudo apt-get update

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

Dit moet vir ons die aflaai sorg.

Sodra dit voltooi is, moet ons die gpsd -stelseldiens deaktiveer deur die volgende opdragte uit te voer:

sudo systemctl stop gpsd.socket

sudo systemctl skakel gpsd.socket uit

As u ooit die standaard gpsd -stelseldiens wil aktiveer, kan u die volgende opdragte uitvoer om dit te herstel:

sudo systemctl aktiveer gpsd.socket

sudo systemctl begin gpsd.socket

Nou moet ons die gpsd -demoon begin en dit na die UART -poorte wys deur in te voer

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

Ons kan nou die opdrag hieronder uitvoer en al die data sien dryf!

cgps -s

Stap 4: Koppel die skerm aan die Raspberry Pi

Sodra ons ons GPS -ontvanger aan die gang het en met die Raspberry Pi werk, kan ons die skerm aan die Raspberry Pi koppel. Ons sal 5 drade gebruik om ons LCD -skerm aan die Raspberry Pi te koppel en nog 4 penne om die hoofkrag en LED aan te sluit op die skerm.

Ek het 'n foto van die TFT -skerm wat ek gebruik, ingesluit, maar dit moet werk met skerms van soortgelyke grootte en gebou.

Koppel LED- en GND aan op die aarde en koppel LED+ en VCC aan 3.3V.

Koppel die RESET -pen op die skerm aan pin 25 op die Pi -bord.

Koppel A0 aan pen 24 op die Pi -bord.

Koppel die SDA -pen aan die MOSI -pen op die Pi -bord.

Koppel die SCK -pen op die LCD -skerm aan die Pi -bord.

Koppel die CS -pen aan pen 8 op die Pi -bord.

Stap 5: Stel die skerm op om te werk met Framboos Pi

Om die skerm op te stel, moet ons die ST7735 -biblioteek in hierdie repo gebruik:

Python ST7735 skermbiblioteek

Sodra ons hierdie skermbiblioteek op ons Raspberry Pi -stelsel geïnstalleer het, kan ons nou 'n voorbeeldlêer opstel om te bevestig dat ons vorige bedrading korrek werk.

Skep 'n lêer met die naam example.py en voeg die volgende teks daar in, saam met 'n voorbeeldbeeld van u keuse in dieselfde gids

invoer ST7735 as TFTimport Adafruit_GPIO as GPIO invoer Adafruit_GPIO. SPI as SPI

BREEDTE = 128

HOOGTE = 160 SPEED_HZ = 4000000

# Raspberry Pi -opset.

# Dit is die penne wat nodig is om die LCD aan die Raspberry Pi te koppel

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

# Skep TFT LCD -skermklas.

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

# Begin die vertoning.

disp.begin () disp.reset ()

# Laai 'n prentjie.

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

# Verander die grootte van die prent en draai dit sodat dit by die vertoning pas.

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

# Sal druk na die terminale dat ons program ons prentjie op die skerm teken

print ('Teken prentjie')

# Hierdie funksie sal ons beeld op die skerm vertoon

disp. vertoon (prent)

Hierdie lêer stel die Raspberry Pi -konfigurasie vir die LCD -skerm op, en die biblioteek omskep ons beeld in die gids en vertoon dit op die skerm.

Stap 6: Stel toestelle op om GPS -inligting op die skerm te vertoon

Ons sal 5 verskillende staatsmasjiene gebruik, terwyl ons ons taakdiagram implementeer om ons GPS -stelsel op te stel.

Vertoon masjien vir veranderingstoestand:

Hierdie staatsmasjien kan beheer watter dit moet vertoon, afhangende van ons knoppie -invoer. Dit word gedoen deur 'n veranderlike te verander wat python in staat stel om eend -tik te gebruik en die korrekte funksie op te roep, afhangende van die genoemde funksie

Spoed toestand masjien:

Hierdie staatsmasjien voer die huidige snelheid uit, afhangende van die ligging van die individu. Dit sal elke kloksiklus vir die GPS -stelsel uitvoer

Uitgangstoestandmasjien:

Hierdie staatsmasjien bepaal die uitset op grond van die veranderlike wat die masjien vir die verandering van die vertoning bepaal om die huidige skerm te wees.

Afstand staat masjien

Hierdie toestelmasjien voer elke kloksiklus uit en bepaal die totale afstand wat die gebruiker afgelê het, en sodra die resetknoppie gedruk word, sal die huidige afgelegde afstand herstel word.

Ligging staat masjien:

Hierdie staatsmasjien gee die huidige ligging van die gebruiker terug met behulp van koördinate wat die GPS -module oor die gebruiker terugstuur. Hierdie staatsmasjien is afhanklik van die internetverbinding van die gebruiker.

Stap 7: Laat ons ons GPS -stelsel implementeer

Sodra ons ons GPS -module inligting na ons Raspberry Pi stuur en ons LCD -skerm wat inligting daaroor vertoon, kan ons ons GPS -stelsel begin programmeer. Ek sal die eindstatusmasjiene van die vorige stap gebruik om ons GPS -stelsel te kodeer

## Hooflêer vir navigasiestelsel # # # #

# Biblioteke vir die teken van beelde

vanaf PIL invoer Beeld vanaf PIL invoer Beeldtekening vanaf PIL invoer ImageFont

# Biblioteek vir ST7737 -beheerder

voer ST7735 in as TFT

# Biblioteek vir GPIO vir Raspberry Pi

invoer Adafruit_GPIO as GPIO invoer Adafruit_GPIO. SPI as SPI

# Biblioteek vir GPS

#invoer gpsd van gps3 invoer gps3 in

# Biblioteek vir tyd

invoer tyd

# Biblioteek om afstand tussen twee punte te vind

van wiskunde invoer sonde, cos, sqrt, atan2, radiale

# Voer Rpi -biblioteek in om knoppies te gebruik om van menu te wissel en terug te stel

# voer RPi. GPIO in as bGPIO

# Stel penne vir knoppies op

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)

# voer geopie -biblioteek in vir geokodering

# # Internettoegang is nodig om te kan werk

van geopy.geocoders voer Nominatim in

geolocator = Nominatim ()

# Konstante vir stelsel

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

BREEDTE = 128

HOOGTE = 160 SPEED_HZ = 4000000

# Raspberry Pi -konfigurasiepenne

DC = 24 # A0 op die TFT -skerm RST = 25 # Herstel pen op TFT -skerm SPI_PORT = 0 # SPI -poort op framboospi, SPI0 SPI_DEVICE = 0 # Slave select op rapsberry pi, CE0

# Skep TFT LCD -skermvoorwerp

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

# Begin die vertoning

disp.begin ()

# Die agtergrond sal groen wees

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

# Maak die skerm wit en wys dit

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

# Spoed-, breedtegraad-, lengtegraadplasingsveranderlikes

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

# Afstand x en y koördinate

distX = 10 distY = 20

pointList =

# Spoed x en y koördinate

speedX = 10 speedY = 20

# Ligging x en y coordiantes

locX = 10 locY = 20

# Skakel om van m/s na mph

conversionVal = 2.24

# Spoedopdateringsfunksie, gee string terug

SpeedVar = 0

def speedFunc (): globale SpeedVar SpeedText = data_stream. TPV ['speed'] if (SpeedText! = "nvt"): 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)

terugkeer (location.address)

# Latitude -opdateringsfunksie, gee vlotwaarde terug

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

# Longitude -opdateringsfunksie, gee string terug

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

# Afstandsfunksie gee TOTAAL afstand afgelê

totale afstand = 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

# Stel die totale afstand terug

def resDistance ():

globale totalDistance totalDistance = 0

# Funksie wat gebruik word om afstand tussen twee koördinate te vind

# gebruik die formule van Haversine om te vind. # Invoerpunte is 'n tupel

def coorDistance (punt1, punt2):

# Geskatte radius van die aarde in kilometer aarde Radius = 6373,0

lat1 = punt1 [0]

lon1 = punt1 [1]

lat2 = punt2 [0]

lon2 = punt2 [1]

distanceLon = lon2 - lon1

distanceLat = lat2 - lat1

# Haversine a

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

# Haversine c

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

# Skakel km om na myl

afstand = (aardeRadius * c) * 0,62137

as (afstand <= 0,01): terugkeer 0,00 anders: terugkeer rond (afstand, 3)

# Funksie om die spoed op die skerm te vertoon

def dispSpeed ():

globale SpeedVar # Plaas afstand op veranderlike op die skerm draw.text ((speedX, speedY), str (SpeedVar), font = ImageFont.truetype ("Lato-Medium.ttf", 72))

# Funksie om afstand op die skerm te vertoon

def dispDistance ():

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

# Funksie om die ligging op die skerm te wys, internet benodig om te werk

def dispLocation ():

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

# Gebruik woordeboek om skakelstellings na te boots

dispOptions = {

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

# Skermuitsetfunksie

def uitset ():

# Gebruik globale veranderlike vir displayIndex globale displayIndex # Maak skerm skoon en pas disp.clear ((255, 255, 255)) draw.rectangle ((0, 10, 127, 150) toe, omtrek = (255, 0, 0), vul = (255, 0, 0))

# Oproepe funksioneer afhangende van die displayIndex -waarde

dispOptions [displayIndex] ()

# Sal uitvee as 'n ander metode werk

# plaas afstandsveranderlike op die skerm

#draw.text ((distX, distY), str (distFunc ()), font = ImageFont.load_default ()) #plaas spoedveranderlike op die skerm #draw.text ((speedX, speedY), speedFunc (), font = ImageFont.load_default ()) # Vertoon opdaterings vir skermweergawe ()

displayButton = 18 # BCM Speld op framboospi

resetButton = 23 # BCM Speld op framboospi

buttonPress = Onwaar

def checkDisplay ():

globale knoppie Druk globale displayIndex if (bGPIO.input (displayButton) en nie buttonPress): displayIndex += 1 buttonPress = True if (displayIndex == 2): displayIndex = 0 elif (bGPIO.input (displayButton) en buttonPress): druk (" Nog steeds ingedruk ") else: buttonPress = Onwaar

# GPS opstel

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

timerPeriod =.5

# Indekswaarde vir display displayIndex = 0 probeer: vir new_data in gps_socket: if new_data: data_stream.unpack (new_data) as 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 () as (bGPIO.input (resetButton)): resDistance () print ('GPS nog nie gekoppel nie') time.sleep (.1) time.sleep (.8) behalwe KeyboardInterrupt: gps_socket.close () print (' / nBepaal deur gebruiker ctrl+c ')

Die kode hierbo is slegs 'n voorbeeld van hoe ons ons stelsel kan kodeer, en ek het 'n video ingebed oor hoe hierdie stelsel werk.