Dans cet article, il s’agit toujours de réaliser un data logger GPS pour aviation.
Outre l’enregistrement sur carte SD des traces GPS, il dispose d’un écran LCD de 16 caractères sue chacune de ces 2 lignes. Cet écran affiche la date et l’heure GPS ainsi que successivement : position, puis vitesse et altitude et enfin direction par rapport au nord géographique et altitude, puis retour à la position comme indiqué ci-dessous.
Il enregistre également les données sur la carte SD dans un fichier CSV (données séparées par des virgules) dont la 1ère ligne contient les nom des colonnes.

Dans les précédents articles, nous avons utilisé pour cela un Arduino, et, malgré que nous n’ayons pas pu y mettre toutes les options désirées, nous avons atteint les limites de capacité mémoire de ces types de cartes.

Il va falloir exploiter une carte ayant plus de ressources.
Pour cela, actuellement, nous avons encore plusieurs possibilités, explorons les avantages et inconvénients de ces cartes.

Carte	Type	Communauté	Langage de programmation	Coût	Caractéristiques
Raspberry Pico	Micro-contrôleur	Peu active produit récent	Micro-Python C (Arduino)	Env 5 €	CPU : 133 MHz SRAM : 264KB Flash : 2MB
PyBoard	Micro-contrôleur	Active documentation et exemples faciles à trouver	Micro-Python	Env 14 €	CPU : 168 MHz SRAM : 192KB Flash : 1MB
ESP32	Micro-contrôleur	Produit assez récent Communauté encore peu active Adaptation de code à réaliser	Micro-Python C (Arduino)	A partir de 15 €	CPU : 240 MHz SRAM : 512KB Flash : 2MB
Raspberry Pi	Nano Ordinateur	Très active documentation et exemples facilement accessibles	C, C++, Pascal, Python, Shell, SQL, Php, Html, CSS, etc...	de 30 € à 80 €	CPU : >= 700 Mhz RAM de 512Mb à 8192 Mb SD Card jusque 128Gb

Les cartes Pico, PyBoard et ESP32 sont des microcontrôleurs comme les Arduino, ce ne sont pas des nano-ordinateurs. Donc pas de système d’exploitation à installer ou à démarrer pour celles-ci, contrairement aux Raspberry.

Un data logger étant un appareil qu’on va allumer et éteindre fréquemment en coupant le courant brutalement, il est préférable de ne pas avoir à gérer un système d’exploitation.

Après avoir essayer personnellement les Pico et ESP32, j’ai choisis de sélectionner un ESP32.
Il existe plusieurs modèles d’ESP 32 avec plus ou moins de SRAM, de mémoire Flash. Certains ont même le wifi intégré ! Voir une connectivité Lora ou un GPS intégré !
J’ai choisis le Wroom pour ses caractéristiques techniques, intégrant le Wifi et préférant mettre le GPS en périphériques externe.
On peut écrire des fichiers dans la mémoire Flash de l’ESP32. Mais sa taille bien qu’importante (2MB) reste limitée. Aussi je préfère stocker les logs GPS sur une carte SD.

Un gros avantage est que la grand majorité des périphériques qui existe pour Arduino, sont compatibles avec chacune de ces cartes. La seule difficulté consiste à trouver une bibliothèque qui sache piloter le périphérique.
Sinon, on peut aussi adapter une bibliothèque existante pour la rendre compatible avec l’ESP32.

On utilisera donc

Le même lecteur de carte SD que sur l’Arduino (env 10 €)	Le même GPS que sur l’Arduino
Le même écran HD44780 et son contrôleur I2C :	Le même relais que sur les Arduinos

Important
Comme les Arduinos, les ESP32 ne reconnaissent que les cartes formatées en FAT32 ou en FAT16 : Evitez le format NTFS ! Je conseille le format FAT32 puisque la version FAT16 est limitée à 4Go et qu’aujourd’hui, la plus petite carte qu’on puisse trouver dans le commerce fait au moins 8Go.

Câblage
La carte SD nécessite, en plus de son alimentation, d’être connectée à 4 PINS de l’ESP32. Ca commence à faire beaucoup avec l’Ecran LCD et le GPS. Du coup, comme le GPS sait nous fournir la date et l’heure (UTC), j’ai choisis de me débarrasser de l’horloge RTC dans ce montage.

Langage de programmation
On peut exploiter le logiciel Arduino et programmer en C pour l’ESP32.
J’ai choisis, d’essayer pour la première fois Micro-Python : ayant une plus grande expérience de Python que du C.

Voici le tableau de câblage complet :

Connexion de	Connexion à	Connexion de	Connexion à
Broches LCD	Broches du Ctrl i2c	SDCard GND	GND (Alim)
Ctrl i2c GND	GND (Alim)	SDCard VCC	+5V (alim)
Ctrl i2c VCC	+5V (alim)	SDCard MISO	ESP32 - G19 (SPI)
Ctrl i2c SDA	ESP32 - G21 (SDA1)	SDCard MOSI	ESP32 - G23 (SPI)
Ctrl i2c SDC	ESP32 - G22 (SDC1)	SDCard SCK	ESP32 - G18 (SPI)
Relais GND	GND (Alim)	SDCard CS	ESP32 - G05
Relais VCC	+5V (alim)	Relais Signal	ESP32 - G12
ESP32 - V5	+5V (alim)	ESP32 - GND	GND (Alim)
GPS VCC	+5V (Alim)	GPS GND	GND (Alim)
GPS TX	GPS32 - G16 (RX2)	GPS RX	Inutilisé

Schéma de câblage complet :
Cliquez dessus pour télécharger la version pdf

Environnement logiciel :
Les micro contrôleurs supportant le micro-python, supportent aussi naturellement le C.
Ils ne sont cependant programmables que dans un langage à la fois : soit en C, soit en Micro Python.
Et ils sont vendus prêts à être programmés en C.
Pour passer au micro-python (et pour revenir au C), il faut mettre à jour le firmware de la carte.
Il existe différente méthodes pour cela, je n’en présenterais qu’une seule : la plus simple.

Comme on programmera en micro-python, ils nous faut un logiciel pour cela. Il en existe plusieurs, mais l’un d’entre eux a particulièrement retenu mon attention ; il s’agit de Thonny.

Thonny est un IDE python et micro python gratuit, multi-os et libre particulièrement accessible y compris aux grand débutants.
Il possède plusieurs outils très intéressant pour les débutants telle une interface graphique avec des menus permettant de :

• Mettre à jour le firmware d’un micro contrôleur vers micro-python
• Rechercher – installer des bibliothèques (comme le logiciel Arduino)
• Accéder directement à la mémoire flash de la carte, comme si c’était une clé USB

Donc la 1ère chose à faire après avoir brancher votre carte ESP32 sur un port USB de votre PC.
Normalement , Windows 10 détectera un nouveau périphérique et installera le pilote (qui est un émulateur de port série sur USB de type CP2102.
Puis il faut télécharger Thonny et l’installer :

 

Une fois fait, un peu de paramétrage est nécessaire : aller dans le menu Outils – Options »
Vous devrez sélectionner l’onglet Interpréteur
Puis choisir Interpréteur MicroPython ESP32
Et cliquer sur Installer ou mettre à jour le firmware

Contenu des fichiers internes à l’ESP32 :
Votre ESP32 va alors recevoir différents fichiers via le port USB.
Ces fichiers seront dans la mémoire Flash (taille 1 à 2 MB) visible comme une clé USB uniquement lorsque l’ESP n’est pas en train d’exécuter un programme.
Parmis ces fichiers se trouvent :

• boot.py : un script qui est lancé au démarrage de l’ESP, on a rarement à y toucher
• main.py : le script du programme dui sera exécuter par l’ESP après l’exécution de boot.py
• différents fichiers nécessaires au fonctionnement de main.py (si nécessaire)

 

L’idée est de se créer un dossier sur on PC avec les fichiers de programmes qu’on développe.
Les déposer tous sur l’ESP32, sauf main.py
Ainsi, en cours de mises au point, Thonny fera exécuter le main.py présent sur le PC par l’ESP32
Puis, une fois le programme main.py bien au point, le déposer dans la mémoire flash de l’ESP32. A partir de là, il devient autonome et n’a plus besoin ni du PC ni de Thonny pour fonctionner.

Par contre, j’ai remarqué que si main.py exige des bibliothèques, elles doivent être sur l’ESP32

Thonny montre dans la partie gauche un explorateur de fichier windows et juste en dessous, un explorateur de fichier de l’ESP32. Il est facile de transférer un fichier dans un sens ou dans l’autre par un clic droit de la souris dessus.Les boutons de lecture et de stop sont parfaitement visibles et on comprend immédiatement qu’ils servent à lancer et à stopper un script Un bas à droite se trouve une invite de commandes python, ce qui permet d’y mettre des instructions toutes simples pour les tester

Le code
On a donc à gérer :

• Un écran LCD pour l’affichage
• Un lecteur de carte SD pour stocker les données
• Un GPS pour obtenir les données
• Un relais à déclencher selon certaines conditions

L’écran LCD est un classique HD44780A : 16 caractères sur 2 lignes (mais j’aurai du prendre la version 4 lignes)
compatible avec les Arduino, Raspberry, PyBoard, Pico et ESP32.
Une seule difficulté : si la bibliothèque de contrôle de l’écran se trouve partout sur le Web en C (Arduino) et en Python (Raspberry). Je ne l’ai pas trouvé en micro python. J’ai du partir de la version Python et l’adapter.

Le lecteur de carte SD est un classique aussi. C’est la verion SPI de chez AZ-Delivery compatible Arduino/Raspberry/Micro-Python. Et là, en cherchant longtemps, j’ai fini par trouver un dépôt github avec le code de la bibliothèque correspondante.

Le GPS est un classique NEO-7M (vous pouvez prendre le 6M aussi ou le 8M). Là, c’est très simple : il s’agit juste d’un équipement à connecter sur le port série. Il existe des bibliothèques en Python qui déchiffres les données issues du GPS. Mais comme c’est vraiment simple, j’ai choisis de le faire moi-même « à l’arrache »

Le relais est un des plus classiques des Arduinos et Raspberry, aucune bibliothèque n’est nécessaire. Il suffit d’activer ou non un port du GPIO de l’ESP32.

Le code des bibliothèques
Je vous conseille de créer un dossier sur votre PC et de mettre ces scripts ensemble dans ce dossier.
Ensuite ils seront à déposer dans la mémoire flash grâce au logiciel Thonny.

Nom du Fichier	Description	Téléchargement
sdcard.py	Bibliothèque de contrôle du lecteur de carte SD	Télécharger
lcd.py	Bibliothèque de contrôle de l'écran LCD	Télécharger
hd44780u.py	Bibliothèque bas niveau utilisée par lcd.py	Télécharger

Le programme principal (main.py)

J’ai réalisé ce code « à l’arrache » : pas de programmation objet, c’est assez simple, utilisation de variables globales (je sais c’est mal mais c’est compréhensible par tous y compris les grand débutants)
Il se décompose en 3 parties :
– la première est une déclaration / initialisation de variables.
– la deuxième consiste à vérifier certaines choses (détection de l’écran LCD, détection du lecteur de carte, carte SD présente au bon format, initialisation du port série pour la connexion au GPS)
– la 3ième est une boucle sans fin du traitement des données reçues et transmises par le GPS. Donc de l’affichage sur l’écran LCD et de l’écriture des données sur la carte SD, activation du relais selon certaines circonstances.

Si la 2ième étape se passe mal , un message explicite s’affiche sur l’écran LCD et le traitement s’arrête.

Problèmatiques et solutions retenues
– Je souhaite récupérer , afficher et écrire les données suivantes provenant du GPS :
– Date et heure
– Latitude, Longitude
– Vitesse, route (direction par rapport au nord)
– Altitude
– Nombre de satellites détectés, qualité du signal (écriture sur la carte SD seulement).

Date et heure
L’ESP 32 ne contient pas d’horloge interne, il ne connait rien de la date ni de l’heure qu’il est.
Mais un GPS fournit la date et l’heure de chaque position.
Cette date/heure est en UTC (temps universel), et pas en heure locale.
N’ayant pas envie de déterminer le changement d’heure à appliquer en fonction de la date, j’ai choisis la laisser en UTC. Il est donc normal que cela affiche 8h51 alors qu’il est en France 9h51 ou 10h51 selon le décalage.

L’heure est fournie par le GPS avec le format suivant :HHMMSS.00 (Ex : 095111.00). Je vais me débarrasser de la partie « .00 »

La date est fournie par le GPS au format DDMMAA (Ex : 311219 pour 31/12/2019). Donc pour y mettre siècle, il me faut trouver l’année et ajouter 20 devant (jamais le GPS ne donnera de date antérieure à aujourd’hui et au 22 ième siècle, on sera passer à autre chose).

Ca y est j’ai donc une heure et une date utilisable. Mais problème : je veux afficher beaucoup de choses sur l’écran LCD. Je dois donc me contenter d’une seule ligne de l’écran (donc de 16 caractères). Je n’afficherai donc qu’une date au format DD/MM et une heure au format MR/MN sur une seule ligne. Pour que l’utilisateur comprenne de quoi il s’agit j’ai ajouter « UTC » à la fin ce qui donne par exemple : « 17/11 10:23 UTC » et cela tient sur 16 caractères.

Description des données fournies par les GPS
Tous les GPS fournissent le même type de données, formatées de la même manière.
Il s’agit de données au format texte, facilement compréhensible par l’humain.
Chaque trame dite « NMEA » a une strcuture bien précise et documentée ici http://aprs.gids.nl/nmea/

Vitesse ,routes et altitudes fournies par le GPS
Vous pensez que les GPS sont fiables à quel point ?

Vous allez être déçus ! Si vous consulter les trames GPS en sortie, vous verrez que d’après eux, nous ne sommes JAMAIS immobiles : Bien installés dans votre jardin devant un café, avec 8 satellites en réception, il affiche des vitesses entre 0,1 et 0,5 km/k après des pointes à 3 km/h alors que vous n’avez pas bougé d’un iota !
J’ai donc choisi que si la vitesse est inférieure à 3km/h, je la considère comme égale à 0 km/h.

Pour la route, ce n’est pas mieux : la direction est fournie au 10ième de degré prêt, trouvez moins un seul pilote ou automatisme capable de tenir une route ne serait-ce qu’au degré prêt. Ca n’existe pas ! et à cause de l’imprécision, la route ne cesse de bouger. Donc j’ai choisis d’arrondir au degré prêt.

Pour l’altitude : idem, l’a précision est de l’ordre de 10m mais le GPS donne une précision à 10 cm prêt donc ça ne cesse de bouger et cela n’a aucun sens. Donc j’ai choisis d’arrondir au mettre prêt.

Positions fournies par le GPS
Idem, pour la latitude et la longitude qui ne cessent de bouger. Il faut dire que le format des données est trop précis :
En effet , la longitude est donnée avec un champ pour le sens (N ou S) et un champs pour la valeur absolue dans un format curieux (Ex : 4910.235667) et la partie décimale ne cesse de bouger.
Qu’est-ce donc que ce format ?
En fait c’est très étrange : 4910.235667 correspond à 49 degrés , 10 minutes et 235667 millionièmes de minutes.

Pour la longitude ça donne E ou W pour le sens et par exemple 17856.589654 (178 degrés et 56,589654 minutes)

En ajoutant le sens (N/S/E/W) à la latitude/longitude, on arrive à :
12 caractères pour la latitude (Ex : N4910.235667)
et 13 caractères pour la longitude (Ex : E12756.589854)

Impossible de mettre tout cela sur une sule ligne de l’écran LCD : je ne dispose que de 16 caractères en tout

J’ai donc choisis de ne pas mettre le séparateur décimal (le .) et de ne prendre que 5 décimales

Cela donne N491023 soit max 7 caractères pour la latitude
Un espace de séparation
et max 8 caractères pour la longitudes ( Ex : E1275658)

E effet, pour rappel, la latitude varie en valeur absolue entre 0° et 90 ° tandis que la longitude varie entre 0° et 180°. Pour uniformiser tout cela, j’ajouterai si nécessaire les zéros devant.

Ex : N011023 pour Nord, 01° et 10,23 minutes et E0025658 pour Est, 2 degrés et 56,58 minutes.

Règles finales d’affichage
Je peux donc afficher sur la 1ère ligne : la date et l’heure UTC (sans les secondes ni l’année)
Il me reste une deuxième ligne seulement.
Elle affichera :
Si la vitesse est < 3 km/h :
– uniquement la position (latitude et longitude)
Sinon :
20 secondes par minute, j’afficherai la position
20 secondes par minute, j’afficherai la vitesse et altitude
20 secondes par minute, j’afficherai la course (route par rapport au nord géographique) et l’altitude.

Remarques :
Passer à 10 secondes ou 15 au lieu de 20 secondes est aisé par une petite modification du programme
Utiliser une autre valeur de 3 km/h comme vitesse pivot est tout aussi aisé
Utiliser un bouton pour basculer d’un type d’affichage à un autre ne serait pas compliqué à mettre en oeuvre.

Problèmatique de l’enregistrement des données sur la carte SD
On pourrait enregistrer chaque trame du GPS. La quantité de données par trame serait de l’ordre de 40 octets par trames. Comme on en reçoit 100 par secondes cela ferait 4000 octets par secondes. Soit 24 ko par minute, 1,44Mo par heure, 34,56Mo par jour, 12,51 Go par an.
Dans le programme j’ai choisis de :
– créer un nouveau fichier de trace à chaque allumage de l’ESP32
– comme il faut nommer le fichier et que je le nomme en me basant sur la date et l’heure de démarrage et que seul, le GPS va me la fournir, je dois d’abord m’assurer que j’ai bien reçu les premières trames contenant la date et l’heure.
– Ne pas enregistrer une ligne par trame mais une ligne CSV structurée comme suis :
date,time,lat,long,speed_kmh,route,nbsat,status,quality
Exemple :
20210811,113522,N491058,E0021685,55,330,08,A,1
20210811,113523,N491090,E0021610,10,200,08,A,1
…….
…….
Dans un prochain article, je proposerai un moyen de transformer ce fichier CSV en fichier kml compatigle googleearth pour visualiser la trace.

Une chose intéressante : même dans une zone de très mauvaise réception où le GPS ne donne ni position, ni vitesse, ni altitude, ni route; la première chose qu’il va essayer de vous fournir ce sont la date et l’heure.
Au démarrage, une fois les vérifications effectuées, j’attends donc d’obtenir la date et l’heure. Je créer un nom de fichier du type SSAAMMJJ_HHMN.CSV et c’est ce fichier qui va contenir la trace du parcours.
Remarque:
L’ESP32 ne disposant pas de date/heure système, quand vous consulterez le fichier de la carte SD dans un explorateur, vous verrez qu’il a été créé le 1er janvier 1970 (ou 2000 selon les cas). Ne vous en préoccupez pas, c’est le nom du fichier qui donnera sa date de création.

Donc le nom du fichier est connu. Alors je fais un nettoyage des anciens fichiers présent sur la carte :
J’ai choisis de ne garder que les fichiers datant de moins d’un an. Comment ? en me basant sur les noms de fichiers pour savoir de quand ils datent.
Remarque
Une variable globale nommée removeall de type booléen, permet de ne supprimer aucun fichier, même très ancien.
Une fois que la boucle principale tourne, j’écris lorsque les secondes fournies par l’heure GPS valent 00,20 et 40, les données sur la carte SD. Ces données sont au format CSV (texte, colonnes séparées par des virgules)et la 1ère ligne contient le nom des colonnes pour s’y retrouver facilement.

Code source
N’oubliez pas de le déposer dans la mémoire flash de l’ESP32 si vous voulez que le programme tourne de manière autonome une fois débranché de votre PC..

Exploitation du fichier de traces GPS
Les logiciels qui savent afficher les traces GPS utilisent principalement 2 type de fichiers :
– les fichiers NMEA (traces brutes du GPS) : pratiques car la dernière ligne du fichier est bien la dernière données attendues (pas d’utilisation de balises ouvrantes et fermantes)
– les fichiers GPX et KML (ou KMZ), qui utilisent un format XML , utilisant des balises : la dernière balise indiquant la fin du fichier.

Il est difficile de créer au fil de l’eau un fichier structuré comme un gpx ou un kml.
En effet, un fichier kml contient le centrage de l’affichage de la carte. Centre qu’on ne peut pas connaitre définitivement tant que le déplacement est toujours en cours.
Et les données NMEA sont trop nombreuses pour l’usage que l’on en a (on ne roule pas à vitesse supersonique).
J’ai donc choisis un format CSV à ma sauce , léger, pratique, mais qui demande à être traité pour pouvoir afficher graphiquement une trace sur Google Earth ou autre logiciel spécialisé.
Pour réaliser cette transformation, j’ai réalisé en python un petit programme qui va générer un fichier kml.

Il fonctionne avec python3. Son usage est simple :
python csv_to_kml.py monfichier.csv
va créer monfichier.kml

Prochaine étape
Mise en place d’une solution permettant de suivre le boitier en temps réel !