7805 Spannungsregler: Pinbelegung, Kondensatoren und Kühlkörper

Der 7805 Spannungsregler ist ein günstiger IC mit drei Beinen, der eine höhere oder schwankende Spannung zwischen 7 und 35 V in stabile 5 V umwandelt. Er ist der einfachste Weg, aus einem 12-V-Netzteil, einer Autobatterie oder einem Akkupack saubere 5 V für Arduino, Sensoren und Relaismodule zu gewinnen: Du brauchst nur zwei kleine Kondensatoren dazu. Allerdings arbeitet der 7805, indem er die überschüssige Spannung in Wärme verwandelt. Wer die richtige Beschaltung, die Grenzen der Eingangsspannung und die zu erwartende Erwärmung kennt, baut deshalb eine Schaltung, die zuverlässig läuft.

In dieser Anleitung lernst du Schritt für Schritt, was ein Spannungsregler ist, wie die Pinbelegung des 7805 aussieht und wie du ihn mit 0,33 µF und 0,1 µF beschaltest, was die Dropout-Spannung bedeutet, wie du die Verlustleistung mit P = (Vin − Vout) · I berechnest und einen Kühlkörper auswählst. Danach schauen wir uns die 78xx-Familie, den AMS1117-3.3 als LDO für 3,3-V-Module, den Unterschied zwischen Linear- und Schaltregler (Buck), den eingebauten Regler des Arduino und die Vin-Grenze an und messen den Regler schließlich mit Arduino, ESP32 und Raspberry Pi Pico.

Was ist ein Spannungsregler und wie funktioniert er?

Ein Spannungsregler ist eine Schaltung, die an ihrem Ausgang eine konstante Spannung hält, auch wenn sich die Eingangsspannung oder der Laststrom ändert. Der 7805 ist ein Linearregler (Längsregler): Im Inneren sitzen ein Leistungstransistor in Reihe zwischen Ein- und Ausgang, eine temperaturstabile interne Referenzspannung und ein Fehlerverstärker, der den Ausgang ständig mit dieser Referenz vergleicht. Sinkt der Ausgang unter 5 V, leitet der Transistor etwas mehr; steigt er darüber, regelt er zurück. Kurz gesagt verhält sich der Transistor wie ein sich selbst einstellender Widerstand, an dem die überschüssige Spannung abfällt. Diese Spannung mal Strom wird zu Wärme, und genau das macht den 7805 so einfach und zugleich so warm.

Die letzten beiden Ziffern der 78er-Familie verraten die Ausgangsspannung: Ein 7805 liefert 5 V, ein 7812 liefert 12 V. Die Buchstaben davor stehen nur für den Hersteller; LM7805, L7805CV, MC7805 und KA7805 erledigen dieselbe Aufgabe. Im Chip stecken eine Strombegrenzung, eine Übertemperaturabschaltung und ein Schutz des sicheren Arbeitsbereichs. Deshalb geht er selbst bei einem Kurzschluss am Ausgang kaum kaputt, sondern begrenzt nur den Strom oder schaltet ab, bis er abgekühlt ist.

7805 Pinbelegung und Schaltplan

Hältst du den 7805 mit der beschrifteten Seite zu dir und den Beinen nach unten, lauten die Pins von links nach rechts 1: Eingang (IN), 2: GND und 3: Ausgang (OUT). Die Metallfahne mit dem Loch ist ebenfalls mit GND verbunden; du kannst den 7805 also ohne Isolierung auf einen Kühlkörper oder ein Metallgehäuse schrauben, das an der Masse der Schaltung liegt. Masse auf der Eingangsseite und Masse auf der Ausgangsseite sind derselbe Punkt: Netzteil, Regler und das versorgte Board müssen sich an einer gemeinsamen Masse treffen. Die Tabelle zeigt, wo der Ausgang des 7805 am jeweiligen Board angeschlossen wird.

Kondensatoren: warum 0,33 µF und 0,1 µF?

Die Standardschaltung in den Datenblättern der Hersteller hat am Eingang einen 0,33-µF- und am Ausgang einen 0,1-µF-Kondensator (manche Hersteller nennen 0,22 µF am Eingang). Der Eingangskondensator verhindert Schwingungen durch die Induktivität der Leitungen, wenn der Regler weit vom Siebkondensator des Netzteils entfernt sitzt. Der Ausgangskondensator ist für die Stabilität nicht zwingend, hält die Spannung bei plötzlichen Lastwechseln aber ruhiger. Beide sollten Keramikkondensatoren sein und so nah wie möglich an den Beinen sitzen. Auf einem 0,33-µF-Keramikkondensator steht 334, auf einem 0,1-µF-Kondensator 104; andere Aufdrucke entschlüsselst du mit dem Kondensator-Code-Rechner.

In der Praxis lohnt es sich, jedem der beiden kleinen Kondensatoren einen Elko zur Seite zu stellen: 10–100 µF am Eingang glätten die Restwelligkeit der Quelle, 10–47 µF am Ausgang mildern Spannungseinbrüche bei Lasten mit plötzlichem Strombedarf wie Servos, Relais oder WLAN-Modulen. Setzt du mehr als 10 µF an den Ausgang, schalte eine 1N4001 vom Ausgang zum Eingang (im Normalbetrieb in Sperrrichtung) für den Fall, dass der Eingang kurzgeschlossen wird: Fällt der Eingang plötzlich auf null, entlädt sich der große Kondensator über diese Diode statt durch den Regler. Eine zweite 1N4001 in Reihe zum Eingang dient als Verpolungsschutz, kostet aber etwa 0,7 V. Zu Bauformen und Polung findest du mehr in Was ist ein Kondensator? und Was ist eine Diode?.

Schritt für Schritt: 5-V-Versorgung mit dem 7805 auf dem Steckbrett

1. Stecke den 7805 so ins Steckbrett, dass jedes Bein in einer eigenen Spalte steckt und die Beschriftung zu dir zeigt.
2. Verbinde den Pluspol der Quelle (z. B. ein 9-V-Netzteil) mit Pin 1, dem Eingang, und den Minuspol mit Pin 2, GND. Wenn du willst, setze eine 1N4001 als Verpolungsschutz in Reihe zur Plusleitung.
3. Setze den 0,33-µF-Keramikkondensator (334) zwischen Eingang und GND, in die Löcher direkt neben den Beinen.
4. Setze den 0,1-µF-Keramikkondensator (104) und optional einen 10–47-µF-Elko zwischen Ausgang (3) und GND; das lange Bein des Elkos kommt an Plus.
5. Miss den Ausgang vor dem Anschließen einer Last mit dem Multimeter: Du solltest 4,8–5,2 V sehen.
6. Verbinde den Ausgang mit dem 5V-Pin des Arduino und GND mit dessen GND. Vermeide es, beim Hochladen USB und externe Versorgung gleichzeitig zu nutzen.
7. Prüfe nach ein paar Minuten Betrieb die Temperatur des Reglers; wird er sehr heiß, setze anhand der Wärmeberechnung unten einen Kühlkörper ein oder senke die Eingangsspannung.

Dropout-Spannung: Wie viel Volt braucht der Eingang mindestens?

Damit ein Linearregler seinen Ausgang stabil halten kann, muss der Eingang um einen bestimmten Betrag über dem Ausgang liegen; diese minimale Differenz heißt Dropout-Spannung. Beim 7805 beträgt sie typisch 2 V bei 1 A, für 5 V am Ausgang brauchst du also mindestens 7 V am Eingang, und auch die Messbedingungen im Datenblatt beginnen bei 7–7,5 V. Fällt die Differenz darunter, kann der Regler nicht mehr regeln und der Ausgang folgt dem Eingang einfach etwa 2 V tiefer: Bei 6 V am Eingang sackt der Ausgang auf rund 4 V ab, der Arduino setzt sich zurück oder die Analogwerte driften.

Entscheidend ist nicht der Mittelwert, sondern der tiefste Punkt der Eingangsspannung. In einem klassischen Netzteil aus Trafo, Brückengleichrichter und Siebkondensator schwankt die Spannung in jeder Halbwelle; die Restwelligkeit lässt sich mit etwa ΔV = I / (100 · C) abschätzen (50-Hz-Netz, Vollweggleichrichtung). Bei 500 mA Last und 2200 µF ergibt das ΔV ≈ 2,3 V. Ein gleichgerichteter 9-V-Wechselspannungstrafo erreicht etwa 11,3 V Spitze, das Tal der Welligkeit liegt also bei rund 9 V; das ist über 7 V und reicht. Nach derselben Logik fällt ein 9-V-Block unter Last schnell unter 7 V, deshalb hält ein 7805 an einem 9-V-Block nicht lange durch. Mehr zu Batterien findest du in der Anleitung Arduino mit Batterie betreiben.

Wärmeberechnung: P = (Vin − Vout) · I

Der Strom, den ein 7805 am Eingang aufnimmt, ist fast genauso groß wie der Strom, den er am Ausgang abgibt; der Unterschied ist nur ein Ruhestrom von wenigen Milliampere. Die im Regler in Wärme umgesetzte Leistung ist daher P = (Vin − Vout) · I, und der Wirkungsgrad beträgt grob Vout / Vin. Beispiel: Versorgst du eine Schaltung mit 500 mA aus einem 12-V-Netzteil, entstehen P = (12 − 5) × 0,5 = 3,5 W Wärme. Für 2,5 W an der Last gehen 3,5 W verloren, der Wirkungsgrad liegt bei nur 42 %. Versorgst du dieselbe Schaltung mit 7,5 V, sinkt der Verlust auf 1,25 W. Eine unnötig hohe Eingangsspannung bringt also nichts außer zusätzlicher Wärme im Regler. Den Zusammenhang von Strom, Spannung und Leistung kannst du im Artikel zum ohmschen Gesetz auffrischen.

Den passenden Kühlkörper auswählen

Die Sperrschichttemperatur ergibt sich aus Tj = Tumgebung + P · θ; θ (Theta) ist der Wärmewiderstand in °C/W. Ein TO-220-Gehäuse ohne Kühlkörper hat zur Luft einen Wärmewiderstand von 50–65 °C/W: 1 W Verlust hebt den Chip um 50–65 °C über die Umgebung. In einem sicheren Design bleibt die Sperrschicht unter 125 °C, in einem 25 °C warmen Raum sind ohne Kühlkörper also höchstens etwa 1,5 W drin. Wird es im Gehäuse 50–60 °C warm, sinkt die Grenze auf 1 W. Bei jedem Fall in der Tabelle oben, der 1 W übersteigt, solltest du an einen Kühlkörper denken.

Für mehr Leistung berechnest du den Wärmewiderstand des Kühlkörpers: θgesamt = θJC + θCS + θSA. Beim 7805 liegt θJC (Sperrschicht–Gehäuse) bei etwa 5 °C/W, θCS (Gehäuse–Kühlkörper) mit Wärmeleitpaste bei etwa 0,5–1 °C/W. Um im 3,5-W-Beispiel die Sperrschicht in einem 40 °C warmen Gehäuse auf 110 °C zu halten, muss θgesamt ≤ (110 − 40) / 3,5 = 20 °C/W sein; für den Kühlkörper selbst bleibt θSA ≤ 20 − 5 − 1 = 14 °C/W. Kleine aufsteckbare TO-220-Kühlkörper haben meist 20–30 °C/W und reichen nicht; du brauchst einen mittelgroßen Rippenkühlkörper aus Aluminium. Die Hersteller geben diesen Wert im Katalog in °C/W an.

• Wärmeleitpaste verwenden: Der dünne Luftspalt zwischen Gehäuse und Kühlkörper verschlechtert die Wärmeübertragung deutlich; eine dünne Schicht Paste genügt.
• Die Fahne liegt auf GND: Beim 78xx ist die Metallfahne mit GND verbunden, der Kühlkörper muss also nicht isoliert werden und mehrere 78xx können sich einen Kühlkörper teilen. Beim 79xx liegt die Fahne am Eingang und muss mit Glimmerscheibe und Isolierbuchse isoliert werden.
• Nicht auf den Übertemperaturschutz verlassen: Ein überhitzter 7805 schaltet sich ab und nach dem Abkühlen wieder ein. Der Ausgang fällt alle paar Sekunden aus und der Arduino startet ständig neu; das ist ein Notschutz, kein normaler Betrieb.
• Wärme aufteilen: Am wirksamsten ist eine niedrigere Eingangsspannung. Willst du aus 24 V 5 V machen, gehe zuerst mit einem Step-down-Wandler auf 7–8 V und nutze den 7805 erst als letzte Stufe.

Die 78xx-Serie: 7805, 7809, 7812 und weitere

Brauchst du eine einstellbare Spannung, nimm den Verwandten LM317: Mit zwei Widerständen liefert er jede Spannung von 1,25 bis 37 V, die sich aus Vout = 1,25 × (1 + R2 / R1) ergibt (R1 meist 240 Ω). Für Wärme und Dropout gelten dieselben Regeln wie beim 7805. Der 78M05 mit 500 mA ist die mittlere Leistungsklasse, die du oft auf SMD-Platinen findest. Egal welchen Typ du wählst, die Regel bleibt: Der Eingang muss mindestens etwa 2–3 V über dem Ausgang liegen.

AMS1117-3.3 LDO: für 3,3-V-Module

ESP32, Raspberry Pi Pico, nRF24L01 und viele Sensoren laufen mit 3,3 V. Mit einem 7805 bekommst du keine 3,3 V; die häufigste Wahl dafür ist der AMS1117-3.3. Der AMS1117 ist ein LDO-Regler (Low Dropout): Bei 800 mA beträgt sein Dropout typisch 1,1 V und höchstens 1,3 V, er macht also problemlos 3,3 V aus 5 V. Er liefert bis zu 1 A, verträgt am Eingang höchstens 15 V und zieht im Leerlauf etwa 5 mA. Er ist auch der Regler, der auf den meisten ESP32-Entwicklungsboards 5 V auf 3,3 V senkt.

Beim SOT-223-Gehäuse des AMS1117 ist die Pinfolge anders als beim 7805: 1: GND/ADJ, 2: Ausgang, 3: Eingang, und die große Fahne liegt am Ausgang. Das Datenblatt empfiehlt für die Stabilität einen 22-µF-Tantalkondensator am Ausgang; fertige Module kommen mit 10-µF-Kondensatoren und laufen mit üblichen Lasten problemlos, baust du die Schaltung aber selbst, setze 22 µF an den Ausgang. Bei Wärme ist er empfindlicher: Der Wärmewiderstand des SOT-223-Gehäuses liegt je nach Kupferfläche auf der Platine bei 46–90 °C/W, und der Hersteller garantiert die Regelung nur bis etwa 1,2 W. Von 5 V auf 3,3 V bei 300 mA sind es P = 1,7 × 0,3 = 0,51 W, das ist kein Problem; von 12 V auf 3,3 V bedeutet derselbe Strom aber 2,6 W, und das Modul geht schnell in die Übertemperaturabschaltung.

Bei einem Projekt, das monatelang mit Batterie laufen soll, ist der Ruhestrom genauso wichtig wie der Dropout: Der AMS1117 zieht etwa 5 mA, selbst wenn er nichts versorgt, und das ist ein Vielfaches dessen, was ein ESP32 im Deep Sleep verbraucht. Auch für 3,3 V aus einer einzelnen Li-Ionen-Zelle (3,0–4,2 V) ist der Spannungsabfall von 1,1 V zu groß: Selbst bei einer vollen 4,2-V-Zelle kommen am Ausgang nur etwa 3,1 V an, und mit sinkender Ladung wird es weniger. Für solche Projekte sind LDOs wie der MCP1700 mit Ruheströmen im Mikroamperebereich und weniger als 0,2 V Dropout die bessere Wahl.

Linearregler oder Schaltregler (Buck)?

Ein Schaltregler (Buck- bzw. Step-down-Wandler) verheizt die überschüssige Spannung nicht, sondern schaltet den Eingang zehntausende Male pro Sekunde ein und aus und überträgt die Energie über eine Spule und einen Kondensator an den Ausgang. So steigt der Wirkungsgrad auf 80–95 %, und der Eingangsstrom ist kleiner als der Ausgangsstrom. Module mit dem LM2596 liefern zum Beispiel aus 4,5–40 V einen einstellbaren Ausgang bis 3 A und schalten mit 150 kHz. Der Preis dafür sind einige zehn Millivolt Schaltwelligkeit (Ripple) am Ausgang, elektromagnetische Störungen und mehr Bauteile. Einstellung und Anschluss des Moduls beschreibt der Artikel zum LM2596 Step-down-Wandler.

Die Faustregel lautet: Ist die Differenz zwischen Ein- und Ausgang klein (2–4 V) und bleibt der Strom unter einigen hundert Milliampere, ist ein 7805 oder ein LDO einfach, rauscharm und günstig. Ist die Differenz groß, liegt der Strom über 500 mA oder läuft das Projekt mit Batterie, nimm einen Schaltregler. Für Analogmessungen, Audio oder empfindliche Sensoren ist auch die Kombination üblich: zuerst mit einem Buck auf 7–8 V, dann mit dem 7805 rauscharme 5 V erzeugen. So bekommst du Wirkungsgrad und saubere Versorgung zugleich.

Der eingebaute Regler des Arduino und die Vin-Grenze

Die Spannung an der Hohlbuchse oder am Vin-Pin des Arduino Uno R3 läuft durch einen 5-V-LDO der 1117-Familie auf dem Board (auf dem Original ein NCP1117, bei Klonen meist ein AMS1117), und hinter der Buchse sitzt eine Diode vom Typ 4007 als Verpolungsschutz. Arduino empfiehlt 7–12 V, die Grenze des Boards liegt bei 6–20 V. Die untere Grenze kommt vom Dropout: Diode und Regler schlucken zusammen etwa 2 V, unter 7 V sinkt die 5V-Schiene. Die obere Grenze kommt von der Wärme: Bei 12 V an Vin und 200 mA Last erzeugt der kleine SOT-223-Regler (12 − 5) × 0,2 = 1,4 W und wird zu heiß zum Anfassen. Bei 20 V bedeutet dieselbe Last 3 W.

Du kannst auch am 5V-Pin des Boards Strom entnehmen, aber auch dieser Strom fließt durch denselben Regler. Bei USB-Versorgung kommt die 5V-Schiene direkt vom USB und ist durch eine 500-mA-Sicherung begrenzt; bei Versorgung über die Buchse setzt die Wärme des Reglers die Grenze. Versorge Lasten wie Servos, LED-Streifen oder Motoren deshalb nicht über den 5V-Pin des Arduino, sondern über einen eigenen 7805 oder ein Buck-Modul, und verbinde die Massen. Der 3.3V-Pin liefert nur 50 mA; für stromhungrige Module wie den ESP-01 oder einen nRF24L01 mit Antenne nimmst du einen eigenen AMS1117-3.3. Die Lage der Pins zeigt der Artikel zur Arduino-Uno-Pinbelegung.

Den Regler mit dem Arduino testen: Eingang, Ausgang und Wärme

Der folgende Sketch misst Ein- und Ausgangsspannung des 7805, gibt Differenz, Verlustleistung und geschätzte Sperrschichttemperatur im seriellen Monitor aus und warnt, wenn der Dropout naht oder ein Kühlkörper nötig ist. Die Eingangsspannung liegt über 5 V und darf nicht direkt an einen Analogpin: Verbinde den Eingang über einen Spannungsteiler aus 100 kΩ und 22 kΩ mit A0 (misst bis etwa 27 V) und den Ausgang über zwei 10-kΩ-Widerstände mit A1. Die Teilerverhältnisse für deine eigenen Widerstände prüfst du mit dem Spannungsteiler-Rechner. Alle Massen müssen verbunden sein.

1// 7805 test istasyonu: giriş, çıkış ve ısı / 7805 test bench: input, output and heat
2// Kart: Arduino Uno / Nano (ATmega328P) / Board: Arduino Uno / Nano (ATmega328P)
3
4const float R1_IN  = 100000.0;  // giriş bölücü üst direnç / input divider top resistor
5const float R2_IN  = 22000.0;   // giriş bölücü alt direnç / input divider bottom resistor
6const float R1_OUT = 10000.0;   // çıkış bölücü üst direnç / output divider top resistor
7const float R2_OUT = 10000.0;   // çıkış bölücü alt direnç / output divider bottom resistor
8
9const float LOAD_A    = 0.30;   // multimetreyle ölçtüğün yük akımı (A) / load current measured with a multimeter (A)
10const float THETA_JA  = 60.0;   // soğutucusuz TO-220, °C/W / TO-220 without heatsink, °C/W
11const float T_AMBIENT = 30.0;   // ortam sıcaklığı (°C) / ambient temperature (°C)
12const float DROPOUT_V = 2.0;    // 7805 için gereken en az fark (V) / minimum headroom for the 7805 (V)
13
14// Gerçek besleme gerilimini dahili 1,1 V referansla ölçer (mV)
15// Measures the real supply voltage with the internal 1.1 V reference (mV)
16long readVcc() {
17  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);  // referans AVcc, kanal 1,1 V / AVcc reference, 1.1 V channel
18  delay(2);                                               // referansın oturmasını bekle / let the reference settle
19  ADCSRA |= _BV(ADSC);                                    // dönüşümü başlat / start a conversion
20  while (bit_is_set(ADCSRA, ADSC));                       // bitmesini bekle / wait until it finishes
21  long raw = ADCL;                                        // önce ADCL okunmalı / ADCL must be read first
22  raw |= ADCH << 8;
23  return 1125300L / raw;                                  // 1,1 x 1023 x 1000
24}
25
26// Bölücünün arkasındaki gerçek gerilimi hesaplar / Calculates the real voltage behind a divider
27float readVolts(uint8_t pin, float vcc, float r1, float r2) {
28  analogRead(pin);                                        // ilk okumayı at / discard the first reading
29  long sum = 0;
30  for (int i = 0; i < 16; i++) sum += analogRead(pin);    // 16 örneğin ortalaması / average of 16 samples
31  float vPin = (sum / 16.0) * vcc / 1023.0;
32  return vPin * (r1 + r2) / r2;
33}
34
35void setup() {
36  Serial.begin(9600);
37}
38
39void loop() {
40  float vcc  = readVcc() / 1000.0;
41  float vin  = readVolts(A0, vcc, R1_IN, R2_IN);
42  float vout = readVolts(A1, vcc, R1_OUT, R2_OUT);
43
44  float headroom = vin - vout;                    // regülatör üzerindeki gerilim / voltage across the regulator
45  float heatW    = headroom * LOAD_A;             // P = (Vin - Vout) x I
46  float tj       = T_AMBIENT + heatW * THETA_JA;  // tahmini yonga sıcaklığı / estimated junction temperature
47  float eff      = (vin > 1.0) ? 100.0 * vout / vin : 0.0;  // verim (%) / efficiency (%)
48
49  Serial.print(F("Vin "));      Serial.print(vin, 2);
50  Serial.print(F(" V | Vout ")); Serial.print(vout, 2);
51  Serial.print(F(" V | Fark ")); Serial.print(headroom, 2);
52  Serial.print(F(" V | Isi "));  Serial.print(heatW, 2);
53  Serial.print(F(" W | Tj ~"));  Serial.print(tj, 0);
54  Serial.print(F(" C | Verim %")); Serial.println(eff, 0);
55
56  if (headroom < DROPOUT_V) Serial.println(F("UYARI: giris dusuk, dropout / WARNING: input too low, dropout"));
57  if (tj > 125.0)           Serial.println(F("UYARI: sogutucu gerekli / WARNING: heatsink required"));
58  delay(1000);
59}

Statt die Versorgungsspannung, auf die sich die Analogmessung bezieht, einfach anzunehmen, misst der Sketch sie mit der Funktion readVcc(): Er liest die interne Festreferenz des ATmega328P von etwa 1,1 V und rechnet daraus die tatsächliche Vcc zurück. So stimmen die Messwerte, egal ob der Arduino über USB oder über den 7805 selbst läuft. Die Methode gilt für ATmega328P-Boards wie Uno und Nano; da die interne Referenz von Chip zu Chip um etwa ±10 % abweichen kann, vergleiche das Ergebnis einmal mit dem Multimeter und passe die Konstante 1125300 an. Trage bei LOAD_A den mit dem Multimeter gemessenen Laststrom ein; hast du einen Kühlkörper montiert, ersetze THETA_JA durch den gesamten Wärmewiderstand aus deiner Kühlkörperberechnung.

ESP32: der AMS1117 und Stromspitzen beim WLAN

ESP32-Entwicklungsboards senken die 5 V am Eingang mit einem LDO auf dem Board auf 3,3 V. Normalerweise zieht das Board 50–100 mA, beim Senden über WLAN springt der Strom aber kurzzeitig auf etwa 300 mA; Espressif empfiehlt deshalb eine Quelle, die mindestens 500 mA liefert. Eine schwache Quelle, ein dünnes, langes USB-Kabel oder ein heißer Regler lassen die 3V3-Schiene bei dieser Spitze einbrechen, der ESP32 schreibt "Brownout detector was triggered" in den seriellen Monitor und startet neu. Der folgende Sketch verrät, ob der letzte Reset ein Brownout war, und speichert die niedrigste Spannung, die die 3V3-Schiene beim Verbinden mit dem WLAN erreicht. Verbinde den 3V3-Pin über einen Teiler aus zwei 10-kΩ-Widerständen mit GPIO 34.

1// ESP32: 3V3 hattını ve brownout resetini izle / ESP32: watch the 3V3 rail and brownout resets
2#include <WiFi.h>
3#include "esp_system.h"
4
5const char* WIFI_SSID = "AgAdi";   // Wi-Fi ağ adı / Wi-Fi network name
6const char* WIFI_PASS = "Sifre";   // Wi-Fi şifresi / Wi-Fi password
7const int SENSE_PIN = 34;          // 3V3 -> 10k -> GPIO34 -> 10k -> GND (yalnız giriş, ADC1) / input-only ADC1 pin
8
9int minMv = 9999;                  // görülen en düşük gerilim (mV) / lowest voltage seen (mV)
10
11int rail3v3() {
12  return analogReadMilliVolts(SENSE_PIN) * 2;  // bölücü yarıya indirir / the divider halves it
13}
14
15void setup() {
16  Serial.begin(115200);
17  delay(300);
18  if (esp_reset_reason() == ESP_RST_BROWNOUT) {
19    Serial.println("Son reset: BROWNOUT, besleme yetersiz / Last reset: BROWNOUT, weak supply");
20  }
21  Serial.printf("Wi-Fi oncesi 3V3: %d mV\n", rail3v3());
22
23  WiFi.begin(WIFI_SSID, WIFI_PASS);
24  unsigned long t0 = millis();
25  while (WiFi.status() != WL_CONNECTED && millis() - t0 < 15000) {
26    int mv = rail3v3();                        // bağlanırken sürekli ölç / keep sampling while connecting
27    if (mv < minMv) minMv = mv;
28    delay(1);
29  }
30  Serial.printf("Baglanirken en dusuk 3V3: %d mV\n", minMv);
31}
32
33void loop() {
34  int mv = rail3v3();
35  if (mv < minMv) minMv = mv;
36  Serial.printf("3V3: %d mV | en dusuk / min: %d mV\n", mv, minMv);
37  delay(1000);
38}

Fällt der Tiefstwert beim Verbinden unter 3,0 V, ist die Versorgung zu schwach. Der ADC erwischt nicht jeden sehr kurzen Einbruch, zeigt aber die Tendenz deutlich. Die Abhilfe ist meist einfach: ein kurzes, dickes USB-Kabel, ein 470-µF-Elko zwischen 5V und GND nahe am Board oder eine Quelle mit mindestens 500 mA. Willst du den ESP32 aus 12 V versorgen, gib die 12 V nicht auf den AMS1117 des Boards, sondern senke sie vorher mit einem Buck-Modul auf 5 V. Ausführliche Fehlersuche findest du im Artikel zu ESP32 Brownout und Guru-Meditation-Fehlern.

Raspberry Pi Pico: VSYS und der 7805

Der Raspberry Pi Pico hat statt eines Linearreglers einen effizienten Buck-Boost-Wandler, und sein VSYS-Pin akzeptiert 1,8–5,5 V. Um einen Pico in einem 12-V-System zu betreiben, kannst du den Ausgang des 7805 an VSYS anschließen; nutzt du gleichzeitig USB, setze eine Schottky-Diode wie die 1N5819 dazwischen, sonst arbeiten die 5 V vom USB und der 7805 gegeneinander. Schließe den Ausgang des 7805 niemals an den 3V3-Pin an; dieser Pin verträgt nicht mehr als 3,3 V. Der folgende MicroPython-Code misst den Eingang des 7805 über einen Teiler an GP26 und VSYS über den Kanal GP29 auf dem Board.

1# Pico: 7805 girişini ve VSYS'i ölç / Pico: measure the 7805 input and VSYS
2from machine import ADC
3import time
4
5adc_in = ADC(26)            # GP26 (ADC0): 100k/22k bölücü / 100k/22k divider
6adc_vsys = ADC(29)          # GP29 (ADC3): kart üzerinde VSYS/3 / VSYS/3 on the board
7
8K_IN = (100 + 22) / 22      # bölücü oranı (~5,55) / divider ratio (~5.55)
9V_OUT = 5.0                 # 7805 çıkışı (V) / 7805 output (V)
10LOAD_A = 0.30               # ölçtüğün yük akımı (A) / load current you measured (A)
11
12def volts(adc, ratio, n=16):
13    total = 0
14    for _ in range(n):
15        total += adc.read_u16()          # 0-65535 arası ham değer / raw value 0-65535
16    return total / n * 3.3 / 65535 * ratio
17
18while True:
19    vin = volts(adc_in, K_IN)
20    vsys = volts(adc_vsys, 3)
21    heat = (vin - V_OUT) * LOAD_A        # P = (Vin - Vout) x I
22    print("Vin {:.2f} V | VSYS {:.2f} V | 7805 isi {:.2f} W".format(vin, vsys, heat))
23    if vin - V_OUT < 2.0:
24        print("UYARI: dropout / WARNING: dropout")
25    time.sleep(1)

Der ADC des Pico liest höchstens 3,3 V, mit dem 100k/22k-Teiler kannst du also bis etwa 18 V messen. Der VSYS-Wert liegt wegen des Spannungsabfalls der Schottky-Diode von etwa 0,3 V etwas unter dem Ausgang des 7805; das ist normal. Beim Pico W ist GP29 mit dem Funkchip geteilt, die VSYS-Messung braucht dort zusätzliche Einstellungen; nutze in dem Fall nur die Messung an GP26. Wenn du neu beim Pico bist, ist der Artikel Was ist der Raspberry Pi Pico? ein guter Einstieg.

Projektideen mit dem 7805 und anderen Reglern

• 5-V-Labornetzteil für den Tisch: Baue mit 12-V-Netzteil, 7805, Kühlkörper und Schalter eine kleine Box, die deine Steckbrett-Projekte mit stabilen 5 V versorgt.
• Netzteil mit Spannungs- und Wärmeanzeige: Bring den Test-Sketch oben auf ein LCD und zeige Eingang, Ausgang und Verlust live an; die Grundidee der Messung steht im Artikel Arduino-Voltmeter bauen.
• Arduino im Auto: Senke die 12–14,4 V der Autobatterie erst mit einem Buck auf 7–8 V, dann mit dem 7805 auf 5 V; eine TVS-Diode am Eingang schützt vor Spannungsspitzen im Bordnetz.
• 12-V-LED-Streifen und Relaissteuerung: Betreibe den Streifen direkt an 12 V und versorge Arduino und Relaismodul aus dem 7805.
• Eigene Schiene für Servos und NeoPixel: Versorge Servomotoren und WS2812B-LEDs über eine eigene 5-V-Schiene mit gemeinsamer Masse, unter 1 A mit einem 7805, darüber mit einem Buck.
• 3,3-V-Sensorplatine: Versorge 3,3-V-Module wie BME280 und nRF24L01 unabhängig vom Arduino über einen AMS1117-3.3; für die Signalpegel nutzt du einen Pegelwandler.

Häufige Fehler und ihre Lösungen

Mit der richtigen Eingangsspannung, zwei kleinen Kondensatoren und bei Bedarf einem Kühlkörper ist der 7805 eines der zuverlässigsten Bauteile der Elektronik und läuft jahrelang. Merke dir die Regel: Je größer die Differenz zwischen Ein- und Ausgang, desto mehr Wärme. Bei großen Differenzen nimm einen Buck, für 3,3 V einen AMS1117 und für lange Batterielaufzeit einen LDO mit kleinem Ruhestrom. In der BlueGrays-App findest du das digitale Voltmeter mit LCD, das per Bluetooth gesteuerte L298N-Auto, den Roboter mit Hinderniserkennung, die smarte Bewässerungsstation und die ESP32-Deep-Sleep-Projekte mit Schaltplänen und Code Schritt für Schritt, und die Stromversorgung dazu baust du mit den Berechnungen aus dieser Anleitung selbst.