Fabriquer un GPS basé sur la carte ESP32 et le module GPS NEO-M6

ESP32 05-12-24

61 0

Plan du Tutoriel :

1- Qu'est ce que le GPS ?

2- Comment il fonctionne le GPS commandé par ESP32 ?

3- Les composants nécessaires du GPS

4- Schéma de câblage du GPS

5- Programmation de la carte ESP32

Qu'est ce que le GPS ?

Le GPS est un système de navigation basé sur un réseau de satellites en orbite autour de la Terre. Ces satellites envoient des signaux qui peuvent être captés par des récepteurs GPS (par exemple, dans les smartphones, les voitures, ou les appareils dédiés).

Comment fonctionne le GPS ?

Satellites :

Le GPS repose sur une constellation d’au moins 24 satellites (aujourd'hui, il y en a généralement plus, pour améliorer la précision).

Ces satellites orbitent à environ 20 000 km d'altitude et sont répartis de manière à couvrir toute la surface de la Terre.

Signal GPS :

Chaque satellite envoie un signal contenant des informations sur son emplacement exact et l’heure précise à laquelle le signal a été envoyé.

Récepteur GPS :

Les appareils équipés de GPS (comme les smartphones ou les navigateurs GPS) captent ces signaux.

En recevant des signaux d'au moins 4 satellites, le récepteur peut calculer :

La position géographique (latitude, longitude).

L'altitude.

L'heure exacte.

Principe de trilatération :

La position est déterminée en mesurant le temps que mettent les signaux des satellites à atteindre le récepteur.

En calculant la distance par rapport à plusieurs satellites, le récepteur peut trianguler sa position.

Applications du GPS

Le GPS est utilisé dans une multitude de domaines, notamment :

Navigation : Guidage pour les voitures, les avions, les bateaux.

Cartographie : Collecte de données géographiques pour créer des cartes.

Localisation : Suivi en temps réel de personnes ou d'objets (livraisons, animaux, véhicules).

Recherche et sauvetage : Localisation des personnes en danger.

Agriculture : Optimisation des cultures grâce à des systèmes de guidage précis.

Sport et loisirs : Suivi des activités (course à pied, randonnée).

Comment il fonctionne le GPS commandé par ESP32 ?

Le système basé sur un ESP32, un module GPS NEO-M6, et un afficheur SSD1306 (OLED) fonctionne en combinant les données GPS pour la localisation avec une interface graphique pour afficher les informations à l'utilisateur.

Fonctionnement général

1- Acquisition des données GPS :

Le module GPS capte les signaux satellites et calcule sa position.

Il transmet ensuite les données via des trames NMEA, comme $GPGGA, $GPRMC, qui contiennent des informations de localisation, vitesse, heure, etc.

2- Traitement des données par l'ESP32 :

L'ESP32 reçoit les trames NMEA via une communication UART.

L'ESP32 peut utiliser ces données pour une application, comme afficher la position sur un écran, les envoyer via Wi-Fi, ou déclencher des actions.

3- Utilisation et transmission des données :

L'ESP32 peut afficher les données GPS sur l'afficheur SSD1306.

Les composants nécessaires du GPS

ESP32 :

Microcontrôleur pour collecter les données GPS, les traiter et les afficher sur l'écran SSD1306.

Module GPS NEO-M6 :

Fournit les données de positionnement via des trames NMEA.

Afficheur SSD1306 (OLED) :

Écran OLED piloté via I2C (ou SPI) pour afficher les informations en temps réel.

Schéma de câblage du GPS

1- ESP32 et Module NEO-M6 :

RX (NEO-M6) connecté au TX (GPIO16) de l'ESP32).

TX (NEO-M6) connecté au RX (GPIO17) de l'ESP32).

Alimentation du module GPS via 3,3V ou 5V de l'ESP32.

2- ESP32 et SSD1306 (I2C) :

SDA (SSD1306) connecté au GPIO dédié SDA (par défaut GPIO 21 sur ESP32).

SCL (SSD1306) connecté au GPIO dédié SCL (par défaut GPIO 22 sur ESP32).

Alimentation du SSD1306 via 3,3V ou 5V (selon le modèle).

Programmation de la carte ESP32

Voici un exemple complet de code en Micropython pour lire et afficher les données GPS sur l'afficheur SSD1306:

On doit importer ses deux bibliothèques : ssd1306.py pour l'afficheur SSD1306 et micropyGPS pour le module GPS NEO-M6.

import time
import machine
from micropyGPS import MicropyGPS
from machine import Pin, I2C
import ssd1306
#import ssd1306
import _thread
import time
i2c = I2C(-1, scl=Pin(22), sda=Pin(21))
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

oled.text('Carte', 0, 0)  # Afficher les deux mots ''
oled.text('ESP32', 0, 10)
oled.show()

def main():
    #♦i2c = machine.I2C(scl=machine.Pin(2), sda=machine.Pin(4))
   # dsp = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

    uart = machine.UART(1, rx=16, tx=17, baudrate=9600, bits=8, parity=None, stop=1, timeout=5000, rxbuf=1024)

    gps = MicropyGPS()

    while True:
      buf = uart.readline()
      if uart.any():
       for char in buf:
         gps.update(chr(char))  # Note the conversion to to chr, UART outputs ints normally

       print('UTC Timestamp:', gps.timestamp)
       print('Date:', gps.date_string('long'))
       print('Latitude:', gps.latitude)
       print('Longitude:', gps.longitude_string())
       print('Horizontal Dilution of Precision:', gps.hdop)
       print('Altitude:', gps.altitude)
       print('Satellites:', gps.satellites_in_use)
       print()

       oled.fill(0)
       y = 0
       dy = 10
       oled.text("{}".format(gps.date_string('s_mdy')), 0, y)
       oled.text("Sat:{}".format(gps.satellites_in_use), 80, y)
       y += dy
       oled.text("{:02d}:{:02d}:{:02.0f}".format(gps.timestamp[0], gps.timestamp[1], gps.timestamp[2]),  0, y)
       y += dy
       oled.text("Lat:{}{:3d}'{:02.4f}".format(gps.latitude[2], gps.latitude[0], gps.latitude[1]),  0, y)
       y += dy
       oled.text("Lon:{}{:3d}'{:02.4f}".format(gps.longitude[2], gps.longitude[0], gps.longitude[1]),  0, y)
       y += dy
       oled.text("Alt:{:0.0f}ft".format(gps.altitude * 1000 / (12*25.4)),  0, y)
       y += dy
       oled.text("HDP:{:0.2f}".format(gps.hdop),  0, y)
       oled.show()

def startGPSthread():
    _thread.start_new_thread(main, ())

if __name__ == "__main__":
  print('...running main, GPS testing')
  main()