Spannungsteiler: Formel, Widerstände berechnen, Arduino-Beispiele

Ein Spannungsteiler ist die einfachste Schaltung, um mit zwei in Reihe geschalteten Widerständen eine Spannung auf einen kleineren, genau berechenbaren Wert zu bringen. Die Ausgangsspannung ergibt sich aus Ua = Ue × R2 / (R1 + R2): R1 liegt an der Quelle, R2 an Masse (GND), und der Ausgang wird am Mittelpunkt zwischen beiden abgegriffen. Zwei Widerstände mit je 10 kΩ teilen 12 V zum Beispiel genau zur Hälfte, also auf 6 V. Diese zwei Widerstände stecken in unzähligen Schaltungen: vom Messen einer 12-V-Batterie mit dem Arduino über das Anpassen eines 5-V-Sensorsignals an die 3,3-V-Pins eines ESP32 bis zum Auslesen von Sensoren wie LDR und NTC.

In diesem Beitrag siehst du mit echten Zahlen, woher die Formel kommt, wie du die Widerstandswerte auswählst und warum die Ausgangsspannung sinkt, sobald du etwas an den Teiler anschließt (Belastung). Danach bauen wir Schritt für Schritt Code, der mit Arduino Uno, ESP32 und Raspberry Pi Pico Batteriespannungen misst, wählen die richtigen Widerstandspaare, um 5 V auf 3,3 V zu bringen, und lesen einen LDR und einen NTC mit einem Teiler aus. Zum Schluss erklären wir, warum ein Spannungsteiler niemals ein Netzteil ersetzen darf.

Was ist ein Spannungsteiler und wie funktioniert er?

Die Formel des Spannungsteilers folgt direkt aus dem ohmschen Gesetz. Durch R1 und R2, die zwischen Quelle und Masse in Reihe liegen, fließt derselbe Strom: I = Ue / (R1 + R2). Die Spannung an R2, also der Ausgang, ist dieser Strom mal R2: Ua = I × R2 = Ue × R2 / (R1 + R2). Kurz gesagt: Die Quellspannung wird im Verhältnis der Widerstandswerte aufgeteilt, am größeren Widerstand fällt der größere Anteil ab. Der Ausgang ist immer kleiner als der Eingang, weil das Verhältnis R2 / (R1 + R2) kleiner als 1 ist. Wie sich Spannungen in Reihenschaltungen aufteilen, liest du ausführlicher in Reihen- und Parallelschaltung von Widerständen berechnen.

Du kannst auch rückwärts rechnen: Willst du 12 V auf 3,3 V bringen und hast für R2 10 kΩ gewählt, ergibt sich R1 = 10 × (12 / 3,3 − 1) ≈ 26,4 kΩ. Diesen Wert gibt es nicht zu kaufen, also nimmst du den nächsthöheren Normwert 27 kΩ; der Ausgang liegt dann bei 12 × 10 / 37 ≈ 3,24 V. R1 aufzurunden senkt den Ausgang leicht, und das ist für den Pin die sichere Seite. Auch ein Potentiometer ist eigentlich ein einstellbarer Spannungsteiler: Der Schleifer teilt die Widerstandsbahn in R1 und R2. Wenn du nicht von Hand rechnen willst, liefert dir der Spannungsteiler-Rechner den Ausgang sofort aus Eingangsspannung und Widerständen. In der Elektronik begegnet dir der Spannungsteiler vor allem bei diesen Aufgaben:

• Höhere Spannungen messen: Quellen wie eine 12-V-Batterie oder einen 7,4-V-Lithium-Akkupack in den Bereich bringen, den ein Analogeingang messen kann.
• Pegel absenken: ein 5-V-Signal für die 3,3-V-Eingänge von ESP32 und Raspberry Pi Pico verträglich machen.
• Widerstandssensoren auslesen: die Widerstandsänderung von LDR, NTC, Biegesensor (Flex) oder Kraftsensor (FSR) in eine Spannung umwandeln.
• Viele Taster an einem Pin: Eine Widerstandsleiter gibt jedem Taster eine andere Spannung, sodass fünf Taster an einem einzigen Analogpin hängen können.
• Rückführung von Spannungsreglern: Regler wie der LM317 oder der einstellbare LM2596 halten ihren Ausgang konstant, indem sie ihn über einen Teiler messen; beim LM317 gilt Ua = 1,25 × (1 + R2 / R1).
• Referenzspannung erzeugen: in Schaltungen mit Operationsverstärkern die halbe Versorgungsspannung als Bezug bereitstellen.

Wie wählt man die Widerstandswerte?

Die Formel interessiert sich nur für das Verhältnis: 1 kΩ + 1 kΩ und 100 kΩ + 100 kΩ teilen gleich, nämlich genau zur Hälfte. In der Praxis zählen aber auch die absoluten Werte. Kleine Widerstände lassen viel Strom durch den Teiler fließen; dieser Strom ist verschwendete Energie und leert bei Batterieprojekten unnötig den Akku. Große Widerstände ziehen sehr wenig Strom, aber ihr Ausgang ist schwach: Eine angeschlossene Last oder der Abtastkondensator im Analogeingang verfälschen die Ausgangsspannung leicht, und Störungen aus den Leitungen wirken sich stärker aus. Die richtige Wahl ist ein Kompromiss zwischen diesen beiden Extremen:

1. Höchste Eingangsspannung bestimmen. Eine 12-V-Bleibatterie erreicht beim Laden bis zu 14,4 V; nimm den ungünstigsten Fall der zu messenden Spannung und rechne 10 % Reserve dazu.
2. Höchste zulässige Pinspannung bestimmen. 5 V beim Arduino Uno, 3,3 V bei ESP32 und Pico; als sicheres Ziel wählst du etwa 4,5 V beim Uno, 2,5 V beim ESP32 und 3,0 V beim Pico.
3. Verhältnis berechnen: k = Zielausgang / höchster Eingang. Zum Beispiel 4,5 / 14,4 ≈ 0,31.
4. R2 wählen (10 kΩ ist meist ein guter Startwert) und R1 mit R1 = R2 × (1 / k − 1) bestimmen. Runde das Ergebnis auf den nächsthöheren Wert der Normreihe für Widerstände auf.
5. Strom und Leistung prüfen: I = Ue / (R1 + R2) und P = Ue² / (R1 + R2). Bei Batterieprojekten sollte der Strom möglichst im Mikroampere-Bereich liegen.
6. Innenwiderstand prüfen: R1 × R2 / (R1 + R2) sollte beim Arduino Uno unter 10 kΩ liegen; sonst setzt du einen 100-nF-Kondensator zwischen Analogpin und GND.
7. Echtes Verhältnis in den Code schreiben: Berechne das Verhältnis mit den gewählten Normwerten neu, miss nach dem Aufbau mit dem Multimeter nach und kalibriere.

Belastung: Was passiert, wenn du etwas an den Teiler anschließt?

Die Formel setzt voraus, dass dem Ausgang kein Strom entnommen wird. Sobald du eine Last anschließt, liegt sie parallel zu R2, der Ersatzwiderstand des unteren Zweigs wird kleiner und die Ausgangsspannung sinkt. Am einfachsten rechnest du das mit der Ersatzspannungsquelle (Thevenin-Ersatzschaltung): Der Teiler verhält sich wie eine Quelle mit der Leerlaufspannung U0 und dem Innenwiderstand Ri = R1 × R2 / (R1 + R2). Mit einer Last RL wird der Ausgang zu U0 × RL / (Ri + RL). Die folgende Tabelle zeigt eine 10-V-Quelle, geteilt durch 10 kΩ + 10 kΩ (U0 = 5 V, Ri = 5 kΩ), mit verschiedenen Lasten am Ausgang:

Als Faustregel gilt: Ist der Lastwiderstand mindestens 100-mal so groß wie der Innenwiderstand des Teilers (Ri), bleibt der Fehler unter 1 %. Ist die Last kleiner, verkleinerst du entweder die Widerstände oder setzt einen Operationsverstärker als Spannungsfolger (Puffer) dazwischen. Der Analogeingang eines Mikrocontrollers ist selbst sehr hochohmig, enthält aber einen kleinen Abtastkondensator, der bei jeder Wandlung geladen wird (beim ATmega328P etwa 14 pF). Deshalb empfiehlt das Datenblatt einen Quellwiderstand von etwa 10 kΩ oder weniger. Nutzt du einen hochohmigeren Teiler, setze einen 100-nF-Kondensator zwischen Analogpin und GND: Er hält die beim Abtasten benötigte Ladung bereit. Liest du mehrere Analogpins nacheinander, verwirf außerdem an jedem Pin den ersten Messwert; so verschwindet der Fehler durch den Kanalwechsel.

Warum ein Spannungsteiler kein Netzteil ersetzt

Die häufigste Anfängerfalle: aus einem 12-V-Netzteil mit zwei Widerständen 5 V abzweigen und damit einen Arduino oder ein Modul versorgen. Auf dem Papier liefert ein Teiler aus 7 kΩ und 5 kΩ aus 12 V genau 5 V, allerdings nur, solange kein Strom entnommen wird. Ein Board mit 50 mA Stromaufnahme verhält sich wie eine Last von etwa 100 Ω; parallel zu den 5 kΩ von R2 sinkt der untere Zweig auf 98 Ω, und der Ausgang bricht auf 0,17 V ein. Verkleinerst du die Widerstände auf 70 Ω und 50 Ω, zieht die Schaltung schon ohne Last 100 mA und erzeugt 1,2 W Wärme; mit Last fällt der Ausgang trotzdem auf 3,9 V, und bei jeder Änderung der Stromaufnahme (WLAN, Servo, Relais) schwankt die Spannung mit. Wird die Last entfernt, steigt die Spannung außerdem wieder an und kann empfindliche Bauteile beschädigen.

12-V-Batterie und Akkus mit dem Arduino messen

Die Analogeingänge des Arduino Uno vertragen höchstens 5 V; eine 12-V-Batterie direkt anzuschließen, zerstört den Pin. Die Lösung ist ein Teiler aus 22 kΩ (R1) und 10 kΩ (R2): Bei einem Verhältnis von 0,3125 kommt die Ladespannung von 14,4 V als 4,5 V am Pin an, und die Schaltung kann bis 16 V messen. Bei 12 V zieht der Teiler nur 0,375 mA, und sein Innenwiderstand liegt mit 6,9 kΩ unter der empfohlenen Grenze von 10 kΩ. Der 10-Bit-ADC unterscheidet etwa 4,9 mV pro Schritt; mit dem Teiler entspricht das einer Auflösung von etwa 15,6 mV am Eingang. Weil ESP32 und Pico mit 3,3 V arbeiten, nehmen wir dort ein größeres R1 (56 kΩ):

1// 12 V akü gerilimini gerilim bölücüyle ölçme / Measuring a 12 V battery with a voltage divider
2// Kaynak + -> 22k (R1) -> A0 -> 10k (R2) -> GND / Source + -> 22k (R1) -> A0 -> 10k (R2) -> GND
3// Kaynağın eksisi Arduino GND'sine bağlı / Source minus is tied to the Arduino GND
4const int VIN_PIN = A0;
5const float VREF = 5.0;      // 5V pininde ölçtüğün gerilim / voltage you measured on the 5V pin
6const float R1 = 22000.0;    // üst direnç (ohm) / top resistor (ohms)
7const float R2 = 10000.0;    // alt direnç (ohm) / bottom resistor (ohms)
8const float CAL = 1.000;     // kalibrasyon: gerçek / okunan / calibration: real / measured
9const float LOW_V = 11.8;    // düşük akü eşiği (V) / low battery threshold (V)
10
11float readInputVoltage() {
12  analogRead(VIN_PIN);                        // ilk okumayı at / discard the first reading
13  long sum = 0;
14  for (int i = 0; i < 16; i++) {              // 16 ölçümün ortalaması / average of 16 readings
15    sum += analogRead(VIN_PIN);
16    delay(2);
17  }
18  float vPin = (sum / 16.0) * VREF / 1024.0;  // pindeki gerilim / voltage at the pin
19  return vPin * (R1 + R2) / R2 * CAL;         // bölücüden önceki gerilim / voltage before the divider
20}
21
22void setup() {
23  Serial.begin(9600);
24  pinMode(LED_BUILTIN, OUTPUT);
25}
26
27void loop() {
28  float v = readInputVoltage();
29  Serial.print(F("Giris / Input: "));
30  Serial.print(v, 2);
31  Serial.println(F(" V"));
32  digitalWrite(LED_BUILTIN, v < LOW_V ? HIGH : LOW);  // akü zayıfsa LED yanar / LED on when the battery is low
33  delay(1000);
34}

Der Code verwirft den ersten Messwert, damit sich der Abtastkondensator des ADC einschwingt, und mittelt dann 16 Messungen, um Rauschen zu verringern. Der gelesene Wert wird zuerst in die Pinspannung umgerechnet (wir teilen durch 1024, weil laut Datenblatt des ATmega328P ADC = Ue × 1024 / Uref gilt) und dann mit (R1 + R2) / R2 = 3,2 multipliziert, um die Spannung vor dem Teiler zu erhalten. Die größte Fehlerquelle ist die Referenzspannung: Der 5V-Pin eines per USB versorgten Uno liegt oft irgendwo zwischen 4,7 und 5,1 V. Miss deshalb den 5V-Pin mit dem Multimeter und trage den Wert bei VREF ein; miss danach die echte Batteriespannung mit dem Multimeter, vergleiche sie mit dem Wert im seriellen Monitor und trage CAL = echt / gemessen in den Code ein. Dieser eine Schritt korrigiert Referenz- und Toleranzfehler zugleich. Schließt du den Teiler hinter dem Ein-/Ausschalter des Geräts an, zieht er im ausgeschalteten Zustand keinen Strom; 0,375 mA ergeben etwa 9 mAh pro Tag, für eine Autobatterie bedeutungslos, für einen kleinen Akku aber spürbar. Passende Widerstandspaare für andere Quellen:

Spannung messen mit dem ESP32

Beim ESP32 hat der ADC 12 Bit (0–4095), unterscheidet sich aber in zwei wichtigen Punkten. Erstens lassen sich ADC2-Pins bei eingeschaltetem WLAN nicht lesen; schließe den Teiler deshalb immer an einen ADC1-Pin an, also GPIO 32–39 (GPIO 34–39 sind reine Eingänge und dafür ideal). Zweitens ist der ADC an den Rändern nicht linear: Bei der standardmäßigen Dämpfung von 11 dB empfiehlt Espressif etwa 150–2450 mV als genauesten Messbereich. Der Pin zeigt zwar Werte bis etwa 3,1 V, doch dort wächst der Fehler. Deshalb haben wir einen Teiler aus 56 kΩ + 10 kΩ gewählt: 14,4 V kommen als 2,18 V am Pin an und bleiben im genauen Bereich. Statt des rohen analogRead() verwenden wir analogReadMilliVolts(), das mithilfe der ab Werk im Chip gespeicherten Kalibrierdaten direkt Millivolt liefert:

1// ESP32: 56k + 10k bölücüyle 12 V ölçme / ESP32: measuring 12 V with a 56k + 10k divider
2const int VIN_PIN = 34;        // ADC1_CH6, Wi-Fi açıkken de çalışır / ADC1_CH6, works with Wi-Fi on
3const float R1 = 56000.0;      // üst direnç (ohm) / top resistor (ohms)
4const float R2 = 10000.0;      // alt direnç (ohm) / bottom resistor (ohms)
5const float CAL = 1.000;       // multimetreyle ayarla / tune with a multimeter
6
7void setup() {
8  Serial.begin(115200);
9  analogReadResolution(12);    // 0-4095 (varsayılan / default)
10}
11
12void loop() {
13  uint32_t mv = 0;
14  for (int i = 0; i < 32; i++) {
15    mv += analogReadMilliVolts(VIN_PIN);     // kalibre edilmiş milivolt / calibrated millivolts
16  }
17  float vPin = mv / 32.0 / 1000.0;           // pindeki gerilim (V) / voltage at the pin (V)
18  float vIn = vPin * (R1 + R2) / R2 * CAL;   // bölücüden önceki gerilim / voltage before the divider
19  Serial.printf("Pin: %.3f V  Giris / Input: %.2f V\n", vPin, vIn);
20  delay(1000);
21}

Spannung messen mit dem Raspberry Pi Pico (MicroPython)

Beim Raspberry Pi Pico sind GP26, GP27 und GP28 die Analogeingänge (ADC0–ADC2). Die MicroPython-Funktion read_u16() skaliert den 12-Bit-Messwert auf 0–65535, und die Referenz ist ADC_VREF, die aus den 3,3 V des Boards stammt. Da der ADC des Pico bis 3,3 V messen kann, kommst du mit 56 kΩ + 10 kΩ bis etwa 21 V. Ein schönes Detail: Der Pico nutzt selbst einen Spannungsteiler. Ein Teiler auf der Platine teilt die Versorgungsspannung VSYS durch drei und führt sie auf GP29 (ADC3); multiplizierst du die mit ADC(29) gelesene Spannung mit 3, siehst du die Versorgungsspannung des Boards (beim Pico W ist GP29 mit dem Funkchip geteilt, dort funktioniert das nicht direkt).

1from machine import ADC
2import time
3
4adc = ADC(26)            # GP26 = ADC0 (pin 31)
5VREF = 3.3               # ADC_VREF; multimetreyle ölçüp düzelt / measure and correct with a multimeter
6R1 = 56000               # üst direnç (ohm) / top resistor (ohms)
7R2 = 10000               # alt direnç (ohm) / bottom resistor (ohms)
8CAL = 1.000              # kalibrasyon katsayısı / calibration factor
9
10
11def read_input_voltage(samples=32):
12    total = 0
13    for _ in range(samples):
14        total += adc.read_u16()                  # 0-65535
15    v_pin = total / samples * VREF / 65535       # pindeki gerilim / voltage at the pin
16    return v_pin * (R1 + R2) / R2 * CAL          # bölücüden önceki gerilim / voltage before the divider
17
18
19while True:
20    v_in = read_input_voltage()
21    print("Giris / Input: {:.2f} V".format(v_in))
22    time.sleep(1)

5-V-Signal auf 3,3 V absenken (für ESP32 und Pico)

Die Pins von ESP32 und Pico sind nicht 5-V-tolerant. Hängt der ECHO-Ausgang eines HC-SR04, der TX-Pin eines Arduino Uno oder der Digitalausgang eines mit 5 V versorgten Moduls direkt an diesen Boards, werden die Schutzdioden am Eingang überlastet, und der Pin kann mit der Zeit kaputtgehen. Für Signale in nur eine Richtung ist ein Spannungsteiler die günstigste Lösung. Ziel ist eine Spannung, die 3,3 V nie überschreitet, aber hoch genug ist, damit das Board sie als HIGH erkennt: Der ESP32 setzt die Untergrenze für HIGH bei 75 % der Versorgung (etwa 2,5 V), der RP2040 im Pico bei 2,0 V. Ein Ausgang zwischen 3,0 und 3,3 V bietet daher bei beiden Boards reichlich Reserve. Genau diese Methode empfiehlt auch der Beitrag zum HC-SR04-Ultraschallsensor, um den ECHO-Pin an 3,3-V-Boards anzuschließen.

Zusammen mit der Kapazität des Pins bildet der Teiler einen kleinen RC-Tiefpass. Die 6,7 kΩ Innenwiderstand eines Teilers aus 10 kΩ + 20 kΩ ergeben mit etwa 15 pF von Pin und Steckbrett eine Zeitkonstante von rund 100 ns; ein UART mit 115200 Baud (8,7 µs pro Bit) merkt davon nichts, aber die Flanken von SPI-Signalen mit einigen MHz werden verschliffen. Auf schnellen Leitungen nimmst du besser 1 kΩ + 2 kΩ. Denk auch daran, dass ein Teiler nur in eine Richtung funktioniert, von der höheren zur niedrigeren Spannung. In Gegenrichtung brauchst du meist nichts: Der Arduino Uno erkennt alles über 3,0 V als HIGH und kann den 3,3-V-Ausgang des ESP32 daher lesen, wenn auch mit wenig Reserve. Bei bidirektionalen Leitungen wie I2C ist ein Teiler dagegen nutzlos; dort setzt man einen Pegelwandler mit MOSFETs ein.

LDR und NTC mit einem Spannungsteiler auslesen

Mikrocontroller können keinen Widerstand messen, nur Spannung. Schaltest du einen Widerstandssensor wie einen LDR oder einen NTC mit einem Festwiderstand als Spannungsteiler in Reihe, wird die Widerstandsänderung am Mittelpunkt zu einer Spannungsänderung. Der Wert des Festwiderstands bestimmt die Empfindlichkeit. Den größten Spannungshub erhältst du, wenn der Festwiderstand dem geometrischen Mittel aus kleinstem und größtem Sensorwiderstand im gewünschten Bereich entspricht: R = √(Rmin × Rmax). Für einen LDR mit 1 kΩ bei hellem und 100 kΩ bei schwachem Licht ergibt das √(1 k × 100 k) = 10 kΩ. Bei 5 V schwankt der Ausgang mit 10 kΩ über 4,09 V, mit 1 kΩ oder 100 kΩ dagegen nur über 2,45 V. Deshalb liegen Starter-Kits 10-kΩ-Widerstände bei. Ein weiterer Vorteil: Weil Teiler und ADC an denselben 5 V hängen, ist der berechnete Widerstand unabhängig von der Versorgungsspannung (ratiometrische Messung); der Code unten braucht daher nicht einmal einen Wert für die Referenzspannung.

1// LDR ve NTC'yi gerilim bölücüyle okuma / Reading an LDR and an NTC with voltage dividers
2// A0: 5V -> LDR -> A0 -> 10k -> GND
3// A1: 5V -> 10k -> A1 -> NTC 10k (B = 3950) -> GND
4const float R_FIXED = 10000.0;  // sabit dirençler (ohm) / fixed resistors (ohms)
5const float R0 = 10000.0;       // NTC'nin 25 °C direnci / NTC resistance at 25 °C
6const float BETA = 3950.0;      // NTC B katsayısı / NTC beta coefficient
7const float T0 = 298.15;        // 25 °C kelvin cinsinden / 25 °C in kelvin
8
9void setup() {
10  Serial.begin(9600);
11}
12
13void loop() {
14  analogRead(A0);                         // kanal değişti, ilk okumayı at / channel changed, discard first reading
15  int ldrRaw = analogRead(A0);
16  analogRead(A1);
17  int ntcRaw = analogRead(A1);
18  if (ldrRaw < 1) ldrRaw = 1;             // sıfıra bölmeyi önle / avoid division by zero
19
20  // Oransal ölçüm: besleme gerilimi hesaptan düşer / ratiometric: the supply voltage cancels out
21  float rLdr = R_FIXED * (1024.0 / ldrRaw - 1.0);
22  float rNtc = R_FIXED * ntcRaw / (1024.0 - ntcRaw);
23  float tempC = 1.0 / (1.0 / T0 + log(rNtc / R0) / BETA) - 273.15;  // Beta denklemi / Beta equation
24
25  Serial.print(F("LDR: "));
26  Serial.print(rLdr / 1000.0, 1);
27  Serial.print(F(" kOhm   NTC: "));
28  Serial.print(rNtc / 1000.0, 2);
29  Serial.print(F(" kOhm   "));
30  Serial.print(tempC, 1);
31  Serial.println(F(" C"));
32  delay(1000);
33}

Im Code liegt der LDR oben, deshalb steigt der Messwert mit zunehmender Helligkeit; sein Widerstand ist R = 10 kΩ × (1024 / ADC − 1). Der NTC liegt unten: Steigt die Temperatur, sinkt sein Widerstand und damit die gemessene Spannung. Für die verbreiteten NTCs mit 10 kΩ bei 25 °C und einem B-Wert von 3950 ergibt sich die Temperatur aus der Beta-Gleichung: 1 / T = 1 / T0 + ln(R / R0) / B (Temperaturen in Kelvin). Da der Festwiderstand dem NTC-Wert bei 25 °C entspricht, liegt der Ausgang bei Raumtemperatur genau bei der halben Versorgungsspannung, wo die Empfindlichkeit am größten ist. Für mehr Genauigkeit über einen großen Temperaturbereich behandeln wir die Steinhart-Hart-Gleichung und die Eigenerwärmung des NTC im Beitrag zum NTC-Thermistor.

Projektideen mit Spannungsteiler

• Batteriewächter mit Unterspannungsalarm: Überwache die Batterie im Wohnmobil oder in der Solaranlage und lass einen Summer ertönen, wenn sie unter 11,8 V fällt; Versorgungsmöglichkeiten für Batterieprojekte findest du unter Arduino mit Batterie betreiben.
• Digitales Voltmeter: Zeige die gemessene Spannung auf einem LCD oder OLED an; die Schritte stehen in Arduino-Voltmeter bauen.
• Automatisches Nachtlicht: Schalte mit einem LDR-Teiler LEDs oder ein Relais ein, sobald es dunkel wird.
• Sonnennachführung: Vergleiche die Spannungen zweier LDR-Teiler und richte ein Solarpanel zum Licht aus (Sonnennachführung).
• Fünf Taster an einem Pin: Baue eine Leiter aus verschiedenen Widerständen und erkenne am Analogwert, welcher Taster gedrückt ist (Taster anschließen).
• Thermostat: Miss die Temperatur mit einem NTC-Teiler und schalte bei der eingestellten Temperatur einen Lüfter oder eine Heizung über ein Relais.

Typische Fehler und ihre Lösungen

Ein Spannungsteiler besteht nur aus zwei Widerständen und einer Formel, taucht aber in fast jedem Projekt auf, das etwas misst. Wählst du das Verhältnis mit der Formel und die absoluten Werte als Kompromiss zwischen Querstrom und Innenwiderstand, berücksichtigst du die Belastung und kalibrierst das Ergebnis mit dem Multimeter, bekommst du zuverlässige Messwerte. Die Grundlagen des analogen Messens findest du in Was ist ein ADC?. In der BlueGrays-App findest du Projekte wie Lichtstärke mit dem LDR messen, ein LDR-Nachtlicht, ein digitales Voltmeter mit LCD, Temperaturmessung mit dem NTC und einen Entfernungsmesser mit ESP32 und HC-SR04, jeweils Schritt für Schritt mit Schaltplan und Code.