D02 Der 9G Servo-Motor
9G Servo Motor Blue

Physische Ausgabe

Ein gewöhnlicher Gleichstrommotor dreht sich kontinuierlich in eine Richtung und kann keine bestimmten Positionen ansteuern. Im Gegensatz dazu ist ein Servomotor in der Lage genaue Winkel anzusteuern und sie auch mit einer gewissen Kraft zu halten. Ein Roboterarm ist eine klassische Anwendung, in der Servomotoren große Dienste leisten. Auf sehr einfache Weise kann mit mehreren Servomotoren ein mehrachsiger Roboterarm realisiert werden.

Spezifikationen
- Signalart: digital
- Spannung: 3,3V – 5V
- Pinabstand: 2,54mm

Mit Servomotoren ist es sogar möglich, die Bewegungsgeschwindigkeit von einer Position zur anderen zu variieren. Normalerweise liegt der Drehwinkelbereich zwischen 0° und 180°. Die genaue Positionierung wird durch ein Regelsystem innerhalb des Servos erzeugt. Das Servo-Gehäuse beinhaltet mehrere elektronische Komponenten, die im Zusammenspiel eine gerichtete Bewegung erzeugen.

Der SG90 Micro Servo Motor von Keyestudio läuft mit 4,8-6V (typisch 5V) und kann sich um etwa 180 Grad drehen. Er verbraucht etwa 10mA im Leerlauf und 100mA bis 250mA bei Belastung. Somit dürfte eine Stromversorgung über den 5V-Ausgang des Arduino kein Problem darstellen. Falls du ein Servo hast, das mehr als 250mA verbraucht, solltest du eine separate Stromversorgung für dein Servo in Betracht ziehen.

Wir brauchen eine Bibliothek

Manche Elektronik-Module benötigen eine oder mehrere Bibliotheken, um zu funktionieren. Was ist eine Bibliothek und wozu brauchen wir sie? Eine Bibliothek reduziert für uns den Programmieraufwand. Dadurch sparen wir uns sehr viel Zeit. Außerdem wird unser Sketch weitaus übersichtlicher und im Ablauf stabiler. Du kannst dir eine Bibliothek so vorstellen, dass sie zusätzlicher Code ist, der vor uns versteckt wird und im Hintergrund arbeitet. Die Bibliothek kann sehr komplex aufgebaut sein, aber das ist kein Problem für uns, da wir auf die einzelnen Funktionen mit Schlüsselwörtern zugreifen. Wir müssen den komplizierten Programmablauf nicht verstehen, sondern für uns relevante Funktionen aufrufen. Das ist das Tolle an Bibliotheken. In der Programmierung kommen Wiederholungen von Programmteilen häufig vor. Um nicht jedes Mal das Rad von neuen zu erfinden, wird Programmcode in Bibliotheken ausgelagert, um sie wiederzuverwenden.

Bei der Installation der Arduino IDE werden automatisch bestimmte Libraries (Bibliotheken) mit installiert. Dazu gehört die Servomotor-Library, die wir nicht extra installieren müssen.

Die Funktionsweise

In einem handelsüblichen Hobby-Servomotor sind fast immer folgende Module beinhaltet: ein Gleichstrommotor mit einem Getriebe, eine Steuerschaltung und ein Rückkopplungsmechanismus (meist in Form von einem Potentiometer). Der Motor selbst hat eine hohe Drehgeschwindigkeit, dafür aber wenig Kraft (Drehmoment). Das Getriebe wandelt die hohe Geschwindigkeit in eine langsamere Drehbewegung um und erzeugt deutlich mehr Drehmoment. Dieser Vorgang wird Übersetzung genannt. Die Steuerelektronik des Servos empfängt vom Arduino getaktete Impulse, die die Winkelangabe beinhaltet. Die Impulse werden von der Servo-Elektronik in Winkelbewegungen interpretiert.

Der Motor wird mit gepulstem Strom an die vorbestimmte Position bewegt. Da der Potentiometer mit dem Motorgetriebe verbunden ist, läuft sie mit seiner Achse synchron. Er hat die Funktion, dem Steuerkreis eine Rückmeldung zu geben, an welcher Position sich momentan die Motorachse befindet. Sie dient zur Positionsüberwachung. Bei eventueller Abweichung wird eine Positionskorrektur vorgenommen. Die meisten Hobby-Servos besitzen einen dreipoligen Standardstecker mit den Leitungen für GND (Masse), VCC (5V) und Signal. Die Farbcodierung kann von Marke zu Marke variieren.

Der Funktionsablauf sieht folgendermaßen aus: Angenommen wir wollen, dass der Servomotor 90 Grad anfährt - also die Hälfte der maximal möglichen Drehbewegung. Das Arduino erzeugt nun ein PWM-Signal (Pulsweitenmodulation) mit einem sehr spezifischen Muster. Hierzu braucht das Arduino die Servomotor-Library, die die Ansteuerung erleichtert. Die Library wandelt Winkelgrade in entsprechende PWM-Signale um. Das Tastverhältnis des Signals ist insgesamt 20ms (Millisekunden) lang - die Pulsbreite ist auf 1ms bis 2ms verteilt. Das Tastverhältnis ist die kleinstmögliche Informationseinheit, die sich fortlaufend wiederholt. Die Pulsbreite ist ein HIGH-Signal innerhalb der 20ms.

Die Pulsbreite zwischen 1ms und 2ms entsprechen den Winkelgraden 0° bis 180°. Wird vom Arduino zur Servoelektronik eine Pulsbreite von 1,5ms gesendet entspricht das der Hälfte des Wertes und somit 90° (180°/2). Die interne Elektronik des Servos interpretiert die eingehenden Signale als Winkelgrade.

Ist der Impuls 1ms lang, ist der Servowinkel Null. Wenn der Impuls 2ms lang ist, steht das Servo auf 180 Grad. Die Dauer der Impulse kann je nach Hersteller variieren und kann zwischen 0,5ms für 0° und 2,5ms für 180° liegen.

Der Aufbau

Wichtig bei der Auswahl der Arduino-Pins für Servomotoren ist die Benutzung eines PWM-Pins. Beim Arduino Uno sind dies Pins, die mit einer Welle markiert sind: 11, 10, 9, 6, 5 und 3. Verbinde dein Arduino mithilfe der Jumper Wire mit dem Modul:

Der Minimal Sketch

Im Folgenden sehen wir die einfachste Form, die Servo-Library anzuwenden. Kopiere den unteren Sketch, füge ihn in die Arduino IDE ein und lade ihn auf das Arduino-Board rauf.

/********************************************************
D02 Der 9G Servo-Motor
Der Sweep Sketch
Mr Robot UXSD / www.mrrobotuxsd.com
*********************************************************/
#include < Servo.h> //Aufruf der Servo-Library

//Erstellen eines Servo-Objekts zur Steuerung eines Servos
Servo myservo; 


void setup() 
{
  //verbindet das Servo an Pin 9 mit dem Servo-Objekt
  myservo.attach(9);  
}


void loop() 
{
  myservo.write(0);  //dem Servo sagen, dass es die Position 0 anfahren soll
  delay(2000); //warte 2000ms, bis der Servo die Position erreicht hat
    
  myservo.write(180); //dem Servo sagen, dass es die Position 180 anfahren soll
  delay(2000);  //warte 2000ms, bis der Servo die Position erreicht hat
}

Wie bereits erwähnt, müssen wir die Servo-Library nicht installieren, da sie bereits integriert ist. Mit der Zeile #include <Servo.h> bekommen wir Zugriff auf die Servo-Funktionen.

SEHR WICHTIG: Leider kann ich aufgrund meines Highlight-Programms den Sketch nicht korrekt anzeigen. Damit der Code in der Arduino IDE funktioniert, musst du unbedingt beim Aufrufen der Bibliothek das Leerzeichen zwischen dem Pfeil links und dem Wort Servo.h entfernen. Das ganze sollte folgendermaßen aussehen:

#include <Servo.h>

Dem Servo-Objekt können wir eine eigene, frei wählbare Bezeichnung myservo zuordnen. Ab diesem Punkt benutzen wir myservo, um die Library anzusprechen.

#include < Servo.h>

Servo myservo;

Innerhalb von void setup() verbinden wir das Servo an Pin 9 mit dem Servo-Objekt.

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

Die Verwendung der Library ist relativ einfach. Die Wortfolge myservo.write gibt die Anweisung, den Servomotor anzusteuern. Die Zahl innerhalb der Klammern gibt den Winkelgrad an, die anfahren soll. Zunächst fährt der Servo die Winkelposition 0 an, wartet 2 Sekunden und dreht sich um 180° und wartet wieder. Die delay()-Funktionen sind nötig, damit der Servo die Zeit bekommt, die jeweilige Position anzufahren.

void loop() 
{
  myservo.write(0);  //dem Servo sagen, dass es die Position 0 anfahren soll
  delay(2000); //warte 2000ms, bis der Servo die Position erreicht hat
    
  myservo.write(180); //dem Servo sagen, dass es die Position 180 anfahren soll
  delay(2000);  //warte 2000ms, bis der Servo die Position erreicht hat
}

Der Sweep Sketch

Der Minimale Sketch hat einen Nachteil: Die Positionen werden mit maximaler Geschwindigkeit angefahren. Weitaus sanfter werden die Servo-Bewegungen mit for-Schleifen. Du kannst sogar bewusst die Geschwindigkeit kontrollieren. Der Sweep-Sketch lässt den Servo-Motor hin- und herdrehen.

/********************************************************
D02 Der 9G Servo-Motor B
Der Sweep Sketch
Quelle: https://www.arduino.cc/en/Tutorial/LibraryExamples/Sweep
Mr Robot UXSD / www.mrrobotuxsd.com
*********************************************************/
#include  //Aufruf der Servo-Library

//Erstellen eines Servo-Objekts zur Steuerung eines Servos
Servo myservo; 

int pos = 0; //Variable zum Speichern der Servoposition


void setup() 
{
  //verbindet das Servo an Pin 9 mit dem Servo-Objekt
  myservo.attach(9);  
}


void loop() 
{
  for (pos = 0; pos <= 180; pos += 1) //geht von 0° bis 180° in Schritten von 1 Grad
  { 
    myservo.write(pos);  //fahre an die Position die in der Variablen 'pos' gespeichert ist
    delay(15); //warte 15ms, bis der Servo die Position erreicht hat
  }

  for (pos = 180; pos >= 0; pos -= 1) //geht von 180° bis 0° in Schritten von 1 Grad
  { 
    myservo.write(pos);  //fahre an die Position die in der Variablen 'pos' gespeichert ist
    delay(15); //warte 15ms, bis der Servo die Position erreicht hat
  }
}

Im Gegensatz zum Minimal Sketch benötigen wir die Variable pos, um die unterschiedlichen Positionen zwischenzuspeichern, die wir innerhalb der beiden for-Schleifen berechnen.

int pos = 0; //Variable zum Speichern der Servoposition

Die erste for-Schleife zählt von der Zahl 0 bis 180 hoch. Sie zählt dabei in Einser Schritten (1,2,3,4,5,6,…) pos +=1. Wir könnten hier auch doppelt so schnell zählen und damit die Drehgeschwindigkeit erhöhen: pos +=2. Innerhalb des Schleifenkörpers sehen wir die bereits bekannte Funktion myservo.write(), mit der die Positionen angefahren werden. Bei jedem Schleifendurchgang wird für die Variable pos der aktuelle Wert eingetragen. Die kleine Verzögerung delay(15) sorgt dafür, dass der Servomotor mit der Programmierung mithält. Theoretisch können wir sehr schnelle Berechnungen anstellen, aber die Elektromechanik hat seinen eigenen Rhythmus und ist gewissen Trägheitsmomenten ausgesetzt.

for (pos = 0; pos <= 180; pos += 1) //geht von 0° bis 180° in Schritten von 1 Grad
  { 
    myservo.write(pos);  //fahre an die Position die in der Variablen 'pos' gespeichert ist
    delay(15); //warte 15ms, bis der Servo die Position erreicht hat
  }

In der zweiten Schleife gehen wir den umgekehrten Weg: Es wird von 180 bis auf die Zahl 0 runtergezählt. Auch hier wird bei jedem Schleifendurchgang der aktuelle Wert für pos aus dem Schleifenkopf in die Funktion myservo.write(pos) eingetragen.

for (pos = 180; pos >= 0; pos -= 1) //geht von 180° bis 0° in Schritten von 1 Grad
  { 
    myservo.write(pos);  //fahre an die Position die in der Variablen 'pos' gespeichert ist
    delay(15); //warte 15ms, bis der Servo die Position erreicht hat
  }

Hier gehts zur Einkaufsliste

Falls du die hier beschriebenen Elektronik-Module nicht hast kannst du sie in meiner Einkaufsliste finden. Warum ich selber hauptsächlich mit Modulen der Marke Keyestudio arbeite erläutere ich unter diesem Blog-Artikel.

In dieser Übersicht äußere ich Empfehlungen aller Art.

Hier kommst du wieder zur Übersicht aller Module.

D02 Der 9G Servo-Motor9G Servo Motor Blue