Thermistance CTN (NTC) Arduino : câblage, Beta et Steinhart-Hart

Une thermistance CTN (NTC en anglais) est un capteur de température très bon marché, à deux pattes, dont la résistance diminue quand la température augmente. Pour utiliser une thermistance CTN avec Arduino, tu la branches avec une résistance fixe de 10 kΩ en pont diviseur de tension, tu lis le point milieu sur une broche analogique (A0), tu en déduis la résistance de la thermistance et tu la convertis en degrés Celsius avec l'équation Beta. Aucune bibliothèque n'est nécessaire, une seule broche analogique suffit et, bien montée, elle atteint une résolution de 0,1 °C à température ambiante. Le plateau et la buse des imprimantes 3D, les batteries de téléphones et d'ordinateurs portables, les climatiseurs, les réfrigérateurs et les thermomètres médicaux numériques mesurent eux aussi la température le plus souvent avec des thermistances CTN.

Dans cet article, tu vas apprendre pas à pas comment la résistance d'une thermistance CTN de 10 kΩ varie avec la température, comment câbler le pont diviseur et choisir la résistance fixe, l'équation Beta avec B = 3950, l'équation plus précise de Steinhart-Hart et l'étalonnage en trois points. Ensuite, tu fabriqueras un thermomètre avec un écran LCD I2C, tu referas la mesure avec l'ADC de l'ESP32 et du Raspberry Pi Pico, et tu verras la différence entre CTN et CTP, les applications dans les imprimantes 3D et les batteries, ainsi que les erreurs les plus fréquentes.

Qu'est-ce qu'une thermistance CTN et comment fonctionne-t-elle ?

Le mot thermistance vient de la contraction de "thermique" et "résistance" : c'est une résistance dont la valeur varie nettement avec la température. CTN signifie coefficient de température négatif (NTC, Negative Temperature Coefficient, en anglais). Elle est fabriquée dans une céramique semi-conductrice obtenue en cuisant (frittage) à haute température des oxydes métalliques comme le manganèse, le nickel et le cobalt. Quand le matériau chauffe, davantage de porteurs de charge participent à la conduction, donc la résistance baisse. La variation est importante : une CTN avec B = 3950 perd environ 4,4 % de sa résistance par degré autour de 25 °C. À titre de comparaison, une résistance à couche métallique ordinaire ne varie que de 50 à 100 ppm par degré, soit 0,005 à 0,01 %. Cette grande sensibilité fait de la CTN un capteur bon marché mais très réactif ; en contrepartie, la relation n'est pas linéaire.

Relation résistance-température : pourquoi n'est-elle pas linéaire ?

La résistance d'une CTN varie de façon exponentielle avec la température : elle chute très vite au froid et plus lentement au chaud. Le tableau ci-dessous donne la résistance d'une CTN de 10 kΩ et B = 3950 calculée avec l'équation Beta, ainsi que la tension et la valeur analogRead que tu liras sur la broche A0 de l'Arduino Uno lorsque cette CTN se trouve dans la branche haute d'un pont diviseur de 10 kΩ alimenté en 5 V (le câblage de la section suivante). La dernière colonne indique à combien de degrés correspond un pas de l'ADC, c'est-à-dire la résolution de la mesure. Les tables réelles des fabricants peuvent s'écarter de ces valeurs de quelques pour cent, surtout aux extrémités de la plage.

Ce tableau mène à deux conclusions importantes. D'abord, le pont diviseur est le plus sensible quand la résistance de la CTN est égale à la résistance fixe, ici vers 25 °C : à cet endroit, la tension sur A0 varie d'environ 55 mV par degré et même l'Uno, avec son ADC 10 bits, mesure par pas de 0,09 °C. C'est cinq fois mieux que le LM35, qui n'offre que 0,49 °C de résolution avec la référence de 5 V. Ensuite, plus tu t'éloignes de ce point, plus la résolution se dégrade : à 100 °C, un pas vaut 0,57 °C, et 1,2 °C à 125 °C. Choisis donc la résistance fixe proche de la résistance de la CTN à la température que tu mesureras le plus souvent. Pour que la tension sur A0 ait la plus grande excursion sur une plage donnée, la résistance fixe doit être la moyenne géométrique des résistances de la CTN aux deux bornes de la plage : pour 0–100 °C, √(33,6 kΩ × 0,70 kΩ) ≈ 4,8 kΩ, soit une valeur normalisée de 4,7 kΩ ; pour 60–100 °C, environ 1,3 kΩ, soit 1,2 kΩ ou 1,5 kΩ.

Câblage de la thermistance CTN : pont diviseur (Uno, ESP32, Pico)

Les entrées analogiques de l'Arduino mesurent une tension, pas une résistance. Tu mets donc la CTN en série avec une résistance fixe pour former un pont diviseur de tension : la tension au point de jonction des deux résistances dépend de la résistance de la CTN, donc de la température. C'est exactement le même montage qu'avec une photorésistance (LDR) ; la seule différence est que la résistance réagit à la température au lieu de la lumière. Dans les codes de cet article, la CTN est dans la branche haute (reliée à l'alimentation) et la résistance de 10 kΩ dans la branche basse (reliée à GND) ; ainsi la valeur lue augmente quand ça chauffe, ce qui est intuitif. Tu peux calculer la tension de sortie avec d'autres valeurs dans l'outil Pont diviseur et vérifier le code couleur de la résistance fixe avec l'outil Code couleur des résistances.

Ce montage a une propriété très pratique : il effectue une mesure ratiométrique. Par défaut, l'ADC de l'Uno prend l'alimentation 5 V comme référence, et le pont est alimenté par ces mêmes 5 V. Même si l'USB fournit 4,8 V au lieu de 5,0 V, la sortie du pont et la référence de l'ADC baissent dans la même proportion et la valeur analogRead ne change pas. Tu n'as donc pas besoin de connaître la tension d'alimentation pour mesurer avec une CTN, ni de te battre avec la tension de référence comme avec le LM35. Pour la même raison, n'utilise pas analogReference(INTERNAL) avec une CTN : avec une référence de 1,1 V, le rapport est faussé et le calcul devient faux. Ce qui détermine vraiment la précision, c'est la valeur de la résistance fixe ; une résistance à 5 % peut à elle seule causer environ 1 °C d'erreur. Utilise donc une résistance à couche métallique à 1 % ou mesure la valeur réelle de la tienne avec un multimètre et reporte-la dans le code.

Calculer la température avec l'équation Beta (B = 3950)

Les fabricants décrivent une CTN avec deux nombres : sa résistance à 25 °C (R0 = 10 kΩ) et sa valeur B (Beta). Avec ces deux nombres, l'équation Beta donne la température correspondant à n'importe quelle résistance : 1/T = 1/T0 + (1/B) × ln(R/R0). T et T0 sont en kelvins (T0 = 25 + 273,15 = 298,15 K) et ln est le logarithme népérien ; pour passer en degrés Celsius, tu soustrais 273,15. Exemple : si la CTN mesure 5300 Ω, ln(5300/10000) = −0,635 ; 1/T = 0,003354 − 0,000161 = 0,003193 et T = 313,2 K, soit environ 40 °C. Les petits nombres à côté de la valeur B indiquent entre quelles températures elle a été mesurée : B25/50 = 3950 signifie que B a été calculé à partir des résistances à 25 °C et à 50 °C. Sans fiche technique, tu peux déterminer B toi-même : mesure la résistance à deux températures et utilise B = ln(R1/R2) / (1/T1 − 1/T2). Par exemple, si tu mesures 10 000 Ω à 25 °C et 3588 Ω à 50 °C, tu obtiens B ≈ 3950.

Première mesure avec Arduino, pas à pas

1. Place la CTN et la résistance de 10 kΩ sur la breadboard ; relie une patte de la CTN au 5V et l'autre à une extrémité de la résistance.
2. Relie l'autre extrémité de la résistance à GND et amène un fil de liaison du point de jonction entre la CTN et la résistance jusqu'à A0.
3. Téléverse le code ci-dessous et ouvre le moniteur série à 9600 bauds.
4. À température ambiante, tu devrais lire environ 20–25 °C. Tiens la CTN entre deux doigts ; en quelques secondes, la valeur doit monter vers 30 °C.
5. Si la valeur baisse quand ça chauffe, la CTN et la résistance sont inversées : corrige le câblage ou remplace la formule du code par celle du montage "CTN en bas".

1const int NTC_PIN = A0;            // NTC ile 10k direncin birleştiği nokta / junction of the NTC and the 10k resistor
2const float SERIES_R = 10000.0;    // sabit direnç, ölçtüğün değeri yaz / fixed resistor, write your measured value
3const float R_NOMINAL = 10000.0;   // NTC'nin 25 °C'deki direnci / NTC resistance at 25 °C
4const float T_NOMINAL_K = 298.15;  // 25 °C kelvin cinsinden / 25 °C in kelvin
5const float BETA_K = 3950.0;       // B25/50 değeri (veri sayfası) / B25/50 value (datasheet)
6const int SAMPLES = 16;            // ortalama için ölçüm sayısı / number of samples to average
7
8void setup() {
9  Serial.begin(9600);
10}
11
12void loop() {
13  long sum = 0;
14  for (int i = 0; i < SAMPLES; i++) {
15    sum += analogRead(NTC_PIN);
16    delay(2);
17  }
18  float adc = sum / (float)SAMPLES;                      // ortalama ham değer / average raw value
19
20  if (adc < 1.0 || adc > 1022.0) {                       // kablo kopuk ya da kısa devre / open or shorted wire
21    Serial.println(F("Sensor hatasi / Sensor error"));
22    delay(1000);
23    return;
24  }
25
26  float rNtc = SERIES_R * (1023.0 - adc) / adc;          // NTC üstte bağlantı / NTC on the high side
27  float tempK = 1.0 / (1.0 / T_NOMINAL_K + log(rNtc / R_NOMINAL) / BETA_K);   // Beta denklemi / Beta equation
28  float tempC = tempK - 273.15;                          // kelvin -> santigrat / kelvin -> Celsius
29
30  Serial.print(F("ADC: "));
31  Serial.print(adc, 1);
32  Serial.print(F("  R: "));
33  Serial.print(rNtc, 0);
34  Serial.print(F(" ohm  Sicaklik / Temp: "));
35  Serial.print(tempC, 2);
36  Serial.println(F(" C"));
37  delay(1000);
38}

À chaque mesure, le code lit A0 seize fois et fait la moyenne ; cela lisse les fluctuations d'un ou deux pas de l'ADC. Si la moyenne est inférieure à 1 ou supérieure à 1022, le fil de la CTN est coupé ou en court-circuit, et le code affiche un message d'erreur au lieu d'une température absurde. Il calcule ensuite la résistance de la CTN à partir de la moyenne, puis la température avec l'équation Beta. Sur Arduino, la fonction log() renvoie le logarithme népérien (ln) ; log10() est le logarithme décimal, et les confondre rend le résultat complètement faux dès que l'on s'éloigne de 25 °C. Dans le moniteur série, tu verras des lignes comme "ADC: 512.3 R: 9969 ohm Sicaklik / Temp: 25.07 C".

L'équation de Steinhart-Hart : un résultat plus précis

L'équation Beta est très bonne dans la plage où B a été mesuré (souvent 25–50 °C), mais elle dérive quand on s'en éloigne, car la valeur B d'une vraie CTN varie légèrement avec la température. Sur une large plage comme 0–100 °C, l'erreur peut dépasser 1 °C. Pour plus de précision, on utilise l'équation de Steinhart-Hart à trois coefficients : 1/T = A + B × ln(R) + C × (ln R)³. L'équation Beta n'est en fait que le cas particulier de celle-ci avec C = 0. Les coefficients se calculent à partir de trois valeurs de résistance mesurées à trois températures différentes ; avec trois points bien choisis, l'équation donne généralement mieux que 0,1 °C dans la plage étalonnée. Au lieu de résoudre A, B et C à la main, le code ci-dessous calcule lui-même les coefficients à partir de tes trois points de mesure, dans setup().

1const int NTC_PIN = A0;
2const float SERIES_R = 10000.0;    // ölçtüğün sabit direnç / your measured fixed resistor
3
4// Kalibrasyon noktaları: örnek değerler, kendi ölçümlerini yaz / calibration points: sample values, use your own
5const float CAL_T1 = 0.0,  CAL_R1 = 32900.0;   // buzlu su / ice water
6const float CAL_T2 = 25.0, CAL_R2 = 10000.0;   // oda, referans termometreyle / room, against a reference thermometer
7const float CAL_T3 = 98.5, CAL_R3 = 690.0;     // kaynayan su / boiling water
8
9float shA, shB, shC;               // Steinhart-Hart katsayıları / coefficients
10
11void computeCoefficients() {
12  float L1 = log(CAL_R1), L2 = log(CAL_R2), L3 = log(CAL_R3);
13  float Y1 = 1.0 / (CAL_T1 + 273.15);
14  float Y2 = 1.0 / (CAL_T2 + 273.15);
15  float Y3 = 1.0 / (CAL_T3 + 273.15);
16  float g2 = (Y2 - Y1) / (L2 - L1);
17  float g3 = (Y3 - Y1) / (L3 - L1);
18  shC = ((g3 - g2) / (L3 - L2)) / (L1 + L2 + L3);
19  shB = g2 - shC * (L1 * L1 + L1 * L2 + L2 * L2);
20  shA = Y1 - (shB + shC * L1 * L1) * L1;
21}
22
23float readResistance() {
24  long sum = 0;
25  for (int i = 0; i < 16; i++) {
26    sum += analogRead(NTC_PIN);
27    delay(2);
28  }
29  float adc = sum / 16.0;
30  if (adc < 1.0 || adc > 1022.0) return -1.0;            // sensör hatası / sensor error
31  return SERIES_R * (1023.0 - adc) / adc;                // NTC üstte / NTC on the high side
32}
33
34void setup() {
35  Serial.begin(9600);
36  computeCoefficients();           // katsayıları bir kez hesapla / compute the coefficients once
37}
38
39void loop() {
40  float r = readResistance();
41  if (r < 0) {
42    Serial.println(F("Sensor hatasi / Sensor error"));
43  } else {
44    float lnR = log(r);
45    float tempK = 1.0 / (shA + shB * lnR + shC * lnR * lnR * lnR);   // Steinhart-Hart
46    Serial.print(F("R: "));
47    Serial.print(r, 0);
48    Serial.print(F(" ohm  Sicaklik / Temp: "));
49    Serial.print(tempK - 273.15, 2);
50    Serial.println(F(" C"));
51  }
52  delay(1000);
53}

Les trois points du code sont des exemples ; mesure ta propre CTN et remplace-les. Avec ces valeurs d'exemple, Steinhart-Hart donne le résultat exact à 0 °C, 25 °C et 98,5 °C. Si tu donnes les mêmes résistances à l'équation Beta (B = 3950), le point à 0 °C devient 0,4 °C et celui à 98,5 °C devient 100,4 °C, soit environ 2 °C d'erreur à haute température. Choisis les points aux deux extrémités et au milieu de la plage que tu vas mesurer ; en dehors de la plage étalonnée (par exemple à −20 °C avec ces coefficients), l'erreur augmente de nouveau. Sur l'Uno, un float ne fait que 32 bits, mais cela suffit pour ce calcul : les résultats concordent à 0,01 °C près avec un calcul en double précision.

Étalonnage : transforme ta CTN en thermomètre fiable

1. Mesure la résistance fixe : mesure la valeur réelle de la résistance de 10 kΩ au multimètre et saisis-la dans SERIES_R ; un écart de 1 % représente à lui seul environ 0,2 °C d'erreur.
2. Rends la CTN étanche : ne plonge pas une CTN époxy nue dans l'eau ; isole ses pattes avec de la gaine thermorétractable et du silicone, ou utilise une CTN déjà montée dans une sonde en inox.
3. Point à 0 °C : remplis un verre à ras bord de glace pilée, ajoute un peu d'eau froide et remue. Laisse la CTN au centre du verre pendant 2–3 minutes et, une fois la valeur stable, note la valeur R affichée dans le moniteur série.
4. Point à température ambiante : laisse la CTN 10 minutes à côté d'un thermomètre numérique fiable, à l'abri des courants d'air ; note la valeur du thermomètre et la résistance de la CTN.
5. Point à haute température : au niveau de la mer, l'eau bout à 100 °C, mais le point d'ébullition baisse d'environ 1 °C tous les 300 m d'altitude (environ 96,7 °C à 1000 m). Plonge la CTN dans l'eau bouillante sans toucher le fond de la casserole et note la résistance.
6. Reporte les valeurs dans le code : saisis les trois points dans le code Steinhart-Hart. Si tu ne mesures qu'autour de la température ambiante, une simple correction d'offset sur un point (soustraire l'écart constant) suffit souvent.

Thermomètre à CTN avec écran LCD

Pour afficher la mesure sans ordinateur, ajoutons un écran LCD I2C 16x2. Relie la broche SDA de l'écran à A4, SCL à A5, VCC au 5V et GND à GND ; le circuit de la CTN ne change pas. Le code utilise la bibliothèque LiquidCrystal I2C, que tu peux installer depuis le gestionnaire de bibliothèques. L'adresse de l'écran est généralement 0x27, sur certains modules 0x3F. Pour le symbole degré, on affiche le caractère 223 de la table de caractères du LCD. L'écran indique aussi, sur la ligne du bas, les températures minimale et maximale mesurées depuis la mise sous tension de l'Arduino.

1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3
4LiquidCrystal_I2C lcd(0x27, 16, 2);   // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
5
6const int NTC_PIN = A0;
7const float SERIES_R = 10000.0;
8const float R_NOMINAL = 10000.0;
9const float T_NOMINAL_K = 298.15;
10const float BETA_K = 3950.0;
11
12float minC = 999.0;                   // en düşük değer / lowest value
13float maxC = -999.0;                  // en yüksek değer / highest value
14
15float readTempC() {
16  long sum = 0;
17  for (int i = 0; i < 16; i++) {
18    sum += analogRead(NTC_PIN);
19  }
20  float adc = sum / 16.0;
21  if (adc < 1.0 || adc > 1022.0) return NAN;             // sensör hatası / sensor error
22  float r = SERIES_R * (1023.0 - adc) / adc;
23  return 1.0 / (1.0 / T_NOMINAL_K + log(r / R_NOMINAL) / BETA_K) - 273.15;
24}
25
26void setup() {
27  lcd.init();
28  lcd.backlight();
29}
30
31void loop() {
32  float t = readTempC();
33  lcd.clear();
34  if (isnan(t)) {
35    lcd.print(F("Sensor hatasi"));
36  } else {
37    if (t < minC) minC = t;
38    if (t > maxC) maxC = t;
39    lcd.print(F("Sicaklik "));
40    lcd.print(t, 1);
41    lcd.print((char)223);             // derece işareti / degree symbol
42    lcd.print('C');
43    lcd.setCursor(0, 1);              // ikinci satır / second row
44    lcd.print(F("Min"));
45    lcd.print(minC, 1);
46    lcd.print(F(" Max"));
47    lcd.print(maxC, 1);
48  }
49  delay(1000);
50}

Thermistance CTN avec l'ESP32

L'ADC de l'ESP32 fait 12 bits (0–4095) et la puce fonctionne en 3,3 V, alors alimente le pont depuis la broche 3V3. Branche toujours la CTN sur une broche ADC1 (GPIO 32–39) ; les broches ADC2 ne sont pas lisibles quand le Wi-Fi est actif. Tu trouveras le brochage de ta carte dans l'outil Pinout. Il y a ici une différence importante : l'ADC de l'ESP32 n'utilise pas la tension d'alimentation comme référence, mais une référence interne d'environ 1,1 V associée à l'atténuation choisie. La mesure ratiométrique de l'Uno ne se fait donc pas d'elle-même, et tu dois connaître la valeur réelle du rail 3V3. C'est pourquoi le code lit des millivolts avec analogReadMilliVolts(), qui utilise les données d'étalonnage gravées dans la puce en usine, et calcule la résistance à partir de la valeur du 3V3 que tu as mesurée au multimètre. D'après la documentation d'Espressif, l'ESP32 classique mesure 150–3100 mV avec l'atténuation par défaut de 11 dB, mais la zone recommandée et la plus linéaire est 150–2450 mV. Ces limites fixent la plage de température mesurable selon le montage :

1const int NTC_PIN = 34;            // ADC1_CH6, Wi-Fi açıkken de çalışır / works while Wi-Fi is on
2const float VCC_MV = 3300.0;       // 3V3 pinini multimetreyle ölçüp yaz / measure the 3V3 pin and write it here
3const float SERIES_R = 10000.0;
4const float R_NOMINAL = 10000.0;
5const float T_NOMINAL_K = 298.15;
6const float BETA_K = 3950.0;
7const int SAMPLES = 64;            // ortalama için ölçüm sayısı / number of samples to average
8
9void setup() {
10  Serial.begin(115200);
11  analogReadResolution(12);                     // 0–4095
12  analogSetPinAttenuation(NTC_PIN, ADC_11db);   // varsayılan zayıflatma / default attenuation
13}
14
15void loop() {
16  uint32_t sum = 0;
17  for (int i = 0; i < SAMPLES; i++) {
18    sum += analogReadMilliVolts(NTC_PIN);       // kalibre edilmiş mV / calibrated millivolts
19    delay(1);
20  }
21  float mv = sum / (float)SAMPLES;
22
23  if (mv < 150.0 || mv > 3100.0) {              // ADC aralığı dışında / outside the ADC range
24    Serial.println("Aralik disi / Out of range");
25    delay(1000);
26    return;
27  }
28
29  float rNtc = SERIES_R * (VCC_MV - mv) / mv;   // NTC üstte / NTC on the high side
30  float tempC = 1.0 / (1.0 / T_NOMINAL_K + log(rNtc / R_NOMINAL) / BETA_K) - 273.15;
31  Serial.printf("Gerilim / Voltage: %.0f mV  R: %.0f ohm  Sicaklik / Temp: %.2f C\n", mv, rNtc, tempC);
32  delay(1000);
33}

Pour un thermomètre intérieur ou extérieur, le montage avec la CTN en haut est idéal. Si tu mesures au-dessus de 50 °C, par exemple une bouilloire, une machine à café ou le plateau d'une imprimante 3D, place la CTN dans la branche basse et remplace la formule par Rntc = Rs × mV / (Vcc − mV). Quand le Wi-Fi est actif, les pics de courant de l'ESP32 créent de petites ondulations sur le rail 3V3 ; faire la moyenne de 64 mesures et ajouter un condensateur de 100 nF entre GPIO 34 et GND améliore nettement le résultat. Si tu débutes avec l'ESP32, consulte l'installation dans l'article Qu'est-ce que l'ESP32.

CTN avec le Raspberry Pi Pico et MicroPython

L'ADC 12 bits du Pico se trouve sur les broches GP26, GP27 et GP28 ; en MicroPython, read_u16() renvoie le résultat mis à l'échelle sur 0–65535. La référence de l'ADC du Pico (ADC_VREF) est tirée sur la carte du rail 3,3 V à travers un petit filtre RC. Si tu alimentes aussi le pont depuis la broche 3V3(OUT), la mesure est à peu près ratiométrique, comme sur l'Uno, et la formule reste la même ; tu utilises simplement 65535 au lieu de 1023. L'ADC du Pico est un peu bruité et fait de petits sauts sur certains codes, donc la moyenne est indispensable ici aussi. Utiliser AGND (broche 33) comme masse analogique réduit un peu le bruit. Si tu utilises le Pico pour la première fois, tu trouveras l'installation de MicroPython dans l'article Qu'est-ce que le Raspberry Pi Pico.

1from machine import ADC
2import math
3import time
4
5ntc = ADC(26)                # GP26 = ADC0, fiziksel pin 31 / physical pin 31
6SERIES_R = 10000             # sabit direnç / fixed resistor
7R_NOMINAL = 10000            # NTC'nin 25 °C'deki direnci / NTC resistance at 25 °C
8T_NOMINAL_K = 298.15         # 25 °C kelvin cinsinden / 25 °C in kelvin
9BETA_K = 3950                # B25/50 değeri / B25/50 value
10SAMPLES = 64                 # ortalama için ölçüm sayısı / number of samples to average
11
12
13def read_temp_c():
14    total = 0
15    for _ in range(SAMPLES):
16        total += ntc.read_u16()          # 0–65535
17    raw = total / SAMPLES
18    if raw < 100 or raw > 65435:
19        return None                      # kopuk ya da kısa devre / open or shorted
20    r_ntc = SERIES_R * (65535 - raw) / raw          # NTC üstte / NTC on the high side
21    temp_k = 1 / (1 / T_NOMINAL_K + math.log(r_ntc / R_NOMINAL) / BETA_K)
22    return temp_k - 273.15
23
24
25while True:
26    t = read_temp_c()
27    if t is None:
28        print("Sensor hatasi / Sensor error")
29    else:
30        print("Sicaklik / Temp: {:.2f} C".format(t))
31    time.sleep(1)

En MicroPython, math.log() est aussi le logarithme népérien : tu utilises donc la même formule que dans le code Arduino. Le Pico possède en plus un capteur de température intégré (ADC(4)), mais il mesure la température de la puce elle-même et non celle de la pièce, et affiche souvent quelques degrés de trop en fonctionnement. Pour la température ambiante, une CTN externe est bien plus précise. Si tu veux utiliser les coefficients de Steinhart-Hart, tu peux traduire la fonction computeCoefficients() du code Arduino en Python en quelques lignes.

Différence entre CTN et CTP

Dans les thermistances CTP (coefficient de température positif, PTC en anglais), la résistance augmente avec la température. Le type de CTP le plus courant sert à protéger plutôt qu'à mesurer : les CTP de commutation en céramique de titanate de baryum gardent une faible résistance jusqu'à une certaine température (le point de Curie), puis leur résistance augmente brusquement d'un facteur cent à mille. Les protections contre la surchauffe des bobinages de moteurs et les éléments chauffants CTP autorégulés fonctionnent sur ce principe. Les fusibles réarmables à base de polymère (polyfuse) se comportent de façon semblable ; le fusible de 500 mA sur la ligne USB de l'Arduino Uno en est un. Les capteurs CTP au silicium comme le KTY81 varient quant à eux de façon presque linéaire, d'environ 0,7–0,8 %/°C. Les sondes à résistance de platine comme la PT100 et la PT1000 ont aussi un coefficient positif, mais ce sont des capteurs métalliques, pas des thermistances ; elles valent 100 Ω ou 1000 Ω à 0 °C, dépassent les 500 °C et nécessitent un amplificateur comme le MAX31865 pour être lues.

Applications : imprimantes 3D et batteries

Dans les imprimantes 3D, la température de la buse (hotend) comme celle du plateau est le plus souvent mesurée par une thermistance CTN. On y utilise des CTN de 100 kΩ plutôt que de 10 kΩ, car à 250 °C une CTN de 10 kΩ descend à environ 35 Ω et la mesure perd sa résolution ; le fichier de configuration du célèbre firmware Marlin avertit d'ailleurs, pour la thermistance générique de 10 kΩ, de "ne pas l'utiliser sur une buse, car sa résolution est mauvaise à haute température". Sur les cartes 8 bits comme la RAMPS, les entrées thermistance sont reliées au 5 V par une résistance de tirage (pull-up) de 4,7 kΩ, et Marlin convertit la valeur de l'ADC en température grâce à des tables toutes prêtes ; l'un des types définis pour les thermistances 100 kΩ B3950 porte le numéro 11. Si le fil de la thermistance se coupe, l'ADC lit sa valeur maximale, le firmware l'interprète comme un froid extrême et affiche Err: MINTEMP ; en cas de court-circuit, c'est Err: MAXTEMP. Si la thermistance sort de son logement, la cartouche chauffe sans arrêt mais la mesure ne monte pas ; Marlin le détecte grâce à sa protection THERMAL RUNAWAY et coupe les chauffages. Ne désactive jamais cette protection.

Les cellules lithium-ion ne doivent pas être chargées en dessous de 0 °C ni au-dessus d'environ 45 °C ; une charge au froid provoque un dépôt de lithium métallique dans la cellule et des dégâts irréversibles. C'est pourquoi la plupart des batteries de téléphones, d'ordinateurs portables et de vélos électriques ont une CTN collée sur les cellules, et la troisième borne du connecteur de batterie (marquée T ou NTC) mène généralement à cette thermistance. La broche 1 (TEMP) du célèbre circuit de charge TP4056 sert justement à cela : d'après sa fiche technique, si la tension sur cette broche reste en dessous de 45 % ou au-dessus de 80 % de la tension d'entrée pendant plus de 0,15 seconde, la charge est suspendue. Dans ton propre projet de batterie, tu peux coller une CTN sur la cellule, la lire avec l'Arduino et couper le circuit de charge avec un MOSFET quand la température sort des limites. Dans les alimentations, de grosses CTN en disque limitent le courant d'appel qui charge les condensateurs à la mise sous tension ; en chauffant, leur résistance passe de quelques ohms à moins d'un ohm, si bien qu'elles causent très peu de pertes en fonctionnement normal.

Idées de projets avec une thermistance CTN

• Thermostat de ventilateur avec hystérésis : allume un ventilateur avec un module relais quand la température dépasse 30 °C et éteins-le à 28 °C ; l'écart de 2 degrés évite que le relais claque sans arrêt.
• Thermomètre d'aquarium à sonde étanche : mesure la température de l'eau avec une sonde CTN en inox et déclenche un buzzer si le chauffage tombe en panne.
• Thermomètre de poche avec écran OLED : affiche la température et une courbe de la dernière heure sur un écran OLED.
• Surveillance du caisson d'imprimante 3D : mesure la température dans le caisson fermé et démarre un ventilateur d'extraction au-delà de 45 °C.
• Gardien de température de batterie : surveille la température de la cellule pendant la charge, coupe la charge en dehors de 0–45 °C et préviens avec une LED.
• Enregistreur de température Wi-Fi : avec un ESP32, écris une mesure par minute sur une carte SD ou affiche-la sur une page web ouverte depuis ton téléphone.

Erreurs fréquentes et solutions

La thermistance CTN t'apprend à transformer une pièce bon marché en thermomètre précis avec une seule résistance et quelques lignes de maths : pont diviseur, ADC, logarithme et étalonnage réunis. Tu réutiliseras la même démarche plus tard avec d'autres capteurs analogiques ; pour lisser encore tes mesures, jette un œil aux techniques de filtrage des données de capteurs. Dans l'application BlueGrays, tu trouveras la mesure de température avec CTN et LCD 2x16, la température et l'humidité avec le DHT11, une station de température ESP32 avec LCD et un enregistreur de température, chacun avec des schémas pas à pas et du code prêt à l'emploi.