Tinkercad Übung 16

Die Servo-Bibliothek

In dieser Übung steuerst du die Position eines Servomotors mit einem Potentiometer

Empfohlenes Vorwissen: Bedienung Tinkercad Circuits, Potentiometer, PWM-Signal, Wertebereich einer Variablen, constrain(), map()
Neue Inhalte: Servo nach Datenblatt anschließen und Servo-Bibliothek benutzen

Schritt 1 - Demo-Entwurf öffnen und inspizieren

Baue die folgende Schaltung auf oder kopiere den Demo-Entwurf.
https://www.tinkercad.com/things/crhhhYYCkz6-kkg-robotik-ubung-16-starter

Abbildung 1 - Potentiometer, Servo und Oszilloskop

In der Schaltung sind ein Servomotor und ein Potentiometer an einen Arduino angeschlossen. Die Schaltung kommt dir vielleicht noch aus Übung 1 bekannt vor. Potentiometer hast du schon in Übung 2 und Übung 13 kennen gelernt.

Ein Servomotor ist ein Spezial-Motor, dem man eine bestimmte Stellposition (als Winkel in Grad) vorgeben kann und er fährt diese Position dann an. Die Geschwindigkeit kann man nicht einstellen und ein Servomotor hat auf keinen vollen Umlauf, d.h. es gibt beim Minimal- und Maximalwinkel einen Anschlag. Weiter kann der Servo nicht drehen. Servos sind praktisch für jedwede Art von Hebel - z.B. bei einem Modellflugzeug oder -boot das Längsruder stellen. Das würde man an dem weißen Kreuz montieren (z.B. über einen Baudenzug).

So sieht ein Servomotor in der Realität aus:

Abbildung 2 - Vergleich Servomotor in der Simulation und in der Realität

Um herauszufinden, wie man den Servomotor anzuschließen hat, schauen wir mal schnell ins Datenblatt. Ein Beispiel-Datenblatt kannst du hier herunterladen:
https://www.dropbox.com/s/234pe53qpr90une/SG90%20Servo%20Motor%20Datasheet.pdf?dl=0

Abbildung 3 - Ausschnitt aus dem Servo-Datenblatt

Der Servo muss vom Arduino mit 5V versorgt werden. Dafür schließt du an:

Vcc an 5V (Vcc ist das Kürzel für "Versorgungsspannung", also Plus-Pol)
Ground an GND (Ground steht wie immer für den Minus-Pol)

Der Servo braucht noch ein Datensignal worüber wir ihm mitteilen, welche Position er anfahren soll. Das Datenblatt spricht von einem PWM-Signal. Es muss also ein PWM-fähiger Pin am Arduino (markiert mit Tilde-Symbol ~) verwendet werden. PWM-Signale hast du in Übung 11 kennen gelernt.

Die Farbkodierung der Leitungen ist bei den meisten Servos immer orange, rot, braun. Es gibt aber auch andere Stecker-Belegungen. Suche mal in Tinkercad nach "Mikro-Servo". Da gibt es noch einen anderen. Der benutzt andere Farben und auch eine andere Reihenfolge am Stecker.

Die Position des Servos wird mit einem PWM-Signal gestellt. Die Pulsweite (siehe Übung 15) bestimmt hierbei die Position.

Auszug aus dem Datenblatt:

Abbildung 4 - Servo PWM Signal

Zu deutsch teilt uns das Datenblatt mit, dass zur Ansteuerung ein PWM-Signal mit Periode 20 Millisekunden (50 Hertz Frequenz) verwendet werden muss. Die Pulsweite bewegt sich zwischen

1 Millisekunde: -90°, ganz nach links gedreht
2 Millisekunden: +90°, ganz nach rechts gedreht

Der Servo kann also nur maximal 180° drehen; dann ist Anschlag.

Die Schaltung sieht am Ende so aus:

Abbildung 5 - Schaltplan Potentiometer mit Servo

Schritt 2 - Servo Bibliothek importieren

Jetzt könnten wir uns wie in Übung 15 hinsetzen und das PWM-Signal selber programmieren. Glücklicherweise gibt es aber für die meisten Bauteile, die man an einen Arduino anschließen kann, schon fertige Programmie, die das für uns machen und wir müssen sie nur in unser Programm einbauen. Diese bereits fertig programmierten Funktionen nennt man Bibliotheken (englisch: Libraries). Alle Arduino-Befehle, die du bisher benutzt hast, stammen aus der Arduino-Bibliothek. Sie vereinfachen dir die Handhabung des Mikrocontrollers, der normalerweise wesentlich schwieriger zu programmieren wäre.

Willst du eine Bibliothek benutzen, muss du sie in dein Programm importieren. In der Simulation, öffne den "Code" Editor, klicke auf die Schaltfläche mit dem Kisten-Symbol, suche "Servo" und bestätige mit "Einschließen".

Abbildung 6 - Bibliothek importieren

Das funktioniert bei einem echten Arduino ein wenig anders (komplizierter).

Dir ist vielleicht aufgefallen, dass es in deinem Programm nun eine neue Zeile gibt:

#include <Servo.h>

Sie beginnt mit einem Hashtag (#), ist also ein Präprozessor-Makro. Diese hast du in Übung 7 kennen gelernt. #include ist kein echter C++ Befehl, sondern wird vor dem Übersetzen ausgeführt. Irgendwo gibt es die Datei "Servo.h", die den Programmcode enthält, den wir benutzen wollen. #include kopiert den Inhalt dieser Datei in unser Programm hinein. Am Ende ist alles eine große Programmcode-Datei. Da es aber sehr unübersichtlich wäre, alle Bibliotheken in unser Programm hineinzukopieren, gibt es das #include Makro, was dies automatisch vor jedem Übersetzen für uns übernimmt und alles bleibt schön versteckt in anderen Programmcode-Dateien.

Tipp: Auf diese Art kannst du dir auch dein eigenes Programm in mehrere Dateien aufteilen, um bei größeren Programmen den Überblick zu behalten.

Jetzt können wir alles benutzen, was in der Servo-Bibliothek bereits für uns fertig programmiert wurde. Schau doch mal in die Arduino-Referenz, was die Servo-Bibliothek für Befehle beherrscht:
https://www.arduino.cc/en/Reference/Servo

Übrigens: Um die Arduino-Befehle (digitalWrite() usw.) nutzen zu können, müsste man normalerweise Arduino.h importieren, da diese nicht zur C++ Programmiersprache gehören, sondern von den Arduino-Entwicklern dazugebaut wurden.

#include <Arduino.h>

Das passiert aber automatisch und so spart man sich die Zeile.

Schritt 3 - Servo Bibliothek konfigurieren

Damit die Servo Bibliothek weiß, an welchem Pin sich der zu steuernde Servo befindet, muss dies konfiguriert werden. Ändere den Programmcode so ab, dass er aussieht wie folgt:

// Bibliothek "Servo" benutzen

#include <Servo.h>

// Bibliotheks-Objekt "mein_servo" erzeugen

Servo mein_servo;

// Konstanten:

const int PIN_SERVO = 9; // 9 ist PWM-fähig

void setup() {

// Servo-Bibliothek steuert Servo an Pin 9

mein_servo.attach(PIN_SERVO);

}

Die Prozedur, mit der man einen Servo konfiguriert, heißt attach(pin). Das ist aber bei jeder Bibliothek anders und muss man in der Referenz nachlesen. Das Konstrukt mit dem Punkt kommt dir sicherlich bekannt vor, denn wir haben es schon bei einer anderen Bilbiothek verwendet:

Serial.begin()

Serial.println()

Serial.print()

Serial.available()

Serial.read()

Stelle dir Serial wie einen Container vor, der sowohl Variablen (also Daten) als auch Funktionen/Prozeduren enthält. Auf die kann man mit dem Punkt zugreifen.

Wer objektorientiert bewandert ist: Serial ist eine Klasse und dessen Funktionen sind Klassenmethoden (statische Methoden).

Jetzt ist es allerdings möglich mehrere Servos an einen Arduino anzuschließen. Deswegen müssen wir erstmal ein Servo-Objekt erzeugen. Den Namen dafür kann man frei wählen. Die Schreibweise

Servo mein_servo;

kommt dir sicherlich auch bekannt vor: Es sieht ein bisschen so aus als wäre Servo der Datentyp und mein_servo der Name einer Variable. Auf diese Art können wir nun mehrere Ableger der Servo-Bibliothek erzeugen, z.B.

Servo mein_servo1;

Servo mein_servo2;

Servo mein_servo3;

Deswegen rufen wir die attach()-Funktion auch nicht auf Servo aus, sondern auf mein_servo. Wir benötigen aber erstmal nur einen Ableger.

Für objektorientiert bewanderte: Servo ist die Klasse, mein_servo das Objekt (die Instanz) und attach(pin) eine Instanztmethode.

Die meisten Bibliotheken funktionieren so wie Servo.

Mit #include importieren.
Ableger (Objekt) erzeugen.
Objekt konfigurieren (meist in setup())
Objekt benutzen (meist in loop())

Schritt 4 - Servo stellen

Als letztes fehlt uns noch der Befehl, der den Servo anweist eine bestimmte Position anzufahren. Dieser heißt

// Winkel in Grad zwischen 0° und 179°, also 180 mögliche Winkel

mein_servo.write(winkel);

Schaue dir diesen Befehl in der Arduino-Referenz an:
https://www.arduino.cc/en/Reference/ServoWrite

Füge den write()-Befehl entweder in setup() oder loop() hinzu und probiere in paar Winkel aus. Starte die Simulation und beobachte welche Position der Servo anfährt. Probiere Winkel außerhalb des Wertebereichs (< 0° oder > 179°) aus.

Um den Servo mit dem Potentiometer stellen zu können, muss jetzt nur noch der Potentiometer-Pin als Eingang konfiguriert und ausgelesen werden. Den Potentiometer-Wert übergibst du als Winkel an mein_servo.write().

Lösungsvorschlag: https://www.tinkercad.com/things/aH3GQDpYrpj-kkg-robotik-ubung-16-servo-ansteuern

Setze das so um, starte die Simulation und drehe langsam am Potentiometer, um dem Servo Zeit zu geben nachzustellen. Was beobachtest du (auch im Oszilloskop)?

Abbildung 7 - Servo mit Potentiometer steuern

Schritt 5 - Datenbereich einhalten

Dir ist bestimmt aufgefallen, dass wir es mit einem Überlauf zu tun haben. Da der Servo eh nur Winkel zwischen 0° und 179° stellen kann, ergibt es keinen Sinn diesen Winkel mit einem großen Wertebereich zu übergeben. Der Winkel ist vom Datentyp byte, kann also nur Zahlen zwischen 0 und 255 abspeichern. Darunter gibt es einen Unterlauf und darüber einen Überlauf. Das hatten wir in Übung 12 und Übung 13 schon einmal.

Der analoge Messwert am Potentiometer kann aber Werte zwischen 0 und 1023 annehmen. Aus diesem Grund springt der Servo auch ungefähr in der Mitte der Potentiometer-Umdrehung wieder zurück. In Übung 12 und Übung 13 hast du Möglichkeiten kennen gelernt wie du mit dieser Situation umgehst.

Verändere das Programm so, dass man mit dem Potentiometer den Servo stellen kann, es dabei aber keinen Überlauf des Wertebereiches vom Servo-Winkel gibt. Du kannst diese Umrechnung vom analogen Potentiometer-Messwert zum Servo-Winkel auch in eine eigene Funktion auslagern.

Das kann zum Beispiel so aussehen:

Abbildung 8 - Servo dreht nicht über 179°

Der Lösungsvorschlag implementiert die Funktion zu_winkel(potentiometer_wert), die den potentiometer_wert (0..1023) auf 0°..255° herunterskaliert und zurück gibt. Jetzt gibt es zwar keinen Überlauf mehr, aber der Servo hört bei Winkel 179° einfach auf zu drehen (ist am Anschlag), obwohl das Potentiometer weiter gedreht wird.

Versuche doch mal ein Programm zu schreiben bei dem der Servo wirklich exakt in der Position steht wie der Drehknopf des Potentiometers, d.h.

Potentiometer ist nach rechts gedreht (90°) → Servo stellt 90°
Potentiometer ist nach oben gedreht (197°) → Servo stellt 179°
usw.

Lösungsvorschlag: https://www.tinkercad.com/things/ehAxR0hcWDM-kkg-robotik-ubung-16-richtiger-wertebereich

Abbildung 9 - Servo stellt genau die Position des Potentiometer-Drehknopfes ein

Zusammenfassung

In dieser Übung hast du das Datenblatt eines Servomotors kennen gelernt. Du weißt wie du eine Programm-Bibliothek in deinem Programm verwendest und hast dieses Wissen dazu genutzt, um einen Servomotor mit einem Potentiometer zu stellen.

Du weißt jetzt alles, um Projekt 5 "Orakel", Projekt 6 "Taschenrechner" oder Projekt 7 "LED-Streifen" auszuprobieren.

Beiträge durchsuchen

KKG Robotik