Afficher les données de localisation envoyées par le GPS NEO-M6 en utilisant la carte ESP32

Fils de connexion

Les fils de connexion sont des fils conducteurs utilisés pour connecter des composants électroniques, tels que des capteurs, des boutons, des LEDs, des moteurs, des afficheurs, des cartes Arduino, des Raspberry Pi, des shields et d’autres dispositifs électroniques.

Plaque d’essai

Une plaque d’essai (aussi appelée breadboard en anglais) est un outil couramment utilisé en électronique pour le prototypage de circuits électroniques. C’est une plaque en plastique ou en métal qui comporte de nombreux trous pour insérer des composants électroniques, tels que des résistances, des condensateurs, des transistors, des LEDs, des boutons, des fils de connexion et d’autres composants.

Les plaques d’essai sont conçues pour faciliter la connexion des composants électroniques en utilisant des fils de connexion courts et des broches de connexion qui sont généralement réparties en groupes de cinq. Les plaques d’essai ont généralement deux rangées de trous, avec chaque rangée étant connectée électriquement dans une configuration parallèle, ce qui permet de connecter facilement des composants en utilisant des fils de connexion sans avoir besoin de soudures.

Les plaques d’essai sont largement utilisées pour les projets de prototypage électronique car elles permettent aux utilisateurs de tester rapidement et facilement des circuits sans avoir à souder les composants sur une carte de circuit imprimé (PCB). Les plaques d’essai sont également réutilisables et peuvent être facilement modifiées en ajoutant ou en supprimant des composants pour tester différentes configurations de circuit.

Programme Micropython

L’utilisation de Micropython avec l’ESP32 permet aux développeurs de créer des projets IoT avec une syntaxe Python familière, ce qui facilite la programmation pour les personnes qui ont une expérience en Python. En outre, Micropython offre un accès facile aux fonctionnalités de bas niveau de l’ESP32 telles que les GPIO (General Purpose Input/Output) pour contrôler les entrées/sorties, les interfaces SPI, I2C et UART pour la communication avec d’autres périphériques, et les fonctions de gestion de l’énergie pour optimiser la durée de vie de la batterie dans les applications autonomes.

Voici le programme Micropython qui permet de lire les données de localisation envoyés par le GPS NEO-M6 et les afficher sur l’afficheur SSD1306.

Les types de données de localisation sont :

Latitude et longitude : Ces données indiquent la position géographique exacte de l’appareil en utilisant les coordonnées de latitude et longitude.
Altitude : Cette donnée indique l’altitude de l’appareil par rapport au niveau de la mer.
Heure : Le GPS NEO-M6 peut fournir l’heure exacte à partir des signaux GPS reçus, ce qui peut être utile pour synchroniser les horloges de différents appareils.
Nombre de satellites : Le récepteur GPS peut également fournir des informations sur le nombre de satellites GPS auxquels il est connecté, ce qui peut aider à évaluer la précision des données de localisation fournies.

Il faut importer ces deux bibliothèques : ssd1306 et micropyGPS

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

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

Afficher les données de localisation envoyées par le GPS NEO-M6 en utilisant la carte ESP32

Qu’est ce que le GPS ?

But de ce tutoriel

Montage

Les composants nécessaires

Programme Micropython

Vous pouvez voir aussi

Afficher les données de localisation envoyées par le GPS NEO-M6 en utilisant la carte ESP32

Construction d’un robot commandé par la carte ESP32 qui détecte et évite les obstacles

0 commentaire

Laisser un commentaire

Annuler la réponse

Tutoriels récents

Réalisation d’un robot suiveur de ligne avec Micro:bit

Utilisation de la caméra OV7670 avec la carte Arduino UNO

Serveur Web de diffusion vidéo avec ESP32-CAM

Connecter Arduino UNO au réseau Wifi en utilisant le module ESP8266

Tutos les plus vus

Système d’arrosage automatique avec Arduino

Allumer une LED par Arduino

Réalisation d’une barrière de parking automatique avec Arduino

Utilisation du capteur Ultrason HC-SR04 avec l’Arduino

Tutos les plus commentés

Commander un moteur par Arduino et le module L298N

Système de mesure du niveau d’eau contrôlé par Arduino

Système d’arrosage automatique avec Arduino

Commander un moteur à courant continu avec Micro:bit