Robot Wall-E controlado por Bluetooth

En este tutorial aprenderás paso a paso cómo programar tu propio robot Wall-E utilizando la plataforma Arduino y controlarlo desde una aplicación móvil. Este proyecto es ideal para quienes están dando sus primeros pasos en la robótica, ya que combina electrónica básica, programación y mecánica.

El robot Wall-E es un kit educativo que permite experimentar con sensores, motores y controladores, mientras desarrollas habilidades en programación con Arduino. ¡Al finalizar este tutorial, habrás creado un robot funcional que podrás personalizar y mejorar según tus propias ideas!

Materiales necesarios:

• Kit robot Wall-E, puedes adquirirlo en nuestra web: Kit robot Wall-E
  También puedes conseguir los planos en PDF para corte láser aquí: Planos Wall-E corte láser
  Este kit incluye toda la estructura del robot en MDF y 02 motores DC con sus respectivas ruedas.
  
  
• 01 Arduino Nano
  

  Controlará los motores para los movimientos del robot y el encendido y apagado de los LEDs de sus ojos.

  
  
• 01 Shield para Arduino Nano, puedes usar este que ya integra el driver L293D: Shield Arduino Nano v2
  Nota: También puedes usar otro shield más comercial como el expansion shield para Arduino Nano, pero tendrás que agregarle un driver L293D o L298N para poder controlar los motores del robot.
  

  Este Shield facilitará las conexiones de los componentes sin necesidad de usar un protoboard ni soldar componentes.  

• 01 interruptor ON/OFF.
  

  Este interruptor permitirá controlar la alimentación de todo el sistema, encendiendo y apagando el robot fácilmente.

  
  
  
• 01 Módulo bluetooth HC-05, HC-06 o HM-10, recomendamos este último ya que al ser BLE consume muy poca energía. Pero no te preocupes, si prefieres usar los otros modelos el código es el mismo.
  
  
  
  
  
• 02 LEDs.
  

  Simularán a los ojos del robot Wall-E.
  
  
  
  

• 02 resistencias de 220ohm o 330ohm.
  
• 02 baterías 18650, o si prefieres también puedes usar una batería LiPo de 2 celdas.
  El robot estará alimentado por 8.4V, el regulador del Shield se encargará de entregar el voltaje adecuado al Arduino y a los motores.

  
  

• 01 case para baterías con conector jack para arduino.
  
  

Paso 1: Ensamblaje del Robot

Antes de comenzar con la programación, es necesario armar correctamente el robot. El kit contiene todas las piezas necesarias: estructura en MDF, motores, ruedas, tornillos y tuercas.

Una vez que tengas tu kit, sigue las instrucciones de ensamblaje paso a paso que se incluye con el kit.

Paso 2: Diagrama de conexiones

Alimentación del robot:

Las baterías se conectarán directamente a la entrada del shield. Asegúrate de conectar el interruptor ON/OFF entre la fuente de alimentación y el conector jack para controlar el encendido y apagado del robot.

Conexión de los motores:

Conecta los dos motores DC a los conectores del Shield. El motor derecho se conecta a la salida MOTOR B, mientras que el motor izquierdo se conecta a MOTOR A.

Módulo Bluetooth:

El módulo bluetooth debe ir conectado directamente al conector correspondiente, para cuestiones gráficas en la imagen se agregaron cables, pero no son necesarios.

Si estás usando un shield que no tenga el conector para módulos bluetooth, debes conectarlo de la siguiente manera:

• Tx (PIN D0) -> Rx del módulo bluetooth
• Rx (PIN D1) -> Tx del módulo bluetooth
• 5V -> Vcc
• GND -> GND

Conexión de los LEDs:

Los LEDs deben ir conectados a dos pines digitales. En este caso, usamos los pines D12 y D13. Cada LED debe tener su respectiva resistencia.

Paso 3: Programación del Robot Wall-E

En esta etapa, cargaremos el programa que le dará vida a tu robot Wall-E. Usaremos el entorno de desarrollo de Arduino IDE para escribir y cargar el código al Arduino Nano. Este programa permitirá controlar el robot a través de comandos enviados por Bluetooth, y también encender o apagar sus ojos LED.

Código:

// Pines del driver L293D
const int ENA  = 11;
const int AIN1 = 10;
const int AIN2 = 9;
const int ENB  = 5;
const int BIN1 = 7;
const int BIN2 = 6;

// Pines LEDs ojos
const int OJO_D = 12;
const int OJO_I = 13;

bool estado_ojos = false;

void setup() {
  // Inicialización de pines de los motores DC
  pinMode(ENA, OUTPUT);
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);
  pinMode(BIN1, OUTPUT);
  pinMode(BIN2, OUTPUT);
  pinMode(ENB, OUTPUT);

  // Inicialización de pines de los ojos
  pinMode(OJO_D, OUTPUT);
  pinMode(OJO_I, OUTPUT);

  digitalWrite(OJO_D, LOW);
  digitalWrite(OJO_I, LOW);

  Serial.begin(9600);
}

void loop() {
  if (Serial.available()) {
    char comando = Serial.read();
    Serial.println(comando);

    switch (comando) {
      case 'A':  // Avanzar
        adelante();
        break;
      case 'R':  // Retroceder
        atras();
        break;
      case 'I':  // Girar a la izquierda
        izquierda();
        break;
      case 'D':  // Girar a la derecha
        derecha();
        break;
      case 'T':  // Detenerse
        detener();
        break;
      case 'O':  // Encender/apagar ojos
        cambiarEstadoOjos();
        break;
      default:
        break;
    }
  }
}

/********** MOVIMIENTOS DE LAS RUEDAS **********/

void adelante() {
  digitalWrite(AIN1, HIGH);
  digitalWrite(AIN2, LOW);
  digitalWrite(BIN1, LOW);
  digitalWrite(BIN2, HIGH);
  analogWrite(ENA, 150);  // Velocidad
  analogWrite(ENB, 150);  // Velocidad
}

void atras() {
  digitalWrite(AIN1, LOW);
  digitalWrite(AIN2, HIGH);
  digitalWrite(BIN1, HIGH);
  digitalWrite(BIN2, LOW);
  analogWrite(ENA, 150);  // Velocidad
  analogWrite(ENB, 150);  // Velocidad
}

void izquierda() {
  digitalWrite(AIN1, LOW);
  digitalWrite(AIN2, HIGH);
  digitalWrite(BIN1, LOW);
  digitalWrite(BIN2, HIGH);
  analogWrite(ENA, 100);  // Velocidad
  analogWrite(ENB, 100);  // Velocidad
}

void derecha() {
  digitalWrite(AIN1, HIGH);
  digitalWrite(AIN2, LOW);
  digitalWrite(BIN1, HIGH);
  digitalWrite(BIN2, LOW);
  analogWrite(ENA, 100);  // Velocidad
  analogWrite(ENB, 100);  // Velocidad
}

void detener() {
  digitalWrite(AIN1, LOW);
  digitalWrite(AIN2, LOW);
  digitalWrite(BIN1, LOW);
  digitalWrite(BIN2, LOW);
  analogWrite(ENA, 0);
  analogWrite(ENB, 0);
}

/********** ENCENDER/APAGAR OJOS **********/

void cambiarEstadoOjos() {
  estado_ojos = !estado_ojos;
  digitalWrite(OJO_D, estado_ojos ? HIGH : LOW);
  digitalWrite(OJO_I, estado_ojos ? HIGH : LOW);
}

Explicación:

1. Se definen los pines del driver L293D que controlan los motores DC, en el shield que usamos están conectados por defecto a los pines 5, 6, 7, 9, 10 y 11. Si estás usando otro shield y driver, debes usar los pines correspondientes:
   
   
   • ENA (pin 11): velocidad del motor izquierdo.
   • AIN1 (pin 10) y AIN2 (pin 9): dirección del motor izquierdo.
   • ENB (pin 5): velocidad del motor derecho.
   • BIN1 (pin 7) y BIN2 (pin 6): dirección del motor derecho.
     
     
2. Se definen los pines para los ojos LED:
   • OJO_D (pin 12): LED ojo derecho.
   • OJO_I (pin 13): LED ojo izquierdo.
     
     
3. Se crea una variable booleana estado_ojos, para guardar si los ojos están encendidos o apagados, permitiendo alternar su estado.
   
   
4. En la función setup():
   • Se configuran los pines de los motores y ojos como salidas.
   • Se inicia la comunicación serial a 9600 baudios para recibir comandos desde el módulo Bluetooth.
     
     
5. En el loop():
   • Se verifica si hay datos recibidos por Bluetooth.
   • Se lee un carácter y se evalúa cuál acción debe realizar el robot según el comando.
     
     
6. El robot responde a los siguientes comandos:
   • ‘A’: avanza hacia adelante.
   • ‘R’: retrocede.
   • ‘I’: gira a la izquierda.
   • ‘D’: gira a la derecha.
   • ‘T’: se detiene.
   • ‘O’: enciende o apaga los ojos LED alternadamente.
     
     
7. Cada acción de movimiento activa los pines correspondientes para controlar la dirección y velocidad de los motores (0 – 255).
   
   
8. La función cambiarEstadoOjos() alterna los pines 12 y 13 entre HIGH y LOW para encender o apagar los LEDs de los ojos.
   
   

Paso 4: Control Bluetooth

Para controlar el robot de manera remota por bluetooth, utilizaremos la aplicación móvil EduConnect, disponible en Google Play Store.

Descárgala aquí: EduConnect – Arduino Bluetooth.

Configuraremos la app de la siguiente manera, en Ajustes elegimos el modelo del módulo bluetooth, en este caso HM-10. Si estás usando un HC-05 o HC-06 sólo debes elegirlo, el código no varía:

En la pantalla de Comandos, configuraremos los siguientes comandos en la app:

Una vez que hayas terminado, solo necesitarás abrir la aplicación EduConnect en tu dispositivo móvil, conectarte al módulo Bluetooth del robot, y podrás comenzar a moverlo utilizando los botones de la app.

Si necesitas más detalles sobre como conectar la aplicación al módulo bluetooth, puedes revisar este tutorial.

Si tienes alguna duda, puedes dejar tu comentario y te ayudaremos.