Systém GPS: 7 krokov

2024 Autor: John Day | [email protected]. Naposledy zmenené: 2024-01-30 12:00

Tvorca projektu: Carlos Gomez

Spoľahlivý navigačný systém je prvoradý pre každého, kto sa pokúša cestovať a objavovať svet.

Najdôležitejším aspektom, ktorý umožňuje navigačnému systému fungovať, je funkcia GPS zabudovaná vo vnútri systému. Systém GPS umožňuje komukoľvek sledovať svoju polohu a rýchlosť, aby mohol zobrazovať presné informácie o používateľovi a poskytovať mu presnú predstavu o tom, kde sa nachádza a ako ďaleko sa nachádza od svojej polohy.

Global Positioning System (GPS) je sieť satelitov obiehajúcich okolo Zeme vo výške asi 20 000 km. Každý, kto má zariadenie GPS, môže prijímať rádiové signály, ktoré satelity vysielajú, a je schopný ich použiť akýmkoľvek spôsobom. Kdekoľvek sa nachádzate na planéte, mali by vám byť kedykoľvek k dispozícii najmenej štyri GPS. Zariadenie GPS môže pomocou metódy nazývanej 3-D trilaterácia použiť tri satelity na určenie polohy zariadenia na Zemi. Každý z troch satelitov vyšle do zariadenia signál a zariadenie určí jeho vzdialenosť od satelitu. Pomocou každého z troch výpočtov vzdialenosti je zariadenie teraz schopné presne určiť svoju polohu na Zemi a vráti ju používateľovi.

Systém GPS, ktorý vytvoríme, bude môcť sledovať polohu používateľa tak, že získa jeho súradnice na Zemi a vykoná niekoľko výpočtov, aby vrátil používateľovi jeho rýchlosť, polohu a prejdenú vzdialenosť.

Krok 1: Začíname

Aby sme mohli tento projekt začať, budeme najskôr musieť zhromaždiť všetky správne materiály

1: Raspberry Pi Zero W

2: Prijímač GPS

Obrazovka 3: 1,8 TFT 128 x 160 LCD SPI obrazovka

4: ~ 11 drôtov

Tlačidlá 5: 2

6: 2x 1k a 2x 10k odpory pre sťahovacie tlačidlá

7: Chlebová doska

Tento projekt bude využívať GPIO piny Raspberry Pi a ako taký budeme potrebovať na vývoj nášho projektu všetko prepojiť s doskou na chlieb. Tiež sa predpokladá, že spájkovanie na všetkých kolíkoch je dokončené a dokončené predtým, ako sa pohneme ďalej a spojíme všetky naše diely.

Krok 2: Pripojte modul GPS k Raspberry Pi

Na používanie nášho systému GPS budete potrebovať pripojenie pinov Tx a Rx z modulu GPS k kolíku GPIO 14 a 15 na Raspberry Pi. Kolík Tx prijímača GPS smeruje k kolíku Rx pí a konektor Rx prijímača GPS smeruje k kolíku Tx zariadenia Raspberry pi.

Prijímač GPS zobrazený na obrázkoch vyžaduje použitie 3,3 V a piny 3,3 V môžete pripojiť na správne napätie pri súčasnom pripájaní uzemňovacieho kolíka k zemi.

Krok 3: Prijímajte údaje z modulu prijímača GPS

Aby sme mohli prijímať údaje z prijímača GPS na Raspberry Pi, musíme povoliť čítanie správnych zásuviek z portov UART. Čítanie nespracovaných údajov by si vyžadovalo vytvorenie vlastnej knižnice analýzy, ale v tomto prípade môžeme využiť démona GPS, ktorý beží na pozadí a pomôže analyzovať údaje a preniesť ich na Raspberry Pi.

Aby sme to dosiahli, môžeme otvoriť terminál na Raspberry Pi a spustiť kód:

sudo apt-get aktualizácia

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

To by sa malo postarať o stiahnutie za nás.

Po dokončení musíme zakázať systémovú službu gpsd spustením nasledujúcich príkazov:

sudo systemctl stop gpsd.socket

sudo systemctl vypnúť gpsd.socket

Ak by ste niekedy chceli povoliť predvolenú systémovú službu gpsd, môžete ju obnoviť spustením nasledujúcich príkazov:

sudo systemctl povoliť gpsd.socket

sudo systemctl start gpsd.socket

Teraz musíme spustiť démona gpsd a nasmerovať ho na porty UART zadaním

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

Teraz môžeme spustiť príkaz nižšie a pozrieť sa na všetky údaje, ktoré v nich plávajú!

cgps -s

Krok 4: Pripojte displej k Raspberry Pi

Akonáhle máme GPS prijímač v prevádzke a pracujeme s Raspberry Pi, potom môžeme pripojiť displej k Raspberry Pi. Na pripojenie nášho LCD displeja k Raspberry Pi použijeme 5 vodičov a ďalšie 4 piny na pripojenie hlavného napájania a LED diódy na obrazovke.

Zahrnul som fotografiu obrazovky TFT, ktorú používam, ale malo by to fungovať s obrazovkami podobnej veľkosti a konštrukcie.

Pripojte LED- a GND k uzemneniu a pripojte LED+ a VCC na 3,3V.

Pripojte kolík RESET na obrazovke k kolíku 25 na doske Pi.

Pripojte A0 k pinu 24 na doske Pi.

Pripojte pin SDA k pinu MOSI na doske Pi.

Pripojte pin SCK na LCD obrazovke k doske Pi.

Pripojte pin CS k pinu 8 na doske Pi.

Krok 5: Nastavte zobrazenie tak, aby fungovalo s Raspberry Pi

Na nastavenie displeja musíme použiť knižnicu ST7735, ktorá sa nachádza v tomto repo:

Knižnica obrazovky Python ST7735

Akonáhle budeme mať túto knižnicu zobrazenia nainštalovanú v našom systéme Raspberry Pi, môžeme pristúpiť k nastaveniu vzorového súboru na potvrdenie, že naše predchádzajúce zapojenie funguje správne.

Vytvorte súbor s názvom example.py a vložte tam nasledujúci text spolu so vzorovým obrázkom, ktorý ste vybrali, do rovnakého priečinka

import ST7735 ako TFTimport Adafruit_GPIO ako GPIO import Adafruit_GPIO. SPI ako SPI

ŠÍRKA = 128

VÝŠKA = 160 SPEED_HZ = 4000000

# Konfigurácia Raspberry Pi.

# Toto sú kolíky potrebné na pripojenie LCD k Raspberry Pi

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

# Vytvorte triedu TFT LCD displeja.

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

# Inicializujte zobrazenie.

disp.begin () disp.reset ()

# Načítajte obrázok.

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

# Zmeňte veľkosť obrázku a otočte ho tak, aby zodpovedal zobrazeniu.

image = image.rotate (270). resize ((ŠÍRKA, VÝŠKA))

# Vytlačí na terminál, že náš program kreslí náš Obraz na obrazovku

tlač ('Kresliaci obrázok')

# Táto funkcia zobrazí náš obrázok na obrazovke

disp.display (obrázok)

Tento súbor nastaví konfiguráciu Raspberry Pi pre obrazovku LCD a knižnica prevedie náš obrázok do priečinka a zobrazí ho na obrazovke.

Krok 6: Nastavte stavové zariadenia na zobrazenie informácií GPS na displeji

Na implementáciu nášho systému GPS použijeme 5 rôznych stavových strojov a implementujeme náš diagram úloh.

Zobraziť stroj na zmenu stavu:

Tento stavový stroj bude ovládať, ktoré sa majú zobrazovať, v závislosti od nášho vstupu tlačidiel. To sa deje zmenou premennej, ktorá umožňuje pythonu využívať výhody písania kačíc a volania správnej funkcie na zobrazenie v závislosti od volanej funkcie.

Rýchlostný stavový stroj:

Tento stavový stroj vykoná aktuálnu rýchlosť v závislosti od polohy jednotlivcov. Tým sa spustí každý hodinový cyklus systému GPS

Výstupný stavový stroj:

Tento stavový stroj určí výstup na základe premennej, ktorú automatický stavový automat zmení na aktuálny displej.

Stavový stroj na vzdialenosť

Tento stavový stroj vykoná každý hodinový cyklus a určí celkovú vzdialenosť, ktorú používateľ prešiel, a po stlačení tlačidla reset vynuluje aktuálnu prejdenú vzdialenosť.

Stavový automat polohy:

Tento stavový stroj vráti aktuálnu polohu používateľa pomocou súradníc, ktoré modul GPS vráti o používateľovi. Tento stavový stroj závisí od internetového pripojenia používateľov.

Krok 7: Poďme implementovať náš systém GPS

Akonáhle budeme mať náš modul GPS odosielanie informácií na náš Raspberry Pi a LCD obrazovku, ktorá na ňom zobrazuje informácie, môžeme začať programovať náš systém GPS. Na kódovanie nášho systému GPS použijem stroje konečného stavu predchádzajúceho kroku

## Hlavný súbor pre navigačný systém # # # #

# Knižnice na kreslenie obrázkov

z PIL import Obrázok z PIL import ImageDraw z PIL import ImageFont

# Knižnica pre ovládač ST7737

importujte ST7735 ako TFT

# Knižnica pre GPIO pre Raspberry Pi

importovať Adafruit_GPIO ako GPIO importovať Adafruit_GPIO. SPI ako SPI

# Knižnica pre GPS

#import gpsd z gps3 import gps3

# Knižnica na čas

čas importu

# Knižnica na nájdenie vzdialenosti medzi dvoma bodmi

z matematiky import sin, cos, sqrt, atan2, radiány

# Importujte knižnicu Rpi, aby ste pomocou tlačidiel mohli prepínať ponuky a resetovať

# importujte RPi. GPIO ako bGPIO

# Nastavovacie kolíky pre tlačidlá

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)

# import geopy knižnice pre geokódovanie

# # Na to, aby to fungovalo, je potrebný prístup na internet

z geopy.geocoders import Nominatim

geolokátor = Nominatim ()

# Konštanty pre systém

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

ŠÍRKA = 128

VÝŠKA = 160 SPEED_HZ = 4000000

# Konfiguračné piny Raspberry Pi

DC = 24 # A0 na TFT obrazovke RST = 25 # Reset pin na TFT obrazovke SPI_PORT = 0 # SPI port na raspberry pi, SPI0 SPI_DEVICE = 0 # Slave select na rapsberry pi, CE0

# Vytvorte objekt TFT LCD displeja

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

# Inicializujte zobrazenie

disp.begin ()

# Pozadie bude nastavené na zelenú

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

# Jasná obrazovka na bielu a zobrazenie

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

# Premenné, rýchlosť, zemepisná šírka, zemepisná dĺžka

#currentS = "Aktuálna rýchlosť:" # Reťazec rýchlosti #totalDis = "Celková vzdialenosť:" # Reťazec vzdialenosti #currentLoc = "Aktuálna poloha:" # Reťazec polohy

# Vzdialenosť súradníc x a y

distX = 10 distY = 20

pointsList =

# Rýchlosť súradníc x a y

rýchlosť X = 10 rýchlosť Y = 20

# Umiestnenie súradníc x a y

locX = 10 locY = 20

# Konvertuje z m/s na mph

conversionVal = 2,24

# Funkcia aktualizácie rýchlosti, vráti reťazec

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

umiestnenie = geolocator.reverse (reverseString)

návrat (poloha.adresa)

# Funkcia aktualizácie Latitude, vráti plávajúcu hodnotu

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

# Funkcia aktualizácie zemepisnej dĺžky, vráti reťazec

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

# Funkcia vzdialenosti vráti TOTAL prejdenú vzdialenosť

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

# Resetuje celkovú vzdialenosť

def resDistance ():

global totalDistance totalDistance = 0

# Funkcia používaná na nájdenie vzdialenosti medzi dvoma súradnicami

# používa na nájdenie Haversinov vzorec. # Vstupné body sú n -tice

def coorDistance (point1, point2):

# Približný polomer Zeme v kilometroch Zeme Radius = 6373,0

lat1 = bod1 [0]

lon1 = bod1 [1]

lat2 = bod2 [0]

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

# Previesť km na míle

vzdialenosť = (earthRadius * c) * 0,62137

if (vzdialenosť <= 0,01): návrat 0,00 inak: návrat zaokrúhlenia (vzdialenosť, 3)

# Funkcia na zobrazenie rýchlosti na obrazovke

def dispSpeed ():

globálny SpeedVar # Umiestnenie vzdialenosti na premennú na obrazovke draw.text ((speedX, speedY), str (SpeedVar), font = ImageFont.truetype ("Lato-Medium.ttf", 72))

# Funkcia na zobrazenie vzdialenosti na obrazovke

def dispDistance ():

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

# Funkcia na zobrazenie umiestnenia na obrazovke, na fungovanie vyžaduje internet

def dispLocation ():

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

# Použitie slovníka na napodobnenie príkazov prepínača

dispOptions = {

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

# Funkcia výstupu obrazovky

def výstup ():

# Použitie globálnej premennej pre displayIndex globálny displayIndex # Čistenie obrazovky a použitie pozadia disp.clear ((255, 255, 255)) draw.rectangle ((0, 10, 127, 150), outline = (255, 0, 0), fill = (255, 0, 0))

# Volá funkciu v závislosti od hodnoty displayIndex

dispOptions [displayIndex] ()

# Ak iná metóda funguje, vymaže sa

# premenná vzdialenosti umiestnenia na obrazovku

#draw.text ((distX, distY), str (distFunc ()), font = ImageFont.load_default ()) #premenná rýchlosti umiestnenia na obrazovku #draw.text ((speedX, speedY), speedFunc (), font = ImageFont.load_default ()) # Aktualizácia zobrazenia obrazovky..display ()

displayButton = 18 # BCM Pin na malinovom pi

resetButton = 23 # BCM Pin na malinovom pi

buttonPress = nepravda

def checkDisplay ():

globálne tlačidloStlačte globálny displayIndex if (bGPIO.input (displayButton) a nie buttonPress): displayIndex += 1 tlačidloPress = True if (displayIndex == 2): displayIndex = 0 elif (bGPIO.input (displayButton) and buttonPress): print (" Stále stlačené ") else: buttonPress = False

# Nastaviť GPS

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

timerPeriod =.5

# Hodnota indexu pre zobrazenie displayIndex = 0 pokus: pre new_data v 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 is not yet connected') time.sleep (.1) time.sleep (.8) okrem KeyboardInterrupt: gps_socket.close () print (' / nUkončené používateľom ctrl+c ')

Vyššie uvedený kód je len jedným príkladom kódovania nášho systému a vložil som video o tom, ako tento systém funguje.