Übungsaufgaben zu digitalen Ausgängen am Mikrocontroller: Vorwiderstand, Ausgangsstrom und Lasten mit Transistor oder Relais

Kopiere den Text in ein KI-Sprachmodell Deiner Wahl und passe Kompetenzstufe, Anzahl, Bearbeitungszeit und Szenario bei Bedarf an. Wie die Aufgaben aufgebaut sind, beschreibt der Artikel Wie sind die Aufgaben aufgebaut?. Prüfe die Ergebnisse mit dem Lehrartikel: KI-Sprachmodelle machen Fehler.

Erstelle neue Übungsaufgaben zum Thema „Digitale Ausgänge am
Mikrocontroller: Vorwiderstand, Ausgangsstrom und Lasten mit Transistor
oder Relais“.

Bauplan: Halte Dich an Aufbau, Kompetenzstufen, Operatoren,
Anforderungsbereiche, Punkte und Zeitschätzung, die im Artikel
https://oer-informatik.de/aufgaben-aufbau beschrieben sind.

Fachliche Grundlage:
- https://oer-informatik.de/mcu-digitale-ausgaenge
- https://oer-informatik.de/transistor-als-schalter
- https://oer-informatik.de/mcu-pinout
- Stilbeispiel: https://oer-informatik.de/mcu-digitale-ausgaenge-uebungsaufgaben

Die Aufgaben sollen Inhalte zu diesen Schlagwörtern abdecken:
- Mikrocontroller
- digitaler Ausgang
- Vorwiderstand
- Ausgangsstrom
- Summenstrom
- Transistor
- Logic-Level-MOSFET
- Relais
- Freilaufdiode
- High-Side

Kompetenzstufe: Kernkompetenz (alternativ: Basiskompetenz, Profilkompetenz, Expertise)
Anzahl: 1 Aufgabe mit Teilaufgaben
Bearbeitungszeit in Minuten ca.: <5 bis 30 min>
Szenario: eines der Szenarien aus dem Bauplan

Vorgehen:
1. Lies zuerst die verlinkten Artikel. Kannst Du keine Webseiten
   abrufen, sag mir das, statt zu raten.
2. Steht bei einer Angabe noch ein Platzhalter in <…>, frag mich
   zuerst danach. Richte Punkte und Zahl der Teilaufgaben nach der
   Bearbeitungszeit (ca. 0,9 min je Punkt).
3. Gib je Aufgabe Titel mit Kompetenzstufe, Ausgangssituation und
   Teilaufgaben mit Operator und Punktzahl aus, dazu die geschätzte
   Bearbeitungszeit.
4. Gib die Beispiellösungen mit Punkteverteilung erst aus, wenn ich
   danach frage.

Geg.: Anschlussübersicht (Port A: PA0 … PA7, Port B: PB0 … PB5, Port C: PC0 … PC3, VDD, VSS), Beschaltung laut Tabelle, U_\mathrm{B} = 5\ \mathrm{V}

Ges.: Zahl und Bitbreite der Ports, Zahl der Ein-/Ausgänge und Analogeingänge

• 3 Ports mit 8, 6 und 4 Bit. (1 Punkt)
• $8 + 6 + 4 = $ 18 Ein-/Ausgänge; zusammen mit VDD und VSS ergibt das die 20 Anschlüsse. Wird ein Quarz an PB4/PB5 oder der Reset an PC3 genutzt, stehen entsprechend weniger frei zur Verfügung. (1 Punkt)
• 4 Analogeingänge AN0 … AN3 an PC0 … PC3. (1 Punkt)

Ges.: Funktion der Leitungen mit Begründung

(je Zeile 1 Punkt)

Geg.: I_\mathrm{Seg} = 8\ \mathrm{mA}; Grenzwerte 20 mA je Pin, 60 mA je Port, 100 mA über VDD; I_\mathrm{MC} = 6\ \mathrm{mA}, I_\mathrm{B,PB2} = 0{,}4\ \mathrm{mA}

Ges.: Zulässigkeit der Ziffer „8“

• Pin: 8\ \mathrm{mA} \leq 20\ \mathrm{mA} → zulässig. (1 Punkt)
• Port A:

\def\arraystretch{2.3} \begin{array}{rcl|l} I_\mathrm{PortA} & = & 7 \cdot I_\mathrm{Seg} & \\ I_\mathrm{PortA} & = & 7 \cdot 8\ \mathrm{mA} = \underline{\underline{56{,}0\ \mathrm{mA}}} \leq 60\ \mathrm{mA} & \end{array}

zulässig, aber mit wenig Reserve. (1 Punkt) - VDD gesamt: I_\mathrm{VDD} = 6\ \mathrm{mA} + 56\ \mathrm{mA} + 0{,}4\ \mathrm{mA} = 62{,}4\ \mathrm{mA} \leq 100\ \mathrm{mA} → zulässig. Die Ziffer „8“ darf angezeigt werden. (1 Punkt)

Geg.: I_\mathrm{Summer} = 25\ \mathrm{mA}, t = 24\ \mathrm{h}

Ges.: Gesamtstrom I_\mathrm{ges}, Leistung P, Energie W

\begin{aligned} &\text{(I)} && I_\mathrm{ges} = I_\mathrm{MC} + I_\mathrm{PortA} + I_\mathrm{B,PB2} + I_\mathrm{Summer} \\ &\text{(II)} && P = U_\mathrm{B} \cdot I_\mathrm{ges} \\ &\text{(III)} && W = P \cdot t \end{aligned}

\def\arraystretch{2.3} \begin{array}{rcl|l} I_\mathrm{ges} & = & 6\ \mathrm{mA} + 56\ \mathrm{mA} + 0{,}4\ \mathrm{mA} + 25\ \mathrm{mA} = \underline{\underline{87{,}4\ \mathrm{mA}}} & \\ P & = & 5\ \mathrm{V} \cdot 87{,}4\ \mathrm{mA} = \underline{\underline{437\ \mathrm{mW}}} & \\ W & = & 0{,}437\ \mathrm{W} \cdot 24\ \mathrm{h} \approx \underline{\underline{10{,}5\ \mathrm{Wh}}} & \end{array}

(Strom 2 Punkte, Leistung 1 Punkt, Energie 1 Punkt) Der Summerstrom fließt nicht über den Controller, belastet aber die Versorgung.

Geg.: U_\mathrm{OH} = 3{,}3\ \mathrm{V}, U_\mathrm{F,gn} = 2{,}2\ \mathrm{V}, U_\mathrm{F,rt} = 2{,}0\ \mathrm{V}, I_\mathrm{F} = 4\ \mathrm{mA}, E12-Reihe

Ges.: R_\mathrm{V,gn}, R_\mathrm{V,rt} (Normwert), tatsächliche Ströme

\begin{aligned} &\text{(I)} && U_\mathrm{OH} = U_\mathrm{V} + U_\mathrm{F} \\ &\text{(II)} && R_\mathrm{V} = \frac{U_\mathrm{V}}{I_\mathrm{F}} \end{aligned}

I in II:

\def\arraystretch{2.3} \begin{array}{rcl|l} R_\mathrm{V} & = & \dfrac{U_\mathrm{OH} - U_\mathrm{F}}{I_\mathrm{F}} & \\ R_\mathrm{V,gn} & = & \dfrac{3{,}3\ \mathrm{V} - 2{,}2\ \mathrm{V}}{4\ \mathrm{mA}} = \underline{\underline{275\ \Omega}} & \\ R_\mathrm{V,rt} & = & \dfrac{3{,}3\ \mathrm{V} - 2{,}0\ \mathrm{V}}{4\ \mathrm{mA}} = \underline{\underline{325\ \Omega}} & \end{array}

Gewählt wird jeweils der nächstgrößere E12-Wert, damit der Strom nicht über 4 mA steigt: 330 Ω für beide LEDs. (2 Punkte)

\def\arraystretch{2.3} \begin{array}{rcl|l} I_\mathrm{F,gn} & = & \dfrac{1{,}1\ \mathrm{V}}{330\ \Omega} \approx \underline{\underline{3{,}33\ \mathrm{mA}}} & \\ I_\mathrm{F,rt} & = & \dfrac{1{,}3\ \mathrm{V}}{330\ \Omega} \approx \underline{\underline{3{,}94\ \mathrm{mA}}} & \end{array}

(Rechnung je LED 1 Punkt, Normwerte und Ströme 2 Punkte) Wer für Grün 270 Ω wählt (nächstkleinerer Wert, 4,07 mA), bekommt die Punkte für den Normwert nur mit Begründung.

Geg.: R_\mathrm{V} = 82\ \Omega, U_\mathrm{F} = 2{,}8\ \mathrm{V} / 3{,}0\ \mathrm{V} / 3{,}2\ \mathrm{V}

Ges.: I_\mathrm{F} für die drei Durchlassspannungen, Beurteilung

\def\arraystretch{2.3} \begin{array}{rcl|l} I_\mathrm{F} & = & \dfrac{U_\mathrm{OH} - U_\mathrm{F}}{R_\mathrm{V}} & \\ I_\mathrm{F,min\,U_F} & = & \dfrac{3{,}3\ \mathrm{V} - 2{,}8\ \mathrm{V}}{82\ \Omega} \approx \underline{\underline{6{,}10\ \mathrm{mA}}} & \\ I_\mathrm{F,typ} & = & \dfrac{3{,}3\ \mathrm{V} - 3{,}0\ \mathrm{V}}{82\ \Omega} \approx \underline{\underline{3{,}66\ \mathrm{mA}}} & \\ I_\mathrm{F,max\,U_F} & = & \dfrac{3{,}3\ \mathrm{V} - 3{,}2\ \mathrm{V}}{82\ \Omega} \approx \underline{\underline{1{,}22\ \mathrm{mA}}} & \end{array}

(3 Punkte)

Beurteilung: Am Widerstand bleiben nur 0,1 bis 0,5 V. Je nach Exemplar schwankt der Strom deshalb etwa um den Faktor 5; zwei Steuerungen aus derselben Serie leuchten sichtbar unterschiedlich hell, und schon eine etwas kleinere Versorgungsspannung lässt die LED fast ausgehen. Für ein Serienprodukt ist das nicht sinnvoll. (1 Punkt)

Bessere Lösung: Die weiße LED mit Vorwiderstand an 5 V legen und über einen npn-Transistor oder Logic-Level-MOSFET auf der Low-Side schalten; dann fallen etwa 2 V am Vorwiderstand ab (z. B. (5\ \mathrm{V} - 3{,}0\ \mathrm{V}) : 4\ \mathrm{mA} = 500\ \Omega → 560 Ω), und die Streuung von U_\mathrm{F} wirkt sich viel weniger aus. Alternativ eine andere Farbe mit kleinerer Durchlassspannung wählen. (1 Punkt)

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

const int LED_RUN   = LED1_PIN;    // grüne LED: Betrieb
const int LED_PUMP  = LED2_PIN;    // weiße LED: Pumpe läuft
const int LED_ERROR = LED3_PIN;    // rote LED: Störung

void setup() {
  pinMode(LED_RUN, OUTPUT);
  pinMode(LED_PUMP, OUTPUT);
  pinMode(LED_ERROR, OUTPUT);
  digitalWrite(LED_RUN, HIGH);     // Betrieb: dauerhaft an
  digitalWrite(LED_ERROR, LOW);    // keine Störung
}

void loop() {
  digitalWrite(LED_PUMP, HIGH);    // Pumpe läuft 5 s ...
  delay(5000);
  digitalWrite(LED_PUMP, LOW);     // ... und steht 25 s
  delay(25000);
}

//-------------------------------------------------------------------------------------
// 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

const int LED_RUN   = LED1_PIN;    // grüne LED: Betrieb
const int LED_PUMP  = LED2_PIN;    // weiße LED: Pumpe läuft
const int LED_ERROR = LED3_PIN;    // rote LED: Störung

void setup() {
  pinMode(LED_RUN, OUTPUT);
  pinMode(LED_PUMP, OUTPUT);
  pinMode(LED_ERROR, OUTPUT);
  digitalWrite(LED_RUN, HIGH);     // Betrieb: dauerhaft an
  digitalWrite(LED_ERROR, LOW);    // keine Störung
}

void loop() {
  digitalWrite(LED_PUMP, HIGH);    // Pumpe läuft 5 s ...
  delay(5000);
  digitalWrite(LED_PUMP, LOW);     // ... und steht 25 s
  delay(25000);
}

//-------------------------------------------------------------------------------------
// 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

const int LED_RUN   = LED1_PIN;    // grüne LED: Betrieb
const int LED_PUMP  = LED2_PIN;    // weiße LED: Pumpe läuft
const int LED_ERROR = LED3_PIN;    // rote LED: Störung

void setup() {
  pinMode(LED_RUN, OUTPUT);
  pinMode(LED_PUMP, OUTPUT);
  pinMode(LED_ERROR, OUTPUT);
  digitalWrite(LED_RUN, HIGH);     // Betrieb: dauerhaft an
  digitalWrite(LED_ERROR, LOW);    // keine Störung
}

void loop() {
  digitalWrite(LED_PUMP, HIGH);    // Pumpe läuft 5 s ...
  delay(5000);
  digitalWrite(LED_PUMP, LOW);     // ... und steht 25 s
  delay(25000);
}

//-------------------------------------------------------------------------------------
// 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

const int LED_RUN   = LED1_PIN;    // grüne LED: Betrieb
const int LED_PUMP  = LED2_PIN;    // weiße LED: Pumpe läuft
const int LED_ERROR = LED3_PIN;    // rote LED: Störung

void setup() {
  pinMode(LED_RUN, OUTPUT);
  pinMode(LED_PUMP, OUTPUT);
  pinMode(LED_ERROR, OUTPUT);
  digitalWrite(LED_RUN, HIGH);     // Betrieb: dauerhaft an
  digitalWrite(LED_ERROR, LOW);    // keine Störung
}

void loop() {
  digitalWrite(LED_PUMP, HIGH);    // Pumpe läuft 5 s ...
  delay(5000);
  digitalWrite(LED_PUMP, LOW);     // ... und steht 25 s
  delay(25000);
}

Bewertung: Liste mit den drei LED-Zeilen 1 Punkt, sprechende Namen 1 Punkt, pinMode(…, OUTPUT) für alle drei Ausgänge 1 Punkt, Dauerzustände von Grün und Rot (in setup() genügt) 1 Punkt, Zyklus mit 5 s und 25 s 1 Punkt.

Geg.: I_\mathrm{F,gn} = 3{,}33\ \mathrm{mA}, I_\mathrm{F,rt} = 3{,}94\ \mathrm{mA}, I_\mathrm{F,ws,max} = 6{,}10\ \mathrm{mA}; Grenzwerte 20 mA je Pin, 100 mA gesamt

Ges.: Einhaltung der Grenzwerte

• Je Pin: Der größte Strom fließt durch die weiße LED bei kleinster Durchlassspannung: 6{,}10\ \mathrm{mA} \leq 20\ \mathrm{mA} → eingehalten. (1 Punkt)

• Summe:

\def\arraystretch{2.3} \begin{array}{rcl|l} I_\mathrm{ges} & = & I_\mathrm{F,gn} + I_\mathrm{F,ws,max} + I_\mathrm{F,rt} & \\ I_\mathrm{ges} & = & 3{,}33\ \mathrm{mA} + 6{,}10\ \mathrm{mA} + 3{,}94\ \mathrm{mA} \approx \underline{\underline{13{,}4\ \mathrm{mA}}} \leq 100\ \mathrm{mA} & \end{array}

eingehalten. (1 Punkt) Für den ungünstigsten Fall zählt vor allem die kleinste Durchlassspannung der weißen LED. (1 Punkt)

Geg.: U_\mathrm{Sp} = 5\ \mathrm{V}, R_\mathrm{Sp} = 100\ \Omega, B_\mathrm{min} = 100, ü = 5, U_\mathrm{OH} = 3{,}3\ \mathrm{V}, U_\mathrm{BE} = 0{,}7\ \mathrm{V}

Ges.: I_\mathrm{C}, I_\mathrm{B}, R_\mathrm{B} (Normwert)

\begin{aligned} &\text{(I)} && I_\mathrm{C} = \frac{U_\mathrm{Sp}}{R_\mathrm{Sp}} \\ &\text{(II)} && I_\mathrm{B} = ü \cdot \frac{I_\mathrm{C}}{B_\mathrm{min}} \\ &\text{(III)} && R_\mathrm{B} = \frac{U_\mathrm{OH} - U_\mathrm{BE}}{I_\mathrm{B}} \end{aligned}

\def\arraystretch{2.3} \begin{array}{rcl|l} I_\mathrm{C} & = & \dfrac{5\ \mathrm{V}}{100\ \Omega} = \underline{\underline{50{,}0\ \mathrm{mA}}} & \\ I_\mathrm{B} & = & 5 \cdot \dfrac{50\ \mathrm{mA}}{100} = \underline{\underline{2{,}50\ \mathrm{mA}}} & \\ R_\mathrm{B} & = & \dfrac{3{,}3\ \mathrm{V} - 0{,}7\ \mathrm{V}}{2{,}5\ \mathrm{mA}} = \underline{\underline{1{,}04\ \mathrm{k\Omega}}} & \end{array}

(je Größe 1 Punkt) Gewählt wird der nächstkleinere E12-Wert 1,0 kΩ: Ein kleinerer Basiswiderstand ergibt einen etwas größeren Basisstrom, der Transistor bleibt sicher in der Sättigung. (1 Punkt)

I_\mathrm{B} = \frac{2{,}6\ \mathrm{V}}{1{,}0\ \mathrm{k\Omega}} = \underline{\underline{2{,}60\ \mathrm{mA}}}

Das ist für den Pin unkritisch. (1 Punkt)

Die Relaisspule speichert Energie im Magnetfeld. Sperrt der Transistor, will der Spulenstrom weiterfließen; die Spule induziert eine Spannung, die am Kollektor weit über die Versorgungsspannung steigt und die zulässige Kollektor-Emitter-Spannung überschreitet. (2 Punkte)

Die Freilaufdiode liegt parallel zur Spule, Kathode an +5 V, Anode am Kollektor. Im Betrieb sperrt sie; beim Abschalten übernimmt sie den Spulenstrom, bis die Energie abgebaut ist. (1 Punkt)

Anforderungen (je 1 Punkt, drei davon):

• Logic-Level-Typ: R_\mathrm{DS(on)} ist schon für U_\mathrm{GS} = 2{,}5\ \mathrm{V} (oder kleiner) angegeben, damit er bei 3,3 V voll durchschaltet,
• zulässige Drain-Source-Spannung mit Reserve über 12 V (z. B. 20 V oder 30 V),
• Dauer-Drainstrom deutlich über 0,8 A,
• kleiner R_\mathrm{DS(on)}, damit die Verlustleistung klein bleibt.

Beschaltung (1 Punkt): Gatewiderstand (etwa 100 bis 220 Ω) zwischen Pin und Gate, Pull-down (etwa 10 bis 100 kΩ) zwischen Gate und Source/GND, damit der MOSFET beim Start sperrt. Source an GND, die Masse des 12-V-Netzteils mit GND des Boards verbinden, Freilaufdiode parallel zum Lüfter.

Verlustleistung (1 Punkt):

Geg.: I_\mathrm{D} = 0{,}8\ \mathrm{A}, R_\mathrm{DS(on)} = 50\ \mathrm{m\Omega} — Ges.: P_\mathrm{V}

P_\mathrm{V} = I_\mathrm{D}^2 \cdot R_\mathrm{DS(on)} = (0{,}8\ \mathrm{A})^2 \cdot 0{,}05\ \Omega = \underline{\underline{32{,}0\ \mathrm{mW}}}

Das schafft auch ein kleines SMD-Gehäuse ohne Kühlkörper.

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     LED4_PIN            = 7;                // LED 4, active HIGH

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

void setup() {
  pinMode(LED1_PIN, OUTPUT);       // Kontroll-LED
  pinMode(RELAY_PIN, OUTPUT);
}

void loop() {
  digitalWrite(RELAY_PIN, HIGH);   // Lüfter an ...
  digitalWrite(LED1_PIN, HIGH);    // ... und Kontroll-LED an
  delay(20000);
  digitalWrite(RELAY_PIN, LOW);    // Lüfter aus ...
  digitalWrite(LED1_PIN, LOW);     // ... und Kontroll-LED aus
  delay(10000);
}

//-------------------------------------------------------------------------------------
// 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     LED4_PIN            = 4;                // LED 4, active HIGH

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

void setup() {
  pinMode(LED1_PIN, OUTPUT);       // Kontroll-LED
  pinMode(RELAY_PIN, OUTPUT);
}

void loop() {
  digitalWrite(RELAY_PIN, HIGH);   // Lüfter an ...
  digitalWrite(LED1_PIN, HIGH);    // ... und Kontroll-LED an
  delay(20000);
  digitalWrite(RELAY_PIN, LOW);    // Lüfter aus ...
  digitalWrite(LED1_PIN, LOW);     // ... und Kontroll-LED aus
  delay(10000);
}

//-------------------------------------------------------------------------------------
// 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     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() {
  pinMode(LED1_PIN, OUTPUT);       // Kontroll-LED
  pinMode(RELAY_PIN, OUTPUT);
}

void loop() {
  digitalWrite(RELAY_PIN, HIGH);   // Lüfter an ...
  digitalWrite(LED1_PIN, HIGH);    // ... und Kontroll-LED an
  delay(20000);
  digitalWrite(RELAY_PIN, LOW);    // Lüfter aus ...
  digitalWrite(LED1_PIN, LOW);     // ... und Kontroll-LED aus
  delay(10000);
}

//-------------------------------------------------------------------------------------
// 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     LED4_PIN            = A3;               // LED 4, active HIGH

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

void setup() {
  pinMode(LED1_PIN, OUTPUT);       // Kontroll-LED
  pinMode(RELAY_PIN, OUTPUT);
}

void loop() {
  digitalWrite(RELAY_PIN, HIGH);   // Lüfter an ...
  digitalWrite(LED1_PIN, HIGH);    // ... und Kontroll-LED an
  delay(20000);
  digitalWrite(RELAY_PIN, LOW);    // Lüfter aus ...
  digitalWrite(LED1_PIN, LOW);     // ... und Kontroll-LED aus
  delay(10000);
}

Bewertung: Liste mit LED 1 und LED 4 1 Punkt, RELAY_PIN als Name für den Ausgang von LED 4 1 Punkt, beide Pins als Ausgang 1 Punkt, Lüfter und Kontroll-LED gemeinsam schalten 1 Punkt, Zeiten 20 s/10 s 1 Punkt.

Der Low-Side-Schalter liegt zwischen Last und Masse; die ausgeschaltete Last bleibt mit +12 V verbunden. Pauls Wunsch erfüllt nur ein High-Side-Schalter zwischen +12 V und Last. (1 Punkt)

Ein P-Kanal-MOSFET sperrt erst, wenn sein Gate etwa auf Source-Potenzial, also auf 12 V liegt. Der Pin liefert höchstens 3,3 V; U_\mathrm{GS} wäre dann etwa −8,7 V, der MOSFET bliebe immer leitend. Deshalb zieht ein zusätzlicher npn-Transistor das Gate nach Masse, ein Widerstand zwischen Gate und Source zieht es sonst auf 12 V (zulässige Gate-Source-Spannung beachten). (1 Punkt)