System GPS: 7 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:32

Twórca projektu: Carlos Gomez

Posiadanie niezawodnego systemu nawigacyjnego jest najważniejsze dla każdego, kto próbuje podróżować i poznawać świat.

Najważniejszym aspektem, który umożliwia działanie systemu nawigacyjnego, jest funkcja GPS wbudowana w system. System GPS pozwala każdemu śledzić swoją lokalizację i prędkość, aby wyświetlać dokładne informacje o użytkowniku i dać mu dokładną reprezentację tego, gdzie się znajduje i jak daleko od swojej lokalizacji.

Global Positioning System (GPS) to sieć satelitów krążących wokół Ziemi na wysokości około 20 000 km. Każdy, kto posiada urządzenie GPS, może odbierać sygnały radiowe nadawane przez satelity i wykorzystywać je w dowolny sposób. Gdziekolwiek jesteś na naszej planecie, co najmniej cztery GPS powinny być dostępne przez cały czas. Korzystając z metody zwanej trilateracją 3-D, urządzenie GPS może wykorzystać trzy satelity w celu określenia położenia urządzenia na Ziemi. Każdy z trzech satelitów wysyła sygnał do urządzenia, a urządzenie określa swoją odległość od satelity. Korzystając z każdego z trzech obliczeń odległości, urządzenie jest teraz w stanie określić swoje położenie na Ziemi i zwraca je użytkownikowi.

Stworzony przez nas system GPS będzie w stanie śledzić położenie użytkownika, pozyskując jego współrzędne na Ziemi i wykonując pewne obliczenia w celu zwrócenia użytkownikowi prędkości, lokalizacji i przebytej odległości.

Krok 1: Pierwsze kroki

Aby rozpocząć ten projekt, najpierw musimy zebrać wszystkie właściwe materiały

1: Raspberry Pi Zero W

2: Odbiornik GPS

3: 1.8 TFT 128x160 ekran LCD SPI

4: ~11 przewodów

5: 2 przyciski

6: rezystory 2x 1k i 2x 10k dla przycisków pull down

7: deska do chleba

Ten projekt będzie wykorzystywał piny GPIO Raspberry Pi i jako taki będziemy musieli połączyć wszystko z płytką chlebową, aby rozwijać nasz projekt. Zakłada się również, że lutowanie na wszystkich pinach jest wykonane i zakończone przed przejściem i połączeniem wszystkich naszych części.

Krok 2: Podłącz moduł GPS do Raspberry Pi

Aby korzystać z naszego systemu GPS należy podłączyć piny Tx i Rx modułu GPS do pinów 14 i 15 GPIO w Raspberry Pi. Pin Tx odbiornika GPS idzie do pinu Rx Pi, a pin Rx odbiornika GPS do pinu Tx Raspberry pi.

Odbiornik GPS pokazany na zdjęciach wymaga użycia 3,3 V i można podłączyć piny 3.3 V do odpowiedniego napięcia, jednocześnie podłączając pin uziemienia do masy.

Krok 3: Odbierz dane z modułu odbiornika GPS

Aby odbierać dane z odbiornika GPS do Raspberry Pi musimy umożliwić odczyt poprawnym gniazdom z portów UART. Odczytanie surowych danych wymagałoby od nas stworzenia własnej biblioteki analizującej, ale w tym scenariuszu możemy skorzystać z demona GPS działającego w tle, aby pomóc w przetwarzaniu danych i przesyłaniu ich do Raspberry Pi

W tym celu możemy otworzyć terminal na Raspberry Pi i wykonać kod:

aktualizacja sudo apt-get

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

To powinno zająć się pobieraniem za nas.

Po zakończeniu musimy wyłączyć usługę systemową gpsd, uruchamiając następujące polecenia:

sudo systemctl stop gpsd.socket

sudo systemctl wyłącz gpsd.socket

Jeśli kiedykolwiek chcesz włączyć domyślną usługę systemową gpsd, możesz uruchomić następujące polecenia, aby ją przywrócić:

sudo systemctl włącz gpsd.socket

sudo systemctl start gpsd.socket

Teraz musimy uruchomić demona gpsd i skierować go do portów UART, wpisując

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

Możemy teraz uruchomić poniższe polecenie i zobaczyć wszystkie dane napływające!

cgps -s

Krok 4: Podłącz wyświetlacz do Raspberry Pi

Gdy już mamy nasz odbiornik GPS i pracujemy z Raspberry Pi, możemy podłączyć wyświetlacz do Raspberry Pi. Użyjemy 5 przewodów do podłączenia naszego wyświetlacza LCD do Raspberry Pi i kolejnych 4 pinów do podłączenia głównego zasilania i diody LED na ekranie.

Dołączyłem zdjęcie ekranu TFT, którego używam, ale powinno to działać z ekranami o podobnej wielkości i budowie.

Podłącz LED- i GND do uziemienia i podłącz LED+ i VCC do 3,3V.

Podłącz pin RESET na ekranie do pinu 25 na płytce Pi.

Podłącz A0 do pinu 24 na płycie Pi.

Podłącz pin SDA do pinu MOSI na płycie Pi.

Podłącz pin SCK na ekranie LCD do płytki Pi.

Podłącz pin CS do pinu 8 na płycie Pi.

Krok 5: Skonfiguruj wyświetlacz do pracy z Raspberry Pi

Aby skonfigurować wyświetlacz musimy skorzystać z biblioteki ST7735 znajdującej się w tym repozytorium:

Biblioteka ekranów Pythona ST7735

Po zainstalowaniu tej biblioteki wyświetlania w naszym systemie Raspberry Pi, możemy teraz przystąpić do konfigurowania przykładowego pliku, aby potwierdzić, że nasze poprzednie okablowanie działa poprawnie.

Utwórz plik o nazwie example.py i wstaw tam następujący tekst wraz z przykładowym obrazem, który wybierzesz w tym samym folderze

import ST7735 jako TFTimport Adafruit_GPIO jako GPIO import Adafruit_GPIO. SPI jako SPI

SZEROKOŚĆ = 128

WYSOKOŚĆ = 160 SPEED_HZ = 4000000

# Konfiguracja Raspberry Pi.

# Są to piny potrzebne do podłączenia wyświetlacza LCD do Raspberry Pi

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

# Utwórz klasę wyświetlacza TFT LCD.

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

# Zainicjuj wyświetlacz.

disp.początek() disp.reset()

# Załaduj obraz.

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

# Zmień rozmiar obrazu i obróć go tak, aby pasował do wyświetlacza.

image = image.rotate(270).resize((SZEROKOŚĆ, WYSOKOŚĆ))

# Wydrukuje na terminalu, na którym nasz program rysuje nasz obraz na ekranie

print('Rysunek obrazu')

# Ta funkcja wyświetli nasz obraz na ekranie

wyśw.wyświetlacz(obraz)

Ten plik skonfiguruje konfigurację Raspberry Pi dla ekranu LCD, a biblioteka przekonwertuje nasz obraz w folderze i wyświetli go na ekranie.

Krok 6: Skonfiguruj maszyny stanu, aby wyświetlać informacje GPS na wyświetlaczu

Użyjemy 5 różnych maszyn stanowych, wdrażając nasz diagram zadań, aby skonfigurować nasz system gps.

Wyświetlacz Zmień stan maszyny:

Ta maszyna stanu będzie kontrolować, który element ma być wyświetlany w zależności od wejścia przycisku. Robi to poprzez zmianęzmiennej która pozwala pythonowi na skorzystanie z pisania kaczką i wywołanie właściwej funkcji do wyświetlenia w zależności od wywołanej funkcji

Maszyna stanu prędkości:

Ta maszyna stanu będzie realizowała bieżącą prędkość w zależności od lokalizacji osób. Spowoduje to wykonanie każdego cyklu zegara dla systemu GPS

Maszyna stanu wyjściowego:

Ten automat stanów określi dane wyjściowe na podstawie zmiennej, którą automat stanów zmiany wyświetlacza określi jako bieżący wyświetlacz.

Maszyna stanu odległości

Ta maszyna stanu wykonuje każdy cykl zegara i określa całkowitą odległość przebytą przez użytkownika, a po naciśnięciu przycisku resetowania zresetuje bieżącą przebytą odległość.

Maszyna stanu lokalizacji:

Ta maszyna stanu zwraca bieżącą lokalizację użytkownika, używając współrzędnych, które moduł GPS zwraca o użytkowniku. Ta maszyna stanu jest zależna od połączenia internetowego użytkownika.

Krok 7: Wdrożmy nasz system GPS

Gdy już mamy nasz moduł GPS wysyłający informacje do naszego Raspberry Pi, a nasz ekran LCD wyświetlający na nim informacje, możemy rozpocząć programowanie naszego systemu GPS. Użyję automatów skończonych z poprzedniego kroku, aby zakodować nasz system GPS

## Główny plik systemu nawigacyjnego # # # #

# Biblioteki do rysowania obrazów

z PIL importuj obrazek z PIL importuj ImageDraw z PIL importuj ImageFont

# Biblioteka dla kontrolera ST7737

importuj ST7735 jako TFT

# Biblioteka GPIO dla Raspberry Pi

importuj Adafruit_GPIO jako GPIO importuj Adafruit_GPIO. SPI jako SPI

# Biblioteka dla GPS

#importuj gpsd z gps3 importuj gps3

# Biblioteka na czas

czas importu

# Biblioteka do znajdowania odległości między dwoma punktami

z matematyki import sin, cos, sqrt, atan2, radians

# Importuj bibliotekę Rpi, aby używać przycisków do przełączania menu i resetowania

# importuj RPi. GPIO jako bGPIO

# Piny konfiguracyjne dla przycisków

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)

# importuj bibliotekę geopy do geokodowania

# # Aby to zadziałało, niezbędny jest dostęp do Internetu

z geopy.geocoders importuj Nominatim

geolokator = Nominatim()

# Stałe dla systemu

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

SZEROKOŚĆ = 128

WYSOKOŚĆ = 160 PRĘDKOŚĆ_HZ = 4000000

# Piny konfiguracyjne Raspberry Pi

DC = 24 # A0 na ekranie TFT RST = 25 # Pin resetowania na ekranie TFT SPI_PORT = 0 # Port SPI na raspberry pi, SPI0 SPI_DEVICE = 0 # Wybór urządzenia podrzędnego na rapsberry pi, CE0

# Utwórz obiekt wyświetlacza TFT LCD

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

# Zainicjuj wyświetlacz

wyśw.rozpocznij()

# Tło zostanie ustawione na zielone

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

# Wyczyść ekran do bieli i wyświetlacza

#disp.clear((255, 255, 255)) draw = disp.draw() #draw.rectangle((0, 10, 127, 150), outline=(255, 0, 0), fill=(0, 0, 255)) #wyśw.wyświetlacz()

# Zmienne położenia prędkości, szerokości geograficznej i długości geograficznej

#currentS = "Aktualna prędkość: " # Ciąg prędkości #totalDis = "Całkowita odległość: " # Ciąg odległości #currentLoc = "Aktualna lokalizacja: " # Ciąg lokalizacji

# Odległość x i y współrzędne

distX = 10 distY = 20

lista punktów =

# Prędkość x i y współrzędne

prędkośćX = 10 prędkośćY = 20

# Współrzędne x i y lokalizacji

locX = 10 locY = 20

# Konwertuje z m/s na mph

wartość konwersji = 2,24

# Funkcja aktualizacji prędkości, zwraca ciąg

Zmienna prędkości = 0

def speedFunc(): globalny SpeedVar SpeedText = data_stream. TPV['speed'] if (SpeedText != "nie dotyczy"): SpeedText = float(SpeedText) * ConversionVal SpeedVar = round(SpeedText, 1) # return (SpeedText)

def LocationFunc():

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

reverseString = latLoc + ", " + lonLoc

lokalizacja = geolocator.reverse(reverseString)

powrót (lokalizacja.adres)

# Funkcja aktualizacji szerokości geograficznej, zwraca wartość zmiennoprzecinkową

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

# Funkcja aktualizacji długości geograficznej, zwraca ciąg

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

# Funkcja odległości zwraca CAŁKOWITĄ przebytą odległość

całkowita odległość = 0

def distFunc():

global totalDistance newLat = latFunc() newLon = lonFunc() if(newLat == 0 lub 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 całkowitą odległość

def resOdległość():

global totalDistance totalDistance = 0

# Funkcja używana do znajdowania odległości między dwiema współrzędnymi

# używa formuły Haversine'a do znalezienia. # Punkty wejściowe to krotka

def coorDistance(punkt1, punkt2):

# Przybliżony promień Ziemi w kilometrach earthPromień = 6373,0

lat1 = punkt1[0]

lon1 = punkt1[1]

lat2 = punkt2[0]

lon2 = punkt2[1]

odległośćLon = lon2 - lon1

odległośćLat = lat2 - lat1

# Haversine a

a = sin(odległośćLat/2)**2 + cos(lat1) * cos(lat2) * sin(odległośćLon/2)**2

# Haversine c

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

# Przelicz km na Mile

odległość = (promień ziemi * c) * 0,62137

if(odległość <= 0,01): zwróć 0,00 else: zwróć runda(odległość, 3)

# Funkcja wyświetlania prędkości na ekranie

def dispSpeed():

global SpeedVar # Umieść odległość na zmiennej na ekranie draw.text((speedX, speedY), str(SpeedVar), font=ImageFont.truetype("Lato-Medium.ttf", 72))

# Funkcja wyświetlania odległości na ekranie

def dispOdległość():

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

# Funkcja ti wyświetla lokalizację na ekranie, wymaga internetu do działania

def dispLocation():

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

# Używanie słownika do naśladowania instrukcji switch

dispOptions = {

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

# Funkcja wyjścia ekranu

def wyjście():

# Użycie zmiennej globalnej dla displayIndex global displayIndex # Czyszczenie ekranu i zastosowanie tła disp.clear((255, 255, 255)) draw.rectangle((0, 10, 127, 150), outline=(255, 0, 0), wypełnienie=(255, 0, 0))

# Wywołuje funkcję w zależności od wartości displayIndex

dispOptions[displayIndex]()

# Usunie się, jeśli inna metoda zadziała

# umieść zmienną odległości na ekranie

#draw.text((distX, distY), str(distFunc()), font=ImageFont.load_default()) # umieść zmienną prędkości na ekranie #draw.text((speedX, speedY), speedFunc(), font=ImageFont.load_default()) # Wyświetla aktualizacje na ekranie disp.display()

displayButton = 18 # BCM Pin na Raspberry Pi

resetButton = 23 # BCM Pin na Raspberry Pi

przyciskNaciśnij = Fałsz

def checkDisplay():

global buttonNaciśnij global displayIndex if(bGPIO.input(displayButton) a nie buttonPress): displayIndex += 1 buttonPress = True if(displayIndex == 2): displayIndex = 0 elif(bGPIO.input(displayButton) i buttonPress): print (" Nadal wciśnięty") w przeciwnym razie: przyciskNaciśnij = False

# Konfiguracja GPS

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

Okres licznika = 0,5

# Wartość indeksu wyświetlacza 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 jeszcze nie podłączony') time.sleep(.1) time.sleep(.8) z wyjątkiem KeyboardInterrupt: gps_socket.close() print(' \nZakończony przez użytkownika ctrl+c')

Powyższy kod to tylko jeden przykład, jak kodować nasz system, a ja umieściłem film o tym, jak ten system działa.