Robot Controlado por Gestos: Construye tu Propio Bot con Detección de Movimiento

Componentes y Suministros

Componente	Cantidad
Arduino UNO	1
Arduino Nano R3	1
Módulo RF-433 Transmisor/Receptor	1
Codificador/Decodificador HT12	1
Acelerómetro Analógico Adafruit ADXL335	1
Shield de Motores para Uno	1
Motor DC (genérico)	1

Herramientas Necesarias

• Soldador (genérico)

Sobre este Proyecto

El robot controlado por gestos es uno de los proyectos más comunes para aficionados y estudiantes para entender e implementar conocimientos de microcontroladores en un proyecto físico y práctico. El concepto es simple: la orientación de la palma controla el movimiento del robot. Veamos cómo funciona desglosando cada componente.

1. ADXL335 (Acelerómetro)

La función del acelerómetro es detectar la orientación de la muñeca. Mide la aceleración incluyendo la gravedad 'g'. Así, podemos detectar la orientación midiendo la componente de 'g' en cada eje del ADXL335.

Debido a la inclinación de la mano, el ángulo de los ejes X e Y con la vertical cambia y una componente de la aceleración 'g' actúa sobre ellos, lo que puede medirse e indica la orientación de la mano.

El ADXL335 mide hasta 3g y se conecta a pines analógicos de Arduino. Emite voltajes proporcionales a la aceleración (0 a Vcc, típicamente 3.3V), leídos por el ADC de 10 bits de Arduino (valores 0-1024). Diferentes orientaciones producen diferentes valores analógicos por eje, que se mapean a movimientos del robot.

Circuito del Acelerómetro

El ADXL335 se conecta al Arduino Nano montado en la palma. Pines X, Y, Z a A0, A1, A2 respectivamente.

Código de Prueba para ADXL335

void setup() {
  pinMode(A0, INPUT); // X
  pinMode(A1, INPUT); // Y
  pinMode(A2, INPUT); // Z
  Serial.begin(9600);
}

void loop() {
  Serial.print(" X= "); Serial.println(analogRead(A0));
  Serial.print(" Y= "); Serial.println(analogRead(A1));
  Serial.print(" Z= "); Serial.println(analogRead(A2));
  delay(1000);
}

Ejecuta este programa para ver valores de inclinación adelante/atrás, izquierda/derecha para usar en control final.

2. Módulo RF-433 Transmisor y Receptor

Transmite comandos desde Arduino Nano (muñeca) a Arduino Uno (robot). Usa ondas de radio a 433 MHz con modulación de amplitud. Alcance hasta 10 metros. Transmite 4 comandos: adelante, atrás, izquierda, derecha; sin datos = quieto.

Circuito Transmisor

Consta de transmisor RF y codificador HT12E. El HT12E tiene 4 pines de datos (conectados a pines digitales 6-9 del Nano) que representan los 4 movimientos. Un HIGH en cada pin individualmente representa un movimiento; LOW en todos = quieto. Pines de dirección A0-A7 puestos a LOW (GND).

Circuito Receptor

Similar al transmisor pero con decodificador HT12D. Los pines de datos se leen como entradas en Arduino Uno (pines analógicos A0-A3) para recibir comandos y mover motores.

3. Shield de Motores

Se usa shield Adafruit con biblioteca AFMotor (GitHub). Maneja conexiones a motores DC. Se recomienda alimentar con 2-3 baterías 9V en paralelo al shield para potencia suficiente. Los 4 motores se agrupan en 2 pares (mismos lados en paralelo) usando solo salidas motor 3 y 4.

4. Integrando Todo

El shield de motores usa casi todos los pines digitales, así que el Arduino Uno lee datos del receptor en pines analógicos. Diagrama final de conexiones en proyecto original.

Código Final

Para Arduino Nano (Transmisor en la muñeca)

int x_axis = 0, y_axis = 0;
int forward = 9, backward = 10, right = 11, left = 12;

void setup() {
  pinMode(A0, INPUT);  // X
  pinMode(A3, OUTPUT); // Y (nota: A3 como salida en original)
  pinMode(forward, OUTPUT);
  pinMode(backward, OUTPUT);
  pinMode(right, OUTPUT);
  pinMode(left, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  x_axis = analogRead(A0);
  y_axis = analogRead(A3);
  
  Serial.print(" X = "); Serial.println(x_axis);
  Serial.print(" Y = "); Serial.println(y_axis);
  
  if (y_axis >= 390) {
    Serial.println("Adelante");
    digitalWrite(forward, HIGH);
  } else if (y_axis <= 310) {
    Serial.println("Atrás");
    digitalWrite(backward, HIGH);
  } else if (x_axis >= 380) {
    Serial.println("Derecha");
    digitalWrite(right, HIGH);
  } else if (x_axis <= 320) {
    Serial.println("Izquierda");
    digitalWrite(left, HIGH);
  } else {
    Serial.println(" ");
  }
  
  delay(200);
  
  // Apagar todos si en zona muerta
  if (x_axis > 320 && x_axis < 380 && y_axis > 310 && y_axis < 390) {
    digitalWrite(forward, LOW);
    digitalWrite(backward, LOW);
    digitalWrite(right, LOW);
    digitalWrite(left, LOW);
  }
}

Para Arduino Uno (Receptor en el robot)

#include 

AF_DCMotor motor_right(3);
AF_DCMotor motor_left(4);

int forward=0, backward=0, right=0, left=0;

void setup() {
  pinMode(A0, INPUT); // Adelante
  pinMode(A1, INPUT); // Atrás
  pinMode(A2, INPUT); // Derecha
  pinMode(A3, INPUT); // Izquierda
  
  Serial.begin(9600);
  motor_right.setSpeed(255);
  motor_left.setSpeed(255);
  motor_right.run(RELEASE);
  motor_left.run(RELEASE);
}

void loop() {
  forward = digitalRead(A0);
  backward = digitalRead(A1);
  right = digitalRead(A2);
  left = digitalRead(A3);
  
  if (forward == HIGH) {
    motor_right.run(FORWARD);
    motor_left.run(FORWARD);
    Serial.println("Adelante");
  }
  if (backward == HIGH) {
    motor_right.run(BACKWARD);
    motor_left.run(BACKWARD);
    Serial.println("Atrás");
  }
  if (right == HIGH) {
    motor_right.run(FORWARD);
    motor_left.run(RELEASE);
    Serial.println("Derecha");
  }
  if (left == HIGH) {
    motor_right.run(RELEASE);
    motor_left.run(FORWARD);
    Serial.println("Izquierda");
  }
  if (left==LOW && right==LOW && forward==LOW && backward==LOW) {
    motor_right.run(RELEASE);
    motor_left.run(RELEASE);
  }
  delay(100);
}

Fotos y Videos

Disponibles en el proyecto original (imágenes del montaje y funcionamiento).