Giant Animatronics Lego Minfig Operationsspiel

Notwendige Werkzeuge und Maschinen

Über dieses Projekt

Dieses Projekt wurde in 4 Phasen abgeschlossen. Ich werde schnell die ersten 3 Phasen (die keine Elektronik enthielten) behandeln und die 4 Phase detailliert beschreiben, die Frank in das Operationsspiel umwandelte und Audio und Animatronik hinzufügte.

Phase 1:Bau der Megafiguren

Ich begann mit der Konstruktion der Hand. Ich dachte, dies wäre der schwierigste Teil des ersten Baus und definierte den Maßstab für die restlichen Teile, die hergestellt werden mussten. Die Hand wurde aus PVC-Rohr und Glasfaserharz hergestellt, um die Lücke zwischen der Innen- und Außenhand zu füllen.

Als nächstes folgte die Kopffertigung. Es besteht aus PVC-Rohr (ein großes Rohrfitting für den Hauptteil des Kopfes), MDF und Harz, um die Lücke in der oberen Noppe zu füllen.

Der Körper der Megafigs wurde aus MDF gefertigt und ist ziemlich geradlinig gebaut. PVC-Fittings werden als Verbindungen zwischen den Gliedmaßen und dem Rumpf verwendet

Die Beine bestehen aus MDF und PVC, um die oberen Beinkurven zu definieren.

Die Arme (die am Ende der härteste Teil waren) wurden mit PVC-Rohr für den Unterarm und MDF für den Oberarm aufgeraut. Als Raumfüller wurde Steckschaum verwendet. Bondo wurde verwendet, um die Oberarmform zu erstellen, und Tonnen von Schleifen und Spachteln brachten ihn in seine endgültige Form.

Die Arme und Hände wurden mit Smoothcast 300 geformt und gegossen.

Alles wurde nach dem Lego-Bausatz von Monster Hunters bemalt.

Phase 2:Haare

Diese Phase bestand darin, die Haare des Wissenschaftlers herzustellen. Werkzeugschaum wurde mit der Bandsäge in die Grundformen der Haarsträhnen geschnitten. Die verschiedenen Teile der Haarteile wurden mit Epoxy zusammengeklebt.

Das gesamte Haarteil wurde mit Smoothcast 300 bedeckt, um eine Plastikhülle über dem Schaum zu bilden. es wurde dann geschliffen und gefüllt.

Epoxy Sculpt wurde verwendet, um alle Nähte zwischen den Haarpartien auszufüllen.

Es wurde grundiert und lackiert.

Phase 3:Franks Bett

Die dritte Phase war der Bau von Franks Bett basierend auf dem Crazy Scientist und seinem Monster Lego Bausatz. Es ist ein einfacher Kastenbau aus MDF- und PVC-Rohr für die Noppen.

Die Eckdetails wurden mit einem PVC-Rohr erstellt, das eine MDF-Scheibe einschloss.

Alles wurde geschliffen, grundiert und lackiert.

Phase 4:Operation Spiel und Bewegung

Der letzte Teil dieses Projekts (bis heute) besteht darin, Frank in ein Operationsspiel umzuwandeln und den Megafigs sowohl Audio als auch Bewegung hinzuzufügen. Ich werde jeden Körperteil des Builds detailliert beschreiben, anstatt in chronologischer Reihenfolge zu gehen, wie die Dinge passiert sind (alles wurde gleichzeitig bearbeitet).

Rumpf:

Der Torso hatte 3D-gedruckte Halterungen an den Gelenken, die 2 Rollschuhlager hielten. Diese dienen als Drehpunkt für Arme und Kopf.

Franks Oberkörper hatte 2 Süßigkeitenschalen, die 3D-gedruckt waren, mit gefrästen Aluminiumlippen belegt und mit einer neuen Torsoplatte bedeckt waren. Die Aluminiumlippen fungieren als Schalter für das Operationsspiel. Wenn die Zange (die mit der MP3-Abschirmung verdrahtet ist) das Aluminium berührt, schließt sie den Stromkreis und aktiviert das Programm.

Köpfe :

Beide Köpfe wurden modifiziert, um Lautsprecher zu bewegen und zu halten. Zuerst wurde dem Hals eine 3D-gedruckte Halterung hinzugefügt, um die 5/16-te Schraube zu halten, die als Achse fungiert.

Perforiertes Metall wurde als Leitfaden verwendet, um die Löcher für das Lautsprechergitter zuzuordnen. Ich war bei diesem Prozess am nervösesten. Jeder Fehler würde meine Lackierung auf den Gesichtern ruinieren. Die Löcher wurden passend zur Umgebungsfarbe lackiert.

Eine 3D-gedruckte Halterung wurde erstellt, um die Lautsprecher hinter den Sprechgittern zu halten.

Beine :

Die neuen Beine wurden in zwei Hälften 3D-gedruckt sowie als Bonbonschale in Knochenform. Eine Aluminiumplatte wurde wie der Torso gefräst. Die Beine wurden zusammengeklebt, geschliffen, mit Bondo geglättet und lackiert.

Arme :

Der ursprüngliche Master für die Arme wurde modifiziert, um eine 3D-gedruckte Halterung aufzunehmen, die ein 5/16-faches Fett für eine Achse enthielt. Anschließend wurden sie umgeformt, gegossen, gereinigt und lackiert.

Servos :

Die Servos wurden mit 3D-gedruckten Halterungen installiert und über Draht mit den Anhängen verbunden und ein Aluminiumhorn befestigte die 5/16-Schrauben. Später wurden Federn hinzugefügt, um das Heben der Arme zu erleichtern.

Elektronik :

Die gesamte Elektronik wurde auf einem Stück MDF montiert, um einen Prototypenprüfstand zu erstellen. Dieses Setup ermöglichte es mir und Daniel, die Programmierung und das Tweek-Zeug herauszufinden und Störungen zu beheben. Alles hat gut funktioniert.

Die Funktionsweise der Elektronik ist

1:der MP3-Schild wartet auf 1 von 3 Eingaben (die Zange auf eine der Aluminiumplatten)

2:Wenn eine Aluminiumplatte aktiviert wird, spielt das MP3-Shield die entsprechende MP3-Datei ab und sendet ein Signal an den Servo Arduino.

3:Wenn das Servo-Arduino ein Signal vom MP3-Schild erhält, führt es den entsprechenden Code für die Servos aus.

Beide Arduinos wurden an der Unterseite von Franks Bett montiert und alles neu verkabelt.

Bereit für Süßes oder Saures:

Alles funktioniert fantastisch und hat eine ganze Nacht des Missbrauchs überstanden.

Für ein ausführlicheres Build-Log besuchen Sie ... http://www.therpf.com/showthread.php?t=195101. Dort habe ich jeden Schritt so detailliert beschrieben, wie ich ihn produziert habe.

Code

• Servos
• Soundeffekte

ServosArduino

/**************************** Targus - Bedienung - Servos********************************//***** Hinweise********// / Digitale Pins 0 und 1 werden normalerweise für die serielle Kommunikation verwendet, wenn ein Arduino von einem Computer hochgeladen und überwacht wird.// Digitale Pins 0 und 1 können für Servos verwendet werden, wenn das Arduino nicht an einen Computer angeschlossen ist.// Wenn digitale Pins 0 und 1 für Servos verwendet werden, kommentieren Sie alle Zeilen aus, die mit 'Seriell' beginnen. in dieser Datei.// Stellen Sie sicher, dass dieses Arduino vor dem anderen Arduino eingeschaltet ist, da dieses Arduino 5V-Signale empfängt.// Stellen Sie sicher, dass ein GND-Kabel auf diesem Arduino mit GND auf dem anderen Arduino verbunden ist./**** ***** Beinhaltet***********/#include /*********** Variablen************/Servo Servo5;Servo-Servo6;Servo-Servo7;Servo-Servo8;Servo-Servo9;Servo-Servo10;Servo-Servo11;int Pin2 =2;int Pin3 =3;int Pin4 =4;/*************** Arduino Setup****************/void setup () { Serial.begin (9600); // serielle Kommunikation für Entwicklung und Fehlerbehebung aktivieren Serial.println("Targus - Operation - Servos\n"); /**************************************** Servos anschließen und Ausgangspositionen einstellen ** ****************************************/servo5.attach(5); // digitaler Pin 5 servo5.write (90); // zu 90 Grad bewegen servo6.attach (6); // digitaler Pin 6 servo6.write (90); servo7.attach(7); // digitaler Pin 7 servo7.write (90); servo8.attach(8); // digitaler Pin 8 servo8.write (90); servo9.attach(9); // digitaler Pin 9 servo9.write (80); servo10.attach(10); // digitaler Pin 10 servo10.write (90); servo11.attach(11); // digitaler Pin 11 servo11.write (80); /**************************** Digitale Eingangspins einrichten ******************** ******/ // Eingangspins einrichten, damit das Arduino mit Soundeffekten uns sagen kann, wann Servos aktiviert werden sollen. pinMode (pin2, INPUT_PULLUP); pinMode (pin3, INPUT_PULLUP); pinMode (pin4, INPUT_PULLUP);}/************* Arduino Loop****************/void loop () { if (digitalRead (pin2) ==HOCH) { zap2(); aufrechtzuerhalten. Sonst if (digitalRead (pin3) ==HIGH) { zap3 (); aufrechtzuerhalten. Sonst if (digitalRead (pin4) ==HIGH) { zap4 (); } delay(300);}/*********** Funktionen************/int moveServo(Servo &servo, int degreeStart, int degreeEnd, unsigned long timeEnd, unsigned long timeStart , float (*easing)(float), unsigned long timeNow) { // diese Funktion gibt eine Zahl 1 zurück, wenn noch Arbeit zu erledigen ist timeEnd +=timeStart; // Verzögerung zur Endzeit hinzufügen if (timeNow  timeEnd) {// Servobewegungsphase erledigt, nichts zu tun return 0; } // Wenn wir so weit kommen, bereiten Sie sich darauf vor, ein Servo zu bewegen. float PercentToMove =float (timeNow - timeStart) / float (timeEnd - timeStart); ProzentToMove =easing(percentToMove); // Kartengradbereiche 0-180 bis Mikrosekundenbereich 500-2400 für einen SG-92R http://www.servodatabase.com/servo/towerpro/sg92r degreeStart =map(degreeStart, 0, 180, 500, 2400); degreeEnd =map(degreeEnd, 0, 180, 500, 2400); SchwimmerservoTo =0; if (degreeEnd> degreeStart) {// gegen den Uhrzeigersinn drehen servoTo =((degreeEnd - degreeStart) * ProzentToMove) + degreeStart; aufrechtzuerhalten. Else {// im Uhrzeigersinn drehen ProzentToMove =1 - ProzentToMove; // Prozent umkehren, so dass Werte wie 0,8 zu 0,2 werden servoTo =((degreeStart - degreeEnd) * percentToMove) + degreeEnd; } servo.writeMicroseconds (servoTo); // Serial.print ( "Würde zuordnen:"); Serial.println (servoTo); // Serial.print ( "degreeStart:"); Serial.println (GradStart); // Serial.print ( "degreeEnd:"); Serial.println (degreeEnd); // Serial.print ( "timeEnd:"); Serial.println (timeEnd); // Serial.print ( "timeStart:"); Serial.println (timeStart); // Serial.print ( "timeNow:"); Serial.println (timeNow); // Serial.print ( "percentToMove:"); Serial.println (percentToMove); // Serial.print ( "servoTo:"); Serial.println (servoTo); // Serial.print("\n"); return 1;}/******************** Funktionen:Lockerung******************* /// Lockerung der Funktionen von https://github.com/warrenm/AHEasing/blob/master/AHEasing/easing.c umbenannt in http://easings.net/ für eine einfache Vorschau.float easeInBack(float pos) { // Modelliert nach dem Überschießen kubisch y =x^3-x*sin(x*pi) return pos * pos * pos - pos * sin(pos * M_PI);}float easeOutBack(float pos) { // Modelliert nach Überschwingen kubisch y =1-( (1-x)^3-(1-x)*sin((1-x)*pi)) float f =(1 - pos); return 1 - (f * f * f - f * sin(f * M_PI));}float easeInOutBack(float pos) { // Nach der stückweise überschwingenden kubischen Funktion modelliert:// y =(1/2)*(( 2x)^3-(2x)*sünde(2*x*pi)); [0, 0.5) // y =(1/2)*(1-((1-x)^3-(1-x)*sin((1-x)*pi))+1); [0.5, 1] ​​if (pos <0.5) { float f =2 * pos; Rückgabe 0,5 * (f * f * f - f * sin(f * M_PI)); aufrechtzuerhalten. Sonst { float f =(1 - (2 * pos - 1)); Rückgabe 0,5 * (1 - (f * f * f - f * sin(f * M_PI))) + 0,5; }}float easeInBounce(float pos) { return 1 - easeOutBounce(1 - pos);}float easeOutBounce(float pos) { if (pos <4 / 11.0) { return (121 * pos * pos) / 16.0; aufrechtzuerhalten. Sonst if (pos <8 / 11.0) { return (363 / 40.0 * pos * pos) - (99 / 10.0 * pos) + 17 / 5.0; aufrechtzuerhalten. Sonst if (pos <9 / 10.0) { zurück (4356 / 361.0 * pos * pos) - (35442 / 1805.0 * pos) + 16061 / 1805.0; aufrechtzuerhalten. Sonst { zurück (54 / 5,0 * Pos * Pos) - (513 / 25,0 * Pos) + 268 / 25,0; aufrechtzuerhalten. aufrechtzuerhalten. Sonst { Rückgabe 0,5 * EaseOutBounce (pos * 2 - 1) + 0,5; }}float easeInCirc(float pos) { // Modelliert nach verschobenem Quadranten IV des Einheitskreises return 1 - sqrt(1 - (pos * pos));}float easeOutCirc(float pos) { // Modelliert nach verschobenem Quadranten II der Einheit circle return sqrt((2 - pos) * pos);}float easeInOutCirc(float pos) { // Nach der stückweisen Kreisfunktion modelliert // y =(1/2)(1 - sqrt(1 - 4x^2)); [0, 0.5) // y =(1/2)(sqrt(-(2x - 3)*(2x - 1)) + 1); [0.5, 1] ​​if (pos <0.5) { return 0.5 * (1 - sqrt(1 - 4 * (pos * pos))); aufrechtzuerhalten. Sonst { Rückgabe 0,5 * (sqrt(-((2 * Pos) - 3) * ((2 * Pos) - 1)) + 1); }}float easeInCubic(float pos) { // Modelliert nach dem kubischen y =x^3 return pos * pos * pos;}float easeOutCubic(float pos) { // Modelliert nach dem kubischen y =(x - 1)^3 + 1 Schwimmer f =(pos - 1); return f * f * f + 1;}float easeInOutCubic(float pos) { // Nach dem stückweisen Kubikmodell modelliert // y =(1/2)((2x)^3); [0, 0.5) // y =(1/2)((2x-2)^3 + 2); [0.5, 1] ​​if (pos <0.5) { return 4 * pos * pos * pos; aufrechtzuerhalten. Sonst { float f =((2 * pos) - 2); Rückgabe 0,5 * f * f * f + 1; }}float easeInElastic(float pos) { // Modelliert nach der gedämpften Sinuswelle y =sin(13pi/2*x)*pow(2, 10 * (x - 1)) return sin(13 * M_PI_2 * pos) * pow(2, 10 * (pos - 1));}float easeOutElastic(float pos) { // Nach der gedämpften Sinuswelle modelliert y =sin(-13pi/2*(x + 1))*pow(2, - 10x) + 1 return sin(-13 * M_PI_2 * (pos + 1)) * pow(2, -10 * pos) + 1;}float easeInOutElastic(float pos) { // Modelliert nach der stückweise exponentiell gedämpften Sinuswelle :// y =(1/2)*sin(13pi/2*(2*x))*pow(2, 10 * ((2*x) - 1)); [0,0.5) // y =(1/2)*(sin(-13pi/2*((2x-1)+1))*pow(2,-10(2*x-1)) + 2 ); [0.5, 1] ​​if (pos <0.5) { return 0.5 * sin(13 * M_PI_2 * (2 * pos)) * pow(2, 10 * ((2 * pos) - 1)); aufrechtzuerhalten. Sonst { return 0.5 * (sin(-13 * M_PI_2 * ((2 * pos - 1) + 1)) * pow (2, -10 * (2 * pos - 1)) + 2); }}float easeInExpo(float pos) { // Modelliert nach der Exponentialfunktion y =2^(10(x - 1)) return (pos ==0.0) ? pos :pow(2, 10 * (pos - 1));}float easeOutExpo(float pos) { // Modelliert nach der Exponentialfunktion y =-2^(-10x) + 1 return (pos ==1.0) ? pos :1 - pow(2, -10 * pos);}float easeInOutExpo(float pos) { // Nach dem stückweisen Exponentialmodell modelliert // y =(1/2)2^(10(2x - 1)); [0,0.5) // y =-(1/2)*2^(-10(2x - 1))) + 1; [0.5,1] if (pos ==0.0 || pos ==1.0) return pos; if (pos <0.5) { return 0.5 * pow (2, (20 * pos) - 10); aufrechtzuerhalten. Sonst { return -0.5 * pow(2, (-20 * pos) + 10) + 1; }}float linear(float pos) { return pos;}float easeInQuad(float pos) { // Nach der Parabel modelliert y =x^2 return pos * pos;}float easeOutQuad(float pos) { // Nach der Parabel modelliert y =-x^2 + 2x return -(pos * (pos - 2));}float easeInOutQuad(float pos) { // Modelliert nach dem stückweisen Quadrat // y =(1/2)((2x)^2 ); [0, 0.5) // y =-(1/2)((2x-1)*(2x-3) - 1); [0.5, 1] ​​if (pos <0.5) { return 2 * pos * pos; aufrechtzuerhalten. Else { Return (-2 * Pos * Pos) + (4 * Pos) - 1; }}float easeInQuart(float pos) { // Modelliert nach dem Quartikum x^4 return pos * pos * pos * pos;}float easeOutQuart(float pos) { // Modelliert nach dem Quartikum y =1 - (x - 1) ^4 Gleitkomma f =(pos - 1); return f * f * f * (1 - pos) + 1;}float easeInOutQuart(float pos) { // Modelliert nach der stückweisen Quartik // y =(1/2)((2x)^4); [0, 0.5) // y =-(1/2)((2x-2)^4 - 2); [0.5, 1] ​​if (pos <0.5) { return 8 * pos * pos * pos * pos; aufrechtzuerhalten. Sonst { float f =(pos - 1); zurück -8 * f * f * f * f + 1; }}float easeInQuint(float pos) { // Modelliert nach der Quinte y =x^5 return pos * pos * pos * pos * pos;}float easeOutQuint(float pos) { // Modelliert nach der Quinte y =(x - 1)^5 + 1 Gleitkomma f =(pos - 1); return f * f * f * f * f + 1;}float easeInOutQuint(float pos) { // Nach der stückweisen Quinte modelliert // y =(1/2)((2x)^5); [0, 0.5) // y =(1/2)((2x-2)^5 + 2); [0.5, 1] ​​if (pos <0.5) { return 16 * pos * pos * pos * pos * pos; aufrechtzuerhalten. Sonst { float f =((2 * pos) - 2); Rückgabe 0,5 * f * f * f * f * f + 1; }}float easeInSine(float pos) { // Nach dem Viertelzyklus der Sinuswelle modelliert sin((pos - 1) * M_PI_2) + 1;}float easeOutSine(float pos) { // Nach dem Viertelzyklus des Sinus modelliert wave (andere Phase) return sin(pos * M_PI_2);}float easeInOutSine(float pos) { // Modelliert nach einer halben Sinuswelle Return 0.5 * (1 - cos(pos * M_PI));}/****** ********* Funktionen:Zap**************** //******* Zap 2********/void zap2() { Serial.println ( "ZAP 2 aufgerufen!"); // Knochen ohne Vorzeichen lange timeStart =millis (); int todo; do { unsigned long timeNow =millis() - timeStart; todo =0; // M Beintritt //todo +=moveServo(servo5, 90, 50, 100, 0, easeInOutCubic, timeNow); // Servo5 nach einer Verzögerung von 0 Sekunden für 1 Sekunde von 90 auf 180 Grad bewegen // todo +=moveServo (servo5, 50, 90, 500, 500, easeOutBounce, timeNow); // Servo5 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // M Kopf von Seite zu Seite todo +=moveServo (servo7, 90, 110, 500,0, easeInOutCubic, timeNow); // Servo7 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo7, 110, 70, 500, 500, easeInOutCubic, timeNow); // Servo7 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen. todo +=moveServo (servo7, 70, 110, 500, 1000, easeInOutCubic, timeNow); todo +=moveServo(servo7, 110, 70, 500, 1500, easeInOutCubic, timeNow); todo +=moveServo(servo7, 70, 110, 500, 2000, easeInOutCubic, timeNow); todo +=moveServo(servo7, 110, 70, 500, 2500, easeInOutCubic, timeNow); todo +=moveServo(servo7, 70, 90, 500, 3000, easeInOutCubic, timeNow); // M linker Arm hoch und runter todo +=moveServo(servo8, 90, 170, 1000, 0, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo8, 170, 90, 1000, 4000, easeOutBounce, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // M rechter Arm nach oben und unten todo +=moveServo (servo6, 90, 130, 1000, 1500, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo6, 130, 90, 1000, 5000, easeOutBounce, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // S Kopf hin und her todo +=moveServo (servo10, 90, 40, 1000, 500, easeInOutCubic, timeNow); // Servo7 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo10, 40, 105, 1000, 2000, easeInOutCubic, timeNow); // Servo7 von 180 auf 90 Grad für 1 Sekunde nach einer Verzögerung von 1 Sekunde bewegen todo +=moveServo (servo10, 105, 90, 1000, 6000, easeInOutCubic, timeNow); // S linker Arm hoch und runter todo +=moveServo(servo11, 80, 160, 1000, 2000, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo11, 160, 80, 1000, 5000, easeInOutCubic, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // S rechter Arm nach oben und unten todo +=moveServo (servo9, 80, 20, 1000, 1000, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo9, 20, 80, 1000, 2000, easeInOutCubic, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen (20); aufrechtzuerhalten. Während (todo> 0);}/****** Zap 3*******/void zap3 () { Serial.println ( "ZAP 3 aufgerufen!"); unsigned long timeStart =millis(); int todo; do { unsigned long timeNow =millis() - timeStart; todo =0; // M Kopf von Seite zu Seite todo +=moveServo(servo7, 90, 130, 1000, 0, easeInOutCubic, timeNow); // Servo7 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo7, 130, 90, 1000, 5000, easeInOutCubic, timeNow); // Servo7 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // M linker Arm nach oben und unten todo +=moveServo (servo8, 90, 170, 1000, 0, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo8, 170, 90, 1000, 4000, easeOutBounce, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // M rechter Arm nach oben und unten todo +=moveServo (servo6, 90, 130, 1000, 1500, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo6, 130, 90, 1000, 5000, easeOutBounce, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // S Kopf hin und her todo +=moveServo (servo10, 90, 40, 1000, 500, easeInOutCubic, timeNow); // Servo7 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo10, 40, 105, 1000, 2000, easeInOutCubic, timeNow); // Servo7 von 180 auf 90 Grad für 1 Sekunde nach einer Verzögerung von 1 Sekunde bewegen todo +=moveServo (servo10, 105, 90, 1000, 6000, easeInOutCubic, timeNow); // S linker Arm hoch und runter todo +=moveServo(servo11, 80, 160, 1000, 0, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo11, 160, 80, 1000, 5000, easeInOutCubic, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // S rechter Arm nach oben und unten todo +=moveServo (servo9, 80, 20, 1000, 1000, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo9, 20, 80, 1000, 6000, easeInOutCubic, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen (10); aufrechtzuerhalten. Während (todo> 0);}/****** Zap 4*******/void zap4 () { Serial.println ( "ZAP 4 aufgerufen!"); unsigned long timeStart =millis(); int todo; do { unsigned long timeNow =millis() - timeStart; todo =0; // M Kopf von Seite zu Seite todo +=moveServo(servo7, 90, 130, 1000, 0, easeInOutCubic, timeNow); // Servo7 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo7, 130, 90, 1000, 5000, easeInOutCubic, timeNow); // Servo7 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // M linker Arm nach oben und unten todo +=moveServo (servo8, 90, 170, 1000, 0, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo8, 170, 90, 1000, 4000, easeOutBounce, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // M rechter Arm nach oben und unten todo +=moveServo (servo6, 90, 130, 1000, 1500, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo6, 130, 90, 1000, 5000, easeOutBounce, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // S Kopf hin und her todo +=moveServo (servo10, 90, 40, 1000, 500, easeInOutCubic, timeNow); // Servo7 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo10, 40, 105, 1000, 2000, easeInOutCubic, timeNow); // Servo7 von 180 auf 90 Grad für 1 Sekunde nach einer Verzögerung von 1 Sekunde bewegen todo +=moveServo (servo10, 105, 90, 1000, 6000, easeInOutCubic, timeNow); // S linker Arm hoch und runter todo +=moveServo(servo11, 80, 160, 1000, 2000, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo11, 160, 80, 1000, 5000, easeInOutCubic, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen // S rechter Arm nach oben und unten todo +=moveServo (servo9, 80, 20, 1000, 1000, easeInOutCubic, timeNow); // Servo8 von 90 auf 180 Grad für 1 Sekunde nach einer Verzögerung von 0 Sekunden bewegen todo +=moveServo (servo9, 20, 80, 1000, 2000, easeInOutCubic, timeNow); // Servo8 nach einer Verzögerung von 1 Sekunde für 1 Sekunde von 180 auf 90 Grad bewegen (10); } while (todo> 0);}

SoundeffekteArduino

/*********************************** Targus - Operation - Sound Effects************************************//****** Notes*******/// Digital Pins 0 and 1 are normally used for serial commucation when uploading and monitoring an Arduino from a computer.// Digital Pins 3, 4, 6, 7, 11, 12, and 13 are used by the Adafruit Music Maker Shield.// This Arduino should be powered on after the servos Arduino since this Arduino will be sending 5V signals.// Make sure a GND wire on this Arduino is connected to GND on the other Arduino./********* Includes**********/#include #include #include /********** Variables***********/int relayPin5 =5;int relayPin8 =8;int relayPin9 =9;int pinVolDown =14; // aka Analog In 0int pinVolUp =15; // aka Analog In 1int volume =50; // this is the default volume which can be changed later by the volDown() and volUp() functions/******************************************************************** Adafruit Music Maker Shield - https://www.adafruit.com/product/1788*********************************************************************/// Adafruit Music Maker Shield Pins#define SHIELD_RESET -1 // VS1053 reset pin (unused!)#define DREQ 3 // VS1053 Data request, ideally an Interrupt pin. See http://arduino.cc/en/Reference/attachInterrupt for more info.#define CARDCS 4 // Card chip select pin#define SHIELD_DCS 6 // VS1053 Data/command select pin (output)#define SHIELD_CS 7 // VS1053 chip select pin (output)// the most important thing on the line below is the variable 'musicPlayer' which we will use to play music laterAdafruit_VS1053_FilePlayer musicPlayer =Adafruit_VS1053_FilePlayer(SHIELD_RESET, SHIELD_CS, SHIELD_DCS, DREQ, CARDCS);/************** Arduino Setup***************/void setup() { Serial.begin(9600); // enable serial communication for development and troubleshooting Serial.println("Targus - Operation - Sound Effects\n"); if (! musicPlayer.begin()) { // initialise the music player Serial.println(F("Couldn't find VS1053, do you have the right pins defined?")); while (1); // loop forever since we could not connect to the Adafruit Music Maker Shield } SD.begin(CARDCS); // initialise the SD card // Set volumes for the left and right channels. musicPlayer.setVolume(volume,volume); // 0-255 with 0 being crazy loud // If DREQ is on an interrupt pin (on uno, #2 or #3) we can do background audio playing musicPlayer.useInterrupt(VS1053_FILEPLAYER_PIN_INT); // DREQ int // Specify which GPIO pins to use for input. musicPlayer.GPIO_pinMode(2, OUTPUT); // switch for ... musicPlayer.GPIO_pinMode(3, OUTPUT); // switch for ... musicPlayer.GPIO_pinMode(4, OUTPUT); // switch for ... // Specify which digital pins we will use for volume control pinMode(pinVolDown, INPUT_PULLUP); pinMode(pinVolUp, INPUT_PULLUP); // Specify which digital pins we will use to communicate with the other Arduino (aka the Arduino with all the servos). pinMode(relayPin5, OUTPUT); pinMode(relayPin8, OUTPUT); pinMode(relayPin9, OUTPUT);}/************* Arduino Loop**************/void loop() { int gpio2 =musicPlayer.GPIO_digitalRead(2); int gpio3 =musicPlayer.GPIO_digitalRead(3); int gpio4 =musicPlayer.GPIO_digitalRead(4); int ioDown =digitalRead(pinVolDown); // volume down int ioUp =digitalRead(pinVolUp); // volume up// Serial.println(ioDown);// Serial.println(ioUp);// Serial.println(gpio2); if (gpio2 ==1) { Serial.println("GPIO 2 triggered.\n"); zap2(); } else if (gpio3 ==1) { Serial.println("GPIO 3 triggered.\n"); zap3(); } else if (gpio4 ==1) { Serial.println("GPIO 4 triggered.\n"); zap4(); } else if (ioDown ==LOW) { Serial.println("Analog 0 triggered.\n"); volDown(); } else if (ioUp ==LOW) { Serial.println("Analog 1 triggered.\n"); volUp(); } delay(2); // this delay may need to be reduced or removed depending on how responsive hitting the tongs to the side of a container feels}/********** Functions***********/void audioPlay(String file) { Serial.println("Playing " + file); musicPlayer.startPlayingFile(file.c_str()); Verzögerung (500); // wait half a second before returning so the audio can get going}void audioStop(String file) { musicPlayer.stopPlaying(); Serial.println("Done playing " + file);}void activate(int pin) { digitalWrite(pin, HIGH); delay(300); // delay as long as needed for the other Arduino to notice an event digitalWrite(pin, LOW);}void volDown() { volume =volume + 1; if (volume> 255) { volume =255; } // Set volumes for the left and right channels. musicPlayer.setVolume(volume,volume); // 0-255 with 0 being crazy loud Serial.print("Volume set to "); Serial.println(volume);}void volUp() { volume =volume - 1; if (volume <0) { volume =0; } // Set volumes for the left and right channels. musicPlayer.setVolume(volume,volume); // 0-255 with 0 being crazy loud Serial.print("Volume set to "); Serial.println(volume);}/*************** Functions:Zap****************/ /****** Zap 2 *******/ void zap2() { // Audio and Servo(s) triggered by GPIO 2 String file ="02.mp3"; // this file should exist on the SD card /*********** Play Audio ************/ audioPlay(file); /************************************* Tell other Arduino to Animate Servos **************************************/ activate(relayPin5); delay(6000); // Customize delay to match end of servo movements, go by feel vs. accurate math since this Arduino's clock may not sync with the other Arduino. /*********** Stop Audio ************/ audioStop(file); } /****** Zap 3 *******/ void zap3() { // Audio and Servo(s) triggered by GPIO 3 String file ="03.mp3"; // this file should exist on the SD card /*********** Play Audio ************/ audioPlay(file); /************************************* Tell other Arduino to Animate Servos **************************************/ activate(relayPin8); delay(6000); // Customize delay to match end of servo movements, go by feel vs. accurate math since this Arduino's clock may not sync with the other Arduino. /*********** Stop Audio ************/ audioStop(file); } /****** Zap 4 *******/ void zap4() { // Audio and Servo(s) triggered by GPIO 4 String file ="04.mp3"; // this file should exist on the SD card /*********** Play Audio ************/ audioPlay(file); /************************************* Tell other Arduino to Animate Servos **************************************/ activate(relayPin9); delay(6000); // Customize delay to match end of servo movements, go by feel vs. accurate math since this Arduino's clock may not sync with the other Arduino. /*********** Stop Audio ************/ audioStop(file); } 

Kundenspezifische Teile und Gehäuse

3D grown Parts

Schaltpläne