Fabriquer un appareil de mesure de la température et de l’humidité, qui affiche les valeurs sur un écran couleur (la couleur change en fonction de la chaleur ou du froid qu’il fait). Grâce à la carte microcontrôleur Arduino Uno et le module d’extension Grove, c’est possible !
Projet idéal pour les débutants avec des connaissances préalables en programmation
Durée : env. 1,5 heure
Budget : env. 70 euros
Matériel nécessaire : 1 carte Arduino Uno rév. 3, 1 module Arduino Shield – Base Shield V2 (Grove Base-Shield), 1 écran Grove LCD avec rétro-éclairage RVB, 1 capteur de température et d’humidité Arduino Grove Pro (précis), 1 câble USB 2.0 haut débit A-St sur B-St d’1 mètre
Éléments nécessaires au fonctionnement : connexion Internet, ordinateur avec navigateur, alimentation électrique pour la carte Arduino
Matériel
1. Carte Arduino Uno rév. 3
La carte microcontrôleur Arduino Uno dispose de tout ce dont vous avez besoin pour réaliser un projet de microcontrôleur, sans pour autant exiger de connaissances importantes en électronique. Elle offre également une multitude de possibilités pour les projets exigeants.La programmation s’effectue par le biais d’une interface USB, qui sert aussi d’interface série pour la sortie des données. L’alimentation est fournie par un bloc d’alimentation ou des piles de 9 à 12 V (faire attention à la polarité : Plus vers l’intérieur, Moins vers l’extérieur) ou par un connecteur USB.
2. Module Grove Base Shield
Le capteur de température et d’humidité et l’écran proviennent du module d’extension Grove qui permet un développement simple et rapide. Le Grove Base Shield est simplement enfiché sur la carte Arduino et met à disposition quatre connecteurs analogiques, huit connecteurs numériques ainsi que quatre connecteurs I²C sous la forme d’un système de connexion unitaire.
La LED de statut et le bouton de réinitialisation de la carte Arduino se retrouvent masqués et se situent donc encore une fois sur le Base Shield.
Important : le commutateur de tension sur le module Grove Base Shield doit être réglé sur 5 V pour une carte Arduino !
3. Capteur de température et d’humidité
Ici, vous allez utiliser un « capteur de température et d’humidité Grove Pro », qui, basé sur un capteur DHT22, sert à mesurer la température avec une précision de ±0,5°C et l’humidité relative avec ±2 %. Ce capteur nécessite un connecteur analogique. Pour ce projet, il s’agit du connecteur A0.
4. Écran
L’« écran Grove LCD avec rétro-éclairage RVB » comporte deux lignes de 16 signes chacune et permet de définir ses propres signes. La couleur d’arrière-plan est réglable.
L’écran nécessite un connecteur I²C. Comme il s’agit d’un système de bus avec I²C, peu importe lequel est utilisé.
Logiciel
Arduino Studio
L’Arduino Studio est l’environnement de développement pour l’Arduino. Le programme y sera créé (à savoir les « Sketches ») et chargé dans l’Arduino. En outre, on peut avoir accès aux interfaces sérielles qui sont fournies par le biais du port USB.
Arduino Studio est disponible gratuitement sur la page Web Arduino : https://www.arduino.cc/en/Main/Software
Une fois l’Arduino connecté au PC, veuillez sélectionner « Outils » → « Port » puis « Arduino/Genuino » dans le menu, afin que la connexion à l’Arduino fonctionne.
Bibliothèques
Afin d’utiliser les modules individuels Shields et Grove, il est nécessaire de mettre à disposition les bibliothèques correspondantes aux interfaces de programmation. La bibliothèque pour le module SD-Shield est déjà disponible par défaut, il est en revanche nécessaire de l’installer pour les deux modules Grove :
Capteur de température et d’humidité Grove Pro
Téléchargement : https://github.com/Seeed-Studio/Grove_Temperature_And_Humidity_Sensor/archive/master.zip
Documentation : http://wiki.seeed.cc/Grove-Temperature_and_Humidity_Sensor_Pro/
Écran LCD RVB Grove
Téléchargement : https://github.com/Seeed-Studio/Grove_LCD_RGB_Backlight/archive/master.zip
Documentation : http://wiki.seeed.cc/Grove-LCD_RGB_Backlight/
Téléchargez les bibliothèques, puis les installer à l’aide du menu « Sketch » → « Intégrer la bibliothèque » → « Ajouter les bibliothèques .ZIP… ».
Vous trouverez des exemples de programmes correspondants pour l’ensemble des bibliothèques sous « Fichier » → « Exemples ».
Premier programme : lire les valeurs du capteur
Nous commençons par un programme, sur lequel seules les valeurs du capteur de température s’affichent sur les interfaces sérielles :#include<SPI.h>// Charger la bibliothèque pour les interfaces sérielles
#include<DHT.h>// Charger la bibliothèque pour le capteur
// Créer l’instance de l’interface du capteur.
// A0 est le connecteur sur le module Grove Base Shield, DHT22 est le type de capteur
DHT dht(A0, DHT22);
voidsetup() { // Est exécuté une fois au début
Serial.begin(9600); // Initialiser les interfaces sérielles
dht.begin(); // Initialiser le capteur
}
voidloop() { // Est exécuté dans une boucle infinie
floathumidity = dht.readHumidity(); // Lire les données
floattemperature = dht.readTemperature(); // Lire les données
if (isnan(temperature) || isnan(humidity)) { // La lecture a-t-elle fonctionné ?
Serial.println(« Erreur lors de la lecture sur le DHT ») ;
} else {
// Éditer les données
Serial.print(temperature);
Serial.print(" | ");
Serial.print(humidity);
Serial.println();
}
delay(1000); // Arrêter l’exécution du programme pendant 1 sec.
}
Chaque programme Arduino dispose de deux méthodes :
setup() est appelé une fois au démarrage du programme, ou lorsqu’il est exécuté pour la première fois sur l’Arduino, lorsque la touche « Reset » (réinitialisation) a été actionnée ou si la mise sous tension a été interrompue. Les appareils sont habituellement initialisés à ce stade.
loop() est appelé dans une boucle infinie, dès lors que la phase de setup (configuration) est terminée. La programmation logique a véritablement lieu à ce stade : les données sont lues par le capteur, on vérifie que la lecture a abouti et que les données sont écrites sur les interfaces sérielles. Le Delay est ce qui importe au final : à ce stade, la totalité de l’exécution est interrompue pendant 1 seconde, afin que l’on puisse encore lire la console sur le PC.
Le programme est structuré avec « Sketch » → « Contrôler/Compiler », afin qu’il puisse être écrit sur l’Arduino. Cela permet également d’obtenir des messages relatifs aux erreurs de programmation et aux problèmes potentiels. Il est possible qu’un avertissement s’affiche en rouge sur le statut d’Arduino Studio, lors de l’exécution de ce programme, car le NAN doit être redéfini… Cela provient de la bibliothèque du capteur de température et peut être ignoré.
Avec « Sketch » → « Télécharger », le programme est écrit sur l’Arduino, il est ainsi automatiquement structuré. Dans les menus « Outils » → « Moniteur série », une publication est alors inscrite :
26.10 | 64.50
26.20 | 64.50
26.20 | 64.50
Piloter l’écran
Afin d’effectuer les étapes initiales avec l’écran LCD, nous allons définir un exemple d’écran et un tableau avec la répartition des pixels pour un nouveau caractère. Dans setup(), ce caractère est ensuite enregistré à l’écran. Dans loop(), nous allons définir la couleur comme étant le rouge et nous allons écrire le texte avec le nouveau caractère à l’écran.#include <Wire.h>
#include <rgb_lcd.h>
rgb_lcdlcd; // Créer l’exemple des interfaces de l’écran
byte HEART_SYMBOL = 0; // Nom descriptif pour le symbole
byteheart[8] = { // La répartition des pixels individuels
0b00000,
0b01010,
0b11111,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000
};
voidsetup(){
lcd.begin(16, 2); // Initialiser l’écran : 2 lignes avec chacune 16 caractères
lcd.createChar(HEART_SYMBOL, heart); // Enregistrer le symbole cœur
}
voidloop() {
intred = 255;
intgreen = 0;
intblue = 0;
lcd.setRGB(red, green, blue);
lcd.setCursor(0, 0); // Mettre le curseur au début de la première ligne à l’écran
lcd.print("I ");
lcd.write(HEART_SYMBOL);
lcd.print(" Arduino");
lcd.setCursor(0, 1); // Mettre le curseur au début de la deuxième ligne à l’écran
lcd.print("===========");
}
Réécrire le programme avec « Sketch » → « Télécharger » sur l’Arduino. Les résultats s’affichent immédiatement à l’écran.
Programme final
Nous associons les deux programmes pour pouvoir afficher la température et l’humidité à l’écran. L’écran ne peut pas encore afficher de caractères, nous en définissons donc alors un similaire au cœur, issu du programme précédent.
Dans setup() l’interface sérielle, le capteur et l’écran sont initialisés et le nouveau symbole est enregistré à l’écran.
Dans loop() la température et l’humidité sont interrogées, la valeur de la couleur est calculée à partir de la température et tout s’affiche. Les formules sont sélectionnées de manière à ce que l’écran soit bleu intense, quand la température est égale ou inférieure à la valeur la plus froide et rouge intense lorsque la température est égale ou supérieure à la valeur la plus chaude. Lorsque la valeur verte reste à 0, le passage du bleu au rouge se fait par le violet. Si la transition se fait par le blanc et que l’écran n’est coloré qu’aux extrémités, alors on peut entrer en commentaire une formule alternative.
La méthode limite (floatcolor – couleur flottante) veille à ce que les valeurs de couleur restent dans la zone autorisée de 0.255 : si ce n’est pas le cas, les températures inférieures à la valeur la plus froide seront par exemple interprétées comme des valeurs de couleur négatives. La transformation d’un nombre à virgule flottant (float) en une valeur de couleur entière (int) s’effectue automatiquement, les décimales disparaissent.
#include<Wire.h>
#include<rgb_lcd.h>
#include<DHT.h>
rgb_lcdlcd;
DHT dht(A0, DHT22);
byte DEGREE_SYMBOL = 0;
bytedegree[8] = {
0b00000,
0b00010,
0b00101,
0b00010,
0b00000,
0b00000,
0b00000,
0b00000
};
voidsetup(){
Serial.begin(9600); // Initialiser la connexion sérielle
lcd.begin(16, 2); // Initialiser l’écran - 2 lignes avec 16 caractères chacune
lcd.createChar(DEGREE_SYMBOL, degree); // Enregistrer le nouveau symbole "°" à l’écran
dht.begin(); // Initialiser le capteur
}
voidloop() {
floathumidity = dht.readHumidity();
floattemperature = dht.readTemperature();
if (isnan(temperature) || isnan(humidity)) {
Serial.println(« Erreur à la lecture du capteur);
} else {
constfloatcoldest = 18;
constfloat hottest = 30;
intred = limit(255 * (temperature - coldest) / (hottest - coldest));
// Couleurs du bleu au rouge en passant par le violet
intgreen = 0;
// rouge et bleu plus on se rapproche des limites, blanc au milieu
// intgreen = limite(255 * sqrt(max(0, (–température la plus chaude)*(température la plus froide))) / (–la plus froide – la plus chaude));
intblue = limite(255 * (–température la plus chaude) / (–la plus froide – la plus chaude));
lcd.setRGB(rouge, vert, bleu);
lcd.setCursor(0, 0);
lcd.print("T: ");
lcd.print(temperature);
lcd.write(DEGREE_SYMBOL);
lcd.print("C");
lcd.setCursor(0, 1);
lcd.print("H: ");
lcd.print(humidity);
lcd.print("%");
}
delay(100);
}
floatlimit(floatcolor) { // Les valeurs de couleur doivent se situer dans la zone 0..255
if (color< 0) {
return 0;
}
elseif (color> 255) {
return 255;
}
else {
returncolor;
}
}
Amusez-vous bien !
Liste des pièces
| Quantité | Article | Prix unitaire | Total | URL |
| 1 | Arduino Uno Rev. 3 | 19,76 € | 19,76 € | https://www.reichelt.com/fr/fr/?ACTION=3;ARTICLE=119045;SEARCH=ARDUINO%20UNO |
| 1 | Module Arduino Shield – Base Shield V2 (Grove Base-Shield) | 10,78 € | 10,78 € | https://www.reichelt.com/fr/fr/?ACTION=3;ARTICLE=191204;SEARCH=ARD%20SHD%20BASE%20V2%20 |
| 1 | Écran LCD Grove avec rétroéclairage R-VB | 16,63 € | 16,63 € | https://www.reichelt.com/fr/fr/?ACTION=3;ARTICLE=191245;SEARCH=GRV%20LCD%20RGB |
| 1 | Capteur de température et d’humidité Arduino – Grove Pro (précis) | 17,33 € | 17,33€ | https://www.reichelt.com/fr/fr/?ACTION=3;ARTICLE=191250;SEARCH=GRV%20TEMP%20HUM%20PRO |
| 1 | Câble USB 2.0 haut débit A-St sur B-St, 1 mètre | 0,71 € | 0,71 € | https://www.reichelt.com/fr/fr/?ACTION=3;ARTICLE=45865;SEARCH=AK%20672/2-1,0 |
| 65,21 € | ||||
| Optionnel | ||||
| 1 | Alimentation électrique pour l’Arduino | 24,87 € | 24,87 € | https://www.reichelt.com/fr/fr/?ACTION=3;ARTICLE=87339;SEARCH=MW%203K10GS |
| Total | 90.08 € |
Alors que les volumes de données ne cessent d’augmenter, la taille des cartes mémoire diminue de plus en plus, tout comme leur prix. Les cartes micro SD (micro Secure Digital) font la taille d’un ongle, mais permettent de stocker d’énormes quantités de photos, vidéos, musiques et autres documents. Ces cartes au format micro sont disponibles dans diverses capacités de stockage et classes de vitesses.
Origines et usages des cartes micro SD
Les cartes micro SD, à l’instar des premières cartes SD, ont été développées par SanDisk, un fabricant de solutions de stockage. Dans un premier temps, elles avaient été baptisées TransFlash.
En 2005, la SD Card Association, une organisation internationale qui définit des standards en matière de cartes mémoire, a décidé de renommer ce support de stockage « micro SD ». Une carte micro SD mesure 11 millimètres sur 15. En raison de sa taille minuscule, elle constitue une extension de mémoire idéale pour les appareils mobiles, tels que smartphones ou tablettes. À titre d’exemple, les cartes SanDisk Ultra® microSDHC™ 16 Go et SanDisk Ultra® microSDHC™ 32 Go sont parfaites pour enregistrer et conserver des photos et vidéos souvenirs.
Le nombre figurant dans le nom indique la capacité de stockage de la carte. Dans cet exemple, 16 Go ou 32 Go. Les cartes micro SD peuvent également être utilisées dans les appareils photo numériques, les systèmes de navigation ou les lecteurs MP3. Il suffit d’un adaptateur pour insérer des cartes micro SD dans un logement prévu pour une carte SD.
Remarque : toutes les cartes micro SD présentées ici sont livrées avec un adaptateur.
Types de cartes micro SD disponibles
Il existe trois types de cartes micro SD sur le marché, qui se différencient par leur capacité de mémoire et leur système de fichiers. Leur désignation dépend d’ailleurs de leur capacité.
Les cartes micro SD ont une capacité de 2 Go et sont formatées selon le système FAT16.
Les cartes micro SDHC (Secure Digital High Capacity) ont une capacité allant de 4 à 32 Go et sont formatées selon le système FAT32.
Les cartes micro SDXC (Secure Digital Extended Capacity) offrent une capacité comprise entre 48 Go et 2 To. Elles utilisent le système exFAT. Les cartes SanDisk Ultra® microSDXC™ Ultra 64 Go et SanDisk® Ultra™ microSDXC™ 128 Go figurent dans cette catégorie. Avec une telle capacité de mémoire, elles donnent toute latitude pour enregistrer et stocker des photos haute résolution ou des vidéos Full HD.
Différentes classes de vitesses
Les cartes micro SD sont disponibles dans plusieurs classes de vitesses, subdivisées en « Speed Class » 2, 4, 6 ou 10. Plus le chiffre est élevé, plus la vitesse de transfert des données est importante.
Cette valeur indique en effet le taux de transfert minimal des données en Mo par seconde(Mo/s). Par conséquent, une carte de classe 4 fonctionne avec un taux de transfert d’au moins 4 Mo/s.
Pour les cartes SDHC et SDXC, il existe la norme UHS Speed Class (Ultra High Speed). Avec la variante UHS-I, les données sont transférées à une vitesse minimale de 10 Mo/s, alors qu’UHS-II affiche une vitesse d’au moins 30 Mo/s.
Remarque : la carte mémoire et le périphérique doivent tous les deux être compatibles avec cette spécification.
Si vous souhaitez jouer les pros et enregistrer des vidéos en Full HD et 4K Ultra HD, puis bénéficier d’une vitesse de transfert extrêmement élevée, il vous faut une carte SanDisk® Extreme PRO® microSDHC™ 32 Go UHS-I. Pour encore plus d’espace mémoire, essayez la SanDisk® Extreme PRO® microSDHC™ 128 Go UHS-I.
Outre les valeurs Speed Class et UHS Speed Class, la Video Speed Class (ou classe de vitesse vidéo) vous donne une autre indication de vitesse. Elle regroupe les niveaux V6, V10, V30, V60 et V90 et permet le transfert des données contenues dans les fichiers vidéo à une vitesse minimale de 90 Mo/s. Avec une classe de vitesse vidéo correspondant à V30, une carte mémoire comme la SanDisk® Extreme® microSDHC™ convient parfaitement à l’enregistrement de scènes à 360° et de vidéos en réalité virtuelle. Cette carte mémoire est disponible en 32 Go, 64 Go et 128 Go.
Parfois, les cartes micro SD font mention d’un facteur de vitesse, qui fournit des renseignements sur leur vitesse de lecture maximale. Cette valeur précise à quelle vitesse une carte micro SD lit des données par rapport à un lecteur CD. Ce chiffre est combiné au facteur x, à savoir la vitesse de lecture simple d’un lecteur CD (150 K/s). Un facteur de 1800x équivaut donc à une vitesse de lecture d’environ 270 Mo/s.
Conseils pour l’achat d’une carte micro SD
Avant de faire l’acquisition d’une carte micro SD, il convient de vérifier avec quel type de carte le périphérique est compatible. En effet, tous les appareils ne prennent pas en charge l’ensemble des capacités et des formats. Pour éviter de se tromper, il peut s’avérer utile de jeter un œil au manuel d’utilisation. Il faut aussi réfléchir à l’utilisation prévue de la carte.
Pour prendre des photos, les cartes portant la dénomination C10, U1 ou V10 sont amplement suffisantes. En revanche, pour tourner des vidéos en Full HD ou 4K, une carte avec une vitesse U3 ou V30 semble un bien meilleur choix. N’optez pour une carte UHS que si votre périphérique prend en charge cette spécification.
16 Go, 32 Go ou 128 Go ? On ne saurait avoir trop d’espace mémoire. Choisissez donc la capacité de stockage maximale dans la limite de vos moyens.
