Thermistance NTC 3950 100K : Utilisation avec Arduino et Comparaison avec le Capteur DHT22

Thermistance NTC 3950, un composant électronique souvent méconnu, trouve sa place prépondérante dans le monde de la mesure de température et donc surtout sur le domaine de l’impression 3D. Parmi les différentes options disponibles, la thermistance NTC 3950 100K se distingue par sa fiabilité et ses performances avancées. Dans cet article, nous explorerons comment utiliser ce capteur en tandem avec une carte Arduino, en passant en revue les principes théoriques, la configuration matérielle, et les résultats de nos expériences.

Introduction à la Thermistance

La thermistance, contraction de “thermique” et “résistance”, se positionne en tant que dispositif de détection de température, réagissant aux variations de résistance en fonction de la température. Par rapport aux thermocouples, les thermistances offrent des avantages , tels que leur précision accrue, leur temps de réponse réduit, et leur coût abordable. Elles s’imposent donc comme le choix intelligent et pratique pour la mesure de température jusqu’à 300 degrés Celsius.

Dans notre cas, nous nous pencherons sur la thermistance NTC (Coefficient de Température Négatif) 3950 100K ohms, dont la résistance diminue à mesure que la température augmente. Les NTC thermistances sont couramment utilisées dans des produits commerciaux fonctionnant dans une plage de température de quelques dizaines de degrés, tels que les thermostats, les grille-pain, voire les imprimantes 3D. Notre modèle présente une résistance de 100 kOhms à 25 degrés Celsius.

Liste des Pièces pour l’Expérience

Avant de plonger dans les détails de l’utilisation de la thermistance NTC 3950 100K, assurons-nous d’avoir tous les composants nécessaires pour notre expérience. Voici une liste des pièces requises :

• Thermistance NTC 3950 100K ohms
• Carte Arduino UNO
• Capteur de Température DHT22 – Ce capteur nous permettra de comparer les résultats obtenus avec la thermistance.
• Résistances 220 kOhms et 10 kOhms – Nous en aurons besoin pour construire notre diviseur de tension.
• Platine d’essai (Breadboard)
• Condensateur 10uF – Pour réduire le bruit sur les mesures de la thermistance.
• Fils de Connexion (Jumper Wires)

Mesure de la Résistance avec un Diviseur de Tension

Arduino est équipé d’un convertisseur analogique-numérique (CAN) 10 bits qui mesure les valeurs de tension. Comme notre thermistance fournit une résistance en sortie, nous devons établir une relation entre la résistance et la tension pour quantifier la variation de résistance en termes de tension. Cela peut être réalisé à l’aide d’un diviseur de tension, un circuit simple basé sur les lois de Kirchhoff.

En utilisant une tension de référence de 3,3V pour Arduino, nous avons conçu un diviseur de tension qui convertit efficacement la résistance de la thermistance en une tension mesurable. Cette conversion est cruciale pour notre expérience.

Sélection de la Résistance pour une Plage de Température Optimale

Le choix de la résistance R1 dans notre diviseur de tension est important pour obtenir des mesures précises dans une plage de température donnée. Nous avons calculé la valeur de R1 en fonction de la plage de température souhaitée. En fixant V0 à 3,3V, nous pouvons prédire la tension lue par Arduino en fonction de la température, grâce aux coefficients de l’équation de la thermistance fournis par le fabricant.

Nous avons créé des courbes de réponse de la tension du diviseur en fonction de la température pour différentes valeurs de R1. Cette étape de sélection de la résistance garantit que nos mesures sont précises dans la plage de température qui nous intéresse.

Expérience avec la Thermistance NTC 3950 100K et Arduino

Maintenant que nous avons établi une relation entre la tension lue par Arduino et la température mesurée par la thermistance, ainsi que sélectionné la résistance R1 appropriée, passons à l’expérience pratique.

Câblage du Circuit

Avant de commencer à collecter des données, il est essentiel de configurer correctement le circuit. Nous avons choisi d’utiliser une référence de tension externe de 3,3V pour Arduino, car la tension de sortie de la thermistance est généralement comprise entre 1,5V et 3,3V dans notre plage de température d’intérêt. De plus, cela réduit le bruit sur les mesures de la thermistance.

Un condensateur de 10uF a été ajouté entre les broches 3,3V et GND pour atténuer davantage le bruit et assurer des lectures plus stables. Voici le schéma de câblage est relativement simple, mais il est essentiel de respecter les connexions pour garantir la précision des mesures :

Code Arduino

Pour obtenir des lectures de température à partir de la thermistance NTC 3950 100K, nous avons écrit un code Arduino spécifique. Ce code prend en compte les coefficients obtenus grâce à la calibration de la thermistance et les utilise pour calculer la température à partir de la tension mesurée.

Nous avons inclus une boucle qui effectue la lecture analogique de la tension sur la broche A0 (où nous avons connecté notre diviseur de tension) et effectue ensuite le calcul de la température en utilisant l’équation de la thermistance. Pour améliorer la stabilité des mesures, nous avons effectué une moyenne sur 10 lectures successives de la tension.

#include <math.h>

#define therm_pin A0
float T_approx;

float V_0 = 3,3; // référence de tension

// première valeur de résistance pour le diviseur de tension
float R_1 = 220000,0;
// coefficients d'ajustement
float a = 283786,2;
float b = 0,06593;
float c = 49886,0;

int avg_size = 10; // taille de la moyenne

void setup() {
  // initialiser la communication série à 9600 bits par seconde :
  Serial.begin(9600);
  pinMode(therm_pin, INPUT);

  // définir la référence analogique pour lire la broche AREF
  analogReference(EXTERNAL);
}

void loop() {
  
  // parcourir plusieurs valeurs pour réduire le bruit
  float T_sum = 0,0;
  for (int ii; ii < avg_size; ii++){
    // lire l'entrée sur la broche analogique 0 :

    int sensorValue = analogRead(therm_pin);

    // Convertir la lecture analogique (qui va de 0 à 1023) en référence de tension (3,3 V ou 5 V ou autre) :
    float voltage = (sensorValue / 1023,0) * V_0;

    // c'est ici que se fait la conversion de la thermistance en fonction des paramètres d'ajustement
    T_sum += (-1,0 / b) * (log(((R_1 * voltage) / (a * (V_0 - voltage))) - (c / a)));
  }
  
  // valeurs moyennes de la boucle
  T_approx = T_sum / float(avg_size);

  // lecture en degrés Celsius et Fahrenheit
  Serial.print("Température : ");
  Serial.print(T_approx);
  Serial.print(" (");
  Serial.print((T_approx * (9,0 / 5,0)) + 32,0);
  Serial.println(" F)");
  
  delay(500);
}

Le code affiche ensuite la température en degrés Celsius et Fahrenheit sur le moniteur série d’Arduino. En ajustant la valeur de “avg_size” dans le code, vous pouvez modifier le nombre de lectures moyennées en fonction de vos besoins en stabilité. Et voici l’Effet de lissage du condensateur sur l’ADC pour la lecture de la thermistance :

Comparaison avec le Capteur DHT22

Pour évaluer les performances de notre thermistance NTC 3950 100K, nous avons décidé de la comparer avec un capteur de température bien connu, le DHT22. Le DHT22 est un capteur d’humidité et de température couramment utilisé avec Arduino.

Nous avons câblé à la fois la thermistance et le DHT22 à notre Arduino pour collecter des données simultanées. Cela nous a permis de comparer les lectures de température des deux capteurs et d’analyser leurs performances respectives. Voici le schéma de câblage :

Code Arduino pour accompagner la comparaison DHT22 et thermistance NTC 3950

#include <math.h>
#include <SimpleDHT.h>

#define therm_pin A0 // Broche pour le capteur de thermistance
#define pinDHT22 2   // Broche pour le capteur DHT22

float T_approx;       // Stockage de la température approximative

float V_0 = 3.3;      // Tension de référence
float R_1 = 220000.0; // Résistance de la thermistance
float a = 283786.2;   // Paramètre a de l'équation de Steinhart-Hart
float b = 0.06593;    // Paramètre b de l'équation de Steinhart-Hart
float c = 49886.0;    // Paramètre c de l'équation de Steinhart-Hart

int avg_size = 50;    // Nombre d'échantillons pour la moyenne

SimpleDHT22 dht22;     // Création d'une instance pour le capteur DHT22

void setup() {
  // Initialisation de la communication série à 9600 bits par seconde :
  Serial.begin(9600);
  pinMode(therm_pin, INPUT);
  analogReference(EXTERNAL); // Utilisation de la référence de tension externe
}

// La routine de boucle s'exécute en boucle indéfiniment :
void loop() {
  float T_sum = 0.0;
  for (int ii; ii < avg_size; ii++) {
    // Lire l'entrée sur la broche analogique 0 :
    int sensorValue = analogRead(therm_pin);
    // Convertir la lecture analogique (qui va de 0 à 1023) en tension de référence (3.3V ou 5V ou autre) :
    float voltage = (sensorValue / 1023.0) * V_0;

    T_sum += (-1.0 / b) * (log(((R_1 * voltage) / (a * (V_0 - voltage))) - (c / a)));
  }

  T_approx = T_sum / float(avg_size);
  
  Serial.print("Thermistance : ");
  Serial.print(T_approx);
  Serial.print(" (");
  Serial.print((T_approx * (9.0 / 5.0)) + 32.0);
  Serial.println(" °F)");

  float temperature = 0;
  dht22.read2(pinDHT22, &temperature, NULL, NULL);
  Serial.print("DHT22 : ");
  Serial.print((float)temperature); Serial.println(" °C, ");

  Serial.print("Différence : ");
  Serial.print(temperature - T_approx);
  Serial.println(" °C");
  delay(500);
}

Résultats et Comparaison

Nos expériences ont révélé des résultats intéressants. En moyenne, la différence de température entre la thermistance NTC 3950 100K et le DHT22 varie de 0,05°C à 1,5°C, en fonction de la température réelle. Cette variation peut être attribuée à plusieurs facteurs.

Tout d’abord, l’ADC d’Arduino, malgré l’utilisation d’un condensateur et d’une référence de tension externe, présente une certaine quantité de bruit, ce qui peut affecter la précision des mesures. De plus, l’équation de la thermistance comporte une certaine marge d’erreur, donc pour des mesures extrêmement précises, une interpolation spécifique à chaque température serait nécessaire.

En outre, le capteur DHT22 lui-même comporte une erreur de ±0,5°C, ce qui signifie que les erreurs entre les deux capteurs peuvent atteindre jusqu’à 2°C. Dans l’ensemble, la différence de 0,5°C que nous avons observée entre les deux capteurs est tout à fait acceptable compte tenu de ces facteurs.

Avantages de la Thermistance

Lorsque nous examinons les données recueillies lors d’une variation rapide de la température, la thermistance NTC 3950 100K brille par sa réactivité. Contrairement au DHT22, qui met un certain temps à fournir une lecture stable, la thermistance peut suivre rapidement les variations de température. Cela en fait un choix idéal pour des environnements où les températures fluctuent rapidement et où une mesure précise est essentielle.

Conclusion

Capteur de Thermistance NTC 3950 100Kohms associée à Arduino offre une solution efficace et précise pour la mesure de température. Son utilisation permet de réaliser des mesures fiables dans des environnements à température variable, tout en offrant une réactivité exceptionnelle. Pour les projets électroniques nécessitant une surveillance de la température, la thermistance NTC 3950 100K s’impose comme un outil essentiel, offrant simplicité d’utilisation et des résultats remarquables.

Lien outilles

1. Téléchargement de Arduino logiciel “Arduino IDE ” : https://www.arduino.cc/en/software
2. Pour plus d’articles : https://www.moussasoft.com/tutoriels-electroniques
3. Twitter: Moussa Lhoussaine (@Moussasoft_com) / Twitter

Arduino – Home

Hamza Bouhouch

Plus de publications

• Hamza Bouhouch

  https://www.moussasoft.com/author/hamzabouhouch

  IoT en Pleine Croissance : Aeris Communications Répond à la Demande de Télématique Automobile
• Hamza Bouhouch

  https://www.moussasoft.com/author/hamzabouhouch

  SparkFun dévoile son Dernier Pilote de Moteur IoT Brushless
• Hamza Bouhouch

  https://www.moussasoft.com/author/hamzabouhouch

  L'IoT et la Connectivité par Satellite : Une Synergie de Données Sans Frontières
• Hamza Bouhouch

  https://www.moussasoft.com/author/hamzabouhouch

  Comment utiliser L293D Pilote de moteur avec Arduino