Embedded Files
1ère station météo avec afficheur texte :
Nous souhaitons fabriquer une petite station météo qui affiche la température, la pression atmosphérique, sa variation et le taux d'humidité.
Pour cela, nous utilisons:
1 Arduino Nano (alimenté en USB-C) (environ 2€).
1 afficheur 4 fois 20 caractères avec interface I2C (environ 4€). Le pont noir entre 2 broches sur le module I2C (à l'opposé de l'ajustable bleu qui permet de régler le contraste) permet de régler l'intensité du backlight : avec le pont : intensité max, sans pont : éteint et illisible, avec un résistance de 470Ω 1/4W intensité "moyenne".
1 capteur de pression AHT20 et BMP280 (environ 1€)
1 ampoule mercure (environ 0.30€) : il suffit de retourner la station pour remettre à 0 les températures mini et maxi. Il y aussi un bouton poussoir en face arrière en parallèle.
1 "rallonge" USB-C (Pas indispensable mais très pratique) : ça permet d'installer l'Arduino et l'embase USB-C (fixée solidement) où on veut tout en pouvant le programmer et l'alimenter sans ouvrir le coffret). (Environ 2.5€).
Le capteur de pression et l'afficheur sont reliés en I2C à l'Arduino Nano. Si on veut mesurer la température extérieure, il faut évidemment déporter le capteur (et prévoir un connecteur). En I2C, on recommande de ne pas dépasser 1m de câble, sinon, il faut réduire la vitesse d'horloge ( Wire.setClock(50000) dans le setup) et/ou rajouter des résistances de pull-up (2k2Ω entre Vcc et SDA et 2k2Ω entre Vcc et SCL au niveau de l'Arduino, voire 1kΩ ). De toute façon, vu le faible débit d'acquisition (une mesure par seconde) il semble sage de réduire la vitesse d'horloge. Attention : avec une vitesse d'horloge I2C relativement faible, il faut attendre au moins 200ms après interrogation des capteurs avant d'utiliser les valeurs...
Nota : dans les programmes de nos stations météo, si la variation de pression est supérieure à 1 hPa (en 6 ou 9 minutes), la valeur n'est pas considérée valide pour les calculs de Pmini et Pmaxi : c'est forcément une erreur de mesure !
Si on veut mesurer la température intérieure, il faut soigneusement disposer le capteur loin de l'Arduino et de l'afficheur qui chauffent légèrement : environ 20mA de backlight afficheur + 20 mA Arduino...
Le schéma est simpliste : l'Arduino Nano, alimenté en USB-C est relié à l'afficheur et au capteur par les broches SDA et SCL de l'I2C et c'est tout. Un bouton de reset est prévu. Nous avons rajouté (sur le connecteur avion) un condensateur de découplage de 820uF 10V.
Il n'y a que 5 fils à connecter à l'Arduino.
Le coffret en cours de réalisation : dans un profilé aluminium de fenêtre découpé avec notre Cnc3040 et dans lequel une tôle aluminium pliée en U a été insérée. L'afficheur (avec son film de protection transparent) est fixé par 4 vis M3x20 dont les têtes sont collées à l'intérieur du coffret à l'Araldite. Le coffret est peint en noir.
Vue arrière du boitier : le connecteur (avion) et le capteur (dans un tube de vitamine C raccourci et percé), les 2 écrous qui maintiennent l'Arduino Nano à l'intérieur et le bouton poussoir de RAZ (en plus d'une ampoule au mercure) :
Le programme Arduino : Rappelons qu'il faut installer l'Arduino IDE (gratuit), créer un nouveau projet, choisir la bonne carte ex: Arduino Nano, installer les bonnes bibliothèques ex: #include <Adafruit_BMP280.h>. Écrire le bon programme, relier le PC avec l'Arduino IDE au module, réussir à téléverser, et débugger. Parfois, en cas d'erreur, résoudre le problème n'est pas toujours simple mais une IA peut grandement aider...
#define VERSION 0.6
#define DATE "30/07/2025"
/*
Station météo baromètre thermomètre humidité variation barométrique continue 20 points sur 48h
Arduino Nano USB-C
Capteur BMP280 (Pression et température) etAHT20 (humidité et température)
Dans cette version, on affiche la pression barométrique sur 4 lignes MAIS
Si la pression est faible : on affiche les températures et la pression sur la ligne du haut et humidité sur la 2e
Si la pression est forte : on affiche les températures et la pression sur la ligne du bas et humidité sur la 3e
Hystereris seuil 1/3 2/3 (pour éviter les "clignotements")
Version ou Pmax et Pmin s'ajuste automatiquement, la colonne du graphe en cours s'ajuste chaque s
ETAT : **********************************
A priori, tout est en ordre
LCD OK, capteur OK, lecture temperature pression et humidité OK
Temperature et humidité sur AHT20 (+-0.3°C au lieu de +-1°C sur BMP280)
Balayage sans décalage
Tmin Tmax et RAZ
1 Fichier, Enregistrer
2 Fichier, Préférences, Paramètres, Afficher les résultats détaillés pendant, Téléversement, OK
3 Croquis, Vérifier, Compiler : pas d'erreurs
4 Brancher cordon USB C entre PC et Nano
5 Outils, type de carte Arduino Nano
6 Outils, Processeur, Atmega 328P (sinon erreur avrdude...)
7 Outils, Port, COM4
8 Croquis, Téléverser
9 Affiche Téléversement....
Un bouton poussoir fugitif relié entre masse et A0
Afficheur LCD 4x20char en I2C 0x27
SDA:A4, SCL:A5
*/
#include <Wire.h>
#include <LiquidCrystal_I2C.h> //afficheur
#include <Adafruit_AHTX0.h> // Bibliothèque AHT20+
#include <Adafruit_BMP280.h>
#define LED 13 //clignote pour voir si vivant
#define TEMPO 7800 //2h24 cycme de 48h
//#define PMIN 970 //pression atmospherique mini et maxi
//#define PMAX 1010
LiquidCrystal_I2C lcd(0x27, 20, 4); //afficheur
Adafruit_BMP280 bmp; // Objet pour le BMP280
Adafruit_AHTX0 aht; // Objet pour l'AHT20
int i=0; //compteur
int t=0; //compteur temps
int flaghaut=1; //affichage texte en haut ou en bas selon pression
float ftmin=100, ftmax=-100; //temperatures mini et maxi
float ft,fp; //temperature et pression
int Pmin; //adaptation automatique
int Pmax;
void setup()
{
pinMode(LED, OUTPUT); //LED Arduino sinon clignotement faible
pinMode(A0,INPUT_PULLUP); //bouton RAZ
Serial.begin(9600); //debug monitor
Serial.println("");
Serial.print("METEO Version");
Serial.println(VERSION); //affichage programme, version et date de mise à jour
Serial.println("");
Serial.println(DATE);
digitalWrite(LED, HIGH);//allume la Led
Serial.print("LED allumée");
delay(500);
digitalWrite(LED, LOW);//éteint la Led
Serial.println(", éteinte");
delay(500);
digitalWrite(LED, HIGH);//allume la Led
lcd.init();
lcd.backlight();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("METEO Ver ");
lcd.print(VERSION);
lcd.setCursor(0, 1);
lcd.print(DATE);
delay(1000); // pour lire la version et la date
digitalWrite(LED,HIGH);//éteint la led
if (!bmp.begin())
{ //Initialisation du BMP280 sensor addresse 0x76
//Serial.println("Pas de BMP280 !");
lcd.setCursor(0, 3);
lcd.print(F("Pb capteur BMP280"));
//while (1); //sortie
}
if (!aht.begin())
{
Serial.println("AHT20 non détecté ! Vérifiez les connexions.");
//while (1); // Arrêt si erreur
}
Serial.println("AHT20 prêt");
Serial.print(" t=");
Serial.print(bmp.readTemperature());
Serial.print(223); //°
Serial.print("C");
lcd.setCursor(0, 2);
lcd.print(F("t="));
lcd.print(bmp.readTemperature());
lcd.write(223); //affiche le ° de °C
lcd.print(F("C"));
fp=bmp.readPressure()/100.0F;
Pmin=fp-2;
Pmax=fp+2; //adaptation
Serial.print(" p=");
Serial.print(fp);
Serial.print("hPa");
lcd.setCursor(0, 3);
lcd.print(F("p="));
lcd.print(bmp.readPressure()/100.0F);
lcd.print(F("hPa"));
initPlot(); //initialisation caracteres speciaux pour le bargraph
delay(4000); //pour avoir le temps de lire...
lcd.clear(); //discutable
}
void loop()
{
int p;
int lecture;
int humidite;
char buffer[10]; //conversion et arrondis capteur
sensors_event_t humidity, temp; // Objets pour les données
aht.getEvent(&humidity, &temp); // Lecture des valeurs
//ft=bmp.readTemperature(); //lecture BMP280 moins précis +-1°C
ft=temp.temperature; //AHT20 +-0.3°C
if (ft<ftmin) ftmin=ft;
if(ft>ftmax) ftmax=ft;
fp=bmp.readPressure()/100.0F;//BMP280
if (fp>Pmax) Pmax=fp; //adaptation
if (fp<Pmin) Pmin=fp;
//Serial.print("Pmin="); //supprime les Serial.print pour ne pas perdre de temps
//Serial.print(Pmin);
//Serial.print(" Pmax=");
//Serial.println(Pmax);
if(fp>((Pmax-Pmin)*0.50)+Pmin) //ex 1005 (980 à 1010)
{
if(flaghaut==1) //au changement, supprimer la ligne du du haut
{
lcd.setCursor(0, 0);
lcd.print(F(" "));//remplit le haut de vide
for(p=17;p<20;p++)
{
lcd.setCursor(p, 2);
lcd.write(byte(7));//remplit le bas de pleins
}
lcd.setCursor(17, 1);
lcd.print(F(" "));//efface humidité
}
flaghaut=0;
//températures et pression en bas
}
if(fp<((Pmax-Pmin)*0.45)+Pmin) //un petit
{
if(flaghaut==0) //au changement, supprimer celles du bas
{
for(p=0;p<20;p++)
{
lcd.setCursor(p, 3);
lcd.write(byte(7));//remplit le bas de pleins
lcd.setCursor(p, 2);
if (p>=17) lcd.write(byte(7));//remplace humidité avec des pleins
}
}
flaghaut=1;
//températures et pression en haut
}
Graph(); //debug variation de pression toutes les secondes*******************
//on let à jour le graphe toutes les s mais on avance que toutes les 2h24
if (t==0)
{
//Graph(); //variation barométrique
lcd.noBacklight();
delay(500);
lcd.backlight(); //pour prévenir mise à jour
i++;
if (i>=20) i=0; //au bout de 20 caractères, on retourne au début
}
t++; //cycle de 2h24
if (t>TEMPO) t=0; //7800 cycle de 48h: une lettre toutes les 2h24mn
dtostrf(ftmin, 2, 0, buffer); //tmini arrondir pas assez de place dans l'afficheur
if(flaghaut==1) lcd.setCursor(0, 0);//ligne du haut
else lcd.setCursor(0, 3);//ligne du bas
lcd.print(buffer);//affichage tmin
lcd.print(" ");
dtostrf(ft, 1, 1, buffer); //t
lcd.print(buffer); //affichage t
lcd.print("C ");
dtostrf(ftmax, 2, 0, buffer); //tmax
lcd.print(buffer); //affichage tmax
lcd.print(" ");
lcd.print(buffer); //affichage tmax
if(flaghaut==1) lcd.setCursor(12, 0);//ligne du haut
else lcd.setCursor(12, 3);//ligne du bas
dtostrf(fp, 1, 1, buffer);
lcd.print(buffer); //pression barométrique
if(flaghaut==1) lcd.setCursor(17, 0);//ligne du haut
else lcd.setCursor(17, 3);//ligne du bas
if(fp<1000) lcd.print("hPa"); //pas la place pou hPa
else lcd.print("hP"); //pas la place pour hPa
if(flaghaut==1) lcd.setCursor(17, 1);//ligne du haut
else lcd.setCursor(17, 2);//ligne du bas
//lcd.print(temp.temperature); // AHT20
//lcd.print("C ");
humidite=humidity.relative_humidity; //supprime les décimales
lcd.print(humidite); // taux humidité
if(flaghaut==1) lcd.setCursor(19, 1);//ligne du haut
else lcd.setCursor(19, 2);//ligne du bas
lcd.print("%");
if(digitalRead(A0)==LOW) //bouton Reset appuyé
{
ftmin=ft;
ftmax=ft; //remet maxi mini à 0
if(flaghaut==1) lcd.setCursor(4, 0);//ligne du haut
else lcd.setCursor(4, 3);//ligne du bas
lcd.print("----RAZ---- ");//on n'éteint pas l'écran pour garder variation baromètre
delay(2000); //pour avoir le temps de lire
}
delay(500); //1 acquisition par seconde
digitalWrite(LED, LOW);//éteint la Led : le programme est vivant
if (flaghaut==1) lcd.setCursor(11,0);
else lcd.setCursor(11,3);
lcd.print(":"); //_ clignote
delay(500); //500
digitalWrite(LED, HIGH);//allume la Led
}
void Graph() //affiche la variation barométrique en continu
{
int j; //pour parcourir la pression barométrique
//Serial.print(" fp=");
//Serial.print(fp);
//Serial.print(" l=");
//Serial.print((Pmax-Pmin)*i/32.0+Pmin); //debug
//Serial.println("");
lcd.setCursor(i, 3); //ligne du bas
lcd.print(" ");//efface précédent
lcd.setCursor(i+1, 3);
lcd.print("|");//efface suivant
//important pour voir ou en est la progression barométrique: la dernière valeur
for(j=0;j<=7;j++)
{
lcd.setCursor(i, 3);
if(fp>(Pmax-Pmin)*j/32.0+Pmin) lcd.write(byte(j)); //bargraph ligne du bas
}
lcd.setCursor(i, 2); //3e ligne
lcd.print(" ");//efface précédent
lcd.setCursor(i+1, 2);
lcd.print("|");//efface suivant
for(j=8;j<=15;j++)
{
lcd.setCursor(i, 2);
if(fp>(Pmax-Pmin)*j/32.0+Pmin) lcd.write(byte(j-8));
}
lcd.setCursor(i, 1); //2e ligne
lcd.print(" ");//efface précédent
lcd.setCursor(i+1, 1);
lcd.print("|");//efface suivant
for(j=16;j<=23;j++)
{
lcd.setCursor(i, 1);
if(fp>(Pmax-Pmin)*j/32.0+Pmin) lcd.write(byte(j-16));
}
lcd.setCursor(i, 0); //1e ligne
lcd.print(" ");//efface précédent
lcd.setCursor(i+1, 0);
lcd.print("|");//efface suivant
for(j=24;j<=31;j++)
{
lcd.setCursor(i,0);
if(fp>(Pmax-Pmin)*j/32.0+Pmin) lcd.write(byte(j-24));
}
}
void initPlot()
{
// symboles requis pour le bargraph
byte row8[8] = {0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
byte row7[8] = {0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
byte row6[8] = {0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
byte row5[8] = {0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
byte row4[8] = {0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111};
byte row3[8] = {0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111};
byte row2[8] = {0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111};
byte row1[8] = {0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111};
lcd.createChar(7, row8);//lcd.createChar(0, row8)
lcd.createChar(0, row1);
lcd.createChar(1, row2);
lcd.createChar(2, row3);
lcd.createChar(3, row4);
lcd.createChar(4, row5);
lcd.createChar(5, row6);
lcd.createChar(6, row7);
}
Le coffret connecté : l'afficheur LCD avec son module I2C avec le connecteur, le réglage (en bleu) de contraste et le connecteur avec la résistance de 470Ω pour définir l'intensité du backlight.
La carte Arduino Nano, le connecteur avion pour le capteur et la rallonge USB-C fixée par 2 vis M3 sur le côté du coffret.
Ça fonctionne : (le capteur barométrique est très précis : on détecte facilement un changement d'altitude de 1m). L'AHT20 est plus précis en température (+-0.3°C) que le BMP280 (+-1°C).
Une ligne affiche : Tmini, T (suivi d'un C), Tmaxi, un ": " qui clignote pour montrer que le système est vivant, la pression en hPa (suivi de hPa).
Une autre ligne affiche le taux d'humidité (arrondit à l'entier pour prendre moins de caractères possible) et %.
Le bargraph évolue sur 48 h (1 colonne toutes les 2h24mn) de Pmini à Pmaxi qui s'ajuste si la pression dépasse. Avantage : ça fonctionne en toute circonstance et ça optimise l'affichage. Inconvénient : il faut quelques jours pour que le système se calibre.
La colonne en cours se met à jour toutes les secondes. La colonne suivante est remplie de | pour séparer les anciennes valeurs des nouvelles.
Actuellement, la station ne stocke pas ses valeurs en EEPROM : si on débranche : on repart à 0...
Astuce : si la pression atmosphérique est plutôt basse : on affiche les températures et la pression sur la ligne du haut et le taux d'humidité sur la 2e.
Si la pression atmosphérique est plutôt haute, on affiche les températures et la pression sur la ligne du bas et le taux d'humidité sur la 3e.
Ainsi, on gagne une ligne et on dispose donc de 4 lignes pour afficher la variation de pression atmosphérique...
Sur la photo ci-dessous, la pression est plutôt faible (par rapport à la moyenne Pmaxi, Pmini). Les températures et la pression sont donc affichées sur la 1ère ligne et le taux d'humidité sur la 2e.
Sur la photo ci-dessous, la pression est au-dessus de la moyenne : donc, températures, pression et humidité sont affichées sur les lignes du bas et le taux d'humidité sur la 3e.
2e Station météo avec un afficheur graphique 320x240 2.4" :
Les possibilités de la station météo précédente sont limitées par l'afficheur 4x20 caractères (de plus, on ne peut créer que 8 caractères spéciaux).
Nous avons donc décidé de tester aussi un afficheur graphique couleur : 320x240.
La plupart de ces afficheurs fonctionnent en 3.3V. L'Arduino Nano de base fonctionne en 5V. On peut rajouter un circuit mais ça complique et ça augmente un peu le prix.
Nous avons donc décidé de baser notre station météo graphique sur un module 2.4 pouces ESP32 Arduino LVGL : (environ 10€) : un module complet : processeur et afficheur.
Le module est évidemment compatible avec l'environnement IDE Arduino.
Par contre, les chinois n'ont pas livré le cordon (pour l'I2C) avec le connecteur promis... (pourtant quasi indispensable)
A ce prix-là, en dehors du câble USB et du connecteur I2C (à raccorder au même capteur AHT20 & BMP280 que la station précédente), nous avons :
En face avant :
Un écran couleur sensitif TFT 320x240 backlight capacitif
Capteur de lumière
Led multicolore
En face arrière :
Prise USB-C pour l'alimentation et la programmation
Slot pour une carte TF MicroSD
Wifi
Connecteur à relier en option à une batterie Lithium
Connecteur I2C 4 contacts
Connecteur Haut-parleur
Connecteur pour un capteur humidité
Il suffit donc de relier le capteur au connecteur I2C 4 fils avec le câble fourni et d'alimenter le module avec l'USB-C.
Nous utilisons le même capteur : Le montage consiste à souder (éventuellement) les 4 picots du connecteur du capteur, relier ces picots au câble fourni, relier l'autre extrémité du câble au module et le connecter avec l'embase USB-C. Nous avons rajouté (sur le connecteur avion) un condensateur de découplage de 820uF 10V et un bouton poussoir de RAZ des températures.
Par contre le code Arduino est nettement plus touffu, en particulier au niveau des bibliothèques, de l'initialisation et de l'utilisation de l'écran.
Nous pensions utiliser uniquement du Vibe coding avec une IA comme Kimi ou Claude 4, avec un gros prompt complet...
Entre le problèmes des bibliothèques et de mise à jour, ce n'est pas évident... (c'est plus compliqué qu'avec l'afficheur "Texte" précédent.
La meilleure méthode est sans doute de demander à l'IA de générer le code pour un minimum : par exemple :
"Créer un programme commenté en français Arduino ESP32 LVGL avec afficheur LCD 320x240 pour Afficher "Station Météo" "
Et c'est tout, en cas de problème, copier coller le message d'erreur dans l'IA
Ensuite on fournit le code qui fonctionne à l'IA et on lui demande d'y rajouter la grille et les graduations. Et ainsi de suite en y allant progressivement...
On est bien obligé de mettre les mains dans le cambouis !
Le boitier de la 2e station météo en cours de construction (dans un morceau de volet aluminium) :
à l'arrière, le boitier vue arrière avec le trou pour l'embase du connecteur avion du capteur, à l'avant, en bas, la semelle du boitier sur laquelle est vissé par 2 vis M3x10 l'intérieur en époxy collé Araldite et le dessus en aluminium, collé. il manque la découpe écran, le support de l'ESP32, (qui sera collé sur les parties latérales en époxy) la découpe de la prise USB et la peinture.
L'avantage de cette solution : on peut faire tourner la station météo sans son boitier et accéder à toutes les parties pour la mise au point.
Le boitier assemblé vue arrière, il manque la peinture.
Le boitier peint (provisoirement), la découpe de l'afficheur avec notre Cnc3040 est provisoire (elle sera agrandie de 5mm sur chacun des 4 côtés). Il manque la découpe de la prise USB sur le côté, à droite. A gauche le même capteur (à base de tube d'aspirine), et le même connecteur avion 6 broches avec, évidemment, le même brochage que la station météo précédente (le câble fait 2m).
On distingue, à travers la découpe, le trou (celui bien visible sur la photo du dessus) qui accueillera l'embase 6 broches avion du capteur et qui sera reliée à l'ESP32 avec le connecteur et les fils fournis.
Il manque aussi 2 petits trous d3 en face avant, un pour visualiser la Led multicolore de l'ESP32 et l'autre pour son capteur de lumière. Nous utilisons une mince épaisseur d'Araldite pour réaliser des fenêtres translucides. Et une goutte de colle à chaud pour les masquer de la peinture à l'aérographe.
Photo du 2e modèle de la station météo qui commence à bien fonctionner (il manque le capteur : les valeurs , ici, sont simulées), le boitier ôté (aspect "vintage", le film de protection de l'écran est toujours en place :
En haut, en blanc : température mini, température, température maxi, pression, humidité
A gauche, en vert, les graduations des températures de -10 à +50
A droite, les graduations de pression de 970 à 995 hPa
La grille en gris
Les 3 courbes : température (vert), pression (bleu), humidité (rouge)
La ligne verticale jaune avance vers la droite en "déposant" les points vert, bleu, rouge des trois courbes au fur et à mesure
La ligne du haut est rafraichie toutes les secondes. La ligne jaune avance d'un pixel vers la droite toutes les 9mn, il faut 48h pour faire un cycle. Ensuite, évidemment, elle repart à gauche.
La led rouge clignote à chaque acquisition, chaque seconde. (elle montre que le programme est vivant).
Faire défiler les courbes n'est pas très facile, ce n'est pas réalisé, en tout cas, pour l'instant...
Le 2e modèle de station météo dans son boitier (Toujours avec le film de protection de l'écran et sans capteur : valeurs simulées) : températures en vert, pression atmosphérique en bleu, taux d'humidité en rouge. Les valeurs les plus récentes sont juste à gauche de la ligne verticale jaune (qui avance vers la droite : un pixel toutes les 6mn : un cycle en 48h).
Le boitier vu de derrière : un bouton poussoir "RAZ" pour les température maxi/mini (pin 21) a été ajouté.
Avec les capteurs :
Finalement, nous avons modifié aussi ce 2e modèle de station pour un affichage identique au 3e modèle (voir un peu plus loin) : 3 cercles humidité, température pression s'affichent sur le bord droit de l'écran et toutes les 9mn, génèrent les 3 points correspondants qui se déplacent d'un pixel vers la gauche. Au bout de 48h, les 3 courbes complètes sont affichées et les 3 points les plus à gauche sont perdus. De plus l'affichage et les graduations des pressions sont dynamiques.
3e Station météo avec un afficheur graphique 480x320 3.5" :
Un 3e modèle de station météo avec un ESP32 JC3248W535C muni d'un écran beaucoup plus grand (3.5"), d'une résolution double (480x320) et dans un petit boitier plastique, sans connecteur mais avec une carte TF microSD de 512 Mo. Le tout à 14€ (promo Aliexpress).
Il est évidemment à peu près indispensable de se procurer les connecteurs correspondants : au moins le JST au pas 1.25, 4 broches pour les capteurs.
C'est un écran tactile capacitif ESP32-S3 3,5 pouces IPS TFT 8M PSRAM 16M FLASH 320X480 ESP32 Module WiFi BT pour le développement Arduino ESP LVGL. Il consomme 130mA.
Carte TF, Gestion batterie Lithium, 12 Entrées/sorties. Sortie HP.
On utilise un programme proche du précédent.
Arduino, Carte, ESP32 Arduino, ESP32S3 Dev Module.
Connecteurs :
Batterie : JST 1.25 2p
Power : JST 1.25 4p
HP : JST 1.25 2p
8P IO : JST 1.25 8p
?? : JST 1.25 4p
et un connecteur pour carte TF sur le dessous (qui sera le dessus dans notre station météo), livré avec une carte 512Mo
Attention : L'embase USB-C du module peut être facilement arrachée du circuit imprimé. Nous recommandons de la renforcer avec de la colle époxy et de débrancher le cordon USB au niveau du PC et pas du module pour le téléversement.
L'ESP32 monté, fixé par 2 de ses 4 vis (livrées), dans un petit support en aluminium en U découpé avec notre Cnc3040 et qui sera monté sur une plaque rectangulaire (avec 4 pieds adhésifs) peints en noir. La plaque est là pour plus de stabilité. Avec toujours, au premier plan, le même capteur AHT20 et BMP280 relié en I2C par 2m de câble au connecteur avion. Ici l'ESP32 est équipé du programme d'origine (on peut évidemment faire pivoter l'affichage de l'écran dans les 4 directions par programme). L'écran de 3.5" est nettement plus confortable que celui de 2.4" de la station météo précédente.
L'ESP32 ouvert pour voir le brochage des connecteurs : pour relier le capteur en I2C, nous utilisons l'avant-dernier connecteur au pas de 2 en haut à gauche : GND, 3V3, IO17 (SDA), IO18 (SCL). Rappelons que le capteur fonctionne de 0V à 5V et donc est compatible avec 3V3. Le bouton poussoir BOOT peut être utile en cas de téléversement difficile. On utilise les bornes 5 et 6 du connecteur 8 broches pour un bouton poussoir de RAZ des températures (On ne souhaite pas utiliser l'écran tactile...)
Utilisation du bouton poussoir SW1 à coté du connecteur batterie : (tension batterie pin 5 ?)
1 clic : active l'alimentation : OK
2 clics rapides : désactive l'alimentation : inopérant
Maintien enfoncé : pour empêcher l'extinction automatique : inopérant
Question : comment, avec une batterie, éteindre le module sans avoir besoin de débrancher le connecteur batterie ? Prévoir un interrupteur en série avec la batterie ? Comment alors charger la batterie avec le connecteur USB-C si interrupteur est ouvert ?
Le boitier complet avec son pied :
Vue de derrière : Le bouton poussoir, à gauche, connecté entre les entrées 5 (mise à la masse) et 6 permet la RAZ des températures mini et maxi : à la place des températures est affiché "RAZ" pendant 2s. Le connecteur avion pour la capteur. Le connecteur 2 broches, en haut, permet de gérer une batterie Lithium 4.3V. Il fonctionne mais, malheureusement, connecter ou déconnecter le câble USB (avec la batterie connectée) reboot l'ESP32. Nous avons essayé de résoudre ce problème en soudant un condensateur, par exemple 820uF 10V entre GND et 3V3, sur l'embase du connecteur avion : reboot quand on débranche l'USB-C :-( Il est recommandé de prévoir 2 trous Ø2 dans le boitier pour accéder au bouton Boot du module parfois nécessaire pour télécharger (sans démonter le boitier).
Le câblage intérieur du boitier :
Le bouton poussoir de RAZ des températures mini et maxi
le connecteur avion avec un condensateur de 820uF 10V pour découpler le 3V3 (insuffisant pour éviter un reboot si on déconnecte l'USB-C avec une batterie Lithium)
2 résistances de pull-up 10kΩ pour l'I2C SDA et SCL. C'est recommandé mais pas sûr que ce soit indispensable...
L'ESP32 avec le boitier (et avec le film de protection écran). Le programme fonctionne. Pas encore de capteur : les valeurs sont simulées :
Nota : on peut encore améliorer la station météo en affichant les 3 points : température, humidité, pression, tout le temps à droite de l'écran, juste avant les graduations de pression. On fait alors défiler "tout" l'écran vers la gauche d'un pixel toutes les 6 minutes. Les valeurs des courbes les plus récentes sont ainsi toujours à droite.
Pour ça :
Il faut pouvoir lire la couleur des pixels, ce qui est a priori impossible avec notre bibliothèque
Il faut créer un tableau des couleurs de 480x320 ce qui ne rentre pas dans la mémoire de l'ESP32...
Nous allons donc créer un tableau de 480x320 d'entiers 8bits :
0 : Noir
1 : Rouge
2 : Vert
3 : Bleu
Avec cette dernière solution, ça rentre (mais il n'y a pas beaucoup de marge) dans la mémoire de l'ESP32.
A la mise sous tension, l'écran ne contient que le texte en haut, la grille et les graduations.
A droite, juste avant les graduations de pression, un petit disque rouge affiche le taux d'humidité, un petit disque vert la température et un petit disque bleu la pression atmosphérique en hPa. Toutes les 6mn (environ) les pixels rouges, verts et bleus se déplace vers la gauche d'un pixel. Au bout de 48h les 3 courbes continuent de se déplacer et les points des courbes à gauche sont perdus. Ainsi, c'est toujours la partie droite des courbes qui est la plus récente...
En plus, nous avons épaissi chaque courbe à 3 pixels pour une meilleure visibilité.
La photo ci-dessous le montre : on perçoit les 3 disques rouge, vert et bleu, à droite des courbes, qui correspondent à la valeur instantanée. (Et oui, la protection d'écran est toujours là :-)...
Une photo avec les capteurs, station météo réglée sur une période de 48h (sans la protection écran !) :
La station a été mise en route en début de nuit.
Après une dizaine d'heures après la mise en route (au matin) : les 3 courbes se propagent vers la gauche mais elles n'ont pas encore atteint l'extrémité gauche (48h)
Les valeurs instantanées correspondent à droite à la position des petits disques rouge, vert et bleu
Le soir, la température en vert a baissé d'un peu plus de 30°C (canicule du mois d'aout) à un peu plus de 20°C la nuit pour commencer à remonter au moment de la photo (matin) et se stabiliser en milieu de journée
Le taux d'humidité en rouge (au départ, autour de 40%), a remonté en début de nuit à cause de la chute de température. L'air n'arrive plus à garder la vapeur d'eau et ça condense : les objets sont humides. Puis le taux d'humidité redescend dans la nuit : la condensation est terminée. Le matin, il a dégringolé.
La pression atmosphérique en bleu, après avoir un peu diminué, semble avoir beaucoup augmenté (anticyclone), pour redescendre. Mais rappelons que l'affichage de la pression est dynamique : si la pression atteint le haut ou le bas de l'écran, la dynamique augmente et les graduations se modifient : il peut falloir plusieurs jours pour que le système soit stabilisé. Ici l'augmentation n'est que de 1 hPa. Dès que la courbe bleu atteint le haut de l'écran, la pression maximum augmente, dès que la courbe bleu atteint le bas de l'écran, la pression minimum diminue et les graduations s'ajustent. Au fil des jours, les amplitudes vont donc diminuer.
Nous avons modifié le code pour corriger rétroactivement la courbe de pression bleue : si on dépasse la pression maxi ou la pression mini (vive ChatGPT 5 !). Le code fonctionne aussi dans l'autre sens : si la pression mini est inférieure de plus de 2 hPa ou si la pression maxi est supérieure de plus de 2 hPa, on rapproche lentement les mini et maxi. Ainsi petit à petit, si la pression est à peu près constante, elle se recentre dans une échelle de 4 hPa.
Sur la photo ci-dessus, la courbe verte montre deux maximum de température correspondant à 2 jours (cycle de 48h). La 2e journée a été un peu moins chaude. Les graduations de la pression varient de 995 à 998 et la pression est en train de descendre : Une dépression arrive, vu la chaleur, risque d'orages dans les prochains jours...
Sur la photo ci-dessous, la pression atmosphérique a atteint le bas : les graduations on été modifiées en conséquence et la courbe de la pression a été redessinée (2 fois) : les amplitudes paraissent un peu plus faibles. (en plus d'avoir été complètement décalées vers la gauche).
Les 3 courbes ont atteint le bord gauche de l'écran. Les pixels des courbes de gauche (48h) seront perdus au fur et à mesure que seront générés les nouveaux pixels récents à droite.
Attention à l'algorithme pour recalculer la courbe bleue : Sur l'image ci-dessous à gauche, les 3 courbes sont enregistrées normalement, la pression est en train de chuter, proche du minimum. Quelques heures plus tard, sur l'image de droite, la pression a continué de chuter, la pression mini a donc progressivement diminué pour compenser, la courbe bleue est progressivement remontée et son amplitude a diminué. En remontant, elle a progressivement traversé les courbes rouge et verte et en a partiellement effacé certaines parties. Pour limiter ce problème, il faut soit diminuer pmini (ou augmenter pmaxi) par bond (Ex :1hPa). Une autre solution plus compliquée : enregistrer dans la mémoire écran toutes les 8 combinaisons : Rouge, Vert, Bleu, Rouge+Bleu, Rouge+Vert etc...
Un cycle complet de 48 h (l'algorithme a été amélioré, il y a beaucoup moins d'interruptions dans les courbes rouges et vertes et les 3 disques : rouge, vert et bleu, sont mis à jour en temps réel) :
La température (en vert) oscille entre un peu moins de 30°C et un peu moins ou un peu plus de 20°C (température mini 19.6°C, température maxi 29.6°C.
La courbe d'humidité (en rouge) suit : Dans la journée, le taux est assez bas, le soir quand la température tombe, le taux d'humidité remonte puis redescend dans la matinée.
La pression barométrique est passée de 985hPa pour remonter à plus de 990hPa. L'affichage s'est adapté et la courbe remplit bien l'écran.
Les 3 modèles de station météo :
Nota : Si vous avez des programmes qui plantent, qui figent, des mesures aberrantes, ça vient peut-être de la mauvaise qualité de l'adaptateur USB 5V ou de son câble (tension insuffisante, courant trop faible, parasites...)
Finalement, nous avons augmenté la durée du cycle d'acquisition de 48h à 96h...
That's All Folks !
Commencé le 11/07/2025
A jour au 05/10/2025
Page updated
Google Sites
Report abuse