מערכת GPS: 7 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:16

יוצר הפרויקט: קרלוס גומז

החזקת מערכת ניווט אמינה היא החשובה ביותר לכל מי שמנסה לטייל ולחקור את העולם.

ההיבט החשוב ביותר המאפשר למערכת הניווט לפעול הוא יכולת ה- GPS המוטבעת בתוך המערכת. מערכת ה- GPS מאפשרת לכל אחד לעקוב אחר המיקום והמהירות שלו על מנת להציג מידע מדויק על המשתמש ולתת למשתמש ייצוג מדויק של המקום בו הוא נמצא וכמה הוא מרוחק מהמיקום שלו.

מערכת המיקום הגלובלית (GPS) היא רשת לוויינים המקיפה את כדור הארץ בגובה של כ- 20, 000 ק מ. כל מי שיש לו מכשיר GPS יכול לקבל את אותות הרדיו שהלוויינים משדרים ומסוגל לנצל אותם בכל הצורך. בכל מקום שהמיקום שלך על הפלנטה לפחות ארבעה GPS צריכים להיות זמינים עבורך בכל עת. באמצעות שיטה הנקראת תלת מימד, מכשיר GPS מסוגל להשתמש בשלושה לוויינים על מנת לקבוע את מיקומו של המכשיר בכדור הארץ. כל אחד משלושת הלוויינים שולח אות למכשיר והמכשיר קובע את מרחקו מהלווין. באמצעות כל אחד משלושת חישובי המרחק המכשיר מסוגל כעת לאתר את מיקומו בכדור הארץ והוא מחזיר את זה למשתמש.

מערכת ה- GPS שניצור תוכל לעקוב אחר מיקומי המשתמש על ידי השגת קואורדינטות המשתמש על פני כדור הארץ וביצוע מספר חישובים על מנת להחזיר את מהירות המשתמש, מיקומו והמרחק הנמשך.

שלב 1: תחילת העבודה

על מנת להתחיל את הפרויקט הזה, יהיה עלינו לאסוף תחילה את כל החומרים הנכונים

1: פטל פי אפס W

2: מקלט GPS

3: 1.8 TFT 128 x 160 מסך SPI LCD

4: ~ 11 חוטים

5: 2 כפתורים

6: נגדים 2x 1k ו 2x 10k לכפתורי משיכה

7: לוח לחם

פרויקט זה ישתמש בסיכות ה- GPIO של ה- Raspberry Pi וככזה נצטרך לחבר הכל עם לוח לחם על מנת לפתח את הפרויקט שלנו. כמו כן, ההנחה היא כי ההלחמה על כל הסיכות נעשית וסיימה לפני שנמשיך וחיבר את כל החלקים שלנו.

שלב 2: חבר מודול GPS ל- Raspberry Pi

כדי להשתמש במערכת ה- GPS שלנו, יהיה עליך לחבר את סיכות ה- Tx וה- Rx ממודול ה- GPS לפין GPIO 14 ו- 15 ב- Raspberry Pi. סיכת ה- Tx של מקלט ה- GPS עוברת לסיכה ה- Rx של ה- Pi וסיכת ה- Rx של מקלט ה- GPS עוברת אל סיכת ה- Tx של ה- Pi Raspberry.

מקלט ה- GPS המוצג בתמונות דורש שימוש 3.3V וניתן לחבר את סיכות 3.3V למתח הנכון, תוך חיבור סיכת הארקה לאדמה.

שלב 3: קבל נתונים ממודול מקלט GPS

על מנת לקבל נתונים ממקלט ה- GPS ל- Raspberry Pi עלינו לאפשר לשקעים הנכונים לקרוא מיציאות UART. קריאת הנתונים הגולמיים תדרוש מאיתנו ליצור ספריית ניתוח משלנו, אך בתרחיש זה נוכל לנצל שד GPS אשר פועל ברקע כדי לסייע בשימוש בנתונים ולשדר אותם ל- Raspberry Pi

על מנת להשיג זאת נוכל לפתוח מסוף ב- Raspberry Pi ולבצע את הקוד:

עדכון sudo apt-get

sudo apt-get להתקין gpsd gpsd-clients python-gps

זה אמור לדאוג לנו להורדה.

לאחר השלמתו, עלינו להשבית את שירות מערכת gpsd על ידי הפעלת הפקודות הבאות:

sudo systemctl עצור 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 בלוח ה- Pi.

חבר את סיכת ה- SDA לסיכת MOSI בלוח ה- Pi.

חבר את סיכת SCK במסך ה- LCD ללוח ה- Pi.

חבר את סיכת CS לסיכה 8 בלוח ה- Pi.

שלב 5: הגדרת תצוגה לעבודה עם פטל פטל

כדי להתקין את התצוגה עלינו להשתמש בספריית ST7735 שנמצאת במאגר זה:

ספריית המסך Python ST7735

לאחר שהתקנתנו את ספריית התצוגה הזו במערכת Raspberry Pi שלנו, כעת נוכל להמשיך בהקמת קובץ דוגמה כדי לאשר שהחיווט הקודם שלנו פועל כהלכה.

צור קובץ שכותרתו example.py והכנס לשם את הטקסט הבא יחד עם תמונה לדוגמה לבחירתך באותה תיקייה

יבוא ST7735 כ- TFT ייבוא Adafruit_GPIO כ- GPIO יבוא Adafruit_GPIO. SPI כ- SPI

רוחב = 128

HEIGHT = 160 SPEED_HZ = 4000000

# תצורת פטל פטל.

# אלה הפינים הדרושים לחיבור ה- LCD ל- Raspberry Pi

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

# צור מחלקת תצוגת LCD TFT.

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) הדפסה ('טוען תמונה …') image = Image.open ('cat.jpg')

# שנה את גודל התמונה וסובב אותה כך שיתאים לתצוגה.

image = image.rotate (270). גודל ((WIDTH, HEIGHT))

# תדפיס למסוף שהתוכנית שלנו מציירת את התמונה שלנו על המסך

הדפס ('ציור תמונה')

# פונקציה זו תציג את התמונה שלנו על המסך

תצוגת תצוגה (תמונה)

קובץ זה יגדיר את תצורת ה- Raspberry Pi למסך ה- LCD והספרייה תמיר את התמונה שלנו בתיקייה ותציג אותה על המסך.

שלב 6: הגדר מכונות מדינה להצגת מידע GPS בתצוגה

נשתמש בחמש מכונות מדינה שונות, תוך יישום תרשים המשימות שלנו להתקנת מערכת ה- GPS שלנו.

תצוגת מצב מצב תצוגה:

מכונת מדינה זו תשלוט על הצג בהתאם לקלט הכפתורים שלנו. זה עושה זאת על ידי שינוי משתנה המאפשר לפייתון לנצל את הקלדת הברווז ולקרוא לפונקציה הנכונה להצגה בהתאם לפונקציה הנקראת

מכונת מצב מהירות:

מכונת מצב זו תבצע את המהירות הנוכחית בהתאם למיקום הפרטים. פעולה זו תבצע כל מחזור שעון עבור מערכת ה- GPS

מכונת מצב פלט:

מכונת מצב זו תקבע את הפלט בהתבסס על המשתנה שמכשיר מצב שינוי התצוגה קובע שהוא התצוגה הנוכחית.

מכונת מצב מרחק

מכונת מצב זו מבצעת כל מחזור שעון וקובעת את המרחק הכולל שעבר המשתמש וברגע שתלחץ על כפתור האיפוס, יאפס את המרחק הנוכחי.

מכונת מצב מיקום:

מכשיר מצב זה מחזיר את המיקום הנוכחי של המשתמש, תוך שימוש בקואורדינטות שמודול ה- GPS מחזיר לגבי המשתמש. מכשיר מצב זה תלוי בחיבור האינטרנט של המשתמשים.

שלב 7: מאפשר ליישם את מערכת ה- GPS שלנו

ברגע שיש לנו מודול ה- GPS שלנו ששולח מידע ל- Raspberry 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, radians

# ייבא ספריית 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

geolocator = Nominatim ()

# קבועים למערכת

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

רוחב = 128

HEIGHT = 160 SPEED_HZ = 4000000

# סיכות תצורה של פטל פטל

DC = 24 # A0 במסך TFT RST = 25 # איפוס סיכה במסך TFT SPI_PORT = 0 # יציאת SPI על פטל פאי, SPI0 SPI_DEVICE = 0 # בחירת שפחה ב- pi פטל, CE0

# צור אובייקט תצוגת LCD TFT

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

# אתחל את התצוגה

disp.begin ()

# הרקע יוגדר לירוק

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

# נקה מסך ללבן ותצג

#disp.clear ((255, 255, 255)) צייר = disp.draw () #צייר.מלבן ((0, 10, 127, 150), מתאר = (255, 0, 0), מילוי = (0, 0, 255)) #disp.display ()

# משתני מיקום מהירות, קו רוחב, קו אורך

#currentS = "מהירות נוכחית:" # מחרוזת מהירות #totalDis = "מרחק כולל:" # מחרוזת מרחק #currentLoc = "מיקום נוכחי:" # מחרוזת מיקום

# מרחק קואורדינטות x ו- y

distX = 10 distY = 20

pointsList =

# קואורדינטות מהירות x ו- y

מהירות X = 10 מהירות Y = 20

# מיקום x ו- y coordiantes

locX = 10 locY = 20

# הופך מ/ש 'לקמ ש

conversionVal = 2.24

# פונקציית עדכון מהירות, מחזירה מחרוזת

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)

החזרה (location.address)

# פונקציית עדכון Latitude, מחזירה ערך צף

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

# פונקציית עדכון אורך, מחזירה מחרוזת

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

# פונקציית המרחק מחזירה TOTAL מרחק נסיעה

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

# אפס מרחק כולל

def resDistance ():

global totalDistance totalDistance = 0

# פונקציה המשמשת לאיתור מרחק בין שני קואורדינטות

# משתמש בנוסחה של האברזין כדי למצוא. # נקודות קלט הן זוג

def coorDistance (נקודה 1, נקודה 2):

# רדיוס משוער של כדור הארץ בקילומטרים כדור הארץ רדיוס = 6373.0

lat1 = נקודה 1 [0]

lon1 = נקודה 1 [1]

lat2 = נקודה 2 [0]

lon2 = נקודה 2 [1]

distanceLon = lon2 - lon1

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 dispDistance ():

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

# פונקציית מיקום התצוגה על המסך, דורשת אינטרנט כדי לעבוד

def dispLocation ():

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

# שימוש במילון לחיקוי הצהרות מתג

dispOptions = {

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

# פונקציית פלט מסך

פלט def ():

# שימוש במשתנה גלובלי לתצוגה DisplayIndex global displayIndex # ניקוי מסך והחלת רקע disp.clear ((255, 255, 255)) draw.rectangle ((0, 10, 127, 150), מתאר = (255, 0, 0), מילוי = (255, 0, 0))

# פונקציית השיחות בהתאם לערך displayIndex

dispOptions [displayIndex] ()

# יימחק אם שיטה אחרת עובדת

משתנה מרחק מקום על המסך

#draw.text ((distX, distY), str (distFunc ()), font = ImageFont.load_default ()) #משתנה מהירות מקום במסך #draw.text ((speedX, speedY), speedFunc (), font = ImageFont.load_default ()) # עדכוני תצוגה לתצוגת המסך ()

displayButton = פין BCM 18 # על פטל פטל

resetButton = 23 # סיכה BCM על פטל פאי

buttonPress = False

def checkDisplay ():

כפתור גלובלי לחץ גלובלי displayIndex אם (bGPIO.input (displayButton) ולא buttonPress): displayIndex += 1 buttonPress = True if (displayIndex == 2): displayIndex = 0 elif (bGPIO.input (displayButton) ו- buttonPress): הדפס (" עדיין נלחץ ") else: buttonPress = False

# התקנת GPS

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

timerPeriod =.5

# ערך אינדקס לתצוגה displayIndex = 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 () פלט () checkDisplay () אם (bGPIO.input (resetButton)): resDistance () אחר: פלט () checkDisplay () אם (bGPIO.input (resetButton)): resDistance () הדפסה ('GPS עדיין לא מחובר') time.sleep (.1) time.sleep (.8) למעט מקלדת הפרעה: gps_socket.close () הדפס (' / n נקבע על ידי המשתמש ctrl+c ')

הקוד שלמעלה הוא רק דוגמה אחת לאופן שבו ניתן לקודד את המערכת שלנו והטמנתי סרטון כיצד המערכת פועלת.