Un compteur de vitesse GPS

Dans notre famille, nous avons une voiture ancienne : une Citroën Traction de 1949. C’est un beau morceau d’histoire, mais quand le temps vient de la conduire, elle a un problème : le compteur de vitesse n’affiche pas la bonne vitesse ! Alors oui, on pourrait rouler au feeling, mais on peut faire mieux ! Dans cet article, je vous partage la réalisation d’un petit compteur de vitesse sur batterie. L’objectif est d’avoir un petit écran qui affichera la vitesse mesurée en direct par GPS.

Je vais vous présenter toutes les étapes de la conception et de la réalisation de cet appareil : électronique, modélisation 3D, conception de l’interface et programmation. C’est parti !

L’électronique

Le système fonctionne autour d’un composant qui permet de recevoir le signal des satellites GPS (pour global positioning system) : position, heure, orientation, etc. Avec sa position en temps réel, il est possible d’en déduire la vitesse. C’est ce qu’on va utiliser pour ce compteur. Voilà un premier prototype, ou la valeur est affichée sur un écran (en bas, il y a l’orientation et l’heure) :

La conception électronique est assez basique. J’ai choisi pour microcontrôleur un Arduino Nano Every qui a un facteur de forme compact. Autour, on retrouve les composants suivants :

• un écran OLED 0,96′ de 128×64 pixels ;
• un module GPS NEO-6M avec une antenne ;
• un circuit de gestion de la batterie (ou BMS pour battery management system) basé sur le circuit intégré TP4056 ;
• une batterie 3,7 v de 1000 mAh ;
• un élévateur de tension basé sur le circuit intégré MT3608 (pour passer du 3,7 v de la batterie au 5v de l’Arduino et d’autres composants) ;
• un interrupteur d’alimentation ;
• un bouton poussoir pour afficher différents menus.

Le système de gestion de la batterie embarque tout un tas de protections qui permettent une utilisation sereine et simple de la batterie. C’est grâce à ce composant que l’on peut charger la batterie en USB, avec une coupure de la charge une fois pleine. En plus de ce composant, l’élévateur de tension permet l’alimenter l’Arduino et les autres modules du circuit qui requièrent du 5v.

Pour indiquer à l’utilisateur le pourcentage de batterie restante, j’ai également connecté la sortie de la batterie (en 3,7 v cette fois donc) à une entrée analogique de l’Arduino. 3,7 v n’est que la tension nominale de la batterie : dans la pratique, elle varie de 4v (chargée à 100 %) à 3,2 v (0 %). La broche analogique de l’Arduino mesurera donc cette grandeur pour estimer le pourcentage de batterie restant.

Concernant le choix de la capacité de la batterie, je me suis basé sur une mesure de la consommation du prototype. Avec un ampèremètre, j’ai mesuré l’intensité approximative à l’alimentation pour en déduire l’autonomie théorique en fonction de la référence de batterie. Le détail des calculs est disponible ici. J’ai retenu 1000 mAh car on peut avoir une batterie de cette capacité assez compacte, et elle donne théoriquement six heures d’autonomie (remarque : il y a peut-être eu un problème dans la mesure de l’intensité, je ne sais plus si elle a été faite en 5v ou en 3,7v – elle devrait être faite à la tension de la batterie).

Voilà à quoi ressemble le câblage final :

Une fois encore, c’est assez simple : on relie les alimentations de même tension entre elles, les bus entre eux et c’est globalement tout ! J’ai ajouté un connecteur USB-C de charge en plus, car celui intégré avec la gestion de la batterie est l’ancienne prise USB qui est datée…

ATTENTION ! Il faut régler la tension de sortie de l’élévateur avant de brancher les composants en 5v dessus ! Si la tension est par défaut réglée trop haut, cela pourrait griller tous les composants censés être alimentés en 5v. Pour cela, utilisez un voltmètre à la sortie et tournez la vis du potentiomètre pour régler la tension.

J’ai essayé de choisir les composants les plus compacts en utilisant ce que j’avais à la maison. L’idéal aurait été de concevoir un circuit imprimé qui intègre directement tous les composants, mais vous allez le voir dans la partie suivante : on a déjà un résultat propre de cette manière.

Le boîtier et l’assemblage

La conception du boîtier est probablement l’étape la plus complexe dans ce projet : il faut arriver à organiser tous les composants dans un espace le plus restreint possible. En plus, il faut assurer leur fixation, un bon rendu extérieur, l’assemblage, etc.

Tout d’abord, il faut penser à l’intégration dans la Traction. L’avantage d’une voiture ancienne pour notre projet, c’est l’absence de plastique ! Il y a un tableau de bord en métal, donc la solution est toute trouvée : le compteur va s’aimanter dessus. On peut également déjà positionner certains composants pour réduire petit-à-petit la complexité du problème. L’écran sera évidement à l’avant, tout comme le bouton poussoir. On peut mettre l’interrupteur d’alimentation sur un côté avec la prise de chargement. Enfin, l’antenne GPS sera placée en haut sous le boîtier pour capter correctement les satellites.

Maintenant, on peut placer les autres composants en interne. J’ai choisi de créer un empilement des différentes cartes. Je m’y suis repris à plusieurs fois pour trouver le meilleur arrangement. Pour cela, je positionne virtuellement chaque composant que je télécharge en ligne depuis GrabCAD par exemple. En parallèle, je teste l’assemblage physiquement pour mieux me rendre compte de l’espace occupé et de la place pour le câblage.

La dernière étape de la modélisation consiste… à modéliser ! J’ai les composants positionnés dans FreeCAD et il ne reste plus qu’à concevoir le boîtier. Voilà le résultat :

La coque extérieure est composée de deux pièces qui sont vissées ensemble. Les composants internes sont fixés sur la partie avant. De l’intérieur, j’ai conçu des entretoises pour fixer toutes les cartes en sandwich :

J’ai dû itérer plusieurs fois en imprimant les pièces pour trouver les bons ajustements. Je vous mets le fichier FreeCAD final du projet en lien ici.

Maintenant, il est temps d’effectuer l’assemblage au propre ! La première étape consiste à poser les aimants et les inserts filetés. Ensuite, on ajoute l’écran et les autres composants accessibles de l’extérieur. Je fais le câblage en même temps, en prévoyant les bonnes longueurs de fils et en protégeant bien chaque contact. Chaque composant est vissé ou collé au double-face à la structure pour éviter les mouvements lors de l’utilisation.

Enfin, il n’y a plus qu’à refermer le boîtier par six vis. Cependant, il faut garder le boîtier ouvert pour programmer l’Arduino !

Le programme

Le programme est exécuté par l’Arduino Nano Every et orchestre tous les composants. La première étape est de concevoir l’interface utilisateur pour avoir bien en tête le résultat à obtenir.

Conception graphique

Je commence par lister les informations à afficher sur l’écran :

• vitesse ;
• heure (fournie par GPS) ;
• informations sur la batterie : pourcentage de charge, autonomie restante, etc. ;
• statistiques sur la conduite : vitesse maximale et temps écoulé.

Je liste ensuite les écrans à dessiner :

• un écran de démarrage ;
• un écran affichant l’autonomie restante après l’écran de démarrage ;
• un écran d’attente d’une connexion aux satellites GPS ;
• un écran principal affichant vitesse, heure et batterie ;
• un écran d’alimentation affichant les statistiques sur la batterie ;
• un écran de statistiques sur la conduite avec la vitesse maximale et le temps de conduite ;
• un écran d’avertissement sur la batterie faible ;
• un écran de batterie déchargée qui est affiché avant d’éteindre le système.

Certains écrans s’affichent uniquement pour certains événements précis. Les trois écrans principaux (vitesse, alimentation et statistiques) pourront être affichés à tour de rôle en pressant le bouton poussoir.

J’aurais pu réaliser tous ces écrans directement avec la bibliothèque Arduino de l’écran, mais j’ai découvert un outil très pratique qui permet de concevoir des affichages graphiquement Lopaka. Avec, on peut positionner du texte, des icônes et d’autres formes depuis une interface, et obtenir le code associé. C’est ce que j’ai utilisé pour dessiner les huit menus de ce projet !

Et voilà !

L’organisation du programme

Comme à mon habitude, je développe les programmes pour Arduino avec PlatformIO. C’est bien plus pratique et poussé que l’EDI Arduino. Je peux notamment le partager facilement sur GitHub.

J’ai utilisé un peu de programmation orientée objet (POO) pour ce projet. L’écran, le module GPS et la batterie sont gérés par leur classe respective dans des fichiers séparés pour une meilleure propreté du code.

J’utilise aussi une bibliothèque pour communiquer avec le module GPS. Grâce à elle, on peut récupérer directement et simplement les informations du module.

Gestion de la batterie

La gestion de la batterie mérite une section séparée parce qu’elle sort un peu de l’ordinaire par rapport aux projets déjà présentés sur ce blog.

Pour rappel, on devine le pourcentage de charge de la batterie en mesurant sa tension, qui varie de 4 v à 3,2 v. Tout d’abord, il faut savoir que l’estimation que nous faisons n’est jamais parfaite, mais elle permet quand même d’en donner une bonne idée.

Je pourrais simplement faire une proportionnalité avec 3,2 v correspondant à 0 % et 4 v à 100 %, mais en réalité, la courbe de tension en fonction du pourcentage réel restant n’est pas linéaire. J’ai donc mis en place un système de mesure expérimentale qui permet de créer une liste associant tension et pourcentage. Le principe est simple : dans battery.hpp, on peut activer un mode d’enregistrement qui relève la tension de la batterie à intervalle régulière jusqu’à être vide. On peut récupérer ces enregistrements par la suite et un programme python traite les données pour sortir deux tableaux en c++ qui associent pourcentage et tension.

Conclusion

Et voilà ce projet de terminé ! Le résultat final est très propre, et par-dessus tout fonctionnel. Pour l’améliorer, il serait intéressant de passer sur un circuit imprimé intégrant tous les composants. Vous pouvez trouver tous les fichiers du projet ici. Je vous laisse avec quelques photos du résultat !