LED-Vorwiderstand berechnen & Lauflicht mit Arduino: Ohmsches Gesetz in der Praxis

Warum überhaupt ein Vorwiderstand?

Eine LED ist ein Halbleiter mit einer festen Durchlassspannung (Vorwärtsspannung). Ist die anliegende Spannung höher als diese Schwelle, steigt der Strom nahezu ungebremst an – die LED überhitzt und brennt durch. Der Vorwiderstand „frisst“ die überschüssige Spannung und begrenzt den Strom auf einen sicheren Wert, typischerweise 10 bis 20 Milliampere bei einer normalen 3- oder 5-mm-LED.

Das Ohmsche Gesetz – die eine Formel, die du brauchst

Das Ohmsche Gesetz verbindet Spannung (U), Strom (I) und Widerstand (R):

U = R * I     ->   R = U / I     ->   I = U / R

Für den LED-Vorwiderstand brauchen wir die umgestellte Form. Die Spannung über dem Widerstand ist die Versorgungsspannung minus die Durchlassspannung der LED:

R = (U_quelle - U_LED) / I_LED

Beispiel: rote LED an 5 V, Zielstrom 15 mA
U_LED (rot)  = 2,0 V
I_LED        = 0,015 A

R = (5 V - 2,0 V) / 0,015 A = 3,0 V / 0,015 A = 200 Ohm

200 Ω gibt es nicht als Standardwert – du nimmst den nächsthöheren, also 220 Ω. Etwas mehr Widerstand bedeutet etwas weniger Strom und damit eine minimal dunklere, aber länger lebende LED. Im Zweifel immer aufrunden.

Durchlassspannung je Farbe

Die Durchlassspannung hängt vom Halbleitermaterial und damit von der Farbe ab. Diese Richtwerte reichen für die Praxis:

Widerstands-Farbcode lesen

Aus dem Sortiment brauchst du den richtigen Wert – den verraten die farbigen Ringe. Bei einem 4-Ring-Widerstand sind die ersten beiden Ringe Ziffern, der dritte der Multiplikator, der vierte die Toleranz.

Beispiel 220 Ω: Rot (2) – Rot (2) – Braun (x10) = 22 × 10 = 220 Ω. Der vierte Ring (meist Gold) steht für 5 % Toleranz. Wer sich unsicher ist, misst einfach mit einem Multimeter nach.

Was du brauchst

Projekt 1: Knight-Rider-Lauflicht

Der Klassiker: Fünf LEDs, die wie beim Auto aus der Serie hin- und herwandern. Steck fünf LEDs mit je einem 220-Ω-Vorwiderstand an die Pins D2 bis D6 (langes Beinchen über den Widerstand zum Pin, kurzes Beinchen an GND).

const int leds[] = {2, 3, 4, 5, 6};
const int anzahl = 5;
const int tempo = 80;   // ms pro Schritt

void setup() {
  for (int i = 0; i < anzahl; i++) {
    pinMode(leds[i], OUTPUT);
  }
}

void loop() {
  // hin
  for (int i = 0; i < anzahl; i++) {
    digitalWrite(leds[i], HIGH);
    delay(tempo);
    digitalWrite(leds[i], LOW);
  }
  // zurueck (die Enden nicht doppelt)
  for (int i = anzahl - 2; i > 0; i--) {
    digitalWrite(leds[i], HIGH);
    delay(tempo);
    digitalWrite(leds[i], LOW);
  }
}

Projekt 2: Ampel mit realistischer Schaltfolge

Rot, Gelb, Grün – aber richtig, inklusive der Rot-Gelb-Phase wie bei einer echten deutschen Ampel. LEDs an D8 (rot), D9 (gelb) und D10 (grün), jeweils mit 220-Ω-Vorwiderstand.

const int rot  = 8;
const int gelb = 9;
const int gruen = 10;

void setup() {
  pinMode(rot, OUTPUT);
  pinMode(gelb, OUTPUT);
  pinMode(gruen, OUTPUT);
}

void alleAus() {
  digitalWrite(rot, LOW);
  digitalWrite(gelb, LOW);
  digitalWrite(gruen, LOW);
}

void loop() {
  // Rot
  alleAus();
  digitalWrite(rot, HIGH);
  delay(4000);

  // Rot + Gelb (gleich gehts los)
  digitalWrite(gelb, HIGH);
  delay(1500);

  // Gruen
  alleAus();
  digitalWrite(gruen, HIGH);
  delay(4000);

  // Gelb (gleich rot)
  alleAus();
  digitalWrite(gelb, HIGH);
  delay(1500);
}

Projekt 3: LED per Poti dimmen (PWM)

Bisher waren LEDs nur an oder aus. Mit PWM (Pulsweitenmodulation) regelst du die Helligkeit stufenlos. Wir lesen einen Drehregler am Analogpin A0 und geben den Wert an eine LED an D9 (PWM-fähig) aus.

const int potiPin = A0;
const int ledPin  = 9;   // PWM (~)

void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int roh = analogRead(potiPin);        // 0 .. 1023 (10-Bit-ADC)
  int hell = map(roh, 0, 1023, 0, 255); // auf 8-Bit-PWM skalieren
  analogWrite(ledPin, hell);

  Serial.print("Poti: ");
  Serial.print(roh);
  Serial.print("  ->  Helligkeit: ");
  Serial.println(hell);
  delay(50);
}

Der Analogeingang liefert 0 bis 1023, analogWrite() erwartet 0 bis 255 – die map()-Funktion rechnet den Bereich sauber um. Drehst du den Regler, dimmt die LED gleichmäßig von aus bis voll.

Häufige Fehler