ANTES DE COMENZAR, QUIERO ACLARAR QUE ESTA ENTRADA DE WIKI ES A MODO DE SEGUIMIENTO DEL PROYECTO Y HAY QUE LEERLO ENTERO ANTES DE REPLICARLO PORQUE HAY CAMBIOS SIGNIFICATIVOS A LO LARGO DE LA EXPLICACIÓN.

SI PREFIERES AHORRÁRTELO, POR FAVOR, VISITA LA DOCUMENTACIÓN CORTA DE ESTE MISMO PROYECTO.

Cómo este proyecto es en grupo, pero yo tomé la decisión de hacerlo en solitario, buscaba un proyecto sencillo y divertido para que mi robot educativo mostrara el concepto de "menos es más".

Pensando en qué me podría basar, recordé este vídeo de youtube. Lo que me llevó a tomar la siguiente decisión.

Debido a que este robot me pareció justo lo que quería, pero a su vez demasiado simple, decidí que mi proyecto sería ampliar este robot tan gracioso, a mi propio estilo.

Para ello, lo primero que hice fue pensar en qué componentes iba a utilizar, y, al final, decidí utilizar lo siguiente:

• Microprocesador Arduino: Éste iba a ser el cerebro de mi robot, debido a que lo he manejado antes y no me toca aprender nada nuevo

• 2 Servomotores: Para lograr el movimiento del robot:

Uno tendría conectado el brazo, que sólo debe dar una vuelta, demostramos el funcionamiento con este sencillo video de inkscape:

Y el otro, es simplemente para abrir la caja y lleva el siguiente mecanismo:

• 1 Sensor DHT11 de Humedad: Éste sería para la funcionalidad nueva que quería añadir, esto es, que dejase la pata en el botón hasta que lo soples (el año pasado comprobé que si soplas este sensor sus mediciones varían)

• 1 Sensor de Ultrasonidos: Este sensor sería también para una funcionalidad añadida mía, esta es, que Cascarrabias tenga miedo al contacto humano y, si te acercas demasiado, éste se esconderá.

• 1 Zumbador pasivo: Este actuador sirve para emitir sonidos, cosa que necesitaremos más adelante.

• 1 LED y 1 SWITCH: Para replicar la función de que, pulsando el botón, despiertas a Cascarrabias porque le enciendes la luz

Una vez pensado esto, el siguiente paso era ver cómo sería el circuito eléctrico de este proyecto, cosa que hice con thinkercad (NOTA: thinkercad no tenía sensor dht11, así que lo sustituí con el sensor negro de temperatura de la esquina inferior inzquierda) y, tampoco tenía switch, así que lo sustituí por lo que tiene un cable negro y otro amarillo:

Para esta parte del desarrollo, lo que había que hacer era ajustar el diagrama eléctrico anterior al diseño de nuestro cascarrabias, para ello, era necesario hacer bocetos y tener claros los materiales que íbamos a necesitar.

Para los materiales, tenía claro que iba a imprimir mis diseños en 3D (que dejaré en el repositorio para que se puedan descargar) ya que tenía acceso a una impresora, y era lo más sencillo.

En cuanto a los bocetos, los hice primero montando el cableado de forma sencilla para ver la longitud de los cables y poder ver las medidas de todo. Después con Inkscape dibujé el cómo podría ser y por último, con Freecad, diseñé las piezas que necesitaría para traer a Cascarrabias-9000 del mundo de las ideas a la realidad. Dejo por aquí dichos bocetos:

Para este montaje, no utilicé todas las piezas explicadas anteriormente, ya que era sólo para orientarme a la hora de escoger el tamaño de la caja y que me entrase todo bien, así que lo consideraremos montaje versión 1:

Después del montaje versión 1, pude hacer un boceto de lo que sería la caja en FreeCad, con tapa y todo, aunque, aún sin mecanismo de apertura.

Así es cómo quedó el primer boceto, la caja tiene un agujero para poder conectar el arduino al ordenador sin necesidad de sacarlo:

Para hacer el mecanismo de apertura, me fijé en este mecanismo que tiene la siguiente caseta de hámster:

Y, con esta guía, pude hacer el mecanismo de apertura de mi caja y por fin terminar su diseño, dejo por aquí los planos de la caja y su tapa, los diseños definitivos se encuentran aquí para descargarlos:

Lamentablemente, las piezas no encajaron bien cuando se imprimieron, por lo que quedaba una caja estática que no podía brirse y, además, las "visagras" de la caja se rompieron, por lo que, a la hora del montaje, en lugar de usar la idea del modelo, utilicé una visagra que compré para este propósito.

Una vez montada la caja, quedó así:

El modelo arreglado de la caja, para que funcione bien, lo adjunto a continuación (si vas a replicar el proyecto, descarga este en lugar del anterior)

Para diseñar a cascarrabias, sólo necesitaba hacerle la cara conectada al mecanismo pinion and crank para un motor y el brazo para el otro motor.

El mecanismo, lo encontré en este enlace, por lo que lo descargué y edité para que encajase con las medidas de mi proyecto antes de ponerlo a imprimir. Puedes descargar esta pieza aquí.

Después, para cascarrabias, había pensado basarme en esta imagen que encontré por internet:

Entonces, para diseñar nuestro cascarrabias, empecé por el boceto.

Para ello, lo que hice fue abrir esa imagen en inkscape, y, con una tableta gráfica, la calqué de la forma que habíamos visto en clase:

Después, llevé el dibujo a FreeCad, y lo extruí y añadí un rectángulo para hacer una especie de "moneda cascarrabias", aunque, los bordes que marcan la diferencia de colores no salieron, pero da igual porque se pueden pintar, o dejarlo en blanco para que cascarrabias parezca más un fantasma o criatura extraña:

Después, para hacer el diseño imprimible, recorté los trozos sobrantes extruyendo figuras creadas con el scketcher (para ahcer bien la forma), para así tener a cascarrabias terminado:

Para imprimir este modelo, puedes visitar este enlace para descargarlo

Pero, en realidad, lo que se va a utilizar es el mecanismo completo, que consta del piñón con el engranaje mencionado anteriormente. Para montar este mecanismo, simplemente uní el cascarrabias con el piñón en blender (para poderlo imprimir todo junto y así no necesitar pegamento ni nada para montarlo y para poder usar el stl del piñón). Después, convertí el nuevo stl (el de las 2 piezas juntas) a fichero freecad por si acaso quieres editar algo con la información de este enlace. Puedes descargar esta pieza aquí:

Lo que, una vez impreso, quedó así:

Pero, cómo es muy fino, decidí también diseñar un soporte, para luego sujetarlo de pie dentro de la caja y que se mueva sin tambalearse, este diseño es muy sencillo, ya que simplemente es un rectángulo con un hueco en el cabe el piñón del cuerpo de Cascarrabias, puedes descargarlo aquí.

Por último, para el brazo de cascarrabias, lo que hice fue una estructura con forma de U con cartón, que serviría para que Cascarrabias pudiese pulsar el botón, este mecanismo iría conectado al al segundo motor, de forma que el servo simplemente giraría para pulsar el botón.

Una vez impresas todas las piezas, podemos pasar a lo divertido del proyecto. ¡El montaje!

Cabe destacar que el diseño del circuito anteriormente diseñado cambió un poco, y al final quedó así justo antes del montaje:

Lo que, traducido a esquema utilizando Kicad queda así. Cabe destacar que en kicad no estaba disponible el sensor de distancia hc-sr04, por lo que tuve que sistituirlo por un ventilador cuyos pines son Tacho(usado como gnd), pwd, +(usado como echo) y -(usado como trig):

Y, ahora, dejaré por aquí cada paso del montaje y una breve explicación, a modo de tutorial, por favor, si vas a seguirlo, no montes nada en el arduino, ya que el orden es importante y se ira explicando a continuación.

Antes de comenzar el montaje, adjunto un esquema/plano del resultado final que esperamos, para que te sea de ayuda a la hora de seguir los siguientes pasos:

Primero, coloca la placa arduino y la protoboard de forma que no se vayan a mover dedntro de la caja, en mi caso, utilicé unas esponjas que tenía por casa, pero puedes utilizar el material que tengas a mano:

Después, enchufa adecuadamente el led y el switch, sin sacar nada de la caja:

A continuación, conecta a la placa el sensor de humedad y el ultrasonidos, de modo que, por fuera de la caja se vean asÍ (o cómo te ve nga bien según los materiales de los que dispongas). Para sujetarlos a la caja, también usé esponjas:

Conecta los motores con sus correspondientes estructuras de la siguiente manera. Es aquí dónde se diseña el brazo que accionará el botón (para tomar bien las medidas), en mi caso, hice una estructura en forma de U cuadrada con cartón, alambre y cinta, pero se puede hacer de cualquier otra forma siempre y cuando sirva para accionar el botón. Pero, una vez completé el montaje, me di cuenta de que el motor del brazo no tenía la suficiente fuerza como para accionar el botón, por lo que me vi obligada a darle un giro al comportamiento que iba a tener nuestro Cascarrabias-9000 y, en lugar de accionar él mismo el botón, nos obligará a nosotros a pulsarlo para apagarle la luz y permitirle dormir. Esto no cambia el montaje, sólo da más libertad a la hora de diseñar el brazo ya que lo importante es que se vea bien mientras se mueve.

Para esto, añadiremos un zumbador al sistema, lo que dejará nuestro circuito de la siguiente manera:

Y la caja quedaría así montada:

¡Ya podemos programar nuestro robot!

Una vez que Cascarrabias está montado, ha llegado la hora de hacerle ser Cascarrabias-9000 programando su comportamiento.

Para ello, los componentes electrónicos que se mencionan al principio de esta wiki serán los protagonistas, ya que programaremos su uso y comportamiento a continuación.

Para esta última tarea del desarrollo, lo que necesitamos es tener instalado arduino ide, si no lo tienes, puedes visitar este enlace para descargarlo.

Una vez instalado y funcionando Arduino ide, necesitaremos instalar 2 librerías, éstas son DHT y Servo. Para instalarlas, sigue los pasos de estas imágenes (estas que se muestran son para instalar DHT, Servo se explica después):

c

Para el caso del servo, los pasos son los mismos, pero la librería es la siguiente:

Una vez instaladas las librerías necesarias, simplemente puedes copiar el código en el fichero que desees y subirlo a tu placa, pero, cómo esta es la documentación extendida del proyecto, procederé a explicar el código detalladamente.

El código completo es el siguiente:

#include <Servo.h> 
#include <DHT.h>

// Initialice servos
Servo cabeza;
Servo brazo;

// Neccesary pins, EDIT AS YOU NEED
int LED = 13;
int SWITCH = 12;
int TRIG = 10;
int ECHO = 9;
int HUM = 7;
int HEAD_PIN = 4; 
int ARM_PIN = 5;
int BUZZER = 2;

// Motor angles. EDIT AS YOU NEED
int HEAD_UP = 50;
int HEAD_DOWN = 180;
int ARM_OUT = -180;
int ARM_IN = 180;
int HEAD_MED = 90;
int ARM_MED = 90;

// initialise dht11 sensor
DHT dht(HUM, DHT11);

// For control states
bool first_time = false;
bool secuence_done = false;
unsigned long initial_time = 0;
int hum = 0;
int dist = 0;
int SCARED = 1;
int DONT_SCARED = 2;

// FUNCTIONS WE NEED
long get_distance(){
  long t;
  long d;

  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  
  t = pulseIn(ECHO, HIGH);
  d = t/59;

  return d;
}

float get_humidity(){
  float h = dht.readHumidity();
  return h;
}

void get_out_of_box(int state){
  digitalWrite(LED, HIGH);
  delay(200);
  cabeza.write(HEAD_UP);
  if (state != SCARED){
    delay(600);
    brazo.write(ARM_OUT);
    delay(1000);
    brazo.write(ARM_IN);
    delay(600);
    brazo.write(ARM_OUT);
    delay(1000);
    brazo.write(ARM_IN);
    delay(600);
    brazo.write(ARM_OUT);
    delay(1000);
    brazo.write(ARM_IN);
  }
  
  return;
}

void get_in_box(){
  digitalWrite(LED, LOW);
  delay(200);
  brazo.write(HEAD_DOWN);
  delay(600);
  cabeza.write(ARM_IN);
  return;
}

void move_head(int velocity){
  cabeza.write(HEAD_MED);
  delay(velocity);
  cabeza.write(HEAD_UP);
  delay(velocity);
  cabeza.write(HEAD_MED);
  delay(velocity);
  cabeza.write(HEAD_UP);
  return;
}

void move_arm(int velocity){
  brazo.write(ARM_OUT);
  delay(velocity);
  brazo.write(ARM_MED);
  delay(velocity);
  brazo.write(ARM_OUT);
  delay(velocity);
  brazo.write(ARM_MED);
  delay(velocity);
  brazo.write(ARM_IN);
  return;
}

// Setup function for getting started our proyect
void setup() {
  Serial.begin(9600);
  pinMode(LED, OUTPUT);
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  pinMode(HUM, INPUT);
  pinMode(SWITCH, INPUT_PULLUP);
  pinMode(BUZZER, OUTPUT);
  digitalWrite(TRIG, LOW);
  dht.begin();
  cabeza.attach(HEAD_PIN);
  brazo.attach(ARM_PIN); 
  return;
}

void get_scared_if_necesary(){
  int hum = get_humidity();
  int dist = get_distance();
  Serial.println(hum);
  Serial.println(dist);
  if (hum > 70 || dist < 10){
    tone(BUZZER, 2000);
    get_in_box();
    get_out_of_box(SCARED);
  }
  noTone(BUZZER);
  return;
}

// Principal program
void loop() {
  if (digitalRead(SWITCH) == false) {
    // Elapsed time since button is pressed
    unsigned long current_time = millis();
    unsigned long elapsed_time = current_time - initial_time;
    
    if (first_time == false){
      for(int i=900; i>=800; i--) {
        tone(BUZZER, i);
        delay(10);
      }
      noTone(BUZZER);
      get_out_of_box(DONT_SCARED);
      first_time = true;
    }
    
    get_scared_if_necesary();

    if (elapsed_time > 10000 && elapsed_time <= 11000){ // SIENDO AMABLES
      if (secuence_done == false){
        tone(BUZZER, 900);
        delay(100);
        tone(BUZZER, 800);
        delay(100);
        noTone(BUZZER);
        delay(100);
        move_arm(1000);
        secuence_done = true;
      }

      get_scared_if_necesary();
      
    }else if (elapsed_time > 20000 && elapsed_time <= 21000) { // SIENDO MENOS AMABLES
      if (secuence_done == true){
        tone(BUZZER, 900);
        delay(1000);
        tone(BUZZER, 800);
        delay(1000);
        noTone(BUZZER);
        
        delay(100);
        move_arm(700);
        secuence_done = false;
      }

      get_scared_if_necesary();

    }else if (elapsed_time > 32000 && elapsed_time <= 33000) { // RECORDANDO NUESTRA EXISTENCIA 
      if (secuence_done == false){
        for(int i=800; i<=900; i++) {
          tone(BUZZER, i);
          delay(10);
        }
        noTone(BUZZER);
        secuence_done = true;
        delay(100);
        move_arm(500);
        delay(100);
        move_arm(500);
      }

      get_scared_if_necesary();

    }else if (elapsed_time > 40000 && elapsed_time <= 41000) { // COMENZANDO A ENFADARNOS
      if (secuence_done == true){
        for (int i = 0; i<=3; i++){
          tone(BUZZER, 900);
          delay(100);
          tone(BUZZER, 800);
          delay(100);
        }
        noTone(BUZZER);

        move_head(500);
        move_head(500);
        move_arm(200);
        move_arm(200);
        move_arm(200);

        secuence_done = false;
      }

      get_scared_if_necesary();

    }else if (elapsed_time > 55000 && elapsed_time <= 60000) { // PERDIENDO LA CORDURA
      if (secuence_done == false){
        tone(BUZZER, 900);
        delay(100);
        move_head(300);
        move_head(300);
        move_head(300);
        move_head(300);
        move_arm(150);
        move_arm(150);
        move_arm(150); 
        secuence_done = true;
      }
      noTone(BUZZER);
      get_scared_if_necesary();

    }else if (elapsed_time > 80000) { // VOLVIENDONOS LOCOS
      tone(BUZZER, 1000);
      move_head(200);
      move_head(200);
      move_head(200);
      move_head(200);
      move_arm(100);
      move_arm(100);
      move_arm(100); 
    }

  } else {
    // Button don't pressed, be inside the box and sleep
      if (first_time == true){
        tone(BUZZER, 1000);
        delay(100);
        tone(BUZZER, 1200);
        delay(100);
        noTone(BUZZER);
        first_time= false;
      }
      
      get_in_box();
      
      unsigned long current_time = millis();

      if (current_time - initial_time >= 10000) {
        initial_time = current_time;
        tone(BUZZER, 200);
        delay(100);
        tone(BUZZER, 250);
        delay(1000);
        noTone(BUZZER);
      }
  } 
}

Que, cómo se puede ver, es un programa para Arduino, con su setup para preparar los componentes y su loop, para definir el comportamiento de éstos. A continuación explicaremos lo más importante del código

A continuación, explicaremos las funciones que han sido necesarias para programar el Cascarrabias-9000.

Es una función muy simple que devuelve la medida de sensor de ultrasonidos, es decir, la distancia en centímetros.

Esta es otra función muy sencilla, que devuelve la humedad en el ambiente captada por el sensor DHT11.

Esta función es la encargada de que Cascarrabias abra la caja y presione el botón, moviendo los motores y encendiendo el led.

Esta función es contraria a la anterior, ya que apaga el led y hace que cascarrabias se esconda de nuevo en su mansión caja.

Esta función es para que cascarrabias se asuste si acercamos la mano o le soplamos.

En el loop en un programa Arduino, es dónde se plasma el comportamiento del dispositivo.

En nuestro caso, el comportamiento consiste en que cuando pulsas el botón, Cascarrabias sale de su caja, y nos pedirá amablemente que le apaguemos la luz y le dejemos dormir, sin embargo, cuanto más tardemos en accionar de nuevo el botón y más le molestemos, más se enfadará, y nos lo hará saber. Cabe destacar que, en mi caso, conecté el botón al revés, por lo que encendido para nosotros en el código es false. Si cuando cargues tu código no funciona, se recomienda que revises los pines y después cambies este valor a true.

Para hacernos saber que se va enfadando, dependiendo del tiempo que tardes en presionar de nuevo el botón, Cascarrabias cada vez es más "agresivo", para así obligarnos a presionar el botón.

Para conseguir esto, se usan temporizadores que van llamando a funciones cuando toca, en un "plazo" de X, cuando pasa este plazo, el ciclo se repite y empezamos desde el principio, dejo a continuación lo que pasa y en qué momento:

La primera vez que despertamos a Cascarrabias, éste intenta ser amable y pedir educadamente que presionemos el botón. Para ello, hará movimientos y sonidos suaves, para que captes su mensaje.

Si no captamos el mensaje a la primera, Cascarrabias irá perdiendo la paciencia, de modo que los movimientos y sonidos se alterarán un poco, pero aún no será desagradable.

La segunda vez que no sepas que lo que hay que hacer es presionar el botón, Cascarrabias dudará de tu inteligencia y/o atención y te indicará de nuevo que pulses el botón, haciendo un ruido de duda.

Si Cascarrabias ve que no le prestas atención, comenzará a enfadarse y a volver sus movimientos más bruscos y sus sonidos más estridentes, de modo que se note que se ha enfadado.

Este comportamiento será algo más agresivo que el anterior.

Si llegas a este punto, no solo Cascarrabias habrá perdido los modales, sino que tú también lo harás si no pulsas el botón rápidamente.

A parte de estos comportamientos, si acercamos demasiado la mano o soplamos en el sensor de humedad, CAscarrabias se asustará, a no ser que esté demasiado enfadado.

Una vez programado el Cascarrabias, la prueba que realicé con la tapa puesta me dio el poblema de que la placa se reiniciaba, por lo que me vi obligada a cambiar la tapa por una plancha de cartón, para asegurar de que la alimentación no se quedase corta a la hora de mover los motores, así que, si vas a replicar este proyecto, consigue unos motores más potentes que los que vienen por defecto en los kits de arduino (por si acaso), ya que son los que yo usé y asegúrate también de tener la alimentación por separado, si te es posible, al contrario que a mi.

La caja, después de este cambio, quedó así:

Una vez incluido el programa en la placa, nuestro cascarrabias se comportaba de la siguiente forma:

Por lo que podemos dar por concluido el proyecto.

Si has llegado hasta aquí: ¡Muchas gracias por seguir el desarrollo!