Composants · 14 min de lecture

Module Peltier Arduino : TEC1-12706, refroidir et chauffer

Comment utiliser un module Peltier TEC1-12706 avec Arduino ? Face chaude et froide, dissipateur, courant de 6 A, MOSFET, pont en H et thermostat DS18B20.

Un module Peltier est un mince élément thermoélectrique dont une face refroidit et l'autre chauffe quand un courant le traverse. Piloté par Arduino, il te permet de fabriquer un mini réfrigérateur, un refroidisseur de boissons, une couveuse ou une enceinte d'expérience à température contrôlée. Le modèle le plus courant chez les makers est le TEC1-12706 de 40×40 mm : il fonctionne en 12 V, consomme environ 6 A et déplace la chaleur d'une face à l'autre sans pièce mobile, sans gaz ni compresseur. Si tu inverses le sens du courant, la face froide se met à chauffer : un même module peut donc refroidir et chauffer.

Mais un Peltier ne se branche pas directement sur une broche d'Arduino comme une LED ou un servo. Seul, il consomme plus de 60 watts, sa face chaude devient dangereusement brûlante en quelques secondes et il se détruit sans gros dissipateur ni ventilateur. Dans cet article, tu vas comprendre son fonctionnement, distinguer la face chaude de la face froide, voir pourquoi le dissipateur est obligatoire, choisir la bonne alimentation et le piloter avec un MOSFET ou un pont en H. À la fin, tu construiras une mini glacière avec un capteur de température DS18B20, puis une boîte thermostatée qui chauffe et refroidit.

Qu'est-ce qu'un module Peltier et comment fonctionne-t-il ?

L'effet Peltier a été découvert en 1834 par Jean Charles Peltier : quand un courant traverse la jonction de deux conducteurs différents, de la chaleur est absorbée ou dégagée à cet endroit. Dans le TEC1-12706, de petits blocs semi-conducteurs de type n et de type p en tellurure de bismuth (Bi2Te3) sont alignés entre deux plaques de céramique. Ils sont reliés en série électriquement et en parallèle thermiquement ; à chaque paire n-p, les porteurs de charge (électrons et trous) entraînent la chaleur dans le même sens, d'une plaque vers l'autre. Le module se comporte donc comme une pompe à chaleur à semi-conducteurs : il ne détruit pas la chaleur, il la prend sur une face et la transporte vers l'autre.

Le nom du modèle donne ses caractéristiques : TEC signifie refroidisseur thermoélectrique (Thermoelectric Cooler), le premier 1 indique un seul étage, 127 est le nombre de paires n-p et 06 le courant maximal d'environ 6 A. Dans la même famille, il existe les TEC1-12704 (4 A), TEC1-12705 (5 A), TEC1-12708 (8 A) et TEC1-12710 (10 A). Comme le nombre de paires reste identique, tous fonctionnent autour de 12–15 V ; plus le courant est élevé, plus ils peuvent pomper de chaleur.

CaractéristiqueValeur du TEC1-12706
Dimensions40 × 40 × 3,8 mm
Tension nominale12 V (Umax ≈ 15,4 V)
Courant maximal (Imax)≈ 6,4 A
Puissance thermique maximale (Qmax)≈ 50–60 W (pour ΔT = 0)
Écart de température maximal (ΔTmax)≈ 66 °C (face chaude à 25 °C, à vide)
Résistance interne≈ 2 Ω (à température ambiante)
Rendement (COP)En usage réel, typiquement 0,3–0,7 ; diminue quand ΔT augmente
Construction127 paires n-p, tellurure de bismuth, plaques en céramique d'alumine
FilsRouge (+), noir (−)

Face chaude et face froide : laquelle est laquelle ?

Un Peltier a deux fils : quand le rouge est relié au plus et le noir au moins, une face refroidit et l'autre chauffe. Si tu inverses la polarité, les faces échangent leurs rôles. Certains fabricants impriment l'inscription sur la face chaude, d'autres sur la face froide ; ne te fie donc pas à l'étiquette. La méthode la plus sûre : pose le module sur la table, branche le rouge au plus et le noir au moins d'un adaptateur 5 V 3 A ou d'une alimentation de laboratoire pendant 1 à 2 secondes au maximum, puis touche les deux faces du doigt. Marque au crayon la face qui se rafraîchit. Si tu laisses branché plus longtemps, le module sans dissipateur chauffe très vite.

La clé pour comprendre le Peltier est le ΔT, l'écart de température entre les deux faces. Le module ne descend pas la face froide à une température absolue, mais à un certain nombre de degrés sous la face chaude. Le ΔTmax d'environ 66 °C du catalogue est la meilleure valeur mesurée quand on ne prélève aucune chaleur sur la face froide ; en charge réelle, quand il extrait la chaleur d'une enceinte, l'écart tombe à 15–30 °C. Si la face chaude monte à 50 °C, la face froide ne descend qu'à 20–30 °C ; si tu gardes la face chaude à 30 °C, la face froide peut passer sous 0 °C. Bref, la performance du côté froid dépend de la qualité du refroidissement du côté chaud.

Pourquoi le dissipateur et le ventilateur sont-ils obligatoires ?

En déplaçant la chaleur, le Peltier consomme lui-même de l'électricité, et toute cette énergie se transforme en chaleur. La chaleur à évacuer par la face chaude est donc la somme de la chaleur prélevée côté froid et de la puissance électrique : Q_chaud = Q_froid + V × I. Un module alimenté en 12 V et 5,5 A consomme environ 66 W ; s'il prélève 20 W côté froid, la face chaude doit évacuer 86 W. Pour garder la face chaude au maximum 15 °C au-dessus d'une ambiance à 25 °C, soit 40 °C, la résistance thermique du dissipateur doit être de 15 / 86 ≈ 0,17 °C/W ; seul un ventirad de processeur (CPU) peut l'atteindre. Un petit dissipateur en aluminium de 3 °C/W monterait, sur le papier, à plus de 250 °C pour la même chaleur ; en pratique, les soudures fondent et la céramique se fissure bien avant.

  • Pâte thermique : étale une couche fine et uniforme sur les deux faces ; une couche épaisse n'améliore pas la conduction, elle la dégrade.
  • Côté chaud : utilise un ventirad de CPU ou un bloc de watercooling ; le ventilateur doit tourner tant que le Peltier fonctionne.
  • Côté froid : un petit dissipateur en aluminium dans l'enceinte et un ventilateur de 40–60 mm brassent l'air et refroidissent toute l'enceinte.
  • Serrage : serre les vis en croix et progressivement ; trop serrer d'un seul côté fissure la plaque de céramique.
  • Évite le pont thermique : comble l'espace entre les deux dissipateurs avec de la mousse ou un joint en caoutchouc, et utilise des rondelles en plastique pour que les vis métalliques ne ramènent pas la chaleur.
  • Isolation : prends une boîte en polystyrène ou en mousse ; un boîtier en plastique fin récupère aussitôt de l'extérieur la chaleur que le Peltier extrait.
Ne branche jamais un Peltier en 12 V sans dissipateur ni ventilateur. La face chaude peut dépasser 100 °C en quelques secondes, le module est détruit définitivement et tu te brûleras si tu le touches. Prévois aussi une sécurité dans ton code : coupe le Peltier si le ventilateur s'arrête ou si la face chaude dépasse 60 °C.

Besoin en courant et choix de l'alimentation

La résistance interne du TEC1-12706 est d'environ 2 Ω. Avec la loi d'Ohm, I = V / R, tu obtiens environ 5,7 A au premier instant sous 12 V ; quand un écart de température s'installe, la tension de Seebeck produite par le module réduit un peu le courant, qui reste autour de 5 A. Cela représente 60–70 W ; dans ton calcul de puissance électrique, ajoute aussi les 0,2–0,5 A des ventilateurs. Comme alimentation, il te faut au moins un adaptateur à découpage 12 V 10 A ou la ligne 12 V d'une ancienne alimentation de PC (ATX). L'USB, la broche 5V d'Arduino ou une pile de 9 V ne pourront jamais fournir ce courant ; pour plus de détails, lis l'article sur l'alimentation d'Arduino. Point intéressant : le Peltier est le plus efficace non pas à plein courant, mais vers 50–70 % du courant maximal, car la chaleur pompée croît proportionnellement au courant alors que les pertes résistives (I²R) croissent avec son carré.

Tension d'alimentationCourant approximatifPuissance électriqueUtilisation
5 V2,4 A12 WTest des faces, refroidissement léger, meilleur rendement
9 V4,3 A39 WCompromis entre rendement et refroidissement
12 V5,7 A69 WFonctionnement nominal, refroidissement maximal
15,4 V (Umax)6,4 A≈ 99 WValeur limite, à ne pas utiliser en continu

Branchement : piloter le Peltier avec un MOSFET et un pont en H

Si tu n'utilises le Peltier que pour refroidir ou que pour chauffer, un seul MOSFET à canal N suffit. Le MOSFET se place entre la borne négative du Peltier et la masse (commutation côté bas) : le fil rouge va au +12 V, le fil noir au drain du MOSFET, et la source à la masse. Avec les sorties 5 V d'une Arduino Uno, choisis un MOSFET logic-level qui s'ouvre complètement ; l'IRLZ44N présente environ 0,025 Ω sous 5 V de grille et dissipe 6² × 0,025 ≈ 0,9 W à 6 A, un petit dissipateur suffit. Les modules IRF520 très répandus, eux, ne s'ouvrent pas complètement à 5 V : ils chauffent et limitent le courant. Place une résistance de 100 Ω en série sur la grille et une résistance de rappel de 10 kΩ entre grille et source, et relie impérativement la masse d'Arduino au moins de l'adaptateur (masse commune). Tu trouveras le choix du MOSFET en détail dans l'article utiliser un MOSFET avec Arduino. Avec les cartes 3,3 V comme l'ESP32 et le Pico, préfère un MOSFET à seuil plus bas, comme l'IRLB8721.

Si tu veux à la fois chauffer et refroidir, il faut inverser le sens du courant, et cela se fait avec un pont en H. Le L298N que tu connais des projets de robots ne convient pas au Peltier : il ne délivre que 2 A en continu par canal et présente une chute de tension de plus de 2 V. Utilise plutôt le module de pont en H BTS7960 (IBT-2), qui supporte jusqu'à 43 A : un PWM sur la broche RPWM fait circuler le courant dans un sens, sur la broche LPWM dans l'autre. Pour comparer les différents pilotes, jette un œil à la comparaison des drivers de moteur. Inverser la polarité avec un relais mécanique est possible, mais les contacts s'usent en cas de commutations fréquentes et tu ne peux pas régler la puissance.

ConnexionArduino Uno (MOSFET)ESP32 (BTS7960)Pico (MOSFET)
DATA DS18B20 de la boîte (pull-up 4,7 kΩ)D2GPIO 4GP16
DATA DS18B20 du dissipateur (pull-up 4,7 kΩ)D3——
Grille du MOSFET (via 100 Ω)D9—GP15
RPWM du BTS7960 (refroidissement)—GPIO 25—
LPWM du BTS7960 (chauffage)—GPIO 26—
R_EN + L_EN du BTS7960—GPIO 27—
VCC logique du BTS7960—3V3—
VCC des capteurs5V3V33V3 (broche 36)
GNDGND + adaptateur 12 V (−)GND + adaptateur 12 V (−)GND + adaptateur 12 V (−)
Brancher le Peltier directement sur une broche d'Arduino, sur la broche 5V/Vin ou sur un L298N est l'erreur la plus fréquente. Une broche d'Arduino fournit au maximum 20–40 mA, alors que le Peltier en demande plus de 150 fois plus. De plus, si le moins de l'adaptateur 12 V n'est pas relié à la masse d'Arduino, le MOSFET ne s'ouvre pas du tout ou seulement à moitié et chauffe.

Mini glacière pas à pas (Arduino + MOSFET)

  1. Prépare une boîte isolée (polystyrène ou mousse, 1 à 3 litres) et découpe dans le couvercle une fenêtre de 40×40 mm pour le Peltier.
  2. Repère la face froide du Peltier avec le test 5 V de 1–2 secondes et marque-la au crayon.
  3. Étale une fine couche de pâte thermique sur la face chaude ; place le ventirad de CPU à l'extérieur de la boîte, et le petit dissipateur avec son ventilateur sur la face froide, à l'intérieur. Serre les vis en croix et uniformément, et comble l'espace entre les deux avec de la mousse.
  4. Relie le fil rouge au plus de l'adaptateur 12 V, le fil noir au drain de l'IRLZ44N et la source au moins de l'adaptateur. Branche les deux ventilateurs directement en 12 V pour qu'ils tournent tant que le système est allumé.
  5. Relie la broche D9 d'Arduino à la grille via une résistance de 100 Ω, place une résistance de 10 kΩ entre grille et source et relie la masse d'Arduino au moins de l'adaptateur.
  6. Branche les deux DS18B20 : amène les lignes de données sur D2 (intérieur de la boîte) et D3 (dissipateur chaud), et ajoute à chacun une résistance pull-up de 4,7 kΩ entre 5V et la ligne de données.
  7. Installe les bibliothèques OneWire et DallasTemperature depuis le gestionnaire de bibliothèques, téléverse le code et ouvre le moniteur série à 9600 bauds pour suivre les températures.
Capteur de température numérique DS18B20
DS18B20 : mesure de -55 à +125 °C avec une précision de ±0,5 °C ; il fonctionne avec un seul fil de données et une résistance pull-up de 4,7 kΩ.
C++ (Arduino IDE)
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const int BOX_SENSOR_PIN = 2;     // kutu içi DS18B20 / DS18B20 inside the box
5const int HOT_SENSOR_PIN = 3;     // sıcak soğutucu DS18B20 / DS18B20 on the hot-side heatsink
6const int MOSFET_PIN     = 9;     // IRLZ44N gate (100 ohm üzerinden / via 100 ohm)
7
8const float TARGET_C    = 15.0;   // hedef kutu sıcaklığı / target box temperature
9const float BAND_C      = 3.0;    // bu farkta tam güç / full power at this difference
10const float HOT_LIMIT_C = 60.0;   // sıcak yüz koruma sınırı / hot-side protection limit
11const int   MAX_DUTY    = 204;    // %80 güç sınırı / 80% power limit
12
13OneWire boxWire(BOX_SENSOR_PIN);
14OneWire hotWire(HOT_SENSOR_PIN);
15DallasTemperature boxSensor(&boxWire);
16DallasTemperature hotSensor(&hotWire);
17
18void setup() {
19  Serial.begin(9600);
20  pinMode(MOSFET_PIN, OUTPUT);
21  analogWrite(MOSFET_PIN, 0);
22  // Timer1 bölücü 8: pin 9/10 PWM ~3.9 kHz / Timer1 prescaler 8: pin 9/10 PWM ~3.9 kHz
23  TCCR1B = (TCCR1B & 0b11111000) | 0x02;
24  boxSensor.begin();
25  hotSensor.begin();
26}
27
28void loop() {
29  boxSensor.requestTemperatures();
30  hotSensor.requestTemperatures();
31  float tBox = boxSensor.getTempCByIndex(0);
32  float tHot = hotSensor.getTempCByIndex(0);
33
34  int duty = 0;
35  if (tBox == DEVICE_DISCONNECTED_C || tHot == DEVICE_DISCONNECTED_C) {
36    duty = 0;                                   // sensör yoksa kapat / switch off if a sensor is missing
37    Serial.println(F("Sensor hatasi / Sensor error"));
38  } else if (tHot >= HOT_LIMIT_C) {
39    duty = 0;                                   // aşırı ısınma koruması / overheat protection
40    Serial.println(F("Sicak yuz cok sicak / Hot side too hot"));
41  } else {
42    float err = tBox - TARGET_C;                // pozitif = kutu fazla sıcak / positive = box too warm
43    if (err <= 0) duty = 0;
44    else if (err >= BAND_C) duty = MAX_DUTY;
45    else duty = (int)(err / BAND_C * MAX_DUTY); // oransal güç / proportional power
46  }
47  analogWrite(MOSFET_PIN, duty);
48
49  Serial.print(F("Kutu/Box: "));
50  Serial.print(tBox, 1);
51  Serial.print(F(" C  Sicak/Hot: "));
52  Serial.print(tHot, 1);
53  Serial.print(F(" C  PWM: "));
54  Serial.println(duty);
55  delay(1000);
56}
Ligne de codeCe qu'elle fait
TCCR1B = (TCCR1B & 0b11111000) | 0x02Règle le diviseur du Timer1 sur 8 ; le PWM de la broche 9 passe de 490 Hz à environ 3,9 kHz.
DEVICE_DISCONNECTED_CDétecte la valeur -127 lue quand le câble du capteur est coupé et éteint le Peltier.
HOT_LIMIT_C = 60.0Si le ventilateur s'arrête ou que le dissipateur est insuffisant, la face chaude est mise en protection à 60 °C.
err / BAND_C * MAX_DUTYAugmente la puissance proportionnellement quand la boîte est de 0 à 3 °C au-dessus de la consigne ; à 3 °C et plus, elle donne 80 % de puissance.
MAX_DUTY = 204Limite la puissance à 80 % ; améliore le rendement et prolonge la durée de vie du module et de l'adaptateur.
La broche 9 de l'Arduino Uno génère par défaut un PWM d'environ 490 Hz ; la ligne TCCR1B du code le porte à environ 3,9 kHz. Comme tu modifies le Timer1, la broche 10 et la bibliothèque Servo sont aussi affectées : tiens-en compte si tu utilises un servo dans le même projet. Tu peux lire le principe du PWM dans l'article Qu'est-ce que le PWM. En réalité, la méthode la plus efficace est un courant continu réglable, car avec le PWM la perte I²R interne est plus grande pour un même courant moyen ; mais pour sa simplicité, le PWM reste le choix le plus courant en loisir. Piloter le Peltier en PWM à l'échelle du kHz, plutôt que de l'allumer et l'éteindre toutes les quelques secondes, réduit la dilatation et la contraction thermiques et prolonge sa vie. Avec une régulation proportionnelle, la boîte peut se stabiliser un peu au-dessus de la consigne ; tu peux corriger ce petit écart avec un PID.

ESP32 : chauffer et refroidir avec le pont en H BTS7960

Avec l'ESP32, tu peux piloter le Peltier dans les deux sens via le BTS7960 et construire une boîte thermostatée à température fixe, indépendante de l'ambiance : si la boîte est au-dessus de la consigne, elle refroidit, si elle est en dessous, elle chauffe. En mode chauffage, le Peltier est particulièrement efficace : la face tournée vers l'intérieur reçoit à la fois la chaleur pompée de l'extérieur et l'électricité consommée, donc 40 W d'électricité peuvent fournir plus de 40 W de chaleur. Relie l'adaptateur 12 V aux entrées B+ et B− du BTS7960 et le Peltier aux sorties M+ et M− ; si tu relies la broche VCC logique du module à la broche 3V3 de l'ESP32, il détecte sans problème les signaux 3,3 V. Le code choisit automatiquement les différentes fonctions LEDC des versions 2.x et 3.x du core Arduino ESP32.

C++ (Arduino IDE)
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const int SENSOR_PIN   = 4;       // DS18B20 DATA
5const int RPWM_PIN     = 25;      // BTS7960 RPWM: soğutma yönü / cooling direction
6const int LPWM_PIN     = 26;      // BTS7960 LPWM: ısıtma yönü / heating direction
7const int EN_PIN       = 27;      // BTS7960 R_EN + L_EN
8const int RPWM_CH      = 0;       // core 2.x LEDC kanalı / core 2.x LEDC channel
9const int LPWM_CH      = 1;
10const int PWM_FREQ     = 20000;   // 20 kHz, duyulmaz / inaudible
11const int PWM_RES      = 8;       // 0-255
12const int PELTIER_DUTY = 200;     // ~%78 güç / ~78% power
13
14const float TARGET_C = 25.0;      // hedef sıcaklık / target temperature
15const float HYST_C   = 1.0;       // histerezis / hysteresis
16const unsigned long REVERSE_WAIT_MS = 30000;  // yön değiştirme beklemesi / reversal wait
17
18OneWire oneWire(SENSOR_PIN);
19DallasTemperature sensors(&oneWire);
20
21int currentMode = 0;              // 0 kapalı, 1 soğutma, -1 ısıtma / 0 off, 1 cool, -1 heat
22int lastDir = 0;
23unsigned long lastChange = 0;
24
25void pwmBegin(int pin, int ch) {
26#if ESP_ARDUINO_VERSION_MAJOR >= 3
27  ledcAttach(pin, PWM_FREQ, PWM_RES);   // core 3.x
28#else
29  ledcSetup(ch, PWM_FREQ, PWM_RES);     // core 2.x
30  ledcAttachPin(pin, ch);
31#endif
32}
33
34void pwmWrite(int pin, int ch, int duty) {
35#if ESP_ARDUINO_VERSION_MAJOR >= 3
36  ledcWrite(pin, duty);                 // core 3.x: pin ile / by pin
37#else
38  ledcWrite(ch, duty);                  // core 2.x: kanal ile / by channel
39#endif
40}
41
42void applyMode(int m) {
43  if (m == 1) {
44    pwmWrite(LPWM_PIN, LPWM_CH, 0);
45    pwmWrite(RPWM_PIN, RPWM_CH, PELTIER_DUTY);
46  } else if (m == -1) {
47    pwmWrite(RPWM_PIN, RPWM_CH, 0);
48    pwmWrite(LPWM_PIN, LPWM_CH, PELTIER_DUTY);
49  } else {
50    pwmWrite(RPWM_PIN, RPWM_CH, 0);
51    pwmWrite(LPWM_PIN, LPWM_CH, 0);
52  }
53}
54
55void setup() {
56  Serial.begin(115200);
57  pwmBegin(RPWM_PIN, RPWM_CH);
58  pwmBegin(LPWM_PIN, LPWM_CH);
59  applyMode(0);                         // önce iki yön de kapalı / both directions off first
60  pinMode(EN_PIN, OUTPUT);
61  digitalWrite(EN_PIN, HIGH);           // sürücüyü etkinleştir / enable the driver
62  sensors.begin();
63}
64
65void loop() {
66  sensors.requestTemperatures();
67  float t = sensors.getTempCByIndex(0);
68
69  int want = currentMode;
70  if (t == DEVICE_DISCONNECTED_C) {
71    want = 0;                           // sensör yok: kapat / no sensor: switch off
72  } else if (currentMode == 0) {
73    if (t > TARGET_C + HYST_C) want = 1;
74    else if (t < TARGET_C - HYST_C) want = -1;
75  } else if (currentMode == 1 && t <= TARGET_C) {
76    want = 0;
77  } else if (currentMode == -1 && t >= TARGET_C) {
78    want = 0;
79  }
80
81  if (want != currentMode) {
82    bool reversing = (want != 0 && lastDir != 0 && want != lastDir);
83    if (!reversing || millis() - lastChange >= REVERSE_WAIT_MS) {
84      currentMode = want;
85      lastChange = millis();
86      if (currentMode != 0) lastDir = currentMode;
87      applyMode(currentMode);
88    }
89  }
90
91  Serial.printf("T: %.2f C  mod/mode: %d\n", t, currentMode);
92  delay(1000);
93}

Le code contient deux règles de sécurité importantes. La première est l'hystérésis : le refroidissement démarre quand la boîte dépasse la consigne de 1 °C et s'arrête quand elle l'atteint ; le chauffage fonctionne à l'inverse. Ainsi, le système ne s'allume et ne s'éteint pas sans cesse autour de la consigne. La seconde est l'attente à l'inversion : passer brutalement du refroidissement au chauffage réchauffe d'un coup une face glacée une seconde plus tôt et provoque un choc thermique dans la céramique ; le code reste donc éteint au moins 30 secondes avant de passer dans l'autre sens. Le sens qui refroidit dépend de ton câblage ; si la boîte chauffe au premier essai, inverse les fils M+ et M−. Pour une régulation plus fine, consulte les articles thermostat Arduino et régulation PID.

Raspberry Pi Pico et MicroPython : contrôler un Peltier

Sur le Raspberry Pi Pico, les modules onewire et ds18x20 fournis avec MicroPython te permettent de lire un DS18B20 sans installer de bibliothèque. Le code ci-dessous fait le même refroidissement proportionnel que l'exemple Arduino : le PWM sort sur GP15 vers la grille du MOSFET ; le DS18B20 est relié à GP16 et tiré vers 3V3 par 4,7 kΩ. Le PWM du Pico a une résolution de 16 bits ; duty_u16() accepte des valeurs de 0 à 65535, et 52000 correspond à environ 80 % de puissance. N'oublie pas d'utiliser là aussi un MOSFET à seuil bas pour le signal de grille en 3,3 V. Si MicroPython est nouveau pour toi, l'article Les bases de MicroPython est un bon point de départ.

MicroPython
1from machine import Pin, PWM
2import onewire, ds18x20, time
3
4TARGET_C = 15.0          # hedef sıcaklık / target temperature
5BAND_C = 3.0             # bu farkta tam güç / full power at this difference
6MAX_DUTY = 52000         # ~%80 güç / ~80% power
7
8pwm = PWM(Pin(15))       # MOSFET gate
9pwm.freq(5000)           # 5 kHz PWM
10pwm.duty_u16(0)
11
12ow = onewire.OneWire(Pin(16))   # DS18B20 DATA (4.7k pull-up)
13ds = ds18x20.DS18X20(ow)
14roms = ds.scan()
15if not roms:
16    raise RuntimeError("DS18B20 bulunamadi / not found")
17
18while True:
19    ds.convert_temp()
20    time.sleep_ms(750)               # dönüşüm süresi / conversion time
21    t = ds.read_temp(roms[0])
22    err = t - TARGET_C               # pozitif = fazla sıcak / positive = too warm
23    if err <= 0:
24        duty = 0
25    elif err >= BAND_C:
26        duty = MAX_DUTY
27    else:
28        duty = int(err / BAND_C * MAX_DUTY)   # oransal güç / proportional power
29    pwm.duty_u16(duty)
30    print("T: {:.2f} C  guc/power: {}%".format(t, duty * 100 // 65535))
31    time.sleep(1)

Idées de projets avec un Peltier

  • Refroidisseur de boissons : avec une boîte en polystyrène, un TEC1-12706 et un DS18B20, fabrique un refroidisseur de canette pour ton bureau et affiche la température sur un petit écran.
  • Couveuse ou yaourtière : utilise le Peltier en mode chauffage pour maintenir 37–43 °C ; la logique du thermostat est la même ici.
  • Boîte de séchage de filament : débarrasse le filament d'imprimante 3D de son humidité pendant des heures à 45–50 °C.
  • Mini déshumidificateur : abaisse la face froide sous le point de rosée pour récupérer l'humidité de l'air goutte à goutte et mesure l'eau recueillie.
  • Expérience de générateur thermoélectrique : mets une face du Peltier dans l'eau chaude et l'autre sur de la glace, puis mesure la tension produite par l'effet Seebeck avec un voltmètre Arduino.
  • Vitesse du ventilateur selon la température : accélère le ventilateur côté chaud en fonction de la température du dissipateur ; les détails sont dans l'article contrôle de ventilateur avec Arduino.
  • Projet pour concours scientifique : un bac de germination ou une boîte d'expérience enzymatique à température constante se démarque parmi les idées de projets TÜBİTAK.

Erreurs fréquentes et solutions

ErreurSymptômeSolution
Faire fonctionner sans dissipateurLe module rougit en quelques secondes, une odeur apparaît, la céramique se fissureMonte un ventirad de CPU sur la face chaude et laisse le ventilateur toujours tourner
La face froide ne refroidit pasLes deux faces chauffent, la boîte chauffeRefroidissement du côté chaud insuffisant ou polarité inversée ; agrandis le dissipateur et vérifie les fils
Alimenter depuis l'ArduinoL'Arduino redémarre, le port USB se coupeAlimente le Peltier avec un adaptateur 12 V 10 A séparé
Piloter avec un L298NLe driver chauffe beaucoup, le courant reste autour de 2 AUtilise un pont en H à fort courant comme le BTS7960
Utiliser un module IRF520Le MOSFET chauffe, le Peltier est faibleUtilise un MOSFET logic-level comme l'IRLZ44N
Pas de masse communeLe MOSFET ne s'ouvre pas ou fonctionne au hasardRelie la masse d'Arduino au moins de l'adaptateur
Pâte thermique trop épaisseΔT bien plus faible que prévuÉtale une couche fine et uniforme
Serrer les vis d'un seul côtéModule fissuré, il ne consomme plus ou fait un court-circuitSerre en croix et progressivement
Inverser brusquement le sensLe module tombe en panne rapidementAttends au moins 30 secondes avant d'inverser le sens
Si la face froide descend sous le point de rosée, l'humidité de l'air se condense dessus. À 25 °C et 50 % d'humidité relative, le point de rosée est d'environ 14 °C ; quand la boîte passe en dessous, des gouttes d'eau se forment sur le dissipateur froid. Garde les cartes électroniques à l'extérieur de la boîte, scelle les bords du Peltier avec du silicone ou de la mousse et ajoute un bac pour recueillir l'eau.

Le module Peltier est une pompe à chaleur silencieuse, sans pièce mobile et réversible ; bien contrôlé avec le bon dissipateur, une alimentation suffisante et un MOSFET ou un BTS7960, il donne une tout autre dimension à tes projets Arduino. Si tu hésites sur le choix du capteur, la comparaison des capteurs de température t'aidera. Dans l'application BlueGrays, tu trouveras, avec schémas de montage et code pas à pas, des projets DHT11, NTC, DHT22 et enregistreur de température ainsi que des exemples de contrôle de puissance par PWM, dont tu pourras adapter facilement la logique de mesure et de régulation à ta propre boîte Peltier.

Questions fréquentes

De combien de degrés un module Peltier refroidit-il ?

L'écart de température maximal du catalogue pour le TEC1-12706 est d'environ 66 °C, mais cette valeur est mesurée quand aucune chaleur n'est prélevée côté froid. Dans une vraie glacière, avec une bonne isolation et un ventirad de CPU, descendre de 10–15 °C sous l'ambiance est un objectif réaliste. Plus tu gardes la face chaude fraîche, plus le côté froid descend.

Peut-on brancher un Peltier directement sur Arduino ?

Non. Le TEC1-12706 consomme environ 5–6 A en 12 V, alors qu'une broche d'Arduino ne peut fournir que 20–40 mA au maximum. Alimente le Peltier avec un adaptateur 12 V séparé et utilise Arduino uniquement pour commander un MOSFET logic-level ou un pont en H comme le BTS7960.

Peut-on fabriquer un réfrigérateur avec un Peltier ?

Tu peux fabriquer un petit refroidisseur de boissons ou une glacière de pique-nique, mais le rendement (COP) d'un Peltier est généralement de 0,3–0,7 ; les réfrigérateurs à compresseur consomment plusieurs fois moins d'énergie pour le même refroidissement. Faire un congélateur avec un seul TEC1-12706 est impossible en pratique ; pour faire de la glace, il faut des modules multi-étages et un refroidissement très puissant.

Combien de watts consomme un TEC1-12706 ?

En 12 V, il consomme environ 5–5,7 A, soit 60–70 W de puissance électrique ; à la tension maximale de 15,4 V, cette valeur approche 100 W. Si tu choisis une alimentation d'au moins 12 V 10 A en comptant les ventilateurs, tu gardes une marge de sécurité.

Quelle face d'un module Peltier refroidit ?

Cela dépend du sens du courant : quand le fil rouge est au plus et le noir au moins, l'une des faces refroidit, et en inversant la polarité les rôles changent. Comme la face portant l'étiquette varie d'un fabricant à l'autre, le plus sûr est de brancher le module en 5 V pendant 1–2 secondes et de toucher les faces pour marquer celle qui se rafraîchit.

Un module Peltier fonctionne-t-il sur batterie ?

Oui, mais pas longtemps. Un pack de trois cellules 18650, soit 11,1 V et 2500 mAh, ne tient que 25–30 minutes à 5 A, et les cellules doivent être de type haute décharge pour fournir ce courant. Pour les projets portables, il est plus judicieux de faire fonctionner le Peltier à faible puissance ou d'utiliser la prise allume-cigare 12 V d'un véhicule.

Voir tous les projets
Température et humidité avec DHT11
AR-55Intermédiaire

Température et humidité avec DHT11

Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

4.7(47)
83
Mesure de la température avec NTC et écran LCD 2x16
AR-44Débutant
Premium

Mesure de la température avec NTC et écran LCD 2x16

Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

4.5(33)
44
ESP32 DHT22 Température et humidité (avec écran LCD)
ES-15Intermédiaire

ESP32 DHT22 Température et humidité (avec écran LCD)

Il s'agit d'un projet permettant de mesurer la température ambiante et le taux d'humidité à l'aide d'un capteur DHT22 et d'afficher ces données en temps réel sur un écran LCD I2C 16x2. Les données du capteur sont lues à l'aide du protocole one-wire grâce à la bibliothèque Adafruit DHT. Ce projet constitue la base des stations météo IoT, de la domotique ou des systèmes de surveillance de l'environnement dans les serres.

4.8(38)
57
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

4.7(7)
12
Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
ES-13Intermédiaire
Premium

Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)

Dans ce projet, nous contrôlons la luminosité d'une LED de manière analogique à l'aide d'un potentiomètre. La broche ADC de l'ESP32 lit la tension entre 0 et 3,3 V provenant du potentiomètre, puis cette valeur est convertie en signal PWM (modulation de largeur d'impulsion) envoyé à la LED. Ainsi, la LED s'allume et s'éteint progressivement. Avec Arduino Core 3.0+, analogWrite() est utilisable directement; sur ESP32-S2/S3, la résolution de l'ADC est fixée à 12 bits.

4.5(19)
32
ESP32 LED Fade avec PWM
ES-8Débutant

ESP32 LED Fade avec PWM

Modifiez la luminosité de la LED en douceur de 0 à max, de max à 0. Nous contrôlons le PWM avec analogWrite() comme dans Arduino - la même syntaxe avec ESP32 Arduino Core 3.0+ fonctionne sans problème. La définition du pin + pinMode + analogWrite est suffisante.

4.8(36)
55
Raspberry Pi Pico PWM LED Fade (Effet Respiration)
PI-14Débutant

Raspberry Pi Pico PWM LED Fade (Effet Respiration)

La LED ne clignote plus — elle respire ! Grâce au PWM (modulation de largeur d'impulsion) du Raspberry Pi Pico, la luminosité monte puis descend lentement. Apprends la classe machine.PWM, duty_u16() (luminosité 16 bits 0–65535), la fréquence PWM, les boucles range() et la sortie quasi analogique. Base du mélange de couleurs RGB, du contrôle moteur, des servos et du buzzer.

4
Station d'irrigation intelligente
AR-83Avancé
Premium

Station d'irrigation intelligente

Un jardinier qui arrose tes plantes tout seul pour qu'elles ne sèchent pas pendant tes vacances.

5.0(42)
57