Otto DIY baut deinen eigenen Roboter in einer Stunde!

Notwendige Werkzeuge und Maschinen

	3D-Drucker (generisch)
	Kreuzschlitzschraubendreher

Apps und Onlinedienste

	Arduino-IDE
	Arduino Web Editor
	Microsoft Visual Studio Code-Erweiterung für Arduino

Über dieses Projekt

Wer ist Otto?

Ein interaktiver Roboter, den jeder bauen kann!

Was kann Otto tun?

Otto geht, tanzt, macht Geräusche und weicht Hindernissen aus.

Warum ist Otto etwas Besonderes?

Otto ist vollständig Open Source, Arduino-kompatibel, 3D-druckbar und hat eine soziale Mission, eine integrative Umgebung für Kinder zu schaffen.

Otto wurde von einem anderen roboteranweisbaren BoB, dem BiPed, inspiriert und mit Code von einem anderen Open-Source-Biped-Roboter namens Zowi programmiert.

CC-BY-SA

Ottos Unterschiede liegen in der zusammengebauten Größe (11cm x 7cm x12cm), sauberer Integration von Komponenten und Ausdrücken. Mit handelsüblichen und 3D-gedruckten Teilen, einfachen elektronischen Verbindungen (fast kein Schweißen erforderlich) und grundlegenden Programmierkenntnissen können Sie Ihren eigenen süßen Otto-Freund in nur einer Stunde bauen! oder noch weniger

Otto entwarf mit Autodesk 123D Design, jetzt kann die ThinkerCAD-Software zur Anpassung oder weiteren Verbesserungen modifiziert werden!

Dieser Schritt für Schritt konzentriert sich darauf, wie man die einfache Otto DIY-Version baut; Ja, es gibt fortschrittlichere Bipdeal-Roboter wie Otto DIY+ oder Tito

Schritt 1:Sammeln Sie zuerst alle Teile und Werkzeuge

Sammeln Sie alle handelsüblichen Hardwareteile, die Sie für diese Baugruppe benötigen.

Mini-Breadboard ist eine Alternative für die Abschirmung, erfordert jedoch mehr Verdrahtung und Zeit

Dann müssen Sie insgesamt nur 6 Teile in 3D drucken:

11. 3D-gedruckter Kopf.

12. 3D-gedruckter Körper.

13. 3D-gedrucktes Bein x2.

14. 3D-gedruckter Fuß x2

Optional:Cutter zum Nachreinigen der 3D-Teile (wenn die 3D-Druckqualität gut genug ist nicht erforderlich) und ein Lötkolben (wenn Sie es mit Batteriestrom möchten, können Sie es sonst noch über USB mit Strom versorgen)

Das ist ganz einfach!; Alle .stl-Dateien herunterladen , Wenn Sie keinen 3D-Drucker haben, können Sie jederzeit zu Ihrem lokalen Maker-Space gehen.

Wenn Sie das Teil nicht haben oder schwer zu bekommen sind, können Sie einfach unsere kompletten Kits kaufen besuch www.ottodiy.com

3D-Druckeinstellungen

Otto ist sehr gut für den 3D-Druck konzipiert. Die heruntergeladenen Dateien sind eigenschaftsorientiert und zentriert, sodass Sie keine Probleme haben, wenn Sie diese allgemeinen Parameter befolgen:

• Wird empfohlen, einen FDM-3D-Drucker mit PLA-Material zu verwenden.
• Keine Stützen oder Flöße erforderlich.
• Auflösung:0,15 mm
• Fülldichte 20 %

Zum Schneiden und Generieren des g-Codes für die maschinenfreieSlicer-Software wie Cura oder in unserem Fall FlashPrint, das mit dem von uns verwendeten FlashForge Finder 3D-Drucker geliefert wird (Wenn Sie den Druck auslagern, müssen Sie sich keine Sorgen machen)

Nach dem Drucken müssen Sie die Beine und Füße, die die Motoren befestigen, ein wenig reinigen.

Überprüfen Sie Ihre Teile

Wie in Schritt 2 erwähnt, werden Micro-Servomotoren mit 3 Schrauben im Bild geliefert, die jetzt enthalten sind und die Teilenummer zum leichteren Lesen neu angeordnet sind.

Denken Sie daran, Ihren Mini-Schraubendreher magnetisiert zu haben.

Laden Sie die Bedienungsanleitungen herunter oder drucken Sie sie aus oder folgen Sie einfach diesem Video:

Montage der Fußservos

Setzen Sie das Mikroservo in die Füße und schieben Sie es dann hinein, wenn es zu hart ist, müssen Sie den Bereich möglicherweise mit einem Cutter mehr reinigen.

Es ist sehr wichtig zu überprüfen, ob sich das Servo um mindestens 90 Grad nach jeder Seite drehen kann.

Verwenden Sie nach der Überprüfung des Uhrwerks nur die kleine Schraube, um es zu befestigen.

Der gleiche Vorgang für den anderen Fuß.

Servos am Körper befestigen

Nehmen Sie die anderen 2 Mikroservos, legen Sie sie an die definierten Stellen im 3D-gedruckten Körper und befestigen Sie sie nur mit den spitzen Schrauben.

Beine am Körper befestigen

Verbinden Sie die Beine mit der Nabe des Mikroservos. Wichtig wie bei den Fußservos müssen Sie überprüfen, ob sich die Beine um 90 Grad auf jeder Seite in Bezug auf den Körper drehen können.

Nachdem Sie die Ausrichtung überprüft haben, befestigen Sie sie mit den kleinen Schrauben im Loch im Inneren des Beins.

Fuß an Beinen befestigen

Achten Sie auf die Kabel, wie in der Abbildung gezeigt, und legen Sie die Kabel in die Schlitze des Körpers durch das Loch der Beine.

Sobald sie in der richtigen Position sind, verwenden Sie die spitzen Schrauben, um sie von hinten zu befestigen.

Kopfmontage

Beginnen Sie mit dem Ultraschallsensor, um die Augen bis zum Äußersten herauszuziehen.

Nachdem Sie den Arduino nano in die Abschirmung gesteckt haben, können Sie optional das Pluskabel des Batteriehalters mit Vin in der Platine und Minus mit einem beliebigen GND verschweißen.

Stecken Sie die beiden Platinen zusammen mit dem Blick auf den USB-Anschluss diagonal in das Loch im 3D-gedruckten Kopf und verwenden Sie dann die letzten 2 spitzen Schrauben, um sie zu befestigen.

Schritt 9:Elektrischer Anschluss

Bereiten Sie die DuPont-Kabel, den Mikroschalter und den Summer vor.

Folgen Sie dann den Pinnummern des Diagramms und stellen Sie sicher, dass Sie sie an der richtigen Position platzieren.

Wenn Sie das Arduino Nano-Shield nicht haben oder finden, verwenden Sie ein Steckbrett und folgen Sie diesem Schaltplan TinkerCAD Circuits

Code mit Blöcken

Sie können jederzeit die Arduino-Quellcodes aus der Otto Wikifactory ausprobieren.

Hier finden Sie einige kostenlose Tutorials für Anfänger, um schnell mit Arduino für jede Komponente zu beginnen:

- Servomotor-Tutorial:https://arduinogetstarted.com/tutorials/arduino-servo-motor
- Ultraschallsensor-Tutorial:https://arduinogetstarted.com/tutorials/arduino-ultrasonic-sensor
- Touch Sensor-Tutorial:https://arduinogetstarted.com/tutorials/arduino-touch-sensor
- Summer-Tutorial:https://arduinogetstarted.com/tutorials/arduino-piezo-buzzer

Besuchen Sie www.ottodiy.com

Otto DIY+ Version bietet mehr Möglichkeiten mit Bluetooth, mehr Sensoren und Interaktionen.

poste deinen Remix und deine Modifikationen in der Wikifactory

Code

• Vermeide Hindernisse

Vermeide HindernisseArduino

//------------------------ ------------------------------------------ //-- Zowi Basis-Firmware v2 angepasst an Otto//-- (c) BQ. Veröffentlicht unter einer GPL-Lizenz//-- 04. Dezember 2015//-- Autoren:Anita de Prado:[email protected]//-- Jose Alberca:[email protected]//-- Javier Isabel:[email protected]//-- Juan Gonzalez (obijuan):[email protected]//-- Irene Sanz :[email protected]//---------- -------------------------------------------------- -----//-- Experimentieren Sie mit allen Funktionen, die Otto dank Zowi hat!//----------------------------- --------------------------------------#include  #include #include #include #include #include #include  #include OttoSerialCommand SCmd; //Das SerialCommand-Objekt//-- Otto Library#include Otto Otto; //Das ist Otto!//------------------------------------------------------ ---------------//-- Erster Schritt:Konfigurieren Sie die Pins, an denen die Servos befestigt sind/* -------------- | O O | |----------------|YR 3==> | | <==YL 2 --------------- || || || ||RR 5==> ----- ------ <==RL 4 |----- ------|*/ #define PIN_YL 2 //servo[0] #define PIN_YR 3 //servo[1] #define PIN_RL 4 //servo[2] #define PIN_RR 5 //servo[3]//---Otto Buttons#define PIN_SecondButton 6#define PIN_ThirdButton 7/////// //////////////////////////////////////////////// ////////////-- Globale Variablen ---------------------------------- ---------//////////////////////////////////////// ////////////////////////////const char programID[]="Otto_todo"; //Jedes Programm hat ein IDconst char name_fac='$'; //Fabriknameconst char name_fir='#'; //Vorname //-- Bewegungsparameterint T=1000; //Anfangsdauer der Bewegungint moveId=0; //Anzahl der Bewegungenint moveSize=15; //Assoziiert mit der Höhe einiger Bewegungen //-------------------------------------- ------------------//-- Otto hat 5 Modi://-- * MODE =0:Otto wartet //-- * MODE =1:Tanzmodus ! //-- * MODE =2:Hinderniserkennungsmodus //-- * MODE =3:Geräuscherkennungsmodus //-- * MODE =4:OttoPAD oder ein beliebiger Teleoperationsmodus (abhört SerialPort). //------------------------------------------------ ---------flüchtiger int MODE=0; //Zustand von Otto in der Hauptzustandsmaschine. volatile bool buttonPushed=false; //Variable, die sich daran erinnert, wenn eine Schaltfläche gedrückt wurdevolatile bool buttonAPushed=false; //Variable, die sich daran erinnert, wenn eine Schaltfläche gedrückt wurdevolatile bool buttonBPushed=false; //Variable, die sich daran erinnert, wenn die B-Taste gedrückt wurdeunsigned long previousMillis=0;int randomDance=0;int randomSteps=0;bool HindernisDetected =false;////////////////// //////////////////////////////////////////////// -- Konfiguration ----------------------------------------------- -------///////////////////////////////////////// //////////////////////////void setup () {// Initialisierung der seriellen Kommunikation Serial.begin (115200); pinMode (PIN_SecondButton, EINGANG); pinMode (PIN_ThirdButton, INPUT); // Setze die Servopins Otto.init (PIN_YL,PIN_YR,PIN_RL,PIN_RR,true); // Kommentieren Sie dies, um die Servotrimmungen manuell einzustellen und im EEPROM zu speichern // Otto.setTrims (TRIM_YL, TRIM_YR, TRIM_RL, TRIM_RR); //Otto.saveTrimsOnEEPROM(); // Entkommentieren Sie dies nur für einen Upload, wenn Sie die Trimmungen endgültig eingestellt haben. // Setze einen zufälligen Seed randomSeed (analogRead (A6)); //Unterbrechungen enableInterrupt(PIN_SecondButton, secondButtonPushed, RISING); enableInterrupt(PIN_ThirdButton, ThirdButtonPushed, RISING); //Rückrufe für SerialCommand-Befehle einrichten SCmd.addCommand("S", receiveStop); // sendAck &sendFinalAck SCmd.addCommand("L", receiveLED); // sendAck &sendFinalAck SCmd.addCommand("T", recieveBuzzer); // sendAck &sendFinalAck SCmd.addCommand("M", receiveMovement); // sendAck &sendFinalAck SCmd.addCommand("H", receiveGesture); // sendAck &sendFinalAck SCmd.addCommand("K", receiveSing); // sendAck &sendFinalAck SCmd.addCommand("C", receiveTrims); // sendAck &sendFinalAck SCmd.addCommand("G", receiveServo); // sendAck &sendFinalAck SCmd.addCommand("D", requestDistance); SCmd.addCommand("N", requestNoise); SCmd.addCommand("B", requestBattery); SCmd.addCommand("I", requestProgramId); SCmd.addDefaultHandler(receiveStop); //Otto wach auf! Otto.sing(S_Verbindung); Otto.home(); Verzögerung (50); // Animation Uuuuuh - Ein kleiner Moment der anfänglichen Überraschung //----- for(int i=0; i<2; i++){ for (int i=0;i<8;i++){ if(buttonPushed) {break;} Otto.putAnimationMouth(littleUuh,i); Verzögerung (150); } } //----- //Lächle für einen glücklichen Otto :) if(!buttonPushed){ Otto.putMouth(smile); Otto.sing(S_happy); Verzögerung (200); } //Wenn Ottos Name '#' ist, bedeutet das, dass Otto nicht getauft wurde //In diesem Fall grüßt Otto länger //5 =EEPROM-Adresse, die Vornamenszeichen enthält if (EEPROM.read(5)==name_fir){ if(!buttonPushed){ Otto.jump(1.700); Verzögerung (200); } if(!buttonPushed){ Otto.shakeLeg(1,T,1); } if(!buttonPushed){ Otto.putMouth(smallSurprise); Otto.swing(2,800,20); Otto.home(); } } if(!buttonPushed){ Otto.putMouth(happyOpen); } previousMillis =millis();}///////////////////////////////////////// ///////////////////////////-- Hauptschleife ------------------- -------------------------------------- //////////////////////// ////////////////////////////////////////////void loop () { //-- MODE 2 - Hinderniserkennungsmodus if(obstacleDetected){ Otto.sing(S_surprise); Otto.playGesture(OttoFretful); Otto.sing(S_fart3); Otto.walk(2.1300,-1); Otto.turn(2,1000,-1); Verzögerung (50); Hindernisdetektor (); } sonst{ Otto.walk(1,1000,1); Hindernisdetektor (); } } ////////////////////////////////////////////// /////////////////////-- Funktionen -------------------------- ------------------------- ///////////////////////////////////////// ////////////////////////////////////////////-- Funktion ausgeführt wenn zweite Schaltfläche wird gedrücktvoid secondButtonPushed(){ buttonAPushed=true; if(!buttonPushed){ buttonPushed=true; Otto.putMouth(smallSurprise); } } //-- Funktion wird ausgeführt, wenn die dritte Schaltfläche gedrückt wirdvoid ThirdButtonPushed(){ buttonBPushed=true; if(!buttonPushed){ buttonPushed=true; Otto.putMouth(smallSurprise); }} //-- Funktion zum Lesen des Distanzsensors und zum Aktualisieren von HindernisDetected Variablevoid HindernisDetector () { int Distance =Otto.getDistance (); Wenn (Abstand <15) {Hindernis erkannt =wahr; }sonst{ hinderniserkannt =falsch; }} //-- Funktion zum Empfangen des Stop-Befehls.void receiveStop () { sendAck (); Otto.home(); sendFinalAck();} //-- Funktion zum Empfangen von LED-Befehlenvoid receiveLED () {//sendAck &ggf. stoppen sendAck(); Otto.home(); //Beispiele für receiveLED Bluetooth-Befehle //L 000000001000010100100011000000000 //L 001111111111111111111111111111111 (todos los LED encendidos) unsigned long int matrix; char *arg; char *endstr; arg=SCmd.next(); //Seriell.println (arg); if (arg !=NULL) { matrix=strtoul(arg,&endstr,2); // Konvertiert eine Zeichenkette in eine lange Ganzzahl ohne Vorzeichen Otto.putMouth(matrix,false); }sonst{ Otto.putMouth(xMouth); Verzögerung (2000); Otto.clearMouth(); } sendFinalAck();}//-- Funktion zum Empfangen von Summer-Befehlenvoid recieveBuzzer(){//sendAck &stop falls nötig sendAck(); Otto.home(); bool error =false; int frec; int-Dauer; char *arg; arg =SCmd.next(); if (arg !=NULL) { frec=atoi(arg); } // Wandelt eine Zeichenkette in eine ganze Zahl um else {error=true;} arg =SCmd.next(); if (arg !=NULL) { Dauer=atoi (arg); } // Wandelt eine Zeichenkette in eine ganze Zahl um else {error=true;} if(error==true){ Otto.putMouth(xMouth); Verzögerung (2000); Otto.clearMouth(); }sonst{ Otto._tone (frec, Dauer, 1); } sendFinalAck();}//-- Funktion zum Empfangen von TRims-Befehlenvoid receiveTrims(){ //sendAck &stop falls nötig sendAck(); Otto.home(); int trim_YL,trim_YR,trim_RL,trim_RR; // Definition des Servo-Bluetooth-Befehls // C trim_YL trim_YR trim_RL trim_RR // Beispiele für ReceiveTrims-Bluetooth-Befehle // C 20 0 -8 3 bool error =false; char *arg; arg=SCmd.next(); if (arg !=NULL) { trim_YL=atoi (arg); } // Wandelt eine Zeichenkette in eine ganze Zahl um else {error=true;} arg =SCmd.next(); if (arg !=NULL) { trim_YR=atoi(arg); } // Wandelt eine Zeichenkette in eine ganze Zahl um else {error=true;} arg =SCmd.next(); if (arg !=NULL) { trim_RL=atoi(arg); } // Wandelt eine Zeichenkette in eine ganze Zahl um else {error=true;} arg =SCmd.next(); if (arg !=NULL) { trim_RR=atoi(arg); } // Wandelt eine Zeichenkette in eine ganze Zahl um else {error=true;} if(error==true){ Otto.putMouth(xMouth); Verzögerung (2000); Otto.clearMouth(); }else{ //Auf EEPROM speichern Otto.setTrims(trim_YL, trim_YR, trim_RL, trim_RR); Otto.saveTrimsOneEEPROM(); // Entkommentieren Sie dies nur für einen Upload, wenn Sie die Trimmungen endgültig eingestellt haben. } sendFinalAck();} //-- Funktion zum Empfangen von Servobefehlenvoid receiveServo () { sendAck (); moveId =30; //Definition des Servo-Bluetooth-Befehls //G servo_YL servo_YR servo_RL servo_RR //Beispiel für ReceiveServo-Bluetooth-Befehle //G 90 85 96 78 bool error =false; char *arg; int servo_YL,servo_YR,servo_RL,servo_RR; arg=SCmd.next(); if (arg !=NULL) { servo_YL=atoi (arg); } // Wandelt eine Zeichenkette in eine ganze Zahl um else {error=true;} arg =SCmd.next(); if (arg !=NULL) { servo_YR=atoi (arg); } // Wandelt eine Zeichenkette in eine ganze Zahl um else {error=true;} arg =SCmd.next(); if (arg !=NULL) { servo_RL=atoi (arg); } // Wandelt eine Zeichenkette in eine ganze Zahl um else {error=true;} arg =SCmd.next(); if (arg !=NULL) { servo_RR=atoi (arg); } // Wandelt eine Zeichenkette in eine ganze Zahl um else {error=true;} if(error==true){ Otto.putMouth(xMouth); Verzögerung (2000); Otto.clearMouth(); } sonst {//Servo aktualisieren:int servoPos [4] ={servo_YL, servo_YR, servo_RL, servo_RR}; Otto._moveServos(200, servoPos); //Bewegung 200ms } sendFinalAck();}//-- Funktion zum Empfangen von Bewegungsbefehlenvoid receiveMovement(){ sendAck(); if (Otto.getRestState()==true){ Otto.setRestState(false); } //Definition der Bluetooth-Bewegungsbefehle //M MoveID T MoveSize char *arg; arg =SCmd.next(); if (arg !=NULL) {moveId=atoi(arg);} else{ Otto.putMouth(xMouth); Verzögerung (2000); Otto.clearMouth(); moveId=0; //stop} arg =SCmd.next(); if (arg !=NULL) {T=atoi(arg);} else{ T=1000; } arg =SCmd.next(); if (arg !=NULL) {moveSize=atoi(arg);} else{ moveSize =15; }} //-- Funktion zum Ausführen der rechten Bewegung gemäß dem empfangenen Bewegungsbefehl.void move(int moveId){ bool manualMode =false; switch (moveId) { case 0:Otto.home(); brechen; Fall 1://M 1 1000 Otto.walk(1,T,1); brechen; Fall 2://M 2 1000 Otto.walk(1,T,-1); brechen; Fall 3://M 3 1000 Otto.turn(1,T,1); brechen; Fall 4://M 4 1000 Otto.turn(1,T,-1); brechen; Fall 5://M 5 1000 30 Otto.updown(1,T,moveSize); brechen; Fall 6://M 6 1000 30 Otto.moonwalker(1,T,moveSize,1); brechen; Fall 7://M 7 1000 30 Otto.moonwalker(1,T,moveSize,-1); brechen; Fall 8://M 8 1000 30 Otto.swing(1,T,moveSize); brechen; Fall 9://M 9 1000 30 Otto.crusaito(1,T,moveSize,1); brechen; Fall 10://M 10 1000 30 Otto.crusaito(1,T,moveSize,-1); brechen; Fall 11://M 11 1000 Otto.jump(1,T); brechen; Fall 12://M 12 1000 30 Otto.flapping(1,T,moveSize,1); brechen; Fall 13://M 13 1000 30 Otto.flapping(1,T,moveSize,-1); brechen; Fall 14://M 14 1000 20 Otto.tiptoeSwing(1,T,moveSize); brechen; Fall 15://M 15 500 Otto.bend(1,T,1); brechen; Fall 16://M 16 500 Otto.bend(1,T,-1); brechen; Fall 17://M 17 500 Otto.shakeLeg(1,T,1); brechen; Fall 18://M 18 500 Otto.shakeLeg(1,T,-1); brechen; Fall 19://M 19 500 20 Otto.jitter(1,T,moveSize); brechen; Fall 20://M 20 500 15 Otto.ascendingTurn(1,T,moveSize); brechen; Standard:manualMode =true; brechen; } if(!manualMode){ sendFinalAck(); } } //-- Funktion zum Empfangen von Gestenbefehlenvoid receiveGesture(){ //sendAck &stop, wenn nötig sendAck(); Otto.home(); //Definition der Gesten-Bluetooth-Befehle //H GestureID Int Geste =0; char *arg; arg =SCmd.next(); if (arg !=NULL) {gesture=atoi(arg);} else { Otto.putMouth(xMouth); Verzögerung (2000); Otto.clearMouth(); } Schalter (Geste) { Fall 1://H 1 Otto.playGesture(OttoHappy); brechen; Fall 2://H 2 Otto.playGesture(OttoSuperHappy); brechen; Fall 3://H 3 Otto.playGesture(OttoSad); brechen; Fall 4://H 4 Otto.playGesture(OttoSleeping); brechen; Fall 5://H 5 Otto.playGesture(OttoFart); brechen; Fall 6://H 6 Otto.playGesture(OttoConfused); brechen; Fall 7://H 7 Otto.playGesture(OttoLove); brechen; Fall 8://H 8 Otto.playGesture(OttoAngry); brechen; Fall 9://H 9 Otto.playGesture(OttoFretful); brechen; Fall 10://H 10 Otto.playGesture(OttoMagic); brechen; Fall 11://H 11 Otto.playGesture(OttoWave); brechen; Fall 12://H 12 Otto.playGesture(OttoVictory); brechen; Fall 13://H 13 Otto.playGesture(OttoFail); brechen; Vorgabe:Pause; } sendFinalAck();}//-- Funktion zum Empfangen von Sing-Befehlenvoid receiveSing(){ //sendAck &stop falls nötig sendAck(); Otto.home(); // Definition von Sing Bluetooth-Befehlen // K SingID int sing =0; char *arg; arg =SCmd.next(); if (arg !=NULL) {sing=atoi(arg);} else { Otto.putMouth(xMouth); Verzögerung (2000); Otto.clearMouth(); } switch (sing) { case 1://K 1 Otto.sing(S_connection); brechen; Fall 2://K 2 Otto.sing(S_disconnection); brechen; Fall 3://K 3 Otto.sing(S_surprise); brechen; Fall 4://K 4 Otto.sing(S_OhOoh); brechen; Fall 5://K 5 Otto.sing(S_OhOoh2); brechen; Fall 6://K 6 Otto.sing(S_cuddly); brechen; Fall 7://K 7 Otto.sing(S_sleeping); brechen; Fall 8://K 8 Otto.sing(S_happy); brechen; Fall 9://K 9 Otto.sing(S_superHappy); brechen; Fall 10://K 10 Otto.sing(S_happy_short); brechen; Fall 11://K 11 Otto.sing(S_sad); brechen; Fall 12://K 12 Otto.sing(S_confused); brechen; Fall 13://K 13 Otto.sing(S_fart1); brechen; Fall 14://K 14 Otto.sing(S_fart2); brechen; Fall 15://K 15 Otto.sing(S_fart3); brechen; Fall 16://K 16 Otto.sing(S_mode1); brechen; Fall 17://K 17 Otto.sing(S_mode2); brechen; Fall 18://K 18 Otto.sing(S_mode3); brechen; Fall 19://K 19 Otto.sing(S_buttonPushed); brechen; Vorgabe:Pause; } sendFinalAck();} //-- Funktion zum Senden des Ultraschallsensormaßes (Abstand in "cm")void requestDistance(){ Otto.home(); // ggf. anhalten int distance =Otto.getDistance(); Serial.print (F("&&")); Serial.print (F ("D")); Serial.print (Abstand); Serial.println (F("%%")); Serial.flush();} //-- Funktion zum Senden von Geräuschsensor-Messungvoid requestNoise(){ Otto.home(); // ggf. stoppen int Mikrofon=Otto.getNoise(); //analogRead (PIN_NoiseSensor); Serial.print (F("&&")); Serial.print (F ("N")); Serial.print (Mikrofon); Serial.println (F("%%")); Serial.flush();} //-- Funktion zum Senden von Batteriespannungs-Prozentvoid-AnfrageBattery(){ Otto.home(); //beenden, falls erforderlich //Der erste Lesevorgang der Batterie ist oft ein falscher Lesevorgang, daher werden wir diesen Wert verwerfen. double batteryLevel =Otto.getBatteryLevel(); Serial.print (F("&&")); Serial.print (F ("B")); Serial.print (BatteryLevel); Serial.println (F("%%")); Serial.flush();} //-- Funktion zum Senden der Programm-IDvoid requestProgramId(){ Otto.home(); // ggf. stoppen Serial.print (F("&&")); Serial.print (F ("I")); Serial.print (Programm-ID); Serial.println (F("%%")); Serial.flush ();} //-- Funktion zum Senden des Ack-Befehls (A)void sendAck () { delay (30); Serial.print (F("&&")); Serial.print (F ("A")); Serial.println (F("%%")); Serial.flush ();} //-- Funktion zum Senden des letzten Ack-Befehls (F)void sendFinalAck () { delay (30); Serial.print (F("&&")); Serial.print (F ("F")); Serial.println (F("%%")); Serial.flush();}//-- Funktionen mit Animatics//--------------------------------- ----------------------void OttoLowBatteryAlarm(){ double batteryLevel =Otto.getBatteryLevel(); if(batteryLevel<45){ while(!buttonPushed){ Otto.putMouth(Donner); Otto.bendTones (880, 2000, 1.04, 8, 3); //A5 =880 Verzögerung (30); Otto.bendTones (2000, 880, 1.02, 8, 3); //A5 =880 Otto.clearMouth(); Verzögerung (500); } }}void OttoSleeping_withInterrupts(){ int bedPos_0[4]={100, 80, 60, 120}; if(!buttonPushed){ Otto._moveServos(700, bedPos_0); } for(int i=0; i<4;i++){ if(buttonPushed){break;} Otto.putAnimationMouth(dreamMouth,0); Otto.bendTone (100, 200, 1.04, 10, 10); if(buttonPushed){break;} Otto.putAnimationMouth(dreamMouth,1); Otto.bendTone (200, 300, 1.04, 10, 10); if(buttonPushed){break;} Otto.putAnimationMouth(dreamMouth,2); Otto.bendTone (300, 500, 1.04, 10, 10); Verzögerung (500); if(buttonPushed){break;} Otto.putAnimationMouth(dreamMouth,1); Otto.bendTone (400, 250, 1.04, 10, 1); if(buttonPushed){break;} Otto.putAnimationMouth(dreamMouth,0); Otto.bendTone (250, 100, 1.04, 10, 1); Verzögerung (500); } if(!buttonPushed){ Otto.putMouth(lineMouth); Otto.sing(S_kuschelig); } Otto.home(); if(!buttonPushed){Otto.putMouth(happyOpen);} }

Arduino-Quelle

Kundenspezifische Teile und Gehäuse

Thingiverse .STL 3D-druckbare Dateien

Schaltpläne