Avec un Arduino Uno, vous pouvez construire pour trois fois rien toutes sortes de projets vraiment soignés. Par exemple ce simple enregistreur de température circadiennes. Le logiciel gère l'ensemble des opérations sans recours à des bibliothèques externes.

Cet enregistreur mesure la température tout au long de la journée et affiche les valeurs de mesure sur un écran graphique. Lorsqu'une nouvelle mesure vient s'ajouter, la courbe affichée est décalée d'un pixel vers la gauche, la plus ancienne valeur disparaît et la nouvelle apparaît à droite. L'intervalle de mesure est facile à modifier de manière à pouvoir saisir des variations de température rapides, par ex. lors de processus de régulation.

Le schéma (fig. 1) montre que ce petit enregistreur n’est composé que de trois modules (accompagnés d'une pincée de composants passifs).

Capteur de température programmable

Le capteur DS1631 mesure la température entre −55 °C et +125 °C, avec une erreur de ±0,5 °C dans la plage de 0 à 70 °C. La valeur de mesure est stockée dans un registre avec une résolution de 9 à 12 bits (au choix de l'utilisateur), où elle peut être lue. Acceptant une tension d'alimentation comprise entre 3,0 et 5,0 V, ce capteur est compatible avec une multitude de microcontrôleurs. Caractéristique de moins en moins courante à notre époque, il est disponible non seulement en boîtier CMS, mais aussi en boîtier DIP.

Le DS1631, dont l’adresse est programmable par les broches A0 à A2, communique avec le contrôleur par le bus I²C. Le circuit interne du capteur (fig. 2) comprend des registres de configuration dans lesquels le contrôleur écrit et un registre de température à lecture seule, dans lequel le contrôleur vient lire la température mesurée. Le capteur est interrogé en permanence par l'enregistreur Arduino avec une résolution de 12 bits.
 

Les registres T_H et T_L servent à programmer une hystérésis pour utiliser le DS1631 comme thermostat (avec sa broche de sortie T_OUT). Toutefois cette fonction n'est pas mise en œuvre par notre enregistreur.

Un afficheur compatible

De nos jours, il est habituel d'interfacer les afficheurs graphiques par un bus (I²C ou SPI). Comme le capteur de température est équipé d'un bus I²C et ne consomme que trois broches de l'Arduino, il reste suffisamment de broches pour une connexion en parallèle de l'afficheur. Ça n'a pas d'avantage ni d'inconvénient, on économise juste quelques centimes.

Vous trouverez des afficheurs appropriés de 128×64 pixels chez de nombreux fabricants (Vishay, Lumex, Winstar...), proposés à moins de 10 € sur eBay et compagnie. La taille et la couleur sont laissées à votre goût. Vous devez juste veiller à ce que le brochage – il en existe différentes variantes – soit compatible (voir le tableau ci-dessous).
 

L'écran graphique affiche (fig. 3) 108 valeurs de températures consécutives, représentées dans un système de coordonnées. Si les 108 valeurs sont uniformément réparties sur 24 h, cela correspond à une résolution d'une mesure toutes les 800 s, soit un peu moins d'un quart d'heure. La température courante est affichée en haut, à droite.

Le centre de calcul

Le troisième composant, l'Arduino Nano, déclenche les mesures de température, lit les valeurs et les convertit en positions de pixels sur l'afficheur.

Croquis sans bibliothèques

Dès le premier coup d'œil sur le croquis largement commenté [1], on s'aperçoit qu'il n'est fait appel à aucune bibliothèque externe. Toutes les opérations de lecture et d'écriture, aussi bien du capteur que de l'afficheur sont effectuées avec les seuls moyens mis à disposition par l'EDI Arduino.

Les fonctions les plus importantes se trouvent à la fin du croquis. Les initialisations du contrôleur, du capteur de température et de l'afficheur sont effectuées dans la fonction setup. Dans la fonction principale loop, et après activation par le cadenceur (meas_flag==1), on procède à la lecture des données du capteur de température (read_temp), ensuite on en déduit la valeur de mesure de la température (cal_temp). Si la limite inférieure (−23 °C) ou supérieure (+40 °C) d'affichage de la température est franchie, la variable est mise à zéro. On calcule ensuite les graduations de l'axe des ordonnées (cal_measval), puis les différentes valeurs nécessaires à l'affichage de la nouvelle valeur de mesure (set_meas(measval)), avec lesquelles on rafraîchit l'afficheur. On prépare l'affichage de la mesure suivante en décalant les pixels représentatifs des valeurs de température d'un pixel vers la gauche, ce qui fait disparaître la mesure la plus ancienne.

Le cadencement est effectué par la routine de traitement des interruptions, tout à la fin du croquis. On y règle l'intervalle de mesure à 800 s, de sorte que les 108 valeurs affichables soient parcourues en 108*800 s = 24 h. Pour le test du croquis, on peut raccourcir cet intervalle à 2 s par exemple.

Le pilotage du capteur se trouve également assez loin dans le croquis. On se sert du port matériel à deux fils du contrôleur (A4 pour SDA et A5 pour SCL). L'écriture du registre de configuration a lieu dans la fonction write_to_config. Avec TWDR=0xAC, on accède au registre de configuration et avec TWDR=0x0C, on passe dans le mode 12 bits permanent. Ensuite, la fonction start_convert démarre le processus de mesure (TWDR=0x51).

La fonction read_temp va lire successivement les deux octets du registre contenant la valeur courante de la température (TWCR=0x84) et les écrit dans les variables temph et templ. Ensuite, la fonction cal_temp convertit ces valeurs en une valeur flottante signée, rangée dans temp.

Les 64 lignes horizontales de la matrice à 128×64 pixels de l'afficheur sont divisées en une échelle de −23 à +40 °C, les 128 colonnes verticales en 19 pixels pour l'affichage de l'échelle de température et 109 pixels pour la courbe de température. L'afficheur est géré par un pilote de segment pour la moitié gauche (CS1) et un autre pour la moitié droite (CS2), chacun divisé en huit pages empilées de 64×8 bits chacune.

Petit survol du programme

Le tableau num[11][5] indique la façon de représenter les chiffres utilisés pour afficher la température courante au haut et à droite sur l'afficheur, c'est-à-dire quels pixels doivent être noirs. L'ensemble du contenu de l'afficheur est stocké dans le tableau dmask[8][128], pour pouvoir rafraîchir l'affichage après décalage vers la gauche des valeurs de mesure à chaque nouvelle acquisition.

Il y a encore les fonctions de pilotage de l'afficheur : set_ytics et set_ylabels dessinent les axes avec les graduations de l'échelle de température ; shift_left décale la courbe de température d'un pixel vers la gauche ; set_meas évalue la date et la position où la nouvelle valeur de mesure doit être écrite dans dmask ; load_qdisp rafraîchit l'afficheur avec le contenu de ce tableau. Enfin, load_num affiche la température courante sous forme numérique en haut et à droite, sous réserve que la courbe de mesure n'y passe pas (sinon, cet affichage est décalé vers le bas).

Le microgiciel commenté est disponible au téléchargement ci-dessous et sur la page web du projet sur le site d'Elektor. 

(180022-03 – version française : Helmut Müller)

► Elektor est réputé pour la qualité de son contenu.

► En voulez-vous davantage ?

► Abonnez-vous maintenant au magazine Elektor et ne manquez plus jamais ni aucun de ces articles précieux ni aucun de ces projets géniaux.