Peltier-Element Arduino: TEC1-12706 zum Kühlen und Heizen
Peltier-Element mit Arduino ansteuern: TEC1-12706, heiße und kalte Seite, Kühlkörper und Lüfter, 6 A mit MOSFET oder H-Brücke, DS18B20-Thermostat-Code.
Ein Peltier-Element ist ein dünnes thermoelektrisches Bauteil: Fließt Strom hindurch, wird eine Seite kalt und die andere heiß. Mit dem Arduino gesteuert, kannst du damit einen Mini-Kühlschrank, einen Getränkekühler, einen Brutkasten oder eine temperaturgeregelte Versuchsbox bauen. Das gängigste Modell für Bastler ist das TEC1-12706 im Format 40×40 mm: Es läuft mit 12 V, zieht etwa 6 A und pumpt Wärme von einer Seite zur anderen, ganz ohne bewegliche Teile, Kühlgas oder Kompressor. Drehst du die Stromrichtung um, wird die bisher kalte Seite warm – mit demselben Modul kannst du also sowohl kühlen als auch heizen.
Ein Peltier-Element ist allerdings kein Bauteil, das du wie eine LED oder einen Servo direkt an einen Arduino-Pin hängst. Es nimmt allein über 60 Watt auf, die heiße Seite wird innerhalb von Sekunden gefährlich heiß, und ohne großen Kühlkörper und Lüfter zerstört es sich selbst. In diesem Beitrag lernst du, wie ein Peltier-Element funktioniert, wie du die heiße und die kalte Seite unterscheidest, warum ein Kühlkörper Pflicht ist, wie du das richtige Netzteil wählst und wie du es mit MOSFET und H-Brücke ansteuerst. Am Ende baust du eine Mini-Kühlbox mit DS18B20-Temperatursensor und eine Thermostatbox, die sowohl heizt als auch kühlt.
Was ist ein Peltier-Element und wie funktioniert es?
Der Peltier-Effekt wurde 1834 von Jean Charles Peltier entdeckt: Fließt Strom durch die Verbindungsstelle zweier verschiedener Leiter, wird dort Wärme aufgenommen oder abgegeben. Im TEC1-12706 sitzen zwischen zwei dünnen Keramikplatten kleine n- und p-dotierte Halbleiterblöcke aus Bismuttellurid (Bi2Te3). Sie sind elektrisch in Reihe und thermisch parallel geschaltet; fließt der Strom durch jedes n-p-Paar, transportieren die Ladungsträger (Elektronen und Löcher) die Wärme in dieselbe Richtung, nämlich von einer Platte zur anderen. Das Modul verhält sich so wie eine elektrische Festkörper-Wärmepumpe: Es vernichtet keine Wärme, sondern nimmt sie auf einer Seite auf und gibt sie auf der anderen ab.
Der Modellname verrät schon die technischen Eckdaten: TEC steht für Thermoelectric Cooler, die erste 1 für eine einstufige Bauweise, 127 für die Anzahl der n-p-Paare und 06 für einen maximalen Strom von etwa 6 A. In derselben Familie gibt es auch TEC1-12704 (4 A), TEC1-12705 (5 A), TEC1-12708 (8 A) und TEC1-12710 (10 A). Weil die Paarzahl gleich bleibt, arbeiten alle bei etwa 12–15 V; mit steigendem Strom wächst die Wärme, die sie pumpen können.
| Eigenschaft | Wert beim TEC1-12706 |
|---|---|
| Abmessungen | 40 × 40 × 3,8 mm |
| Nennspannung | 12 V (Umax ≈ 15,4 V) |
| Maximaler Strom (Imax) | ≈ 6,4 A |
| Maximale Wärmepumpleistung (Qmax) | ≈ 50–60 W (bei ΔT = 0) |
| Maximaler Temperaturunterschied (ΔTmax) | ≈ 66 °C (heiße Seite 25 °C, ohne Last) |
| Innenwiderstand | ≈ 2 Ω (bei Raumtemperatur) |
| Wirkungsgrad (COP) | Im Praxisbetrieb typisch 0,3–0,7; sinkt mit wachsendem ΔT |
| Aufbau | 127 n-p-Paare, Bismuttellurid, Keramikplatten aus Aluminiumoxid |
| Kabel | Rot (+), Schwarz (−) |
Heiße und kalte Seite: Welche ist welche?
Ein Peltier-Element hat zwei Kabel: Ist Rot an Plus und Schwarz an Minus angeschlossen, wird eine Seite kalt und die andere heiß. Polst du um, tauschen die Seiten die Rollen. Manche Hersteller drucken das Etikett auf die heiße, andere auf die kalte Seite – verlass dich also nicht darauf. Am sichersten gehst du so vor: Leg das Modul auf den Tisch, schließe Rot an Plus und Schwarz an Minus eines 5-V-3-A-Netzteils oder Labornetzteils an, und zwar höchstens 1–2 Sekunden, und fass beide Seiten mit dem Finger an. Markiere die kühlere Seite mit einem Stift. Bleibt es länger angeschlossen, erhitzt sich ein Modul ohne Kühlkörper schnell.
Der Schlüssel zum Verständnis ist ΔT, also der Temperaturunterschied zwischen den beiden Seiten. Das Modul kühlt die kalte Seite nicht auf eine absolute Temperatur, sondern auf einen bestimmten Wert unter der Temperatur der heißen Seite. Die im Datenblatt genannten etwa 66 °C ΔTmax sind der Bestwert, wenn der kalten Seite gar keine Wärme entzogen wird; unter echter Last, also wenn es Wärme aus der Box zieht, sinkt der Unterschied auf 15–30 °C. Steigt die heiße Seite auf 50 °C, bleibt die kalte nur bei etwa 20–30 °C; kannst du die heiße Seite auf 30 °C halten, kann die kalte unter 0 °C fallen. Kurz gesagt: Wie gut du die heiße Seite kühlst, bestimmt die Leistung der kalten Seite.
Warum sind Kühlkörper und Lüfter Pflicht?
Beim Wärmetransport verbraucht das Peltier-Element selbst Strom, und diese Energie wird komplett zu Wärme. Die Wärme, die auf der heißen Seite abgeführt werden muss, ist deshalb die Summe aus der Wärme von der kalten Seite und der elektrischen Leistung: Q_heiß = Q_kalt + V × I. Bei 12 V und 5,5 A nimmt das Modul etwa 66 W auf; zieht es der kalten Seite 20 W, müssen auf der heißen Seite 86 W abgeführt werden. Willst du die heiße Seite höchstens 15 °C über einer Umgebung von 25 °C halten, also bei 40 °C, muss der Kühlkörper einen Wärmewiderstand von 15 / 86 ≈ 0,17 °C/W haben; das schafft nur ein CPU-Kühler mit Lüfter. Ein kleiner Alukühlkörper mit 3 °C/W käme bei gleicher Wärme rechnerisch auf über 250 °C; in der Praxis schmilzt das Lot im Modul und die Keramik reißt, lange bevor es so weit ist.
- Wärmeleitpaste: Trag auf beide Seiten eine dünne, gleichmäßige Schicht auf; eine dicke Schicht verbessert die Wärmeleitung nicht, sondern verschlechtert sie.
- Heiße Seite: Nimm einen CPU-Kühler mit Lüfter oder einen Wasserkühlblock; der Lüfter muss immer laufen, solange das Peltier-Element in Betrieb ist.
- Kalte Seite: Ein kleiner Alukühlkörper in der Box und ein 40–60-mm-Lüfter verteilen die Kälte durch Luftumwälzung in der ganzen Box.
- Anzug der Schrauben: Zieh die Schrauben über Kreuz und nur nach und nach an; einseitig zu festes Anziehen lässt die Keramikplatte reißen.
- Wärmebrücken vermeiden: Füll den Spalt zwischen den beiden Kühlkörpern mit Schaumstoff oder Gummidichtung und nimm Kunststoffscheiben, damit Metallschrauben die Wärme nicht zurückleiten.
- Dämmung: Verwende eine Box aus Styropor oder Schaumstoff; eine dünne Plastikbox lässt die vom Peltier-Element entzogene Wärme sofort wieder von außen eindringen.
Strombedarf und Wahl des Netzteils
Der Innenwiderstand des TEC1-12706 beträgt etwa 2 Ω. Rechnest du mit dem Ohmschen Gesetz I = V / R, ergeben sich bei 12 V zunächst etwa 5,7 A; sobald ein Temperaturunterschied entsteht, senkt die vom Modul selbst erzeugte Seebeck-Spannung den Strom etwas, er bleibt aber bei rund 5 A. Das sind etwa 60–70 W; rechne bei der Berechnung der elektrischen Leistung noch den Strom der Lüfter von 0,2–0,5 A dazu. Als Stromquelle eignet sich ein Schaltnetzteil mit mindestens 12 V 10 A oder die 12-V-Schiene eines alten PC-Netzteils (ATX). USB, der 5V-Pin des Arduino oder eine 9-V-Batterie können diesen Strom nie liefern; Details findest du im Beitrag Arduino-Stromversorgung. Interessant: Ein Peltier-Element arbeitet nicht bei vollem Strom am effizientesten, sondern bei etwa 50–70 % des Maximalstroms. Die gepumpte Wärme wächst proportional zum Strom, die Verluste am Innenwiderstand (I²R) aber mit dem Quadrat des Stroms.
| Versorgungsspannung | Ungefährer Strom | Elektrische Leistung | Einsatz |
|---|---|---|---|
| 5 V | 2,4 A | 12 W | Seitentest, leichte Kühlung, höchste Effizienz |
| 9 V | 4,3 A | 39 W | Ausgewogene Effizienz und Kühlung |
| 12 V | 5,7 A | 69 W | Nennbetrieb, stärkste Kühlung |
| 15,4 V (Umax) | 6,4 A | ≈ 99 W | Grenzwert, nicht im Dauerbetrieb nutzen |
Anschluss: Peltier-Element mit MOSFET und H-Brücke ansteuern
Nutzt du das Peltier-Element nur zum Kühlen oder nur zum Heizen, reicht ein einzelner N-Kanal-MOSFET. Der MOSFET sitzt zwischen dem Minuspol des Peltier-Elements und Masse (Low-Side-Schaltung): Das rote Kabel geht an +12 V, das schwarze an den Drain des MOSFETs, Source an GND. Wähle einen Logic-Level-MOSFET, der mit den 5 V des Arduino Uno voll durchschaltet; der IRLZ44N hat bei 5 V Gate-Spannung etwa 0,025 Ω, wird bei 6 A mit 6² × 0,025 ≈ 0,9 W warm, und ein kleiner Kühlkörper genügt. Die beliebten IRF520-Module schalten mit 5 V dagegen nicht voll durch, werden heiß und begrenzen den Strom. Setz einen 100-Ω-Vorwiderstand ans Gate und einen 10-kΩ-Pulldown zwischen Gate und Source, und verbinde unbedingt die Arduino-Masse mit dem Minuspol des Netzteils (gemeinsame Masse). Mehr zur MOSFET-Wahl findest du im Beitrag MOSFET mit Arduino verwenden. Bei 3,3-V-Boards wie ESP32 und Pico nimmst du einen MOSFET mit niedrigerer Schwelle, etwa den IRLB8721.
Willst du sowohl heizen als auch kühlen, musst du die Stromrichtung umkehren; das geht mit einer H-Brücke. Der aus Roboterprojekten bekannte L298N eignet sich nicht für das Peltier-Element, da er pro Kanal nur 2 A Dauerstrom liefert und über 2 V Spannung verliert. Nimm stattdessen das H-Brücken-Modul BTS7960 (IBT-2), das bis zu 43 A verträgt: PWM am RPWM-Pin lässt den Strom in die eine Richtung fließen, PWM am LPWM-Pin in die andere. Einen Vergleich verschiedener Treiber findest du im Beitrag Motortreiber im Vergleich. Die Polung per mechanischem Relais umzukehren ist ebenfalls möglich, aber bei häufigem Schalten verschleißen die Kontakte, und du kannst die Leistung nicht regeln.
| Anschluss | Arduino Uno (MOSFET) | ESP32 (BTS7960) | Pico (MOSFET) |
|---|---|---|---|
| DS18B20 DATA Box (4,7-kΩ-Pull-up) | D2 | GPIO 4 | GP16 |
| DS18B20 DATA Kühlkörper (4,7-kΩ-Pull-up) | D3 | — | — |
| MOSFET-Gate (über 100 Ω) | D9 | — | GP15 |
| BTS7960 RPWM (Kühlen) | — | GPIO 25 | — |
| BTS7960 LPWM (Heizen) | — | GPIO 26 | — |
| BTS7960 R_EN + L_EN | — | GPIO 27 | — |
| BTS7960 VCC (Logik) | — | 3V3 | — |
| Sensor VCC | 5V | 3V3 | 3V3 (Pin 36) |
| GND | GND + 12-V-Netzteil (−) | GND + 12-V-Netzteil (−) | GND + 12-V-Netzteil (−) |
Schritt für Schritt: Mini-Kühlbox (Arduino + MOSFET)
- Bereite eine gedämmte Box vor (Styropor oder Schaumstoff, 1–3 Liter) und schneide im Deckel ein 40×40-mm-Fenster für das Peltier-Element aus.
- Finde die kalte Seite des Peltier-Elements mit dem 1–2 Sekunden langen 5-V-Test und markiere sie mit einem Stift.
- Trag dünn Wärmeleitpaste auf die heiße Seite auf; setz den CPU-Kühler mit Lüfter außen an die Box, den kleinen Kühlkörper samt Lüfter an die kalte Seite, sodass er in der Box liegt. Zieh die Schrauben über Kreuz und gleichmäßig an und füll den Spalt mit Schaumstoff.
- Verbinde das rote Kabel mit dem Pluspol des 12-V-Netzteils, das schwarze mit dem Drain des IRLZ44N und Source mit dem Minuspol des Netzteils. Schließe beide Lüfter direkt an 12 V an, damit sie immer laufen, solange das System an ist.
- Verbinde Pin D9 des Arduino über einen 100-Ω-Widerstand mit dem Gate, setz einen 10-kΩ-Widerstand zwischen Gate und Source und verbinde die Arduino-Masse mit dem Minuspol des Netzteils.
- Schließe die beiden DS18B20 an: Führe die Datenleitungen an D2 (in der Box) und D3 (heißer Kühlkörper) und setz an jeden einen 4,7-kΩ-Pull-up-Widerstand zwischen 5V und Daten.
- Installiere im Bibliotheksverwalter die Bibliotheken OneWire und DallasTemperature, lade den Code hoch und beobachte die Temperaturen im Seriellen Monitor bei 9600 Baud.

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}| Codezeile | Was sie macht |
|---|---|
| TCCR1B = (TCCR1B & 0b11111000) | 0x02 | Setzt den Timer1-Teiler auf 8; das PWM an Pin 9 steigt von 490 Hz auf etwa 3,9 kHz. |
| DEVICE_DISCONNECTED_C | Erkennt den Wert -127, den du bei abgerissenem Sensorkabel liest, und schaltet das Peltier-Element ab. |
| HOT_LIMIT_C = 60.0 | Fällt der Lüfter aus oder reicht der Kühlkörper nicht, schaltet die Schutzfunktion die heiße Seite bei 60 °C ab. |
| err / BAND_C * MAX_DUTY | Erhöht die Leistung proportional, wenn die Box 0–3 °C über dem Ziel liegt; ab 3 °C gibt es 80 % Leistung. |
| MAX_DUTY = 204 | Begrenzt die Leistung auf 80 %; steigert die Effizienz und verlängert die Lebensdauer von Modul und Netzteil. |
Heizen und Kühlen mit dem ESP32: BTS7960-H-Brücke
Steuerst du das Peltier-Element mit dem ESP32 über den BTS7960 in beide Richtungen, kannst du eine Thermostatbox bauen, die unabhängig von der Umgebungstemperatur konstant bleibt: Liegt die Box über dem Ziel, kühlt sie, liegt sie darunter, heizt sie. Im Heizbetrieb ist das Peltier-Element besonders effizient; die zur Box zeigende Seite erhält sowohl die von außen gepumpte Wärme als auch die aufgenommene elektrische Energie, es kann also mit 40 W Strom mehr als 40 W Wärme abgeben. Schließe das 12-V-Netzteil an die Eingänge B+ und B− des BTS7960 an und das Peltier-Element an die Ausgänge M+ und M−; verbindest du den Logik-VCC-Pin des Moduls mit dem 3V3-Pin des ESP32, erkennt es die 3,3-V-Signale problemlos. Der Code wählt automatisch die unterschiedlichen LEDC-Funktionen von ESP32-Arduino-Core 2.x und 3.x.
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}Im Code stecken zwei wichtige Sicherheitsregeln. Erstens die Hysterese: Das Kühlen startet, wenn die Box 1 °C über dem Ziel liegt, und stoppt beim Erreichen des Ziels; das Heizen funktioniert umgekehrt. So schaltet das System nicht ständig um den Zielwert herum an und aus. Zweitens die Wartezeit beim Richtungswechsel: Ein abrupter Wechsel vom Kühlen zum Heizen erwärmt die eben noch eiskalte Seite schlagartig und erzeugt einen Thermoschock in der Keramik; der Code bleibt deshalb vor dem Wechsel in die Gegenrichtung mindestens 30 Sekunden ausgeschaltet. Welche Richtung kühlt, hängt von deiner Verkabelung ab; wärmt sich die Box beim ersten Versuch auf, tausche die Kabel M+ und M− aus. Für genauere Regelung wirf einen Blick auf die Beiträge Arduino-Thermostat und PID-Regelung.
Peltier-Steuerung mit Raspberry Pi Pico und MicroPython
Auf dem Raspberry Pi Pico kannst du dank der in MicroPython bereits enthaltenen Module onewire und ds18x20 den DS18B20 ohne zusätzliche Bibliothek auslesen. Der folgende Code macht die proportionale Kühlung aus dem Arduino-Beispiel: Das PWM geht von Pin GP15 ans Gate des MOSFETs; der DS18B20 hängt an GP16 und ist mit 4,7 kΩ an 3V3 gezogen. Das PWM des Pico hat 16 Bit Auflösung; duty_u16() nimmt Werte von 0 bis 65535, und 52000 entspricht etwa 80 % Leistung. Denk auch hier für das 3,3-V-Gate-Signal an einen MOSFET mit niedriger Schwelle. Bist du neu bei MicroPython, ist der Beitrag MicroPython-Grundlagen ein guter Einstieg.
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)Projektideen mit dem Peltier-Element
- Getränkekühler für eine Dose: Bau mit einer Styroporbox, einem TEC1-12706 und einem DS18B20 einen Cola-Kühler für den Schreibtisch und zeig die Temperatur auf einem kleinen Display an.
- Brutkasten oder Joghurtmaschine: Nutze das Peltier-Element in Heizrichtung und halte 37–43 °C konstant; die Thermostat-Logik ist auch hier dieselbe.
- Filament-Trockenbox: Entziehe 3D-Drucker-Filament stundenlang bei 45–50 °C die Feuchtigkeit.
- Mini-Luftentfeuchter: Kühl die kalte Seite unter den Taupunkt, sammle die Luftfeuchtigkeit tropfenweise und miss das gesammelte Wasser.
- Thermoelektrischer Generator als Experiment: Halte eine Seite des Peltier-Elements in heißes Wasser, die andere ans Eis und miss die durch den Seebeck-Effekt entstehende Spannung mit einem Arduino-Voltmeter.
- Lüfterdrehzahl nach Temperatur: Regle den Lüfter auf der heißen Seite je nach Kühlkörpertemperatur hoch; Details im Beitrag Arduino-Lüftersteuerung.
- Wissenschaftswettbewerb: Ein Keimgefäß mit konstanter Temperatur oder eine Enzym-Versuchsbox sticht unter den TÜBİTAK-Projektideen hervor.
Häufige Fehler und Lösungen
| Fehler | Symptom | Lösung |
|---|---|---|
| Betrieb ohne Kühlkörper | Das Modul glüht in Sekunden, es riecht, die Keramik reißt | CPU-Kühler mit Lüfter an die heiße Seite, der Lüfter muss immer laufen |
| Kalte Seite kühlt nicht | Beide Seiten werden warm, die Box erwärmt sich | Kühlung der heißen Seite zu schwach oder Polung vertauscht; größeren Kühlkörper nehmen, Kabel prüfen |
| Versorgung über den Arduino | Arduino startet neu, der USB-Port schaltet ab | Das Peltier-Element mit einem separaten 12-V-10-A-Netzteil versorgen |
| Ansteuerung mit L298N | Treiber wird sehr heiß, Strom bleibt bei etwa 2 A | Eine H-Brücke für hohe Ströme wie den BTS7960 verwenden |
| IRF520-Modul verwenden | MOSFET wird heiß, Peltier-Element arbeitet schwach | Einen Logic-Level-MOSFET wie den IRLZ44N nehmen |
| Keine gemeinsame Masse | MOSFET schaltet nicht oder arbeitet zufällig | Arduino-Masse mit dem Minuspol des Netzteils verbinden |
| Dicke Wärmeleitpaste | ΔT viel niedriger als erwartet | Eine dünne, gleichmäßige Schicht auftragen |
| Schrauben einseitig anziehen | Modul gerissen, zieht keinen Strom oder hat Kurzschluss | Über Kreuz und nur nach und nach anziehen |
| Abrupter Richtungswechsel | Modul geht nach kurzer Zeit kaputt | Vor dem Richtungswechsel mindestens 30 Sekunden warten |
Das Peltier-Element ist eine leise Wärmepumpe ohne bewegliche Teile, die in beide Richtungen arbeiten kann; mit dem richtigen Kühlkörper, einem ausreichenden Netzteil und MOSFET oder BTS7960 sicher gesteuert, bringt es eine ganz neue Dimension in deine Arduino-Projekte. Bist du bei der Sensorwahl unsicher, hilft dir der Beitrag Temperatursensoren im Vergleich. In der BlueGrays-App findest du neben Projekten mit DHT11, NTC, DHT22 und Temperaturloggern auch Beispiele zur Leistungsregelung per PWM mit Schaltplan und Code Schritt für Schritt; die Mess- und Regellogik dieser Projekte kannst du leicht auf deine eigene Peltier-Box übertragen.
Häufige Fragen
Wie weit kühlt ein Peltier-Element?
Der höchste Temperaturunterschied laut Datenblatt liegt beim TEC1-12706 bei etwa 66 °C, doch dieser Wert wird gemessen, wenn der kalten Seite gar keine Wärme entzogen wird. In einer echten Kühlbox mit guter Dämmung und CPU-Kühler samt Lüfter ist ein Ziel von 10–15 °C unter der Umgebung realistisch. Je kühler du die heiße Seite hältst, desto kälter wird die kalte.
Kann man ein Peltier-Element direkt an den Arduino anschließen?
Nein. Der TEC1-12706 zieht bei 12 V etwa 5–6 A, ein Arduino-Pin liefert höchstens 20–40 mA. Versorge das Peltier-Element mit einem separaten 12-V-Netzteil und steuere mit dem Arduino nur einen Logic-Level-MOSFET oder eine H-Brücke wie den BTS7960.
Kann man mit einem Peltier-Element einen Kühlschrank bauen?
Einen kleinen Getränkekühler oder eine Kühlbox für Picknicks kann man bauen, aber der Wirkungsgrad (COP) liegt meist bei 0,3–0,7; Kompressorkühlschränke brauchen für dieselbe Kühlung um ein Vielfaches weniger Energie. Mit einem einzelnen TEC1-12706 lässt sich praktisch kein Gefrierfach bauen; für Eis braucht es mehrstufige Module und sehr starke Kühlung.
Wie viel Watt zieht der TEC1-12706?
Bei 12 V etwa 5–5,7 A, also 60–70 W elektrische Leistung; bei der Höchstspannung von 15,4 V nähert sich der Wert 100 W. Wählst du zusammen mit den Lüftern ein Netzteil mit mindestens 12 V 10 A, lässt du dir eine sichere Reserve.
Welche Seite des Peltier-Elements wird kalt?
Das hängt von der Stromrichtung ab: Ist Rot an Plus und Schwarz an Minus angeschlossen, wird eine Seite kalt; bei umgekehrter Polung tauschen sie die Rollen. Weil das Etikett je nach Hersteller auf unterschiedliche Seiten gedruckt ist, verbindest du das Modul am sichersten 1–2 Sekunden mit 5 V, tastest beide Seiten ab und markierst die kühle.
Läuft ein Peltier-Element mit Akku?
Es läuft, aber nicht lange. Ein Pack aus drei 18650-Zellen mit 11,1 V und 2500 mAh hält bei 5 A nur etwa 25–30 Minuten, und die Zellen müssen für diesen Strom ausgelegt sein (hoher Entladestrom). Bei tragbaren Projekten ist es sinnvoller, das Peltier-Element mit geringer Leistung zu betreiben oder die 12-V-Zigarettenanzünder-Buchse im Auto zu nutzen.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

Temperaturmessung mit NTC und 2x16 Lcd Display
Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

ESP32 LED-Überblendung mit PWM
Ändern Sie die Helligkeit der LED stufenlos von 0 bis max, von max bis 0. Wir steuern PWM mit analogWrite() wie in Arduino - die gleiche Syntax mit ESP32 Arduino Core 3.0+ funktioniert reibungslos. Pin-Definition + pinMode + analogWrite ist genug.

Raspberry Pi Pico PWM LED Fade (Atem-Effekt)
Die LED blinkt nicht mehr nur — sie atmet! Mit der PWM (Pulsweitenmodulation) des Raspberry Pi Pico steigt die Helligkeit langsam an und fällt wieder ab. Lerne die machine.PWM-Klasse, duty_u16() (16-Bit-Helligkeit 0–65535), PWM-Frequenz, range()-Schleifen und analogähnliche Ausgabe. Grundlage für RGB-Farbmischung, Motorsteuerung, Servos und Buzzer.

Intelligente Bewässerungsstation
Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

