GPS rendszer: 7 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:43

A projekt készítője: Carlos Gomez

A megbízható navigációs rendszer birtoklása mindenekelőtt azok számára fontos, akik utazni és felfedezni szeretnék a világot.

A legfontosabb szempont, amely lehetővé teszi a navigációs rendszer működését, a rendszerbe ágyazott GPS -képesség. A GPS -rendszer lehetővé teszi, hogy bárki nyomon kövesse tartózkodási helyét és sebességét annak érdekében, hogy pontos információkat jelenítsen meg a felhasználóról, és pontos képet adjon a felhasználónak arról, hogy hol és milyen messze van a helyétől.

A globális helymeghatározó rendszer (GPS) a Föld körül mintegy 20 000 km magasságban keringő műholdak hálózata. Bárki, aki rendelkezik GPS -eszközzel, fogadhatja a műholdak által sugárzott rádiójeleket, és szükség esetén képes azokat hasznosítani. Bárhol is tartózkodik a bolygón, legalább négy GPS -nek bármikor elérhetőnek kell lennie. A 3-D trilateration nevű módszerrel a GPS-eszköz három műhold segítségével képes meghatározni az eszköz földi helyzetét. A három műhold mindegyike jelet küld az eszköznek, és az eszköz meghatározza a távolságot a műholdtól. A három távolságszámítás mindegyikét használva az eszköz képes pontosan meghatározni földi helyét, és ezt visszaadja a felhasználónak.

Az általunk létrehozott GPS -rendszer képes lesz nyomon követni a felhasználó tartózkodási helyét azáltal, hogy lekéri a felhasználó koordinátáit a Földön, és elvégez néhány számítást annak érdekében, hogy visszaadja a felhasználó sebességét, helyét és a megtett távolságot.

1. lépés: Első lépések

A projekt elindításához először össze kell gyűjtenünk a megfelelő anyagokat

1: Raspberry Pi Zero W

2: GPS vevő

3: 1.8 TFT 128 x 160 LCD SPI képernyő

4: ~ 11 vezeték

5: 2 gombok

6: 2x 1k és 2x 10k ellenállás lehúzható gombokhoz

7: Kenyértábla

Ez a projekt a Raspberry Pi GPIO csapjait fogja használni, és mint ilyen, mindent össze kell kötnünk egy kenyértáblával, hogy fejlesszük a projektünket. Azt is feltételezzük, hogy az összes csap forrasztása megtörtént és befejeződött, mielőtt továbblépünk és összekötjük az összes alkatrészünket.

2. lépés: Csatlakoztassa a GPS -modult a Raspberry Pi -hez

A GPS rendszer használatához csatlakoztatnia kell a Tx és Rx csapokat a GPS modulból a Raspberry Pi 14 és 15 GPIO tűihez. A GPS vevő Tx csapja a Pi Rx tűjéhez, a GPS vevő Rx csapja pedig a Raspberry pi Tx tűjéhez kerül.

A képeken látható GPS -vevő használatához 3,3 V szükséges, és a 3,3 V -os csatlakozókat a megfelelő feszültségre csatlakoztathatja, miközben a földelőcsapot a földhöz csatlakoztatja.

3. lépés: Adatok fogadása a GPS vevőmodulból

Annak érdekében, hogy adatokat kapjunk a GPS -vevőről a Raspberry Pi -re, engedélyeznünk kell a megfelelő foglalatok olvasását az UART -portokról. A nyers adatok olvasásához saját elemző könyvtárat kell létrehoznunk, de ebben a forgatókönyvben kihasználhatjuk a háttérben futó GPS démon előnyeit az adatok elemzéséhez és a Raspberry Pi

Ennek elérése érdekében megnyithatunk egy terminált a Raspberry Pi -n, és végrehajthatjuk a kódot:

sudo apt-get update

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

Ennek gondoskodnia kell a letöltésről számunkra.

Miután befejeződött, le kell tiltanunk a gpsd rendszerszolgáltatást a következő parancsok futtatásával:

sudo systemctl stop gpsd.socket

sudo systemctl letiltja a gpsd.socket

Ha valaha is engedélyezni szeretné az alapértelmezett gpsd rendszerszolgáltatást, a következő parancsokkal futtathatja azt:

sudo systemctl engedélyezze a gpsd.socket

sudo systemctl indítsa el a gpsd.socket parancsot

Most el kell indítanunk a gpsd démont, és beírással az UART portokra kell mutatnunk

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

Most futtathatjuk az alábbi parancsot, és láthatjuk, hogy minden adat lebeg!

cgps -s

Lépés: Csatlakoztassa a kijelzőt a Raspberry Pi -hez

Miután a GPS -vevőnket felállítottuk és a Raspberry Pi -vel dolgozunk, csatlakoztathatjuk a kijelzőt a Raspberry Pi -hez. 5 vezetéket használunk az LCD -kijelző és a Raspberry Pi csatlakoztatásához, és további 4 érintkezőt a tápellátás és a LED csatlakoztatásához a képernyőn.

Mellékeltem egy fényképet az általam használt TFT képernyőről, de ennek hasonló méretű és felépítésű képernyőkkel kell működnie.

Csatlakoztassa a LED-et és a GND-t a földhöz, és csatlakoztassa a LED+ -ot és a VCC-t a 3.3V-hoz.

Csatlakoztassa a képernyőn található RESET csapot a Pi táblán lévő 25 tűhöz.

Csatlakoztassa az A0 -t a Pi -tábla 24 -es tűjéhez.

Csatlakoztassa az SDA tűt a Pi táblán lévő MOSI tűhöz.

Csatlakoztassa az LCD -képernyőn található SCK -tűt a Pi -kártyához.

Csatlakoztassa a CS -tűt a Pi -tábla 8. tűjéhez.

5. lépés: Állítsa be a kijelzőt a Raspberry Pi használatához

A kijelző beállításához az ebben a repóban található ST7735 könyvtárat kell használnunk:

Python ST7735 képernyőkönyvtár

Miután telepítettük ezt a kijelzőkönyvtárat a Raspberry Pi rendszerünkre, most folytathatjuk a példafájl beállítását annak megerősítésére, hogy az előző huzalozásunk megfelelően működik.

Hozzon létre egy example.py nevű fájlt, és illessze be ide a következő szöveget az általad választott mintaképpel együtt

importálja az ST7735 -t TFT -ként Importálja az Adafruit_GPIO -t GPIO -ként, importálja az Adafruit_GPIO. SPI -t SPI -ként

SZÉLESSÉG = 128

MAGASSÁG = 160 SPEED_HZ = 4000000

# Raspberry Pi konfiguráció.

# Ezek a csapok szükségesek az LCD és a Raspberry Pi csatlakoztatásához

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

# TFT LCD kijelző osztály létrehozása.

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

# Inicializálja a kijelzőt.

disp.begin () disp.reset ()

# Töltsön be egy képet.

newData = 0x42 disp.command (newData) print ('Kép betöltése …') image = Image.open ('cat.jpg')

# Méretezze át a képet, és forgassa el úgy, hogy illeszkedjen a kijelzőhöz.

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

# A terminálra kinyomtatja, hogy programunk rajzolja a képünket a képernyőre

print ('Rajz kép')

# Ez a funkció megjeleníti a képünket a képernyőn

disp.display (kép)

Ez a fájl beállítja a Raspberry Pi konfigurációt az LCD -képernyőhöz, és a könyvtár átalakítja a képünket a mappában, és megjeleníti a képernyőn.

6. lépés: Az állapotgépek beállítása a GPS -információk megjelenítésére a kijelzőn

5 különböző állapotgépet fogunk használni, miközben végrehajtjuk a feladatdiagramunkat a gps rendszer beállításához.

Kijelző állapotváltó gép:

Ez az állapotgép vezérli a megjelenítendő gomboktól függően. Ezt egy olyan változó megváltoztatásával teszi lehetővé, amely lehetővé teszi a python számára, hogy kihasználja a kacsa gépelés előnyeit, és meghívja a megjeleníteni kívánt függvényt a hívott függvénytől függően

Sebesség állapotú gép:

Ez az állapotgép az egyének helyétől függően végrehajtja az aktuális sebességet. Ez végrehajtja a GPS rendszer minden órajelét

Kimeneti állapotú gép:

Ez az állapotgép a kimenetet annak a változónak a alapján határozza meg, amelyet a kijelzőváltási állapotgép az aktuális kijelzőnek határoz meg.

Távolság állapot gép

Ez az állapotgép végrehajt minden órajelciklusot, és meghatározza a felhasználó által megtett teljes távolságot, és amint megnyomja a reset gombot, visszaállítja az aktuális megtett távolságot.

Helyállapot -gép:

Ez az állapotgép visszaadja a felhasználó aktuális tartózkodási helyét, a GPS -modul által a felhasználóról visszaadott koordináták segítségével. Ez az állapotgép a felhasználók internetkapcsolatától függ.

7. lépés: implementáljuk GPS rendszerünket

Miután a GPS -modulunk információt küld a Raspberry Pi -nek, és az LCD -képernyőn információkat jelenítünk meg, elkezdhetjük a GPS -rendszer programozását. Az előző lépés véges állapotú gépeit fogom használni a GPS rendszerünk kódolásához

## A navigációs rendszer fő fájlja # # # #

# Könyvtárak képek rajzolásához

from PIL import Image from PIL import ImageDraw from PIL import ImageFont

# Könyvtár az ST7737 vezérlőhöz

importálja az ST7735 -t TFT -ként

# Könyvtár a GPIO számára a Raspberry Pi számára

importálja az Adafruit_GPIO -t GPIO -ként, importálja az Adafruit_GPIO. SPI -t SPI -ként

# Könyvtár a GPS számára

#import gpsd from gps3 import gps3

# Könyvtár időre

importálási idő

# Könyvtár két pont közötti távolság megtalálására

a matematikából import sin, cos, sqrt, atan2, radián

# Importálja az Rpi könyvtárat a gombok segítségével a menük váltásához és a visszaállításhoz

# RPi. GPIO importálása bGPIO -ként

# Beállító csapok a gombokhoz

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álja a geopy könyvtárat a geokódoláshoz

# # Ennek működéséhez internet -hozzáférés szükséges

a geopy -ból.geokódolók importálják a Nominatim -et

geolokator = Nominatim ()

# Állandó a rendszerhez

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

SZÉLESSÉG = 128

MAGASSÁG = 160 SPEED_HZ = 4000000

# Raspberry Pi konfigurációs csapok

DC = 24 # A0 a TFT -képernyőn

# Hozzon létre TFT LCD kijelző objektumot

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

# Inicializálja a kijelzőt

disp.begin ()

# A háttér zöldre lesz állítva

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

# Tisztítsa meg a képernyőt fehérre és jelenítse meg

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

# Sebesség, szélesség, hosszúság elhelyezési változók

#currentS = "Aktuális sebesség:" # Speed string #totalDis = "Teljes távolság:" # Distance string #currentLoc = "Jelenlegi hely:" # Location string

# X és y távolság koordinátái

distX = 10 distY = 20

pointsList =

# Sebesség x és y

speedX = 10 speedY = 20

# Az x és az y koordináták

locX = 10 locY = 20

# M/s -ból mph -re konvertál

conversionVal = 2,24

# Gyors frissítési funkció, karakterláncot ad vissza

SpeedVar = 0

def speedFunc (): globális SpeedVar SpeedText = data_stream. TPV ['speed'] if (SpeedText! = "n/a"): SpeedText = float (SpeedText) * conversionVal SpeedVar = kerek (SpeedText, 1) # return (SpeedText)

def locationFunc ():

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

reverseString = latLoc + "," + lonLoc

location = geolocator.reverse (reverseString)

visszatérés (location.address)

# Koordináták frissítési funkció, lebegő értéket ad vissza

def latFunc (): Szélesség = adat_folyam. TPV ['lat'] if (Latitude == "n/a"): return 0 else: return float (kerek (szélesség, 4))

# Hosszúság frissítési funkció, karakterláncot ad vissza

def lonFunc (): Longitude = data_stream. TPV ['lon'] if (Longitude == "n/a"): return 0 else: return float (kerek (hosszúság, 4))

# A Távolság funkció ÖSSZES megtett távolságot ad vissza

totalDistance = 0

def distFunc ():

globális totalDistance newLat = latFunc () newLon = lonFunc () if (newLat == 0 or newLon == 0): totalDistance = totalDistance # return (totalDistance) else: pointsList.append ((newLat, newLon)) last = len (pointsList) -1 ha (utolsó == 0): return else: totalDistance += coorDistance (pointsList [last-1], pointsList [last]) # return totalDistance

# Visszaállítja a teljes távolságot

def resDistance ():

globális totalDistance totalDistance = 0

# Funkció két koordináta közötti távolság megkeresésére

# Haversine képletét használja a kereséshez. # A bemeneti pontok egy sor

def coorDistance (1. pont, 2. pont):

# A Föld hozzávetőleges sugara kilométerben földRádius = 6373,0

lat1 = 1. pont [0]

lon1 = 1. pont [1]

lat2 = 2. pont [0]

lon2 = pont2 [1]

távolságLon = lon2 - lon1

distanceLat = lat2 - lat1

# Haversine a

a = sin (távolságLat/2) ** 2 + cos (lat1)*cos (lat2)*sin (távolságLon/2) ** 2

# Haversine c

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

# Konvertálja a km -t km -re

távolság = (earthRadius * c) * 0.62137

if (távolság <= 0,01): visszatérés 0,00 else: visszatérő kör (távolság, 3)

# Funkció a sebesség megjelenítésére a képernyőn

def dispSpeed ():

globális SpeedVar # Helyezze a távolságot a változóra a képernyőn draw.text ((speedX, speedY), str (SpeedVar), font = ImageFont.truetype ("Lato-Medium.ttf", 72))

# Funkció a távolság kijelzésére a képernyőn

def dispDistance ():

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

# A funkció megjelenítése a képernyőn, internet szükséges a működéshez

def dispLocation ():

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

# A szótár használata a kapcsoló állítások utánozására

dispOptions = {

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

# Képernyő kimeneti funkció

def kimenet ():

# Globális változó használata displayIndex globális displayIndex # Képernyő törlése és háttér diszpozíció alkalmazása. Clear ((255, 255, 255)) draw.rectangle ((0, 10, 127, 150), outline = (255, 0, 0), kitöltés = (255, 0, 0))

# Hívás funkció a displayIndex értékétől függően

dispOptions [displayIndex] ()

# Törlődik, ha más módszer működik

# helye távolság változó a képernyőn

#draw.text ((distX, distY), str (distFunc ()), font = ImageFont.load_default ()) #sebesség változó helye a képernyőn #draw.text ((speedX, speedY), speedFunc (), font = ImageFont.load_default ()) # Frissítések megjelenítése a képernyőn disp.display ()

displayButton = 18 # BCM Pin a málna pi

resetButton = 23 # BCM Pin a málna pi

buttonPress = Hamis

def checkDisplay ():

global buttonPress global displayIndex if (bGPIO.input (displayButton) és not buttonPress): displayIndex += 1 buttonPress = True if (displayIndex == 2): displayIndex = 0 elif (bGPIO.input (displayButton) és buttonPress): print (" Még mindig megnyomva ") else: buttonPress = Hamis

# GPS beállítása

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

timerPeriod =.5

# Index érték a kijelzőnIndex = 0 try: 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 még nincs csatlakoztatva') time.sleep (.1) time.sleep (.8), kivéve a KeyboardInterrupt: gps_socket.close () print (' / nLevetette: ctrl+c ')

A fenti kód csak egy példa arra, hogyan kódoljuk a rendszerünket, és beágyaztam egy videót a rendszer működéséről.