LM2596 einstellen: Step-Down-Modul auf 5 V und 3,3 V justieren

Den LM2596 einstellen heißt: Du legst Spannung an den Eingang des Moduls und drehst an der Messingschraube des blauen Trimmpotis, während du den Ausgang mit dem Multimeter misst, bis der gewünschte Wert anliegt, zum Beispiel 5 V oder 3,3 V. Das LM2596-Step-Down-Modul (Buck-Wandler) ist ein günstiger und sehr verbreiteter Abwärtswandler, der aus einem 12-V-Netzteil, einer Autobatterie oder einem 2S-Li-Ionen-Akku effizient eine niedrigere Spannung für Arduino, ESP32, Servos und LED-Streifen erzeugt. Er nimmt 4,5–40 V am Eingang, regelt auf jeden Wert zwischen etwa 1,25 V und 35 V herunter und liefert bis zu 3 A. Die goldene Regel passt in einen Satz: Stelle den Ausgang immer ein und miss ihn, bevor du eine Last anschließt.

In dieser Anleitung lernst du, wie ein Buck-Wandler funktioniert, welche Anschlüsse und Bauteile das Modul hat, wie du 5 V und 3,3 V Schritt für Schritt mit Trimmpoti und Multimeter einstellst und welche Formel Vout = 1,23 × (1 + R2 / R1) den Ausgang bestimmt. Danach geht es um die Versorgung von Arduino und Servos aus 12 V, Strombegrenzung und Erwärmung, Wirkungsgrad und den Unterschied zum 7805 sowie typische Fehler (Verpolung, Spannungseinbruch unter Last), bevor wir zu Code kommen, der den Ausgang mit Arduino, ESP32 und Raspberry Pi Pico misst.

Was ist der LM2596 und wie funktioniert er?

Der LM2596 ist ein schaltender Abwärtsregler-IC, ursprünglich von National Semiconductor entwickelt und heute von Texas Instruments gefertigt. Linearregler wie der 7805 werden überschüssige Spannung los, indem sie sie in Wärme umwandeln; der LM2596 schaltet stattdessen seinen internen Leistungstransistor etwa 150.000-mal pro Sekunde (150 kHz) ein und aus. Solange der Transistor leitet, fließt Strom durch die Spule zur Last, und die Spule speichert Energie in ihrem Magnetfeld; sperrt der Transistor, gibt die Spule diese Energie über eine Schottky-Diode weiter an die Last ab. Der Ausgangskondensator glättet diese Impulse. Den Anteil der Zeit, in der der Transistor eingeschaltet ist, nennt man Tastverhältnis (Duty Cycle), ungefähr D ≈ Vout / Vin: Um aus 12 V 5 V zu machen, ist der Schalter etwa 42 % der Zeit eingeschaltet.

Weil keine Energie verheizt wird, liegt der Wirkungsgrad bei etwa 80–90 %, und der Eingangsstrom ist kleiner als der Ausgangsstrom: Ein Modul, das aus 12 V bei 5 V 2 A liefert, zieht am Eingang nur etwa 1 A. Für eine stabile Ausgangsspannung sorgt der FB-Pin (Feedback). Der Chip vergleicht die Spannung am FB-Pin mit seiner internen 1,23-V-Referenz und passt das Tastverhältnis entsprechend an. Beim fertigen Modul ist ein Zweig des Spannungsteilers am FB-Pin ein Mehrgang-Trimmpoti; drehst du an der Schraube, ändern sich das Teilerverhältnis und damit die Ausgangsspannung. Es gibt auch Festspannungsversionen des LM2596 mit 3,3 V, 5 V und 12 V, in der Arduino-Welt ist aber das blaue Modul mit der einstellbaren Version (ADJ) am weitesten verbreitet.

Anschlüsse und Bauteile des Moduls

Das blaue LM2596-Modul hat vier Anschlusspunkte: IN+ und IN− sind der Eingang, OUT+ und OUT− der Ausgang. IN− und OUT− sind auf der Platine miteinander verbunden; ein Buck-Wandler trennt Eingang und Ausgang nicht galvanisch, Quelle, Modul und versorgtes Board teilen sich also eine gemeinsame Masse (GND). Auf der Platine findest du den fünfbeinigen LM2596S-Chip (TO-263-Gehäuse: VIN, Ausgang, GND, FB und ON/OFF), eine große 33–47-µH-Spule, meist mit 330 oder 470 beschriftet, eine 3-A-Schottky-Diode wie die SS34, je einen Elko am Eingang und am Ausgang (meist 100–220 µF) und ein Mehrgang-Trimmpoti mit der Aufschrift 103 (10 kΩ). Den Aufdruck auf der Spule kannst du mit dem Spulen-Code-Rechner entschlüsseln. Bei den meisten Modulen liegt der ON/OFF-Pin des Chips auf GND, das Modul arbeitet also, sobald Spannung anliegt.

LM2596 einstellen Schritt für Schritt: 5 V oder 3,3 V mit dem Multimeter

1. Schließe nichts an den Ausgang an. Das Modul wird ohne Last eingestellt; Arduino oder ESP32 schließt du erst an, wenn du die richtige Spannung gesehen hast.
2. Schließe die Quelle, die du im Projekt wirklich nutzt (z. B. ein 12-V-2-A-Netzteil), an den Eingang an: Plus an IN+, Minus an IN−. Hat das Board eine LED, leuchtet sie.
3. Stelle das Multimeter auf Gleichspannung (20-V-Bereich oder Auto); halte die rote Messspitze an OUT+ und die schwarze an OUT−. Der erste Wert kann nahe an der Eingangsspannung liegen, denn die Werkseinstellung ist unbekannt.
4. Drehe die Messingschraube des Trimmpotis mit einem kleinen Schlitzschraubendreher 2–3 Umdrehungen in eine Richtung und beobachte die Anzeige. Sinkt die Spannung, drehst du richtig; steigt sie, drehe in die andere Richtung. Die Richtung kann je nach Verdrahtung des Trimmpotis von Modul zu Modul verschieden sein.
5. Beim Mehrgang-Trimmpoti mit etwa 25 Umdrehungen kann der ganze Bereich 20 Umdrehungen und mehr brauchen. Die Schraube hat keinen Endanschlag; am Ende rutscht sie mit einem leisen Klicken durch, und die Spannung ändert sich nicht mehr. Dann drehst du zurück.
6. Kurz vor dem Ziel gehst du in Vierteldrehungen und dann noch feiner weiter. Für 5 V lässt du es bei 5,00–5,10 V, für 3,3 V bei 3,30–3,35 V; bei 3,3-V-Boards wie ESP32 und Pico niemals über 3,6 V.
7. Schließe die Last an oder teste mit einem 10-Ω-/5-W-Widerstand, der bei 5 V etwa 500 mA zieht, und wiederhole die Messung unter Last. Fällt die Spannung um mehr als 0,1–0,2 V, prüfe Quelle und Verkabelung.
8. Wenn du fertig bist, gib einen Tropfen Nagellack oder Heißkleber auf die Trimmpoti-Schraube; bei vibrierenden Robotern kann sich die Einstellung mit der Zeit verstellen.

Die Ausgangsformel: Vout = 1,23 × (1 + R2 / R1)

Der LM2596 regelt seinen Ausgang so, dass am FB-Pin 1,23 V anliegen. Nennen wir den Widerstand zwischen Ausgang und FB R2 und den zwischen FB und GND R1, ergibt sich Vout = 1,23 × (1 + R2 / R1). Auf dem Modul übernimmt das 10-kΩ-Trimmpoti die Rolle von R2, R1 ist ein kleiner Festwiderstand auf der Platine. Aus der Formel folgen zwei wichtige Dinge: Selbst wenn R2 gegen null geht, sinkt der Ausgang nicht unter 1,23 V; und egal wie groß R2 wird, der Ausgang kann den Eingang nicht übersteigen. Drehst du das Trimmpoti zu weit auf, hält der Chip den Schalter dauerhaft geschlossen, und der Ausgang bleibt etwa 1–2 V unter dem Eingang hängen. Das ist der häufigste Grund für die Klage "mein Modul regelt nicht herunter".

Willst du in einem vibrierenden oder langlebigen Projekt Festwiderstände statt des Trimmpotis verwenden, halte dich an das Datenblatt und wähle R1 zwischen 240 Ω und 1,5 kΩ. Mit R1 = 1 kΩ ergibt sich für 5 V R2 = 1 kΩ × (5 / 1,23 − 1) ≈ 3,07 kΩ; mit einem 1-%-Widerstand von 3,09 kΩ liegt der Ausgang bei 5,03 V. Für 3,3 V ist R2 ≈ 1,68 kΩ, ein 1-%-Widerstand mit 1,69 kΩ liefert 3,31 V. Das ist eigentlich nur ein Spannungsteiler; die Verhältnisse kannst du mit dem Spannungsteiler-Rechner prüfen.

Die Mindestwerte in der Tabelle gelten für 2–3 A Last: Der Schalter des LM2596 hat bei 3 A typisch 1,16 V Spannungsabfall, Spule und Leitungen kommen mit einigen hundert Millivolt dazu. Bei geringer Last (um 1 A) sinkt die nötige Differenz auf etwa 1,5 V. Ein 7,4-V-2S-Li-Ionen-Akku fällt beim Entladen auf rund 6,4 V; das reicht für eine 5-V-Schiene mit 1 A noch aus, für eine 6-V-Servoschiene aber nicht. Wie du ein GSM-Modul einstellst, das 4 V braucht, steht im Artikel zum SIM800L.

Arduino aus einem 12-V-Netzteil oder Akku versorgen

Es gibt zwei richtige Wege, einen Arduino mit einem LM2596 zu versorgen. Der erste: Du stellst das Modul auf 5,0 V ein und verbindest den Ausgang direkt mit dem 5V-Pin. Weil dabei der Spannungsregler des Boards umgangen wird, entsteht fast keine Wärme, und es ist die effizienteste Variante; allerdings schützt dann nichts mehr das Board. Verstellt sich das Trimmpoti oder fällt das Modul so aus, dass es den Eingang durchreicht, landen 12 V direkt am Mikrocontroller. Steckst du bei dieser Verbindung zusätzlich das USB-Kabel ein, werden die USB-Versorgung des Computers und der Modulausgang miteinander verbunden; am sichersten ist es, das Modul beim Hochladen abzuklemmen.

Der zweite Weg: Du stellst das Modul auf 7,5–9 V ein und schließt es am Hohlstecker oder am Vin-Pin an. Dann übernimmt der Regler des Boards die letzte Stufe, und die Diode am Hohlstecker schützt vor Verpolung. 12 V direkt am Hohlstecker funktionieren auch, aber bei 200 mA Last erzeugt der kleine Regler des Boards (12 − 5) × 0,2 = 1,4 W Wärme; stellst du den LM2596 auf 7,5 V, sinkt dieser Verlust auf (7,5 − 5) × 0,2 = 0,5 W. Alle Versorgungsvarianten findest du im Artikel Arduino mit Strom versorgen, die Lage der Pins unter Arduino-Uno-Pinbelegung.

Servos und Motoren versorgen: Strom berechnen

Am häufigsten wird der LM2596 als Servoversorgung eingesetzt. Ein SG90 zieht in Bewegung 100–250 mA und beim Anlaufen und unter Last 600–700 mA. Ein MG996R erreicht blockiert bei 6 V etwa 2,5 A. Rechne bei der Auswahl nicht mit dem Durchschnitt, sondern addiere den Strom aller Servos, die gleichzeitig belastet sein können. Von einem LM2596 ohne Kühlkörper 2 A Dauerstrom zu erwarten, ist realistisch: 3 SG90 laufen problemlos, aber einen Roboterarm mit 4–6 MG996R an einem einzigen Modul zu betreiben, führt fast sicher zu Resets und Zittern. Nimm dann für jeweils ein oder zwei Servos ein eigenes Modul oder ein 5-A-Modul wie den XL4015.

Auch den Eingangsstrom solltest du berechnen, denn wenn das Netzteil nicht mithält, bricht der Ausgang ein, egal wie gut das Modul ist. Die Formel lautet Iin = (Vout × Iout) / (Vin × η). Für 2 A bei 5 V aus 12 V mit 85 % Wirkungsgrad gilt Iin = 10 W / (12 V × 0,85) ≈ 0,98 A; ein 12-V-2-A-Netzteil reicht also. Dieselbe Last zieht aus einem 7,4-V-2S-Akku etwa 1,6 A. Ein Elko mit 470–1000 µF direkt an der Servoschiene sorgt dafür, dass die Anlaufströme aus dem Kondensator statt aus dem Modul kommen. Alle Lösungen für servobedingte Resets findest du unter Arduino startet ständig neu, den Servoanschluss unter Was ist ein Servomotor und MG996R-Servo.

Strombegrenzung, Erwärmung und Kühlkörper

Ein Buck-Wandler ist effizient, aber nicht verlustfrei. Die Verlustleistung beträgt ungefähr PVerlust = PAusgang × (1/η − 1) und verteilt sich auf Chip, Schottky-Diode und Spule. Bei 5 V 2 A (10 W) Ausgangsleistung und 85 % Wirkungsgrad entstehen etwa 1,8 W Wärme. Der LM2596S auf dem Modul sitzt in einem TO-263-Gehäuse, das auf eine kleine Kupferfläche gelötet ist; laut Datenblatt liegt sein Wärmewiderstand zur Luft je nach Kupferfläche bei 30–50 °C/W. Deshalb wird der Chip bei 2 A so heiß, dass du ihn nicht lange anfassen kannst, und bei 3 A sind ein kleiner aufklebbarer Alu-Kühlkörper und Luftstrom Pflicht. In einem geschlossenen Gehäuse sinken diese Grenzen noch weiter.

Die Strombegrenzung des LM2596 lässt sich nicht einstellen. Erreicht der Spitzenstrom im Schalter etwa 4,5 A (je nach Fertigungsstreuung 3,6–6,9 A), verkürzt der Chip die Impulse, senkt bei Überlast die Frequenz und schaltet sich bei Überhitzung ab. Diese Schutzfunktionen retten das Modul bei einem Kurzschluss meistens, ersetzen aber keine Sicherung. Für Aufgaben, bei denen du den Strom einstellen musst, etwa um eine Power-LED zu treiben oder ein strombegrenztes Testnetzteil zu bauen, gibt es CC/CV-LM2596-Module (Konstantstrom / Konstantspannung) mit einem zweiten Trimmpoti für den Strom. Für eine kurzschlussfeste Schiene setzt du zusätzlich eine passende Sicherung in den Eingang.

Wirkungsgrad und Vergleich mit dem 7805

Im Vergleich mit dem Spannungsregler 7805, der dieselbe Aufgabe erfüllt, wird der Unterschied deutlich. Liefert der 7805 aus 12 V bei 5 V 1 A, zieht er auch am Eingang 1 A und wandelt (12 − 5) × 1 = 7 W in Wärme um; sein Wirkungsgrad liegt bei nur 42 %, und er braucht einen großen Kühlkörper. Der LM2596 zieht bei derselben Last etwa 0,49 A am Eingang und verliert weniger als 1 W. In batteriebetriebenen Projekten schlägt sich das direkt in der Laufzeit nieder: Verdoppelt sich der Wirkungsgrad, hält der Akku etwa doppelt so lange.

Der Preis für den Buck-Wandler ist Störspannung. Laut Datenblatt beträgt die sägezahnförmige Welligkeit am Ausgang typisch 0,5–3 % der Ausgangsspannung, bei 5 V also 25–150 mV, dazu kommt 150-kHz-Schaltrauschen. Für Arduino, Servos, Relais und LEDs ist das kein Problem, bei präzisen Analogmessungen, einem Mikrofon oder einem Audioverstärker macht es sich aber bemerkbar. Kombiniere dann beides: Erst mit dem LM2596 auf 7–8 V herunter, danach mit einem 7805 oder einem LDO auf saubere 5 V; so gewinnst du Wirkungsgrad und Ruhe. Für kleine Experimente mit wenig Strom auf dem Steckbrett ist ein fertiges MB102-Breadboard-Netzteilmodul eine praktische Lösung.

LM2596-Ausgang unter Last mit dem Arduino messen

Wie stark die Spannung unter Last einbricht, siehst du am besten, wenn du den Einbruch misst, während die Last arbeitet. Der folgende Code schwenkt ein Servo ständig zwischen 0 und 180 Grad und gibt dabei die niedrigste und höchste Spannung am LM2596-Ausgang im seriellen Monitor aus. So wird verdrahtet: Das rote Servokabel kommt an OUT+, das braune an OUT−, das Signalkabel an D9; zwischen OUT+ und GND baust du einen Spannungsteiler aus 47 kΩ und 10 kΩ und verbindest dessen Mittelpunkt mit A0. Der Arduino wird über USB versorgt, und OUT− muss mit dem GND des Arduino verbunden sein.

1// LM2596 yük testi: servo dönerken çıkış gerilimini izle / LM2596 load test: watch the output while a servo moves
2// Kart: Arduino Uno / Nano (ATmega328P) / Board: Arduino Uno / Nano (ATmega328P)
3#include <Servo.h>
4
5const int SENSE_PIN = A0;          // OUT+ -> 47k -> A0 -> 10k -> GND
6const int SERVO_PIN = 9;           // servo sinyal kablosu / servo signal wire
7const float R_TOP = 47000.0;       // bölücü üst direnç / divider top resistor
8const float R_BOTTOM = 10000.0;    // bölücü alt direnç / divider bottom resistor
9const float AREF_V = 1.1;          // dahili referans, multimetreyle düzelt / internal reference, calibrate with a multimeter
10const float LOW_LIMIT = 4.6;       // 5 V hat için uyarı sınırı / warning limit for a 5 V rail
11
12Servo servo;
13float vMin, vMax;
14
15float readOutput() {
16  long sum = 0;
17  for (int i = 0; i < 8; i++) {
18    sum += analogRead(SENSE_PIN);  // 8 örneğin toplamı / sum of 8 samples
19  }
20  float vPin = (sum / 8.0) * AREF_V / 1023.0;
21  return vPin * (R_TOP + R_BOTTOM) / R_BOTTOM;  // bölücüyü geri hesapla / undo the divider
22}
23
24void track() {
25  float v = readOutput();
26  if (v < vMin) vMin = v;          // en düşük değer / lowest value
27  if (v > vMax) vMax = v;          // en yüksek değer / highest value
28}
29
30void setup() {
31  Serial.begin(9600);
32  analogReference(INTERNAL);       // 1,1 V referans, beslemeden bağımsız / 1.1 V reference, independent of the supply
33  for (int i = 0; i < 10; i++) {   // referans otursun, ilk okumaları at / let the reference settle, drop first readings
34    analogRead(SENSE_PIN);
35    delay(5);
36  }
37  servo.attach(SERVO_PIN);
38}
39
40void loop() {
41  vMin = 99.0;
42  vMax = 0.0;
43  for (int a = 0; a <= 180; a += 2) {     // 0 -> 180 derece / 0 -> 180 degrees
44    servo.write(a);
45    for (int k = 0; k < 5; k++) { track(); delay(2); }
46  }
47  for (int a = 180; a >= 0; a -= 2) {     // 180 -> 0 derece / 180 -> 0 degrees
48    servo.write(a);
49    for (int k = 0; k < 5; k++) { track(); delay(2); }
50  }
51  Serial.print(F("Min: "));
52  Serial.print(vMin, 2);
53  Serial.print(F(" V  Max: "));
54  Serial.print(vMax, 2);
55  Serial.print(F(" V  Dusus / Drop: "));
56  Serial.print(vMax - vMin, 2);
57  Serial.println(F(" V"));
58  if (vMin < LOW_LIMIT) {
59    Serial.println(F("UYARI: gerilim cok dusuyor / WARNING: voltage sags too much"));
60  }
61  delay(1000);
62}

Statt der eigenen Versorgungsspannung des Arduino nutzt der Code die interne 1,1-V-Referenz des ATmega328P (analogReference(INTERNAL)); so stört es die Messung nicht, ob USB 4,7 V oder 5,1 V liefert. Mit dem 47k/10k-Teiler misst du höchstens etwa 6,2 V; bei einer 6-V-Servoschiene machst du wegen der Referenztoleranz den oberen Widerstand 56 kΩ groß und passt die Konstante R_TOP an. Da die interne Referenz von Chip zu Chip um etwa ±10 % abweichen kann, miss den Ausgang einmal mit dem Multimeter und korrigiere AREF_V (z. B. 1,08), bis beide Werte übereinstimmen. Fällt die Spannung beim Schwenken um mehr als 0,3 V, kürze die Leitungen, nimm dickere Kabel und setze 470 µF an die Servoschiene; unter 0,1 V ist deine Versorgung gesund.

ESP32: aus einem 12-V-Akku versorgen und den Akku überwachen

Einen ESP32 aus einem 12-V-Akku zu versorgen, ist für eine Sensorstation im Garten oder einen Tracker im Auto ein typisches Szenario. Stelle den LM2596 auf 5,0 V ein und schließe ihn am 5V-Pin (VIN) des ESP32-Boards an; der LDO auf dem Board erzeugt die 3,3 V. Die kurzen Stromspitzen, die der ESP32 beim Senden über WLAN zieht, deckt der LM2596 problemlos ab; die Anzeichen einer schwachen Versorgung findest du ausführlich im Artikel ESP32-Brownout-Fehler. Der folgende Code liest die Akkuspannung über einen 100-kΩ-/22-kΩ-Teiler an GPIO34 und schickt den ESP32 für 10 Minuten in den Tiefschlaf, sobald die Spannung die sichere Untergrenze eines Bleiakkus erreicht.

1// ESP32: LM2596 ile 12 V aküden beslen, aküyü izle / ESP32: run from a 12 V battery via an LM2596, monitor the battery
2#include <Arduino.h>
3#include "esp_sleep.h"
4
5const int BAT_PIN = 34;                           // GPIO34: yalnız giriş, ADC1 / input-only, ADC1
6const float RATIO = (100.0 + 22.0) / 22.0;        // 100k / 22k bölücü (~5,55) / divider (~5.55)
7const float LOW_V = 11.8;                         // kurşun asit akü alt sınırı / lead-acid low limit
8const uint64_t SLEEP_US = 10ULL * 60 * 1000000;   // 10 dakika (mikrosaniye) / 10 minutes (microseconds)
9
10float batteryVolts() {
11  uint32_t mv = 0;
12  for (int i = 0; i < 16; i++) {
13    mv += analogReadMilliVolts(BAT_PIN);          // kalibre edilmiş mV / calibrated mV
14  }
15  return mv / 16.0 / 1000.0 * RATIO;              // bölücüyü geri hesapla / undo the divider
16}
17
18void setup() {
19  Serial.begin(115200);
20  delay(200);
21}
22
23void loop() {
24  float v = batteryVolts();
25  Serial.printf("Aku / Battery: %.2f V\n", v);
26  if (v < LOW_V) {
27    Serial.println("Aku zayif, 10 dk uyku / Battery low, sleeping 10 min");
28    Serial.flush();
29    esp_sleep_enable_timer_wakeup(SLEEP_US);      // zamanlayıcıyla uyan / wake up by timer
30    esp_deep_sleep_start();                       // derin uyku / deep sleep
31  }
32  delay(5000);
33}

Der Teiler bringt selbst eine Ladespannung von 14,4 V auf etwa 2,6 V herunter, du bleibst also im Messbereich des ESP32-ADC. Ein Bleiakku ist in Ruhe bei etwa 12,6–12,8 V voll; unter 11,8 V nähert er sich der Tiefentladung, was seine Lebensdauer verkürzt. Einen Haken gibt es: Der LM2596 selbst zieht auch ohne Last 5–10 mA. Während der ESP32 im Tiefschlaf nur Mikroampere braucht, verbraucht das Modul 120–240 mAh pro Tag, und ein 7-Ah-Akku ist allein deshalb nach 1–2 Monaten leer. Mit dem Akkulaufzeit-Rechner kannst du das mit deinen eigenen Werten durchrechnen. Für Projekte, die monatelang schlafen, brauchst du ein Modul mit herausgeführtem EN-Pin (ON/OFF), um die Versorgung ganz abzuschalten, oder einen Abwärtswandler mit sehr geringem Ruhestrom; Details zu Schlaftechniken stehen im Artikel ESP32 Deep Sleep.

Einstellhilfe mit dem Raspberry Pi Pico (MicroPython)

Wenn du die Einstellung auf dem Computerbildschirm verfolgen willst, kannst du den Pico als einfaches Voltmeter nutzen. Da der ADC des Pico höchstens 3,3 V misst, verbindest du den LM2596-Ausgang über einen Teiler aus 100 kΩ und 10 kΩ mit GP26; mit diesem Verhältnis misst du bis 36 V sicher, sodass der Pico selbst dann keinen Schaden nimmt, wenn das noch nicht eingestellte Modul fast die Eingangsspannung ausgibt. Der Pico wird über USB versorgt, und die GNDs sind verbunden. Je nach Zielwert gibt der Code "high" oder "low" aus und schaltet die LED auf dem Board ein, sobald der Ausgang innerhalb von ±1 % liegt. Wenn du neu beim Pico bist, beginne mit Was ist der Raspberry Pi Pico?.

1# Pico: LM2596 ayar yardımcısı / Pico: LM2596 adjustment helper
2from machine import ADC, Pin
3import time
4
5adc = ADC(26)                  # GP26 (ADC0): OUT+ -> 100k -> GP26 -> 10k -> GND
6led = Pin("LED", Pin.OUT)      # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
7RATIO = (100 + 10) / 10        # bölücü oranı 11, en fazla ~36 V / divider ratio 11, up to ~36 V
8VREF = 3.3                     # ADC referansı (V) / ADC reference (V)
9CAL = 1.000                    # multimetreyle düzeltme katsayısı / multimeter correction factor
10TARGET = 5.00                  # hedef: 5.00 ya da 3.30 / target: 5.00 or 3.30
11
12def read_volts(n=64):
13    total = 0
14    for _ in range(n):
15        total += adc.read_u16()                    # 0-65535 ham değer / raw value
16    return total / n / 65535 * VREF * RATIO * CAL
17
18while True:
19    v = read_volts()
20    err = (v - TARGET) / TARGET * 100              # hedeften sapma (%) / deviation from target (%)
21    led.value(abs(err) <= 1.0)                     # ±%1 içinde LED yanar / LED on within ±1%
22    if err > 1.0:
23        hint = "yuksek, dusur / high, lower it"
24    elif err < -1.0:
25        hint = "dusuk, artir / low, raise it"
26    else:
27        hint = "tamam / OK"
28    print("{:.2f} V  {:+.1f} %  {}".format(v, err, hint))
29    time.sleep(0.3)

Da der ADC des Pico um etwa 1–2 % danebenliegen kann, korrigierst du den Faktor CAL einmal im Vergleich mit dem Multimeter; die endgültige Einstellung bestätigst du trotzdem am besten mit dem Multimeter. Willst du den Pico später ebenfalls aus dem LM2596 versorgen, verbinde den 5,0-V-Ausgang über eine Schottky-Diode 1N5819 mit dem VSYS-Pin; die Diode verhindert, dass beide Quellen gegeneinander arbeiten, wenn USB eingesteckt ist. Schließe den Modulausgang niemals am 3V3-Pin des Pico an.

Projektideen mit dem LM2596

• Roboterauto: Ein 2S-18650-Akku (7,4 V) versorgt die Motoren direkt über den L298N, ein auf 5 V eingestellter LM2596 versorgt Arduino und Sensoren. Die Schritte findest du im Artikel Arduino-Roboterauto bauen.
• Roboterarm: Baue mit einem auf 6 V eingestellten LM2596 eine kräftige, vom Arduino unabhängige Schiene für die MG996R-Servos; Details in der Anleitung Arduino-Roboterarm.
• Smartes 12-V-Gewächshaus: Ein einziges 12-V-Netzteil versorgt Lüfter und Pumpe, und der LM2596 erzeugt aus derselben Schiene 5 V für Arduino, Relais und LCD; siehe Projekt smartes Gewächshaus.
• Einstellbares Labornetzteil: Baue aus einem LM2596, einem alten Laptop-Netzteil und einem mit dem Arduino gebauten Digitalvoltmeter ein kleines Labornetzteil, das die Ausgangsspannung anzeigt.
• WS2812B-LED-Streifen: 60 LEDs in vollem Weiß können bis zu 3,6 A ziehen; begrenze die Helligkeit und bleib mit einem 5-V-LM2596 unter 2 A. Die Stromrechnung steht im Artikel WS2812B NeoPixel.
• ESP32-Gerät im Auto: Wandle die Bordspannung von 12–14,4 V auf 5 V herunter; setze eine Sicherung in den Eingang und eine TVS-Diode gegen Spannungsspitzen im Fahrzeug.

Häufige Fehler und Lösungen

Richtig eingestellt, mit genügend Abstand zwischen Ein- und Ausgang und innerhalb seiner 2-A-Grenze betrieben, ist der LM2596 eines der praktischsten Bauteile, um ein Projekt aus einem einzigen Netzteil oder Akku zu versorgen. Merk dir die Reihenfolge: zuerst ohne Last einstellen, dann unter Last messen, zuletzt das Board anschließen. In der BlueGrays-App findest du Projekte, die eine eigene Versorgung brauchen, wie das Bluetooth-Auto mit L298N, den Hindernis-ausweichenden Roboter, Servoprojekte, die Choreografie mit 32 Servos, die WS2812B-Streifensteuerung, das Digitalvoltmeter mit LCD und die smarte Bewässerungsstation, mit Schritt-für-Schritt-Schaltplänen und Code.