Construye un robot DIY OTTO con Arduino

FunduinoÚltima actualización el 27.12.2020

Vom Bausatz zum tanzenden Roboter mit Ultraschall-Augen

Der OTTO ist ein kleiner, süßer Roboter. Vier Miniaturservos treiben ihn an, sodass er seine beiden Beine und Füße getrennt bewegen kann. Die Programmierung mit der Arduino-Software ist sehr einfach: Genau wie in unseren anderen Anleitungen programmierst du die einzelnen Module nach und nach.

Mit etwas Ausdauer und Geschick beim Programmieren bewegt sich der Roboter wie ein Tänzer und pfeift seine eigene Melodie. Auch Gegenstände erkennt er problemlos – dafür sorgt der eingebaute Ultraschall-Abstandssensor.

Den OTTO gibt es auch als Komplettset.

Zusammengebauter OTTO-DIY-Roboter mit Ultraschallsensor als Augen — Der Funduino OTTO

Alle Bauteile des OTTO-Bausatzes nebeneinander gelegt — Die Bauteile im Überblick

1 / 2

Funduino OTTO oder OTTO DIY?

OTTO DIY hat eine sehr große Community. Alle Informationen findest du in der GitHub-Datenbank von OTTO DIY. Wenn du einen 3D-Drucker hast, kannst du dir die Teile auch selbst ausdrucken. Es gibt inzwischen sehr viele Versionen des Roboters, die du bei Thingiverse herunterladen kannst – manche sind nur optisch verändert, andere bieten zusätzliche Funktionen.

Funduino hat ein eigenes Design erstellt. An der Programmierung ändert das nichts – nur der Aufbau unterscheidet sich in drei Punkten:

Das NANO-Protoshield, also die Platine mit den angeschlossenen Modulen, sitzt an der Rückwand des Roboterunterteils statt auf der Kopfunterseite. Vorteil: Wenn du an der Elektronik arbeiten musst, fällt dir nach dem Abnehmen des Kopfes nicht ein Großteil der Elektronik entgegen.
Durch das aufrecht stehende Protoshield liegt der Stromanschluss an der Oberseite des Kopfes und ist über eine Durchführung erreichbar. Vorteil: Du kannst während der Programmierphase kurzfristig eine externe Spannungsquelle anschließen, ohne den Kopf zu demontieren.
Durch den außenliegenden Anschluss brauchst du keinen Ein-/Ausschalter mehr: Zum Starten steckst du kopfseitig einfach den Stecker ein. Das spart das Löten des Schalters, und durch den genormten Anschluss am Protoshield bist du bei der Spannungsversorgung sehr flexibel.

Im Funduinoshop bekommst du den Bausatz für den Funduino OTTO mit und ohne gedrucktes Gehäuse: Hier den OTTO bestellen.

Selbst gedruckte Gehäuseteile für den OTTO-Roboter — Gehäuseteile aus dem 3D-Drucker

Zwei Servos auf 90° einstellen

Stelle zuerst zwei der Servos auf 90° ein. Stecke dazu den Aufsatz auf und drehe den Servo auf 90°.

Servomotor SG90 mit aufgestecktem Aufsatz wird auf 90 Grad gedreht — Servo mit aufgestecktem Aufsatz auf 90° stellen

Servos in den Bauch einsetzen

Setze die Servos in den Bauch des OTTO ein und schraube sie fest.

Zwei Servomotoren im Unterteil des OTTO eingesetzt und festgeschraubt — Die Servos im Bauch des OTTO

Clips in die Beine einsetzen

Setze die zurechtgeschnittenen Clips in die Beine des OTTO ein.

Zurechtgeschnittener Clip wird in ein Bein des OTTO eingesetzt — Clips in die Beine einsetzen

Bein des OTTO mit eingesetztem Clip — Der Clip sitzt im Bein

1 / 2

Beine am Bauch festschrauben

Schraube die Beine nun am Bauch des OTTO fest.

Beine des OTTO werden am Unterteil festgeschraubt — Die Beine werden am Bauch festgeschraubt

OTTO mit beiden montierten Beinen — Beide Beine montiert

1 / 2

Clips in die Füße einsetzen

Setze danach in beide Füße jeweils einen kurzen, zurechtgeschnittenen Clip ein und schraube ihn fest.

Servos in den Füßen montieren

Richte die beiden restlichen Servos wie zuvor auf 90° aus, setze sie in die Füße ein und schraube sie fest.

Auf 90 Grad ausgerichteter Servo wird in einen Fuß des OTTO eingesetzt — Servos in den Füßen einsetzen

Festgeschraubter Servo im Fuß des OTTO — Die Servos in den Füßen werden festgeschraubt

1 / 2

Servokabel verlegen und Füße festklemmen

Führe die Kabel der Servos durch die Beine in den Innenraum des OTTO-Bauches. Klemme dann die Füße fest und schraube die Servos an.

NANO einstecken und Servos anschließen

Stecke den NANO-Mikrocontroller in das Expansion Board und verbinde die Kabel der Servos so:

Linkes Bein – Pin 2
Rechtes Bein – Pin 3
Linker Fuß – Pin 4
Rechter Fuß – Pin 5

Stecke dann das Expansion Board in die Halterung im Bauch.

Ultraschallsensor einsetzen

Jetzt setzt du den Ultraschallsensor in die Augenöffnung ein.

Ultraschallsensor HC-SR04 wird in die Augenöffnung des OTTO eingesetzt — Der Ultraschallsensor kommt in die Augenöffnung

OTTO-Kopf mit eingesetztem Ultraschallsensor — Der Sensor sitzt im Kopf

1 / 2

Ultraschallsensor verkabeln

Nimm vier Steckkabel und stecke sie an den Ultraschallsensor. Die anderen Enden verbindest du mit den Pins 8 und 9. Sicher sind dir schon die Beschriftungen G, V und S auf dem Expansion Board aufgefallen – die sind jetzt wichtig:

Trig – Pin 8, Reihe S
Echo – Pin 9, Reihe S
Vcc – Pin 9, Reihe V
GND – Pin 8, Reihe G

Lautsprecher anschließen

Stecke zwei weitere Steckkabel an den Lautsprecher und verbinde sie mit Pin 13 am Expansion Board. Die Plus-Seite kommt an S, die Minus-Seite an G.

Batterie anschließen – fertig aufgebaut

Jetzt ist ein guter Moment, die Batterieklemme an die Batterie zu stecken und durch die Öffnung zu führen.

Fertig! Naja … fast. Du musst den OTTO noch programmieren.

Fertig zusammengebauter OTTO-Roboter vor dem Programmieren — Der fertig aufgebaute OTTO

Bibliothek einbinden und Pins festlegen

Dazu brauchst du die Arduino IDE und musst ein Programm auf den OTTO überspielen. Suche am einfachsten in der IDE nach OttoDIYLib – diese Bibliothek erleichtert dir das Programmieren deines OTTO sehr.

Füge diesen Block immer am Anfang deines Codes ein, dann kannst du auf die Bibliothek zugreifen:

Bibliothek einbinden und Pins festlegen

#include <Otto.h>
Otto Otto;
#define LeftLeg 2   // Linkes Bein Pin
#define RightLeg 3  // Rechtes Bein Pin
#define LeftFoot 4  // Linker Fuß Pin
#define RightFoot 5 // Rechter Fuß Pin
#define Buzzer 13   // Lautsprecher Pin

Der setup-Teil

Im Setup muss außerdem Folgendes stehen:

Der setup-Teil

void setup() {
  Otto.init(LeftLeg, RightLeg, LeftFoot, RightFoot, true, Buzzer);
  Otto.home();
}

Bewegungen

Jetzt kannst du auf verschiedene Funktionen zugreifen, die der OTTO ausführen kann. Die Parameter bedeuten:

schritte – wie oft die Bewegung wiederholt wird, ohne dass du weitere Codezeilen schreiben musst
zeit (weiter unten als T notiert) – die Ausführungszeit in Millisekunden. Eine höhere Zahl verlangsamt die Bewegung. Probiere Werte zwischen 500 und 3000: 3000 = sehr langsam, 2000 = langsam, 1000 = normal, 500 = schnell.
richtung – beim Gehen: 1 = vorwärts, -1 = rückwärts. Beim Drehen und Beugen: 1 = links, -1 = rechts.

Otto.jump() hat keinen Richtungsparameter – der wäre beim Springen sinnlos. Richtig springen kann der OTTO übrigens nicht, aber er versucht es immerhin.

Bewegungen im Überblick

// Gehen: richtung 1 = vorwärts, -1 = rückwärts
Otto.walk(schritte, zeit, richtung);
Otto.walk(2, 1000, 1); // Beispiel: zwei Schritte vorwärts in 1000 ms

// Drehen: richtung 1 = links, -1 = rechts
Otto.turn(schritte, T, richtung);

// Beugen: richtung 1 = links, -1 = rechts
Otto.bend(schritte, T, richtung);

// Bein schütteln
Otto.shakeLeg(schritte, T, richtung);

// Springen: hier gibt es keinen Richtungsparameter
Otto.jump(schritte, T);

Tänze

Bei den Tänzen gibt es einen weiteren Parameter: h beschreibt die Größe der Bewegungen. Damit werden die Tänze interessanter. Die sinnvollen Wertebereiche stehen als Kommentar hinter jedem Befehl.

Tänze im Überblick

// h beschreibt die Größe der Bewegungen

Otto.moonwalker(schritte, T, h, richtung); // 1 = links, -1 = rechts; h zwischen 15 und 40
Otto.crusaito(schritte, T, h, richtung);   // 1 = links, -1 = rechts; h zwischen 20 und 50
Otto.flapping(schritte, T, h, richtung);   // 1 = vorne, -1 = hinten; h zwischen 10 und 30
Otto.swing(schritte, T, h);                // h zwischen 0 und 50
Otto.tiptoeSwing(schritte, T, h);          // h zwischen 0 und 50
Otto.jitter(schritte, T, h);               // h zwischen 5 und 25
Otto.updown(schritte, T, h);               // h zwischen 0 und 90
Otto.ascendingTurn(schritte, T, h);        // h zwischen 5 und 50

Sounds und Gesten

Der OTTO kann verschiedene Töne erzeugen und Lieder singen. Indem du den Inhalt der Klammer änderst, spielst du mit Leichtigkeit verschiedene Melodien ab. Um eine Melodie zu wiederholen, rufst du die Funktion einfach erneut auf.

Verfügbare Melodien: S_connection, S_disconnection, S_buttonPushed, S_mode1, S_mode2, S_mode3, S_surprise, S_OhOoh, S_OhOoh2, S_cuddly, S_sleeping, S_happy, S_superHappy, S_happy_short, S_sad, S_confused, S_fart1, S_fart2, S_fart3.

Das Beste zum Schluss: Mit einer Kombination aus Bewegungen und Sounds drückt der OTTO verschiedene Gesten und Emotionen aus – über die Funktion Otto.playGesture(). Wie du siehst, ist das eigentlich ziemlich einfach – sieht aber ziemlich fortgeschritten aus.

Sounds

// Melodie abspielen – songName aus der Liste unten einsetzen
Otto.sing(songName);

// Einzelnen Ton abspielen (Notenfrequenz, Abspielzeit, Pause danach)
Otto._tone(10, 3, 1);

// Tonübergang (Ausgangsfrequenz, Schlussfrequenz, Zusatz, Abspielzeit, Pause danach)
Otto.bendTones(100, 200, 1.04, 10, 10);

Gesten

Otto.playGesture(OttoHappy);
Otto.playGesture(OttoSuperHappy);
Otto.playGesture(OttoSad);
Otto.playGesture(OttoVictory);
Otto.playGesture(OttoAngry);
Otto.playGesture(OttoSleeping);
Otto.playGesture(OttoFretful);
Otto.playGesture(OttoLove);
Otto.playGesture(OttoConfused);
Otto.playGesture(OttoFart);
Otto.playGesture(OttoWave);
Otto.playGesture(OttoMagic);
Otto.playGesture(OttoFail);

Calificar la guía