Componenten · 14 min leestijd

Peltier-module met Arduino: koelen en verwarmen met de TEC1-12706

Hoe gebruik je een TEC1-12706 Peltier-module met Arduino? Hete en koude zijde, koellichaam, 6 A stroom, MOSFET- en H-brugsturing, DS18B20-thermostaatcode.

Een Peltier-module is een dun thermo-elektrisch onderdeel: als er stroom doorheen loopt, wordt de ene zijde koud en de andere heet. Met een Arduino aangestuurd kun je er een mini-koelkast, een drankkoeler, een broedstoof of een temperatuurgeregelde experimenteerkamer mee bouwen. Het meest gebruikte hobbymodel is de 40×40 mm TEC1-12706: hij werkt op 12 V, trekt ongeveer 6 A en pompt warmte van de ene zijde naar de andere zonder bewegende delen, gas of compressor. Als je de stroomrichting omdraait, gaat de koude zijde juist opwarmen; dezelfde module kan dus zowel koelen als verwarmen.

Een Peltier is echter geen onderdeel dat je zomaar op een Arduino-pin aansluit zoals een led of een servo. Op zichzelf verbruikt hij meer dan 60 watt, de hete zijde wordt binnen seconden gevaarlijk heet en zonder groot koellichaam en ventilator maakt hij zichzelf kapot. In dit bericht leer je hoe een Peltier werkt, hoe je de hete zijde van de koude onderscheidt, waarom een koellichaam verplicht is, hoe je de juiste voeding kiest en hoe je hem aanstuurt met een MOSFET en een H-brug. Aan het eind bouw je een mini-koelbox met een DS18B20-temperatuursensor en een thermostaatbox die zowel verwarmt als koelt.

Wat is een Peltier-module en hoe werkt hij?

Het Peltier-effect werd in 1834 ontdekt door Jean Charles Peltier: als er stroom door het knooppunt van twee verschillende geleiders loopt, wordt daar warmte opgenomen of afgegeven. In de TEC1-12706 zitten kleine n-type en p-type halfgeleiderblokjes van bismuttelluride (Bi2Te3) tussen twee dunne keramische platen. Deze blokjes zijn elektrisch in serie en thermisch parallel geschakeld; terwijl er stroom door elk n-p-paar loopt, nemen de ladingdragers (elektronen en gaten) warmte mee in dezelfde richting, van de ene plaat naar de andere. Daardoor gedraagt de module zich als een elektrisch aangedreven warmtepomp zonder bewegende delen: hij vernietigt geen warmte, maar verplaatst die alleen van de ene zijde naar de andere.

De modelnaam geeft ook meteen de technische samenvatting: TEC staat voor thermo-elektrische koeler (thermoelectric cooler), de eerste 1 betekent één trap, 127 is het aantal n-p-paren binnenin en 06 geeft aan dat de maximale stroom ongeveer 6 A is. In dezelfde familie zitten modellen als de TEC1-12704 (4 A), TEC1-12705 (5 A), TEC1-12708 (8 A) en TEC1-12710 (10 A). Omdat het aantal paren gelijk blijft, werken ze allemaal op ongeveer 12–15 V; naarmate de stroom stijgt, neemt ook de warmte toe die ze kunnen verpompen.

EigenschapWaarde TEC1-12706
Afmetingen40 × 40 × 3,8 mm
Nominale spanning12 V (Umax ≈ 15,4 V)
Maximale stroom (Imax)≈ 6,4 A
Maximale warmteverpomping (Qmax)≈ 50–60 W (bij ΔT = 0)
Maximaal temperatuurverschil (ΔTmax)≈ 66 °C (hete zijde 25 °C, zonder belasting)
Inwendige weerstand≈ 2 Ω (bij kamertemperatuur)
Rendement (COP)Meestal 0,3–0,7 in de praktijk; daalt naarmate ΔT groter wordt
Opbouw127 n-p-paren, bismuttelluride, keramische platen van aluminiumoxide
DradenRood (+), zwart (−)

Hete en koude zijde: welke is welke?

Een Peltier heeft twee draden: als de rode draad naar plus gaat en de zwarte naar min, wordt de ene zijde koud en de andere heet. Draai je de polariteit om, dan wisselen de zijden. Sommige fabrikanten drukken het label op de hete zijde en andere op de koude zijde, dus vertrouw het label niet. De veiligste methode is deze: leg de module op tafel, sluit rood aan op de plus en zwart op de min van een 5 V 3 A-adapter of een labvoeding voor hooguit 1–2 seconden en raak beide zijden aan met je vinger. Markeer de zijde die koud werd met een stift. Als je hem langer aangesloten laat, warmt een module zonder koellichaam snel op.

De sleutel tot het begrijpen van een Peltier is ΔT, het temperatuurverschil tussen de twee zijden. De module brengt de koude zijde niet naar een absolute temperatuur; hij brengt hem een bepaald aantal graden onder de hete zijde. De ΔTmax van ongeveer 66 °C uit de catalogus is de beste waarde, gemeten als er helemaal geen warmte aan de koude zijde wordt onttrokken; onder echte belasting, dus als je warmte uit een box haalt, zakt het verschil naar 15–30 °C. Als de hete zijde stijgt tot 50 °C, blijft de koude zijde maar op ongeveer 20–30 °C; kun je de hete zijde op 30 °C houden, dan kan de koude zijde onder 0 °C komen. Kortom: hoe goed je de hete kant koelt, bepaalt de prestaties van de koude kant.

Waarom zijn een koellichaam en ventilator verplicht?

Terwijl een Peltier warmte verplaatst, verbruikt hij ook elektriciteit, en al die energie wordt warmte. De warmte die aan de hete zijde moet worden afgevoerd, is dus de warmte uit de koude zijde plus het elektrische vermogen: Q_hot = Q_cold + V × I. Een module op 12 V en 5,5 A verbruikt ongeveer 66 W elektriciteit; als hij 20 W uit de koude zijde haalt, moet er 86 W aan de hete zijde worden afgevoerd. Wil je de hete zijde hooguit 15 °C boven een kamer van 25 °C houden, dus op 40 °C, dan moet de thermische weerstand van het koellichaam 15 / 86 ≈ 0,17 °C/W zijn; dat haalt alleen een CPU-koellichaam met ventilator. Een klein aluminium koellichaam met een thermische weerstand van 3 °C/W zou bij dezelfde warmte op papier boven 250 °C uitkomen; in de praktijk smelt het soldeer binnenin en barst het keramiek voordat de module daar komt.

  • Warmtegeleidende pasta: Breng een dunne, gelijkmatige laag aan op beide zijden; een dikke laag verbetert de warmteoverdracht niet, maar maakt hem juist slechter.
  • Hete zijde: Gebruik een CPU-koellichaam met ventilator of een waterkoelblok; de ventilator moet altijd draaien zolang de Peltier aan staat.
  • Koude zijde: Een klein aluminium koellichaam in de box en een ventilator van 40–60 mm roeren de lucht om en koelen elk deel van de box.
  • Vastklemmen: Draai de schroeven kruiselings en telkens een beetje aan; aan één kant te vast draaien laat de keramische plaat barsten.
  • Thermische bruggen voorkomen: Vul de ruimte tussen de twee koellichamen op met schuim of een rubberen pakking en gebruik kunststof ringen, zodat metalen schroeven de warmte niet terugvoeren.
  • Isolatie: Gebruik een box van polystyreen of schuim; een dunne plastic box laat de warmte die de Peltier verwijdert direct weer van buiten naar binnen lekken.
Sluit een Peltier nooit aan op 12 V zonder koellichaam en ventilator. De hete zijde kan in een paar seconden boven 100 °C komen, de module raakt blijvend beschadigd en je verbrandt je hand als je hem aanraakt. Voeg ook een veiligheidsmaatregel toe aan je code: schakel de Peltier uit als de ventilator stopt of de hete zijde boven 60 °C komt.

Stroombehoefte en het kiezen van een voeding

De inwendige weerstand van de TEC1-12706 is ongeveer 2 Ω. Als je I = V / R uitrekent met de wet van Ohm, zie je dat hij op 12 V eerst ongeveer 5,7 A trekt; naarmate er een temperatuurverschil tussen de twee zijden ontstaat, verlaagt de Seebeck-spanning die de module zelf opwekt de stroom een beetje, maar hij blijft rond de 5 A. Dat is grofweg 60–70 W; als je een berekening van het elektrisch vermogen doet, tel dan ook de 0,2–0,5 A van de ventilatoren erbij. Een schakelende adapter van minimaal 12 V 10 A of de 12 V-rail van een oude computervoeding (ATX) is geschikt. USB, de 5V-pin van de Arduino of een 9 V-batterij kunnen deze stroom nooit leveren; voor details zie het bericht over de voeding van de Arduino. Een interessant punt: een Peltier is niet bij volle stroom het efficiëntst, maar bij ongeveer 50–70% van zijn maximale stroom. Dat komt doordat de warmte die hij pompt evenredig met de stroom toeneemt, terwijl het weerstandsverlies (I²R) in de module met het kwadraat van de stroom groeit.

VoedingsspanningStroom (ca.)Elektrisch vermogenGebruik
5 V2,4 A12 WZijdetest, lichte koeling, hoogste rendement
9 V4,3 A39 WEvenwichtig rendement en koeling
12 V5,7 A69 WNominaal bedrijf, sterkste koeling
15,4 V (Umax)6,4 A≈ 99 WGrenswaarde, niet continu gebruiken

Bedrading: een Peltier aansturen met een MOSFET en een H-brug

Als je de Peltier alleen wilt koelen of alleen wilt verwarmen, is één N-kanaals MOSFET genoeg. De MOSFET komt tussen de min van de Peltier en massa (low-side-schakeling): de rode draad gaat naar +12 V, de zwarte draad naar de drain van de MOSFET en de source-pin naar GND. Je moet een logic-level MOSFET kiezen die volledig openstaat met de 5 V-pinnen van de Arduino Uno; de IRLZ44N heeft ongeveer 0,025 Ω weerstand bij 5 V gatespanning en dissipeert 6² × 0,025 ≈ 0,9 W bij 6 A, dus een klein koellichaam is genoeg. De populaire IRF520-modules schakelen daarentegen bij 5 V niet volledig in; ze worden heet en beperken de stroom. Plaats een serieweerstand van 100 Ω op de gate en een pull-downweerstand van 10 kΩ tussen gate en source, en verbind de GND van de Arduino altijd met de min van de adapter (gemeenschappelijke GND). De keuze van een MOSFET vind je uitgebreid in het bericht een MOSFET gebruiken met Arduino. Kies op 3,3 V-boards zoals de ESP32 en Pico liever een MOSFET met een lagere drempelspanning, zoals de IRLB8721.

Wil je zowel verwarmen als koelen, dan moet je de stroomrichting kunnen omkeren; dat doe je met een H-brug. De L298N die je kent uit robotprojecten is niet geschikt voor een Peltier, omdat hij maar 2 A continu per kanaal kan leveren en een spanningsval van meer dan 2 V heeft. Gebruik in plaats daarvan de H-brugmodule BTS7960 (IBT-2), die tot 43 A aankan: PWM op de RPWM-pin laat de stroom in de ene richting lopen en PWM op de LPWM-pin in de tegenovergestelde richting. Om verschillende drivers te vergelijken, bekijk je het bericht vergelijking van motordrivers. De polariteit omkeren met een mechanisch relais kan ook, maar bij vaak schakelen slijten de contacten en kun je het vermogen niet regelen.

AansluitingArduino Uno (MOSFET)ESP32 (BTS7960)Pico (MOSFET)
DS18B20 DATA in de box (4,7 kΩ pull-up)D2GPIO 4GP16
DS18B20 DATA op het koellichaam (4,7 kΩ pull-up)D3——
MOSFET-gate (via 100 Ω)D9—GP15
BTS7960 RPWM (koelen)—GPIO 25—
BTS7960 LPWM (verwarmen)—GPIO 26—
BTS7960 R_EN + L_EN—GPIO 27—
BTS7960 VCC (logica)—3V3—
VCC van de sensor5V3V33V3 (pin 36)
GNDGND + 12 V-adapter (−)GND + 12 V-adapter (−)GND + 12 V-adapter (−)
De Peltier rechtstreeks op een Arduino-pin, op de 5V/Vin-pin van de Arduino of op een L298N aansluiten is de meest gemaakte fout. Een Arduino-pin levert hooguit 20–40 mA, terwijl een Peltier er meer dan 150 keer zoveel wil. Bovendien gaat de MOSFET helemaal niet aan, of half aan en dan oververhit hij, als de min van de 12 V-adapter niet met de GND van de Arduino is verbonden.

Stap voor stap: een mini-koelbox (Arduino + MOSFET)

  1. Maak een geïsoleerde box klaar (polystyreen of schuim, 1–3 liter); snijd in het deksel een opening van 40×40 mm voor de Peltier.
  2. Zoek de koude zijde van de Peltier met de 5 V-test van 1–2 seconden en markeer hem met een stift.
  3. Breng een dunne laag warmtegeleidende pasta aan op de hete zijde; plaats het CPU-koellichaam met ventilator buiten de box en het kleine koellichaam met ventilator op de koude zijde, zodat ze in de box zitten. Draai de schroeven gelijkmatig en kruiselings aan en vul de ruimte ertussen met schuim.
  4. Sluit de rode draad aan op de plus van de adapter, de zwarte draad op de drain van de IRLZ44N en de source-pin op de min van de adapter. Sluit beide ventilatoren rechtstreeks aan op 12 V, zodat ze altijd draaien zolang het systeem aan staat.
  5. Sluit Arduino-pin D9 via een weerstand van 100 Ω aan op de gate, plaats een weerstand van 10 kΩ tussen gate en source en verbind de GND van de Arduino met de min van de adapter.
  6. Sluit de twee DS18B20-sensoren aan: leid de datalijnen naar pin D2 (in de box) en D3 (hete koellichaam) en voeg bij elk een pull-upweerstand van 4,7 kΩ toe tussen 5V en data.
  7. Installeer de bibliotheken OneWire en DallasTemperature via de Library Manager, upload de code en open de Serial Monitor op 9600 baud om de temperaturen te volgen.
DS18B20 digitale temperatuursensor
DS18B20: meet van -55 tot +125 °C met een nauwkeurigheid van ±0,5 °C; werkt met één datalijn en een pull-upweerstand van 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}
CoderegelWat het doet
TCCR1B = (TCCR1B & 0b11111000) | 0x02Stelt de prescaler van Timer1 in op 8; PWM op pin 9 gaat van 490 Hz naar ongeveer 3,9 kHz.
DEVICE_DISCONNECTED_CVangt de waarde -127 af bij een verbroken sensordraad en schakelt de Peltier uit.
HOT_LIMIT_C = 60.0Als de ventilator stopt of het koellichaam te klein is, wordt de hete zijde beschermd bij 60 °C.
err / BAND_C * MAX_DUTYVerhoogt het vermogen evenredig terwijl de box 0–3 °C boven de streefwaarde zit; geeft 80% vermogen bij 3 °C en hoger.
MAX_DUTY = 204Beperkt het vermogen tot 80%; verbetert het rendement en verlengt de levensduur van module en adapter.
Pin 9 van de Arduino Uno geeft standaard ongeveer 490 Hz PWM; de TCCR1B-regel in de code verhoogt dat naar ongeveer 3,9 kHz. Omdat je Timer1 verandert, worden ook pin 10 en de Servo-bibliotheek beïnvloed; houd daar rekening mee als je in hetzelfde project een servo gebruikt. De werking van PWM lees je in het bericht wat is PWM. Eigenlijk is regelbare gewone gelijkstroom de efficiëntste methode, want bij PWM is het interne I²R-verlies bij dezelfde gemiddelde stroom hoger; toch is PWM dankzij de eenvoud de meest gebruikte manier in hobbyprojecten. De Peltier aansturen met PWM op kHz-niveau in plaats van hem telkens seconden aan en uit te zetten, vermindert thermische uitzetting en krimp en verlengt de levensduur van de module. Met proportionele regeling kan de box zich iets boven de streefwaarde instellen; die kleine afwijking kun je wegwerken met PID.

Verwarmen en koelen met de ESP32: BTS7960 H-brug

Door de Peltier met een ESP32 via een BTS7960 in beide richtingen aan te sturen, bouw je een thermostaatbox die een constante temperatuur houdt, ongeacht de kamertemperatuur: hij koelt als de box boven de streefwaarde zit en verwarmt als hij eronder zit. In verwarmingsmodus is de Peltier bijzonder efficiënt; de zijde die naar binnen in de box kijkt, krijgt zowel de warmte die hij van buiten pompt als de elektriciteit die hij verbruikt, dus met 40 W elektriciteit kan hij meer dan 40 W warmte leveren. Sluit de 12 V-adapter aan op de ingangen B+ en B− van de BTS7960 en de Peltier op de uitgangen M+ en M−; als je de logica-VCC-pin van de module met de 3V3-pin van de ESP32 verbindt, leest hij de 3,3 V-signalen zonder problemen. De code kiest automatisch de verschillende LEDC-functies in ESP32 Arduino core 2.x en 3.x.

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}

In de code zitten twee belangrijke veiligheidsregels. De eerste is hysterese: het koelen begint als de box 1 °C boven de streefwaarde komt en stopt als hij de streefwaarde bereikt; verwarmen werkt andersom. Zo schakelt het systeem niet constant aan en uit rond de streefwaarde. De tweede is de wachttijd bij omkeren: een abrupte overgang van koelen naar verwarmen verwarmt plotseling een zijde die een seconde eerder ijskoud was en veroorzaakt thermische schok in het keramiek; daarom blijft de code minstens 30 seconden uit voordat hij naar de tegenovergestelde richting schakelt. Welke richting koelt, hangt af van je bedrading; als de box bij de eerste poging opwarmt, wissel je de draden M+ en M− om. Voor nauwkeurigere regeling zie je de berichten over de Arduino-thermostaat en PID-regeling.

Peltier-sturing met Raspberry Pi Pico en MicroPython

Op de Raspberry Pi Pico kun je dankzij de modules onewire en ds18x20 die in MicroPython zijn ingebouwd een DS18B20 uitlezen zonder extra bibliotheek te installeren. De onderstaande code doet dezelfde proportionele koeling als het Arduino-voorbeeld: PWM gaat van pin GP15 naar de gate van de MOSFET; de DS18B20 zit op GP16 en is met 4,7 kΩ naar 3V3 getrokken. De PWM van de Pico heeft een resolutie van 16 bit; duty_u16() neemt een waarde van 0 tot 65535 en 52000 komt overeen met ongeveer 80% vermogen. Vergeet niet om voor het 3,3 V-gatesignaal weer een MOSFET met lage drempelspanning te gebruiken. Ben je nieuw met MicroPython, dan is het bericht basis van MicroPython een goed begin.

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)

Projectideeën met een Peltier

  • Koeler voor één blikje: Maak een frisdrankkoeler voor op je bureau met een polystyreen box, één TEC1-12706 en een DS18B20; toon de temperatuur op een klein display.
  • Broedstoof of yoghurtmaker: Gebruik de Peltier in de verwarmende richting om het bereik van 37–43 °C stabiel te houden; de logica van de thermostaat is hier ook hetzelfde.
  • Droogbox voor filament: Haal uren lang vocht uit 3D-printerfilament bij 45–50 °C.
  • Mini-ontvochtiger: Breng de koude zijde onder het dauwpunt om druppel voor druppel vocht uit de lucht op te vangen en meet het opgevangen water.
  • Experiment met thermo-elektrische generator: Leg de ene zijde van de Peltier op heet water en de andere op ijs; meet de spanning die het Seebeck-effect opwekt met een Arduino-voltmeter.
  • Ventilatorsnelheid op basis van temperatuur: Laat de ventilator aan de hete zijde sneller draaien naarmate het koellichaam warmer wordt; details staan in het bericht ventilatorregeling met Arduino.
  • Project voor een wetenschapsbeurs: Een kiemkamer voor zaden met constante temperatuur of een enzymexperimentbox valt op tussen de projectideeën voor wetenschapswedstrijden.

Veelgemaakte fouten en hoe je ze oplost

FoutSymptoomOplossing
Gebruiken zonder koellichaamDe module oververhit in seconden, je ruikt een brandlucht, het keramiek barstMonteer een CPU-koellichaam met ventilator op de hete zijde en laat de ventilator altijd draaien
De koude zijde koelt nietBeide zijden worden warm, de box warmt opDe koeling van de hete zijde is onvoldoende of de polariteit is omgekeerd; gebruik een groter koellichaam, controleer de draden
Voeden vanuit de ArduinoDe Arduino reset, de USB-poort valt uitVoed de Peltier met een aparte 12 V 10 A-adapter
Aansturen met een L298NDe driver wordt erg heet, de stroom blijft rond 2 AGebruik een H-brug voor hoge stroom, zoals de BTS7960
Een IRF520-module gebruikenDe MOSFET wordt heet, de Peltier werkt zwakGebruik een logic-level MOSFET zoals de IRLZ44N
Geen gemeenschappelijke GNDDe MOSFET gaat niet aan of werkt willekeurigVerbind de GND van de Arduino met de min van de adapter
Dikke warmtegeleidende pastaΔT is veel lager dan verwachtBreng een dunne, gelijkmatige laag aan
De schroeven aan één kant aandraaienDe module is gebarsten, trekt geen stroom of sluit kortDraai kruiselings en telkens een beetje aan
Abrupt omkerenDe module faalt snelWacht minstens 30 seconden voordat je omkeert
Als de koude zijde onder het dauwpunt komt, condenseert vocht uit de lucht erop. Bij 25 °C en 50% relatieve luchtvochtigheid ligt het dauwpunt rond 14 °C; als de box daaronder komt, vormen zich waterdruppels op het koude koellichaam. Houd elektronische boards buiten de box, dicht de randen van de Peltier af met siliconenkit of schuim en plaats een opvangbakje voor het opgevangen water.

Een Peltier-module is een stille warmtepomp zonder bewegende delen die in beide richtingen kan werken; veilig aangestuurd met het juiste koellichaam, een voldoende sterke voeding en een MOSFET of BTS7960 geeft hij Arduino-projecten een geheel nieuwe dimensie. Als je geen sensor kunt kiezen, helpt het bericht vergelijking van temperatuursensoren je verder. In de BlueGrays-app vind je projecten met DHT11, NTC, DHT22 en een temperatuurlogger, plus voorbeelden van PWM-vermogensregeling met schakelschema's en code stap voor stap, en je kunt de meet- en regellogica uit die projecten eenvoudig aanpassen aan je eigen Peltier-box.

Veelgestelde vragen

Hoe koud kan een Peltier-module worden?

Het maximale temperatuurverschil van de TEC1-12706 in de catalogus is ongeveer 66 °C, maar die waarde wordt gemeten als er geen warmte aan de koude zijde wordt onttrokken. In een echte koelbox met goede isolatie en een CPU-koellichaam met ventilator is 10–15 °C onder de omgevingstemperatuur komen een realistisch doel. Hoe koeler je de hete zijde houdt, hoe kouder de koude kant wordt.

Kun je een Peltier rechtstreeks op een Arduino aansluiten?

Nee. De TEC1-12706 trekt op 12 V ongeveer 5–6 A, terwijl een Arduino-pin hooguit 20–40 mA kan leveren. Je moet de Peltier voeden met een aparte 12 V-adapter en de Arduino alleen gebruiken om een logic-level MOSFET of een H-brug zoals de BTS7960 aan te sturen.

Kun je een koelkast maken met een Peltier?

Je kunt een kleine drankkoeler of picknickbox maken, maar het rendement (COP) van een Peltier ligt meestal tussen 0,3 en 0,7; koelkasten met compressor gebruiken voor dezelfde koeling een veelvoud minder energie. Een vriezer maken met één TEC1-12706 is niet praktisch; voor ijs maken heb je modules met meerdere trappen en zeer sterke koeling nodig.

Hoeveel watt trekt de TEC1-12706?

Op 12 V trekt hij ongeveer 5–5,7 A, dat is 60–70 W elektrisch vermogen; bij de maximale spanning van 15,4 V loopt dit richting 100 W. Kies je een voeding van minimaal 12 V 10 A, inclusief de ventilatoren, dan houd je een veilige marge over.

Welke kant van een Peltier-module wordt koud?

Dat hangt af van de stroomrichting: als de rode draad naar plus gaat en de zwarte naar min, wordt een van de zijden koud, en als je de polariteit omdraait, wisselen de rollen. Omdat de zijde met het label per fabrikant verschilt, is de veiligste manier om de module 1–2 seconden op 5 V aan te sluiten en de zijde die koud wordt te markeren door beide zijden aan te raken.

Kan een Peltier-module op een batterij werken?

Het werkt, maar niet lang. Een pakket van drie 18650-cellen, 11,1 V en 2500 mAh, houdt bij een stroom van 5 A maar 25–30 minuten vol, en de cellen moeten een type met hoge ontlaadstroom zijn dat die stroom kan leveren. Voor draagbare projecten is het zinvoller om de Peltier op laag vermogen te laten werken of de 12 V-sigarettenaanstekerbus van een auto te gebruiken.

Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

Temperatuur en luchtvochtigheid met DHT11

Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

4.7(47)
83
Temperatuur meten met NTC en 2x16 LCD-display
AR-44Beginner
Premium

Temperatuur meten met NTC en 2x16 LCD-display

Meet de temperatuur om je heen met een sensor die op een klein kraaltje lijkt. Dit onderdeel, een NTC, laat elektriciteit makkelijker door naarmate het warmer wordt; de Arduino leest die verandering…

4.5(33)
44
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)

Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

4.8(38)
57
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

4.7(7)
12
ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
ES-13Gemiddeld
Premium

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)

In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

4.5(19)
32
ESP32-led dimmen met PWM
ES-8Beginner

ESP32-led dimmen met PWM

De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

4.8(36)
55
Raspberry Pi Pico PWM-led-fade (ademeffect)
PI-14Beginner

Raspberry Pi Pico PWM-led-fade (ademeffect)

De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

4
Slim bewateringsstation
AR-83Gevorderd
Premium

Slim bewateringsstation

Een tuinier die je planten zelf water geeft, zodat ze niet uitdrogen terwijl jij op vakantie bent.

5.0(42)
57