Aujourd’hui, je vous propose de réaliser un petit thermomètre d’intérieur, piloté par arduino, et mettant en œuvre un capteur de température et d’hygrométrie DHT22, ainsi qu’un écran OLED i2c bicolore. Ainsi, vous pourrez découvrir une application simple, ludique, et concrète de ce capteur DHT et de cet afficheur, à travers un projet pratique et didactique, à portée de tout bon débutant en électronique !
Bien évidemment, il ne s’agit pas ici de réinventer la roue, ni même d’essayer de concevoir un thermomètre arduino qui puisse être moins cher que ceux que l’on trouve dans le commerce, ou sur internet ! Mais il s’agit plutôt d’apprendre à réaliser soi-même un objet concret, utile, et abouti (avec son « beau » boitier de finition, si je puis dire, imprimé en 3D !), et de voir étape par étape toute la partie conception électronique et mise en boitier.
Comme vous l’aurez compris, cet article se veut simple et didactique avant tout, afin que tous ceux qui débutent en électronique puissent découvrir, apprendre, et s’inspirer d’un tel montage. Mais cela étant dit, cela n’enlève rien au caractère utile de ce thermomètre arduino, qui pour ma part, a pris place dans le salon 😉
Intro : le projet dans son ensemble !
Pour faire court, on pourrait dire que ce projet est un simple thermomètre / hygromètre arduino, prenant la forme d’un cube avec des ouïes ! Mais pour être plus précis, voici ce qu’il permettra de faire :
- L’affichage de la température ambiante (précision d’environ ± 0,5 °C)
- Et l’affichage du taux d’humidité ambiant (précision d’environ ± 2 %)
Ce projet, à but essentiellement didactique, montre comment mettre en œuvre :
- Un écran OLED 0,96″ i2c pour l’affichage des mesures (monochrome à deux parties colorées : jaune en haut, et bleu en milieu/bas)
- Un capteur DHT22 pour effectuer ces mesures de température et hygrométrie
- Et un Arduino Nano, pour gérer le tout !
Au niveau fonctionnement, c’est comme qui dirait du « plug-and-play » ! C’est-à-dire que vous branchez l’alimentation, … et tout fonctionne ! Il n’y a donc aucun paramétrage à faire, ni bouton à appuyer. En bref, c’est un produit autonome 😉
Au niveau des branchements extérieurs, il n’y en a qu’un seul : l’alimentation, qui sera fournie par un bloc secteur (7,5 volts, 1 ampère). Le branchement se fera d’ailleurs en toute simplicité, via un connecteur DC Ø5,5 mm extérieur, et Ø2,1 mm intérieur.
Enfin, toute la partie électronique prendra place dans un « élégant » boîtier imprimé en 3D, afin d’avoir un objet fini, et convivial. Vous retrouverez d’ailleurs en bas d’article tous les schémas et autres supports servant à la réalisation de ce projet, aussi bien pour la partie électronique, que la fabrication du boitier en lui même.
Schéma fonctionnel de ce « thermomètre arduino »
Avant de vous montrer le schéma électronique, voici un petit schéma fonctionnel, représentant les blocs fonctionnels de ce thermomètre arduino, et les traitements qui vont être faits en interne :
Comme vous le voyez, on trouve principalement 3 blocs principaux, au sein de ce projet, à savoir :
- 1 capteur DHT22 : qui va mesurer, à la demande, la température et le taux d’humidité de l’air ambiant
- 1 arduino nano : qui va interroger ce capteur à intervalles réguliers, et envoyer des informations à l’écran, après mise en forme « graphique »
- Et 1 afficheur OLED : qui va simplement afficher les données, textes, et autres éléments graphiques, que l’Arduino Nano lui aura demandé d’afficher
À noter qu’il y a un 4ème bloc sur ce schéma fonctionnel, qui est seulement là pour mettre en évidence que ce projet nécessitera l’usage d’une alimentation externe, pour alimenter l’ensemble des sous-systèmes.
Comme vous pouvez le constater, ce projet est vraiment simple à appréhender, lorsque présenté en blocs fonctionnels. D’ailleurs, le schéma électronique qui suit l’est tout autant. Par contre, comme vous verrez plus loin, le code de programmation arduino sera quant à lui bien plus fourni ! Mais pour l’heure, voyons la partie « matérielle » 😉
Schéma électronique du projet
Au niveau schéma électronique, on retrouve nos 4 blocs fonctionnels, présentés avant, comme vous pouvez en juger par vous-même ici :
Par ailleurs, vous remarquerez qu’il n’y a que très peu de composants mis en œuvre dans ce projet (ce qui est idéal pour les débutants en électronique !). En fait, tout cela est permis grâce au fait que chacun des composants utilisés ici est déjà une forme « intégrée » en soi, avec tout plein de « sous-composants » déjà intégrés à leur niveau. Du coup, au final, on obtient quelque chose d’assez simple et rudimentaire, au niveau matériel. Bien sûr, la partie logicielle sera quant à elle bien plus conséquente ! Mais pour l’instant, restons quelque peu sur ce schéma, et voyons plus en détail chacun des blocs figurant sur celui-ci !
L’alimentation
Ce projet sera alimenté via un bloc secteur, lui fournissant du 7,5 volts. Du coup, la partie alimentation de ce projet se limitera à :
- Une diode de protection anti-retour, prévenant toute inversion de polarité. J’ai utilisé ici une diode schottky, afin de limiter la chute de tension à ses bornes, et par conséquent, le dégagement de chaleur qu’elle pourrait produire à l’intérieur du boitier (qui fausserait la mesure de température, en interne). Pour ceux que ça intéresse, voici la documentation technique de la diode utilisée dans ce montage : https://www.vishay.com/docs/88525/1n5817.pdf
- Un condensateur de filtrage, permettant de lisser la tension d’entrée. Car le bloc secteur que j’ai utilisé est ni plus ni moins qu’une alimentation à découpage, et qui par conséquent, comporte bon nombre de parasites hautes fréquences
Si on considère le fait que l’alimentation externe fournira du 7,5 volts, et que la chute de tension aux bornes de la diode sera d’environ 0,3 volts, alors la tension qui sortira de cette alim sera d’environ 7,2 volts. Ce qui est d’ailleurs idéal pour alimenter notre arduino via sa broche Vin, qui requiert une tension allant de 7 à 12 volts pour bien fonctionner.
À noter, qu’en interne, l’Arduino convertira cette tension d’alimentation en +5V et +3,3V, grâce à ses régulateurs de tension intégrés. Et comme vous l’aurez compris, cette tension 5 volts alimentera le reste de notre montage.
Le capteur DHT22 (température / hygrométrie)
La mesure de température et taux d’humidité est confiée à un capteur DHT22. Et au niveau câblage, on peut difficilement faire plus simple ! Car ce capteur n’a au final besoin que de :
- une alimentation (+5V / GND)
- et d’une ligne de données digitale (ici branchée sur l’entrée/sortie A1 de notre Arduino Nano, mais les pins D2 à D12 auraient également pu convenir)
À noter que s’il n’y a besoin d’aucun composant additionnel ici, c’est parce que le DHT22 utilisé dans ce projet est un modèle « tout équipé ». C’est-à-dire qu’il intègre déjà sur son PCB :
- Une résistance de pull-up, pour la ligne de données
- Et un condensateur de filtrage à proximité du capteur, pour une parfaite stabilité de fonctionnement
Au passage, si vous souhaitez plus d’infos sur ces composants additionnels, ou sur le DHT22 en lui-même, je vous renvoie à ce tutorial sur le DHT22, que j’avais fait il y a peu.
L’afficheur OLED i2c
Pour ce projet, j’ai choisi de confier l’affichage des données à un écran OLED « monochrome bicolore », c’est-à-dire disposant de 2 parties d’écrans de couleurs différentes. En fait, la surface d’affichage est scindée en 2 parties :
- 1 partie haute (16 pixels de hauteur), de couleur jaune
- Et 1 partie médiane/basse (48 pixels de hauteur), de couleur bleue
Côté dimensions, cet afficheur OLED fera 0,96″ de diagonale, pour une résolution de 128×64 pixels affichables (largeur x hauteur).
La communication entre l’Arduino et cet écran OLED se fera via le bus I2C, c’est-à-dire via leurs broches SCL et SDA respectives. Pour en savoir plus sur cette partie, je vous renvoie tout simplement à ce tutorial sur les écrans OLED i2c (chipset SSD1306), que j’ai récemment publié, et qui présente tout cela en détail.
Remarque : il n’y a besoin d’aucun composant additionnel ici non plus, car cet afficheur OLED intègre tous les composants « secondaires » nécessaires, permettant de s’interfacer en toute simplicité avec un Arduino. Ce qui simplifie donc notre schéma électronique, pour notre plus grand bonheur 😉
Le cœur du montage : un Arduino Nano
Du reste, un Arduino Nano vient orchestrer le tout. Il aura pour rôle :
- D’interroger le capteur DHT22, pour récolter des mesures de température et hygrométrie
- D’envoyer des instructions d’affichage à l’afficheur OLED i2c, pour faire afficher toutes ces données de manière « sympa » et présentable, à l’écran !
Concernant le capteur de température et d’hygrométrie DHT22, j’ai branché sa ligne de données sur l’entrée/sortie A1 de l’Arduino Nano, afin que toutes les pistes soient routées du même côté, lors de la réalisation du PCB. Bien entendu, toute autre entrée/sortie digitale, D0 à D12, aurait convenu (même si au passage, je vous déconseille l’utilisation des pins D0 et D1, car cela pourrait perturber les signaux RX/TX de l’arduino).
Concernant l’afficheur OLED i2c, celui-ci sera piloté via les broches SDA et SCL, depuis l’Arduino Nano. À noter ici que comme l’écran oled sera déporté du PCB, un connecteur à 4 broches figure sur le schéma électronique à la place de l’écran, afin de formaliser le déport de celui-ci (le raccordement entre cet écran et notre circuit imprimé se fera via une nappe électrique).
Enfin, concernant l’alimentation de l’Arduino Nano en lui-même, celle-ci s’opère comme vu précédemment, c’est à dire via le +7,2V environ, fourni par l’alimentation externe sécurisée. Cette tension pénètre l’Arduino Nano via l’entrée Vin, requérant une tension de 7 à 12 volts pour bien fonctionner.
Nota : l’Arduino Nano dispose d’un régulateur de tension intégré, permettant de « créer » du +5V à partir de cette tension Vin. Et c’est cette tension +5V qui servira à alimenter les composants externes à l’arduino, à savoir le capteur DHT22, et l’écran oled i2C.
Diagramme fonctionnel (processus logiciel)
Maintenant que nous avons vu ensemble la partie matérielle (hardware), nous allons nous intéresser à la partie logicielle (software). Et comme vous verrez, cette partie sera bien plus fournie que la précédente, car il s’agit là du cœur même du projet.
Mais avant de vous présenter les lignes de codes à proprement parler, je tenais à vous présenter ce diagramme, qui résume dans les grandes lignes tout ce que fera le programme arduino. Donc, le voici !
En fait, en synthèse, il faut retenir ici qu’il y a essentiellement 3 choses qui se répètent à l’infini :
- L’interrogation du capteur DHT22 par l’Arduino
- L’affichage de la température sur l’écran OLED (avec pause de 7 secondes)
- Et l’affichage du taux d’humidité sur l’écran OLED (avec pause de 7 secondes à nouveau, avant rebouclage)
Tout le reste n’étant là que pour sécuriser ou agrémenter le tout, à l’image de la remontée d’information à l’écran en cas d’erreur de mesure au niveau du capteur de température / hygrométrie. C’est pourquoi ce diagramme se révèle assez simple, au final, si vous regardez d’un peu plus près.
Ceci étant vu, passons à présent à la transcription de ce diagramme fonctionnel en code de programmation arduino ! Ainsi, vous verrez comment se formalise chacun des blocs ci-dessus !
Programme arduino (code)
Vous trouverez ci-après l’intégralité du code servant dans ce projet. Mais avant d’aller plus loin, il y a plusieurs choses qu’il faut que je vous précise.
Tout d’abord, ce programme est prévu pour interagir avec deux composants « majeurs » :
- Un capteur DHT22, permettant la mesure de température et taux d’humidité dans l’air
- Et un écran monochrome « bicolore » OLED i2c, faisant 128×64 pixels (0,96 pouces de diagonale / chipset SSD1306)
À noter ici que j’ai exceptionnellement câblé la ligne de données du DHT22 sur l’entrée/sortie A1 de l’Arduino Nano, pour des raisons pratiques, au niveau du routage PCB de ce projet. Bien sûr, toute autre E/S digitale aurait convenu, comme celles allant de D2 à D12, sur cet arduino.
Ensuite, pour égayer le tout, j’ai importé une police de caractère spéciale, pour afficher le message de bienvenue. J’ai également importé une seconde police de caractères (font), pour l’affichage des titres « TEMPERATURE » et « HYGROMETRIE », en haut de l’écran OLED. Si vous êtes intéressé par l’utilisation de polices de caractères différentes de celles proposées par défaut dans les librairies arduino, je vous renvoie vers cet article en lien.
Enfin, il faut savoir que j’ai également inséré 2 blocs de données dans le code, représentant les 2 images que j’ai utilisé pour l’occasion, à savoir :
- Un symbole représentant un thermomètre, pour illustrer l’affichage de la température
- Un symbole représentant une goutte d’eau, pour illustrer l’affichage du taux d’humidité
Là encore, si vous souhaitez savoir comment insérer des images directement dans le code arduino pour les faire afficher sur un écran OLED i2c, je vous renvoie à cet article en lien.
Voilà pour ce qui était des choses importantes à souligner, avant de vous présenter le code ! À présent, voyons ce dernier sans plus attendre 😉
/*
______ _ _///_ _ _ _
/ _ \ (_) | ___| | | | (_)
| [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___
| ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \
| | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/
\__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___|
| |
\_|
Fichier : thermometre_hygrometre.ino
Description : Programme support au projet "Thermomètre d'intérieur Arduino"
(avec exemple de mise en oeuvre : capteur DHT22 + écran OLED i2c + mise en boitier impression 3D)
Auteur : Jérôme TOMSKI (https://passionelectronique.fr/)
Créé le : 01.08.2021
Librairie Adafruit SSD1306 utilisée : https://github.com/adafruit/Adafruit_SSD1306 (importable depuis le Gestionnaire de bibliothèques de l'IDE Arduino)
Librairie Adafruit GFX incluse (dépendance) : https://github.com/adafruit/Adafruit-GFX-Library (nécessairement incluse, avec l'import de la librairie ci-dessus)
Police de caractère "Tahu" : https://www.dafont.com/fr/tahu.font
Police de caractère "Bebas Neue" : https://www.dafont.com/fr/bebas-neue.font
Convertisseur TTF vers GFX FONTS utilisé : https://rop.nl/truetype2gfx/ (pour intégrer des fonts sympa dans votre programme arduino)
Convertisseur PNG vers GFX PICTURE utilisé : https://javl.github.io/image2cpp/ (pour intégrer des images à votre code arduino, pour les faire afficher ensuite sur l'écran OLED)
*/
#include <Adafruit_SSD1306.h>
#include "Tahu16pt7b.h" // Police de caractère : Tahu, en taille 16 points
#include "BebasNeue11pt7b.h" // Police de caractère : Bebas Neue, en taille 11 points
#include <DHT.h>
// =======================================================
// Paramètrages du capteur température/hygrométrie (DHT22)
// =======================================================
#define brocheDeBranchementDHT A1 // La ligne de communication du capteur DHT est branchée sur la pin A1 de l'Arduino Nano
#define typeDeDHT DHT22 // Le type de DHT utilisé est un DHT22 (que vous pouvez changer en DHT11, DHT21, ou autre, le cas échéant)
DHT dht(brocheDeBranchementDHT, typeDeDHT);
int valeurHumidite; // Variable qui contiendra la valeur du taux d'humidité ambiant (en %)
int valeurTemperatureEnDegreCelsius; // Variable qui contiendra la valeur de la température ambiante (exprimée en degrés Celsius)
boolean mesureCorrectementEffectuee; // Variable qui indiquera si oui ou non la lecture des mesures effectuées par le DHT22 s'est bien passée ou non
// =========================================
// Paramètrages écran OLED 128x64 pixels I2C
// =========================================
#define nombreDePixelsEnLargeur 128 // Taille de l'écran OLED, en pixel, au niveau de sa largeur
#define nombreDePixelsEnHauteur 64 // Taille de l'écran OLED, en pixel, au niveau de sa hauteur
#define brocheResetOLED -1 // Reset de l'OLED partagé avec l'Arduino (d'où la valeur à -1, et non un numéro de pin)
#define adresseI2CecranOLED 0x3C // Adresse de "mon" écran OLED sur le bus i2c (généralement égal à 0x3C, ou 0x3D)
#define delaiAlternanceAffichageTemperaturePuisHygrometrie 7000 // Tous les 7000 ms (soit 7 secondes), on alternera l'affichage de la t°, et de l'hygrométrie
Adafruit_SSD1306 ecranOLED(nombreDePixelsEnLargeur, nombreDePixelsEnHauteur, &Wire, brocheResetOLED); // Le "Wire" indique qu'on travaille en I2C, au niveau de l'écran OLED
// ====================================
// Spécifications des images à afficher
// ====================================
#define largeurImageAafficher 27 // Largeur des images à afficher (symbole thermomètre et symbole goutte d'eau), en pixels
#define hauteurImageAafficher 40 // Hauteur des images à afficher (symbole thermomètre et symbole goutte d'eau), en pixels
// Image "goutte-eau-pse_v2", faisant 27x40px
const unsigned char monImageGoutteEauPse [] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00,
0x00, 0x13, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x61, 0x80, 0x00, 0x00, 0x40, 0xc0, 0x00,
0x00, 0xc0, 0x60, 0x00, 0x01, 0x80, 0x20, 0x00, 0x01, 0x00, 0x30, 0x00, 0x03, 0x00, 0x10, 0x00,
0x06, 0x00, 0x10, 0x00, 0x04, 0x00, 0x18, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x04, 0x00,
0x18, 0x00, 0x06, 0x00, 0x30, 0x00, 0x03, 0x00, 0x20, 0x00, 0x01, 0x00, 0x20, 0x00, 0x01, 0x80,
0x20, 0x00, 0x00, 0x80, 0x60, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x80,
0x40, 0x00, 0x00, 0xc0, 0x40, 0x00, 0x00, 0x40, 0x48, 0x00, 0x00, 0x40, 0x4c, 0x00, 0x00, 0x40,
0x44, 0x00, 0x00, 0xc0, 0x44, 0x00, 0x00, 0x80, 0x66, 0x00, 0x00, 0x80, 0x23, 0x00, 0x00, 0x80,
0x31, 0x80, 0x01, 0x80, 0x10, 0xc0, 0x03, 0x00, 0x18, 0x70, 0x06, 0x00, 0x0c, 0x00, 0x0c, 0x00,
0x06, 0x00, 0x18, 0x00, 0x03, 0xe3, 0xf0, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
// Image "thermometre-mercure-pse-27x40", faisant 27x40px
const unsigned char monImageThermometreMercure [] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x01, 0xfc, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0x06, 0x03, 0x3f, 0x00,
0x04, 0x01, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x04, 0x01, 0x38, 0x00, 0x04, 0x01, 0x00, 0x00,
0x04, 0x01, 0x00, 0x00, 0x04, 0x01, 0x3f, 0x00, 0x04, 0x01, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00,
0x04, 0x71, 0x38, 0x00, 0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x3f, 0x00,
0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x38, 0x00, 0x04, 0xf9, 0x00, 0x00,
0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x3e, 0x00, 0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x00, 0x00,
0x0c, 0xf9, 0x80, 0x00, 0x18, 0xf8, 0xc0, 0x00, 0x11, 0xfc, 0x40, 0x00, 0x33, 0xfe, 0x60, 0x00,
0x23, 0xfe, 0x20, 0x00, 0x67, 0xff, 0x30, 0x00, 0x47, 0xff, 0x10, 0x00, 0x67, 0xff, 0x30, 0x00,
0x23, 0xfe, 0x20, 0x00, 0x31, 0xfc, 0x60, 0x00, 0x10, 0xf8, 0x40, 0x00, 0x18, 0x70, 0xc0, 0x00,
0x0e, 0x03, 0x80, 0x00, 0x03, 0x8e, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
// ========================
// Initialisation programme
// ========================
void setup() {
// Initialisation du DHT22;
dht.begin();
// Initialisation de l'écran OLED
if(!ecranOLED.begin(SSD1306_SWITCHCAPVCC, adresseI2CecranOLED))
while(1); // Arrêt du programme (boucle infinie) si échec d'initialisation de l'écran OLED
// Affichage du texte de démarrage
ecranOLED.clearDisplay(); // Vidange du buffer de l'écran OLED
ecranOLED.setTextSize(1); // Sélection de facteur 1:1 pour le facteur de grossissement du texte
ecranOLED.setTextColor(WHITE); // Couleur "blanche" (ou colorée, si votre afficheur monochrome est bleu, jaune, ou bleu/jaune)
ecranOLED.setCursor(15,35); // Positionnement du "curseur invisible" de l'écran OLED, en position x=15 (axe horizontal), et y=35 (axe vertical)
ecranOLED.setFont(&Tahu16pt7b); // Sélection de la police "Tahu"
ecranOLED.println("Bonjour !"); // …et affichage du message de bienvenue
ecranOLED.display();
delay(3000); // On laisse le mot "Bonjour !" affiché 3 secondes à l'écran, avant d'attaquer la boucle principale
}
// ======================================
// Boucle principale (boucle perpétuelle)
// ======================================
void loop() {
// Récupération des infos température/hygrométrie, auprès du capteur DHT22
recupInfosTemperatureEtHygrometrie();
// Affichage de la température (+ pause de quelques secondes)
affichageTemperature();
delay(delaiAlternanceAffichageTemperaturePuisHygrometrie);
// Affichage de l'hygrométrie (+ pause de quelques secondes)
affichageHygrometrie();
delay(delaiAlternanceAffichageTemperaturePuisHygrometrie);
// ... et répétition à l'infini !
}
// ========================================================
// Section : récupération des infos température/hygrométrie
// ========================================================
void recupInfosTemperatureEtHygrometrie() {
// Lecture des données (interrogation du capteur DHT22 par l'Arduino)
float tauxHumidite = dht.readHumidity(); // Lecture du taux d'humidité (en %)
float temperatureEnDegreCelsius = dht.readTemperature(); // Lecture de la température, exprimée en degrés Celsius
// Vérification si données bien reçues
if (isnan(tauxHumidite) || isnan(temperatureEnDegreCelsius)) { // Si aucune valeur correcte n'est retournée par le capteur DHT22, on met
mesureCorrectementEffectuee = false; // à "faux" la variable "mesureCorrectementEffectuee", pour ensuite faire afficher
} // le sigle "--" sur l'écran OLED (indiquant qu'aucune valeur n'a pu être relevée)
else
{ // Sauvegarde de ces valeurs mesurées, pour affichage ultérieur
valeurHumidite = round(tauxHumidite); // Arrondi à la valeur entière la plus proche
valeurTemperatureEnDegreCelsius = round(temperatureEnDegreCelsius)-1; // Arrondi à la valeur entière la plus proche (auquel j'ai enlevé 1°C, pour compenser la mise en boitier)
mesureCorrectementEffectuee = true; // … et on mémorise le fait que la mesure s'est bien passée
}
}
// =====================================
// Section : affichage de la température
// =====================================
void affichageTemperature() {
// Affichage du symbole "thermomètre" à l'écran
ecranOLED.clearDisplay(); // Effaçage de la mémoire tampon de l'écran OLED
ecranOLED.drawBitmap(
8, // Alignement de la gauche de l'image à 8 pixels du côté gauche de l'écran
20, // Alignement du haut de l'image à 20 pixels du haut de l'écran (pour être dans la partie bleue, et non la jaune)
monImageThermometreMercure, // Chargement de l'image "thermomètre"
largeurImageAafficher,
hauteurImageAafficher,
1);
// Titre
ecranOLED.setFont(&BebasNeue11pt7b); // Sélection de la police "Bebas Neue", taille 11pt
ecranOLED.setTextSize(1);
ecranOLED.setTextColor(WHITE);
ecranOLED.setCursor(15,15); // Positionnement du texte en x=15, et y=15 pixels
ecranOLED.print("TEMPERATURE"); // Et affichage du mot "TEMPERATURE"
// Valeur
ecranOLED.setFont(); // Re-sélection de la police de caractère par défaut, de la librairie Adafruit
ecranOLED.setTextSize(3);
ecranOLED.setTextColor(WHITE);
if(valeurTemperatureEnDegreCelsius<0)
ecranOLED.setCursor(40,30); // x, y (48,30) si valeur de t° avec 2 chiffres, et (40,30) pour valeur à 3 chiffres (ou t° négative)
else
ecranOLED.setCursor(48,30);
if(mesureCorrectementEffectuee == false)
ecranOLED.print("--"); // Si problème de lecture au niveau du DHT22, affichage du symbole "--"
else
ecranOLED.print(valeurTemperatureEnDegreCelsius); // Si aucun pb au niveau du DHT22, affichage de la valeur de température mesurée
ecranOLED.setTextSize(2);
ecranOLED.print((char)247); // Appelle le symbole ressemblant au sigle degré "°", car ce dernier n'existe pas vraiment dans cette police de caractère
ecranOLED.setTextSize(3); // (d'où le changement de tailles de texte (taille 3 -> taille 2 -> taille 3), pour tricher un peu !
ecranOLED.print("C");
ecranOLED.display(); // Transfert de la mémoire tampon à l'écran, pour affichage de tout ça !
}
// ======================================
// Section : affichage du taux d'humidité
// ======================================
void affichageHygrometrie() {
// Affichage du symbole "goutte d'eau" à l'écran
ecranOLED.clearDisplay(); // Effaçage de la mémoire tampon de l'écran OLED
ecranOLED.drawBitmap(
16, // Alignement de la gauche de l'image à 8 pixels du côté gauche de l'écran
20, // Alignement du haut de l'image à 20 pixels du haut de l'écran (pour être dans la partie bleue, et non la jaune)
monImageGoutteEauPse, // Chargement de l'image "goutte d'eau"
largeurImageAafficher,
hauteurImageAafficher,
1);
// Titre
ecranOLED.setFont(&BebasNeue11pt7b); // Sélection de la police "Bebas Neue", taille 11pt
ecranOLED.setTextSize(1);
ecranOLED.setTextColor(WHITE);
ecranOLED.setCursor(18,15); // Positionnement du texte en x=18, et y=15 pixels
ecranOLED.print("HYGROMETRIE"); // Et affichage du mot "HYGROMETRIE"
// Valeur
ecranOLED.setFont(); // Re-sélection de la police de caractère par défaut, de la librairie Adafruit
ecranOLED.setTextSize(3);
ecranOLED.setTextColor(WHITE);
if(valeurHumidite==100)
ecranOLED.setCursor(46,30); // x, y (56,30) si valeur d'hygrométrie sur 2 chiffres, ou (46,30) si valeur sur 3 chiffres (par ex : "100" %)
else
ecranOLED.setCursor(56,30);
if(mesureCorrectementEffectuee == false)
ecranOLED.print("--"); // Si problème de lecture au niveau du DHT22, affichage du symbole "--"
else
ecranOLED.print(valeurHumidite); // Si aucun pb au niveau du DHT22, affichage de la valeur du taux d'humidité mesuré
ecranOLED.print("%");
ecranOLED.display(); // Transfert de la mémoire tampon de l'ODED à l'écran, pour affichage
}
Nota : j’ai essayé de mettre un maximum de commentaires dans le code, afin que vous puissiez avoir une meilleure compréhension possible de chaque ligne de ce programme. Cela étant dit, n’hésitez pas également à prendre du recul, et analyser toutes ces lignes de code « bloc par bloc », et non ligne par ligne. Ainsi, la compréhension sera facilitée !
Bon… je crois que nous avons fait le tour de ce projet, aussi bien concernant la partie matérielle, que logicielle ! Maintenant, passons à la réalisation physique de ce thermomètre arduino, ainsi que de sa mise en boitier, imprimé en 3D !
Fabrication et montage en boitier
Tout d’abord, un rapide coup d’œil sur le PCB à fabriquer, vu côté composants :
Au passage, vous trouverez en fin d’article le fichier « Gerber » permettant de réaliser ce circuit imprimé (ou plutôt, vous permettant de le faire faire réaliser par un fabricant de PCB). À noter qu’il s’agit là d’un simple PCB monocouche à double face. Côté composant (le « dessus ») vous trouverez un plan de masse. Et côté soudures (à « l’arrière »), vous retrouverez toutes les pistes cuivrées.
Cela étant dit, vous vous demanderez peut-être pourquoi j’ai positionné tel ou tel composant électronique de telle ou telle manière. Du coup, je vous glisse quelques explications ici, à ce sujet. En fait :
- La place au centre reste volontairement libre afin de laisser passer les fils et connecteur de l’alimentation externe, une fois le boitier refermé ; cet écartement sert également à distancier au possible l’arduino et le capteur de température, pour que ce dernier ne soit pas trop influencé par le dégagement de chaleur du microcontrôleur.
- Les bornes de connexion de l’écran OLED ont été positionnés en avant du PCB, afin de faciliter le montage en boitier (comme vous le verrez un peu plus loin, en image)
- Le capteur DHT22 est implanté juste en arrière des ouïes de ventilation du boitier, afin de bien capter la température et humidité ambiante, sans toutefois varier trop rapidement (cela créé un peu d’inertie, afin de stabiliser les mesures). Ce capteur est d’ailleurs mis à l’opposé de l’Arduino Nano, afin que ses mesures ne soient pas « trop » faussées par ce dernier, comme évoqué précédemment.
- Et l’Arduino Nano a été placé de telle manière que sa prise USB se retrouve à l’arrière du PCB, afin de pouvoir reprogrammer facilement son arduino, au besoin, sans avoir à tout démonter (il suffira juste de déclipser l’arrière du boitier, en fait)
Ceci étant dit, passons maintenant aux soudures et à l’assemblage complet de ce thermomètre arduino !
Soudure des composants
Voici comment ont été soudés et positionnés les composants de ce thermomètre arduino au niveau du PCB, vu sous différents angles :
Comme vous le constaterez, l’Arduino et le DHT22 sont montés sur support débrochable, afin de pouvoir les sortir au besoin. L’alim sera quant à elle branchée sur le connecteur blanc, doté d’un détrompeur, afin d’éviter les risques d’inversion de polarité (même si cela n’est pas vraiment nécessaire, dans l’absolu, puisqu’une diode anti-retour a été mise en œuvre dans ce montage). Enfin, l’écran OLED a lui aussi ses broches de connexion, car déporté du circuit imprimé (connexion via fils dupont, comme visible un peu plus loin).
À noter ici que tous les composants sont « traversants ». Il n’y a donc aucun CMS à souder.
Mise en place du connecteur d’alimentation externe
Avant d’aller plus loin, il sera nécessaire de mettre en place le connecteur d’alimentation DC Ø5,5 de part et d’autre du couvercle du thermomètre arduino. Voici comment cela se présente, en photos :
Si vous refaites ce montage, n’oubliez surtout pas de mettre en place l’écrou de fixation du connecteur DC « autour des fils », avant toute soudure. De même, n’oubliez pas de glisser des bouts de gaine thermorétractable sur chacun des fils, si vous souhaitez faire de belles finitions 😉
Important : ATTENTION à la polarité du connecteur DC en lui même. Car, tel que présenté sur la 4ème photo ci-dessus, il faut que vous câbliez les éléments de telle manière que :
– le fil rouge correspond à la « tige métallique » centrale de l’embase DC
– le fil noir correspond à la « bague métallique » externe de l’embase DC
À ce stade, je vous recommande d’ailleurs de bien vérifier vos sens de raccordements avec un multimètre, afin de vous assurer que tout soit bien câblé ! Et ce, AVANT soudure de quoi que ce soit 😉
Raccordement écran OLED, avec mise en boitier
Maintenant, passons à l’afficheur OLED ! Pour commencer, il s’agira de brancher 4 fils dupont (longueur 10cm, type femelle/femelle) sur l’arrière de l’écran oled. Une fois fait, il faudra ensuite insérer cet afficheur dans le boitier imprimé en 3D, « en forçant » légèrement (car j’ai conçu ce boitier 3D afin qu’il n’y ait besoin d’aucune vis, les pièces électroniques étant maintenues serrées, par friction ; cela étant dit, rien ne vous empêche de mettre un point de colle, si avez peur qu’il tombe !). Un aperçu de tout ça, en images :
Nota : faites bien attention de ne pas vous tromper dans le sens de montage de l’écran OLED, et des fils de connexion dupont. Au moindre doute, n’hésitez pas à vous référer aux photos suivantes, pour éviter de commettre la moindre erreur 😉
Montage de l’Arduino Nano, et du capteur DHT22
Histoire de compléter notre montage, nous pouvons à présent ajouter l’Arduino Nano sur son support (en veillant bien à mettre le côté du connecteur USB dans le bon sens), ainsi que le capteur de t° et hygrométrie DHT22. D’ailleurs, voici quelques autres photos prises à la volée, vous montrant leurs implantations respectives, sous divers angles :
Cela étant fait, nous allons pouvoir commencer à finaliser ce thermomètre arduino !
Raccordements finaux, et glissement du circuit imprimé dans le boitier
À présent, nous avons presque fini de monter le tout. Car il ne reste plus qu’à brancher les fils dupont de l’écran OLED sur le PCB, ainsi que le connecteur d’alimentation, et glisser le circuit imprimé dans son logement. Pour ce faire, une glissière a été créée dans le modèle d’impression 3d, afin de pouvoir maintenir le PCB en place, dans le bas du boitier. À noter que le glissement est quelque peu étroit, et va vous obliger à forcer un peu sur le pcb pour le mettre en place (ce qui est parfaitement normal, et nécessaire pour maintenir le circuit imprimé en place, pour ne pas qu’il bouge ensuite). Voici ce que cela donne, en couleur :
Remarque : vous avez là une « superbe » vue d’ensemble des composants. Profitez-en pour vérifier que vous ayez bien respecté leurs sens de branchement respectifs !
Fermeture du boitier, et branchement du bloc d’alimentation externe
Dernière étape : la fermeture du boitier. Ici, il s’agit d’un boitier conçu pour se refermer par simple « clipsage ». Il n’y a donc pas la moindre vis à mettre. Du reste, il ne vous restera plus qu’à brancher le cordon du bloc d’alimentation externe (7,5V/1A, dans ce projet), tel que visible sur les images ci-dessous :
Voilà ! Nous voici arrivé au terme du montage de ce thermomètre arduino. Maintenant, place à la mise sous tension, et aux essais !
Essais et remarques
Les essais sont en fait rapides à faire, car il n’y a, pour ainsi dire, rien à faire ! En somme : on branche, … et ça tourne tout seul !
En fait, une fois mis sous tension, vous devriez voir s’afficher :
- Un message de bienvenue
- Et en boucle : tantôt l’affichage de la température mesurée, tantôt l’affichage du taux d’humidité mesuré
À noter qu’en cas de problème de récupération d’infos au niveau de la sonde de température / hygrométrie, la valeur « — » s’affichera à la place des chiffres.
Du reste, voici deux photos de l’écran OLED en gros plan, prises de mon côté :
Au passage, je vous prie de bien vouloir m’excuser de ne pas avoir pu vous mettre plus de photos ici, mais la fréquence de rafraîchissement de l’afficheur OLED m’a empêché de prendre des photos correctes (que ce soit via mon téléphone, ou via mon appareil photo, car ils ne sont pas suffisamment paramétrables). Je suis donc désolé de ne pouvoir vous mettre plus de photos ici, faute de mieux !
Par contre, histoire de bien souligner le fait que ce projet n’est pas parfait, j’aurais quelques remarques critiques à vous partager (même si l’intérêt premier de ce thermomètre arduino n’était pas d’être parfait, je vous l’accorde !). En fait, en synthèse, je dirais que :
- La précision de ce thermomètre arduino est quelque peu relative, du fait que la chaleur dégagée par l’Arduino Nano, au sein même du boitier 3d, va forcément quelque peu fausser les mesures de la sonde DHT22. C’est d’ailleurs pourquoi j’ai retiré un degré à chaque mesure de température, dans le programme arduino, avant affichage.
- L’impression 3D n’est pas une œuvre d’art en soi, même si elle se révèle simple et fonctionnelle à la fois, sans requérir la moindre vis. Par ailleurs, les parties emboitées risquent de prendre du jeu avec le temps, si manipulées trop souvent.
- La taille de l’écran OLED est trop petite pour une lecture de loin. En fait, sa taille est adaptée pour une lecture de près, dans le cas où, par exemple, vous poseriez ce thermomètre arduino sur votre bureau de travail, à portée de main. Sinon, l’écriture se révèlera quelque peu petite pour vos yeux, très probablement !
- L’absence de « trou » permettant de pouvoir programmer l’arduino directement, depuis l’extérieur du boitier, vous obligera à ouvrir ce dernier pour toute modif du programme. Cela étant dit, comme vous n’aurez certainement jamais besoin de retoucher au code de programmation, cela n’est pas vraiment un souci en soi, me direz-vous 😉
Voilà ! Comme ça, tout est dit !
Liens utiles et téléchargements
Si vous êtes intéressé par la reproduction de ce projet chez vous, voici tous les fichiers qui vous seront nécessaires :
- Le schéma électronique de ce thermomètre arduino (format PDF)
- Le programme arduino au complet, avec ses fichiers connexes (format ZIP)
- Le dossier de fabrication au format Gerber, pour faire fabriquer le circuit imprimé PCB à l’identique (fichier ZIP)
- Les fichiers sources du boitier 3D, au format FreeCAD (logiciel gratuit), si vous souhaitez apporter des modifications au boitier en lui-même (fichier ZIP)
- Les modèles d’impression 3D au format STL, pour pouvoir imprimer ce boitier avec une imprimante 3D (fichier ZIP)
Et la liste des composants électroniques nécessaires :
- 1 x embase à souder DC Ø5,5 (ext) et Ø2,1 (int), avec écrou (pour raccordement alim externe)
- 1 x connecteur JST 2 fils de 100mm (pour alim PCB depuis embase DC)
- 1 x diode schottky 1N5817, au format DO41
- 1 x condensateur électrolytique 100µF 16V
- 1 x arduino nano V3 (microcontrôleur ATmega328P)
- 1 x écran OLED jaune/bleu 0,96″ i2c 128×64 pixels (attention : bien prendre un modèle I2C, c’est à dire comportant des broches SDA/SCL ; au passage : si vous optez pour une autre marque, vous devrez sûrement adapter le modèle d’impression 3d, car toutes les dimensions ne sont pas les mêmes, d’un fabricant à l’autre)
- 1 x capteur DHT22 monté sur PCB (avec ses composants additionnels intégrés)
- 1 x support 3 broches femelles, au pas de 2,54 mm (pour surélévation capteur DHT22)
- 2 x supports 15 broches femelles, au pas de 2,54mm (pour surélévation Arduino Nano)
- 1 x support 4 broches mâles, au pas de 2,54 mm (pour branchement nappe écran OLED)
- 1 x nappe de fils dupont femelle/femelle, longueur 10 cm (besoin de 4 fils de cette nappe, pour ce projet)
- 1 x alim externe 7,5V/1A DC Ø5.5, munie d’une fiche DC de Ø5,5mm extérieur, et Ø2.1/2.5mm intérieur (prise EU, si vous êtes en France)
- Et de la gaine thermorétractable, multi diamètres, afin de protéger les soudures au niveau des fils de connexion
Conclusion
J’espère que ce projet vous aura plu, ou tout du moins, aura su vous inspirer ou vous permettre d’apprendre de nouvelles choses, notamment au niveau de la mise en œuvre pratique des capteurs type DHT22 et écrans OLED i2c à contrôleur SSD1306. Aussi, n’hésitez pas à laisser vos remarques et questions en commentaires, au besoin !
Du reste, si ce genre de réalisation vous plait, n’hésitez pas également à le me dire dans la zone commentaire ! En attendant, je continuerai bien sûr à vous publier un maximum d’articles et tutos, mais dans la limite du temps dont je dispose, bien entendu 😉
Voilà pour aujourd’hui ! Il ne me reste plus qu’à vous dire « à la prochaine » !
Jérôme.
À découvrir aussi : réalisation d’un coupleur d’accus 18650 au lithium-ion
(*) Mis à jour le 16/01/2024
Wawwwww !
J’ai regardé toute tes réalisations, et c’est plus que complet. Bravo !
Je suis entrain d’installer deux Led 10W (9-11 volts 20000K) sur un véhicule télécommandé. J’ai acheté un Système de commutateur LED de commande pour RC Car (Tension d’entrée : 5–24 V, actuel : 5 A courant d’appel : 10 A). Je n’arrive pas à contrôler ces 2 LED avec mon Flysky FS-16X.
Peut-être un tuto pour un système de contrôle de LED serait intéressant.
Salutations
Georges
Salut Georges !
J’aimerai bien, mais malheureusement, je manque cruellement de temps. En tout cas, je me note ça pour plus tard, si jamais un jour je trouve du temps 😉
Désolé de ne pouvoir t’aider plus que ça, pour l’instant…
Jérôme.
Bravo pour cet article.
Le code est vraiment clair et facile à comprendre pour un bricoleur comme moi.
Je vais m’en inspirer pour créer une petite balance à partir d’une jauge d’effort.
Merci !
De rien, au plaisir !
Et bon courage à toi, pour ton projet 😉
Jérôme.
Bravo pour ce projet de A à Z, depuis la conception de la carte PCB jusqu’au packaging. L’exposé est très clair avec des explications bien détaillées, aussi bien au niveau électronique que programmation. Merci pour cette publication.
De rien, c’est avec plaisir !
Bonjour Jérôme
J’ai découvert ce site il y a peu de temps. Je le trouve très intéressant et de plus des explications très précises, c’est super. Je vais réaliser d’ici peu ce thermomètre mais à la différence, le pcb sera en gravure anglaise. Je suis également en train de construire un petit blog afin de publier ces créations.
Bonne continuation
Eric
Super ! Amuse-toi bien alors !
Bonjour
J’ai fait le montage sur une plaque Breadboard.
Cela marche à part que je n’ai aucune données du capteur, seulement des traits. J’utilise un DHT11, est-ce que ça pourrait venir de là ? Ayant plusieurs de ces capteurs j’ai fait l’essai mais rien n’a changé. Stp, pourrais-tu m’en dire plus ?
En te remerciant
@+
Aurais-tu par hasard un compte sur discord afin que l’on puisse mieux discuter ?
Bonsoir Eric !
Basiquement, cela devrait marcher. Car le DHT11 a le même brochage que le DHT22, sauf erreur de ma part, et sa tension d’alimentation est à peu de chose près la même. En fait, la « seule » différence entre ces deux capteurs, c’est que le DHT 11 est carrément moins précis, et a des plages de mesure plus restreintes.
Mais j’y pense … as-tu bien adapté la ligne « #define typeDeDHT DHT22 » du programme arduino ? Car là, si tu utilises un DHT 11 à la place d’un DHT 22, il faut le spécifier dans cette ligne de code !
H.S. : non, je n’ai aucun compte discord
Bonne soirée à toi.
Jérôme.
Jérôme
Merci pour la ligne à modifier, j’avais zappé. Tout est nickel et je te félicite pour ce projet qui est super. Je pensais remplacer l’alimentation par des piles afin de ne pas avoir un fil à la patte mais elles risquent de ne pas durer longtemps.
Par contre les mesures sont des entières, est-ce possible d’ajouter des décimales afin d’avoir plus précis ?
Je vais tout de même acheter des dht22.
Bonne soirée également
Eric
Salut !
Oui, les piles, c’est pas top ! C’est pour ça que j’ai préféré mettre une petite alim extérieure.
Côté dixièmes de degrés, je les avais mis de côté dans ce projet, car la place sur l’écran est vraiment réduite. Mais si tu veux le faire, il faudrait changé plusieurs choses dans le programme, qui n’a pas été prévu pour ça (à commencer par la variable « valeurTemperatureEnDegreCelsius » qui faudrait passer du format INT à FLOAT, puis utiliser une police d’affichage plus petite sur l’écran ou gérer les espacements différemment, etc). En tout cas, je te laisse bosser dessus, faute de temps de mon côté 😉
Bon courage à toi.
Jérôme.
Jérôme bonjour,
Merci pour ces articles rédigés en vrai français !
Projet : Thermomètre Arduino
J’ai fait les branchements sur carte la “arduino uno” et écran Oled et DHT22 pas de problème. Après avoir lu attentivement les articles sur l’écran Oled et sur la réalisation de ce projet je n’y arrive pas. Le code me pose trois problèmes :
1 L’IDE me retourne “Tahu16pt7b.h: No such file or directory” ??
2 Dans le convertisseur “truetype2gfx” lorsque l’on indique dans “Font Size” 16 points la police qui en ressort est “Tahu__216pt7b.h” !!
3 À quel endroit doit-on mettre les nouvelles Fonts récupérées dont la Font “Tahu” ?
Je travaille sur iMac avec l’IDE 1.8.13
Merci de votre réponse
Salut Pierre !
Alors, concernant tes 3 problèmes :
1) Si l’IDE te retourne le message « No such file or directory » au niveau de la directive d’inclusion de la police de caractère, c’est que celle-ci n’a pas pu être trouvée, à l’endroit attendu. Il faut donc que tu mettes le bon fichier, au bon endroit ! Sous windows, cela se traduit par le fait de mettre le fichier « .h » de la « font convertie » dans le même répertoire que le script arduino (extension « .ino »). J’imagine que sous Mac ce doit être pareil 😉
2) Si le convertisseur « truetype2gfx » te retourne un nom de fichier différent, ce n’est pas grave en soi. Car tu peux soit le renommer en « Tahu16pt7b.h » et le mettre dans le répertoire où se trouve ton script arduino, soit lui laisser ce nom là et modifier légèrement ton code (en mettant par exemple #include « Tahu__216pt7b.h » à la place de #include « Tahu16pt7b.h », dans ton cas).
3) En fait, le fichier « .ttf » de la font récupérée sert uniquement de « matière première » au niveau du convertisseur en ligne « truetype2gfx ». Et le fichier « .h » retourné par le convertisseur sera, quant à lui, celui qui nous intéresse ; il sera à mettre dans le même répertoire que le script arduino, comme évoqué précédemment.
Voilà, en espérant avoir pu t’aider, malgré mon ignorance totale du monde Mac …
Bon courage à toi,
Jerome.
J’ai pris un réel plaisir à lire ton projet étant donné que moi même aussi je travaille sur un projet similaire. Je me suis un peu basé sur ton projet afin de peaufiner le mien.
Bonjour,
Je débute en Arduino, et je souhaitais réaliser votre structure. Hélas lors de la compilation j’ai des messages d’erreur concernant les polices de caractères, elles sont impossible à trouver. Pouvez-vous m’indiquer, simplement, comment résoudre ce grave souci, surtout que j’ai déjà investi dans le matériel.
Dans l’attente de vous lire,
Cordialement,
EVE Alain
Salut Alain !
Pour t’aider, télécharge simplement le fichier ZIP nommé « Le programme arduino au complet », disponible dans le paragraphe 8 (« Liens utiles et téléchargements »). Ensuite il te suffira de dézipper ce fichier, pour te retrouver avec un répertoire contenant le programme arduino en lui-même, accompagné des fichiers qu’il semble te manquer.
En dehors de ces fichiers de police de caractères, il faudra aussi installer les bibliothèques « SSD1306 » et « DHT » dans ton IDE Arduino (si cela n’a jamais été fait dans le passé), afin de pouvoir compiler correctement le programme.
Voilà ! En espérant avoir pu t’aider.
Bien à toi,
Jérôme.
Afin de filtrer au maximum les messages de type "spam" ou "inappropriés", chaque commentaire est soumis à modération, et validé manuellement. Du coup, il se peut que certains commentaires ne soient pas publiés, ou sinon, avec un peu de retard. Par ailleurs, j'ai malheureusement plus de messages à traiter que de temps pour y répondre ; c'est pourquoi je ne pourrais pas répondre à tout le monde. Désolé …