Grundlagen · 11 Min. Lesezeit

Elektrische Leistung berechnen: P = U × I, Watt, kWh, Beispiele

Elektrische Leistung berechnen mit P = U × I: Watt und kWh erklärt, Stromkosten, Widerstand und Spannungsregler, Netzteil-Wahl, LED-Streifen und Motoren.

Elektrische Leistung berechnen heißt herauszufinden, wie viel Energie eine Schaltung oder ein Gerät pro Sekunde umsetzt. Die Grundformel ist ganz einfach: P = U × I, also Leistung (Watt) gleich Spannung (Volt) mal Strom (Ampere). Eine Schaltung mit 5 V und 2 A nimmt 10 W auf, ein Motor mit 12 V und 0,5 A nimmt 6 W auf. Diese eine Formel beantwortet viele Fragen der Elektronik: Welches Netzteil brauche ich, verbrennt mein Widerstand, wie lange hält der Akku, wie hoch ist die Stromrechnung?

Wenn du Projekte mit Arduino, ESP32 oder Raspberry Pi Pico baust, ersparen dir Leistungsberechnungen drei große Ärgernisse: Boards, die wegen eines zu schwachen Netzteils von selbst neu starten, Spannungsregler, an denen man sich die Finger verbrennt, und qualmende Widerstände. In diesem Beitrag lernst du die Formeln und Einheiten (W, Wh, kWh, mAh), die Berechnung von Energieverbrauch und Stromkosten, die Erwärmung von Widerständen und Reglern, die Netzteilwahl sowie Rechenbeispiele für LED-Streifen und Motoren. Zum Schluss messen wir die Leistung mit dem INA219-Sensor tatsächlich, mit Arduino und Pico.

Was ist elektrische Leistung und wie berechnest du sie?

Die Leistung zeigt, wie schnell Energie verbraucht oder umgewandelt wird. Ihre Einheit ist das Watt (W); 1 W bedeutet 1 Joule Energie pro Sekunde. Stell dir die Spannung als Wasserdruck in einem Rohr vor und den Strom als die Wassermenge, die hindurchfließt: Die Leistung ist die Arbeit, die das Wasser pro Sekunde verrichtet. Je höher Druck oder Durchfluss, desto mehr Arbeit. Die Grundformel lautet P = U × I. Setzt du die Beziehung U = I × R aus dem Ohmschen Gesetz ein, erhältst du zwei weitere nützliche Formen: P = I² × R und P = U² / R. Welche du nimmst, hängt davon ab, welche zwei Werte du kennst. Schnell rechnen kannst du auch mit dem Ohmschen-Gesetz-Rechner.

FormelWann verwenden?Beispiel
P = U × IWenn du Spannung und Strom kennst5 V × 2 A = 10 W
P = I² × RWenn du Strom und Widerstand kennst (Erwärmung von Widerständen)(0,02 A)² × 150 Ω = 0,06 W
P = U² / RWenn du Spannung und Widerstand kennst (Heizdrähte)(12 V)² / 100 Ω = 1,44 W
I = P / UUm den Strom aus der Leistung eines Geräts zu bestimmen60 W / 12 V = 5 A
E = P × tEnergie, die in einer bestimmten Zeit verbraucht wird10 W × 3 Stunden = 30 Wh

Watt, kWh und mAh: Energieverbrauch und Stromkosten

Am häufigsten wird Leistung mit Energie verwechselt. Watt ist eine Momentangröße, wie der Tacho im Auto: Sie sagt, wie viel es gerade ist. Wattstunde (Wh) und Kilowattstunde (kWh) sind Energie, wie der Kilometerzähler: Sie sagen, wie viel es insgesamt war. Ein 100-W-Gerät, das 10 Stunden läuft, verbraucht 1000 Wh, also 1 kWh Energie. Die Stromrechnung richtet sich nicht nach der Leistung, sondern nach den verbrauchten kWh. Die mAh (Milliamperestunden) auf Akkus geben die elektrische Ladung an; für die Energie musst du mit der Spannung multiplizieren: Wh = mAh × V / 1000.

EinheitWas wird gemessen?Umrechnung / Beispiel
mW (Milliwatt)Leistung1 W = 1000 mW; eine Anzeige-LED hat etwa 40 mW
W (Watt)Leistung5 V × 1 A = 5 W
kW (Kilowatt)Leistung1 kW = 1000 W; ein Wasserkocher hat etwa 2 kW
Wh (Wattstunde)Energie10 W × 1 Stunde = 10 Wh
kWh (Kilowattstunde)Energie (Einheit auf der Rechnung)1000 W × 1 Stunde = 1 kWh
mAh (Milliamperestunde)Elektrische Ladung (Akkukapazität)2500 mAh × 3,7 V = 9,25 Wh
kW und kWh sind nicht dasselbe. „Das Gerät verbraucht im Monat 50 kW“ ist falsch, richtig sind 50 kWh. Ebenso speichern ein Li-Ion-Akku mit 2000 mAh bei 3,7 V und ein NiMH-Akku mit 2000 mAh bei 1,2 V nicht dieselbe Energie: Der erste speichert 7,4 Wh, der zweite nur 2,4 Wh. Rechne Akkus beim Vergleich immer in Wh um.

Den Monatsverbrauch eines Geräts findest du in drei Schritten: Leistung (W) mit den täglichen Betriebsstunden multiplizieren, das Ergebnis mit 30 Tagen multiplizieren und durch 1000 teilen, um kWh zu erhalten. Für den Rechnungsbetrag multiplizierst du die kWh mit dem Preis pro kWh. Eine 9-W-LED-Lampe, die täglich 5 Stunden brennt, verbraucht 9 × 5 × 30 = 1350 Wh = 1,35 kWh; bei einem angenommenen Preis von 0,30 €/kWh kostet das im Monat etwa 0,40 €. Die Tabelle unten zeigt, wie klein der Einfluss eines rund um die Uhr laufenden Arduino auf die Rechnung ist, wie viel Unterschied dagegen ein LED-Streifen oder ein Wasserkocher macht. Denk daran: Auch das Netzteil selbst verbraucht durch Wirkungsgradverluste einige hundert Milliwatt extra.

GerätLeistungTägliche NutzungMonatsverbrauch
Arduino Uno (USB, Leerlauf)≈ 0,25 W24 Stunden≈ 0,18 kWh
ESP32 (WLAN an, Durchschnitt)≈ 0,5 W24 Stunden≈ 0,36 kWh
9-W-LED-Lampe9 W5 Stunden1,35 kWh
5 m 12-V-LED-Streifen (5050, 60 LEDs/m)72 W5 Stunden10,8 kWh
Wasserkocher2000 W10 Minuten10 kWh

Warum wird ein Widerstand heiß? Den richtigen Wattwert wählen

Fließt Strom durch einen Widerstand, wird die aufgenommene Leistung vollständig in Wärme umgewandelt. Das nennt man Joulesche Wärme, und sie berechnet sich mit P = I² × R. Die Standardwiderstände, die du auf dem Breadboard verwendest, vertragen meist 1/4 W (0,25 W). Für einen sicheren Entwurf wählst du am besten einen Widerstand mit mindestens der doppelten berechneten Leistung, denn nahe am Grenzwert wird er sehr heiß und sein Wert driftet. Beispiel 1: Eine rote LED (2 V, 20 mA) an 5 V braucht (5 − 2) / 0,02 = 150 Ω; die Leistung am Widerstand beträgt 3 V × 0,02 A = 0,06 W, da reicht 1/4 W locker. Beispiel 2: Eine einzelne weiße LED (3,2 V) an 12 V lässt 8,8 V am Widerstand abfallen; mit 470 Ω fließen etwa 18,7 mA und die Leistung steigt auf 8,8 × 0,0187 ≈ 0,165 W. Das sind zwei Drittel von 1/4 W, der Widerstand wird deutlich warm. Deshalb ist es klüger, einen 1/2-W-Widerstand zu nehmen oder mehrere LEDs in Reihe zu schalten, damit am Widerstand weniger Spannung abfällt. Die Werte findest du in Sekunden mit dem LED-Vorwiderstandsrechner.

BelastbarkeitTypisches AussehenEmpfohlene maximale Dauerbelastung
1/8 W (0,125 W)Sehr klein, dünner Körper≈ 0,06 W
1/4 W (0,25 W)Standardwiderstand auf dem Breadboard≈ 0,125 W
1/2 W (0,5 W)Etwas dickerer Körper≈ 0,25 W
1 W – 2 WMetalloxidwiderstand mit großem Körper≈ 0,5 – 1 W
5 W – 10 WWeißer Keramikwiderstand (Zementwiderstand)≈ 2,5 – 5 W

Erwärmung von Spannungsreglern: 7805 und AMS1117 berechnen

Linearer Spannungsregler LM7805 mit 5 V Ausgang
LM7805-Linearregler: Die Spannungsdifferenz zwischen Eingang und Ausgang, multipliziert mit dem Strom, wird direkt zu Wärme.

Lineare Regler wie der 7805, der AMS1117 und der Regler auf dem Arduino-Board verheizen überschüssige Spannung als Wärme. Die Verlustleistung berechnest du mit P = (U_ein − U_aus) × I, und der Wirkungsgrad beträgt etwa U_aus / U_ein. Machst du aus 12 V 5 V und ziehst 500 mA, erzeugt der Regler (12 − 5) × 0,5 = 3,5 W Wärme. Der Wärmewiderstand eines TO-220-Gehäuses ohne Kühlkörper liegt bei etwa 50–65 °C/W; 3,5 W bedeuten also über 175 °C über der Umgebungstemperatur, und der Regler schaltet zum Selbstschutz ab. Du musst entweder einen großen Kühlkörper verwenden oder die Eingangsspannung senken. Die effizienteste Lösung ist ein Schaltregler (Buck) wie der LM2596: Mit 85–90 % Wirkungsgrad verliert er für dieselbe Aufgabe nur 0,3–0,5 W. Details findest du in den Beiträgen Spannungsregler 7805 und LM2596 Step-down-Wandler.

ReglerEingang → AusgangStromVerlust als WärmeWirkungsgrad
LM78059 V → 5 V0,3 A1,2 W≈ 56 %
LM780512 V → 5 V0,5 A3,5 W≈ 42 %
AMS1117-3.35 V → 3,3 V0,3 A0,51 W≈ 66 %
LM2596 (Buck)12 V → 5 V2 A≈ 1,4 W≈ 88 %
Den Arduino Uno über die DC-Buchse mit 12 V zu versorgen und dann über den 5V-Pin Servos, Relais oder einen LED-Streifen zu betreiben, überhitzt den kleinen Regler auf dem Board schnell: Schon eine Last von 200 mA bedeutet (12 − 5) × 0,2 = 1,4 W, und das ist für dieses kleine SMD-Gehäuse viel zu viel. Nimm an der DC-Buchse 7–9 V und versorge Verbraucher mit hohem Strom aus einer separaten 5-V-Quelle, wobei du die GND-Leitungen verbindest. Das ganze Thema findest du im Beitrag Arduino-Stromversorgung.

Netzteil wählen: Wie viel Ampere und Watt brauchst du?

  1. Schreib für jedes Bauteil im Projekt die Betriebsspannung und den Strom im ungünstigsten Fall auf; diese Werte stehen in den Datenblättern oder Modulbeschreibungen.
  2. Addiere die Ströme aller Teile, die mit derselben Spannung versorgt werden. Bei Motoren und Servos rechnest du nicht mit dem normalen Strom, sondern mit dem Anlauf- und Blockierstrom (Stall): Ein SG90-Servo kann bei Blockierung bis zu 650 mA ziehen. Ein Kondensator von 470–1000 µF neben den Servos dämpft Spannungseinbrüche bei plötzlichen Stromspitzen.
  3. Wenn ein Regler dazwischen sitzt, entspricht der Eingangsstrom beim Linearregler dem Ausgangsstrom; beim Buck-Wandler rechnest du über die Leistung: I_ein ≈ (U_aus × I_aus) / (U_ein × Wirkungsgrad).
  4. Schlag auf den Gesamtstrom 20–30 % Reserve auf; Netzteile werden warm, wenn sie dauerhaft am Limit des Typenschilds laufen, und ihre Ausgangsspannung sinkt.
  5. Wähle die Spannung genau passend und den Strom gleich oder größer als berechnet. Die Stromangabe des Netzteils ist eine Obergrenze; deine Schaltung zieht nur so viel, wie sie braucht, daher schadet ein 5-V-3-A- statt eines 5-V-2-A-Netzteils nicht. Eine zu hohe Spannung dagegen kann die Schaltung zerstören.
Bauteil (5 V)AnzahlTypischer StromSumme
Arduino Uno1≈ 50 mA50 mA
SG90-Servo (in Bewegung)2≈ 250 mA500 mA
WS2812B-LED (volles Weiß)3060 mA1800 mA
HC-SR04-Abstandssensor1≈ 15 mA15 mA
I2C-16x2-LCD (Hintergrundbeleuchtung an)1≈ 30 mA30 mA
Gesamt≈ 2,4 A (12 W) → mit 25 % Reserve ein 5-V-3-A-Netzteil (15 W)

Rechenbeispiel: LED-Streifen und WS2812B-Projekte

12-V-LED-Streifen vom Typ 5050 haben meist 60 LEDs pro Meter und rund 14,4 W/m. Für 3 Meter Streifen brauchst du 14,4 × 3 = 43,2 W; der Strom beträgt I = 43,2 / 12 = 3,6 A. Mit 25 % Reserve sind das 4,5 A, ein 12-V-5-A-Netzteil (60 W) passt also. Willst du den Streifen per PWM mit dem Arduino dimmen, kommt ein MOSFET dazu; ein Logic-Level-MOSFET wie der IRLZ44N hat bei 5 V Gate-Spannung einen Durchlasswiderstand von etwa 0,022 Ω, der Verlust beträgt P = I² × R = 3,6² × 0,022 ≈ 0,29 W, ein Kühlkörper ist also nicht nötig. Bei adressierbaren WS2812B-LEDs zieht jede LED in vollem Weiß etwa 60 mA: Ein 1 Meter langer Streifen mit 144 LEDs pro Meter bedeutet 144 × 0,06 = 8,64 A, also 43 W bei 5 V. Ein so hoher Strom verursacht im dünnen Kupfer des Streifens Spannungsabfall; speise lange Streifen an mehreren Stellen ein und begrenze die Helligkeit in der Software. Details findest du in den Beiträgen WS2812B NeoPixel, RGB-LED-Streifen steuern und Arduino MOSFET verwenden.

Rechenbeispiel: Motorprojekte und Akkulaufzeit

Gelbe TT-Getriebemotoren ziehen bei 6 V im Leerlauf etwa 150–250 mA, bei blockiertem Rad kann der Strom aber über 1 A steigen. Ein Roboterauto mit vier Motoren zieht bei normaler Fahrt insgesamt etwa 1 A. Ein L298N an zwei 18650-Akkus (7,4 V) verliert wegen seiner Bipolartransistoren etwa 2 V; die Motoren sehen deshalb nur etwa 5,4 V, und der L298N verheizt 2 V × 1 A = 2 W. Fast ein Viertel der 7,4 W aus den Akkus geht im Treiber verloren; MOSFET-Treiber wie der TB6612FNG verringern diesen Verlust stark. Die Akkulaufzeit schätzt du grob mit Kapazität (mAh) / mittlerer Strom (mA) × 0,8: Bei einem 2500-mAh-Pack und 1,2 A Durchschnitt inklusive Arduino erhältst du 2500 / 1200 × 0,8 ≈ 1,7 Stunden Fahrzeit. Der Akkulaufzeit-Rechner nimmt dir diese Arbeit ab; weiter geht es mit DC-Motorsteuerung mit dem L298N, Motortreiber im Vergleich und mAh-Akkukapazität.

Leistung mit dem Arduino messen: der INA219-Sensor

Rechnen ist schön, aber den echten Verbrauch siehst du erst, wenn du misst. Den Strom kannst du mit einem Multimeter messen, doch um wechselnde Lasten und die über die Zeit angesammelte Energie zu verfolgen, ist das INA219-Modul viel praktischer. Es misst den kleinen Spannungsabfall an einem 0,1-Ω-Shunt-Widerstand in Reihe mit der Last und liest gleichzeitig die Lastspannung; über I2C kannst du Spannungen bis 26 V und in der Standardeinstellung Ströme bis etwa 3,2 A messen. Der Code setzt genau die Formeln aus diesem Beitrag um: P = U × I für die Momentanleistung und E = P × t für die Gesamtenergie. Du musst nur die Bibliothek Adafruit INA219 über den Bibliotheksverwalter installieren. Zu Messprinzip und Kalibrierung siehe den Beitrag INA219-Stromsensor.

INA219-PinArduino UnoESP32Raspberry Pi Pico
VCC5V3V33V3 (Pin 36)
GNDGNDGNDGND
SCLA5GPIO 22GP5
SDAA4GPIO 21GP4
VIN+Pluspol der StromquellePluspol der StromquellePluspol der Stromquelle
VIN−Pluspol der LastPluspol der LastPluspol der Last
C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_INA219.h>
3
4Adafruit_INA219 ina219;          // varsayılan I2C adresi 0x40 / default I2C address 0x40
5
6float energy_mWh = 0.0;          // biriken enerji / accumulated energy
7unsigned long lastMs = 0;
8
9void setup() {
10  Serial.begin(115200);
11  if (!ina219.begin()) {
12    Serial.println(F("INA219 bulunamadi / INA219 not found"));
13    while (1) { delay(10); }
14  }
15  lastMs = millis();
16}
17
18void loop() {
19  float busV = ina219.getBusVoltage_V();        // yük gerilimi (V) / load voltage (V)
20  float current_mA = ina219.getCurrent_mA();    // akım (mA) / current (mA)
21  float power_mW = busV * current_mA;           // güç: P = V x I / power: P = V x I
22
23  unsigned long now = millis();
24  float dtHours = (now - lastMs) / 3600000.0;   // ms -> saat / ms -> hours
25  lastMs = now;
26  energy_mWh += power_mW * dtHours;             // enerji: E = P x t / energy: E = P x t
27
28  Serial.print(F("V: "));
29  Serial.print(busV, 2);
30  Serial.print(F(" V  I: "));
31  Serial.print(current_mA, 1);
32  Serial.print(F(" mA  P: "));
33  Serial.print(power_mW, 0);
34  Serial.print(F(" mW  E: "));
35  Serial.print(energy_mWh, 2);
36  Serial.println(F(" mWh"));
37
38  delay(1000);
39}

Der Code liest jede Sekunde Lastspannung und Strom und multipliziert beide zur Leistung in Milliwatt. Danach rechnet er die mit millis() gemessene Zeit zwischen zwei Messungen in Stunden um, multipliziert sie mit der Leistung und addiert das Ergebnis zur Gesamtenergie; so siehst du im Serial Monitor, wie viele mWh dein Gerät bis jetzt verbraucht hat. Die Funktion getPower_mW() der Bibliothek liefert dasselbe Ergebnis; hier haben wir die Multiplikation selbst gemacht, um die Formel zu zeigen. Wichtig: Der Minuspol der gemessenen Stromquelle muss mit dem GND des Arduino verbunden sein, sonst ist die Spannungsmessung unbrauchbar. Der Shunt wird immer in Reihe mit der Last geschaltet; VIN+ und VIN− direkt an die beiden Pole eines Akkus zu klemmen, verursacht einen Kurzschluss.

Leistungsmessung mit ESP32 und Raspberry Pi Pico

Der obige Arduino-Code läuft auf dem ESP32 ohne Änderung; die Wire-Bibliothek nutzt standardmäßig GPIO 21 (SDA) und GPIO 22 (SCL). Der ESP32 ist für solche Messungen ein interessantes Board, weil sich sein Verbrauch je nach Zustand stark ändert: Beim Senden per WLAN kann der Momentanstrom 240 mA übersteigen, im Durchschnitt liegt er bei 80–120 mA, im Deep Sleep zieht der Chip nur etwa 10 µA. Plötzliche Stromspitzen lassen an einem schwachen USB-Kabel oder Netzteil die Spannung einbrechen und führen zu Brownout-Resets; mit dem INA219 kannst du diese Spitzen sehen und messen, um wie viel der Deep Sleep die Akkulaufzeit verlängert. Auf dem Raspberry Pi Pico genügt ohne Bibliothek ein kurzer MicroPython-Code, der die Register des INA219 direkt ausliest:

MicroPython
1from machine import Pin, I2C
2import time
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
5ADDR = 0x40              # INA219 varsayılan adresi / INA219 default address
6R_SHUNT = 0.1            # modüldeki şönt direnci (ohm) / shunt resistor on the module (ohm)
7
8def read_reg(reg):
9    data = i2c.readfrom_mem(ADDR, reg, 2)   # 2 bayt oku / read 2 bytes
10    return (data[0] << 8) | data[1]
11
12energy_wh = 0.0                              # biriken enerji / accumulated energy
13last = time.ticks_ms()
14
15while True:
16    raw = read_reg(0x01)                     # şönt gerilimi yazmacı / shunt voltage register
17    if raw > 32767:                          # işaretli sayıya çevir / convert to signed
18        raw -= 65536
19    shunt_v = raw * 0.00001                  # 1 birim = 10 uV / 1 LSB = 10 uV
20    bus_v = (read_reg(0x02) >> 3) * 0.004    # 1 birim = 4 mV / 1 LSB = 4 mV
21    current_a = shunt_v / R_SHUNT            # Ohm kanunu: I = V / R / Ohm's law: I = V / R
22    power_w = bus_v * current_a              # güç: P = V x I / power: P = V x I
23
24    now = time.ticks_ms()
25    dt_h = time.ticks_diff(now, last) / 3600000   # ms -> saat / ms -> hours
26    last = now
27    energy_wh += power_w * dt_h              # enerji: E = P x t / energy: E = P x t
28
29    print("V: {:.2f} V  I: {:.1f} mA  P: {:.0f} mW  E: {:.4f} Wh".format(
30        bus_v, current_a * 1000, power_w * 1000, energy_wh))
31    time.sleep(1)

Projektideen rund um die Leistungsberechnung

  • USB-Leistungsmesser: Zeige mit dem INA219 und einem OLED-Display die Momentanleistung und die Gesamt-Wh eines Handy-Ladevorgangs oder deines Arduino-Projekts an.
  • Akkutester: Entlade einen Akku über einen Lastwiderstand und miss seine Kapazität in mAh und Wh; nutze die Ergebnisse, um 18650-Akkus zu vergleichen.
  • Smarter Steckdosenzähler: Verfolge mit dem ESP32 den kWh-Verbrauch eines Geräts an der Steckdose und berechne die Monatskosten; verwende für die 230-V-Seite isolierte, sichere Module und lies den Beitrag ESP32 Smart Plug.
  • Leistungsanzeige für den Schreibtisch: Ergänze ein Arduino-Voltmeter um einen Stromsensor und baue ein Messgerät, das Spannung, Strom und Leistung gleichzeitig zeigt.
  • Solarpanel-Monitor: Miss die Leistung vom Panel zur Batterie und protokolliere die über den Tag erzeugten Wh.
  • Akkulaufzeit-Experiment: Lass denselben ESP32-Code mit und ohne Deep Sleep laufen, miss den Durchschnittsstrom und vergleiche die Akkulaufzeit.

Häufige Fehler und ihre Lösungen

FehlerSymptomLösung
Netzteilstrom zu knapp gewähltBoard startet zufällig neu, LEDs flackern, Servo zittertGesamtstrom berechnen, 20–30 % Reserve aufschlagen
Netzteil mit höherer Spannung für „stärker“ haltenRegler überhitzt, Bauteile verbrennenSpannung genau passend und Strom ausreichend wählen
Wattzahl des Widerstands nicht berechnetWiderstand wird schwarz, riecht verbrannt, Wert driftetMit P = I² × R berechnen, Widerstand mit doppelter Belastbarkeit wählen
Mit Linearregler große Spannungsdifferenz abbauen7805 wird sehr heiß, schaltet thermisch abEingangsspannung senken, Kühlkörper oder Buck-Wandler verwenden
mAh für Energie haltenAkkus mit unterschiedlicher Spannung werden falsch verglichenMit Wh = mAh × V / 1000 umrechnen
Amperemeter parallel anschließenSicherung des Multimeters brennt durch, Quelle wird kurzgeschlossenStrommessgerät immer in Reihe mit der Last schalten
Der schnellste Weg abzuschätzen, wie warm eine Schaltung wird, ist, für jedes Bauteil „abfallende Spannung × durchfließender Strom“ zu multiplizieren. Liegt das Ergebnis unter 0,1 W, ist meist alles in Ordnung; kleine Teile werden bei etwa 0,5 W spürbar warm, ab 1 W solltest du unbedingt an Kühlung denken. Echte Werte misst du, wie im Beitrag Multimeter richtig benutzen beschrieben.

Wenn du P = U × I und seine beiden abgeleiteten Formen beherrschst, beruhen Netzteilkauf, Widerstandswahl, Akkulaufzeit-Schätzung und Stromkostenrechnung nicht mehr auf Raten, sondern auf Rechnung. Gewöhnst du dir an, bei jedem neuen Projekt zuerst eine kleine Leistungstabelle zu erstellen, verschwinden verbrannte Bauteile und unerklärliche Resets weitgehend. In der BlueGrays-App findest du Projekte mit LEDs, LED-Streifen, Motoren und digitalem Voltmeter Schritt für Schritt mit Schaltplänen und Code, an denen du die hier gelernten Berechnungen an echten Schaltungen ausprobieren kannst.

Häufige Fragen

Wie berechnet man Watt?

Watt ist das Produkt aus Spannung und Strom: P = U × I. Ein Gerät mit 12 V und 2 A nimmt zum Beispiel 24 W auf. Kennst du nur Strom und Widerstand, nutzt du P = I² × R, kennst du Spannung und Widerstand, P = U² / R.

Wie viel Watt sind 1 kWh?

kWh ist keine Leistung, sondern eine Energieeinheit, deshalb entspricht sie keinem direkten Wattwert. 1 kWh ist die Energie, die ein Gerät mit 1000 W in einer Stunde verbraucht. Eine 100-W-Lampe verbraucht 1 kWh in 10 Stunden, ein 10-W-Gerät in 100 Stunden.

Wie berechne ich den monatlichen Stromverbrauch eines Geräts?

Multipliziere die Leistung des Geräts (W) mit den täglichen Betriebsstunden und mit 30 Tagen, und teile durch 1000, um kWh zu erhalten. Ein 72-W-LED-Streifen, der täglich 5 Stunden brennt, verbraucht 72 × 5 × 30 / 1000 = 10,8 kWh. Multipliziert mit dem Preis pro kWh erhältst du die Monatskosten.

Schadet ein Netzteil mit mehr Ampere dem Gerät?

Solange die Spannung stimmt, nicht. Die Stromangabe auf dem Netzteil ist der maximale Strom, den es liefern kann; die Schaltung zieht nur so viel, wie sie braucht. Gefährlich ist, eine zu hohe Spannung zu wählen oder ein Netzteil, dessen Strom unter dem Bedarf liegt.

Wie rechnet man Ampere in Watt um?

Du multiplizierst den Strom mit der Spannung: W = A × V. Ein USB-Netzteil mit 3 A bei 5 V liefert 15 W, ein ohmsches Gerät mit 2 A am 230-V-Netz nimmt etwa 460 W auf. Bei Wechselstrom spielt bei Geräten mit Motor zusätzlich der Leistungsfaktor eine Rolle, und ohne die Spannung zu kennen kannst du nicht von Ampere auf Watt umrechnen.

Wie viel Watt muss ein Widerstand haben?

Berechne zuerst mit P = I² × R oder P = U × I die Leistung, die am Widerstand umgesetzt wird, und wähle dann einen Widerstand mit mindestens der doppelten Belastbarkeit. Beim Betrieb von LEDs am Arduino liegt die Leistung meist unter 0,1 W, deshalb genügt ein Standardwiderstand mit 1/4 W. Bei Schaltungen ab 12 V können 1/2 W oder größere Widerstände nötig sein.

Alle Projekte ansehen
LED Blinken
AR-1Anfänger

LED Blinken

Das allererste Hallo der Elektronik: eine einzelne LED an- und ausschalten. Der Arduino schaltet die LED in kurzen Abständen ein und aus, das Licht blinkt also schnell.

4.6(200)
1246
Raspberry Pi Pico: Externe LED zum Leuchten bringen (Steckbrett)
PI-2Anfänger

Raspberry Pi Pico: Externe LED zum Leuchten bringen (Steckbrett)

Der nächste Schritt nach der eingebauten LED des Pico: eine externe LED auf dem Steckbrett anschließen und über Pin GP14 steuern. Du lernst, jeden GPIO-Pin des Pico als Ausgang zu nutzen, die Polung der LED (langes Bein = Anode/+, kurzes Bein = Kathode/–) und warum ein Vorwiderstand (220Ω) Pflicht ist. Ohne ihn fließt zu viel Strom durch die LED und sie kann durchbrennen.

4.5(2)
7
Digitales Voltmeter mit LCD-Anzeige
AR-56Mittel
Premium

Digitales Voltmeter mit LCD-Anzeige

Finde mit einem selbstgebauten Messgerät heraus, wie viel Spannung eine Batterie oder ein Netzteil liefert.

4.5(27)
36
220V Glühbirne mit Druckknopf (Push)
AR-19Fortgeschritten
Premium

220V Glühbirne mit Druckknopf (Push)

Solange du den Knopf gedrückt hältst, leuchtet eine echte 220-Volt-Glühbirne, und sobald du loslässt, geht sie aus.

4.4(30)
38
WS2812B-LED-Streifen verwenden
AR-69Mittel
Premium

WS2812B-LED-Streifen verwenden

Du lernst einen smarten LED-Streifen kennen, bei dem du jedes einzelne Licht für sich einfärben kannst.

4.8(54)
70
Steuerung des ESP32 WS2812B NeoPixel-Streifens
ES-24Mittel
Premium

Steuerung des ESP32 WS2812B NeoPixel-Streifens

WS2812B-LEDs (NeoPixel) sind adressierbare RGB-LEDs, die sich in Reihe über einen einzigen Datenpin steuern lassen. Wir steuern einen WS2812B-Streifen mit 8 LEDs über die Bibliothek Adafruit_NeoPixel und erzeugen eine flüssige Regenbogenanimation. Die 3,3-V-Logik des ESP32 klappt bei den meisten WS2812B; bei Instabilität hilft ein 470Ω-Serienwiderstand plus 1000µF-Kondensator. Die Animation verschiebt den Farbton im HSV-Farbraum.

4.9(19)
30
Bluetooth-gesteuertes Auto mit L298N
AR-80Fortgeschritten
Premium

Bluetooth-gesteuertes Auto mit L298N

Mach dein Handy zur Fernbedienung und steuere dein eigenes Roboterauto. Der Arduino empfängt über ein Bluetooth-Modul die Befehle einer Fernsteuer-App auf dem Handy und treibt die Räder über einen…

5.0(39)
66
ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
ES-33Fortgeschritten
Premium

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)

Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

4.3(10)
16