Giant Animatronics Lego Minfig Operation Game

Outils et machines nécessaires

À propos de ce projet

Ce projet a été réalisé en 4 étapes. Je couvrirai rapidement les 3 premières étapes (qui ne contenaient pas d'électronique) et détaillerai les 4 étapes qui convertissaient Frank en jeu d'opération et ajouterai de l'audio et de l'animatronique.

Étape 1 :Construire les Megafigs

J'ai commencé par construire la main. J'ai pensé que ce serait la partie la plus difficile de la construction initiale et cela a défini l'échelle pour le reste des pièces qui devaient être fabriquées. La main a été fabriquée à partir de tuyaux en PVC et de résine de fibre de verre pour combler le vide entre la main intérieure et extérieure.

La fabrication de la tête était la suivante. Il est fabriqué à partir de tuyaux en PVC (un gros raccord de tuyau pour la partie principale de la tête), de MDF et de résine pour combler le vide dans le nœud supérieur.

Le corps des mégafigurines était fabriqué à partir de MDF et d'une construction de boîte assez simple. Des raccords en PVC sont utilisés comme joints entre les appendices et le torse

Les pieds sont en MDF et PVC pour définir les courbes du haut des pieds.

Les bras (qui ont fini par être la partie la plus difficile) ont été dégrossis avec un tuyau en PVC pour l'avant-bras et du MDF pour le haut du bras. La mousse florale a été utilisée comme remplissage d'espace. Bondo a été utilisé pour créer la forme du bras supérieur, et des tonnes de ponçage et de remplissage lui ont donné sa forme finale.

Les bras et les mains ont été moulés et coulés avec Smoothcast 300.

Tout a été peint sur la base du kit Monster Hunters Lego.

Phase 2 :Cheveux

Cette phase consistait à fabriquer les cheveux des Scientifiques. La mousse d'outillage a été découpée à l'aide de la scie à ruban dans les formes de base des mèches de cheveux. Les différentes parties des postiches ont été collées ensemble avec de l'époxy.

L'ensemble du postiche a été recouvert de Smoothcast 300 pour créer une coque en plastique sur la mousse. il a ensuite été poncé et rempli.

Epoxy sculpt a été utilisé pour remplir toutes les coutures entre les sections de cheveux.

Il a été apprêté et peint.

Phase 3 :Le lit de Frank

La troisième phase était la construction du lit de Frank basé sur le Crazy Scientist et son kit Monster Lego. Il s'agit d'une simple boîte fabriquée en MDF et en PVC pour les picots.

Les détails des coins ont été créés avec un tuyau en PVC qui a pris en sandwich un disque de MDF.

Tout a été poncé, apprêté et peint.

Phase 4 :Opération Jeu et Mouvement

La dernière partie de ce projet (à ce jour) consiste à convertir Frank en un jeu d'opérations et à ajouter à la fois de l'audio et du mouvement aux Megafigs. Je vais détailler chaque partie du corps de la construction au lieu d'aller dans l'ordre chronologique de la façon dont les choses se sont passées (tout était travaillé en même temps).

Torse :

Le torse avait des supports imprimés en 3D ajoutés aux articulations qui tenaient 2 roulements de patins à roulettes. Ceux-ci agissent comme un point de pivot pour les bras et la tête.

Le haut du corps de Frank avait 2 plats de bonbons imprimés en 3D, surmontés de lèvres en aluminium fraisé et recouverts d'une nouvelle plaque de torse. Les lèvres en aluminium agissent comme un interrupteur pour le jeu d'opération. Lorsque les pinces (qui sont câblées dans le blindage MP3) touchent l'aluminium, cela complète le circuit, activant le programme.

Têtes :

Les deux têtes ont été modifiées pour déplacer et maintenir les haut-parleurs. Tout d'abord, un support imprimé en 3D a été ajouté au cou pour maintenir le boulon 5/16e qui agit comme un axe.

Le métal perforé a été utilisé comme guide pour tracer les trous de la grille du haut-parleur. J'étais le plus nerveux à propos de ce processus. Toute erreur ruinerait mon travail de peinture sur les visages. Les trous ont été peints pour correspondre à la couleur environnante.

Un support imprimé en 3D a été créé pour maintenir les haut-parleurs derrière les grilles de prise de parole.

Jambes :

Les nouvelles jambes ont été imprimées en 3D en deux moitiés ainsi qu'un plat de bonbons en forme d'os. Une plaque d'aluminium a été fraisée comme le torse. Les pieds ont été collés ensemble, poncés, lissés au bondo et peints.

Armes :

Le maître d'origine des bras a été modifié pour accepter un support imprimé en 3D qui contenait un gras de 5/16e pour un axe. Ils ont ensuite été remoulés, coulés, nettoyés et peints.

Servos :

Les servos ont été installés à l'aide de supports imprimés en 3D et connectés aux appendices via un fil et une corne en aluminium fixait les boulons 5/16. Des ressorts ont été ajoutés plus tard pour aider au levage des bras.

Electronique :

Toute l'électronique a été montée sur un morceau de MDF pour créer un prototype de banc d'essai. Cette configuration m'a permis, ainsi qu'à Daniel, de comprendre la programmation, les trucs de tweek et de résoudre les problèmes. Tout a bien fonctionné.

La façon dont fonctionne l'électronique est

1 :le shield MP3 attend 1 des 3 entrées (la pince vers l'une des plaques en aluminium)

2 :Lorsqu'une plaque en aluminium est activée, le shield MP3 lit le fichier MP3 correspondant et envoie un signal au servo Arduino.

3:Lorsque le servo arduino reçoit un signal du blindage MP3, il exécute le code correspondant pour les servos.

Les deux arduinos ont été montés sous le lit de Frank, et tout a été recâblé.

Prêt pour Trick or Treaters :

Tout fonctionne à merveille et a tenu jusqu'à une nuit complète d'abus.

Pour un journal de construction plus détaillé, visitez ... http://www.therpf.com/showthread.php?t=195101. Là, j'ai détaillé chaque étape au fur et à mesure que je l'ai produit.

Code

• Servos
• Effets sonores

ServosArduino

/****************************** Targus - Fonctionnement - Servos******************************//****** Remarques*******// / Les broches numériques 0 et 1 sont normalement utilisées pour la communication série lors du téléchargement et de la surveillance d'un Arduino à partir d'un ordinateur. // Les broches numériques 0 et 1 peuvent être utilisées pour les servos si l'Arduino n'est pas connecté à un ordinateur. // Si les broches numériques 0 et 1 sont utilisés pour les servos, commentez toutes les lignes commençant par « Serial ». dans ce fichier.// Assurez-vous que cet Arduino est sous tension avant l'autre Arduino car cet Arduino recevra des signaux 5V.// Assurez-vous qu'un fil GND sur cet Arduino est connecté à GND sur l'autre Arduino./**** ***** Comprend**********/#include /********** Variables**********/Servo servo5;Servo servo6;Servo servo7;Servo servo8;Servo servo9;Servo servo10;Servo servo11;int pin2 =2;int pin3 =3;int pin4 =4;/****************** Arduino Configuration*************/void setup() { Serial.begin(9600); // activer la communication série pour le développement et le dépannage Serial.println("Targus - Operation - Servos\n"); /********************************************** Connecter les servos et définir les positions initiales ** **************************************/ servo5.attach(5) ; // broche numérique 5 servo5.write(90); // se déplace à 90 degrés servo6.attach(6); // broche numérique 6 servo6.write(90); servo7.attach (7) ; // broche numérique 7 servo7.write(90); servo8.attach(8) ; // broche numérique 8 servo8.write(90); servo9.attach(9) ; // broche numérique 9 servo9.write(80); servo10.attach(10) ; // broche numérique 10 servo10.write(90); servo11.attach(11); // broche numérique 11 servo11.write(80); /****************************** Configuration des broches d'entrée numérique ******************** ******/ // Configurez les broches d'entrée pour que l'Arduino avec des effets sonores puisse nous dire quand activer les servos. pinMode(pin2, INPUT_PULLUP); pinMode(pin3, INPUT_PULLUP); pinMode(pin4, INPUT_PULLUP);}/************ Arduino Loop************/void loop() { if (digitalRead(pin2) ==HAUT) { zap2(); } else if (digitalRead(pin3) ==HIGH) { zap3(); } else if (digitalRead(pin4) ==HIGH) { zap4(); } delay(300);}/********** Fonctions**********/int moveServo(Servo &servo, int degreeStart, int degreeEnd, unsigned long timeEnd, unsigned long timeStart , float (*easing)(float), unsigned long timeNow) { // cette fonction renverra un nombre 1 s'il y a encore du travail à faire timeEnd +=timeStart; // ajoute un retard à l'heure de fin if (timeNow  timeEnd) { // phase de mouvement d'asservissement terminée, rien à faire return 0; } // si nous arrivons aussi loin, préparez-vous à déplacer un servo float percentToMove =float(timeNow - timeStart) / float(timeEnd - timeStart); percentToMove =easing(percentToMove); // mappe les plages de degrés 0-180 à la plage de microsecondes 500-2400 pour un SG-92R http://www.servodatabase.com/servo/towerpro/sg92r degreeStart =map(degreeStart, 0, 180, 500, 2400); degréEnd =map(degréEnd, 0, 180, 500, 2400); flotteur servoTo =0 ; if (degreeEnd> degreeStart) { // tourne dans le sens inverse des aiguilles d'une montre servoTo =((degreeEnd - degreeStart) * percentToMove) + degreeStart; } else { // rotation dans le sens des aiguilles d'une montre percentToMove =1 - percentToMove; // inverser le pourcentage pour que des valeurs comme 0,8 deviennent 0,2 servoTo =((degreeStart - degreeEnd) * percentToMove) + degreeEnd; } servo.writeMicroseconds(servoTo); // Serial.print("Mapperait à :"); Serial.println(servoTo); // Serial.print("degréDébut:"); Serial.println(degréDébut); // Serial.print("degreeEnd:"); Serial.println(degréFin); // 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;}/****************** Fonctions :accélération******************* /// Fonctions d'assouplissement de https://github.com/warrenm/AHEasing/blob/master/AHEasing/easing.c renommé pour correspondre à http://easings.net/ pour une prévisualisation facile.float easyInBack(float pos) { // Modélisé après le dépassement cube y =x^3-x*sin(x*pi) return pos * pos * pos - pos * sin(pos * M_PI);}float easyOutBack(float pos) { // Modélisé après le dépassement cubique 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 easyInOutBack(float pos) { // Modélisé d'après la fonction cubique de dépassement par morceaux :// y =(1/2)*(( 2x)^3-(2x)*sin(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; return 0.5 * (f * f * f - f * sin(f * M_PI)); } else { float f =(1 - (2 * pos - 1)); renvoie 0,5 * (1 - (f * f * f - f * sin(f * M_PI))) + 0,5 ; }}float easyInBounce(float pos) { return 1 - easyOutBounce(1 - pos);}float easyOutBounce(float pos) { if (pos <4 / 11.0) { return (121 * pos * pos) / 16.0; } else if (pos <8 / 11.0) { return (363 / 40.0 * pos * pos) - (99 / 10.0 * pos) + 17 / 5.0; } else if (pos <9 / 10.0) { return (4356 / 361.0 * pos * pos) - (35442 / 1805.0 * pos) + 16061 / 1805.0; } else { return (54 / 5,0 * pos * pos) - (513 / 25,0 * pos) + 268 / 25,0; }}float easyInOutBounce(float pos) { if (pos <0.5) { return 0.5 * easyInBounce(pos * 2); } else { return 0.5 * easyOutBounce(pos * 2 - 1) + 0.5; }}float easyInCirc(float pos) { // Modélisé d'après le quadrant décalé IV du cercle unité return 1 - sqrt(1 - (pos * pos));}float easyOutCirc(float pos) { // Modélisé d'après le quadrant décalé II de l'unité circle return sqrt((2 - pos) * pos);}float easyInOutCirc(float pos) { // Modélisé d'après la fonction circulaire par morceaux // 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))); } else { return 0.5 * (sqrt(-((2 * pos) - 3) * ((2 * pos) - 1)) + 1); }}float easyInCubic(float pos) { // Modélisé d'après le cube y =x^3 return pos * pos * pos;}float easyOutCubic(float pos) { // Modélisé d'après le cube y =(x - 1)^3 + 1 flottant f =(pos - 1); return f * f * f + 1;}float easyInOutCubic(float pos) { // Modélisé d'après le cube par morceaux // 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; } else { float f =((2 * pos) - 2); renvoie 0,5 * f * f * f + 1 ; }}float easyInElastic(float pos) { // Modélisé d'après l'onde sinusoïdale amortie y =sin(13pi/2*x)*pow(2, 10 * (x - 1)) return sin(13 * M_PI_2 * pos) * pow(2, 10 * (pos - 1));}float easyOutElastic(float pos) { // Modélisé d'après l'onde sinusoïdale amortie y =sin(-13pi/2*(x + 1))*pow(2, - 10x) + 1 return sin(-13 * M_PI_2 * (pos + 1)) * pow(2, -10 * pos) + 1;}float easyInOutElastic(float pos) { // Modélisé d'après l'onde sinusoïdale exponentiellement amortie par morceaux :// 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)); } else { return 0.5 * (sin(-13 * M_PI_2 * ((2 * pos - 1) + 1)) * pow(2, -10 * (2 * pos - 1)) + 2); }}float easyInExpo(float pos) { // Modélisé d'après la fonction exponentielle y =2^(10(x - 1)) return (pos ==0.0) ? pos :pow(2, 10 * (pos - 1));}float easyOutExpo(float pos) { // Modélisé d'après la fonction exponentielle y =-2^(-10x) + 1 return (pos ==1.0) ? pos :1 - pow(2, -10 * pos);}float easyInOutExpo(float pos) { // Modélisé d'après l'exponentielle par morceaux // y =(1/2)2^(10(2x - 1)); [0,0.5) // y =-(1/2)*2^(-10(2x - 1))) + 1; [0.5,1] si (pos ==0.0 || pos ==1.0) renvoie pos; if (pos <0.5) { return 0.5 * pow(2, (20 * pos) - 10); } else { return -0.5 * pow(2, (-20 * pos) + 10) + 1; }}float linear(float pos) { return pos;}float easyInQuad(float pos) { // Modélisé d'après la parabole y =x^2 return pos * pos;}float easyOutQuad(float pos) { // Modélisé d'après la parabole y =-x^2 + 2x return -(pos * (pos - 2));}float easyInOutQuad(float pos) { // Modélisé d'après le quadratique par morceaux // 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; } else { return (-2 * pos * pos) + (4 * pos) - 1; }}float easyInQuart(float pos) { // Modélisé d'après la quartique x^4 return pos * pos * pos * pos;}float easyOutQuart(float pos) { // Modélisé d'après la quartique y =1 - (x - 1) ^4 float f =(pos - 1); return f * f * f * (1 - pos) + 1;}float easyInOutQuart(float pos) { // Modélisé d'après la quartique par morceaux // 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; } else { float f =(pos - 1); renvoie -8 * f * f * f * f + 1; }}float easyInQuint(float pos) { // Modélisé d'après le quintic y =x^5 return pos * pos * pos * pos * pos;}float easyOutQuint(float pos) { // Modélisé d'après le quintic y =(x - 1)^5 + 1 flottant f =(pos - 1); return f * f * f * f * f + 1;}float easyInOutQuint(float pos) { // Modélisé d'après le quintique par morceaux // 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; } else { float f =((2 * pos) - 2); renvoie 0,5 * f * f * f * f * f + 1 ; }}float easyInSine(float pos) { // Modélisé d'après un quart de cycle de l'onde sinusoïdale return sin((pos - 1) * M_PI_2) + 1;}float easyOutSine(float pos) { // Modélisé d'après un quart de cycle de sinus wave (phase différente) return sin(pos * M_PI_2);}float easyInOutSine(float pos) { // Modélisé d'après le retour d'une demi-onde sinusoïdale 0,5 * (1 - cos(pos * M_PI));}/****** ******* Fonctions :Zap******************//****** Zap 2*******/void zap2() { Serial.println("ZAP 2 appelé!"); //Bone non signé long timeStart =millis(); int todo; do { long timeNow non signé =millis() - timeStart; faire =0 ; // M Leg Kick //todo +=moveServo(servo5, 90, 50, 100, 0, easyInOutCubic, timeNow); // déplace le servo5 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde // todo +=moveServo(servo5, 50, 90, 500, 500, easyOutBounce, timeNow); // déplace le servo5 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // M Tête côte à côte todo +=moveServo(servo7, 90, 110, 500,0, easyInOutCubic, timeNow); // déplace le servo7 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo7, 110, 70, 500, 500, easyInOutCubic, timeNow); // déplace le servo7 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde todo +=moveServo(servo7, 70, 110, 500, 1000, easyInOutCubic, timeNow); todo +=moveServo(servo7, 110, 70, 500, 1500, easyInOutCubic, timeNow); todo +=moveServo(servo7, 70, 110, 500, 2000, easyInOutCubic, timeNow); todo +=moveServo(servo7, 110, 70, 500, 2500, easyInOutCubic, timeNow); todo +=moveServo(servo7, 70, 90, 500, 3000, easyInOutCubic, timeNow); // M bras gauche haut et bas todo +=moveServo(servo8, 90, 170, 1000, 0, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo8, 170, 90, 1000, 4000, easyOutBounce, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // M bras droit de haut en bas todo +=moveServo(servo6, 90, 130, 1000, 1500, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo6, 130, 90, 1000, 5000, easyOutBounce, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // S Tête côte à côte à faire +=moveServo(servo10, 90, 40, 1000, 500, easyInOutCubic, timeNow); // déplace le servo7 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo10, 40, 105, 1000, 2000, easyInOutCubic, timeNow); // déplace le servo7 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde todo +=moveServo(servo10, 105, 90, 1000, 6000, easyInOutCubic, timeNow); // S bras gauche haut et bas todo +=moveServo(servo11, 80, 160, 1000, 2000, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo11, 160, 80, 1000, 5000, easyInOutCubic, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // S bras droit de haut en bas pour faire +=moveServo(servo9, 80, 20, 1000, 1000, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo9, 20, 80, 1000, 2000, easyInOutCubic, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde (20) ; } while (todo> 0);}/****** Zap 3*******/void zap3() { Serial.println("ZAP 3 appelé!"); long timeStart non signé =millis(); int todo; do { long timeNow non signé =millis() - timeStart; faire =0 ; // M Tête côte à côte todo +=moveServo(servo7, 90, 130, 1000, 0, easyInOutCubic, timeNow); // déplace le servo7 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo7, 130, 90, 1000, 5000, easyInOutCubic, timeNow); // déplace le servo7 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // M bras gauche de haut en bas todo +=moveServo(servo8, 90, 170, 1000, 0, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo8, 170, 90, 1000, 4000, easyOutBounce, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // M bras droit de haut en bas todo +=moveServo(servo6, 90, 130, 1000, 1500, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo6, 130, 90, 1000, 5000, easyOutBounce, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // S Tête côte à côte à faire +=moveServo(servo10, 90, 40, 1000, 500, easyInOutCubic, timeNow); // déplace le servo7 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo10, 40, 105, 1000, 2000, easyInOutCubic, timeNow); // déplace le servo7 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde todo +=moveServo(servo10, 105, 90, 1000, 6000, easyInOutCubic, timeNow); // S bras gauche haut et bas todo +=moveServo(servo11, 80, 160, 1000, 0, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo11, 160, 80, 1000, 5000, easyInOutCubic, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // S bras droit de haut en bas pour faire +=moveServo(servo9, 80, 20, 1000, 1000, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo9, 20, 80, 1000, 6000, easyInOutCubic, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde (10) ; } while (todo> 0);}/****** Zap 4*******/void zap4() { Serial.println("ZAP 4 appelé!"); long timeStart non signé =millis(); int todo; do { long timeNow non signé =millis() - timeStart; faire =0 ; // M Tête côte à côte todo +=moveServo(servo7, 90, 130, 1000, 0, easyInOutCubic, timeNow); // déplace le servo7 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo7, 130, 90, 1000, 5000, easyInOutCubic, timeNow); // déplace le servo7 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // M bras gauche de haut en bas todo +=moveServo(servo8, 90, 170, 1000, 0, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo8, 170, 90, 1000, 4000, easyOutBounce, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // M bras droit de haut en bas todo +=moveServo(servo6, 90, 130, 1000, 1500, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo6, 130, 90, 1000, 5000, easyOutBounce, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // S Tête côte à côte à faire +=moveServo(servo10, 90, 40, 1000, 500, easyInOutCubic, timeNow); // déplace le servo7 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo10, 40, 105, 1000, 2000, easyInOutCubic, timeNow); // déplace le servo7 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde todo +=moveServo(servo10, 105, 90, 1000, 6000, easyInOutCubic, timeNow); // S bras gauche haut et bas todo +=moveServo(servo11, 80, 160, 1000, 2000, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo11, 160, 80, 1000, 5000, easyInOutCubic, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde // S bras droit de haut en bas pour faire +=moveServo(servo9, 80, 20, 1000, 1000, easyInOutCubic, timeNow); // déplace le servo8 de 90 à 180 degrés pendant 1 seconde après un délai de 0 seconde todo +=moveServo(servo9, 20, 80, 1000, 2000, easyInOutCubic, timeNow); // déplace le servo8 de 180 à 90 degrés pendant 1 seconde après un délai de 1 seconde (10) ; } while (todo> 0);}

Effets sonoresArduino

/*********************************** 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()); retard (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); } 

Pièces et boîtiers personnalisés

3D grown Parts

Schémas