Otto DIY construa seu próprio robô em uma hora!

Ferramentas e máquinas necessárias

	Impressora 3D (genérica)
	Chave de fenda Phillips Cross

Aplicativos e serviços online

	Arduino IDE
	Arduino Web Editor
	Extensão de código do Microsoft Visual Studio para Arduino

Sobre este projeto

Etapa 1:primeiro reúna todas as peças e ferramentas

Configurações de impressão 3D

• Recomendado o uso de uma impressora 3D FDM com material PLA.
• Não há necessidade de suportes ou balsas.
• Resolução:0,15 mm
• densidade de preenchimento 20%

Verifique suas peças

Conjunto de servos de pé

Fixar servos no corpo

Fixar as pernas no corpo

Fixe o pé nas pernas

Montagem da cabeça

Etapa 9:Conexão elétrica

Código com blocos

Código

• Evite obstáculos

Evite obstáculos Arduino

 // ---------------------- ------------------------------------------ // - firmware básico do Zowi v2 adaptado para Otto // - (c) BQ. Lançado sob uma licença GPL // - 04 de dezembro de 2015 // - Autores:Anita de Prado:[email protected]//-- Jose Alberca:[email protected]//-- Javier Isabel:[email protected]//-- Juan Gonzalez (obijuan):[email protected]//-- Irene Sanz:[email protected]//---------- -------------------------------------------------- ----- // - Experimente todos os recursos que Otto tem graças ao Zowi! // --------------------------- -------------------------------------- # include  #include  #include  #include  #include  #include  #include  #include  OttoSerialCommand SCmd; // O objeto SerialCommand // - Biblioteca Otto # include  Otto Otto; // Aqui é Otto! // ------------------------------------------ --------------- // - Primeiro passo:Configure os pinos onde os servos estão conectados / * --------------- | 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] // --- Botões Otto # define PIN_SecondButton 6 # define PIN_ThirdButton 7 /////// //////////////////////////////////////////////////////// ////////////-- Variáveis ​​globais ---------------------------------- --------- /////////////////////////////////////////// //////////////////////////////// const char programID [] ="Otto_todo"; // Cada programa terá um IDconst char name_fac ='$'; // Factory nameconst char name_fir ='#'; // Nome // - Parâmetros de movimentoint T =1000; // Duração inicial do movimentoint moveId =0; // Número de movimentoint moveSize =15; // Associado à altura de alguns movimentos // --------------------------------------- ------------------ // - Otto tem 5 modos:// - * MODE =0:Otto está aguardando // - * MODE =1:Modo de dança ! // - * MODE =2:Modo detector de obstáculo // - * MODE =3:Modo detector de ruído // - * MODE =4:OttoPAD ou qualquer modo de teleoperação (escuta SerialPort). // ------------------------------------------------ --------- volátil int MODE =0; // Estado de Otto na máquina principal de estado. botão bool volátilPushed =false; // Variável para lembrar quando um botão for pressionado volátil bool buttonAPushed =false; // Variável a ser lembrada quando um botão for pressionado volátil bool buttonBPushed =false; // Variável a ser lembrada quando o botão B for pressionado com sinalização longa previousMillis =0; int randomDance =0; int randomSteps =0; bool obstacleDetected =false; /////////////////// //////////////////////////////////////////////////////// -- Configurar ----------------------------------------------- ------- /////////////////////////////////////////////// ////////////////////////////// void setup () {// Inicialização da comunicação serial Serial.begin (115200); pinMode (PIN_SecondButton, INPUT); pinMode (PIN_ThirdButton, INPUT); // Definir os pinos do servo Otto.init (PIN_YL, PIN_YR, PIN_RL, PIN_RR, true); // Remova o comentário para definir os trims do servo manualmente e salve no EEPROM //Otto.setTrims(TRIM_YL, TRIM_YR, TRIM_RL, TRIM_RR); //Otto.saveTrimsOnEEPROM (); // Remova o comentário apenas para um upload quando você finalmente definir os cortes. // Define uma semente aleatória randomSeed (analogRead (A6)); // Interrumptions enableInterrupt (PIN_SecondButton, secondButtonPushed, RISING); enableInterrupt (PIN_ThirdButton, thirdButtonPushed, RISING); // Configurar callbacks para comandos 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 acorde! Otto.sing (S_connection); Otto.home (); atraso (50); // Animação Uuuuuh - Um pequeno momento de surpresa inicial // ----- for (int i =0; i <2; i ++) {for (int i =0; i <8; i ++) {if (buttonPushed) {pausa;} Otto.putAnimationMouth (littleUuh, i); atraso (150); }} // ----- // Sorria para um Otto feliz :) if (! ButtonPushed) {Otto.putMouth (smile); Otto.sing (S_happy); atraso (200); } // Se o nome de Otto for '#' significa que Otto não foi batizado // Neste caso, Otto faz uma saudação mais longa // 5 =endereço EEPROM que contém o caractere do primeiro nome if (EEPROM.read (5) ==name_fir) {if (! buttonPushed) {Otto.jump (1.700); atraso (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 ();} ////////////////////////////////////////////// /////////////////////////////// - Principal Loop ------------------- -------------------------- ////////////////////////// //////////////////////////////////////////////////// void loop () { // - MODO 2 - Modo detector de obstáculo if (obstacleDetected) {Otto.sing (S_surprise); Otto.playGesture (OttoFretful); Otto.sing (S_fart3); Otto.walk (2,1300, -1); Otto.turn (2,1000, -1); atraso (50); obstacleDetector (); } else {Otto.walk (1,1000,1); obstacleDetector (); }} //////////////////////////////////////////////////// /////////////////////-- Funções -------------------------- ------------------------ ////////////////////////// /////////////////////////////////////////////////// - Função executada quando o segundo botão é pushvoid secondButtonPushed () {buttonAPushed =true; if (! buttonPushed) {buttonPushed =true; Otto.putMouth (smallSurprise); }} // - Função executada quando o terceiro botão é pressionado para evitar o thirdButtonPushed () {buttonBPushed =true; if (! buttonPushed) {buttonPushed =true; Otto.putMouth (smallSurprise); }} // - Função para ler o sensor de distância e atualizar obstacleDetected variablevoid obstacleDetector () {int distance =Otto.getDistance (); if (distância <15) {obstacleDetected =true; } else {obstacleDetected =false; }} // - Função para receber o comando Stop.void receiveStop () {sendAck (); Otto.home (); sendFinalAck ();} // - Função para receber comandos LEDvoid receiveLED () {// sendAck ¶r se necessário sendAck (); Otto.home (); // Exemplos de comandos Bluetooth recebidosLED // L 000000001000010100100011000000000 // L 0011111111111111111111111111111111111 (todos los LED encendidos) unsigned long int matrix; char * arg; char * endstr; arg =SCmd.next (); //Serial.println (arg); if (arg! =NULL) {matriz =strtoul (arg, &endstr, 2); // Converte uma string de caracteres em um inteiro longo sem sinal Otto.putMouth (matrix, false); } else {Otto.putMouth (xMouth); atraso (2000); Otto.clearMouth (); } sendFinalAck ();} // - Função para receber comandos da campainha evite recieveBuzzer () {// sendAck ¶r se necessário sendAck (); Otto.home (); erro bool =falso; int frec; duração interna; char * arg; arg =SCmd.next (); if (arg! =NULL) {frec =atoi (arg); } // Converte uma string de caracteres em um inteiro else {error =true;} arg =SCmd.next (); if (arg! =NULL) {duração =atoi (arg); } // Converte uma string char em um inteiro else {error =true;} if (error ==true) {Otto.putMouth (xMouth); atraso (2000); Otto.clearMouth (); } else {Otto._tone (frec, duração, 1); } sendFinalAck ();} // - Função para receber comandos TRimsvoid receiveTrims () {// sendAck ¶r se necessário sendAck (); Otto.home (); int trim_YL, trim_YR, trim_RL, trim_RR; // Definição do comando Servo Bluetooth // C trim_YL trim_YR trim_RL trim_RR // Exemplos de comandos receiveTrims Bluetooth // C 20 0 -8 3 bool error =false; char * arg; arg =SCmd.next (); if (arg! =NULL) {trim_YL =atoi (arg); } // Converte uma string de caracteres em um inteiro else {error =true;} arg =SCmd.next (); if (arg! =NULL) {trim_YR =atoi (arg); } // Converte uma string de caracteres em um inteiro else {error =true;} arg =SCmd.next (); if (arg! =NULL) {trim_RL =atoi (arg); } // Converte uma string de caracteres em um inteiro else {error =true;} arg =SCmd.next (); if (arg! =NULL) {trim_RR =atoi (arg); } // Converte uma string char em um inteiro else {error =true;} if (error ==true) {Otto.putMouth (xMouth); atraso (2000); Otto.clearMouth (); } else {// Salvar no EEPROM Otto.setTrims (trim_YL, trim_YR, trim_RL, trim_RR); Otto.saveTrimsOnEEPROM (); // Remova o comentário apenas para um upload quando você finalmente definir os cortes. } sendFinalAck ();} // - Função para receber comandos Servo evitar receiveServo () {sendAck (); moveId =30; // Definição do comando Servo Bluetooth // G servo_YL servo_YR servo_RL servo_RR // Exemplo de comandos receiveServo Bluetooth // 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); } // Converte uma string de caracteres em um inteiro else {error =true;} arg =SCmd.next (); if (arg! =NULL) {servo_YR =atoi (arg); } // Converte uma string de caracteres em um inteiro else {error =true;} arg =SCmd.next (); if (arg! =NULL) {servo_RL =atoi (arg); } // Converte uma string de caracteres em um inteiro else {error =true;} arg =SCmd.next (); if (arg! =NULL) {servo_RR =atoi (arg); } // Converte uma string char em um inteiro else {error =true;} if (error ==true) {Otto.putMouth (xMouth); atraso (2000); Otto.clearMouth (); } else {// Atualizar Servo:int servoPos [4] ={servo_YL, servo_YR, servo_RL, servo_RR}; Otto._moveServos (200, servoPos); // Mover 200ms} sendFinalAck ();} // - Função para receber comandos de movimentovoid receiveMovement () {sendAck (); if (Otto.getRestState () ==true) {Otto.setRestState (false); } // Definição dos comandos Bluetooth de movimento // M MoveID T MoveSize char * arg; arg =SCmd.next (); if (arg! =NULL) {moveId =atoi (arg);} else {Otto.putMouth (xMouth); atraso (2000); Otto.clearMouth (); moveId =0; // parar} arg =SCmd.next (); if (arg! =NULL) {T =atoi (arg);} else {T =1000; } arg =SCmd.next (); if (arg! =NULL) {moveSize =atoi (arg);} else {moveSize =15; }} // - Função para executar o movimento correto de acordo com o comando de movimento recebido.void move (int moveId) {bool manualMode =false; switch (moveId) {case 0:Otto.home (); pausa; caso 1:// M 1 1000 Otto.walk (1, T, 1); pausa; caso 2:// M2 1000 Otto.walk (1, T, -1); pausa; caso 3:// M 3 1000 Otto.turn (1, T, 1); pausa; caso 4:// M 4 1000 Otto.turn (1, T, -1); pausa; caso 5:// M 5 1000 30 Otto.updown (1, T, moveSize); pausa; caso 6:// M 6 1000 30 Otto.moonwalker (1, T, moveSize, 1); pausa; caso 7:// M 7 1000 30 Otto.moonwalker (1, T, moveSize, -1); pausa; caso 8:// M 8 1000 30 Otto.swing (1, T, moveSize); pausa; caso 9:// M 9 1000 30 Otto.crusaito (1, T, moveSize, 1); pausa; caso 10:// M 10 1000 30 Otto.crusaito (1, T, moveSize, -1); pausa; caso 11:// M 11 1000 Otto.jump (1, T); pausa; case 12:// M 12 1000 30 Otto.flapping (1, T, moveSize, 1); pausa; case 13:// M 13 1000 30 Otto.flapping (1, T, moveSize, -1); pausa; caso 14:// M 14 1000 20 Otto.tiptoeSwing (1, T, moveSize); pausa; caso 15:// M 15 500 Otto.bend (1, T, 1); pausa; caso 16:// M 16 500 Otto.bend (1, T, -1); pausa; caso 17:// M 17 500 Otto.shakeLeg (1, T, 1); pausa; caso 18:// M 18 500 Otto.shakeLeg (1, T, -1); pausa; caso 19:// M 19 500 20 Otto.jitter (1, T, moveSize); pausa; caso 20:// M 20 500 15 Otto.ascendingTurn (1, T, moveSize); pausa; padrão:manualMode =true; pausa; } if (! manualMode) {sendFinalAck (); }} // - Função para receber comandos de gestosvoid receiveGesture () {// sendAck ¶r se necessário sendAck (); Otto.home (); // Definição de comandos Bluetooth Gesture // H GestureID int Gesture =0; char * arg; arg =SCmd.next (); if (arg! =NULL) {gesto =atoi (arg);} else {Otto.putMouth (xMouth); atraso (2000); Otto.clearMouth (); } switch (gesto) {case 1:// H 1 Otto.playGesture (OttoHappy); pausa; caso 2:// H 2 Otto.playGesture (OttoSuperHappy); pausa; caso 3:// H 3 Otto.playGesture (OttoSad); pausa; caso 4:// H 4 Otto.playGesture (OttoSleeping); pausa; caso 5:// H 5 Otto.playGesture (OttoFart); pausa; case 6:// H 6 Otto.playGesture (OttoConfused); pausa; caso 7:// H 7 Otto.playGesture (OttoLove); pausa; caso 8:// H 8 Otto.playGesture (OttoAngry); pausa; case 9:// H 9 Otto.playGesture (OttoFretful); pausa; case 10:// H 10 Otto.playGesture (OttoMagic); pausa; case 11:// H 11 Otto.playGesture (OttoWave); pausa; case 12:// H 12 Otto.playGesture (OttoVictory); pausa; caso 13:// H 13 Otto.playGesture (OttoFail); pausa; padrão:break; } sendFinalAck ();} // - Função para receber comandos singvoid receiveSing () {// sendAck &stop se necessário sendAck (); Otto.home (); // Definição dos comandos Sing Bluetooth // K SingID int sing =0; char * arg; arg =SCmd.next (); if (arg! =NULL) {sing =atoi (arg);} else {Otto.putMouth (xMouth); atraso (2000); Otto.clearMouth (); } switch (sing) {case 1:// K 1 Otto.sing (S_connection); pausa; caso 2:// K 2 Otto.sing (S_disconnection); pausa; caso 3:// K 3 Otto.sing (S_surprise); pausa; case 4:// K 4 Otto.sing (S_OhOoh); pausa; caso 5:// K 5 Otto.sing (S_OhOoh2); pausa; caso 6:// K 6 Otto.sing (S_cuddly); pausa; caso 7:// K 7 Otto.sing (S_sleeping); pausa; caso 8:// K 8 Otto.sing (S_happy); pausa; case 9:// K 9 Otto.sing (S_superHappy); pausa; case 10:// K 10 Otto.sing (S_happy_short); pausa; caso 11:// K 11 Otto.sing (S_sad); pausa; case 12:// K 12 Otto.sing (S_confused); pausa; caso 13:// K 13 Otto.sing (S_fart1); pausa; caso 14:// K 14 Otto.sing (S_fart2); pausa; caso 15:// K 15 Otto.sing (S_fart3); pausa; case 16:// K 16 Otto.sing (S_mode1); pausa; case 17:// K 17 Otto.sing (S_mode2); pausa; case 18:// K 18 Otto.sing (S_mode3); pausa; caso 19:// K 19 Otto.sing (S_buttonPushed); pausa; padrão:break; } sendFinalAck ();} // - Função para enviar medida do sensor ultrassônico (distância em "cm") void requestDistance () {Otto.home (); // pare se necessário int distance =Otto.getDistance (); Serial.print (F ("&&")); Serial.print (F ("D")); Serial.print (distância); Serial.println (F ("%%")); Serial.flush ();} // - Função para enviar sensor de ruído mensevóide requestNoise () {Otto.home (); // pare se necessário int microfone =Otto.getNoise (); // analogRead (PIN_NoiseSensor); Serial.print (F ("&&")); Serial.print (F ("N")); Serial.print (microfone); Serial.println (F ("%%")); Serial.flush ();} // - Função para enviar percentvoid da tensão da bateria requestBattery () {Otto.home (); // pare se necessário // A primeira leitura da bateria costuma ser uma leitura errada, portanto, iremos descartar este valor. double batteryLevel =Otto.getBatteryLevel (); Serial.print (F ("&&")); Serial.print (F ("B")); Serial.print (batteryLevel); Serial.println (F ("%%")); Serial.flush ();} // - Função para enviar programa IDvoid requestProgramId () {Otto.home (); // pare se necessário Serial.print (F ("&&")); Serial.print (F ("I")); Serial.print (ID do programa); Serial.println (F ("%%")); Serial.flush ();} // - Função para enviar Comando Ack (A) void sendAck () {delay (30); Serial.print (F ("&&")); Serial.print (F ("A")); Serial.println (F ("%%")); Serial.flush ();} // - Função para enviar o comando Ack final (F) void sendFinalAck () {delay (30); Serial.print (F ("&&")); Serial.print (F ("F")); Serial.println (F ("%%")); Serial.flush ();} // - Funções com animatics // ---------------------------------- ---------------------- void OttoLowBatteryAlarm () {double batteryLevel =Otto.getBatteryLevel (); if (batteryLevel <45) {while (! buttonPushed) {Otto.putMouth (thunder); Otto.bendTones (880, 2000, 1.04, 8, 3); // A5 =880 atraso (30); Otto.bendTones (2000, 880, 1.02, 8, 3); // A5 =880 Otto.clearMouth (); atraso (500); }}} void OttoSleeping_withInterrupts () {int bedPos_0 [4] ={100, 80, 60, 120}; if (! buttonPushed) {Otto._moveServos (700, bedPos_0); } para (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); atraso (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); atraso (500); } if (! buttonPushed) {Otto.putMouth (lineMouth); Otto.sing (S_cuddly); } Otto.home (); if (! buttonPushed) {Otto.putMouth (happyOpen);}} 

Fonte do Arduino

Peças personalizadas e gabinetes

Arquivos para impressão 3D Thingiverse .STL

Esquemas