GPS სისტემა: 7 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

პროექტის შემქმნელი: კარლოს გომესი

სანდო სანავიგაციო სისტემის ქონა უმნიშვნელოვანესია მათთვის, ვინც ცდილობს იმოგზაუროს და შეისწავლოს სამყარო.

ყველაზე მნიშვნელოვანი ასპექტი, რომელიც ნავიგაციის სისტემის მუშაობის საშუალებას იძლევა არის სისტემის შიგნით ჩამონტაჟებული GPS შესაძლებლობა. GPS სისტემა ნებისმიერს აძლევს საშუალებას თვალყური ადევნოს მათ ადგილმდებარეობას და სიჩქარეს, რათა აჩვენოს მომხმარებლის შესახებ ზუსტი ინფორმაცია და მისცეს მომხმარებელს ზუსტი წარმოდგენა იმის შესახებ, თუ სად არიან და რამდენად შორს არიან ისინი თავიანთი მდებარეობიდან.

გლობალური პოზიციონირების სისტემა (GPS) არის თანამგზავრების ქსელი, რომელიც ბრუნავს დედამიწაზე დაახლოებით 20 000 კმ სიმაღლეზე. ნებისმიერს, რომელსაც აქვს GPS მოწყობილობა, შეუძლია მიიღოს რადიო სიგნალები, რომლებსაც თანამგზავრები გადასცემენ და შეუძლია გამოიყენოს ისინი, როგორც საჭიროა. სადაც არ უნდა იყოს თქვენი მდებარეობა პლანეტაზე მინიმუმ ოთხი GPS უნდა იყოს თქვენთვის ნებისმიერ დროს. მეთოდის გამოყენებით, სახელწოდებით 3-D trilateration, GPS მოწყობილობას შეუძლია გამოიყენოს სამი თანამგზავრი, რათა დაადგინოს მოწყობილობის მდებარეობა დედამიწაზე. სამივე თანამგზავრიდან თითოეული აგზავნის სიგნალს მოწყობილობაზე და მოწყობილობა განსაზღვრავს მის მანძილს თანამგზავრიდან. სამი მანძილის თითოეული გამოთვლის გამოყენებით მოწყობილობას შეუძლია ზუსტად განსაზღვროს მისი მდებარეობა დედამიწაზე და ეს დაუბრუნოს მას მომხმარებელს.

GPS სისტემა, რომელსაც ჩვენ შევქმნით, შეძლებს თვალყური ადევნოს მომხმარებლის ადგილსამყოფელს დედამიწაზე მომხმარებლის კოორდინატების მოპოვებით და გარკვეული გათვლებით, რათა დააბრუნოს მომხმარებლის სიჩქარე, მდებარეობა და დაფარული მანძილი.

ნაბიჯი 1: დაწყება

იმისათვის, რომ დავიწყოთ ეს პროექტი, ჩვენ ჯერ უნდა შევიკრიბოთ ყველა სწორი მასალა

1: Raspberry Pi Zero W

2: GPS მიმღები

3: 1.8 TFT 128 x 160 LCD SPI ეკრანი

4: ~ 11 მავთული

5: 2 ღილაკი

6: 2x 1k და 2x 10k რეზისტორები დასაშვები ღილაკებისთვის

7: პურის დაფა

ეს პროექტი გამოიყენებს Raspberry Pi– ს GPIO ქინძისთავებს და, როგორც ასეთი, ჩვენ დაგვჭირდება ყველაფრის დაკავშირება პურის დაფასთან, რათა განვავითაროთ ჩვენი პროექტი. ასევე ვარაუდობენ, რომ ყველა ქინძისთავზე შედუღება დასრულებულია და დასრულებულია ჩვენი ყველა ნაწილის გადასვლამდე და შეერთებამდე.

ნაბიჯი 2: შეაერთეთ GPS მოდული Raspberry Pi– სთან

ჩვენი GPS სისტემის გამოსაყენებლად დაგჭირდებათ Tx და Rx ქინძისთავების დაკავშირება GPS მოდულიდან GPIO pin 14 და 15 Raspberry Pi– ზე. GPS მიმღების Tx pin მიდის Pi– ს Rx pin– ზე და GPS მიმღების Rx pin მიდის Raspberry pi– ს Tx pin– ზე.

სურათებში ნაჩვენები GPS მიმღები მოითხოვს 3.3 ვ გამოყენებას და თქვენ შეგიძლიათ დაუკავშიროთ 3.3 ვ ქინძისთავები სწორ ძაბვას, ხოლო მიწას მიწას მიწასთან აკავშირებთ.

ნაბიჯი 3: მიიღეთ მონაცემები GPS მიმღების მოდულიდან

GPS მიმღებიდან Raspberry Pi– მდე მონაცემების მისაღებად ჩვენ უნდა მივცეთ უფლება სოკეტების წაკითხვა UART პორტებიდან. ნედლეული მონაცემების წაკითხვა დაგვჭირდება, რომ შევქმნათ ჩვენი საანალიზო ბიბლიოთეკა, მაგრამ ამ სცენარში ჩვენ შეგვიძლია გამოვიყენოთ GPS დემონი, რომელიც მუშაობს ფონზე, რათა დაგეხმაროთ მონაცემების გაანალიზებაში და გადაცემა ჟოლოს პიზე.

ამის მისაღწევად ჩვენ შეგვიძლია გავხსნათ ტერმინალი Raspberry Pi– ზე და შევასრულოთ კოდი:

sudo apt-get განახლება

sudo apt-get დააინსტალირეთ gpsd gpsd- კლიენტები python-gps

ეს უნდა იზრუნოს გადმოტვირთვაზე ჩვენთვის.

დასრულების შემდეგ, ჩვენ უნდა გამორთოთ gpsd სისტემის სერვისი შემდეგი ბრძანებების გაშვებით:

sudo systemctl stop gpsd.socket

sudo systemctl გამორთეთ gpsd.socket

თუ ოდესმე გსურთ ჩართოთ ნაგულისხმევი gpsd სისტემის სერვისი, შეგიძლიათ აღადგინოთ შემდეგი ბრძანებები მის აღსადგენად:

sudo systemctl ჩართვა gpsd.socket

sudo systemctl დაწყება gpsd.socket

ახლა ჩვენ უნდა დავიწყოთ gpsd დემონი და მიუთითოთ იგი UART პორტებზე შესვლის გზით

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

ჩვენ ახლა შეგვიძლია გაუშვათ ქვემოთ მოყვანილი ბრძანება და ვნახოთ ყველა მონაცემი, რომელიც მცურავია!

cgps -s

ნაბიჯი 4: დაუკავშირეთ ჩვენება Raspberry Pi- ს

მას შემდეგ რაც ჩვენ გვექნება GPS მიმღები Raspberry Pi– სთან მუშაობისას, ჩვენ შეგვიძლია დავამყაროთ დისპლეი Raspberry Pi– სთან. ჩვენ გამოვიყენებთ 5 მავთულს ჩვენი LCD ეკრანის დასაკავშირებლად Raspberry Pi– სთან და კიდევ 4 ქინძისთავთან მთავარი ენერგიისა და LED– ის დასაკავშირებლად. ეკრანზე.

მე ჩავრთე TFT ეკრანის ფოტო, რომელსაც მე ვიყენებ, მაგრამ ეს უნდა იმუშაოს მსგავსი ზომის და აგების ეკრანებთან.

შეაერთეთ LED- და GND მიწასთან და შეაერთეთ LED+ და VCC 3.3V.

შეაერთეთ ეკრანზე RESET პინი 25 – ის Pi დაფაზე.

შეაერთეთ A0 პინზე 24 დაფაზე.

შეაერთეთ SDA პინი MOSI პინზე Pi დაფაზე.

შეაერთეთ SCK პინი LCD ეკრანზე Pi დაფაზე.

შეაერთეთ CS პინი PIN დაფაზე 8 -ის პინზე.

ნაბიჯი 5: დააინსტალირეთ ეკრანი ჟოლოს პითან მუშაობისთვის

ჩვენების დასაყენებლად ჩვენ უნდა გამოვიყენოთ ST7735 ბიბლიოთეკა, რომელიც ნაპოვნია ამ რეპოში:

Python ST7735 ეკრანის ბიბლიოთეკა

მას შემდეგ რაც ჩვენ გვაქვს ეს ბიბლიოთეკა Raspberry Pi სისტემაზე დაინსტალირებული, ჩვენ შეგვიძლია გავაგრძელოთ მაგალითი ფაილის დაყენება იმის დასადასტურებლად, რომ ჩვენი წინა გაყვანილობა სწორად მუშაობს.

შექმენით ფაილი სახელწოდებით example.py და ჩასვით შემდეგი ტექსტი იქ ერთად თქვენს მიერ არჩეული სურათის ნიმუში იმავე საქაღალდეში

იმპორტი ST7735 როგორც TFTimport Adafruit_GPIO როგორც GPIO იმპორტი Adafruit_GPIO. SPI როგორც SPI

სიგანე = 128

HEIGHT = 160 SPEED_HZ = 4000000

# ჟოლო Pi კონფიგურაცია.

# ეს არის ქინძისთავები, რომლებიც საჭიროა LCD– ის Raspberry Pi– ს დასაკავშირებლად

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

# შექმენით TFT LCD ჩვენების კლასი.

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

# ჩვენების ინიციალიზაცია.

disp.begin () disp.reset ()

# ჩატვირთეთ სურათი.

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

# შეცვალეთ სურათი და გადაატრიალეთ იგი ეკრანის შესატყვისი.

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

# დაბეჭდება ტერმინალში, რომ ჩვენი პროგრამა ხატავს ჩვენს სურათს ეკრანზე

ბეჭდვა ("სურათის დახატვა")

# ეს ფუნქცია აჩვენებს ჩვენს სურათს ეკრანზე

დისპლეი. ჩვენება (სურათი)

ეს ფაილი დააინსტალირებს Raspberry Pi კონფიგურაციას LCD ეკრანზე და ბიბლიოთეკა გარდაქმნის ჩვენს სურათს საქაღალდეში და აჩვენებს მას ეკრანზე.

ნაბიჯი 6: დააყენეთ სახელმწიფო მანქანები, რომ აჩვენონ GPS ინფორმაცია ეკრანზე

ჩვენ გამოვიყენებთ 5 სხვადასხვა სახელმწიფო მანქანას, ჩვენი ამოცანის დიაგრამის განხორციელებისას ჩვენი GPS სისტემის დასაყენებლად.

ჩვენების შეცვლა მდგომარეობის მანქანა:

ეს სახელმწიფო მანქანა გააკონტროლებს რომელი ეკრანის ჩვენებას დამოკიდებულია ჩვენი ღილაკის შეყვანის მიხედვით. ის ამას ცვლის ცვლადის შეცვლით, რაც პითონს საშუალებას აძლევს ისარგებლოს იხვის აკრეფით და გამოაძახოს სწორი ფუნქცია ჩვენებაზე, გამოძახებული ფუნქციის მიხედვით

სიჩქარის მდგომარეობის მანქანა:

ეს სახელმწიფო მანქანა შეასრულებს მიმდინარე სიჩქარეს ინდივიდების ადგილმდებარეობის მიხედვით. ეს შეასრულებს ყველა საათის ციკლს GPS სისტემისთვის

გამომავალი მდგომარეობის მანქანა:

ეს სახელმწიფო მანქანა განსაზღვრავს გამომავალს ცვლადის საფუძველზე, რომელსაც ჩვენების შეცვლის მდგომარეობის მანქანა განსაზღვრავს, რომ იყოს მიმდინარე ჩვენება.

მანძილის სახელმწიფო მანქანა

ეს სახელმწიფო მანქანა ასრულებს საათის ყოველ ციკლს და განსაზღვრავს მომხმარებლის მიერ გატარებულ საერთო მანძილს და მას შემდეგ რაც გადატვირთვის ღილაკს დააჭერთ, აღადგენს მიმდინარე გავლილ მანძილს.

მდებარეობის სახელმწიფო მანქანა:

ეს სახელმწიფო მანქანა აბრუნებს მომხმარებლის ამჟამინდელ მდებარეობას, კოორდინატების გამოყენებით, რომელსაც GPS მოდული აბრუნებს მომხმარებლის შესახებ. ეს სახელმწიფო მანქანა დამოკიდებულია მომხმარებლების ინტერნეტ კავშირზე.

ნაბიჯი 7: მოდით განვახორციელოთ ჩვენი GPS სისტემა

მას შემდეგ რაც ჩვენ გვექნება ჩვენი GPS მოდული, რომელიც აგზავნის ინფორმაციას ჩვენს ჟოლოს Pi- ზე და ჩვენს LCD ეკრანზე, რომელიც აჩვენებს ინფორმაციას მასზე, ჩვენ შეგვიძლია დავიწყოთ ჩვენი GPS სისტემის დაპროგრამება. მე გამოვიყენებ წინა ნაბიჯის სასრული მდგომარეობის მანქანებს ჩვენი GPS სისტემის კოდირების მიზნით

## ნავიგაციის სისტემის მთავარი ფაილი # # # #

# ბიბლიოთეკები სურათების დახატვისთვის

PIL იმპორტიდან სურათი PIL იმპორტიდან ImageDraw საწყისი PIL იმპორტი ImageFont

# ბიბლიოთეკა ST7737 კონტროლერისთვის

იმპორტი ST7735 როგორც TFT

# ბიბლიოთეკა GPIO– სთვის ჟოლოს პიისთვის

იმპორტი Adafruit_GPIO როგორც GPIO იმპორტი Adafruit_GPIO. SPI როგორც SPI

# ბიბლიოთეკა GPS– ისთვის

#იმპორტი gpsd საწყისი gps3 იმპორტი gps3

# ბიბლიოთეკა დროულად

იმპორტის დრო

# ბიბლიოთეკა ორ წერტილს შორის მანძილის საპოვნელად

მათემატიკიდან იმპორტი ცოდვა, cos, sqrt, atan2, რადიანები

# იმპორტი Rpi ბიბლიოთეკა, რომ გამოიყენოთ ღილაკები მენიუს გადასატანად და გადატვირთვისთვის

# იმპორტი RPi. GPIO როგორც bGPIO

# დააყენეთ ღილაკები ღილაკებისთვის

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)

# იმპორტი გეოპიური ბიბლიოთეკა გეოკოდირებისთვის

# # ინტერნეტის შესასრულებლად აუცილებელია

geopy.geocoders იმპორტირება Nominatim

გეოლოკატორი = ნომინატიმი ()

# მუდმივები სისტემისთვის

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

სიგანე = 128

HEIGHT = 160 SPEED_HZ = 4000000

# Raspberry Pi კონფიგურაციის ქინძისთავები

DC = 24 # A0 TFT ეკრანზე RST = 25 # გადატვირთვა PIN TFT ეკრანზე SPI_PORT = 0 # SPI პორტი ჟოლოს პიზე, SPI0 SPI_DEVICE = 0 # მონა არჩევა ჟოლოს პიზე, CE0

# შექმენით TFT LCD ჩვენების ობიექტი

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

# ჩვენების ინიციალიზაცია

დაიშალა. ()

# ფონი იქნება მწვანე

#გამიზნულია ((0, 255, 0))

# ეკრანის გასუფთავება თეთრამდე და ჩვენება

#disp.clear ((255, 255, 255)) draw = disp.draw () #draw.rectangle ((0, 10, 127, 150), მონახაზი = (255, 0, 0), შევსება = (0, 0, 255)) #დისპლეი ()

# სიჩქარე, გრძედი, გრძედი განლაგების ცვლადი

#currentS = "მიმდინარე სიჩქარე:" # სიჩქარე string #totalDis = "სულ მანძილი:" # მანძილი string #currentLoc = "ამჟამინდელი მდებარეობა:" # მდებარეობის სტრიქონი

# მანძილი x და y კოორდინატები

distX = 10 distY = 20

ქულების სია =

# სიჩქარე x და y კოორდინატები

სიჩქარე X = 10 სიჩქარე Y = 20

# მდებარეობა x და y კოორდინატები

locX = 10 locY = 20

# გარდაქმნის m/s– დან mph– ში

კონვერტაციისVal = 2.24

# სიჩქარის განახლების ფუნქცია, აბრუნებს სტრიქონს

SpeedVar = 0

def speedFunc (): გლობალური SpeedVar SpeedText = data_stream. TPV ['სიჩქარე'] თუ (SpeedText! = "n/a"): SpeedText = float (SpeedText) * conversionVal SpeedVar = მრგვალი (SpeedText, 1) # დაბრუნება (SpeedText)

def locationFunc ():

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

reverseString = latLoc + "," + lonLoc

მდებარეობა = geolocator.reverse (reverseString)

დაბრუნება (მდებარეობა. მისამართი)

# Latitude განახლების ფუნქცია, აბრუნებს float მნიშვნელობას

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

# გრძედის განახლების ფუნქცია, აბრუნებს სტრიქონს

def lonFunc (): განედი = data_stream. TPV ['lon'] if (განედი == "n/a"): return 0 else: return float (რაუნდი (განედი, 4))

# დისტანციის ფუნქცია აბრუნებს TOTAL განვლილ მანძილს

სულ მანძილი = 0

def distFunc ():

გლობალური totalDistance newLat = latFunc () newLon = lonFunc () if (newLat == 0 ან newLon == 0): totalDistance = totalDistance # return (totalDistance) else: pointsList.append ((newLat, newLon)) last = len (pointsList) -1 თუ (ბოლო == 0): სხვას დაბრუნება: totalDistance += coorDistance (pointsList [last-1], pointsList [last]) # return totalDistance

# აღადგენს საერთო მანძილს

def resDistance ():

გლობალური totalDistance totalDistance = 0

# ფუნქცია გამოიყენება ორ კოორდინატს შორის მანძილის მოსაძებნად

# იყენებს ჰავერსინის ფორმულას მოსაძებნად. # შეყვანის წერტილები მრავლდება

def coor მანძილი (წერტილი 1, წერტილი 2):

# დედამიწის სავარაუდო რადიუსი დედამიწის კილომეტრში რადიუსი = 6373.0

lat1 = წერტილი 1 [0]

lon1 = წერტილი 1 [1]

lat2 = წერტილი 2 [0]

lon2 = წერტილი 2 [1]

მანძილი ლონი = ლონი 2 - ლონი 1

distanceLat = lat2 - lat1

# ჰავერსინი ა

a = sin (distanceLat/2) ** 2 + cos (lat1)*cos (lat2)*sin (distanceLon/2) ** 2

# ჰავერსინი გ

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

# გადააკეთეთ კმ მილი

მანძილი = (earthRadius * c) * 0.62137

თუ (მანძილი <= 0.01): დაბრუნება 0.00 სხვა: დაბრუნების რაუნდი (მანძილი, 3)

# ფუნქცია ეკრანზე სიჩქარის ჩვენებისათვის

def dispSpeed ():

გლობალური SpeedVar # განათავსეთ მანძილი ცვლადზე ეკრანის გათამაშებაზე. ტექსტი ((speedX, speedY), str (SpeedVar), font = ImageFont.truetype ("Lato-Medium.ttf", 72))

# ფუნქცია ეკრანზე მანძილის ჩვენებისათვის

def დისტანცია ():

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

# ფუნქცია ეკრანზე მდებარეობის ჩვენებისათვის, მოითხოვს ინტერნეტს სამუშაოდ

def დისლოკაცია ():

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

# ლექსიკონის გამოყენება შეცვლის განცხადებების იმიტირებისთვის

dispOptions = {

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

# ეკრანის გამომავალი ფუნქცია

def გამომავალი ():

# გლობალური ცვლადის გამოყენება ჩვენებისათვის Index გლობალური ჩვენება Index # ეკრანის გასუფთავება და ფონის გამოყენება. ნათელი ((255, 255, 255)) დახაზეთ. მართკუთხედი ((0, 10, 127, 150), მონახაზი = (255, 0, 0), შევსება = (255, 0, 0))

# ზარების ფუნქცია დამოკიდებულია ჩვენების ინდექსის ღირებულებაზე

dispOptions [displayIndex] ()

# წაიშლება თუ სხვა მეთოდი მუშაობს

# ადგილი დისტანციის ცვლადი ეკრანზე

#draw.text ((distX, distY), str (distFunc ()), font = ImageFont.load_default ()) #მოათავსეთ სიჩქარის ცვლადი ეკრანზე #draw.text ((speedX, speedY), speedFunc (), font = ImageFont.load_default ()) # ეკრანის განახლებების ჩვენება disp.display ()

displayButton = 18 # BCM Pin ჟოლოს პიზე

resetButton = 23 # BCM Pin ჟოლოს პიზე

ღილაკზე დაჭერა = ყალბი

def checkDisplay ():

გლობალური ღილაკი პრეს გლობალური ჩვენება ინდექსი if (bGPIO.input (displayButton) და არა ღილაკი Press): displayIndex += 1 ღილაკი Press = True if (displayIndex == 2): displayIndex = 0 elif (bGPIO.input (displayButton) და ღილაკზე დაჭერა): ბეჭდვა (" ჯერ კიდევ დაჭერილია ") სხვაგან: ღილაკზე დაჭერა = ყალბი

# დააყენეთ GPS

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

ტაიმერი პერიოდი =.5

# ინდექსის მნიშვნელობა ჩვენების ჩვენებისათვის Index = 0 ცდა: new_data– ს gps_socket– ში: if new_data: data_stream.unpack (new_data) თუ 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 ჯერ არ არის დაკავშირებული') time.sleep (.1) time.sleep (.8) გარდა KeyboardIntruptrupt: gps_socket.close () print (' / n დამთავრებული მომხმარებლის მიერ ctrl+c ')

ზემოთ მოყვანილი კოდი მხოლოდ ერთი მაგალითია იმისა, თუ როგორ ხდება ჩვენი სისტემის კოდირება და მე ჩავრთე ვიდეო, თუ როგორ მუშაობს ეს სისტემა.