Welt der Fertigung
Sie sind hier: Startseite » Suchen » Lernen » Arduino

Servomotor via Arduino ansteuern

Bewegung per PWM-Signal

Ob Modellbau oder Steuerungstechnik – Servomotoren sind eine ideale Lösung, um Bewegung in Konstruktionen zu bringen. Zu deren Ansteuerung ist der Arduino bestens geeignet, da mit diesem Kleincomputer sich sehr einfach die dazu nötigen PWM-Signale erzeugen lassen.

Kein Modellflugzeug und kein Spielzeugroboter, die nicht über einen Servo verfügen. Diese sind in der Lage, sehr rasch innerhalb eines bestimmten Arbeitsbereichs unterschiedliche Winkelpositionen einzunehmen. Ein passendes PWM-Signal (PWM=Pulsweitenmodulation) ist alles, was dazu nötig ist, einen Servo in die gewünschte Position drehen zu lassen.

Das Wesen eines PWM-Signals sowie dessen Erzeugung mit dem Arduino wurde an anderer Stelle bereits erläutert und kann hier nachgelesen werden.

Das dort vermittelte Wissen zum Dimmen einer LED kann in identischer Weise zur Ansteuerung eines Servos genutzt werden. Dazu ist zunächst die Kenntnis dessen Kabelbelegung nötig.

Kabelbelegung eines Servos:

Die Farben der am Servo angebrachten Kabel folgen leider keine einheitlichen Norm. Folgende Paarungen sind jedoch häufig anzutreffen:

Schwarz oder Braun = Masse (GND)
Rot = +5V
Orange, Gelb oder Weiß = PWM-Signal

Dieses Wissen erlaubt es, die Kabel korrekt zu handhaben. Ist der passende Gegenstecker nicht zur Hand, um den Servo mit dem Arduino zu verbinden, so kann man sich auch mit selbst gebauten Drahtklemmen behelfen, um eine Verbindung zum Stecker herzustellen.

Servomotoren arbeiten mit der Pulsweitenmodulation (PWM). Dabei hat der High-Pegel eine Pulsbreite zwischen 0 und 2 Millisekunden, während der Low-Pegel den Rest bis zu einem Gesamtwert von 20 Millisekunden ausmacht. Ist der Low-Pegel beispielsweise 1 Millisekunde aktiv, so muss der Low-Pegel exakt 19 Sekunden Low sein, damit sich eine Gesamtdauer von 20 Millisekunden ergibt.

Folgendes Diagramm soll dies verdeutlichen:

Verbindung des Servos mit dem Arduino:

Folgendes Bild zeigt, wie ein Servo mit dem Arduino verbunden wird. Dabei ist wichtig, leistungsstarke Exemplare nicht direkt über den Arduino mit Strom zu versorgen, sondern dafür eine externe Quelle zu nutzen.

Eine Skizze verdeutlicht präziser, wie der Servo am Arduino anzuschließen ist:

Wie man sieht, ist es bei dieser Ansteuerung nicht zwingend nötig, die PWM-Pins zu nutzen. Auch ein Digitalanschluss eignet sich zur Ansteuerung.

Wird der Servo an einem Digitalanschluss mit dem Arduino verbunden, so muss zur Ansteuerung der digitalWrite-Befehl genutzt werden.

Das Programm zum Ansteuern des Servos sieht demnach wie folgt aus:

void setup() {
pinMode(13, OUTPUT); // initialisiert den digitalen Pin 13 als Ausgang.
}
void loop() {
digitalWrite(13, HIGH); // Pin 13 auf High
delay(1); // 1 ms warten
digitalWrite(13, LOW); // Pin 13 auf Low
delay(19); // 19 ms warten, ergibt 20 ms Takt
}

Dieses Programm soll bewirken, dass die Welle des Servomotors eine +90 Grad-Stellung einnimmt. Jede Abänderung des Signals um plus eine Millisekunde sollte der Theorie nach eine Neupositionierung des Servos um 90 Grad gegen den Uhrzeigersinn bewirken. Zu beachten ist, dass die Periodendauer stets 20 Millisekunden betragen muss. Die Zeitdauer für das Low-Signal muss demnach jeweils entsprechend angepasst werden.

Folgendes Bild soll den Sachverhalt verdeutlichen:

Wie das nachfolgende Bild zeigt, ist das jedoch nicht der Fall. Vielmehr wird eine Stellung eingenommen, die deutlich über +90 Grad liegt. Die Erläuterung für dieses Problem folgt etwas weiter unten.

Ein leicht abgewandeltes Programm mit 2 ms High-Signal und 18 ms Low-Signal bewirkt, dass der Servo eine 0-Grad-Stellung einnimmt.

Nach der Logik müsste nun eine Low-Signal von 3ms sowie ein Low-Signal von 17 ms eine Positionierung der Welle des Servos auf der -90 Grad-Stellung erfolgen.

Doch leider wird nur eine Stellung eingenommen, die grob einer +60 Grad-Stellung entspricht.

Dieses Verhalten zeigt, dass mechanische Ungenauigkeiten verhindern, dass die Theorie mit der Praxis übereinstimmt. Ist eine exakte Übereinstimmung der Befehle mit der Winkellage gewünscht, bleibt nur die Lösung, das Gehäuse entsprechend der Abweichungen in den Konstruktionsaufbau einzubauen, damit die Schwenkwinkel den programmierten Befehlen entsprechen.

Servo an PWM-Pin:

Wird der Servo an einen PWM-fähigen Pin angeschlossen, so ergibt sich ein identisches Verhalten, solange der digitalwrite-Befehl genutzt wird. Wird jedoch stattdessen der analogwrite-Befehl genutzt, so reagiert der Servo mit einem abweichenden Verhalten: Er möchte seine Drehachse endlos im Uhrzeigersinn drehen. Das funktioniert jedoch nur, wenn die Endlagenverriegelung entfernt wurde oder abgebrochen ist.

Das Programm ist sehr kurz:

void setup() {
pinMode(11, OUTPUT); // initialisiert den digitalen Pin 11 als Ausgang.
}
void loop() {
analogWrite(11,2); // Pin, Zykluszeit
}

Hinweis zum analogWrite-Befehl:

Die erste Zahl bezeichnet den Pin, auf den geschrieben wird, die zweite Zahl definiert eine Zykluszeit. Dieser Wert darf eine ganzzahlige Zahl zwischen 0 und 255 sein.

Externe Energieversorgung:

Große Servos dürfen nicht direkt über den Arduino mit Strom versorgt werden, da dieser durch die Stromlast sonst zerstört wird. Daher ist eine externe Stromversorgung einzurichten, die wie folgt aussehen kann:

Für den realen Versuchsaufbau kann hilfsweise eine Steckplatine verwendet werden, um rasch eine Verbindung zwischen Batteriepack und Arduino aufzubauen.

Um mehrere Servos mit externer Energie zu versorgen, muss nur eine einfache Anpassung vorgenommen werden.

Servoansteuerung per Potentiometer:

Während die Ansteuerung eines Servos per Zeitsignal ideal für Automatisierungszwecke ist, eignet sich die Ansteuerung über ein Potentiometer besonders gut für die manuelle Positionierung eines Servos. Wichtig ist, dass die Steuerleitung des Servos in jedem Fall auf einen PWM-Pin geführt wird. Dazu eignen sich beispielsweise die Pins 9, 10 und 11. Das Potentiometer muss an einen Analog-In-Pin des Arduino, beispielsweise den Pin 0, angeschlossen werden.

Selbstverständlich darf nur ein kleines Servo mit geringer Lastaufnahme direkt an den Arduino angeschlossen werden. Größere Servos müssen, wie bereits erwähnt, über eine separate Stromversorgung betrieben werden. Dies könnte wie folgt aussehen:

Zwar ist es möglich, die Ansteuerung eines Servos ohne Nutzung einer Arduino-Bibliothek zu programmieren, doch ist der Aufwand dazu nicht unerheblich. Aus diesem Grund wird dazu geraten, die Bibliothek ›Servo.h‹ einzusetzen. Diese wird, wie alle Bibliotheken, über das vorangestellte Doppelkreuz # einem Sketch hinzugefügt.

Das dazugehörende Programm könnte wie folgt aussehen:

#include <Servo.h>

Servo ServoNr1; // Servo-Objekt anlegen
int analogPin=0; // Analoger Pin
int Potiwert; // Variablenspeicher für Potentiometerwert


void setup() {
ServoNr1.attach(11); // Servo mit Pin 11 verbinden
}

void loop() { // Endlosschleife Start
Potiwert=map(analogRead(analogPin),0,1023,0,179);
ServoNr1.write(Potiwert); // Servo ansteuern
}

Ein Aufbau könnte wie folgt aussehen:

Beobachtung:

In seltenen Fällen ist ein unruhiges Verhalten des Servos festzustellen. Im Netz gibt es unterschiedliche Empfehlungen, das „Zittern“ von Servos zu unterbinden. Interessierte Leser sollten sich diesen Quellen zuwenden, wenn saubere Positionieraufgaben gefragt sind. Oft genügt es jedoch schon, einen anderen Servo zu nutzen, da das „Zittern“ durchaus von Fertigungsmängeln herrühren kann.

Servo über direkte Gradeingabe steuern:

Wie vorhin gesehen, liest der map-befehl die Stellung des Potentiometers aus und wandelt den erhaltenen Wert in einen Gradwert um. Natürlich ist es auch möglich, dem Servo direkt mitzuteilen, wohin sich seine Drehachse drehen soll, indem der Gradwert direkt als Integerzahl in den Befehl ›ServoNr1.write(x)‹ eingeben wird. Anstelle des Platzhalters „x“ ist hier die gewünschte Gradzahl einzugeben.

Der dazugehörige Sketch könnte wir folgt aussehen:

#include <Servo.h>

Servo ServoNr1; // Servo-Objekt anlegen

void setup() {
ServoNr1.attach(11); // Servo mit Pin 11 verbinden
}

void loop() {
ServoNr1.write(30); // Servo direkt mit Gradwert ansteuern
}

Diese Möglichkeit lässt es natürlich zu, mehrere Taster einzusetzen, um die Achse des Servos rasch in eine bestimmte Position zu lenken.

Die dazu nötige Verschaltung des Servos muss wie folgt vorgenommen werden:

Hinweis: Die 10k-Widerstände dienen dazu, stets einen sauberen LOW- beziehungsweise HIGH-Pegel zu erzeugen. Sie eliminieren Hürden, die etwa durch statische Energie oder hohe Luftfeuchtigkeit hervorgerufen werden.

Das dazugehörige Programm (Sketch) könnte wie folgt lauten:

#include <Servo.h>

Servo ServoNr1; // Servo-Objekt anlegen
int Winkel=180; // Startwinkel
int Taster1Pin=2; // Taster 1 wurde Pin 2 zugeordnet
int Taster2Pin=3; // Taster 2 wurde Pin 3 zugeordnet
int Taster3Pin=4; // Taster 3 wurde Pin 4 zugeordnet
int Taster4Pin=5; // Taster 4 wurde Pin 5 zugeordnet

void setup() {
ServoNr1.attach(11); // Servo mit Pin 11 verbinden
pinMode (Taster1Pin, INPUT); //Pin 2 als Eingang definieren
pinMode (Taster2Pin, INPUT); //Pin 3 als Eingang definieren
pinMode (Taster3Pin, INPUT); //Pin 4 als Eingang definieren
pinMode (Taster4Pin, INPUT); //Pin 5 als Eingang definieren
}

// Die Loop-Funktion sorgt für eine Endlosschleife

void loop() {
if (digitalRead(Taster1Pin)==HIGH) //Abfrage Taster 1
{
Winkel=0;
//ServoNr1.write(Winkel);
}
else {
}
if (digitalRead(Taster2Pin)==HIGH) //Abfrage Taster 2
{
Winkel=60;
}
else {
}
if (digitalRead(Taster3Pin)==HIGH) //Abfrage Taster 3
{
Winkel=90;
}
else {
}
if (digitalRead(Taster4Pin)==HIGH) //Abfrage Taster 4
{
Winkel=180;
}
else {
}
ServoNr1.write(Winkel);
}

Wie die Animation zeigt, funktioniert die Ansteuerung des Servos mithilfe der Bibliothek ›Servo.h‹ perfekt und sehr einfach.

Zu beachten ist, dass durch eine ungünstige Perspektive der Bilder der Eindruck erweckt wird, der Servo würde die gewünschten Winkel nicht exakt anfahren. Dies ist jedoch nicht der Fall.

Zudem ist zu beachten, dass größerer Servos, wie bereits erwähnt, unbedingt mit einer externen Stromversorgung zu betreiben sind, da der Arduino durch deren hohen Strombedarf beschädigt werden kann.

War dieser Artikel für Sie hilfreich?

Bitte bewerten Sie diese Seite durch Klick auf die Symbole.

Zugriffe heute: 1 - gesamt: 223.