DC-Motor & N20 Getriebemotor mit Arduino ansteuern: PWM-Drehzahlregelung Schritt für Schritt

Getriebemotor oder blanker DC-Motor – was brauchst du?

Ein blanker Bürsten-DC-Motor wie der 130er Micro-Motor dreht extrem schnell – bis zu 20.000 Umdrehungen pro Minute – hat dafür aber kaum Drehmoment. Perfekt für Propeller, Lüfter oder Vibrationseffekte, aber völlig ungeeignet, um ein Rad oder eine Mechanik anzutreiben: Er bleibt bei der kleinsten Last stehen.

Genau dafür gibt es Getriebemotoren wie den N20 mit Vollmetall-Getriebe: Ein Untersetzungsgetriebe tauscht Drehzahl gegen Kraft. Aus 20.000 U/min werden z. B. 40 U/min – dafür dreht die Welle mit so viel Drehmoment, dass sie Roboterräder, Seilwinden oder Drehteller zuverlässig bewegt. Die Faustregel:

Wann ein Schrittmotor die bessere Wahl ist, liest du im Artikel Schrittmotor 28BYJ-48 mit Arduino ansteuern – heute geht es um die pure Rotation.

Warum der Motor NIEMALS direkt an den Arduino-Pin darf

Ein Arduino-GPIO liefert maximal etwa 40 mA – empfohlen sind 20 mA. Schon der kleine 130er Motor zieht im Anlauf und unter Last aber schnell mehrere hundert Milliampere, im Blockierfall über ein Ampere. Schließt du ihn direkt an einen Pin an, überlastest du den Ausgangstreiber des ATmega328 – im besten Fall stirbt nur der Pin, im schlimmsten der ganze Chip.

Die Lösung ist ein Transistor als elektronischer Schalter: Der Arduino-Pin liefert nur einen winzigen Steuerstrom an die Basis, der Transistor schaltet dafür den großen Motorstrom aus einer separaten Versorgung. Dazu kommen zwei Bauteile, die du nie weglassen darfst:

• Basiswiderstand (ca. 1 kΩ): begrenzt den Steuerstrom aus dem Arduino-Pin – aus dem Widerstands-Sortiment
• Freilaufdiode (z. B. 1N4007) über dem Motor: Ein Motor ist eine Spule. Beim Abschalten erzeugt er eine Spannungsspitze von etlichen Volt, die ungebremst den Transistor oder Arduino zerstört. Die Diode (Kathode/Ring Richtung Plus!) leitet diese Spitze harmlos ab.

Das brauchst du

1Aufbau & erster Test: Motor ein- und ausschalten

So verkabelst du die Transistor-Schaltung auf dem Breadboard:

Der erste Sketch schaltet den Motor im Zwei-Sekunden-Takt – damit prüfst du, ob die Schaltung stimmt:

const int MOTOR = 9;   // D9 = PWM-faehiger Pin

void setup() {
  pinMode(MOTOR, OUTPUT);
}

void loop() {
  digitalWrite(MOTOR, HIGH);   // Transistor schaltet durch -> Motor laeuft
  delay(2000);
  digitalWrite(MOTOR, LOW);    // Motor aus
  delay(2000);
}

2Drehzahl regeln mit PWM

Ein DC-Motor kennt eigentlich nur an und aus. Der Trick der Drehzahlregelung heißt PWM (Pulsweitenmodulation): Der Arduino schaltet den Transistor hunderte Male pro Sekunde ein und aus. Ist er 50 % der Zeit an, bekommt der Motor im Mittel die halbe Leistung – er dreht langsamer. Die Trägheit des Ankers glättet das Pulsen zu einer runden Drehbewegung. Auf den PWM-Pins (beim Nano: D3, D5, D6, D9, D10, D11) erledigt analogWrite() das für dich mit Werten von 0 bis 255:

const int MOTOR = 9;

void setup() {
  pinMode(MOTOR, OUTPUT);
}

void loop() {
  // sanft beschleunigen
  for (int tempo = 0; tempo <= 255; tempo += 5) {
    analogWrite(MOTOR, tempo);
    delay(100);
  }
  delay(1500);   // kurz Vollgas halten

  // sanft abbremsen
  for (int tempo = 255; tempo >= 0; tempo -= 5) {
    analogWrite(MOTOR, tempo);
    delay(100);
  }
  delay(1500);
}

3Drehzahl per Rotary Encoder einstellen

Feintuning per Code-Upload ist mühsam – ein KY-040 Rotary Encoder macht daraus ein echtes Bedienelement: Drehen ändert die Drehzahl, Drücken stoppt den Motor. Verkabelung: CLK an D2, DT an D3, SW an D4, + an 5V, GND an GND.

const int MOTOR = 9;
const int CLK = 2;
const int DT  = 3;
const int SW  = 4;

volatile int tempo = 0;        // 0..255
volatile int letzterCLK;
bool motorAn = true;

void encoderISR() {
  int clk = digitalRead(CLK);
  if (clk != letzterCLK && clk == LOW) {
    if (digitalRead(DT) != clk) tempo += 10;   // rechtsherum: schneller
    else                        tempo -= 10;   // linksherum: langsamer
    tempo = constrain(tempo, 0, 255);
  }
  letzterCLK = clk;
}

void setup() {
  Serial.begin(115200);
  pinMode(MOTOR, OUTPUT);
  pinMode(CLK, INPUT);
  pinMode(DT, INPUT);
  pinMode(SW, INPUT_PULLUP);
  letzterCLK = digitalRead(CLK);
  attachInterrupt(digitalPinToInterrupt(CLK), encoderISR, CHANGE);
}

void loop() {
  // Taster: Motor stoppen / starten (mit einfachem Entprellen)
  if (digitalRead(SW) == LOW) {
    motorAn = !motorAn;
    delay(300);
  }

  analogWrite(MOTOR, motorAn ? tempo : 0);

  static unsigned long letzteAusgabe = 0;
  if (millis() - letzteAusgabe > 500) {
    letzteAusgabe = millis();
    Serial.printf("Tempo: %d/255 (%s)\n", tempo, motorAn ? "AN" : "STOP");
  }
}

Wie der Encoder intern funktioniert und wie du ihn sauber entprellst, erklärt ausführlich der Artikel Rotary Encoder KY-040 mit Arduino auslesen.

Ausblick: Drehrichtung wechseln mit der H-Brücke

Mit einem einzelnen Transistor kannst du den Motor nur ein- und ausschalten und seine Drehzahl regeln – die Drehrichtung bleibt fest. Für Vor- und Rückwärtsfahrt braucht es eine H-Brücke: vier Schalter in H-Anordnung, die den Strom wahlweise in beide Richtungen durch den Motor leiten. In der Praxis nimmt man dafür fertige Treiber-ICs (klassisch L298N oder moderner DRV8833/TB6612), die zwei Motoren gleichzeitig mit Richtung und PWM-Tempo steuern – die Grundlage für jedes zweirädrige Roboterfahrzeug.

Troubleshooting