H-Brücke mit MOSFETs bauen – Motorsteuerung für Arduino & Co.

Ich zeige dir heute, wie du mit einer H-Brücke aus MOSFETs einen Elektromotor in beide Richtungen steuern kannst. Eine H-Brücke ermöglicht es dir, die Polarität der Spannung am Motor umzukehren und somit die Drehrichtung zu ändern – perfekt für Roboterprojekte, ferngesteuerte Fahrzeuge oder andere Anwendungen, bei denen du präzise Motorkontrolle brauchst.

In diesem Tutorial verwende ich Logic-Level-MOSFETs, die direkt mit den 5V-Ausgangspins eines Arduino angesteuert werden können. Das ist ein wichtiger Unterschied zu vielen anderen Anleitungen, die MOSFETs verwenden, welche bei 5V Gate-Spannung nicht vollständig durchschalten.

---

Materialliste

• N-Channel Logic-Level-MOSFET IRLZ44N (2×)
• P-Channel Logic-Level-MOSFET IRF9Z34N (2×)
• NPN-Transistor BC547 (2×) – für die P-Channel-Ansteuerung
• Widerstände 100 Ω (4×) – Gate-Vorwiderstände
• Widerstände 10 kΩ (2×) – Pull-up für P-Channel-Gates
• Widerstände 1 kΩ (2×) – Basis-Vorwiderstände BC547
• Freilaufdioden 1N4007 (4×) – Schutz vor induktiven Spannungsspitzen
• Kondensator 100 µF – Entkopplung der Versorgungsspannung
• DC-Elektromotor 6–12 V
• Breadboard und Verbindungskabel
• Spannungsquelle 6–12 V (separat vom Arduino!)
• Arduino oder anderer Mikrocontroller

⚠️ Wichtig – MOSFET-Auswahl: Nicht alle MOSFETs sind für die direkte Ansteuerung durch einen Arduino geeignet. Der klassische IRFZ40 und der IRF9Z30 schalten bei 5V Gate-Spannung nicht vollständig durch – das führt zu hohen Verlusten und überhitzten Bauteilen. Der IRLZ44N (N-Channel) und IRF9Z34N (P-Channel) sind Logic-Level-Typen, die bei 5V sauber durchschalten.

---

Technische Grundlagen

Was ist eine H-Brücke?

Eine H-Brücke besteht aus vier Schaltern (hier: MOSFETs), die in einer H-förmigen Konfiguration angeordnet sind. Durch gezieltes Schalten dieser Transistoren kannst du die Stromrichtung durch den Motor umkehren und damit seine Drehrichtung ändern.

Die vier möglichen Zustände sind:

• Vorwärts: Oberer linker + unterer rechter MOSFET leiten → Strom fließt von links nach rechts durch den Motor
• Rückwärts: Oberer rechter + unterer linker MOSFET leiten → Strom fließt von rechts nach links
• Bremsen: Beide unteren (oder beide oberen) MOSFETs leiten → Motor wird aktiv kurzgeschlossen und gebremst
• Freilauf: Alle MOSFETs gesperrt → Motor läuft frei aus

⚠️ Shoot-Through – unbedingt vermeiden: Du darfst niemals gleichzeitig den oberen und unteren MOSFET derselben Seite durchschalten. Das erzeugt einen direkten Kurzschluss zwischen Versorgungsspannung und GND und zerstört sofort die Bauteile. Im Code sorgen Dead-Time-Verzögerungen dafür, dass zwischen dem Ausschalten eines MOSFETs und dem Einschalten seines Gegenstücks immer eine kurze Pause liegt.

N-Channel vs. P-Channel MOSFETs

• N-Channel MOSFET (IRLZ44N): Schaltet durch, wenn am Gate eine positive Spannung (relativ zu Source) anliegt. Wird auf der Low-Side (Masse-Seite) eingesetzt. Kann direkt vom Arduino angesteuert werden, da Source auf GND liegt.
• P-Channel MOSFET (IRF9Z34N): Schaltet durch, wenn das Gate negativer als die Source ist. Wird auf der High-Side (Versorgungsspannungs-Seite) eingesetzt. Hier liegt Source auf der Motorspannung (z.B. 12V) – der Arduino-Ausgang (5V) kann das Gate daher nicht direkt auf ausreichend niedriges Potential ziehen. Deswegen brauchen wir eine Treiberstufe mit einem BC547.

Warum ein Transistor für die P-Channel-Ansteuerung?

Angenommen, deine Motorspannung beträgt 12V. Die Source des P-Channel-MOSFETs liegt auf 12V. Damit der MOSFET leitet, muss das Gate auf ca. 12V − 5V = 7V oder weniger gezogen werden. Ein Arduino-Ausgang (0V oder 5V) kann das Gate nicht direkt auf dieses Potential bringen.

Die Lösung: Ein NPN-Transistor (BC547) als Treiberstufe. Wenn der Arduino den BC547 einschaltet (Basis auf HIGH), zieht dessen Kollektor das Gate des P-MOSFETs auf GND – der P-MOSFET schaltet durch. Ein Pull-up-Widerstand (10 kΩ) von Gate nach Versorgungsspannung sorgt dafür, dass der P-MOSFET sicher sperrt, wenn der BC547 ausgeschaltet ist.

Das Ergebnis ist eine invertierte Logik für die oberen MOSFETs: Arduino HIGH → P-MOSFET leitet.

---

Schaltplan und Aufbau

Schritt-für-Schritt-Aufbau

1. Stromversorgung vorbereiten:

• Verwende eine separate Spannungsquelle für den Motor (6–12V). Speise den Motor niemals direkt aus dem Arduino – der kann maximal ~500mA liefern.
• Schalte einen 100-µF-Kondensator parallel zur Motorspannung (nahe der Schaltung), um Spannungsspitzen abzufangen.
• Verbinde GND der Motorspannungsquelle mit GND des Arduino.

2. Low-Side – N-Channel-MOSFETs (IRLZ44N):

• Source beider IRLZ44N auf GND
• Je ein 100-Ω-Widerstand zwischen Arduino-Ausgang und Gate (dämpft Schwingungen)
• Drain bildet jeweils den Motoranschluss (zusammen mit dem darüberliegenden P-MOSFET)

3. High-Side – P-Channel-MOSFETs (IRF9Z34N) mit BC547-Treiber:

• Source beider IRF9Z34N auf Motorspannung (+V_Motor)
• 10-kΩ-Pull-up-Widerstand von Gate nach +V_Motor (hält Gate oben = MOSFET gesperrt)
• Kollektor des BC547 an das Gate des IRF9Z34N
• Emitter des BC547 auf GND
• 1-kΩ-Widerstand von Arduino-Ausgang an Basis des BC547
• Drain bildet den Motoranschluss (zusammen mit dem IRLZ44N darunter)

4. Motor anschließen:

• Die beiden Motoranschlüsse kommen jeweils zwischen den Drain des oberen (P-Channel) und unteren (N-Channel) MOSFETs einer Seite

5. Freilaufdioden (1N4007):

• Je eine Diode antiparallel zu jedem MOSFET (Anode an Drain, Kathode an Source beim N-Channel; umgekehrt beim P-Channel)
• Sie fangen die induktiven Spannungsspitzen ab, die der Motor beim Abschalten erzeugt – ohne sie können die MOSFETs zerstört werden

---

Ansteuerungslogik

Durch die invertierende BC547-Stufe gilt für alle vier Steuerpins einheitlich: HIGH = MOSFET leitet.

Richtung	Pin 1 (links oben)	Pin 2 (links unten)	Pin 3 (rechts oben)	Pin 4 (rechts unten)
Vorwärts	HIGH	LOW	LOW	HIGH
Rückwärts	LOW	HIGH	HIGH	LOW
Stop (Freilauf)	LOW	LOW	LOW	LOW
Bremsen	LOW	HIGH	LOW	HIGH

---

Der Code

// H-Brücke mit Logic-Level-MOSFETs und BC547-Treiber für P-Channel
// Alle Pins: HIGH = MOSFET leitet (durch BC547 invertierte P-Channel-Ansteuerung)

const int PIN_LEFT_HIGH  = 2;  // Linker oberer MOSFET  (P-Channel via BC547)
const int PIN_LEFT_LOW   = 3;  // Linker unterer MOSFET (N-Channel, direkt)
const int PIN_RIGHT_HIGH = 4;  // Rechter oberer MOSFET (P-Channel via BC547)
const int PIN_RIGHT_LOW  = 5;  // Rechter unterer MOSFET (N-Channel, direkt)

// Dead-Time in Mikrosekunden – Pause zwischen Umschalten
// Verhindert Shoot-Through (Kurzschluss durch gleichzeitig leitende MOSFETs)
const int DEAD_TIME_US = 10;

void setup() {
  pinMode(PIN_LEFT_HIGH,  OUTPUT);
  pinMode(PIN_LEFT_LOW,   OUTPUT);
  pinMode(PIN_RIGHT_HIGH, OUTPUT);
  pinMode(PIN_RIGHT_LOW,  OUTPUT);
  motorStop();
  Serial.begin(9600);
  Serial.println("H-Brücke bereit.");
}

void loop() {
  Serial.println("Vorwärts");
  motorForward();
  delay(2000);

  motorStop();
  delay(500);

  Serial.println("Rückwärts");
  motorBackward();
  delay(2000);

  motorStop();
  delay(500);
}

// Alle MOSFETs ausschalten (Freilauf)
void motorStop() {
  digitalWrite(PIN_LEFT_HIGH,  LOW);
  delayMicroseconds(DEAD_TIME_US);
  digitalWrite(PIN_LEFT_LOW,   LOW);
  delayMicroseconds(DEAD_TIME_US);
  digitalWrite(PIN_RIGHT_HIGH, LOW);
  delayMicroseconds(DEAD_TIME_US);
  digitalWrite(PIN_RIGHT_LOW,  LOW);
}

// Motor vorwärts: links oben + rechts unten leiten
void motorForward() {
  motorStop(); // Erst alles aus (Dead-Time sicherheitshalber)
  delayMicroseconds(DEAD_TIME_US);
  digitalWrite(PIN_LEFT_HIGH, HIGH);
  digitalWrite(PIN_RIGHT_LOW, HIGH);
}

// Motor rückwärts: rechts oben + links unten leiten
void motorBackward() {
  motorStop();
  delayMicroseconds(DEAD_TIME_US);
  digitalWrite(PIN_RIGHT_HIGH, HIGH);
  digitalWrite(PIN_LEFT_LOW,   HIGH);
}

// Motor aktiv bremsen: beide unteren MOSFETs leiten (Motor kurzgeschlossen)
void motorBrake() {
  motorStop();
  delayMicroseconds(DEAD_TIME_US);
  digitalWrite(PIN_LEFT_LOW,  HIGH);
  digitalWrite(PIN_RIGHT_LOW, HIGH);
}

// Geschwindigkeitssteuerung via PWM (nur auf N-Channel-Pins, Pin 3 und 5 sind PWM-fähig)
// speed: 0–255
void motorForwardPWM(int speed) {
  motorStop();
  delayMicroseconds(DEAD_TIME_US);
  digitalWrite(PIN_LEFT_HIGH, HIGH);   // P-Channel links: dauerhaft ein
  analogWrite(PIN_RIGHT_LOW,  speed);  // N-Channel rechts: PWM
}

void motorBackwardPWM(int speed) {
  motorStop();
  delayMicroseconds(DEAD_TIME_US);
  digitalWrite(PIN_RIGHT_HIGH, HIGH);
  analogWrite(PIN_LEFT_LOW,    speed);
}

Hinweis zu PWM: PWM wird hier nur auf den N-Channel-MOSFETs (Low-Side) eingesetzt. Das ist die einfachere und zuverlässigere Variante. Für sehr hochfrequentes PWM (>10 kHz) empfiehlt sich ein dedizierter Gate-Treiber-IC – für typische Maker-Projekte reicht diese Schaltung aber problemlos aus.

---

Troubleshooting

Motor dreht sich gar nicht

• Ist GND der Motorspannungsquelle mit Arduino-GND verbunden?
• Miss die Gate-Spannungen mit einem Multimeter: Beim IRLZ44N sollten am Gate 5V anliegen (wenn leitend). Beim IRF9Z34N sollte das Gate nahe GND liegen (wenn leitend).
• Prüfe, ob der BC547 schaltet: Kollektor-Emitter-Spannung sollte bei aktivem Transistor unter 0,3V liegen.

MOSFETs werden sehr heiß

• Wahrscheinlicher Shoot-Through: Überprüfe, ob nie gleichzeitig oberer und unterer MOSFET einer Seite leiten.
• Erhöhe die Dead-Time im Code (DEAD_TIME_US).
• Bei höheren Strömen (>3A) Kühlkörper auf die MOSFETs montieren.

Motor läuft nur in eine Richtung

• Prüfe die BC547-Schaltung für die nicht funktionierende Seite.
• Miss die Basis-Spannung des BC547 – sie sollte bei HIGH-Signal ca. 4,3V betragen (5V minus Spannungsabfall am 1-kΩ-Widerstand).

Motor vibriert oder brummt, dreht sich aber kaum

• Zu wenig Strom: Prüfe, ob deine Spannungsquelle ausreichend Strom liefert.
• PWM-Frequenz zu niedrig: Der Standard-analogWrite() des Arduino läuft auf ~490 Hz. Für manche Motoren besser höhere Frequenzen einstellen.

---

Erweiterungsmöglichkeiten

• Strommessung: Shunt-Widerstand (z.B. 0,1 Ω) in der GND-Leitung des Motors + analogRead() zum Überwachen des Motorstroms
• Optokoppler: Für galvanische Trennung zwischen Steuerung und Leistungsteil – besonders bei höheren Spannungen sinnvoll
• Gate-Treiber-IC: Z.B. IR2104 für sauberes High-Side-Switching und eingebaute Dead-Time – empfohlen ab ca. 5A oder PWM-Frequenzen über 20 kHz
• Mehrere Motoren: Mehrere H-Brücken für Roboter mit Rädern – jede Brücke benötigt 4 Arduino-Pins
• Encoder-Feedback: Hallsensor oder optischer Encoder am Motor für Positions- oder Drehzahlregelung

---

Fazit

Mit dieser H-Brücke aus Logic-Level-MOSFETs (IRLZ44N + IRF9Z34N) und BC547-Treiberstufen für die High-Side hast du eine Schaltung, die zuverlässig mit einem 5V-Arduino zusammenarbeitet und Motorspannungen von 6–20V schalten kann.

Die wichtigsten Punkte zum Mitnehmen:

• Nur Logic-Level-MOSFETs verwenden – Standard-MOSFETs schalten bei 5V nicht vollständig durch
• P-Channel High-Side immer mit Treibertransistor ansteuern
• Freilaufdioden sind kein optionales Extra – ohne sie werden die MOSFETs zerstört
• Dead-Time im Code schützt vor Shoot-Through
• Motor immer separat versorgen, nicht vom Arduino

Fang mit niedrigen Spannungen und kleinen Motoren an. Wenn die Schaltung läuft, kannst du die Spannung schrittweise erhöhen und mit PWM-Geschwindigkeitssteuerung experimentieren.