Wie man Servomotoren mit Arduino steuert

In diesem Tutorial lernst du, wie Servomotoren funktionieren und wie man sie mit Arduino steuert.

Servomotoren werden oft in Robotikprojekten verwendet, aber man findet sie auch in RC-Autos, Flugzeugen usw. Sie sind sehr nützlich, wenn du eine präzise Positionskontrolle und/oder hohes Drehmoment benötigst.

Im ersten Teil dieses Artikels betrachten wir den inneren Aufbau eines Servos und welche Art von Steuersignal er verwendet. Ich erkläre auch die Unterschiede zwischen einem Standard- und einem Continuous-Servo. Anschließend zeige ich dir, wie du einen Servomotor an den Arduino anschließt.

Mit dem ersten Codebeispiel kannst du sowohl die Position als auch die Geschwindigkeit des Servomotors steuern. Danach schauen wir uns an, wie man einen Servo mit einem Potentiometer steuert und wie du den Code anpassen kannst, um mehrere Servomotoren gleichzeitig zu steuern. Am Ende des Artikels findest du die Spezifikationen und Abmessungen einiger der beliebtesten Servomotoren auf dem Markt.

Materialien

Hardware-Komponenten

SG90 micro servo	× 1	Amazon
MG996R high-torque servo	× 1	Amazon
Arduino Uno Rev3	× 1	Amazon
Jumper wires	× 15	Amazon
Breadboard	× 1	Amazon
10 kΩ potentiometer (Breadboard-Typ)	× 1	Amazon
USB cable type A/B	× 1	Amazon
5V power supply (optional)	× 1	Amazon

Software

Arduino IDE

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Wie funktioniert ein Servomotor?

Ein Standard-Hobbyservo besteht typischerweise aus einem kleinen Elektromotor, einem Potentiometer, Steuerelektronik und einem Getriebe. Die Position der Ausgangswelle wird ständig vom internen Potentiometer gemessen und mit der vom Controller (z. B. Arduino) vorgegebenen Zielposition verglichen.

Je nach Abweichung passt die Steuerelektronik die tatsächliche Position der Ausgangswelle so an, dass sie der Zielposition entspricht. Dies ist als geschlossenes Regelungssystem bekannt.

Das Getriebe verringert die Drehzahl des Motors, was das Drehmoment an der Ausgangswelle erhöht. Die maximale Drehzahl der Ausgangswelle liegt normalerweise bei etwa 60 U/min.

Servo-Steuerung

Servomotoren werden gesteuert, indem ein PWM-Signal (Pulsweitenmodulation) an die Signalleitung des Servos gesendet wird. Die Pulsbreite bestimmt die Position der Ausgangswelle. Wenn du dem Servo ein Signal mit einer Pulsbreite von 1,5 Millisekunden (ms) sendest, bewegt sich der Servo in die Neutralposition (90 Grad). Die minimale (0 Grad) und maximale (180 Grad) Position entsprechen typischerweise einer Pulsbreite von 1 ms bzw. 2 ms. Beachte, dass dies je nach Typ und Marke des Servos leicht variieren kann (z. B. 0,5 und 2,5 ms). Viele Servos drehen nur etwa 170 Grad (oder sogar nur 90), aber die Mittelstellung liegt fast immer bei 1,5 ms.

Zum Anpassen der minimalen und maximalen Position im Code siehe den Abschnitt unten.

Servomotoren erwarten in der Regel alle 20 Millisekunden einen Impuls, also 50 Hz, aber viele RC-Servos funktionieren auch gut im Bereich von 40 bis 200 Hz.

360-Grad (Continuous) vs. 180-Grad (Standard) Servo

Die meisten RC-Servos sind vom 180-Grad-Typ, das heißt, sie können sich nur im Bereich von 0 bis 180 Grad drehen. Es gibt jedoch auch Continuous-Servos, auch bekannt als 360-Grad-Servomotoren.

Continuous-Servos reagieren anders auf das Steuersignal als Standard-180-Grad-Servos. Bei einem Continuous-Servo kannst du die genaue Position der Ausgangswelle nicht steuern, sondern nur die Geschwindigkeit und Richtung. Ein 1-ms-Impuls setzt die Motordrehzahl auf volle Geschwindigkeit in eine Richtung, ein 2-ms-Impuls auf volle Geschwindigkeit in die andere Richtung. Ein Wert nahe 1,5 ms lässt den Motor stoppen.

Wenn sich dein Servo unerwartet verhält, verwendest du möglicherweise einen Continuous-Servo statt eines Standard-Servos.

Für weitere Informationen schau dir unser Tutorial an Positional versus Continuous Servos.

Wie schließt man einen Servomotor an den Arduino an?

Das Anschließen eines Servomotors ist sehr einfach, da du nur drei Kabel verbinden musst: Strom, Masse und Signal. Das Stromkabel ist typischerweise rot und wird mit 5 V verbunden.

Ein Mikroservo wie der SG90 verbraucht im Leerlauf etwa 10 mA und beim Drehen 100 – 250 mA, daher kannst du ihn direkt mit dem 5-V-Ausgang des Arduino versorgen. Bei mehreren oder größeren Servos musst du jedoch vorsichtig sein. Wenn dein(e) Motor(en) mehr als 300 mA verbrauchen, solltest du eine externe Stromversorgung verwenden, um den Arduino nicht zu beschädigen! Siehe den Schaltplan unten für die Verwendung externer Stromversorgungen.

Das Massekabel ist typischerweise schwarz oder braun und sollte mit dem Masse-Pin des Arduino verbunden werden. Bei Verwendung einer separaten Stromversorgung verbinde das Massekabel sowohl mit dem Arduino als auch mit der Stromversorgung.

Das Signalkabel ist typischerweise gelb, orange oder weiß und kann mit jedem digitalen Pin des Arduino verbunden werden. In diesem Fall habe ich es mit dem digitalen Pin 9 verbunden.

Die Verbindungen sind auch in der folgenden Tabelle aufgeführt.

Servomotor-Verbindungen

Servomotor	Arduino
Strom (rot)	5 V
Masse (schwarz oder braun)	GND
Signal (gelb, orange oder weiß)	Pin 9

Wie bereits erwähnt, solltest du bei großen oder mehreren Servomotoren eine externe Stromversorgung verwenden. Verbinde die Stromversorgung einfach wie im Schaltplan unten gezeigt. Achte darauf, den GND-Pin des Arduino und der Stromversorgung miteinander zu verbinden.

Du kannst diese Konfiguration auch verwenden, wenn dein Servomotor eine andere Spannung benötigt, als der Arduino liefern kann, z. B. 6 V oder mehr. Das folgende Bild zeigt, wie man eine externe Stromversorgung zum Antrieb des Servos verwendet:

Anschlüsse für Servomotor mit externer Stromversorgung

Servomotor	Anschluss
Strom (rot)	5 V Stromversorgung
Masse (schwarz oder braun)	Masse der Stromversorgung und Arduino GND
Signal (gelb, orange oder weiß)	Pin 9 Arduino

Arduino Beispielcode

Zur Steuerung des Servomotors verwenden wir die Servo.h Bibliothek, die mit der Arduino IDE vorinstalliert ist. Mit dem Beispielcode unten kannst du die genaue Position des Servomotors steuern, außerdem enthält er Code, um den Servoarm automatisch hin und her zu schwenken.

Du kannst den Beispielcode über die Arduino IDE auf deinen Arduino hochladen. Im Folgenden erkläre ich, wie der Code funktioniert.

/* Servo motor with Arduino example code. Position and sweep. More info: https://www.makerguides.com/ */

// Include the servo library:
#include "Servo.h"

// Create a new servo object:
Servo myservo;

// Define the servo pin:
#define servoPin 9

void setup() {
  // Attach the Servo variable to a pin:
  myservo.attach(servoPin);
}

void loop() {
  // Tell the servo to go to a particular angle:
  myservo.write(90);
  delay(1000);
  myservo.write(180);
  delay(1000);
  myservo.write(0);
  delay(1000);

  // Sweep from 0 to 180 degrees:
  for (int angle = 0; angle <= 180; angle += 1) {
    myservo.write(angle);
    delay(15);
  }

  // And back from 180 to 0 degrees:
  for (int angle = 180; angle >= 0; angle -= 1) {
    myservo.write(angle);
    delay(15);
  }
  delay(1000);
}

Wie der Code funktioniert

Der erste Schritt ist, die benötigte Arduino-Bibliothek einzubinden. Diese Bibliothek findest du auch unter Sketch > Include Library > Servo.

// Include the servo library:
#include "Servo.h"

Als Nächstes musst du ein neues Objekt der Servo-Klasse erstellen. In diesem Fall habe ich den Servo ‚myservo‘ genannt, du kannst aber auch andere Namen verwenden. Beachte, dass du den Namen des Servos im restlichen Code ebenfalls ändern musst.

// Create a new servo object:
Servo myservo;

Danach habe ich definiert, an welchen Arduino-Pin der Servomotor angeschlossen ist.

// Define the servo pin:
#define servoPin 9

Die Anweisung #define wird verwendet, um einem konstanten Wert einen Namen zu geben. Der Compiler ersetzt alle Verweise auf diese Konstante durch den definierten Wert, wenn das Programm kompiliert wird. Also überall, wo du servoPinerwähnst, ersetzt der Compiler es beim Kompilieren durch den Wert 9.

Im Setup-Teil des Codes verknüpfen wir das Servo-Objekt, das wir erstellt haben, mit dem Pin, der den Servo steuert. Die attach() Funktion hat auch zwei optionale Parameter, die ich im Abschnitt unten bespreche.

void setup() {
  // Attach the Servo variable to a pin:
  myservo.attach(servoPin);
}

Winkel/Position steuern:

Im ersten Teil der loop-Funktion sagen wir dem Servomotor einfach, er soll sich auf einen bestimmten Winkel mit der Funktion write()bewegen. Beachte, dass du zwischen den Befehlen eine Verzögerung einbauen musst, damit der Servo Zeit hat, die eingestellte Position zu erreichen.

  // Tell the servo to go to a particular angle:
  myservo.write(90);
  delay(1000);
  myservo.write(180);
  delay(1000);
  myservo.write(0);
  delay(1000);

Geschwindigkeit steuern:

Im letzten Teil des Codes habe ich zwei for-Schleifen verwendet, um den Servomotor hin und her zu schwenken. Dieser Codeabschnitt kann auch nützlich sein, wenn du die Geschwindigkeit des Servomotors steuern möchtest. Durch Ändern des delay-Werts am Ende der for-Schleife kannst du die Geschwindigkeit des Servoarms anpassen.

  // Sweep from 0 to 180 degrees:
  for (int angle = 0; angle <= 180; angle += 1) {
    myservo.write(angle);
    delay(15);
  }
  // And back from 180 to 0 degrees:
  for (int angle = 180; angle >= 0; angle -= 1) {
    myservo.write(angle);
    delay(15);
  }

Warum dreht mein Servo nicht die vollen 0 – 180 Grad?

Wie im Einführungsteil besprochen, wird der Winkel der Ausgangswelle des Servomotors durch die Breite des elektrischen Pulses bestimmt, der auf das Steuerkabel angewendet wird. Allgemein entspricht eine Pulsbreite von etwa 1 ms der Minimalposition, 2 ms der Maximalposition und 1,5 ms 90° (Neutralstellung). Dies kann jedoch je nach Marke und sogar bei verschiedenen Servos derselben Marke leicht variieren. Das bedeutet, dass du die minimalen und maximalen Werte im Code an den verwendeten Servo anpassen musst.

Die Arduino Servo-Bibliothek macht es sehr einfach, den minimalen und maximalen Winkel des Servomotors einzustellen, indem du zwei optionale Parameter in der attach() Funktion angibst. Der erste Parameter ist die Nummer des Pins, an dem der Servo angeschlossen ist. Der zweite Parameter ist die Pulsbreite in Mikrosekunden (μs), die dem minimalen (0-Grad) Winkel des Servos entspricht. Der dritte Parameter ist die Pulsbreite in Mikrosekunden, die dem maximalen (180-Grad) Winkel des Servos entspricht.

Standardmäßig sind die minimalen und maximalen Pulsbreiten auf 544 und 2400 Mikrosekunden eingestellt. Diese Werte funktionieren für die meisten gängigen Servos, aber manchmal muss man sie leicht anpassen.

Ich empfehle, die minimalen und maximalen Werte in kleinen Schritten (10-20 Mikrosekunden) anzupassen, um den Servo nicht zu beschädigen. Wenn der Servoarm an die mechanischen Endanschläge stößt, erhöhe den minimalen Wert und verringere den maximalen Wert.

#define servoPin 9
int min = 480;
int max = 2500;
Servo myservo;

void setup() {
  myservo.attach(servoPin, min, max);
}

Einen Servomotor mit einem Potentiometer und Arduino steuern

Die Position eines Servomotors mit einem Potentiometer zu steuern ist sehr einfach und kann sehr nützlich sein, wenn du die Motorposition manuell einstellen möchtest. Wie im obigen Schaltplan zu sehen ist, ist der Servomotor wie zuvor angeschlossen. Der einzige Unterschied ist, dass ich ein Breadboard verwendet habe, um die Stromversorgung vom Arduino zu verteilen.

Das Potentiometer hat drei Pins, verbinde die äußeren Pins mit 5 V und GND. Der mittlere Pin des Potentiometers ist mit dem analogen Pin A0 des Arduino verbunden.

Servomotor mit Potentiometer Arduino Beispielcode

Der Beispielcode unten ermöglicht es dir, einen Servomotor mit einem Potentiometer zu steuern.

/* Servo motor with potentiometer and Arduino example code. More info: https://www.makerguides.com/ */

#include "Servo.h" // include the required Arduino library

#define servoPin 9 // Arduino pin for the servo
#define potPin A0 // Arduino pin for the potentiometer

int angle = 0; // variable to store the servo position in degrees
int reading = 0; // variable to store the reading from the analog input

Servo myservo; // create a new object of the servo class

void setup() {
  myservo.attach(servoPin);
}

void loop() {
  reading = analogRead(potPin); // read the analog input
  angle = map(reading, 0, 1023, 0, 180); // map the input to a value between 0 and 180 degrees
  myservo.write(angle); // tell the servo to go to the set position
  delay(15); // wait 15 ms for the servo to reach the position
}

Beachte, dass vor dem setup- und loop-Abschnitt des Codes eine neue Variable reading hinzugefügt wird und der Potentiometer-Eingangspin definiert ist.

Im loop-Abschnitt des Codes lesen wir den Wert vom analogen Pin A0 mit der Funktion analogRead().

reading = analogRead(potPin); // read the analog input

Arduino-Boards enthalten einen 10-Bit-Analog-Digital-Wandler (ADC), daher erhalten wir einen Wert zwischen 0 und 1023, abhängig von der Position des Potentiometers.

Da der Servomotor sich nur zwischen 0 und 180 Grad drehen kann, müssen wir die Werte mit der map() Funktion skalieren. Diese Funktion ordnet eine Zahl von einem Bereich in einen anderen um.

angle = map(reading, 0, 1023, 0, 180); // map the input to a value between 0 and 180 degrees

Zuletzt schreiben wir den Winkel an den Servomotor:

myservo.write(angle); // tell the servo to go to the set position
delay(15); // wait 15 ms for the servo to reach the position

Mehrere Servomotoren steuern

Mehrere Servos zu steuern ist genauso einfach wie nur einen, aber ich bekomme oft Fragen, wie man den Code anpassen kann. Deshalb habe ich unten ein einfaches Beispiel hinzugefügt.

Beachte, dass du eine externe Stromversorgung verwenden musst, um die Servos zu versorgen, da der Arduino nicht genug Strom liefern kann, um alle Motoren zu betreiben.

Für dieses Beispiel verwenden wir einfach mehr Arduino-Pins für die zusätzlichen Servos. Das bedeutet jedoch, dass du bei einem Arduino Uno auf 12 Servos begrenzt bist und möglicherweise nicht genug Pins für andere Komponenten übrig hast.

Eine andere Möglichkeit ist die Verwendung eines oder mehrerer PCA9685 PWM/servo drivers. Dieser Treiber ermöglicht es dir, 16 Servos mit nur 2 Pins des Arduino über I2C zu steuern. Adafruit verkauft diese auch in Form eines Arduino shield.

Da die Einrichtung dieser Servotreiber etwas komplizierter ist, werde ich dies in einem separaten Tutorial behandeln.

Arduino Beispielcode für mehrere Servos

Wie du im Beispiel unten siehst, musst du einfach mehrere Objekte der Servo-Klasse mit unterschiedlichen Namen erstellen. Du kannst jeden Servo ansprechen, indem du im setup- und loop-Abschnitt des Codes den richtigen Namen verwendest.

/* Arduino with multiple servos example code. More info: https://www.makerguides.com/ */

#include "Servo.h"

Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
Servo servo5;

void setup()
{
  servo1.attach(9);
  servo2.attach(10);
  servo3.attach(11);
  servo4.attach(12);
  servo5.attach(13);
}

void loop()
{
  servo1.write(0);
  servo2.write(0);
  servo3.write(0);
  servo4.write(0);
  servo5.write(0);
  delay(2000);
  servo1.write(90);
  servo2.write(90);
  servo3.write(90);
  servo4.write(90);
  servo5.write(90);
  delay(1000);
  servo1.write(180);
  servo2.write(180);
  servo3.write(180);
  servo4.write(180);
  servo5.write(180);
  delay(1000);
}

Servomotor-Spezifikationen

Unten findest du die Spezifikationen einiger der beliebtesten Servomotoren auf dem Markt. Der ursprüngliche Hersteller dieser Servomotoren ist Tower Pro Pte Ltd. , aber ähnliche Modelle sind auch von vielen anderen Anbietern erhältlich.

SG90 analog micro servo

Spezifikationen

Betriebsspannung	4,8 V
Gewicht	9 g
Haltemoment	1,8 kg/cm (4,8 V)
Getriebetyp	POM-Getriebesatz
Betriebsgeschwindigkeit	0,12 s/60° (4,8 V)
Betriebstemperatur	0 – 55 °C
Kosten	Check price

Abmessungen

MG90S digital micro servo

Spezifikationen

Betriebsspannung	4,8 V
Gewicht	13,4 g
Haltemoment	1,8 kg/cm (4,8 V), 2,2 kg/cm (6,6 V)
Getriebetyp	6061-T6 Aluminium
Betriebsgeschwindigkeit	0,10 s/60° (4,8 V), 0,08 s/60° (6,0 V)
Betriebstemperatur	0 – 55 °C
Kosten	Check price

Abmessungen

MG996R high torque digital servo

Spezifikationen

Betriebsspannung	4,8 – 6,6 V
Stromaufnahme im Leerlauf	10 mA
Stromaufnahme ohne Last	170 mA
Stromaufnahme beim Blockieren	1400 mA
Gewicht	55 g
Haltemoment	9,4 kg/cm (4,8 V), 11 kg/cm (6,0 V)
Getriebetyp	Metallgetriebe
Betriebsgeschwindigkeit	0,19 s/60° (4,8 V), 0,15 s/60° (6,0 V)
Betriebstemperatur	0 – 55 °C
Kosten	Check price

Abmessungen

Fazit

In diesem Tutorial habe ich dir gezeigt, wie man Servomotoren mit Arduino verwendet. Wir haben die Grundlagen der Steuerung von Position und Geschwindigkeit von Servomotoren betrachtet, wie man einen Servo mit einem Potentiometer steuert und wie man mehrere Servomotoren gleichzeitig steuert.

Wenn du mehr über andere Motortypen lernen möchtest, schau dir die folgenden Artikel an:

• Positional versus Continuous Servos
• 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
• How to control a Stepper Motor with Arduino Motor Shield Rev3
• How to control a stepper motor with A4988 driver and Arduino

Ich habe auch einen Artikel über How To Control Servo Motors using ESP32 , falls du mit einem ESP32-Mikrocontroller arbeiten möchtest.

Wenn du Fragen, Vorschläge hast oder denkst, dass in diesem Tutorial etwas fehlt, hinterlasse bitte einen Kommentar unten.