Hello,

Dans les 5 chapitres précédents, nous avons réussi à reproduire toutes les fonctions de l’Aquila, à savoir :

• Gestion de la lampe
• Gestion des moteurs Pas à Pas
• Gestion du capteur de basses
• Gestion des DIP Switchs
• Gestion du signal DMX

« Ah bah c’est bon t’as fini alors ! »

Heu… Non 🙂 Car je souhaite rajouter quelques fonctions de sécurité. Pour rappel, l’Aquila dispose à l’origine d’une lampe halogène ELC 250W. Ce type de lampe chauffe beaucoup, mais à vrai dire c’est prévu pour 😉

Cependant, là je remplace la lampe halogène par une LED de 100W, et elle nécessite beaucoup plus d’attention car elle est très sensible aux hautes températures. De surcroit, contrairement à notre lampe halogène ELC 250W, il est très compliqué de la remplacer.

Donc pour éviter de la griller, on va surveiller sa température. On va voir comment on peut faire.

Capteurs de température

Dès qu’on parle de collecter une donnée variable dans le temps, dans notre cas la température, il existe deux grandes familles de capteurs :

• Analogique
• Numérique

Je vais vous présenter deux exemples de capteurs compatibles avec notre Arduino.

Le DS18B20

Le DS18B20 est un capteur numérique, que l’on retrouve sous forme de composant à souder ou bien sous forme étanche.

La DS18B20 utilise un bus 1-wire et peut donc être câblé en parallèle avec plusieurs autres sondes sur un seul fil. Pratique !

Chaque DS18B20 possède un numéro de série unique sur le bus 1-Wire, gravé à la fabrication dans le composant.

Si vous voulez plus d’infos et pleins d’exemples de code pour Arduino, vous pouvez visiter cette page.

Les thermistances

Il s’agit de capteurs analogiques agissants comme des résistances « variables », dont le facteur de variation est la température.

Il en existe deux types :

• les CTN (NTC en anglais) : signifie « coefficient de température négatif ». Autrement dit, plus la température augmente, plus la résistance diminue
• les CTP (PTC en anglais) : signifie « coefficient de température positif ». Autrement dit, plus la température augmente, plus la résistance augmente.

Une thermistance est défini par son coefficient de variation B ainsi que par sa résistance nominale à température ambiante (25°C).

Cas concret pour l’Aquila

Choix du capteur

Pour mon besoin, je n’ai pas la nécessité d’avoir des sondes aussi précises, c’est pourquoi je vais concentrer la suite de mon article sur les thermistances.

Je dispose de thermistances CTN référencées : NTC MF52-103/3435. On peut se référer à la datasheet, mais tout est déjà écrit dans la ref :

• 103 : c’est la valeur de la résistance à 25°C. La lecture se fait comme pour certains condensateurs, c’est à dire qu’on prend les 2 premiers chiffres, suivi du nombre de zéros, ce qui nous donne « 10 » suivi de 3 zéros ==> 10000 ==> 10kΩ
• 3435 : c’est la valeur du coefficient B

Montage

Un Arduino ne sachant lire en analogique que des tensions, on va monter un « pont diviseur de tension ». Pour simplifier, on va prendre une résistance avec une valeur identique à la résistance nominale.

On applique la loi des mailles puis la loi d’Ohm sur notre pont diviseur. La tension au point milieu sera de : Ur1 = U * (R2 / (R1 + R2))

Avec ce montage, on a une tension qui sera :

• De 2,5V si la température ambiante est de 25°C (car les 2 résistances en série ayant une résistance identique, la tension au point milieu est divisée par 2)
• Inférieure à 2,5V si la température ambiante est supérieure à 25°C
• Supérieure à 2,5V si la température ambiante est inférieure à 25°C

Calcul de la résistance de la CTN

Première chose à savoir, AnalogRead() retourne la valeur d’une tension. Elle n’est pas exprimée en Volts, mais cela n’empêche pas d’appliquer la loi d’ohm. Donc inutile de convertir notre valeur (entre 0 et 1023) en volts.

Pour commencer nos calculs, voici les valeurs que nous connaissons dans le schéma (R1 est la CTN, R2 est la résistance fixe)

• Ur1 = C’est la valeur retournée par AnalogRead(0)
• R2 = 10000 Ω
• U total = C’est la valeur maximale retournable par AnalogRead(0), à savoir 1023

Dans un circuit en série, l’intensité est la même en tout point du circuit. De ce fait, l’intensité traversant R1 et R2 est la même. On sait aussi grâce à la loi d’Ohm (U = R * i) que la tension et la résistance sont proportionnelles.

Pour trouver R1, notre CTN, on va donc appliquer une proportionnalité avec R2.

Le calcul est simple : ratio = 1023 / AnalogRead(0)

Ensuite, grâce à ce ratio, on va pouvoir calculer la valeur de R1 : R1 = 10000 / (ratio – 1)

La formule de calcul ainsi exprimée pour Arduino est :

// Calcul intensité
float ratio = 1023 / AnalogRead(0);
int ntcRes = bridgeRes / (ratio - 1)

Et si on veut optimiser le code :

int ntcRes = bridgeRes / ((1023 / AnalogRead(0)) - 1)

Calcul de la température à partir de la résistance de la CTN

Il existe une formule permettant de convertir la résistance électrique d’un semi-conducteur en température. C’est la relation de Steinhart-Hart.

Bon… comme je suis nul en maths, j’ai utilisé mon ami Google pour trouver un code tout fait, et j’ai retenu celui-là 😉

float steinhart;
steinhart = average / THERMISTORNOMINAL; // (R/Ro) 
steinhart = log(steinhart); // ln(R/Ro) 
steinhart /= BCOEFFICIENT; // 1/B * ln(R/Ro) 
steinhart += 1.0 / (TEMPERATURENOMINAL + 273.15); // + (1/To) 
steinhart = 1.0 / steinhart; // Invert 
steinhart -= 273.15; // convert to C

Et au final ça donne quoi ?

Voici un exemple de code :

void setup() {
 Serial.begin(9600);
}

int readTemperatureSensor(byte ntcPin, long ntcResNominal, int ntcTempNominal, int ntcBCoeff, long ntcBridgeRes) {

 // Convert AnalogRead to Ohms
 long ntcRes = ntcBridgeRes / ((1023 / analogRead(ntcPin)) - 1);

 // Steinhart-Hart Algorithmn (Ohms to Temperature)
 float steinhart;
 // (R/Ro)
 steinhart = ntcRes / ntcResNominal;
 // ln(R/Ro)
 steinhart = log(steinhart); 
 // 1/B * ln(R/Ro)
 steinhart /= ntcBCoeff; 
 // + (1/To) (in Kelvins)
 steinhart += 1.0 / (ntcTempNominal + 273.15); 
 // Invert
 steinhart = 1.0 / steinhart; 
 // convert to C
 steinhart -= 273.15; 

 return (int)steinhart;
}

void loop() {
 Serial.println(readTemperatureSensor(0, 10000, 25, 3435, 10000));
 delay(1000); 
}

Et si on veut optimiser ?

La conversion avec la relation de Steinhart-Hart n’a d’intérêt que si on veut convertir une tension en résistance, puis une résistance en degrés celcius.

Dans le cas de l’Aquila, on peut se contenter de traiter uniquement un seuil retourné par AnalogRead(). Si ce seuil descend en dessous de 20, par exemple, c’est que la LED est trop chaude, et dans ce cas on déclenche les fonctions de sécurité. Cela simplifie grandement le code et libère de la CPU. Deux façons de faire :

• Si le paramètre est fixe, il suffit de calculer le seuil à la main, et de le rentrer en dur dans le logiciel de l’Arduino. Si AnalogRead() est inférieur au seuil, alors la lampe est trop chaude.
• Si le paramètre est réglable, il suffit de coder une fonction convertissant les degrés en « volts », et de mémoriser la valeur résultante.

Si on fait les calculs à la main, on voit que, pour cette CTN, une température > à 60°C générera une valeur AnalogRead() inférieure à 58.

Vous pouvez vous référer a ce calculateur Excel, de mon cru : Calculateur-CTN.xlsx (1234 téléchargements)

Et voila, vous savez maintenant comment lire la résistance d’une CTN avec un Arduino. On va donc pouvoir surveiller la température du radiateur de la LED de puissance et la désactiver si celle-ci grimpe trop en température.

La suite au prochain épisode !