Otto DIY construit votre propre robot en une heure !

Outils et machines nécessaires

	Imprimante 3D (générique)
	Tournevis cruciforme

Applications et services en ligne

	Arduino IDE
	Éditeur Web Arduino
	Extension de code Microsoft Visual Studio pour Arduino

À propos de ce projet

Qui est Otto ?

Un robot interactif que tout le monde peut fabriquer !

Que peut faire Otto ?

Otto marche, danse, fait des sons et évite les obstacles.

Pourquoi Otto est-il spécial ?

Otto est entièrement open source, compatible Arduino, imprimable en 3D et avec une mission d'impact social pour créer un environnement inclusif pour les enfants.

Otto a été inspiré par un autre robot instructable BoB le BiPed et programmé à l'aide du code d'un autre robot bipède open source appelé Zowi.

CC-BY-SA

Les différences d'Otto résident dans la taille assemblée (11 cm x 7 cm x 12 cm), une intégration plus nette des composants et des expressions. En utilisant des pièces prêtes à l'emploi et imprimées en 3D, des connexions électroniques simples (presque aucune soudure requise) et des compétences de base en codage, vous pourrez créer votre propre ami Otto mignon en moins d'une heure ! voire moins

Otto a été conçu à l'aide d'Autodesk 123D Design, maintenant le logiciel ThinkerCAD, vous pouvez le modifier pour la personnalisation ou d'autres améliorations !

Cette étape par étape se concentre sur la façon de construire la version simple d'Otto DIY ; oui, il existe des robots bipdeal plus avancés comme Otto DIY+ ou Tito

Étape 1 :Rassemblez d'abord toutes les pièces et tous les outils

Rassemblez toutes les pièces de quincaillerie standard dont vous aurez besoin pour cet assemblage.

la mini planche à pain est une alternative au blindage mais nécessite plus de câblage et de temps

Ensuite, il vous suffit d'imprimer en 3D 6 pièces au total :

11. Tête imprimée en 3D.

12. Corps imprimé en 3D.

13. Jambe imprimée en 3D x2.

14. Pied imprimé en 3D x2

Facultatif :un cutter pour le post-nettoyage des pièces 3D (si la qualité d'impression 3D est assez bonne, pas besoin) et un fer à souder (si vous le voulez sur batterie, sinon vous pouvez toujours le connecter via USB pour l'alimenter)

C'est tout simple ! ; télécharger tous les fichiers .stl , Si vous n'avez pas d'imprimante 3D, vous pouvez toujours accéder à votre espace de création local.

Si vous n'avez pas ou est difficile d'obtenir la pièce, vous pouvez simplement acheter nos kits complets visite www.ottodiy.com

Paramètres d'impression 3D

Otto est très bien conçu pour l'impression 3D, les fichiers que vous avez téléchargés sont orientés propriétés et centrés, donc ne vous poseront pas de problèmes si vous suivez ces paramètres communs :

• Il est recommandé d'utiliser une imprimante 3D FDM avec du matériel PLA.
• Pas besoin de supports ou de radeaux du tout.
• Résolution :0,15 mm
• Densité de remplissage 20 %

Pour trancher et générer le code g pour le logiciel gratuit slicer de la machine comme Cura ou dans notre cas FlashPrint fourni avec l'imprimante 3D FlashForge Finder que nous utilisons (si vous sous-traitez l'impression, ne vous inquiétez pas)

Après l'impression, vous devrez nettoyer un peu les zones des jambes et des pieds qui fixent les moteurs.

Vérifiez vos pièces

Comme mentionné à l'étape 2, les micro servomoteurs sont livrés avec 3 vis dans l'image sont maintenant inclus et ont réorganisé le numéro de pièce pour une lecture facile.

Pensez à avoir aimanté votre mini tournevis.

Téléchargez ou imprimez les manuels d'instructions ou suivez simplement cette vidéo :

Assemblage des servos au pied

Mettez le micro servo à l'intérieur des pieds, puis poussez-le à l'intérieur, s'il est trop dur, vous devrez peut-être nettoyer davantage la zone avec un cutter.

Il est très important de vérifier que le servo est capable de tourner d'au moins 90 degrés de chaque côté.

Après avoir vérifié le mouvement, n'utilisez que la petite vis pour le fixer.

Même procédé pour l'autre pied.

Fixer les servos au corps

Prenez les 2 autres micro servos, placez-les aux emplacements définis dans le corps imprimé en 3D et fixez-les uniquement avec les vis pointues.

Fixer les jambes au corps

Connectez les jambes au moyeu du micro servo, important comme les servos de pied, vous devez vérifier que les jambes sont capables de tourner à 90 degrés de chaque côté par rapport au corps.

Après avoir vérifié l'alignement, fixez-les à l'aide des petites vis dans le trou à l'intérieur du pied.

Fixer le pied aux jambes

En prenant soin des câbles comme indiqué sur l'illustration, vous devez placer les câbles à l'intérieur des fentes du corps en passant par le trou des jambes.

Une fois qu'ils sont dans la bonne position, utilisez les vis pointues pour les fixer par l'arrière.

Assemblage de la tête

Commencer par le capteur à ultrasons est important pour tirer les yeux à la limite.

Après avoir placé l'Arduino nano dans le blindage, vous pouvez éventuellement souder le câble positif du support de batterie à Vin dans la carte et le négatif à n'importe quel GND.

Insérez en diagonale les deux cartes ensemble face au connecteur USB dans le trou de la tête imprimée en 3D, puis utilisez les 2 dernières vis pointues pour la fixer.

Étape 9 :Branchement électrique

Préparez les câbles DuPont, le micro-interrupteur et le buzzer.

Suivez ensuite les numéros des broches du diagramme et assurez-vous de les mettre dans la bonne position.

Si vous n'avez pas ou ne trouvez pas le bouclier Arduino Nano, utilisez une planche à pain et suivez ce schéma de circuit TinkerCAD Circuits

Coder avec des blocs

Vous pouvez toujours essayer les codes sources Arduino de la Wikifactory Otto.

Vous trouverez ici des didacticiels gratuits permettant aux débutants de démarrer rapidement avec Arduino pour chaque composant :

- Tutoriel sur les servomoteurs :https://arduinogetstarted.com/tutorials/arduino-servo-motor
- Tutoriel sur les capteurs à ultrasons :https://arduinogetstarted.com/tutorials/arduino-ultrasonic-sensor
- Touch Tutoriel du capteur :https://arduinogetstarted.com/tutorials/arduino-touch-sensor
- Tutoriel du buzzer :https://arduinogetstarted.com/tutorials/arduino-piezo-buzzer

Visitez www.ottodiy.com

La version Otto DIY+ a plus de possibilités en utilisant Bluetooth, plus de capteurs et d'interactions.

postez votre remix et vos modifications dans la Wikifactory

Code

• Éviter les obstacles

Évitez les obstaclesArduino

//---------------------- ------------------------------------------//-- Micrologiciel de base Zowi v2 adapté à Otto//-- (c) BQ. Publié sous licence GPL//-- 04 décembre 2015//-- Auteurs :Anita de Prado :[email protected]//-- Jose Alberca :[email protected]//-- Javier Isabel :[email protected]//-- Juan Gonzalez (obijuan) :[email protected]//-- Irene Sanz :[email protected]//---------- -------------------------------------------------- -----//-- Expérimentez avec toutes les fonctionnalités d'Otto grâce à Zowi !//--------------------------- ----------------------------------------------------#include  #include #include #include #include #include #include  #include OttoSerialCommand SCmd ; //L'objet SerialCommand//-- Bibliothèque Otto#include Otto Otto; //C'est Otto !//------------------------------------------ ---------------//-- Première étape :Configurer les broches où les servos sont attachés/* --------------- | 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]//---Boutons Otto#define PIN_SecondButton 6#define PIN_ThirdButton 7/////// ////////////////////////////////////////////////////////////// ////////////-- Variables globales ---------------------------------- ---------/////////////////////////////////////// ///////////////////////////const char programID[]="Otto_todo"; //Chaque programme aura un IDconst char name_fac='$'; //Nom d'usineconst char name_fir='#'; //Prénom//-- Paramètres de mouvementint T=1000; //Durée initiale du mouvementint moveId=0; //Nombre de mouvementint moveSize=15; //Associé à la hauteur de certains mouvements//---------------------------------------- ------------------//-- Otto a 5 modes://-- * MODE =0 :Otto attend //-- * MODE =1 :Mode danse ! //-- * MODE =2 :Mode détecteur d'obstacles //-- * MODE =3 :Mode détecteur de bruit //-- * MODE =4 :OttoPAD ou tout mode Téléopération (écoute SerialPort). //------------------------------------------------ ---------volatile int MODE=0; //Etat d'Otto dans la machine d'état principale. volatile bool buttonPoussé=false; //Variable à mémoriser lorsqu'un bouton a été poussévolatile bool buttonAPushed=false; //Variable à mémoriser lorsqu'un bouton a été enfoncévolatile bool buttonBPushed=false; //Variable à mémoriser lorsque le bouton B a été enfoncé unsigned long previousMillis=0;int randomDance=0;int randomSteps=0;bool obstacleDetected =false;/////////////////// ////////////////////////////////////////////////////////////// -- Installer ----------------------------------------------- -------///////////////////////////////////////// /////////////////////////void setup(){ //Initialisation de la communication série Serial.begin(115200); pinMode(PIN_SecondButton,ENTRÉE); pinMode(PIN_TroisièmeBouton,ENTRÉE); //Définir les broches du servo Otto.init(PIN_YL,PIN_YR,PIN_RL,PIN_RR,true); // Décommentez ceci pour définir les trims des servos manuellement et enregistrez sur EEPROM // Otto.setTrims (TRIM_YL, TRIM_YR, TRIM_RL, TRIM_RR); //Otto.saveTrimsOnEEPROM(); // Décommentez ceci uniquement pour un téléchargement lorsque vous définissez enfin les garnitures. //Définir une graine aléatoire randomSeed(analogRead(A6)); //Interruptions enableInterrupt(PIN_SecondButton, secondButtonPushed, RISING); enableInterrupt(PIN_ThirdButton, thirdButtonPushed, RISING); //Configurer les rappels pour les commandes SerialCommand 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 réveille-toi ! Otto.sing(S_connexion); Otto.home(); retard (50); // Animation Uuuuuh - Un petit moment de surprise initiale //----- for(int i=0; i<2; i++){ for (int i=0;i<8;i++){ if(buttonPushed) {break;} Otto.putAnimationMouth(littleUuh,i); retard (150); } } //----- //Sourire pour un Otto heureux :) if(!buttonPushed){ Otto.putMouth(smile); Otto.sing(S_heureux); retard (200); } //Si le nom d'Otto est '#' signifie qu'Otto n'a pas été baptisé //Dans ce cas, Otto fait un message d'accueil plus long //5 =adresse EEPROM qui contient le caractère du prénom if (EEPROM.read(5)==name_fir){ if(!buttonPushed){ Otto.jump(1,700); retard (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); } précédentMillis =millis();}///////////////////////////////////////// //////////////////////////-- Boucle principale ------------------- --------------------------//////////////////////// //////////////////////////////////////////boucle vide() { //-- MODE 2 - Mode détecteur d'obstacles if(obstacleDetected){ Otto.sing(S_surprise); Otto.playGesture(OttoFretful); Otto.sing(S_fart3) ; Otto.marche(2.1300,-1); Otto.turn(2,1000,-1); retard (50); Détecteur d'obstacles(); } else{ Otto.walk(1,1000,1) ; Détecteur d'obstacles(); } } ////////////////////////////////////////////// /////////////////////-- Les fonctions -------------------------- ------------------------///////////////////////// /////////////////////////////////////////////////////////////-- Fonction exécutée quand le deuxième bouton est poussévoid secondButtonPushed(){ buttonAPushed=true ; if(!buttonPushed){ buttonPushed=true ; Otto.putMouth(smallSurprise); } }//-- Fonction exécutée lorsque le troisième bouton est enfoncévoid thirdButtonPushed(){ buttonBPushed=true; if(!buttonPushed){ buttonPushed=true ; Otto.putMouth(smallSurprise); }}//-- Fonction pour lire le capteur de distance et pour actualiser obstacleDetected variablevoid obstacleDetector(){ int distance =Otto.getDistance(); if(distance<15){ obstacleDetected =true; }else{ obstacleDetected =false; }}//-- Fonction pour recevoir la commande Stop.void receiveStop(){ sendAck(); Otto.home(); sendFinalAck();}//-- Fonction pour recevoir les commandes LEDvoid receiveLED(){ //sendAck &stop si nécessaire sendAck(); Otto.home(); //Exemples de commandes Bluetooth receiveLED //L 000000001000010100100011000000000 //L 001111111111111111111111111111111 (todos los LED encendidos) longue matrice int non signée ; char *arg; char *endstr; arg=SCmd.next(); //Série.println (arg); if (arg !=NULL) { matrice=strtoul(arg,&endstr,2); // Convertit une chaîne de caractères en entier long non signé Otto.putMouth(matrix,false); }else{ Otto.putMouth(xMouth); retard (2000); Otto.clearMouth(); } sendFinalAck();}//-- Fonction pour recevoir les commandes du buzzervoid recieveBuzzer(){ //sendAck &stop si nécessaire sendAck(); Otto.home(); erreur booléenne =faux ; int frec; durée int; char *arg; arg =SCmd.next(); if (arg !=NULL) { frec=atoi(arg); } // Convertit une chaîne de caractères en un entier else {error=true;} arg =SCmd.next(); if (arg !=NULL) { duration=atoi(arg); } // Convertit une chaîne de caractères en un entier else {error=true;} if(error==true){ Otto.putMouth(xMouth); retard (2000); Otto.clearMouth(); }else{ Otto._tone(frec, durée, 1); } sendFinalAck();}//-- Fonction pour recevoir des commandes TRimsvoid receiveTrims(){ //sendAck &stop si nécessaire sendAck(); Otto.home(); int trim_YL,trim_YR,trim_RL,trim_RR ; //Définition de la commande Servo Bluetooth //C trim_YL trim_YR trim_RL trim_RR //Exemples de commandes Bluetooth receiveTrims //C 20 0 -8 3 bool error =false; char *arg; arg=SCmd.next(); if (arg !=NULL) { trim_YL=atoi(arg); } // Convertit une chaîne de caractères en un entier else {error=true;} arg =SCmd.next(); if (arg !=NULL) { trim_YR=atoi(arg); } // Convertit une chaîne de caractères en un entier else {error=true;} arg =SCmd.next(); if (arg !=NULL) { trim_RL=atoi(arg); } // Convertit une chaîne de caractères en un entier else {error=true;} arg =SCmd.next(); if (arg !=NULL) { trim_RR=atoi(arg); } // Convertit une chaîne de caractères en un entier else {error=true;} if(error==true){ Otto.putMouth(xMouth); retard (2000); Otto.clearMouth(); }else{ //Enregistrez-le sur EEPROM Otto.setTrims(trim_YL, trim_YR, trim_RL, trim_RR); Otto.saveTrimsOnEEPROM(); // Décommentez ceci uniquement pour un téléchargement lorsque vous définissez enfin les garnitures. } sendFinalAck();}//-- Fonction pour recevoir des commandes Servovoid receiveServo(){ sendAck(); moveId =30 ; //Définition de la commande Servo Bluetooth //G servo_YL servo_YR servo_RL servo_RR //Exemple de commandes Bluetooth receiveServo //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); } // Convertit une chaîne de caractères en un entier else {error=true;} arg =SCmd.next(); if (arg !=NULL) { servo_YR=atoi(arg); } // Convertit une chaîne de caractères en un entier else {error=true;} arg =SCmd.next(); if (arg !=NULL) { servo_RL=atoi(arg); } // Convertit une chaîne de caractères en un entier else {error=true;} arg =SCmd.next(); if (arg !=NULL) { servo_RR=atoi(arg); } // Convertit une chaîne de caractères en un entier else {error=true;} if(error==true){ Otto.putMouth(xMouth); retard (2000); Otto.clearMouth(); }else{ //Mettre à jour le servo :int servoPos[4]={servo_YL, servo_YR, servo_RL, servo_RR} ; Otto._moveServos(200, servoPos); //Move 200ms } sendFinalAck();}//-- Fonction pour recevoir des commandes de mouvementvoid receiveMovement(){ sendAck(); if (Otto.getRestState()==true){ Otto.setRestState(false); } //Définition des commandes Bluetooth de mouvement //M MoveID T MoveSize char *arg; arg =SCmd.next(); if (arg !=NULL) {moveId=atoi(arg);} else{ Otto.putMouth(xMouth); retard (2000); Otto.clearMouth(); moveId=0; //arrêt } arg =SCmd.next(); if (arg !=NULL) {T=atoi(arg);} else{ T=1000; } arg =SCmd.next(); if (arg !=NULL) {moveSize=atoi(arg);} else{ moveSize =15; }}//-- Fonction pour exécuter le bon mouvement selon la commande de mouvement reçue.void move(int moveId){ bool manualMode =false; switch (moveId) { case 0 :Otto.home(); Pause; cas 1 ://M 1 1000 Otto.walk(1,T,1) ; Pause; cas 2 ://M 2 1000 Otto.walk(1,T,-1); Pause; cas 3 ://M 3 1000 Otto.turn(1,T,1) ; Pause; cas 4://M 4 1000 Otto.turn(1,T,-1); Pause; cas 5 ://M 5 1000 30 Otto.updown(1,T,moveSize); Pause; cas 6 ://M 6 1000 30 Otto.moonwalker(1,T,moveSize,1) ; Pause; cas 7 ://M 7 1000 30 Otto.moonwalker(1,T,moveSize,-1); Pause; cas 8 ://M 8 1000 30 Otto.swing(1,T,moveSize); Pause; cas 9 ://M 9 1000 30 Otto.crusaito(1,T,moveSize,1) ; Pause; cas 10 ://M 10 1000 30 Otto.crusaito(1,T,moveSize,-1); Pause; cas 11 ://M 11 1000 Otto.jump(1,T); Pause; cas 12 ://M 12 1000 30 Otto.flapping(1,T,moveSize,1) ; Pause; case 13 ://M 13 1000 30 Otto.flapping(1,T,moveSize,-1); Pause; case 14 ://M 14 1000 20 Otto.tiptoeSwing(1,T,moveSize); Pause; cas 15 ://M 15 500 Otto.bend(1,T,1) ; Pause; cas 16 ://M 16 500 Otto.bend(1,T,-1); Pause; cas 17 ://M 17 500 Otto.shakeLeg(1,T,1) ; Pause; cas 18 ://M 18 500 Otto.shakeLeg(1,T,-1); Pause; case 19 ://M 19 500 20 Otto.jitter(1,T,moveSize); Pause; case 20 ://M 20 500 15 Otto.ascendingTurn(1,T,moveSize); Pause; par défaut :manualMode =true; Pause; } if(!ManualMode){ sendFinalAck(); } }//-- Fonction pour recevoir des commandes gestuellesvoid receiveGesture(){ //sendAck &stop si nécessaire sendAck(); Otto.home(); //Définition des commandes Bluetooth Gesture //H GestureID int geste =0; char *arg; arg =SCmd.next(); if (arg !=NULL) {gesture=atoi(arg);} else { Otto.putMouth(xMouth); retard (2000); Otto.clearMouth(); } switch (geste) { case 1 ://H 1 Otto.playGesture(OttoHappy); Pause; cas 2://H 2 Otto.playGesture(OttoSuperHappy); Pause; cas 3 ://H 3 Otto.playGesture(OttoSad); Pause; cas 4://H 4 Otto.playGesture(OttoSleeping); Pause; cas 5://H 5 Otto.playGesture(OttoFart); Pause; cas 6 ://H 6 Otto.playGesture(OttoConfused); Pause; cas 7 ://H 7 Otto.playGesture(OttoLove); Pause; cas 8 ://H 8 Otto.playGesture(OttoAngry); Pause; cas 9 ://H 9 Otto.playGesture(OttoFretful); Pause; cas 10 ://H 10 Otto.playGesture(OttoMagic); Pause; cas 11 ://H 11 Otto.playGesture(OttoWave); Pause; case 12 ://H 12 Otto.playGesture(OttoVictory); Pause; case 13 ://H 13 Otto.playGesture(OttoFail); Pause; par défaut :pause ; } sendFinalAck();}//-- Fonction pour recevoir des commandes de chantvoid receiveSing(){ //sendAck &stop si nécessaire sendAck(); Otto.home(); //Définition des commandes Sing Bluetooth //K SingID int sing =0; char *arg; arg =SCmd.next(); if (arg !=NULL) {sing=atoi(arg);} else { Otto.putMouth(xMouth); retard (2000); Otto.clearMouth(); } switch (sing) { case 1 ://K 1 Otto.sing(S_connection); Pause; cas 2://K 2 Otto.sing(S_disconnection); Pause; cas 3://K 3 Otto.sing(S_surprise); Pause; cas 4://K 4 Otto.sing(S_OhOoh); Pause; cas 5://K 5 Otto.sing(S_OhOoh2); Pause; cas 6 ://K 6 Otto.sing(S_cuddly); Pause; cas 7 ://K 7 Otto.sing(S_sleeping); Pause; cas 8 ://K 8 Otto.sing(S_happy); Pause; cas 9 ://K 9 Otto.sing(S_superHappy); Pause; cas 10 ://K 10 Otto.sing(S_happy_short); Pause; cas 11 ://K 11 Otto.sing(S_sad); Pause; cas 12 ://K 12 Otto.sing(S_confused); Pause; cas 13 ://K 13 Otto.sing(S_fart1) ; Pause; cas 14 ://K 14 Otto.sing(S_fart2) ; Pause; cas 15 ://K 15 Otto.sing(S_fart3) ; Pause; cas 16 ://K 16 Otto.sing(S_mode1) ; Pause; cas 17 ://K 17 Otto.sing(S_mode2) ; Pause; case 18 ://K 18 Otto.sing(S_mode3) ; Pause; case 19 ://K 19 Otto.sing(S_buttonPushed); Pause; par défaut :pause ; } sendFinalAck();}//-- Fonction pour envoyer la mesure du capteur à ultrasons (distance en "cm")void requestDistance(){ Otto.home(); //arrêt si nécessaire int distance =Otto.getDistance(); Serial.print(F("&&")); Serial.print(F("D ")); Serial.print(distance); Serial.println(F("%%")); Serial.flush();}//-- Fonction pour envoyer le capteur de bruit measurevoid requestNoise(){ Otto.home(); //arrêt si nécessaire int microphone=Otto.getNoise(); //AnalogRead(PIN_NoiseSensor); Serial.print(F("&&")); Serial.print(F("N ")); Serial.print(micro); Serial.println(F("%%")); Serial.flush();}//-- Fonction pour envoyer le pourcentage de tension de la batterie requestBattery(){ Otto.home(); //arrêt si nécessaire //La première lecture de la batterie est souvent une mauvaise lecture, nous allons donc rejeter cette valeur. double batteryLevel =Otto.getBatteryLevel(); Serial.print(F("&&")); Serial.print(F("B ")); Serial.print(batteryLevel); Serial.println(F("%%")); Serial.flush();}//-- Fonction pour envoyer le programme IDvoid requestProgramId(){ Otto.home(); //arrêt si nécessaire Serial.print(F("&&")); Serial.print(F("I ")); Serial.print(programID); Serial.println(F("%%")); Serial.flush();}//-- Fonction pour envoyer la commande Ack (A)void sendAck(){ delay(30); Serial.print(F("&&")); Serial.print(F("A")); Serial.println(F("%%")); Serial.flush();}//-- Fonction pour envoyer la commande Ack finale (F)void sendFinalAck(){ delay(30); Serial.print(F("&&")); Serial.print(F("F")); Serial.println(F("%%")); Serial.flush();}//-- Fonctions avec animatics//---------------------------------- ---------------------- void OttoLowBatteryAlarm(){ double batteryLevel =Otto.getBatteryLevel(); if(batteryLevel<45){ while(!buttonPushed){ Otto.putMouth(tonnerre); Otto.bendTones (880, 2000, 1.04, 8, 3); //A5 =880 retard(30); Otto.bendTones (2000, 880, 1.02, 8, 3); //A5 =880 Otto.clearMouth(); retard (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.bendTones (100, 200, 1.04, 10, 10); if(buttonPushed){break;} Otto.putAnimationMouth(dreamMouth,1) ; Otto.bendTones (200, 300, 1.04, 10, 10); if(buttonPushed){break;} Otto.putAnimationMouth(dreamMouth,2) ; Otto.bendTones (300, 500, 1.04, 10, 10); retard (500); if(buttonPushed){break;} Otto.putAnimationMouth(dreamMouth,1) ; Otto.bendTones (400, 250, 1.04, 10, 1); if(buttonPushed){break;} Otto.putAnimationMouth(dreamMouth,0) ; Otto.bendTones (250, 100, 1.04, 10, 1); retard (500); } if(!buttonPushed){ Otto.putMouth(lineMouth); Otto.sing(S_câlin); } Otto.home(); if(!buttonPushed){Otto.putMouth(happyOpen);} }

Source Arduino

Pièces et boîtiers personnalisés

Fichiers imprimables Thinverse .STL 3D

Schémas