Der camerarobot ist ein Roboterarm mit einer Kamera, der sich über ein Programm steuern lässt. Der Benutzer kann über ein Interface entscheiden wie die Kamera zu welchem Zeitpunkt ausgerichtet sein und positioniert sein soll. Über einen Play-Button führt der Roboter die Positionsabfolge durch, wobei alle Positionszwischenwerte automatisch linear berechnet werden.

Abbildung 1: Bild des camerarobots

Inspiration: Ursprünglich sollte der Roboter nicht nur steuerbar sein, sondern auch Bewegungen des Menschen ausgleichen und sich stabilisieren. Das heißt die Kamera hält auf einen bestimmten Punkt und egal wie man den Kameraarm hält, die Kamera richtet sich immer wieder so aus, dass sie auf diesen einen Punkt filmt. Die Funktionsweise der Kameraroboter wie der 6-Achsen Kameraarm Kira von Motorized Precision (https://youtu.be/bKO_r3_vNw4?t=144), haben uns fasziniert und inspiriert. Es war uns natürlich bewusst, dass wir eine kleinere, einfachere Version bauen werden, aber am Grundprinzip einer Kamera die sich steuern lässt haben wir uns orientiert.

Zu Anfang hatten wir folgende Überlegungen:

• Anzahl der Motoren: In welche Richtungen soll sich die Kamera drehen können?
• Konstruktion: Der Roboter muss leicht und stabil bleiben, damit die Motoren nicht überlastet werden.

Aufgrund dieser Überlegungen entstanden zuerst Skizzen:

Abbildung 2: Skizze des Roboterarms mit zwei Gliedern und sechs Freiheitsgraden (Degrees of freedom / DOF)

Dann haben wir festgelegt, was wir auf jeden Fall schaffen wollen (MUSS), was wir gerne zusätzlich noch erreichen würden (SOLL) und was wir als Bonus noch dazubauen wenn wir noch Zeit haben (BONUS).

• MUSS: Kamerakäfig und grafisches Computerinterface um den Roboter anzusteuern
• SOLL: Roboterarm mit zwei weiteren Motoren und der Möglichkeit Bewegungen nach oben und unten auszugleichen
• BONUS: Grundplatte mit zwei weiteren Motor die Höhen- und Tiefenbewegung der Kamera ermöglichen

Nach dieser Aufteilung waren unsere zwei größten technischen Fragen:

• Wie ermöglichen wir die Kommunikation zwischen Processing (Das Programm in dem wir unser Interface erstellen wollten) und dem Roboter/Arduino?
• Wie bestimmen wir die Ausrichtung vom Roboter? Bzw. wie schaffen wir es, dass Lageabweichungen erkannt und durch die Motoren ausgeglichen werden?

Baugruppen:
Unser Projekt „camerarobot“ bestand am Ende aus zwei Teilen:

1. Der erste Teil ist der Roboter selber. Mit Arm: 1 Motor – Bewegung nach oben/unten (height) und Kamerakäfig: 2 Motoren – Rotation rechts/links (yaw-axis) und Rotation hoch/runter (pitch-axis)
2. Und der zweite Teil entspricht dem Programm/Interface das wir geschrieben haben:
   Die Linien stellen den Zeitablauf da. Auf den Linien kann der Benutzer Punkte setzen und die Position für alle drei Motoren zu einem bestimmten Zeitpunkt festlegen (Keyframes). Am Ende lässt sich durch Klicken des Play-Buttons das ganze abspielen wie eine Choreographie.
   Mit dem Knopf mit Kamerasymbol ganz links oben, verbindet man die Kamera mit dem GUI und das Bild erscheint. Mit dem Knopf mit dem USB-Zeichen rechts daneben verbindet man Processing mit dem Arduino.
   

Abbildung 3: Die Achsen des camerarobots

Abbildung 4: Das GUI

Liste der verwendeten Bauteile

• MPU6050
• logitech webcam
• 15mm Aluminium L Profil
• 20mm Aluminium L Profil
• 2 große Servos
• 1 kleiner Servo
• Arduino Nano
• Kabel

Abbildung 6: Leitungsplan

Konstruktion
Wie schon erwähnt mussten wir darauf achten, dass die Konstruktion leicht bleibt und trotzdem höchste Stabilität bietet. Ziel eines solchen Roboters ist es eine Bewegung möglichst genau immer wieder auszuführen. Durch eine schwache Konstruktion wäre keine Wiederholbarkeit der Bewegungen garantiert, weil die Bewegungen der Motoren zu viele Erschütterungen auslösen würden. Aus diesen Gründen war Aluminium ein gutes Konstruktionsmaterial, das L-Profil spart zusätzlich Gewicht während die Stabilität deutlich erhöht wird. Leider wurde dadurch die Konstruktion etwas komplizierter, da die Profile weniger symmetrisch waren.

Die Einzelteile wurden alle erst vorbereitet: wir haben die Teile zugeschnitten, Kanten abgeschliffen, Löcher gebohrt, Markierungen gezeichnet. Dann haben wir die Teile mit Superkleber fixiert und dann verschraubt. Da unsere Werkstücke zu klein waren um die Servos konventionell zu befestigen haben wir nur die Welle der Servos durch das Aluminium geführt. Leider waren um die Wellen nervige Plastikerhöhungen, die ein Stabiles befestigen der Servos unmöglich gestalteten, weshalb wir für diese mit einem Dremel Aussparungen in das Aluminium gefräst haben. Der untere Teil des Kamerakäfigs wird auf der einen Seite vom kleinen Servo gehalten, die andere Seite ist in einem mit Epoxid verklebten Kugellager gelagert. Der ganze Kamerakäfig ist hängend an einem der größeren Servos angebracht, da hier keine den Servo beeinflussende Kraft auf den Servo ausgeübt wird stellt es kein Problem dar, dass dieser den Korb alleine hält. Der dritte Servo trägt den Käfig samt beider anderer Servos an einem beweglichen Parallelogramm, welches die Hoch-/Runterbewegung ermöglicht. An dieser Stelle wäre ein Gegengewicht sinnvoll gewesen um den letzten Servo zu entlasten.

Abbildung 7: Zusammenbau des Kamerakfigs

Software Schnittstelle
Das GUI ist mit standart Processing Methoden realisiert. Für verschiedenste Arten Knöpfe und die Slider haben wir eigene Klassen geschrieben. Das Programm verbindet sich mit einem Serial Port um dem Arduino einen Formatierten String zu schicken, der die Winkel der verschiedenen Servos beinhaltet. Dieser String wird mehrmals pro Sekunde geschickt, wodurch flüssige Bewegungen zustande kommen. Die Keyframes sind pro Achse in jeweils einer Hashmap gespeichert mit der Timelineposition(Zeit) als Key und dem Winkel als value. Für alle Positionen zwischen zwei Keyframes werden die umklammernden Keyframes in der Hashmap gefunden und der Winkelwert dann liniear berechnet. Dies wird pro Iteration der Programmschleife einmal für jede Achse gemacht. Bei einer erweiterten Version mit mehr Motoren und Achsen sollte man aus Performancegründen eine andere Methode bevorzugen.

Ansteuerung des MP6050 Sensors
Der Sensor ist dafür da, die Position der Kamera zu bestimmen. Um zu wissen ob und wie der Sensor funktioniert, haben wir im Internet Code herausgesucht, der die Winkel des Sensors ausgibt und in Processing seine Position visualisiert (siehe http://elektro.turanis.de/html/prj075/index.html). Der Sensor benutzt ein elektronisches Gyroskop und Accelerometer um Winkeländerungen und Richtungsbeschleunigungen aufzuzeichnen. Die genaue Ausrichtung des Sensors wird durch eine Kombination aus den Daten beider Sensoren berechnet. In Processing sah das ganze dann so aus:

Abbildung 8: Visualisierung der Position des MPU-Sensors

Mit Hilfe der Position des Sensors bzw. der Kamera ist das Ausgleichen von Bewegungen nach oben und unten mit folgendem Code theoretisch schon möglich. Allerdings noch nicht über das Interface, also für den Benutzer.

servo.write(servo.read() - angle_y + offset)

Der Winkel in dem der Servo sich befinden soll (servo.write()), setzt sich zusammen aus dem Winkel in dem er sich gerade befindet (servo.read()) minus dem pitch-Winkel vom MPU Sensor (angle_y: die Kombination aus gyro und accelometer) plus dem Winkel auf den die Kamera halten soll, auch wenn sie nach oben oder unten bewegt wird (offset).

Im Nachhinein haben wir einen Kameraroboter mit Käfig, Arm und 3 Freiheitsgraden (DOF) gebaut, die sich über ein GUI steuern lassen. Unser MUSS haben wir damit auf jeden Fall erreicht. Das SOLL haben wir größtenteils geschafft. In der ursprünglichen Skizze sind in unserem SOLL zwei Motoren gezeigt, allerdings konnten wir durch unser Parallelogrammdesign den Arm auch ohne Ausgleichmotor bauen. Die Grundfuktion der Hoch- und Runterbewegung ist dadurch gegeben, wobei ein weiterer Motor mehr Bewegungsmöglichkeiten geben würde. Es fehlt allerdings eine Funktion, die dem Benutzer mit einem Knopf im Interface die Stabilisierung ermöglicht. Wenn wir mehr Zeit hätten oder wenn jemand dieses Projekt aufnehmen und erweitern möchte, wäre das wahrscheinlich der erste bzw. der nächste Schritt. Den BONUS, also die Grundplatte mit den zwei weiteren Motoren, haben wir nicht geschafft.
Die Konstruktion ist gut gelungen. Wir hatten die Befürchtung, dass die Konstruktion zu schwer wird für den untersten Servo (Height-Servo). Allerdings hat sich Aluminium als gutes Material erwiesen und obwohl der große Servo sehr belastet ist, macht er keine Probleme. Wir hatten wie schon erwähnt, überlegt ein Gegengewicht auf den hinteren Teil des Holzkreuzes zu befestigen, um das vordere Gewicht von Arm und Käfig auszubalancieren.
Dagegen spinnt der kleine Servo manchmal rum und auch allgemein sind die Bewegungen sehr ruckelig und abrupt. Woran das genau liegen und wie man es verbessern könnte wissen wir leider selber nicht genau. Das gilt es noch herauszufinden am besten wahrscheinlich mit Hilfe von den Kursleitern.
Eine andere Erweiterungsmöglichkeit könnte das speichern und laden von selbst erstellten Timelines im Interface darstellen.
Fazit: Verglichen mit den anderen Robotik-Projekten aus diesem, sowie aus den vorherigen Semestern waren unsere Ideen zu Anfang sehr anspruchsvoll. Obwohl wir uns viel vorgenommen haben, sind wir so weit gekommen, dass der Roboter benutzbar ist und eine Funktion erfüllt. Andere Gruppen hatten zum Beispiel weniger Glück und ihr Roboter hat bei der Präsentation gar nicht funktioniert. Deswegen sind wir zufrieden mit uns, denn wir haben grundsätzlich viel geschafft (MUSS und ein bisschen SOLL) und trotzdem gibt es noch Luft nach oben und genug Verbesserungsmöglichkeiten.

Sammlung des kompletten Programmcodes zum download: camerarobot_code.zip