Einen Servo am Arduino anschließen und verwenden

Früher oder später kommt jeder Maker an den Punkt, an dem er ein Projekt mit einem Servo-Motor bauen möchte – z.B. für einen Zeiger oder für einen Roboterarm. In diesem Tutorial lernst du, wie du einen Servo am Arduino anschließt und steuerst. Du erfährst, wie du den kleinen Motor mit einem Poti verwendest, Sensordaten damit visualisierst und was es bei der Stromzufuhr zu beachten gilt.

Was ist ein Servo?

Zunächst ein paar Worte darüber, was ein Servo eigentlich ist: Hierbei handelt es sich um einen Motor, der nicht einfach nur anfängt zu laufen, sondern den du auf eine bestimmte Position drehen kannst. Das heißt, du kannst ihm einen Winkel von 0° bis 180° zuweisen und damit z.B. einen am Servo montierten Zeiger im Halbkreis drehen lassen.

Die Bibliothek Servo.h

Damit die Steuerung für dich so einfach wie möglich ist, gibt es die Bibliothek Servo.h – die in der Regel bereits vorinstalliert ist, sodass du sie ohne Umwege in deinem Sketch einbinden kannst. Mit ihr kannst du bis zu 12 Motoren an einem Arduino verwenden (am Arduino Due sogar 60).

Binde die Bibliothek am Anfang deines Sketchs wie folgt ein:

#include <Servo.h>

Zwei Funktionen der Bibliothek benötigst du immer wieder, wenn du mit Servos arbeitest:

• attach(pin) – Hier legst du einmalig den Pin fest, an dem dein Servo-Motor angeschlossen ist
• write(angle) – Damit „fährst“ du den Servo an den gewünschten Winkel (angle)

Im Verlauf dieses Tutorials schauen wir uns diese Funktionen genauer an. Weitere Funktionen dieser Bibliothek lernst du in der Arduino-Referenz kennen.

Die Minimalschaltung

Für die allerersten Gehversuche reicht es, wenn du deinen Servo wie folgt mit deinem Arduino verbindest. Für das Signal (orange) kannst du natürlich einen Digitalpin deiner Wahl verwenden. In den folgenden Sketches verwenden wir jedoch immer Pin 8.

Hinweis: Jeder Servo hat drei Kabel: Strom (5V), Masse (GND) und Signal. Diese haben jedoch je nach Modell eine unterschiedliche Reihenfolge. Vergewissere dich immer, dass du alles richtig angeschlossen hast, bevor du ihn mit Strom versorgst.

Der erste Sketch

Auch hier halten wir alles so einfach wie möglich. Kopiere dir den folgenden Sketch und lade ihn auf deinen Arduino.

#include <Servo.h>

Servo myServo;

void setup() {
  myServo.attach(8);
}

void loop() {
  myServo.write(0);
  delay(2000);
  myServo.write(90);
  delay(2000);
  myServo.write(180);
  delay(2000);
  myServo.write(90);
  delay(2000);
}

Ganz oben im Sketch bindest du die Bibliothek Servo.h ein. Danach erstellst du ein Objekt mit dem Namen myServo.

Im Setup verknüpfst du mithilfe der Funktion attach() den Digitalpin mit diesem Objekt – oder einfacher gesagt, du teilst deinem Arduino mit, dass dein Servo am Pin 8 hängt.

Im Loop steuerst du mit deinem Motor nun verschiedene Winkel mit der Funktion write() an. Du beginnst bei 0° und wartest zwei Sekunden. Danach drehst du weiter auf 90°, dann auf 180°, zurück auf 90° – und wieder von vorne.

Einen Kondensator verwenden

Ein Servo benötigt recht viel Strom, vor allem zu Beginn einer Bewegung. Das kann zu einem Spannungsabfall führen, der zu ungewünschten Ergebnissen bis hin zu einem Reset des Arduinos führen kann.

Um dem vorzubeugen, kannst du einen Kondensator in die Stromversorgung des Motors einbauen, wie du hier sehen kannst:

Der Kondensator mit einer Kapazität von mindestens 470µF speichert Energie, die der Servo neben jener vom Arduino nutzen kann. Damit kannst du den Spannungsabfall etwas verringern.

Hinweis: Wenn du einen Elektrolytkondensator (Elko) verwendest, achte unbedingt auf die richtige Polarität: Die Seite mit dem hellen Strich (s. Screenshot oben) muss an Erde (GND). Wenn du die Seiten vertauschst, kann der Kondensator explodieren!

Wenn auch ein Kondensator nicht hilft, kannst du deinen Servo an seinen eigenen Stromkreis anschließen, der vom Arduino (und weiteren dort angeschlossenen Teilen) unabhängig ist.

Den Servo mit einem Poti steuern

Jetzt gehen wir noch einen Schritt weiter: Du steuerst deinen Motor mit einem Poti. Ziel ist es hierbei, dass er sich analog zu den Bewegungen des Potentiometers dreht.

Füge also deinem Aufbau ein Poti wie folgt hinzu.

Kopiere dir anschließend den folgenden Sketch und lade ihn auf deinen Arduino:

#include <Servo.h>

int servoPosition;
int potiValue;

Servo myServo;

void setup(){
  myServo.attach(8);
}

void loop(){
  delay(10);
  potiValue = analogRead(A0);
  servoPosition = map(potiValue, 0, 1023, 0, 180);
  myServo.write(servoPosition);
}

Neu in diesem Sketch sind zwei Variablen. In servoPosition speicherst du den Winkel, den der Servo ansteuern soll. In potiValue steht der aktuelle Wert des Potis, den du so ausliest und speicherst:

 potiValue = analogRead(A0);

Jetzt wird es interessant: Den Winkel des Servos bestimmst du mit der Funktion map(). Hier „mappst“ du den Wert, den dein Poti ausgibt (potiValue) auf den entsprechenden Winkel des Servos (servoPosition). Hierfür benötigst du sowohl für den Poti als auch für den Motor den Minimal- und Maximalwert. Für den Poti sind das 0 und 1023 – für den Servo 0 und 180 (Grad). Der Analogeingang des Arduinos liefert übrigens genau 1024 verschiedene Werte – aber da die Zählung bei 0 beginnt, ist 1023 der höchste davon.

 servoPosition = map(potiValue, 0, 1023, 0, 180);

Zuletzt bewegst du den Motor auf die errechnete Position:

 myServo.write(servoPosition);

Steuerung mit einem Sensor

Noch ein letztes Experiment: Diesmal lässt du einem Temperatursensor den Servo steuern. Hier verwenden wir einen einfachen TMP36, aber du kannst natürlich auch jeden anderen Temperatursensor verwenden.

Du ahnst sicher schon, worauf das Ganze hinausläuft – genau, ein Analogthermometer. Ersetze den Poti zunächst einfach durch den TMP36:

Im Sketch musst du ebenfalls nicht viel verändern. Wir haben nur den Namen der Variablen und die Funktion map() angepasst – und eine Ausgabe im Seriellen Monitor ergänzt, die du gleich noch brauchen wirst:

#include <Servo.h>

int servoPosition;
int temp;

Servo myServo;

void setup() {
  myServo.attach(8);
  Serial.begin(115200);
}

void loop() {
  delay(10);
  temp = analogRead(A0);
  Serial.println(temp);
  servoPosition = map(temp, 20, 358, 0, 180);
  myServo.write(servoPosition);
}

Wie du in der Funktion siehst, haben wir für den TMP36 einen Bereich von 20 bis 358 angegeben. Das deckt ungefähr den kompletten Messbereich des Sensors ab – von -40°C bis 125°C. Achte darauf, dass du hier einen für deinen Sensor passenden Wertebereich angibst.

Den passenden Wertebereich finden

Und genau hier kommt die Zeile Serial.println(temp) ins Spiel: Öffne den Seriellen Monitor (bei 115200 Baud) und beobachte, welche Rohwerte dein Sensor tatsächlich ausgibt. Bei Zimmertemperatur wirst du irgendwo um die 140 landen.

Du merkst schon: Mit dem großen Bereich von 20 bis 358 bewegt sich dein Zeiger im Alltag kaum. Deshalb lohnt es sich, nur den Ausschnitt zu mappen, der dich wirklich interessiert. Halte den Sensor einmal kurz zwischen die Finger und einmal an etwas Kaltes – die beiden Werte, die du im Seriellen Monitor abliest, sind ein guter Start für dein Minimum und Maximum:

 servoPosition = map(temp, 130, 160, 0, 180);

Übrigens, wenn du nicht die volle Bandbreite des Servos nutzen möchtest, also z.B. den Zeiger nur zwischen 20° und 160° drehen lassen willst, kannst du das natürlich ebenfalls in der Funktion anpassen.

Möchtest du ein reales Beispiel? Dann wirf einen Blick in unser Analogthermometer. Oder auf das Code-Schloss mit Folientastatur.

Und das soll es gewesen sein. 🙂 Du weißt jetzt, wie du einen Servo-Motor am Arduino anschließt und ihn auf verschiedene Arten und Weisen steuern kannst. Viel Spaß bei deinen weiteren Experimenten!