Système GPS : 7 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

Créateur du projet: Carlos Gomez

Avoir un système de navigation fiable est primordial pour quiconque essaie de voyager et d'explorer le monde.

L'aspect le plus important qui permet au système de navigation de fonctionner est la capacité GPS intégrée à l'intérieur du système. Le système GPS permet à quiconque de suivre son emplacement et sa vitesse afin d'afficher des informations précises sur l'utilisateur et de donner à l'utilisateur une représentation précise de l'endroit où il se trouve et à quelle distance il se trouve.

Le Global Positioning System (GPS) est un réseau de satellites en orbite autour de la Terre à une altitude d'environ 20 000 km. Quiconque possède un appareil GPS peut recevoir les signaux radio diffusés par les satellites et peut les utiliser de la manière dont il a besoin. Où que vous soyez sur la planète, au moins quatre GPS devraient être à votre disposition à tout moment. En utilisant une méthode appelée trilatération 3-D, un appareil GPS est capable d'utiliser trois satellites afin de déterminer l'emplacement de l'appareil sur la Terre. Chacun des trois satellites envoie un signal à l'appareil et l'appareil détermine sa distance par rapport au satellite. En utilisant chacun des trois calculs de distance, l'appareil est maintenant capable de localiser son emplacement sur la Terre et il le renvoie à l'utilisateur.

Le système GPS que nous allons créer sera capable de suivre les emplacements de l'utilisateur en obtenant les coordonnées de l'utilisateur sur la Terre et en effectuant des calculs afin de renvoyer la vitesse, l'emplacement et la distance parcourue de l'utilisateur.

Étape 1: Mise en route

Afin de démarrer ce projet, nous devrons d'abord rassembler tous les bons matériaux

1: Raspberry Pi Zero W

2: récepteur GPS

3: 1.8 TFT 128x160 LCD SPI Écran

4: ~ 11 fils

5: 2 boutons

6: 2x résistances 1k et 2x 10k pour les boutons déroulants

7: Planche à pain

Ce projet utilisera les broches GPIO du Raspberry Pi et en tant que tel, nous devrons tout connecter avec une planche à pain afin de développer notre projet. Il est également supposé que la soudure de toutes les broches est terminée avant de continuer et de connecter toutes nos pièces.

Étape 2: connectez le module GPS au Raspberry Pi

Pour utiliser notre système GPS, vous devrez connecter les broches Tx et Rx du module GPS aux broches GPIO 14 et 15 du Raspberry Pi. La broche Tx du récepteur GPS va à la broche Rx du Pi et la broche Rx du récepteur GPS va à la broche Tx du Raspberry pi.

Le récepteur GPS montré dans les images nécessite 3,3 V pour être utilisé et vous pouvez connecter les broches 3,3 V à la tension correcte, tout en connectant la broche de terre à la terre.

Étape 3: Recevoir les données du module récepteur GPS

Afin de recevoir des données du récepteur GPS vers le Raspberry Pi, nous devons autoriser les prises correctes à lire à partir des ports UART. La lecture des données brutes nous obligerait à créer notre propre bibliothèque d'analyse, mais dans ce scénario, nous pouvons tirer parti d'un démon GPS qui s'exécute en arrière-plan pour aider à analyser les données et les transmettre au Raspberry Pi

Pour ce faire, nous pouvons ouvrir un terminal sur le Raspberry Pi et exécuter le code:

sudo apt-get mise à jour

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

Cela devrait prendre en charge le téléchargement pour nous.

Une fois terminé, nous devons désactiver le service système gpsd en exécutant les commandes suivantes:

sudo systemctl stop gpsd.socket

sudo systemctl désactiver gpsd.socket

Si vous souhaitez un jour activer le service système gpsd par défaut, vous pouvez exécuter les commandes suivantes pour le restaurer:

sudo systemctl activer gpsd.socket

sudo systemctl démarrer gpsd.socket

Maintenant, nous devons démarrer le démon gpsd et le pointer vers les ports UART en entrant

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

Nous pouvons maintenant exécuter la commande ci-dessous et voir toutes les données flotter !

cgps -s

Étape 4: connectez l'écran au Raspberry Pi

Une fois que notre récepteur GPS est opérationnel et fonctionne avec le Raspberry Pi, nous pouvons ensuite connecter l'écran au Raspberry Pi. Nous utiliserons 5 fils pour connecter notre écran LCD au Raspberry Pi et 4 autres broches pour connecter l'alimentation principale et la LED sur l'écran.

J'ai inclus une photo de l'écran TFT que j'utilise, mais cela devrait fonctionner avec des écrans de taille et de construction similaires.

Connectez LED- et GND à la terre et connectez LED+ et VCC à 3,3V.

Connectez la broche RESET de l'écran à la broche 25 de la carte Pi.

Connectez A0 à la broche 24 de la carte Pi.

Connectez la broche SDA à la broche MOSI sur la carte Pi.

Connectez la broche SCK de l'écran LCD à la carte Pi.

Connectez la broche CS à la broche 8 sur la carte Pi.

Étape 5: Configurer l'affichage pour qu'il fonctionne avec Raspberry Pi

Pour configurer l'affichage, nous devons utiliser la bibliothèque ST7735 trouvée dans ce référentiel:

Bibliothèque d'écrans Python ST7735

Une fois cette bibliothèque d'affichage installée sur notre système Raspberry Pi, nous pouvons maintenant procéder à la configuration d'un exemple de fichier pour confirmer que notre câblage précédent fonctionne correctement.

Créez un fichier intitulé example.py et insérez-y le texte suivant avec un exemple d'image de votre choix dans le même dossier

importer ST7735 en tant que TFTimporter Adafruit_GPIO en tant que GPIO importer Adafruit_GPIO. SPI en tant que SPI

LARGEUR = 128

HAUTEUR = 160 VITESSE_HZ = 4000000

# Configuration du Raspberry Pi.

# Ce sont les broches nécessaires pour connecter l'écran LCD au Raspberry Pi

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

# Créer une classe d'affichage LCD TFT.

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

# Initialiser l'affichage.

disp.begin() disp.reset()

# Charger une image.

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

# Redimensionnez l'image et faites-la pivoter pour qu'elle corresponde à l'affichage.

image = image.rotate(270).resize((LARGEUR, HAUTEUR))

# Imprimera sur le terminal que notre programme dessine notre image à l'écran

print('Image de dessin')

# Cette fonction affichera notre image à l'écran

affichage.affichage(image)

Ce fichier configurera la configuration Raspberry Pi pour l'écran LCD et la bibliothèque convertira notre image dans le dossier et l'affichera à l'écran.

Étape 6: Configurez les machines d'état pour afficher les informations GPS à l'écran

Nous utiliserons 5 machines à états différentes, tout en implémentant notre diagramme de tâches pour configurer notre système GPS.

Affichage Changer la machine d'état:

Cette machine d'état contrôlera lequel afficher en fonction de notre entrée de bouton. Pour ce faire, il modifie une variable qui permet à python de tirer parti de la frappe de canard et d'appeler la fonction correcte à afficher en fonction de la fonction appelée.

Machine d'état de vitesse:

Cette machine d'état exécutera la vitesse actuelle en fonction de l'emplacement des individus. Cela exécutera chaque cycle d'horloge pour le système GPS

Machine d'état de sortie:

Cette machine d'état déterminera la sortie en fonction de la variable que la machine d'état de changement d'affichage détermine comme étant l'affichage actuel.

Machine d'état de distance

Cette machine d'état exécute chaque cycle d'horloge et détermine la distance totale parcourue par l'utilisateur et une fois que le bouton de réinitialisation est enfoncé, réinitialise la distance actuelle parcourue.

Machine d'état de localisation:

Cette machine d'état renvoie l'emplacement actuel de l'utilisateur, en utilisant les coordonnées que le module GPS renvoie sur l'utilisateur. Cette machine d'état dépend de la connexion Internet de l'utilisateur.

Étape 7: Implémentons notre système GPS

Une fois que notre module GPS envoie des informations à notre Raspberry Pi et que notre écran LCD affiche des informations dessus, nous pouvons alors commencer à programmer notre système GPS. Je vais utiliser les machines à états finis de l'étape précédente afin de coder notre système GPS

## Fichier principal pour le système de navigation # # # #

# Bibliothèques pour dessiner des images

depuis l'import PIL Image depuis l'import PIL ImageDraw depuis l'import PIL ImageFont

# Bibliothèque pour contrôleur ST7737

importer ST7735 en tant que TFT

# Bibliothèque pour GPIO pour Raspberry Pi

importer Adafruit_GPIO en tant que GPIO importer Adafruit_GPIO. SPI en tant que SPI

# Bibliothèque pour GPS

#importer gpsd depuis gps3 importer gps3

# Bibliothèque pour le temps

heure d'importation

# Bibliothèque pour trouver la distance entre deux points

des maths importer sin, cos, sqrt, atan2, radians

# Importer la bibliothèque Rpi pour utiliser les boutons pour changer de menu et réinitialiser

# importer RPi. GPIO en tant que bGPIO

# Broches de configuration pour les boutons

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)

# importer la bibliothèque geopy pour le géocodage

# # Un accès Internet est nécessaire pour que cela fonctionne

de geopy.geocodeurs importer Nominatim

géolocalisateur = Nominatim()

# Constantes pour le système

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

LARGEUR = 128

HAUTEUR = 160 VITESSE_HZ = 4000000

# Broches de configuration Raspberry Pi

DC = 24 # A0 sur l'écran TFT RST = 25 # Pin de réinitialisation sur l'écran TFT SPI_PORT = 0 # Port SPI sur raspberry pi, SPI0 SPI_DEVICE = 0 # Sélection esclave sur rapsberry pi, CE0

# Créer un objet d'affichage LCD TFT

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

# Initialiser l'affichage

disp.begin()

# L'arrière-plan sera défini sur vert

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

# Effacer l'écran en blanc et afficher

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

# Variables de placement Vitesse, Latitude, Longitude

#currentS = "Vitesse actuelle: " # Chaîne de vitesse #totalDis = "Distance totale: " # Chaîne de distance #currentLoc = "Emplacement actuel: " # Chaîne d'emplacement

# Distance x et coordonnées y

distX = 10 distY = 20

liste de points =

# Coordonnées de vitesse x et y

vitesseX = 10 vitesseY = 20

# Coordonnées d'emplacement x et y

locX = 10 locY = 20

# Convertit de m/s en mph

ConversionVal = 2,24

# Fonction de mise à jour rapide, renvoie la chaîne

VarVitesse = 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)

retour (lieu.adresse)

# Fonction de mise à jour de la latitude, renvoie la valeur flottante

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

# Fonction de mise à jour de la longitude, renvoie la chaîne

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

# La fonction de distance renvoie la distance TOTALE parcourue

Distance totale = 0

def distFunc():

globalDistance totale newLat = latFunc() newLon = lonFunc() if(newLat == 0 ou 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

# Réinitialise la distance totale

def resDistance():

total globalDistance totalDistance = 0

# Fonction utilisée pour trouver la distance entre deux coordonnées

# utilise la formule de Haversine pour trouver. # Les points d'entrée sont un tuple

def coorDistance(point1, point2):

# Rayon approximatif de la Terre en kilomètres EarthRadius = 6373.0

lat1 = point1[0]

lon1 = point1[1]

lat2 = point2[0]

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

# Convertir des km en Miles

distance = (rayon terrestre * c) * 0,62137

if(distance <= 0.01): return 0.00 else: return round(distance, 3)

# Fonction pour afficher la vitesse à l'écran

def vitesse d'affichage ():

global SpeedVar # Place la distance sur la variable à l'écran draw.text((speedX, speedY), str(SpeedVar), font=ImageFont.truetype("Lato-Medium.ttf", 72))

# Fonction pour afficher la distance à l'écran

def dispDistance():

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

# Fonction ti afficher l'emplacement à l'écran, nécessite Internet pour fonctionner

def dispLocation():

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

# Utilisation d'un dictionnaire pour imiter les instructions de commutation

DispOptions = {

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

# Fonction de sortie d'écran

def sortie():

# Utilisation de la variable globale pour displayIndex global displayIndex # Effacement de l'écran et application de l'arrière-plan disp.clear((255, 255, 255)) draw.rectangle((0, 10, 127, 150), outline=(255, 0, 0), remplissage=(255, 0, 0))

# Appelle la fonction en fonction de la valeur displayIndex

dispOptions[displayIndex]()

# S'effacera si une autre méthode fonctionne

# place la variable de distance à l'écran

#draw.text((distX, distY), str(distFunc()), font=ImageFont.load_default()) # place la variable de vitesse sur l'écran #draw.text((speedX, speedY), speedFunc(), font=ImageFont.load_default()) # Afficher les mises à jour à l'écran disp.display()

displayButton = 18 # BCM Pin sur raspberry pi

resetButton = 23 # BCM Pin sur raspberry pi

Appuyez sur le bouton = Faux

def checkDisplay():

global buttonPress global displayIndex if(bGPIO.input(displayButton) et non buttonPress): displayIndex += 1 buttonPress = True if(displayIndex == 2): displayIndex = 0 elif(bGPIO.input(displayButton) et buttonPress): print (" Toujours enfoncé") sinon: buttonPress = False

# Configurer le GPS

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

timerPeriod =.5

# Valeur d'index pour 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 pas encore connecté') time.sleep(.1) time.sleep(.8) sauf KeyboardInterrupt: gps_socket.close() print(' \nTerminé par l'utilisateur ctrl+c')

Le code ci-dessus n'est qu'un exemple sur la façon de coder notre système et j'ai intégré une vidéo sur le fonctionnement de ce système.