Un barographe multifonction performant et économique

Mon précédent barographe était un modèle Naudet acheté en 2007. Il a rendu l’âme après 12 ans de mauvais service : affichage cristaux liquides très peu lisible, énorme dérive du capteur, menus compliqués…

Après recherche sur le web, je me suis dirigé vers une autoréalisation en assemblant les pièces suivantes (prix port compris) :

• 3.5 pouces TFT LCD module d’écran Ultra HD 320X480 pour Arduino + carte MEGA 2560 R3 (13.89 €).
• Module de capteur de pression atmosphérique altimètre de GY-BME280-3.3 (2.36 €).
• Transistors BD 139, diode 1N411, résistors, buzzer et poussoirs.
• Pile de sauvegarde 9v.
• Module de capteur de propane-butane MQ6 (1.23 €) optionnel.
• Thermistance CTN (récupération) optionnel.

L’assemblage

Il est très simple. L’écran s’enfiche au dessus de la carte. J’ai choisi de raccorder les autres éléments à l’aide de platines à trame perforée (Figure ci-dessous). Il serait plus « propre » d’intercaler une platine de prototypage pour carte MEGA 2560 (entre 1 et 2 €), mais cela augmenterait l’épaisseur de la réalisation.

Quelques choix

• La consommation sur un voilier est toujours critique. La carte et l’écran consomment chacun environ 100 mA. La carte doit être alimentée en permanence pour la capture et l’enregistrement des données. En revanche l’écran peut être allumé sur demande. Il ne parait pas directement possible de commander l’allumage par logiciel. Le choix a donc été fait de commander l’alimentation 5v de l’écran via une ligne de donnée et un transistor.
• Une alarme en cas de variation de pression de 3mb sur 3h.
• Une « interface utilisateur » via deux boutons.
  • Bouton G commande l’affichage : allumage (pour 40 s) puis cyclage sur 5 durées (3h, 6h, 12h, 24h, 48h).
  • Bouton D sert à régler l’heure et l’alarme. Un appui long fait défiler le temps (de plus en plus vite). Un appui court permet de basculer l’alarme (sur l’écran actif A, inactif X).
• Des options. La carte consommant en permanence, il serait dommage de ne pas l’utiliser pour d’autres données.
  • La température de l’eau. Sur mon bateau, une thermistance CTN collée au puits de dérive fait l’affaire. On consultera Wikipedia Steinhart–Hart equation pour déterminer les constantes A, B, C nécessaires au calcul de la température.
  • Une alarme gaz. En quarante cinq ans de navigation, j’ai vu deux voiliers exploser pas loin avec graves dégâts et blessures. Le problème des détecteurs, c’est toujours la consommation (160 mA) car le capteur doit être chaud. L’utilisation de la carte permet une mise en service intermittente : il n’est pas besoin de tester en permanence. J’ai choisi de le faire toutes les 6 minutes.

Le logiciel

L’environnement de développement Aduino IDE [1] est une merveille de possibilités et de simplicité. J’ai pu m’aider de nombreuses références sur le Web pour écrire un code qui corresponde à ce que je voulais. Il est plus bas en annexe. Je l’ai commenté suffisamment pour qu’on puisse comprendre comment ça marche et le modifier selon les besoins. Il ne faut pas oublier d’ajouter à l’IDE les modules « INCLUDE » et choisir le type de carte dans les outils (Arduino/Genuino Mega or Mega 2560 ) ainsi que le numéro du port série virtuel associé au port USB. Ensuite vous copiez le code et vous le transférez à la carte par USB.

Des extensions possibles

Toujours dans l’idée de ne pas laisser le processeur consommer sans rien faire, on pourrait tirer parti des 4 ports série pour connecter des périphériques nmea. Avec un GPS, on pourrait faire une alarme de mouillage. Avec un anémomètre on aurait en plus les données de vent !

Note finale
Je suis plus informaticien qu’électronicien. La bonne nouvelle est que ces cartes suppléent à un manque de connaissances ou d’habileté en électronique. Certainement des navigateurs mieux formés dans ce domaine auront des montages plus canoniques à proposer !

Une photo
Pas facile de prendre une photo d’un écran qui réfléchit. La courbe et les caractères (respectivement jaunes et blancs dans la réalité) sont en fait très lisibles. La chute de pression brutale à 7h correspond à l’allumage du chauffage dans mon bureau. Le baro est malencontreusement placé au dessus d’un radiateur en attendant de naviguer au printemps !

Annexe : le code

/*
display 320*480 jbl 10/2019
*/

#include // pour l’écran
#include
#include « SparkFunBME280.h »// pour le capteur

BME280 Sensor ; //Uses I2C address 0x76 (jumper closed)

TFT_HX8357 tft = TFT_HX8357() ; // Invoke custom library

//couleurs
#define LTBLUE 0xB6DF
#define LTYELLOW 0xFFF8
#define LTGREY 0xE71C
#define WHITE 0xFFFF
#define BLACK 0x0000
//ports
#define THERMISTORPIN A0 //analogique pour la température extérieure
#define BoutonG 3 //pour l’affichage
#define BoutonD 2 //réglages
#define AllumeCapteurGaz 14 //met en service le capteur de gaz via un transistor
#define TestCapteurGaz 15 //la sortie TTL du capteur de gaz (active au niveau bas)
#define ecran 12 //allume l’écran via un transistor
#define piezoPin 4 //le buzzeur

//constante pour l’alarme barométrique
//l’écart barométrique sur 3h maxi qui déclenche l’alarme.
//Il est compté en position verticale sur l’écran (320 pour 80mb)
#define GapBaro 12 //correspond à 3mb

//les modes d’affichage de la courbe
byte state=0 ;// 5 modes respectivement sur 3h, 6h, 12h, 24h, 48h
String Duree[]=« 3h »,« 6h »,« 12h »,« 24h »,« 48h » ;//pour affichage

byte heure=00 ;
//la donnée de pression est mémorisée à chaque intervalle de 22.5 secondes (3/8 de minute)
//de façon que 480 données (largeur de l’écran) correspondent à 3h (state=0)
//chaque heure contient 160 intervalles
byte interval=00 ;
//en principe un intervalle est de 22500 millisecondes.
//Néanmoins, il faut ajuster empiriquement cette valeur en fonction de l’horloge du AT Mega2560
const float delai=22297 ;

//ces deux valeurs comptent respectivement les millisecondes depuis le début
//d’un intervalle de 22.5 secondes et depuis le réveil de l’écran ;
//il est important de les déclarer en unsigned long
//http://arlotto.univ-tln.fr/arduino/...
unsigned long temps=0 ;//Important pour stocker les millis
unsigned long TempsReveil ;

//l’allumage de l’écran provoque un décalage dans la lecture de la pression
bool Reveil=false ;//rattrapage après allumage de l’écran
float gap ;//à rattraper

// la mesure de pression se fait en continu sur chaque intervalle de 22.5s
//on mémorise la moyenne en comptant les relevés
float pression ;
byte nbReleves ;

//les listes où mémoriser les données de pression
//on mémorise des positions verticales sur l’écran (0 pour 1040mb, 319 pour 960mb)
//on stocke 480 données (largeur de l’écran) pour les 3 premières heures
int Values[480] ;
//pour 6h on prend une donnée sur deux dans Values pour les 3 premières heures
//et on a stocké une donnée sur deux pour les 3 heures précédentes dans Values3
int Values3[240] ;
//pour 12h on prend une donnée sur quatre dans Values pour les 3 premières heures
//et on prend une donnée sur deux pour les 3 heures précédentes dans Values3
//et on a stocké une donnée sur quatre pour les 6 heures précédentes dans Values6
int Values6[240] ;
//pour 24h on prend une donnée sur huit dans Values pour les 3 premières heures
//et on prend une donnée sur quatre pour les 3 heures précédentes dans Values3
//et on prend une donnée sur deux pour les 6 heures précédentes dans Values6
//et on a stocké une donnée sur huit pour les 12 heures précédentes dans Values12
int Values12[240] ;
//pour 48h on prend une donnée sur seize dans Values pour les 3 premières heures
//et on prend une donnée sur huit pour les 3 heures précédentes dans Values3
//et on prend une donnée sur quatre pour les 6 heures précédentes dans Values6
//et on prend une donnée sur deux pour les 12 heures précédentes dans Values12
//et on a stocké une donnée sur seize pour les 24 heures précédentes dans Values24
int Values24[240] ;

//Pour utiliser les listes Values comme des files (piles LIFO) on utilise des index
//qui mémorisent, dans chaque liste, la position de la dernière donnée entrée
word index=0 ;//pour Values
byte index3=0 ;//pour Values3
byte index6=0 ;//pour Values6
byte index12=0 ;//pour Values12
byte index24=0 ;//pour Values24
byte delaiBoutonD=200 ;
//Ces booléens servent pour le stockage d’une donnée sur deux dans les listes Values3 à Values12
bool Bshift3=false ;
bool Bshift6=false ;
bool Bshift12=false ;
bool Bshift24=false ;

//variables pour les alarmes
bool alarmBaro=false ;//activée/désactivée
bool alarmGaz=false ;//activée/désactivée
bool AlarmOn=true ;//false desactive toutes les alarmes
//l’index jusqu’auquel poursuivre la recherche d’un GapBaro dans la liste Values
word indexAlarm=0 ;

//variables pour la température extérieure
float ValPortThermistance=500 ;//la valeur relévée sur le port THERMISTORPIN
int TempExt=20 ;//la température affiché ; elle est mémorisée pour le cas où le calcul donne une valeur aberrante

bool Changestate=false ;//gestion rebond

void axes(TFT_HX8357 &tft)
int i ; int h ;
//une ligne horizontale tous les 20 pixels (soit 5mb)
//grise sauf pour la ligne des 1000mb en bleu.
//avec graduation à gauche
for ( i = 19 ; i <= 299 ; i += 20)
if (i == 159) tft.drawLine(0, i, 479,i, LTGREY) ;
else tft.drawLine(0, i, 479,i,LTBLUE) ;
tft.drawNumber(1040-(i+1)/4, 0, i, 1) ;
//une ligne verticale tous les 160 pixels pour state=0 (3h)
//80 pixels pour state=1 (6h), etc. Correspond aux heures rondes
// avec étiquette toutes les 2 heures
for (i=479-interval/pow(2,state) ;i>0 ;i-=160/pow(2,state))
tft.drawLine(i,0, i, 319, LTGREY) ;//tracer
h=heure ;
for (i=479-interval/(pow(2,state)) ;i>0 ;i-=320/pow(2,state))
tft.drawNumber(h, i, 310, 1) ;h=22+h ;h=h%24 ; ;