H-Brücke für Gleichstrommotoren

Ein Transistor kann einen Gleichstrommotor ein- und ausschalten und per PWM seine Drehzahl stellen. Für die Drehrichtung reicht das nicht, denn dazu muss sich die Polarität am Motor umkehren. Ein Roboterfahrzeug, ein Rollladen, eine motorische Klappe oder ein Linearantrieb brauchen deshalb eine H-Brücke: vier Schalter, die den Motor wahlweise in die eine oder andere Richtung an die Versorgung legen.

Fertige Motortreiber erledigen das für kleine Motoren in einem Gehäuse. Sobald es um ein paar Ampere bei 12 V geht, wird eine H-Brücke aus einzelnen MOSFETs interessant: Sie verliert kaum Spannung, ist billig und du verstehst jedes Bauteil. Hier baust du sie für einen 12-V-Getriebemotor mit 1,5 A Betriebsstrom auf und steuerst sie mit einem Arduino.

Schaltplan

• T1, T2 (IRF9540N): P-Kanal-MOSFETs auf der Plus-Seite (High-Side). Sie leiten, wenn ihr Gate unter die Source gezogen wird.
• R1, R5 (10 kΩ): halten die P-Kanal-Gates auf +12 V, die FETs sind dann aus.
• Q1, Q2 (BC547) mit R2, R6 (4,7 kΩ): Pegelwandler. Der 5-V-Pin kann ein Gate an 12 V nicht direkt steuern; der Transistor zieht es auf Masse und schaltet den P-Kanal-FET ein. Das Prinzip zeigt der P-MOSFET als High-Side-Schalter.
• T3, T4 (IRLZ44N): Logic-Level-MOSFETs auf der Masse-Seite, direkt vom Arduino angesteuert.
• R3, R7 (220 Ω): begrenzen den Umladestrom der Gates auf etwa 23 mA.
• R4, R8 (10 kΩ): halten die N-Kanal-FETs aus, solange der Arduino startet.
• Nicht gezeichnet: 470 μF/25 V und 100 nF direkt zwischen +12 V und Masse an der Brücke, eine 5-A-Sicherung in der Zuleitung und die gemeinsame Masse mit dem Arduino.

So funktioniert die Schaltung

Vorwärts: T1 verbindet die linke Motorseite mit +12 V, T4 die rechte mit Masse. Die Drehzahl stellst du über das Tastverhältnis an T4 ein. In der Aus-Phase der PWM will der Strom in der Wicklung weiterfließen – der Motor ist eine große Spule (Induktion). Er findet seinen Weg über die Body-Diode von T2 zurück zur Plusleitung und kreist über T1 durch den Motor. Ohne diesen Weg würde die Spannung an der Brückenmitte hochschnellen und T4 zerstören; das Prinzip ist das der Freilaufdiode.

Bremsen: Beide unteren FETs leiten. Der drehende Motor arbeitet als Generator und treibt einen Strom durch den Kurzschluss, der ihn abbremst.

Querstrom (Shoot-Through): Leiten oben und unten auf derselben Seite gleichzeitig, fließt ein Kurzschlussstrom von +12 V nach Masse, begrenzt nur durch die Durchlasswiderstände: rechnerisch 12 V / 0,14 Ω ≈ 85 A. Die FETs sterben in Millisekunden. Deshalb schaltet das Programm beim Richtungswechsel zuerst alles aus, wartet eine Totzeit und schaltet erst dann die andere Diagonale ein.

Dimensionierung

Der Motor: 12 V, 1,5 A im Betrieb, Wicklungswiderstand 2 Ω. Beim Anlaufen steht er noch, nur die Wicklung begrenzt den Strom: 12 V / 2 Ω = 6 A für einige zehn Millisekunden.

1. N-Kanal-FET. Der IRLZ44N verträgt 55 V und 47 A, bei 5 V Gate-Spannung ist R_DS(on) ≤ 25 mΩ:

2. P-Kanal-FET. Der IRF9540N verträgt −100 V und −23 A, bei −10 V Gate-Spannung ist R_DS(on) ≤ 0,117 Ω. Sein Gate sieht hier −11,9 V, also gilt dieser Wert:

Zusammen fallen in der Brücke 1,5 A · (0,117 Ω + 0,025 Ω) ≈ 0,21 V ab. Ein L298N würde bei diesem Strom 2 bis 3 V verlieren.

3. Freilauf. In der Aus-Phase der PWM fließt der Strom durch die Body-Diode von T2, rund 0,9 V bei 1,5 A. Bei 50 % Tastverhältnis:

Mit dem Durchlassverlust ist T1 bzw. T2 dann bei knapp 1 W. Ohne Kühlkörper (62 K/W im TO-220) wären das über 60 K Erwärmung – zu viel. Entweder bekommen T1 und T2 kleine Kühlkörper, oder du schaltest je eine Schottky-Diode 1N5822 parallel. Sie übernimmt den Freilaufstrom mit etwa 0,45 V und halbiert die Wärme. Wie du den Kühlkörper bemisst, steht unter Wärme und Kühlung.

4. Ansteuerung der P-Kanal-FETs. Q1 bekommt (5 V − 0,7 V) / 4,7 kΩ ≈ 0,9 mA Basisstrom und muss nur 12 V / 10 kΩ = 1,2 mA ziehen – er sättigt sicher und schaltet T1 schnell ein. Ausgeschaltet wird T1 aber nur über R1. Mit bis zu 97 nC Gate-Ladung und gut 1 mA Ladestrom dauert das rund 0,1 ms. Deshalb gehört die PWM auf die unteren FETs, und das Programm wartet beim Richtungswechsel 1 ms.

5. PWM-Frequenz. Die Pins 9 und 10 des Uno takten mit 490 Hz. T4 wird über 220 Ω mit Spitzenstrom 23 mA umgeladen und braucht pro Flanke etwa 3 μs. Die Schaltverluste bleiben damit klein:

Arduino-Programm

const int H_A = 7, H_B = 8;        // P-Kanal über Q1/Q2: HIGH = ein
const int L_A = 9, L_B = 10;       // N-Kanal, PWM-fähig

void allesAus() {
  analogWrite(L_A, 0);
  analogWrite(L_B, 0);
  digitalWrite(H_A, LOW);
  digitalWrite(H_B, LOW);
  delay(1);                        // Totzeit: P-Kanal-FETs sperren erst nach ~0,1 ms
}

void fahren(int tempo) {           // −255 … +255
  allesAus();
  if (tempo > 0) {                 // vorwärts: T1 ein, T4 taktet
    digitalWrite(H_A, HIGH);
    analogWrite(L_B, tempo);
  } else if (tempo < 0) {          // rückwärts: T2 ein, T3 taktet
    digitalWrite(H_B, HIGH);
    analogWrite(L_A, -tempo);
  }
}

void bremsen() {
  allesAus();
  digitalWrite(L_A, HIGH);         // beide unteren FETs: Motor kurzgeschlossen
  digitalWrite(L_B, HIGH);
}

void setup() {
  pinMode(H_A, OUTPUT); pinMode(H_B, OUTPUT);
  pinMode(L_A, OUTPUT); pinMode(L_B, OUTPUT);
  allesAus();
}

void loop() {
  fahren(180);  delay(2000);
  bremsen();    delay(500);
  fahren(-120); delay(2000);
  allesAus();   delay(1000);
}

Jede Richtungsänderung läuft über allesAus(). Willst du nur die Drehzahl ändern, rufst du direkt analogWrite auf dem gerade taktenden Pin auf. Wie die Drehzahl vom Tastverhältnis abhängt, zeigt Motordrehzahl per PWM.

Bauteilliste

Varianten

Motortreiber-IC für kleine Motoren. Bis 1,5 A und 10,8 V ist der DRV8833 einfacher: zwei Eingänge pro Motor, Totzeit, Freilauf und Überstromschutz sind eingebaut. Er braucht nur drei Kondensatoren.

Beim DRV8833 bedeutet AIN1 = PWM, AIN2 = Low vorwärts mit Freilauf; AIN1 = High, AIN2 = PWM vorwärts mit Bremsen in der Aus-Phase. Mit einem Widerstand an AISEN begrenzt er den Strom.

Größere Ströme und schnelle PWM. Für 20 kHz (unhörbar) und mehrere Ampere nimmst du vier N-Kanal-FETs mit einem Halbbrückentreiber wie dem IR2104, der die oberen Gates per Bootstrap-Kondensator über die Versorgung hebt und die Totzeit selbst erzeugt.

L298N-Modul. Billig und robust, aber bipolar: 2 bis 3 V Verlust, viel Wärme. Für 12-V-Motoren mit über 1 A ist die MOSFET-Brücke deutlich besser.

Nur eine Richtung. Muss der Motor nur vorwärts laufen, reicht ein einzelner MOSFET als Low-Side-Schalter mit Freilaufdiode.

Typische Fehler

• FET raucht beim ersten Richtungswechsel: Querstrom. Fehlt die Totzeit oder schaltet das Programm einen P-FET ein, während der N-FET derselben Seite noch leitet, entsteht ein Kurzschluss.
• Motor läuft nur in eine Richtung: Ein P-Kanal-FET bekommt kein Gate-Signal. Miss die Spannung am Gate gegen +12 V: eingeschaltet etwa −12 V, ausgeschaltet 0 V.
• P-FETs werden heiß, Motor läuft schwach: IRF9540N und IRF540N verwechselt, oder T1 in falscher Richtung eingebaut. Die Source gehört an +12 V.
• Arduino setzt sich beim Anlaufen zurück: Der Anlaufstrom zieht die Versorgung herunter. C1 näher an die Brücke, getrennte Versorgung für den Arduino, Massen sternförmig verbinden.
• Motor pfeift: 490 Hz liegen im Hörbereich. Für leisen Betrieb brauchst du über 20 kHz und dafür einen Gate-Treiber.
• Störungen am Arduino: Motoren erzeugen Bürstenfeuer. 100 nF direkt an den Motorklemmen helfen, siehe EMV.

Selbsttest