Sistem GPS: 7 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

Creatorul proiectului: Carlos Gomez

A avea un sistem de navigație fiabil este esențial pentru oricine încearcă să călătorească și să exploreze lumea.

Cel mai important aspect care permite funcționarea sistemului de navigație este capacitatea GPS încorporată în interiorul sistemului. Sistemul GPS permite oricui să urmărească locația și viteza pentru a afișa informații exacte despre utilizator și pentru a oferi utilizatorului o reprezentare exactă a locului în care se află și cât de departe sunt de locația lor.

Sistemul de poziționare globală (GPS) este o rețea de sateliți care orbitează Pământul la o altitudine de aproximativ 20, 000 km. Oricine are un dispozitiv GPS poate primi semnalele radio transmise de sateliți și este capabil să le utilizeze în orice mod este necesar. Indiferent de locația dvs. de pe planetă, cel puțin patru GPS ar trebui să vă fie disponibile în orice moment. Folosind o metodă numită trilaterare 3-D, un dispozitiv GPS poate utiliza trei sateliți pentru a determina locația dispozitivului pe Pământ. Fiecare dintre cei trei sateliți trimite un semnal către dispozitiv, iar acesta determină distanța față de satelit. Folosind fiecare dintre cele trei calcule de distanță, dispozitivul este acum capabil să identifice locația sa pe Pământ și îl returnează utilizatorului.

Sistemul GPS pe care îl vom crea va putea urmări locațiile utilizatorului prin obținerea coordonatelor utilizatorului pe Pământ și efectuarea unor calcule pentru a returna viteza, locația și distanța parcursă a utilizatorului.

Pasul 1: Introducere

Pentru a începe acest proiect, va trebui mai întâi să adunăm toate materialele corecte

1: Raspberry Pi Zero W

2: Receptor GPS

Ecran LCD SPI 3: 1,8 TFT 128 x 160

4: ~ 11 fire

5: 2 butoane

6: 2x rezistențe 1k și 2x 10k pentru butoane de tragere

7: Placă de pâine

Acest proiect va folosi pinii GPIO ai Raspberry Pi și, ca atare, va trebui să conectăm totul cu o placă de pâine pentru a ne dezvolta proiectul. De asemenea, se presupune că lipirea pe toate știfturile este terminată și terminată înainte de a trece mai departe și de a conecta toate piesele noastre.

Pasul 2: Conectați modulul GPS la Raspberry Pi

Pentru utilizarea sistemului nostru GPS, va trebui să conectați pinii Tx și Rx de la modulul GPS la pinii GPIO 14 și 15 de pe Raspberry Pi. Pinul Tx al receptorului GPS merge la pinul Rx al Pi și pinul Rx al receptorului GPS merge la pinul Tx al Raspberry pi.

Receptorul GPS afișat în imagini necesită utilizarea a 3,3V și puteți conecta pinii de 3,3V la tensiunea corectă, în timp ce conectați pinul de masă la masă.

Pasul 3: Primiți date din modulul receptor GPS

Pentru a primi date de la receptorul GPS către Raspberry Pi, trebuie să permitem prizelor corecte să citească din porturile UART. Citirea datelor brute ne-ar impune să creăm propria noastră bibliotecă de analiză, dar în acest scenariu putem profita de un daemon GPS care rulează în fundal pentru a ajuta la analiza datelor și a le transmite la Raspberry Pi

Pentru a realiza acest lucru, putem deschide un terminal pe Raspberry Pi și executăm codul:

sudo apt-get update

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

Acest lucru ar trebui să aibă grijă de descărcare pentru noi.

Odată finalizat, trebuie să dezactivăm serviciul de sistem gpsd executând următoarele comenzi:

sudo systemctl opri gpsd.socket

sudo systemctl dezactivează gpsd.socket

Dacă vreți vreodată să activați serviciul de sistem gpsd implicit, puteți rula următoarele comenzi pentru a-l restaura:

sudo systemctl activează gpsd.socket

sudo systemctl pornește gpsd.socket

Acum trebuie să pornim daemon-ul gpsd și să-l îndreptăm către porturile UART introducând

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

Acum putem rula comanda de mai jos și putem vedea toate datele care plutesc!

cgps -s

Pasul 4: Conectați afișajul la Raspberry Pi

Odată ce avem receptorul GPS în funcțiune și lucrăm cu Raspberry Pi, putem conecta afișajul la Raspberry Pi. Vom folosi 5 fire pentru a conecta afișajul LCD la Raspberry Pi și alți 4 pini pentru a conecta alimentarea principală și LED-ul pe ecran.

Am inclus o fotografie a ecranului TFT pe care îl folosesc, dar acest lucru ar trebui să funcționeze cu ecrane de dimensiuni și construcții similare.

Conectați LED- și GND la masă și conectați LED + și VCC la 3.3V.

Conectați pinul RESET de pe ecran la pinul 25 de pe placa Pi.

Conectați A0 la pinul 24 de pe placa Pi.

Conectați pinul SDA la pinul MOSI de pe placa Pi.

Conectați pinul SCK de pe ecranul LCD la placa Pi.

Conectați pinul CS la pinul 8 de pe placa Pi.

Pasul 5: Configurați afișajul pentru a lucra cu Raspberry Pi

Pentru a configura afișajul, trebuie să folosim biblioteca ST7735 găsită în această repo:

Biblioteca de ecran Python ST7735

Odată ce avem această bibliotecă de afișare instalată pe sistemul nostru Raspberry Pi, putem trece acum la configurarea unui exemplu de fișier pentru a confirma că cablajul nostru anterior funcționează corect.

Creați un fișier intitulat example.py și introduceți următorul text acolo împreună cu un exemplu de imagine la alegere în același folder

import ST7735 ca TFT importă Adafruit_GPIO ca GPIO importă Adafruit_GPIO. SPI ca SPI

LĂȚIME = 128

ÎNĂLȚIME = 160 SPEED_HZ = 4000000

# Configurare Raspberry Pi.

# Acestea sunt pinii necesari pentru conectarea LCD-ului la Raspberry Pi

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

# Creați clasa de afișaj LCD TFT.

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

# Inițializați afișajul.

disp.begin () disp.reset ()

# Încărcați o imagine.

newData = 0x42 disp.command (newData) print ('Se încarcă imaginea …') image = Image.open ('cat.jpg')

# Redimensionați imaginea și rotiți-o astfel încât să se potrivească cu afișajul.

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

# Va imprima pe terminal că programul nostru ne desenează imaginea pe ecran

print („Imagine desen”)

# Această funcție va afișa imaginea noastră pe ecran

disp.display (imagine)

Acest fișier va configura configurația Raspberry Pi pentru ecranul LCD, iar biblioteca ne va converti imaginea în dosar și o va afișa pe ecran.

Pasul 6: Configurați mașinile de stat pentru a afișa informații GPS pe afișaj

Vom folosi 5 mașini de stare diferite, în timp ce implementăm diagrama noastră de sarcini pentru a configura sistemul nostru GPS.

Afișaj Mașină de schimbare a stării:

Această mașină de stare va controla care să se afișeze în funcție de introducerea butonului nostru. Face acest lucru schimbând o variabilă care permite python să profite de tastarea rațelor și apelând funcția corectă pentru a se afișa în funcție de funcția apelată

Mașină de viteză:

Această mașină de stare va executa viteza curentă în funcție de locația indivizilor. Aceasta va executa fiecare ciclu de ceas pentru sistemul GPS

Mașină de stare de ieșire:

Această mașină de stare va determina ieșirea pe baza variabilei pe care mașina de stare de schimbare a afișajului o determină a fi afișarea curentă.

Mașină cu distanță

Această mașină de stare execută fiecare ciclu de ceas și determină distanța totală parcursă de utilizator și odată apăsat butonul de resetare, va reseta distanța curentă parcursă.

Mașina de stare a locației:

Această mașină de stare returnează locația curentă a utilizatorului, utilizând coordonatele pe care le returnează modulul GPS despre utilizator. Această mașină de stare depinde de conexiunea la internet a utilizatorilor.

Pasul 7: Să implementăm sistemul nostru GPS

Odată ce avem modulul nostru GPS care trimite informații către Raspberry Pi și pe ecranul nostru LCD care afișează informații pe acesta, putem începe programarea sistemului nostru GPS. Voi folosi mașinile cu stări finite ale pasului anterior pentru a ne codifica sistemul GPS

## Fișier principal pentru sistemul de navigare # # # #

# Biblioteci pentru desenarea imaginilor

din import PIL Imagine din import PIL ImageDraw din import PIL ImageFont

# Biblioteca pentru controlerul ST7737

import ST7735 ca TFT

# Biblioteca pentru GPIO pentru Raspberry Pi

importă Adafruit_GPIO ca GPIO importă Adafruit_GPIO. SPI ca SPI

# Biblioteca pentru GPS

#import gpsd din gps3 import gps3

# Biblioteca pentru timp

timpul de import

# Biblioteca pentru găsirea distanței dintre două puncte

din matematica import sin, cos, sqrt, atan2, radians

# Importați biblioteca Rpi pentru a utiliza butoanele pentru a comuta meniurile și a reseta

# import RPi. GPIO ca bGPIO

# Pinii de configurare pentru butoane

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 bibliotecă geopy pentru Geocodificare

# # Accesul la internet este necesar pentru ca acest lucru să funcționeze

din geopy.geocoders import Nominatim

geolocator = Nominatim ()

# Constante pentru sistem

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

LĂȚIME = 128

ÎNĂLȚIME = 160 SPEED_HZ = 4000000

# Pinii de configurare Raspberry Pi

DC = 24 # A0 pe ecranul TFT RST = 25 # Resetați pinul pe ecranul TFT SPI_PORT = 0 # Port SPI pe raspberry pi, SPI0 SPI_DEVICE = 0 # Selectare sclav pe rapsberry pi, CE0

# Creați obiect de afișare TFT LCD

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

# Inițializați afișajul

disp.begin ()

# Fundalul va fi setat la verde

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

# Ștergeți ecranul pentru alb și afișați

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

# Variabile de plasare a vitezei, latitudinii, longitudinii

#currentS = "Viteza curentă:" # Speed string #totalDis = "Distanța totală:" # Distance string #currentLoc = "Locația curentă:" # Șirul de locație

# Distanța coordonatelor x și y

distX = 10 distY = 20

pointsList =

# Viteza coordonatelor x și y

viteza X = 10 viteza Y = 20

# Locația x și y coordonează

locX = 10 locY = 20

# Convertește de la m / s la mph

conversionVal = 2,24

# Funcția de actualizare a vitezei, returnează șirul

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)

return (location.address)

# Funcția de actualizare Latitude, returnează valoarea float

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

# Funcția de actualizare a longitudinii, returnează șirul

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

# Funcția Distanță returnează distanța TOTALĂ parcursă

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

# Resetează distanța totală

def resDistance ():

global totalDistance totalDistance = 0

# Funcție utilizată pentru a găsi distanța dintre două coordonate

# folosește formula Haversine pentru a găsi. # Punctele de intrare sunt un tuplu

def coorDistance (punctul 1, punctul 2):

# Raza aproximativă a Pământului în kilometri pământ Radiul = 6373,0

lat1 = punct1 [0]

lon1 = punct1 [1]

lat2 = punct2 [0]

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

# Conversia km în mile

distanță = (earthRadius * c) * 0,62137

if (distanță <= 0,01): returnează 0,00 altceva: returnează runda (distanță, 3)

# Funcția de afișare a vitezei pe ecran

def dispSpeed ():

global SpeedVar # Plasați distanța pe variabilă pe ecran draw.text ((speedX, speedY), str (SpeedVar), font = ImageFont.truetype ("Lato-Medium.ttf", 72))

# Funcția de afișare a distanței pe ecran

def dispDistance ():

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

# Funcția afișează locația pe ecran, necesită funcționarea internetului

def dispLocation ():

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

# Utilizarea dicționarului pentru a imita declarațiile de comutare

dispOptions = {

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

# Funcția de ieșire a ecranului

ieșire def ():

# Utilizarea variabilei globale pentru displayIndex global displayIndex # Ștergerea ecranului și aplicarea fundalului disp.clear ((255, 255, 255)) draw.rectangle ((0, 10, 127, 150), contur = (255, 0, 0), umplere = (255, 0, 0))

# Funcția de apeluri în funcție de valoarea displayIndex

dispOptions [displayIndex] ()

# Se va șterge dacă funcționează altă metodă

# variabilă distanță a locului pe ecran

# draw.text ((distX, distY), str (distFunc ()), font = ImageFont.load_default ()) # plasează variabila de viteză pe ecran # draw.text ((speedX, speedY), speedFunc (), font = ImageFont.load_default ()) # Afișează actualizări pe ecran disp.display ()

displayButton = 18 # BCM Pin pe zmeură pi

resetButton = 23 # BCM Pin pe raspberry pi

buton Apăsați = Fals

Def checkDisplay ():

buton global Apăsați displayIndex global if (bGPIO.input (displayButton) și nu buton Apăsați): displayIndex + = 1 buton Apăsați = True if (displayIndex == 2): displayIndex = 0 elif (bGPIO.input (displayButton) și buttonPress): print (" Încă apăsat ") altfel: buton Apăsați = False

# Configurați GPS

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

timerPeriod =.5

# Valoare index pentru display displayIndex = 0 try: for 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 not connected yet') time.sleep (.1) time.sleep (.8) exceptie KeyboardInterrupt: gps_socket.close () print (' / nTerminat de utilizator ctrl + c ')

Codul de mai sus este doar un exemplu despre cum să codificăm sistemul nostru și am încorporat un videoclip despre cum funcționează acest sistem.