Digitale Ausgänge am Mikrocontroller: LED mit Vorwiderstand, Ausgangsstrom und Lasten mit Transistor oder Relais

Digitale Ausgänge am Mikrocontroller: LED mit Vorwiderstand, Ausgangsstrom und Lasten mit Transistor oder Relais

https://bildung.social/@oerinformatik/

https://oer-informatik.de/mcu-digitale-ausgaenge

Mikrocontroller, digitaler Ausgang, digitalWrite, LED, Vorwiderstand, Ausgangsstrom, Summenstrom, Transistor, MOSFET, Relais, Freilaufdiode, High-Side

tl/dr; (ca. 28 min Lesezeit): Ein Ausgangspin kann eine LED direkt treiben, ein Relais oder einen Lüfter aber nicht. Hier schaltest Du mit pinMode() und digitalWrite() mehrere LEDs (Ampel), berechnest den Vorwiderstand für 3,3 V und 5 V, liest zulässige Pin- und Summenströme aus dem Datenblatt, stellst eine Strombilanz auf und treibst größere Lasten über Transistor, MOSFET oder Relais mit Freilaufdiode – Low-Side und High-Side. Für ESP32-C6, ESP32, ESP8266 (NodeMCU) und Arduino Uno [AI-Assisted]. (Zuletzt geändert am 10.11.2026)

Dieser Artikel ist Teil einer Artikelreihe über Mikrocontroller-Grundlagen: Erste Schritte / Digitale Ausgänge / Digitale Eingänge / Variablen und Datentypen / Pinbelegung der Boards

Schon fit in diesem Thema? Nutze die Kann-Liste und die Leitfragen unter dem Artikel als Checkliste, ob Du die relevanten Kompetenzen bereits hast. Hier klicken, um Kann-Liste ein- oder auszublenden

Ein Mikrocontroller soll etwas bewirken: eine Statusanzeige leuchten lassen, eine Pumpe einschalten, ein Ventil öffnen. Dafür hat er digitale Ausgänge. Sie kennen zwei Zustände: HIGH (der Pin liegt an der Versorgungsspannung des Controllers) und LOW (der Pin liegt an Masse). Die Grenze dessen, was ein solcher Pin treiben kann, ist schnell erreicht. Eine LED schafft er direkt, ein Relais oder einen Lüfter nur über eine Verstärkerstufe.

Am Ende des Artikels steht diese Ampel auf dem Steckbrett, danach ein Lüfter, den ein Relais über einen Transistor schaltet:

Zum Üben gibt es eigene Übungsaufgaben zu digitalen Ausgängen.

Dieser Artikel baut auf der Kann-Liste des Artikels Erste Schritte mit dem Mikrocontroller auf.

Schritt 1: Einen Pin als Ausgang schalten

Nach einem Reset sind alle Pins Eingänge. Damit ein Pin etwas treibt, legst Du ihn in setup() mit pinMode(pin, OUTPUT); als Ausgang fest. Danach setzt digitalWrite(pin, HIGH); bzw. digitalWrite(pin, LOW); den Pegel. Der Pin behält diesen Pegel, bis Du ihn wieder änderst.

Im Inneren ist ein Ausgangspin eine Gegentaktstufe (push-pull): Ein Transistor verbindet den Pin mit der Versorgungsspannung (High), ein zweiter mit Masse (Low). Deshalb kann der Pin

• Strom liefern (source): Die Last liegt zwischen Pin und GND und ist eingeschaltet, wenn der Pin HIGH ist (high-aktiv),

• Strom aufnehmen (sink): Die Last liegt zwischen Versorgungsspannung und Pin und ist eingeschaltet, wenn der Pin LOW ist (low-aktiv).

In dieser Reihe sind alle externen LEDs high-aktiv angeschlossen. Wo ein Board eine low-aktive LED hat (die Onboard-LED des NodeMCU), steht in der Liste der Ein- und Ausgabeelemente eine Konstante wie LED_PWM1_ON, die den Einschaltpegel festhält – das zeigt der Artikel Erste Schritte.

Was HIGH als Spannung bedeutet, hängt vom Board ab:

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

Belastest Du den Pin, weicht die Spannung vom Ideal ab: Die Transistoren der Gegentaktstufe haben einen Widerstand. Das Datenblatt nennt deshalb eine minimale High-Spannung U_\mathrm{OH} und eine maximale Low-Spannung U_\mathrm{OL} bei einem bestimmten Strom. Beim ATmega328P mit 5 V sind es z. B. mindestens 4,2 V bzw. höchstens 0,9 V bei 20 mA. Für die Rechnungen in diesem Artikel vernachlässigen wir diesen Spannungsabfall.

Schritt 2: Den Vorwiderstand der LED berechnen

Eine LED ist eine Diode: Unterhalb ihrer Durchlassspannung U_\mathrm{F} fließt fast kein Strom, darüber steigt er sehr steil an. Direkt an einen Pin angeschlossen würde sie so viel Strom ziehen, wie die Ausgangsstufe hergibt – LED und Pin werden überlastet. Ein Widerstand in Reihe, der Vorwiderstand R_\mathrm{V}, begrenzt den Strom. Ob er vor oder hinter der LED liegt, ist gleich; „Serienwiderstand“ wäre der genauere Name.

Die Anode der LED (langes Bein, größere Elektrode im Inneren) zeigt zum positiveren Anschluss, die Kathode (kurzes Bein, abgeflachter Rand) zum negativeren. Falsch herum gesteckt sperrt die LED und leuchtet nicht.

Nach der Maschenregel teilen sich LED und Vorwiderstand die Pinspannung: U_\mathrm{OH} = U_\mathrm{V} + U_\mathrm{F}. Am Widerstand fällt also der Rest ab, und mit dem gewünschten Strom I_\mathrm{F} folgt nach dem ohmschen Gesetz:

R_\mathrm{V} = \frac{U_\mathrm{V}}{I_\mathrm{F}} = \frac{U_\mathrm{OH} - U_\mathrm{F}}{I_\mathrm{F}}

Beispiel ESP32 (3,3 V): rote LED mit U_\mathrm{F} = 2{,}0\ \mathrm{V}, gewünscht I_\mathrm{F} = 6\ \mathrm{mA}:

R_\mathrm{V} = \frac{3{,}3\ \mathrm{V} - 2{,}0\ \mathrm{V}}{6\ \mathrm{mA}} = \frac{1{,}3\ \mathrm{V}}{0{,}006\ \mathrm{A}} \approx 217\ \Omega

Gewählt wird der nächstgrößere Normwert 220 Ω. Damit fließen I_\mathrm{F} = 1{,}3\ \mathrm{V} : 220\ \Omega \approx 5{,}91\ \mathrm{mA} – das ist genau der Vorwiderstand der Standard-Pinbelegung dieser Reihe.

Beispiel Arduino Uno (5 V): dieselbe LED mit I_\mathrm{F} = 10\ \mathrm{mA}:

R_\mathrm{V} = \frac{5{,}0\ \mathrm{V} - 2{,}0\ \mathrm{V}}{10\ \mathrm{mA}} = 300\ \Omega \quad\Rightarrow\quad 330\ \Omega,\ I_\mathrm{F} = \frac{3{,}0\ \mathrm{V}}{330\ \Omega} \approx 9{,}09\ \mathrm{mA}

Moderne LEDs leuchten schon mit 2 bis 5 mA hell genug für eine Statusanzeige. Die 20 mA aus vielen LED-Datenblättern sind der Nennstrom, nicht der nötige Strom. Je kleiner der Strom, desto weniger belastest Du den Pin und die Summe aller Pins (Schritt 4).

Durchlassspannungen hängen von der Farbe (dem Halbleitermaterial) ab. Mit typischen Werten ergeben sich diese Vorwiderstände (nächstgrößerer Wert der E12-Reihe):

An 3,3 V haben blaue und weiße LEDs kaum Spielraum: Liegt U_\mathrm{F} bei 3,2 V, bleiben für den Widerstand nur 0,1 V, und der Strom hängt fast nur noch von der Streuung der LED ab. Für solche LEDs ist 5 V mit einer Transistorstufe (Schritt 5) die sichere Lösung.

Normwerte: Widerstände gibt es nur in gestuften Werten, den E-Reihen (DIN EN 60063). Die E3-Reihe hat drei Werte je Dekade (1,0 – 2,2 – 4,7), die E6-Reihe sechs, die E12-Reihe zwölf (1,0 – 1,2 – 1,5 – 1,8 – 2,2 – 2,7 – 3,3 – 3,9 – 4,7 – 5,6 – 6,8 – 8,2). Für einen Vorwiderstand nimmst Du den nächstgrößeren Wert: Die LED leuchtet dann etwas schwächer, wird aber nicht überlastet.

Den Wert erkennst Du an den Farbringen: Bei vier Ringen stehen zwei Ziffern, ein Multiplikator und die Toleranz (Gold 5 %, Silber 10 %), bei fünf Ringen drei Ziffern, Multiplikator und Toleranz. Der 220-Ω-Widerstand der Ampel trägt Rot – Rot – Braun – Gold.

Schritt 3: Mehrere LEDs schalten – eine Ampel

Mit drei LEDs entsteht eine Ampel. Jede LED bekommt ihren eigenen Vorwiderstand, denn LEDs verschiedener Farbe haben verschiedene Durchlassspannungen: Mit einem gemeinsamen Widerstand würde nur die LED mit der kleinsten U_\mathrm{F} leuchten. Die drei Kathoden gehen gemeinsam an GND. Die Standard-Pinbelegung nutzt dafür LED 1 (rot), LED 2 (gelb) und LED 3 (grün):

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

Die Fritzing-Datei zum Nachbauen: mcu-digitale-ausgaenge-ampel-steckbrett-esp32c6.fzz

Das DevKit V4 liegt neben dem Steckbrett:

Die Fritzing-Datei zum Nachbauen: mcu-digitale-ausgaenge-ampel-steckbrett-esp32.fzz

Der NodeMCU liegt neben dem Steckbrett:

Die Fritzing-Datei zum Nachbauen: mcu-digitale-ausgaenge-ampel-steckbrett-esp8266.fzz

Der Uno liegt neben dem Steckbrett. Die rote LED hängt an Pin 8 der Digitalleiste, Gelb und Grün an A1 und A2 der Analogleiste:

Die Fritzing-Datei zum Nachbauen: mcu-digitale-ausgaenge-ampel-steckbrett-uno.fzz

Das Programm legt alle drei Pins als Ausgang fest und schaltet die vier Ampelphasen nacheinander. In jeder Phase werden nur die LEDs umgeschaltet, die sich ändern; die übrigen behalten ihren Pegel:

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: ESP32-C6 Dev Kit N8-M
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     LED1_PIN            = 4;                // LED 1, active HIGH (strapping pin, ok as output)
const int     LED2_PIN            = 5;                // LED 2, active HIGH (strapping pin, ok as output)
const int     LED3_PIN            = 6;                // LED 3, active HIGH

void setup() {
  pinMode(LED1_PIN, OUTPUT);       // LED 1: rot
  pinMode(LED2_PIN, OUTPUT);       // LED 2: gelb
  pinMode(LED3_PIN, OUTPUT);       // LED 3: grün
}

void loop() {
  // Phase 1: grün
  digitalWrite(LED1_PIN, LOW);
  digitalWrite(LED2_PIN, LOW);
  digitalWrite(LED3_PIN, HIGH);
  delay(3000);

  // Phase 2: gelb
  digitalWrite(LED3_PIN, LOW);
  digitalWrite(LED2_PIN, HIGH);
  delay(1000);

  // Phase 3: rot
  digitalWrite(LED2_PIN, LOW);
  digitalWrite(LED1_PIN, HIGH);
  delay(3000);

  // Phase 4: rot und gelb
  digitalWrite(LED2_PIN, HIGH);
  delay(1000);
}

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: ESP32 Dev Kit V1 / V2 / C V4 (ESP32-WROOM-32)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     LED1_PIN            = 27;               // LED 1, active HIGH
const int     LED2_PIN            = 14;               // LED 2, active HIGH (flickers briefly while booting)
const int     LED3_PIN            = 13;               // LED 3, active HIGH

void setup() {
  pinMode(LED1_PIN, OUTPUT);       // LED 1: rot
  pinMode(LED2_PIN, OUTPUT);       // LED 2: gelb
  pinMode(LED3_PIN, OUTPUT);       // LED 3: grün
}

void loop() {
  // Phase 1: grün
  digitalWrite(LED1_PIN, LOW);
  digitalWrite(LED2_PIN, LOW);
  digitalWrite(LED3_PIN, HIGH);
  delay(3000);

  // Phase 2: gelb
  digitalWrite(LED3_PIN, LOW);
  digitalWrite(LED2_PIN, HIGH);
  delay(1000);

  // Phase 3: rot
  digitalWrite(LED2_PIN, LOW);
  digitalWrite(LED1_PIN, HIGH);
  delay(3000);

  // Phase 4: rot und gelb
  digitalWrite(LED2_PIN, HIGH);
  delay(1000);
}

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: NodeMCU ESP8266 (without I2C/SPI)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     LED1_PIN            = 16;               // D0, LED 1, active HIGH (onboard LED on D0 of many boards lights inversely)
const int     LED2_PIN            = 5;                // D1, LED 2, active HIGH
const int     LED3_PIN            = 4;                // D2, LED 3, active HIGH

void setup() {
  pinMode(LED1_PIN, OUTPUT);       // LED 1: rot
  pinMode(LED2_PIN, OUTPUT);       // LED 2: gelb
  pinMode(LED3_PIN, OUTPUT);       // LED 3: grün
}

void loop() {
  // Phase 1: grün
  digitalWrite(LED1_PIN, LOW);
  digitalWrite(LED2_PIN, LOW);
  digitalWrite(LED3_PIN, HIGH);
  delay(3000);

  // Phase 2: gelb
  digitalWrite(LED3_PIN, LOW);
  digitalWrite(LED2_PIN, HIGH);
  delay(1000);

  // Phase 3: rot
  digitalWrite(LED2_PIN, LOW);
  digitalWrite(LED1_PIN, HIGH);
  delay(3000);

  // Phase 4: rot und gelb
  digitalWrite(LED2_PIN, HIGH);
  delay(1000);
}

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: Arduino Uno (5V logic)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     LED1_PIN            = 8;                // LED 1, active HIGH
const int     LED2_PIN            = A1;               // LED 2, active HIGH (analog pin used as digital output)
const int     LED3_PIN            = A2;               // LED 3, active HIGH

void setup() {
  pinMode(LED1_PIN, OUTPUT);       // LED 1: rot
  pinMode(LED2_PIN, OUTPUT);       // LED 2: gelb
  pinMode(LED3_PIN, OUTPUT);       // LED 3: grün
}

void loop() {
  // Phase 1: grün
  digitalWrite(LED1_PIN, LOW);
  digitalWrite(LED2_PIN, LOW);
  digitalWrite(LED3_PIN, HIGH);
  delay(3000);

  // Phase 2: gelb
  digitalWrite(LED3_PIN, LOW);
  digitalWrite(LED2_PIN, HIGH);
  delay(1000);

  // Phase 3: rot
  digitalWrite(LED2_PIN, LOW);
  digitalWrite(LED1_PIN, HIGH);
  delay(3000);

  // Phase 4: rot und gelb
  digitalWrite(LED2_PIN, HIGH);
  delay(1000);
}

Die Listen der Ein- und Ausgabeelemente für weitere Boards (ESP32 Dev Kit V1/V2, WeMos-Board mit OLED) stehen im Artikel Pinbelegung der Mikrocontroller-Boards.

Für eine echte Ampel würdest Du die Wartezeiten mit millis() statt delay() messen, damit das Programm nebenbei z. B. einen Anforderungstaster abfragen kann. Das zeigt der Artikel Zeit ohne delay().

Schritt 4: Wie viel Strom darf ein Pin liefern?

Jeder Ausgang hat Grenzen. Das Datenblatt des Controllers nennt drei Arten davon. Überschreitet die Schaltung eine, stimmen die Pegel nicht mehr, der Chip wird heiß oder er nimmt Schaden:

Absolute Grenzwerte (Absolute Maximum Ratings) dürfen nie überschritten werden, auch nicht kurz. Für den Betrieb gelten die kleineren Werte aus den DC Characteristics; achte dort auf die Bedingungen (test conditions: Versorgungsspannung, Temperatur, Strom) und auf min, typ und max. Für eine sichere Auslegung zählt immer der ungünstigste Wert. Wo die Werte im englischen Datenblatt stehen:

Die Boards dieser Reihe im Vergleich (Richtwerte; die genauen Werte stehen im Datenblatt des Chips):

Bei den Boards kommt eine weitere Grenze hinzu: Der Spannungsregler auf der Platine versorgt den Controller, das Funkmodul und alles, was am 3,3-V-Pin hängt. Er liefert typisch einige hundert Milliampere, und davon braucht ein ESP mit eingeschaltetem WLAN in Sendespitzen schon einen großen Teil.

Ampel prüfen: Am ESP32 fließen durch die rote LED rund 5,9 mA, durch Gelb und Grün etwas weniger. Selbst wenn alle drei gleichzeitig leuchten, sind es unter 20 mA – weit unter allen Grenzen. Am Uno mit 220 Ω sind es je LED etwa 13 mA, zusammen unter 40 mA: ebenfalls zulässig.

Strom- und Leistungsbilanz einer Baugruppe: Für die Auslegung der Versorgung addierst Du die Stromaufnahme aller Teile aus den Datenblättern – getrennt nach Versorgungsspannung: Controller im Betrieb (active supply current), Ausgangsströme der Pins, Sensoren, Anzeigen, Relaisspulen, Motoren. Für jede Spannung folgt die Leistung P = U \cdot I, mit der Betriebsdauer der Energiebedarf W = P \cdot t. Ein Beispiel für die Ampel mit Lüfter aus Schritt 5 an einem ESP32-C6 ohne WLAN:

Die 3,3 V erzeugt ein Linearregler aus den 5 V des USB-Anschlusses; er nimmt auf der 5-V-Seite denselben Strom auf, den er auf der 3,3-V-Seite abgibt. Damit:

I_{3,3\,\mathrm{V}} = 25\ \mathrm{mA} + 11{,}4\ \mathrm{mA} = 36{,}4\ \mathrm{mA} \qquad I_{5\,\mathrm{V}} = 36{,}4\ \mathrm{mA} + 10\ \mathrm{mA} + 100\ \mathrm{mA} = 146{,}4\ \mathrm{mA}

P = 5\ \mathrm{V} \cdot 146{,}4\ \mathrm{mA} \approx 0{,}732\ \mathrm{W} \qquad W = 0{,}732\ \mathrm{W} \cdot 8\ \mathrm{h} \approx 5{,}86\ \mathrm{Wh}

Ein USB-Anschluss mit 500 mA reicht also aus. Kommt ein ESP mit WLAN hinzu, rechnest Du für die Sendespitzen mit deutlich mehr Strom auf der 3,3-V-Seite.

Schritt 5: Größere Lasten mit Transistor, MOSFET oder Relais schalten

Relais, Lüfter, Motoren, Magnetventile, Lampen und LED-Streifen brauchen mehr Strom oder eine höhere Spannung, als ein Pin liefern kann. Dann schaltet der Pin nur noch einen Transistor oder MOSFET, und der schaltet die Last aus einer eigenen Versorgung U_\mathrm{Last}. Der Pin liefert dabei nur einen kleinen Basis- bzw. Ladestrom.

(a) Bipolartransistor und Relais: Ein npn-Transistor schaltet die Relaisspule gegen Masse. Damit er sicher durchschaltet (Sättigung), wählst Du den Basisstrom mit einem Übersteuerungsfaktor ü von 2 bis 5 größer als nötig. Beispiel: Kleinrelais 5 V mit I_\mathrm{C} = 70\ \mathrm{mA} Spulenstrom, Transistor BC547 mit Stromverstärkung B_\mathrm{min} = 110, ü = 3, ESP32 mit 3,3 V und U_\mathrm{BE} = 0{,}7\ \mathrm{V}:

I_\mathrm{B} = ü \cdot \frac{I_\mathrm{C}}{B_\mathrm{min}} = 3 \cdot \frac{70\ \mathrm{mA}}{110} \approx 1{,}91\ \mathrm{mA} \qquad R_\mathrm{B} = \frac{U_\mathrm{OH} - U_\mathrm{BE}}{I_\mathrm{B}} = \frac{2{,}6\ \mathrm{V}}{1{,}91\ \mathrm{mA}} \approx 1{,}36\ \mathrm{k\Omega}

Gewählt wird der nächstkleinere Normwert 1,2 kΩ, damit der Basisstrom eher größer wird: I_\mathrm{B} = 2{,}6\ \mathrm{V} : 1{,}2\ \mathrm{k\Omega} \approx 2{,}17\ \mathrm{mA} – für den Pin kein Problem. Wie Du Transistorstufen im Detail auslegst, zeigt der Artikel Transistor als Schalter.

Freilaufdiode: Eine Spule (Relais, Schütz, Magnetventil, Motor) speichert Energie im Magnetfeld. Sperrt der Transistor, will der Strom weiterfließen; die Spule erzeugt dafür eine hohe Induktionsspannung, die den Transistor zerstören kann. Die Freilaufdiode D_\mathrm{F} parallel zur Spule – Kathode an Plus – sperrt im Betrieb und übernimmt beim Abschalten den Spulenstrom, bis die Energie abgebaut ist. Für kleine Relais genügt eine 1N4148, für größere Spulen nimmst Du eine 1N4001. Fertige Relaismodule haben Transistor, Freilaufdiode und oft einen Optokoppler schon an Bord; viele sind low-aktiv und brauchen 5 V an der Spulenseite.

Relais und Schütz auswählen: Ein Relais trennt den Steuerstromkreis galvanisch vom Laststromkreis. Bei der Auswahl zählen die Spulenspannung (z. B. 5 V, 12 V, 24 V DC) und der Spulenstrom, die Kontaktart (Schließer, Öffner, Wechsler) und die Kontaktbelastbarkeit (Spannung, Strom, AC oder DC). Für Motoren und große Leistungen nimmt man ein Schütz; seine Spule (meist 24 V DC oder 230 V AC) steuert der Mikrocontroller über ein Koppelrelais oder einen Transistor an. Das Relais erhält nach DIN EN 81346 das Kennzeichen K (z. B. -K1); seine Anschlüsse sind nach DIN EN 50005 bezeichnet: Spule A1/A2, Schließer 13/14, Öffner 21/22. Netzspannung gehört nur in Schaltungen, die eine Elektrofachkraft aufgebaut und geprüft hat.

(b) Logic-Level-MOSFET (Low-Side): Ein N-Kanal-MOSFET braucht keinen Dauerstrom am Gate, sondern nur eine Spannung U_\mathrm{GS}. Für 3,3-V-Controller muss es ein Logic-Level-MOSFET sein, dessen Durchlasswiderstand R_\mathrm{DS(on)} im Datenblatt schon für U_\mathrm{GS} = 2{,}5\ \mathrm{V} angegeben ist (z. B. IRLML6344 oder AO3400 im SMD-Gehäuse). Ein „normaler“ MOSFET schaltet bei 3,3 V nur halb durch und wird heiß. Der Gatewiderstand R_\mathrm{G} (etwa 100 bis 220 Ω) begrenzt den Umladestrom des Gates, der Pull-down R_\mathrm{PD} (etwa 10 bis 100 kΩ) hält den MOSFET gesperrt, solange der Pin beim Start noch ein Eingang ist.

Low-Side und High-Side: Liegt der Schalter zwischen Last und Masse wie in (a) und (b), ist es ein Low-Side-Schalter. Er ist einfach, weil der Emitter bzw. die Source an Masse liegt und der Pin direkt ansteuern kann. Nachteil: Auch im ausgeschalteten Zustand liegt die Last an U_\mathrm{Last}; ein Kurzschluss der Last gegen Masse schaltet sie ein. Ein High-Side-Schalter (c) liegt zwischen U_\mathrm{Last} und Last; die ausgeschaltete Last liegt an Masse. Er braucht einen pnp-Transistor oder P-Kanal-MOSFET. Ist U_\mathrm{Last} größer als die Pinspannung, kann der Pin das Gate nicht weit genug hochziehen, um den MOSFET zu sperren. Dann zieht ein zusätzlicher npn-Transistor das Gate nach Masse (MOSFET leitet), und R_\mathrm{GS} zieht es sonst auf U_\mathrm{Last} (MOSFET sperrt). Achte auf die zulässige Gate-Source-Spannung des MOSFET.

Ventile und Zylinder: In Anlagen schaltet der Controller über solche Stufen auch Magnetventile der Pneumatik und Hydraulik. Ein Magnetventil (z. B. ein 3/2- oder 5/2-Wegeventil) lenkt Druckluft bzw. Öl in einen Zylinder; ein einfach wirkender Zylinder fährt mit Druck aus und mit einer Feder zurück, ein doppelt wirkender wird in beide Richtungen mit Druck bewegt. Die Ventilspulen brauchen meist 24 V DC und einige Watt, also einen Transistor, MOSFET oder Treiberbaustein mit Freilaufdiode. Für mehrere Lasten gibt es Treiberbausteine mit mehreren Stufen und eingebauten Freilaufdioden, z. B. ein Darlington-Array mit sieben Kanälen bis 500 mA. Stetig verstellbare Proportionalventile bekommen ein PWM-Signal (Analoge Ausgabe mit PWM).

Aufbau auf dem Steckbrett: Für den Versuch genügt ein Reed-Relais mit 5-V-Spule (etwa 10 mA) und ein kleiner 5-V-Motor als Lüfter. Der Ausgang von LED 4 steuert über 1 kΩ die Basis eines BC547; Spule, Kontakt und Lüfter hängen an 5 V vom Board. Die Diode liegt parallel zur Spule. Das Relais ist im Bild als Prinzipdarstellung mit den Anschlüssen A1, A2, 13 und 14 gezeichnet; bei einem echten Reed-Relais steht die Anschlussfolge im Datenblatt.

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

Die Fritzing-Datei zum Nachbauen: mcu-digitale-ausgaenge-relais-steckbrett-esp32c6.fzz

Die Fritzing-Datei zum Nachbauen: mcu-digitale-ausgaenge-relais-steckbrett-esp32.fzz

Die Fritzing-Datei zum Nachbauen: mcu-digitale-ausgaenge-relais-steckbrett-esp8266.fzz

Die Fritzing-Datei zum Nachbauen: mcu-digitale-ausgaenge-relais-steckbrett-uno.fzz

Für das Programm ist die Transistorstufe nur ein weiterer Ausgang. Damit der Code lesbar bleibt, gibt eine Konstante dem Ausgang von LED 4 den Namen RELAY_PIN; der Lüfter läuft im Wechsel 5 Sekunden und steht 5 Sekunden:

ESP32-C6 ESP32 (DevKit V4) ESP8266 (NodeMCU) Arduino Uno all none

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: ESP32-C6 Dev Kit N8-M
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     LED4_PIN            = 7;                // LED 4, active HIGH

const int RELAY_PIN = LED4_PIN;    // Transistorstufe des Relais am Ausgang von LED 4

void setup() {
  Serial.begin(115200);
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW);    // Transistor sperrt: Relais abgefallen, Lüfter aus
}

void loop() {
  digitalWrite(RELAY_PIN, HIGH);   // Basisstrom fließt: Transistor leitet, Relais zieht an
  Serial.println("Luefter an");
  delay(5000);

  digitalWrite(RELAY_PIN, LOW);    // Transistor sperrt, die Freilaufdiode baut die Spulenenergie ab
  Serial.println("Luefter aus");
  delay(5000);
}

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: ESP32 Dev Kit V1 / V2 / C V4 (ESP32-WROOM-32)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     LED4_PIN            = 4;                // LED 4, active HIGH

const int RELAY_PIN = LED4_PIN;    // Transistorstufe des Relais am Ausgang von LED 4

void setup() {
  Serial.begin(115200);
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW);    // Transistor sperrt: Relais abgefallen, Lüfter aus
}

void loop() {
  digitalWrite(RELAY_PIN, HIGH);   // Basisstrom fließt: Transistor leitet, Relais zieht an
  Serial.println("Luefter an");
  delay(5000);

  digitalWrite(RELAY_PIN, LOW);    // Transistor sperrt, die Freilaufdiode baut die Spulenenergie ab
  Serial.println("Luefter aus");
  delay(5000);
}

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: NodeMCU ESP8266 (without I2C/SPI)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     LED4_PIN            = 15;               // D8, LED 4, active HIGH (LED to GND keeps D8 LOW at boot)

const int RELAY_PIN = LED4_PIN;    // Transistorstufe des Relais am Ausgang von LED 4

void setup() {
  Serial.begin(115200);
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW);    // Transistor sperrt: Relais abgefallen, Lüfter aus
}

void loop() {
  digitalWrite(RELAY_PIN, HIGH);   // Basisstrom fließt: Transistor leitet, Relais zieht an
  Serial.println("Luefter an");
  delay(5000);

  digitalWrite(RELAY_PIN, LOW);    // Transistor sperrt, die Freilaufdiode baut die Spulenenergie ab
  Serial.println("Luefter aus");
  delay(5000);
}

//-------------------------------------------------------------------------------------
// Liste der Ein- und Ausgabeelemente
// Board: Arduino Uno (5V logic)
//-------------------------------------------------------------------------------------
// Datentyp | Name der Variable   | Anschlusspin      | Name, Verhalten
const int     LED4_PIN            = A3;               // LED 4, active HIGH

const int RELAY_PIN = LED4_PIN;    // Transistorstufe des Relais am Ausgang von LED 4

void setup() {
  Serial.begin(115200);
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW);    // Transistor sperrt: Relais abgefallen, Lüfter aus
}

void loop() {
  digitalWrite(RELAY_PIN, HIGH);   // Basisstrom fließt: Transistor leitet, Relais zieht an
  Serial.println("Luefter an");
  delay(5000);

  digitalWrite(RELAY_PIN, LOW);    // Transistor sperrt, die Freilaufdiode baut die Spulenenergie ab
  Serial.println("Luefter aus");
  delay(5000);
}

Die Listen der Ein- und Ausgabeelemente für weitere Boards (ESP32 Dev Kit V1/V2, WeMos-Board mit OLED) stehen im Artikel Pinbelegung der Mikrocontroller-Boards.

Die USB-Buchse liefert nur wenige hundert Milliampere. Für größere Lüfter, Motoren oder 12-V- und 24-V-Lasten brauchst Du ein eigenes Netzteil. Seine Masse verbindest Du mit GND des Boards, sonst fehlt dem Transistor der Bezug.

Schritt 6: Ein- und Ausgänge im Stromlaufplan und im Datenblatt finden

In einem Stromlaufplan erkennst Du an der Beschaltung, ob eine Portleitung Ein- oder Ausgang ist:

Ports und Bitbreite: Klassische 8-Bit-Controller fassen ihre Anschlüsse zu Ports zusammen. Jeder Port hat einen Buchstaben, seine Leitungen sind nummeriert, die Zahl der Leitungen ist die Bitbreite. Der ATmega328P des Uno hat Port B (PB0 … PB7, 8 Bit), Port C (PC0 … PC6, 7 Bit) und Port D (PD0 … PD7, 8 Bit), zusammen 23 Ein-/Ausgänge. Einige davon sind mehrfach belegt: PB6/PB7 für den Quarz, PC6 als Reset. Diese Angaben findest Du in der Anschlussbelegung (Pin Configurations) und unter Features (programmable I/O lines).

Die ESP-Controller zählen dagegen einfach GPIOs durch: Der ESP32-C6 hat 31 (GPIO0 … GPIO30), der klassische ESP32 34 und der ESP8266 17. Intern liegen sie in 32 Bit breiten Registern. Auf einem Board sind nur manche herausgeführt, und einige sind für Flash, USB oder den Start reserviert. Welche Pins Du gefahrlos nutzen kannst, steht in der Pinbelegung der Boards.

Unterschiede der Boards

Unter der Haube: Was macht digitalWrite()?

digitalWrite() setzt am Ende nur ein Bit in einem Ausgangsregister: Beim Uno ist es das Bit eines Ports im Register PORTB, PORTC oder PORTD; die Richtung legt pinMode() im Register DDRx fest. Bei den ESP-Controllern schreibt der Core in Register, die einzelne Bits setzen oder löschen, ohne die anderen zu verändern. Vorher rechnet die Funktion die Arduino-Pinnummer in Port und Bit um – deshalb ist digitalWrite() deutlich langsamer als ein direkter Registerzugriff. Wie Du Ports direkt über Register und Bitoperationen ansprichst und wie Du für ein Datenbyte die geschalteten Ausgänge bestimmst, zeigt der Vertiefungsartikel Register und Bitoperationen. Dort geht es auch um Grenzwerte wie Verlustleistung und Summenstrom aus dem Datenblatt.

Die Grafik zeigt den Weg vom Aufruf bis zum Pegel am Pin am Beispiel der eingebauten LED des Uno an Pin 13:

Wie geht es weiter?

Ausgänge allein reichen selten: Im nächsten Artikel geht es um digitale Eingänge mit Tastern, Pull-up- und Pull-down-Widerständen. LEDs dimmen und Lüfter in der Drehzahl stellen kannst Du mit PWM. Zum Üben gibt es die Übungsaufgaben zu digitalen Ausgängen.

Leitfragen

1. Was bedeutet high-aktiv und low-aktiv bei einer LED am Ausgang? Antwort

High-aktiv: Die LED liegt zwischen Pin und GND und leuchtet bei HIGH; der Pin liefert Strom (source). Low-aktiv: Die LED liegt zwischen Versorgungsspannung und Pin und leuchtet bei LOW; der Pin nimmt Strom auf (sink). siehe Abschnitt „Schritt 1“

2. Wie berechnest Du den Vorwiderstand einer LED, und welchen Normwert wählst Du? Antwort

R_\mathrm{V} = (U_\mathrm{OH} - U_\mathrm{F}) : I_\mathrm{F}, also Pinspannung minus Durchlassspannung, geteilt durch den gewünschten Strom. Gewählt wird der nächstgrößere Wert der E-Reihe, damit der Strom nicht größer wird als geplant. siehe Abschnitt „Schritt 2“

3. Warum braucht jede LED einer Ampel ihren eigenen Vorwiderstand? Antwort

LEDs verschiedener Farben haben verschiedene Durchlassspannungen. An einem gemeinsamen Widerstand würde die LED mit der kleinsten Durchlassspannung fast den ganzen Strom übernehmen, die anderen blieben dunkel. siehe Abschnitt „Schritt 3“

4. Welche Stromgrenzen musst Du an Ausgängen prüfen, und wo stehen sie im englischen Datenblatt? Antwort

Den Strom je Pin, den Summenstrom einer Portgruppe und den Summenstrom des Bausteins (VCC/GND). Absolute Grenzwerte stehen unter Absolute Maximum Ratings und dürfen nie überschritten werden; für den Betrieb gelten die Werte der DC Characteristics mit ihren test conditions. siehe Abschnitt „Schritt 4“

5. Wie stellst Du die Strom- und Leistungsbilanz einer Baugruppe auf? Antwort

Stromaufnahme aller Verbraucher aus den Datenblättern nach Versorgungsspannung getrennt addieren (Controller, Pins, Sensoren, Spulen, Motoren), mit P = U \cdot I die Leistung und mit W = P \cdot t den Energiebedarf bestimmen und mit der Belastbarkeit von Regler, Netzteil oder Akku vergleichen. siehe Abschnitt „Schritt 4“

6. Wozu dient die Freilaufdiode an einer Relaisspule, und wie wird sie eingebaut? Antwort

Beim Abschalten erzeugt die Spule eine hohe Induktionsspannung, die den Transistor zerstören kann. Die Diode liegt parallel zur Spule mit der Kathode an Plus, sperrt im Betrieb und übernimmt beim Abschalten den Spulenstrom. siehe Abschnitt „Schritt 5“

7. Was unterscheidet einen Low-Side- von einem High-Side-Schalter? Antwort

Der Low-Side-Schalter liegt zwischen Last und Masse (npn-Transistor, N-MOSFET) und lässt sich direkt vom Pin ansteuern; die Last liegt dauerhaft an Plus. Der High-Side-Schalter liegt zwischen Plus und Last (pnp, P-MOSFET); die ausgeschaltete Last liegt an Masse, die Ansteuerung braucht bei höherer Lastspannung einen zusätzlichen npn-Transistor als Pegelwandler. siehe Abschnitt „Schritt 5“

8. Warum muss es an einem 3,3-V-Controller ein Logic-Level-MOSFET sein? Antwort

Ein normaler MOSFET schaltet erst bei etwa 10 V Gate-Source-Spannung voll durch. Bei 3,3 V bleibt sein Durchlasswiderstand hoch, er wird heiß. Ein Logic-Level-MOSFET hat seinen R_\mathrm{DS(on)} im Datenblatt schon für 2,5 V angegeben. siehe Abschnitt „Schritt 5“

9. Woran erkennst Du im Stromlaufplan, ob eine Portleitung Ein- oder Ausgang ist? Antwort

Am angeschlossenen Bauteil: LEDs mit Vorwiderstand, Basis- oder Gatewiderstände und Treibereingänge hängen an Ausgängen; Taster mit Pull-up oder Pull-down und digitale Sensorausgänge an Eingängen; Spannungsteiler mit Sensor oder Potenziometer an Analogeingängen. siehe Abschnitt „Schritt 6“

Links und weitere Informationen

• als Nachschlagewerk: Arduino-Sprachreferenz zu digitalWrite()

• für die Transistorstufe: Transistor als Schalter

• für die Pins aller Boards: Pinbelegung der Mikrocontroller-Boards

• für Register und Grenzwerte: Register und Bitoperationen

• als Primärquelle: Datenblätter der Chips bei Espressif und Microchip (ATmega328P)

Hinweis zur Nachnutzung als Open Educational Resource (OER)

Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “Digitale Ausgänge am Mikrocontroller: LED mit Vorwiderstand, Ausgangsstrom und Lasten mit Transistor oder Relais” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/mcu-digitale-ausgaenge veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/mcu/arduino-esp. Erstellt mit KI-Assistenz; von mir umfassend redaktionell überarbeitet, geprüft und freigegeben. Stand: 10.11.2026.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]