Robot de control de gestos

Acerca de este proyecto

El robot de control por gestos es uno de los tipos de proyectos más comunes realizados por aficionados y estudiantes para comprender e implementar el conocimiento del microcontrolador en un proyecto físico y práctico. El concepto detrás de esto es simple:la orientación de la palma controla el movimiento del automóvil robot. ¿Cómo hace eso, preguntas? Vamos a analizarlo.

Para obtener una buena comprensión, avanzaremos entendiendo el papel y la función de cada componente y luego combinándolos para lograr el rendimiento deseado.

1. ADXL335 (acelerómetro)

La función del acelerómetro es simple:detectar la orientación de la muñeca. El acelerómetro mide la aceleración, incluida la aceleración debida a la gravedad 'g'. Por lo tanto, podemos usar el acelerómetro para detectar la orientación de la muñeca midiendo el componente de 'g' en cualquier eje particular de ADXL335 como se muestra en la siguiente figura:

Debido a la inclinación de la mano, el ángulo del eje X y / o Y con cambios verticales y, por lo tanto, un componente de la aceleración 'g' actúa sobre ellos también, lo que puede medirse y, por lo tanto, indica la orientación de la mano.

El ADXL335 puede medir hasta 3 g de aceleración y está interconectado con Arduino conectando sus pines de eje a los pines analógicos de Arduino. El acelerómetro emite valores de voltaje proporcionales a la aceleración.

En este proyecto, el acelerómetro está conectado a Arduino Nano y se adjunta a la palma. El ADXL335 emite voltaje en el rango de 0 a Vcc (voltaje aplicado generalmente 3.3V) y es leído por los pines analógicos de Arduino. Por lo tanto, para el usuario, obtenemos un valor en el rango de 0 a 1024 (ADC de 10 bits). La diferente orientación produce un valor analógico diferente para cada eje que luego se asigna a diferentes movimientos del robot.

El diagrama de circuito del acelerómetro es:

Un código de prueba para comprender el funcionamiento de ADXL335 es el siguiente:

  void setup () {pinMode (A0, INPUT); // el eje x está conectado a A0 pinMode (A1, INPUT); // el eje y está conectado a A1 pinMode (A2, INPUT); // el eje z está conectado a A2Serial.begin (9600); // Para imprimir datos en Serial Monitor} void loop () {Serial.print ("X ="); Serial.println (analogRead (A0)); Serial.print ("Y ="); Serial.println (analogRead (A1)); Serial.print ("Z ="); Serial.println (analogRead (A2)); retraso (1000);}  

Puede ejecutar este programa para ver qué valores obtiene para la inclinación hacia adelante, hacia atrás, hacia la izquierda y hacia la derecha de la palma de la mano y la muñeca, que se utilizarán finalmente para controlar el robot.

2. Transmisor y receptor RF-433

La función del módulo de RF es simple:transmitir datos de comando desde la muñeca Arduino Nano al motor que controla Arduino Uno. El módulo de RF utiliza ondas de radio a una frecuencia de 433 Hz y, por lo tanto, el nombre RF-433. Usan Modulación de Amplitud para enviar datos, pero sin entrar en muchos tecnicismos y manteniendo las cosas simples, se usarán para transmitir comandos al robot, es decir:avanzar, retroceder, derecha o izquierda. Y en caso de que no haya datos, quédese quieto. Funcionan bien hasta un alcance de 10 metros.

Ahora para comprender cómo implementar el módulo de RF en nuestro proyecto, trabajemos en los circuitos del transmisor y el receptor de forma secuencial.

Circuito transmisor

El circuito del transmisor consta de dos partes:el transmisor RF y el codificador HT12E. El transmisor consta de un pin de datos, una antena, una tierra y alimentación. Es el trabajo del codificador HT12E proporcionar datos al transmisor. El codificador consta de 4 pines de datos cuyos datos se pueden enviar. Usaremos estos 4 pines de datos para representar los cuatro movimientos, un ALTO en estos pines individualmente representará uno de los cuatro movimientos y un BAJO en todos representa que se quede quieto.

El diagrama del circuito es como se muestra:

Los pines de la izquierda (A0-A7) son los pines de dirección y definen el par que intercambiará datos (el transmisor y el receptor que tengan las mismas direcciones solo compartirán datos). Configuraremos A0-A7 como BAJO (conectado a tierra).

Los pines de entrada de datos están conectados a los pines digitales de Arduino (en este proyecto del 6 al 9) y generarán los datos de comando como:

Comando de clavija digital (cuando está ALTO)

9 Adelante

10 inversa

11 Izquierda

12 Derecha

Escribiremos digitalmente los pines digitales como ALTO según la entrada de ADXL335 para realizar el movimiento requerido.

Circuito receptor

El circuito del receptor es completamente similar al circuito del transmisor como se muestra, pero en lugar de los pines de datos como salida de Arduino, en este caso se leerán como entradas para recibir el comando de Arduino Uno y ejecutar los motores según sea necesario:

Para simplificar, puede conectar el LED en serie en el pin 17 con una resistencia de 1K en lugar del circuito complejo como se muestra para indicar la conexión adecuada con el transmisor.

3. PROTECTOR DEL MOTOR

El escudo del motor es la parte más fácil de manejar debido a la disponibilidad de la biblioteca de Adafruit AFMotor, enlace:- https://github.com/adafruit/Adafruit-Motor-Shield-library

Descargue y copie la biblioteca en la carpeta de bibliotecas de Arduino para poder incluirla en el boceto del programa.

Un ejemplo de biblioteca AFMotor es el siguiente:

  #include  AF_DCMotor motor (4); // Conecte los cables del motor al punto Motor 4 en la configuración del shieldvoid () {Serial.begin (9600); // configurar la biblioteca serial a 9600 bps Serial.println ("¡Prueba de motor!"); // enciende el motor motor.setSpeed ​​(200); motor.run (LIBERAR);} bucle vacío () {uint8_t i; Serial.print ("tic"); motor.run (ADELANTE); para (i =0; i <255; i ++) {motor.setSpeed ​​(i); retardo (10);} para (i =255; i! =0; i--) {motor.setSpeed ​​(i); delay (10);} Serial.print ("tac"); motor.run (HACIA ATRÁS); para (i =0; i <255; i ++) {motor.setSpeed ​​(i); retardo (10);} para (i =255; i! =0; i--) {motor.setSpeed ​​(i); delay (10);} Serial.print ("tecnología"); motor.run (LIBERAR); retraso (1000);  

4. Combinando todo

¡La última y última parte incluye combinar todas las partes anteriores juntas para formar el robot completo que sigue los comandos de la mano!

Dado que el escudo del motor usa casi todos los pines digitales, usaremos los pines analógicos de Arduino Uno para leer los datos del receptor. El diagrama de circuito final es el siguiente:

El escudo del motor maneja las conexiones a los motores. Conecte una batería de 9V a la entrada de energía del blindaje.

NOTA:Yo personalmente prefiero conectar 2 o incluso 3,9V baterías en paralelo a la entrada de energía del blindaje para proporcionar suficiente energía para hacer funcionar los cuatro motores. He conectado los cuatro motores en un grupo de 2 (los motores del mismo lado están conectados en paralelo y, por lo tanto, solo requieren los puntos de motor 3 y 4 para funcionar).

El código final

Para Arduino Nano:

  int x_axis =0; int y_axis =0; int forward =9; int backward =10; int right =11; int left =12; void setup () {pinMode (A0, INPUT); // PinMode del eje X (A3, SALIDA); // PinMode del eje Y (adelante, SALIDA); // ALTO para moverse hacia adelante pinMode (hacia atrás, SALIDA); // ALTO para retroceder pinMode (derecha, SALIDA); // HIGH para mover Right pinMode (izquierda, SALIDA); // HIGH para mover a la izquierda 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 (eje_y); if (eje_y> =390) {Serial.println ("Adelante"); digitalWrite (directo, ALTO); } else {if (y_axis <=310) {Serial.println ("BACK"); digitalWrite (hacia atrás, ALTA); } else {if (x_axis> =380) {Serial.println ("DERECHA"); digitalWrite (derecha, ALTA); } else {if (x_axis <=320) {Serial.println ("IZQUIERDA"); digitalWrite (izquierda, ALTA); } Serial.println (""); }}} retraso (200); if (eje_x> 320 &&eje_x <380 &&eje_y> 310 &&eje_y <390) {digitalWrite (adelante, BAJO); digitalWrite (hacia atrás, BAJO); digitalWrite (derecha, BAJA); digitalWrite (izquierda, BAJA); }}  

Para Arduino Uno:

  #include  AF_DCMotor motor_right (3); AF_DCMotor motor_left (4); int forward =0; int backward =0; int right =0; int left =0; void setup () { pinMode (A2, ENTRADA); pinMode (A3, ENTRADA); pinMode (A4, ENTRADA); pinMode (A5, ENTRADA); Serial.begin (9600); motor_right.setSpeed ​​(255); motor_left.setSpeed ​​(255); motor_right.run (LIBERAR); motor_left.run (RELEASE);} bucle vacío () {forward =digitalRead (A0); hacia atrás =digitalRead (A1); derecha =digitalRead (A2); izquierda =digitalRead (A3); if (adelante ==ALTO) {motor_right.run (ADELANTE); motor_left.run (ADELANTE); Serial.println ("Reenviar"); } if (hacia atrás ==HIGH) {motor_right.run (BACKWARD); motor_left.run (HACIA ATRÁS); Serial.println ("Invertir"); } if (right ==HIGH) {motor_right.run (FORWARD); motor_left.run (LIBERAR); Serial.println ("DERECHA"); } if (left ==HIGH) {motor_right.run (RELEASE); motor_left.run (ADELANTE); Serial.println ("IZQUIERDA"); } if (left ==LOW &&right ==LOW &&forward ==LOW &&backward ==LOW) {motor_right.run (RELEASE); motor_left.run (LIBERAR); } retraso (100);}  

Las fotos y videos están aquí: