Méthode : Obtenir la valeur de la température
Le signal permettant de calculer la température est lu sur l'entrée analogique de l'Arduino A0.
Si une variable signal a été déclarée dans le programme, l'instruction signal=analogRead(A0); y affecte une valeur entière comprise entre 0 et 1023 en fonction de la valeur de la tension appliquée à l'entrée analogique A0 (entre 0 et 5 V).
Pour obtenir la valeur de la tension et en déduire la température, on utilise les instructions ci-dessous :
tension = signal * 5.0 / 1023.0;//Obtention de la tension à partir du signal lu sur A0
tempK = tension * 100.0;//Conversion de la tension en température exprimée en kelvin
tempC = tension * 100 - 273.15;//Conversion des kelvins en celsius
Les variables tension, tempK et tempC doivent être déclarées en début de programme en tant que décimaux (type float).
Méthode : Affichage sur le moniteur série
La platine Arduino ne possède pas d'écran. Même s'il est possible d'en connecter un, on peut se contenter dans un premier temps d'utiliser le moniteur série.
Si l'Arduino est connecté à l'ordinateur par son câble USB, il peut envoyer des données sur le moniteur série, qui est une fenêtre d'affichage accessible en cliquant sur dans la fenêtre du logiciel de programmation de l'Arduino.
Pour utiliser le moniteur série en tant qu'afficheur, les trois instructions de la bibliothèque dédiée sont :
Serial.begin(9600); pour initialiser la communication avec le moniteur série.
Serial.print(variable ou texte entre " "); pour afficher la valeur d'une variable ou du texte.
Serial.println(variable ou texte entre " "); comme précédemment mais avec un retour à la ligne.
Le code ci-dessous permet l'utilisation du capteur de température LM335Z avec un affichage sur le moniteur série.
//On commence par déclarer les variables
float tension;
float tempC;
float tempK;
//Fin de la déclaration des variables
void setup() {
// put your setup code here, to run once:
Serial.begin(9600); //Initialisation de la communication avec le moniteur série
}
void loop() {
// put your main code here, to run repeatedly:
tension = analogRead(A0) * 5.0 / 1023.0; //Lecture de la tension sur l'entrée analogique A0
tempK = tension * 100.0;//Conversion de la tension en température exprimée en kelvin
tempC = tension * 100 - 273.15;//Conversion des kelvins en celsius
Serial.print(tempK);//Affiche la valeur de la température en kelvins
Serial.println(" K");
Serial.print(tempC);//Affiche la valeur de la température en degrés Celsius
Serial.println("°C");
delay(3000);//On fait une mesure toutes les 3 secondes
}
Méthode : Sur un écran LCD
L'écran LCD 2 lignes - 16 colonnes utilisé ici est le moins onéreux. Il est un peu fastidieux à câbler et mobilise beaucoup de ports E/S numériques.
On retient le câblage suivant :
Borne de l'écran | Pin Arduino / Breadboard |
---|---|
1 | Masse |
2 | +5V |
3 | Curseur du potentiomètre |
4 | Pin 12 |
5 | Masse |
6 | Pin 11 |
11 | Pin 5 |
12 | Pin 4 |
13 | Pin 3 |
14 | Pin 2 |
15 | \(R=1\ k\Omega\) -------- +5V |
16 | Masse |
Afin de gérer l'affichage de messages sur l'écran, des instructions spécifiques existent. Elles font partie d'une librairie qu'il est nécessaire d'intégrer au programme.
La librairie associée à notre écran LCD s'appelle LiquidCrystal.
On l'intègre dans un programme par l'instruction #include <LiquidCrystal.h> en tout début de programme, en même temps que la déclaration des variables (avant la procédure setup()).
Dans la même partie du programme, on déclare les bornes utilisées pour communiquer avec l'écran, en cohérence avec le câblage vu précédemment : LiquidCrystal lcd(12,11,5,4,3,2);
Initialisation de l'écran
Dans la boucle setup() : initialiser l'écran par la commande lcd.begin(16,2); (16 colonnes et 2 lignes).
Quelques instructions
lcd.clear(); efface l'ensemble de l'écran.
lcd.setCursor(colonne,ligne); place le curseur à un endroit précis de l'écran.
lcd.print("Le texte à afficher"); affiche la chaîne de caractères entre " " à partir du curseur.
lcd.print(var); affiche la valeur de la variable var à partir du curseur.
D'autres instructions existent, elles sont détaillées à la page suivante (en anglais) : https://www.arduino.cc/en/Reference/LiquidCrystal
Le code ci-dessous permet l'affichage sur l'écran LCD décrit plus haut.
//Cablage Ecran LCD :
//1 Masse
//2 +5V
//3 Potar
//4 pin 12
//5 Masse
//6 pin 11
//11 pin 5
//12 pin 4
//13 pin 3
//14 pin 2
//15 pin 1kOhm -> 5V
//16 Masse
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //Définit les bornes utilisées pour communiquer avec l'écran LCD
float TK, TC, V; //définition des variables Température en kelvin, en celsius et de la tension
void setup() {
// put your setup code here, to run once:
lcd.begin(16, 2); // Initialisation de l'écran
lcd.clear();//Efface l'écran LCD
}
void loop() {
// put your main code here, to run repeatedly:
V = analogRead(A0) * 5 / 1023.0; //Récupération de la tension sur l'entrée analogique A0
TK = V * 100.0; //Calcul de la température absolue
TC = TK - 273.15; //Conversion en °C
lcd.clear(); //on efface l'écran
lcd.setCursor(0, 0); // On place le curseur en haut à gauche de l'écran
//Affichage de la température en °C
lcd.print("T=");
lcd.print(TC);
lcd.write(223);//223 est le code du caractère °
lcd.print("C");
lcd.setCursor(0, 1); // On change de ligne
//Affichage de la température en K
lcd.print("T=");
lcd.print(TK);
lcd.print(" K");
delay(2000);//On fait une mesure toutes les deux secondes
}
Complément : Écran LCD avec module I2C
Il est possible de ne pas avoir à connecter 12 broches de l'écran LCD en lui adjoignant un module I2C. On trouve l'ensemble déjà soudé comme sur les photographies ci-contre.
Seules quatre broches sont alors nécessaires :
Vcc pour le +5V
GND à la masse
SCL sur l'entrée analogique A5 de la carte Arduino
SDA sur l'entrée analogique A4 de la carte Arduino
Le potentiomètre du module I2C (en bleu sur la photographie) permet d'ajuster le contraste de l'écran.
L'utilisation de ce type de module LCD nécessite une bibliothèque dédiée. Vous pouvez la récupérer en cliquant sur ce lien : LiquidCrystal_I2C.zip. Sa compatibilité a été testée avec les cartes Arduino Uno Rev 3 et l'IDE en version 1.8.8. Il s'agit d'une version modifiée de ce qui est téléchargeable sur le site DFRobot afin de corriger un bug d'affichage (seule la première lettre d'un mot s'affiche).
Pour ajouter la bibliothèque à l'environnement de programmation
Lancer Arduino IDE, puis cliquer sur Croquis -> Inclure une bibliothèque -> Ajouter la bibliothèque .ZIP.
Pour inclure les bibliothèques dans le programme
Deux bibliothèques sont nécessaires pour faire fonctionner ce type d'affichage. On les inclut par les deux lignes suivantes dans la zone de déclaration des variables (en début de code) :
Dans cette même zone du code (avant setup() et loop()), on déclare l'écran LCD avec son adresse de communication, son nombre de colonnes et de lignes :
LiquidCrystal_I2C lcd(0x20, 16, 2); //Pour une adresse de communication 0x20 et un écran 16 colonnes, 2 ligne
Affichage de la température sur un écran LCD I2C
Le code ci-dessous permet l'affichage de la température sur un écran LCD avec module de communication I2C.
//Libraries
//Déclaration de l'écran LCD I2C à l'adresse 0x20
LiquidCrystal_I2C lcd(0x20, 16, 2);
float tension;
float tempC;
float tempK;
void setup() {
// put your setup code here, to run once:
lcd.init();//Initialisation de l'écran LCD
lcd.backlight();//Allumage du rétroéclairage
}
void loop() {
// put your main code here, to run repeatedly:
tension = analogRead(A0) * 5 / 1023.0;//Lecture de la tension sur l'entrée analogique A0
tempK = tension * 100.0;//Conversion de la tension en température exprimée en kelvin
tempC = tempK - 273.15;//Conversion des kelvins en celsius
lcd.clear();//On efface l'écran
lcd.setCursor(0, 0);//On place le curseur à l'origine (coin supérieur gauche)
lcd.print(tempC);//On affiche la valeur de la température en celsius.
lcd.print(" ");
lcd.write(223);//Affichage du symbole degré
lcd.print("C");
lcd.setCursor(0, 1);//On passe à la ligne suivante
lcd.print(tempK);
lcd.print(" K");
delay(2000);//On actualise la température toutes les 2 secondes
}
Complément : Connaître l'adresse de communication du port I2C de l'écran
Pour vérifier l'adresse de communication du bus I2C utilisé par l'écran, on peut utiliser le programme suivant avec l'écran connecté à la carte Arduino.
Le moniteur série affiche les adresses des interfaces I2C détectées.
// --------------------------------------
// i2c_scanner
//
// Version 1
// This program (or code that looks like it)
// can be found in many places.
// For example on the Arduino.cc forum.
// The original author is not know.
// Version 2, Juni 2012, Using Arduino 1.0.1
// Adapted to be as simple as possible by Arduino.cc user Krodal
// Version 3, Feb 26 2013
// V3 by louarnold
// Version 4, March 3, 2013, Using Arduino 1.0.3
// by Arduino.cc user Krodal.
// Changes by louarnold removed.
// Scanning addresses changed from 0...127 to 1...119,
// according to the i2c scanner by Nick Gammon
// http://www.gammon.com.au/forum/?id=10896
// Version 5, March 28, 2013
// As version 4, but address scans now to 127.
// A sensor seems to use address 120.
// Version 6, November 27, 2015.
// Added waiting for the Leonardo serial communication.
//
//
// This sketch tests the standard 7-bit addresses
// Devices with higher bit address might not be seen properly.
//
void setup()
{
Wire.begin();
Serial.begin(9600);
while (!Serial); // Leonardo: wait for serial monitor
Serial.println("\nI2C Scanner");
}
void loop()
{
byte error, address;
int nDevices;
Serial.println("Scanning...");
nDevices = 0;
for(address = 1; address < 127; address++ )
{
// The i2c_scanner uses the return value of
// the Write.endTransmisstion to see if
// a device did acknowledge to the address.
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
Serial.print("I2C device found at address 0x");
if (address<16)
Serial.print("0");
Serial.print(address,HEX);
Serial.println(" !");
nDevices++;
}
else if (error==4)
{
Serial.print("Unknown error at address 0x");
if (address<16)
Serial.print("0");
Serial.println(address,HEX);
}
}
if (nDevices == 0)
Serial.println("No I2C devices found\n");
else
Serial.println("done\n");
delay(5000); // wait 5 seconds for next scan
}