Construye tu propio robot en una hora con el kit Otto DIY

Componentes y suministros

• Kit Otto DIY Builder (×1)
• Shield Arduino NANO I/O para Otto DIY (×1)
• Arduino Nano Every (×1)
• Cable USB-A a Mini-USB (×1)
• Micro-servomotor SG90 (×4)
• Zumbador (×1)
• Cables jumper hembra-hembra (×6)
• Interruptor micro 8x8mm On/Off (×1)
• Portapilas 4xAA (×1)
• Pilas AA (×1)

Herramientas necesarias

• Impresora 3D (genérica)
• Destornillador Phillips

Aplicaciones y servicios en línea

• Arduino IDE
• Arduino Web Editor
• Extensión Microsoft Visual Studio Code para Arduino

Sobre este proyecto

¿Qué es Otto?

Otto es un robot interactivo que cualquiera puede construir. Camina, baila, emite sonidos y evita obstáculos.

¿Por qué es especial Otto?

Otto es completamente de código abierto, compatible con Arduino, imprimible en 3D y tiene una misión de impacto social para crear un entorno inclusivo para niños. Inspirado en el robot BoB the BiPed y programado usando código del robot bípedo Zowi.

Con piezas estándar e impresas en 3D, conexiones electrónicas simples (casi sin soldadura) y conocimientos básicos de programación, podrás construir tu propio amigo Otto en tan solo una hora. Diseñado con Autodesk 123D Design (ahora Tinkercad), puedes modificarlo para personalizarlo o mejorarlo.

Paso 1: Reunir todas las piezas y herramientas

Necesitarás imprimir 6 piezas en 3D:

• Cabeza (×1)
• Cuerpo (×1)
• Piernas (×2)
• Pies (×2)

Opcional: cúter para limpiar piezas impresas y soldador si deseas alimentación por batería.

Descarga los archivos .stl. Si no tienes impresora 3D, acude a tu makerspace local o compra el kit completo en www.ottodiy.com.

Configuración de impresión 3D

• Impresora FDM con filamento PLA
• Sin soportes ni raft
• Resolución: 0.15 mm
• Densidad de relleno: 20%

Usa software de laminado como Cura o FlashPrint. Tras imprimir, limpia ligeramente las áreas de fijación de los motores en piernas y pies.

Paso 2: Montaje de servos en los pies

Inserta los microservos en los pies y fíjalos con el tornillo pequeño. Verifica que giren al menos 90° a cada lado. Repite para el otro pie.

Paso 3: Fijar servos al cuerpo

Coloca los otros 2 microservos en las ubicaciones definidas en el cuerpo impreso y fíjalos con tornillos puntiagudos.

Paso 4: Unir piernas al cuerpo

Conecta las piernas al eje del microservo, verificando que giren 90° a cada lado respecto al cuerpo. Fija con tornillos pequeños.

Paso 5: Unir pies a las piernas

Pasa los cables por las ranuras del cuerpo y los agujeros de las piernas. Fija con tornillos puntiagudos desde la parte trasera.

Paso 6: Montaje de la cabeza

Empieza por el sensor de ultrasonidos: saca los «ojos» al límite. Coloca el Arduino Nano en el shield, suelda opcionalmente el portapilas (positivo a Vin, negativo a GND). Inserta ambas placas en diagonal orientando el conector USB hacia el orificio de la cabeza impresa y fija con los 2 tornillos restantes.

Paso 7: Conexiones eléctricas

Prepara cables DuPont, microinterruptor y zumbador. Sigue el diagrama de pines. Si no tienes el shield, usa una protoboard y el diagrama de TinkerCAD Circuits.

Programación con bloques

Puedes usar los códigos fuente de Arduino desde la Wikifactory de Otto. Tutoriales para principiantes:

• Tutorial servomotor
• Tutorial sensor ultrasónico
• Tutorial sensor táctil
• Tutorial zumbador

Visita www.ottodiy.com para más información. La versión Otto DIY+ añade Bluetooth, más sensores e interacciones.

Código

Evitación de obstáculos (Arduino)

//-----------------------------------------------------------------
//-- Zowi basic firmware v2 adapted to Otto
//-- (c) BQ. Released under a GPL license
//-- 04 December 2015
//-- Authors: Anita de Prado, Jose Alberca, Javier Isabel, Juan Gonzalez, Irene Sanz
//-----------------------------------------------------------------
#include <Servo.h>
#include <Oscillator.h>
#include <EEPROM.h>
#include <BatReader.h>
#include <US.h>
#include <LedMatrix.h>
#include <EnableInterrupt.h>
#include <OttoSerialCommand.h>
#include <Otto.h>

OttoSerialCommand SCmd;
Otto Otto;

#define PIN_YL 2
#define PIN_YR 3
#define PIN_RL 4
#define PIN_RR 5
#define PIN_SecondButton 6
#define PIN_ThirdButton 7

const char programID[]="Otto_todo";
const char name_fac='$';
const char name_fir='#';

int T=1000;
int moveId=0;
int moveSize=15;

volatile int MODE=0;
volatile bool buttonPushed=false;
volatile bool buttonAPushed=false;
volatile bool buttonBPushed=false;
unsigned long previousMillis=0;
int randomDance=0;
int randomSteps=0;
bool obstacleDetected = false;

void setup(){
  Serial.begin(115200);
  pinMode(PIN_SecondButton,INPUT);
  pinMode(PIN_ThirdButton,INPUT);
  Otto.init(PIN_YL,PIN_YR,PIN_RL,PIN_RR,true);
  randomSeed(analogRead(A6));
  enableInterrupt(PIN_SecondButton, secondButtonPushed, RISING);
  enableInterrupt(PIN_ThirdButton, thirdButtonPushed, RISING);
  
  SCmd.addCommand("S", receiveStop);
  SCmd.addCommand("L", receiveLED);
  SCmd.addCommand("T", recieveBuzzer);
  SCmd.addCommand("M", receiveMovement);
  SCmd.addCommand("H", receiveGesture);
  SCmd.addCommand("K", receiveSing);
  SCmd.addCommand("C", receiveTrims);
  SCmd.addCommand("G", receiveServo);
  SCmd.addCommand("D", requestDistance);
  SCmd.addCommand("N", requestNoise);
  SCmd.addCommand("B", requestBattery);
  SCmd.addCommand("I", requestProgramId);
  SCmd.addDefaultHandler(receiveStop);
  
  Otto.sing(S_connection);
  Otto.home();
  delay(50);
  for(int i=0; i<2; i++){
    for (int i=0;i<8;i++){
      if(buttonPushed){break;}
      Otto.putAnimationMouth(littleUuh,i);
      delay(150);
    }
  }
  if(!buttonPushed){
    Otto.putMouth(smile);
    Otto.sing(S_happy);
    delay(200);
  }
  if (EEPROM.read(5)==name_fir){
    if(!buttonPushed){ Otto.jump(1,700); delay(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();
}

void loop(){
  if(obstacleDetected){
    Otto.sing(S_surprise);
    Otto.playGesture(OttoFretful);
    Otto.sing(S_fart3);
    Otto.walk(2,1300,-1);
    Otto.turn(2,1000,-1);
    delay(50);
    obstacleDetector();
  } else{
    Otto.walk(1,1000,1);
    obstacleDetector();
  }
}

void secondButtonPushed(){
  buttonAPushed=true;
  if(!buttonPushed){ buttonPushed=true; Otto.putMouth(smallSurprise); }
}

void thirdButtonPushed(){
  buttonBPushed=true;
  if(!buttonPushed){ buttonPushed=true; Otto.putMouth(smallSurprise); }
}

void obstacleDetector(){
  int distance = Otto.getDistance();
  if(distance<15){ obstacleDetected = true; }
  else{ obstacleDetected = false; }
}

// Funciones de comunicación serial (recibir comandos, enviar ACK, etc.)
// ... (código completo disponible en el repositorio)

Instala primero las librerías desde GitHub OttoDIY.

Piezas personalizadas y envolventes

Archivos .STL imprimibles en 3D disponibles en Thingiverse.

Esquemáticos

Conexiones de servos, sensor ultrasónico, zumbador y batería. Usa cables DuPont.