Cómo hacer un robot de control por gestos en casa

Acerca de este proyecto

Se trata de cómo hacer usted mismo un automóvil controlado por gestos. Básicamente, esta es una aplicación simple del acelerómetro, giroscopio de 3 ejes MPU-6050. Puedes hacer muchas más cosas. entendiendo cómo usarlo, cómo conectarlo con Arduino y cómo transferir sus datos a través de los módulos Bluetooth. en este artículo, me centraré en la comunicación de Bluetooth a Bluetooth, entre dos módulos de Bluetooth HC-05.

Siga el video para construir un cuerpo de robot y conexiones para este proyecto.

El diagrama de conexión para el robot y la unidad transmisora ​​se proporcionan a continuación, puede consultarlos.

PCB de pedido directo utilizado en este proyecto desde PCBway:https://www.pcbway.com/project/shareproject/How_to_Make_Arduino_Based_Edge_Avoiding_Robot.html

Ahora hablemos de la configuración del módulo Bluetooth. Básicamente, el módulo Bluetooth HC-05 viene con una configuración de fábrica del módulo esclavo. eso significa que podemos enviar datos al módulo jus enchufándolo. No es necesario realizar ninguna otra configuración para enviar datos desde dispositivos móviles al módulo HC-05. simplemente ingrese su contraseña predeterminada (1234/0000) para conectarse. pero ¿qué pasa si queremos enviar datos usando este módulo a algún otro módulo del mismo oa un dispositivo móvil?

en este proyecto, hacemos lo mismo enviando datos a través del módulo Bluetooth. recogido por el sensor giroscópico mpu-6050 al otro módulo Bluetooth.

Así que primero configure el primer módulo bluetooth como dispositivo esclavo. para hacer esto, conéctelo con Arduino según este diagrama de cableado.

Y cargue el código por nombre configure.

  #include  
 SoftwareSerial BTSerial (10, 11); // RX | TX 
 void setup () 
 {
 Serial.begin (9600); 
 Serial.println ("Ingresar comandos AT:"); 
 BTSerial.begin (38400 ); // Velocidad predeterminada de HC-05 en el comando AT more 
} 
 void loop () 
 {
 // Siga leyendo de HC-05 y envíe a Arduino Serial Monitor 
 if (BTSerial.available ()) 
 Serial.write (BTSerial.read ()); 
 // Siga leyendo desde Arduino Serial Monitor y envíe a HC-05 
 if (Serial. disponible ()) 
 BTSerial.write (Serial.read ()); 
}  

Desconecte el módulo. Mantenga presionada la tecla ky en el módulo y vuelva a conectarlo. Verá que el LED del módulo parpadea más lentamente. Una vez cada 2 segundos. Esto significa que el HC-05 está en el modo de comando AT. Ahora abra el monitor en serie, cambie la velocidad en baudios a 9600 y el tipo de salida como NL y CR. Ahora escriba AT en el cuadro de envío y envíelo. si responde ok, significa que todo está bien. Pero si no es así, y responde con algún error, envía AT nuevamente. Hasta que responda con ok o chequear conexiones y enviar AT de nuevo…

después de obtener la respuesta correcta del módulo, ingrese los siguientes comandos uno por uno,

AT + ORGL y envíalo. este comando establecerá el módulo en la configuración de fábrica.

AT + RMAAD este comando liberará el módulo de cualquier emparejamiento anterior

AT + UART? comprobar la velocidad en baudios actual del módulo

AT + UART =38400, 0, 0 establece la velocidad en baudios como 38400

EN + PAPEL? compruebe el rol si es esclavo o maestro. responde con 0 o 1. si el módulo es esclavo, responde 0 y si es un dispositivo maestro, responderá con 1

establecer la función como dispositivo esclavo. ingrese AT + ROLE =0

AT + DIRECCIÓN? verifique la dirección del módulo.

Anote esta dirección. respondió por módulo. después de obtener esta dirección, se realiza la configuración del módulo esclavo.

Ahora es el momento de configurar el segundo módulo Bluetooth como dispositivo maestro. Conecte este módulo con la placa Arduino e introdúzcalo en el modo AT. como hicimos con el anterior.

Ingrese estos comandos AT según la secuencia dada.

AT + ORGL

AT + RMAAD

AT + UART?

AT + UART =38400, 0, 0

¿AT + PAPEL?

establezca la función de este módulo como dispositivo maestro. AT + PAPEL =1

AT + CMODE =0 para que el módulo conecte solo un dispositivo. la configuración predeterminada es 0

ahora vincule este módulo con el dispositivo esclavo para hacer esto, ingrese,

AT + BIND ="la dirección del módulo esclavo" y todo listo

ahora instale bibliotecas para el sensor MPU-6050 y una comunicación I2C. Dado que el sensor giroscópico MPU-6050 tiene una interfaz I2C. descargue las bibliotecas y el código fuente desde aquí:http://www.mediafire.com/file/l8mru5emulb8x93/gesture_control_robot.rar/file

si ha preinstalado estas bibliotecas, omita esto.

Ahora conecte la unidad de automóvil con la PC mediante un cable USB. seleccione el puerto de comunicación y el tipo de placa correctos. Y cargue el programa con el nombre "Gesture_controled_Robot__car_unit_". Asegúrese de que la batería y el módulo Bluetooth no estén conectados con el automóvil mientras carga el programa.

  // programa de Shubham Shinganapure el 3-10-2019 
 // 
 // para coche robótico controlado por gestos 
 int lm1 =8; // salida del motor izquierdo 1 
 int lm2 =9; // salida del motor izquierdo 2 
 int rm1 =10; // salida del motor derecho 1 
 int rm2 =11; // salida del motor derecho 2 
 char d =0; 
 void setup () 
 {
 pinMode (lm1, OUTPUT); 
 pinMode (lm2, OUTPUT); 
 pinMode (rm1, SALIDA); 
 pinMode (rm2, SALIDA); 
 Serial.begin (38400); 
 sTOP (); 
} 
 bucle vacío () 
 {
 if (Serial.available ()> 0) 
 {
 d =Serial.read (); 
 if (d ==' F ') 
 {
 ForWard (); 
} 
 if (d ==' B ') 
 {
 BackWard (); 
} 
 if (d =='L') 
 {
 Izquierda (); 
} 
 if (d =='R') 
 {
 Derecha (); 
} 
 if (d =='S') 
 {
 sTOP (); 
} 
} 
} 
 void ForWard () 
 {
 digitalWrite (lm1, HIGH); 
 digitalWrite (lm2, LOW); 
 digitalWrite (rm1, HIGH); 
 digitalWrite (rm2, LOW); 
} 
 void BackWard () 
 {
 digitalWrite (lm1, LOW); 
 digitalWrite (lm2, HIGH ); 
 digitalWrite (rm1, LOW); 
 digitalWrite (rm2, HIGH); 
} 
 void Left () 
 {
 digitalWrite (lm1, LOW); 
 digitalWrite (lm2, HIGH); 
 digitalWrite (rm1, HIGH); 
 digitalWrite (rm2, LOW); 
} 
 void Right () 
 {
 digitalWrite (lm1, HIGH); 
 digitalWrite (lm2, LOW); 
 digitalWrite (rm1, LOW); 
 digitalWrite (rm2, HIGH); 
} 
 void STOP () 
 {
 digitalWrite (lm1, LOW); 
 digitalWrite (lm2, LOW); 
 digitalWrite (rm1, LOW); 
 digitalWrite ( rm2, BAJO); 
}  

Haga lo mismo con la unidad remota. programa abierto por nombre remoto. y cárguelo en la unidad remota.

  // programa modificado el 10/3/19 por // por Shubham Shinganapure. 
 // 
 // para coche robótico controlado por gestos (remoto) 
 #include " I2Cdev.h "
 #include" MPU6050_6Axis_MotionApps20.h "
 // # include" MPU6050.h "// no es necesario si se utilizan MotionApps incluyen el archivo 
 // Se requiere la biblioteca Arduino Wire si I2Cdev Implementación de I2CDEV_ARDUINO_WIRE 
 // se usa en I2Cdev.h 
 #if I2CDEV_IMPLEMENTATION ==I2CDEV_ARDUINO_WIRE 
 #include "Wire.h" 
 #endif 
 // clase predeterminada I2C La dirección es 0x68 
 // Las direcciones I2C específicas se pueden pasar como parámetro aquí 
 // AD0 low =0x68 (predeterminado para la placa de evaluación SparkFun breakout e InvenSense) 
 // AD0 high =0x69 
 MPU6050 mpu; 
 #define OUTPUT_READABLE_YAWPITCHROLL 
 // Control MPU / variables de estado 
 bool dmpReady =false; // establecer verdadero si DMP init fue exitoso 
 uint8_t mpuIntStatus; // contiene el byte de estado de interrupción actual de MPU 
 uint8_t devStatus; // devuelve el estado después de cada operación del dispositivo (0 =éxito,! 0 =error) 
 uint16_t packetSize; // tamaño esperado del paquete DMP (el valor predeterminado es 42 bytes) 
 uint16_t FIFoCount; // recuento de todos los bytes actualmente en FIFO 
 uint8_t FIFOBuffer [64]; // Búfer de almacenamiento FIFO 
 VectorFloat gravity; 
 Quaternion q; 
 float ypr [3]; // [guiñada, cabeceo, balanceo] guiñada / cabeceo / balanceo contenedor y vector de gravedad 
 uint8_t teapotPacket [14] ={'$', 0x02, 0,0, 0,0, 0,0, 0,0 , 0x00, 0x00, '\ r', '\ n'}; 
 volátil bool mpuInterrupt =false; // indica si el pin de interrupción de MPU se ha elevado 
 void dmpDataReady () {
 mpuInterrupt =true; 
} 
 #include  
 SoftwareSerial BTSerial ( 10, 11); // RX | TX 
 int bt =8; 
 int x =1; 
 void setup () {
 #if I2CDEV_IMPLEMENTATION ==I2CDEV_ARDUINO_WIRE 
 Wire.begin (); 
 TWBR =24; // Reloj I2C de 400 kHz (200 kHz si la CPU es de 8 MHz) 
 #elif I2CDEV_IMPLEMENTATION ==I2CDEV_BUILTIN_FASTWIRE 
 Fastwire ::setup (400, true); 
 #endif 
 // inicializar serie comunicación 
 // (115200 elegido porque es necesario para la salida Teapot Demo, pero es 
 // realmente depende de usted dependiendo de su proyecto) 
 Serial.begin (115200); 
 BTSerial.begin (38400); 
 // while (! Serial); // espera la enumeración de Leonardo, otros continúan inmediatamente 
 Serial.println (F ("Inicializando dispositivos I2C ...")); 
 mpu.initialize (); 
 // verifica la conexión 
Serial.println(F("Prueba de conexiones de dispositivo ... ")); 
 Serial.println (mpu.testConnection ()? F (" Conexión de MPU6050 exitosa "):F (" Error de conexión de MPU6050 " )); 
 // esperar a que esté listo 
 // cargar y configurar el DMP 
 Serial.println (F ("Initializing DMP ...")); 
 devStatus =mpu .dmpInitialize (); 
 // proporcione aquí sus propias compensaciones de giro, escaladas para sensibilidad mínima 
 mpu.setXGyroOffset (220); 
 mpu.setYGyroOffset (76); 
 mpu. setZGyroOffset (-85); 
 mpu.setZAccelOffset (1788); 
 // asegúrese de que funcionó (devuelve 0 si es así) 
 if (devStatus ==0) {
 / / enciende el DMP, ahora que está listo 
 Serial.println (F ("Habilitando DMP ...")); 
 mpu.setDMPEnabled (true); 
 // habilita la interrupción de Arduino detección 
 Serial.println (F ("Habilitando la detección de interrupciones (interrupción externa Arduino 0) ...")); 
 a ttachInterrupt (0, dmpDataReady, RISING); 
 mpuIntStatus =mpu.getIntStatus (); 
 // establece nuestro indicador DMP Ready para que la función main loop () sepa que está bien usarlo 
 Serial .println (F ("¡DMP listo! Esperando la primera interrupción ... ")); 
 dmpReady =true; 
 // obtiene el tamaño de paquete DMP esperado para una comparación posterior 
 packetSize =mpu.dmpGetFIFOPacketSize (); 
} else {
 // ¡ERROR! 
 // 1 =falló la carga de memoria inicial 
 // 2 =fallaron las actualizaciones de configuración de DMP 
 // (si se va a romper, normalmente el código será 1) 
 Serial.print (F ("Error de inicialización DMP (código")); 
 Serial.print (devStatus); 
 Serial.println (F (")")); 
} 
 // configurar LED para salida 
 pinMode (bt, INPUT); 
} 
 // ==============================================================
 // ===BUCLE PRINCIPAL DEL PROGRAMA ===
 // ================================================================
 bucle vacío () {
 if (digitalRead (bt) ==HIGH) 
 {
 x ++; 
 delay (150); 
} 
 if ((x% 2) ==0) {
 // si la programación falló, no intente hacer nada 
 if (! dmpReady) return; 
 // espere la interrupción de MPU o paquetes adicionales disponibles 
 while (! mpuInterrupt &&FIFoCount  // aquí hay otras cosas sobre el comportamiento del programa 
 //. 
 //. 
 //. 
 // si eres realmente paranoico, puedes probar con frecuencia entre otras 
 // cosas para ver si mpuInterrupt es verdadero, y si es así, "break;" del 
 // bucle while () para procesar inmediatamente los datos de MPU 
 //. 
 //. 
 //. 
} 
 // restablecer el indicador de interrupción y obtener el byte INT_STATUS 
 mpuInterrupt =false; 
 mpuIntStatus =mpu.getIntStatus ( ); 
 // obtener el conteo FIFO actual 
 FIFOCount =mpu.getFIFOCount (); 
 // verificar el desbordamiento (esto nunca debería suceder a menos que nuestro código sea demasiado ineficiente) 
 si ((mpuIntStatus &0x10) || FifoCount ==1024) {
 // Restablecer para que podamos continuar limpiamente 
 mpu.resetFIFO (); 
 Serial.println (F ("¡Desbordamiento FIFO!")); 
 // de lo contrario, verifique la interrupción de datos DMP listos (esto debería suceder con frecuencia) 
} else if (mpuIntStatus &0x02) {
 // espere la longitud correcta de los datos disponibles, debería ser una espera MUY breve 
 while (FIFOCount  // leer un paquete de FIFO 
 mpu.getFIFOBytes (FIFOBuffer, packetSize); 
 // rastrear el conteo FIFO aquí en caso de que haya> 1 paquete disponible 
 // (esto nos permite leer más inmediatamente sin esperar una interrupción) 
 FIFoCount - =packetSize; 
 #ifdef OUTPUT_READABLE_YAWPITCHROLL 
 // mostrar Ángulos de Euler en grados 
 mpu.dmpGetQuaternion (&q, FIFoBuffer); 
 mpu.dmpGetGravity (&gravity, &q); 
 mpu.dmpGetYawPitchRoll (ypr, &q, &gravity); 
 Serial .print ("ypr \ t"); 
 Serial.print (ypr [0] * 180 / M_PI); 
 Serial.print ("\ t"); 
 Serial.print ( ypr [1] * 180 / M_PI); 
 Serie .print ("\ t"); 
 Serial.println (ypr [2] * 180 / M_PI); 
 if ((ypr [1] * 180 / M_PI) <=-25) 
{BTSerial.write('F '); 
} 
 else if ((ypr [1] * 180 / M_PI)> =25) 
 {BTSerial.write (' B ' ); 
} 
 else if ((ypr [2] * 180 / M_PI) <=-25) 
{BTSerial.write('L '); 
} 
 else if ((ypr [2] * 180 / M_PI)> =20) 
 {BTSerial.write ('R'); 
} 
 else {
 BTSerial. write ('S'); 
} 
 #endif 
} 
} 
 else {
 BTSerial.write ('S'); 
} 
}  

Inserte el módulo Bluetooth esclavo en la unidad del automóvil y domine el módulo Bluetooth en la unidad remota. Y todo listo.

Encendámoslo y estará listo para jugar …….

Espero que encuentres esto útil. si es así, dale me gusta, compártelo, comenta tu duda. ¡Para más proyectos de este tipo, sígueme! Apoya mi trabajo y suscríbete a Mi canal en YouTube.

¡Gracias!

Código

• Robot controlado por gestos (unidad remota)

Robot controlado por gestos (unidad remota) Arduino

 // programa modificado el 10/3/19 por // por Shubham Shinganapure. //// para coche robótico controlado por gestos (remoto) #include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" // #incluye "MPU6050.h" // no es necesario si usa MotionApps include file // La biblioteca Arduino Wire es requerido si I2Cdev I2CDEV_ARDUINO_WIRE implementación // se usa en I2Cdev.h # si I2CDEV_IMPLEMENTATION ==I2CDEV_ARDUINO_WIRE #include "Wire.h" # endif // La dirección I2C predeterminada de la clase es 0x68 // Las direcciones I2C específicas pueden pasarse aquí como un parámetro // AD0 low =0x68 (predeterminado para la placa de evaluación SparkFun breakout y InvenSense) // AD0 high =0x69MPU6050 mpu; #define OUTPUT_READABLE_YAWPITCHROLL // Control / estado de MPU varsbool dmpReady =false; // establecer verdadero si DMP init fue exitosouint8_t mpuIntStatus; // contiene el byte de estado de interrupción real de MPUuint8_t devStatus; // devuelve el estado después de cada operación del dispositivo (0 =éxito,! 0 =error) uint16_t packetSize; // tamaño esperado del paquete DMP (el valor predeterminado es 42 bytes) uint16_t FIFoCount; // recuento de todos los bytes actualmente en FIFOuint8_t fifoBuffer [64]; // Búfer de almacenamiento FIFOVectorFloat gravity; Quaternion q; flotar ypr [3]; // [guiñada, cabeceo, balanceo] guiñada / cabeceo / balanceo contenedor y vector de gravedaduint8_t teapotPacket [14] ={'$', 0x02, 0,0, 0,0, 0,0, 0,0, 0x00, 0x00, '\ r', '\ n'}; volátil bool mpuInterrupt =falso; // indica si el pin de interrupción de MPU se ha vuelto altovoid dmpDataReady () {mpuInterrupt =true;} # include  SoftwareSerial BTSerial (10, 11); // RX | TXint bt =8; int x =1; configuración vacía () {#if I2CDEV_IMPLEMENTATION ==I2CDEV_ARDUINO_WIRE Wire.begin (); TWBR =24; // Reloj I2C de 400 kHz (200 kHz si la CPU es de 8 MHz) #elif I2CDEV_IMPLEMENTATION ==I2CDEV_BUILTIN_FASTWIRE Fastwire ::setup (400, true); #endif // inicializar la comunicación en serie // (se eligió 115200 porque es necesario para la salida de la demostración de Teapot, pero // realmente depende de usted según su proyecto) Serial.begin (115200); BTSerial.begin (38400); // mientras (! Serial); // espera la enumeración de Leonardo, otros continúan inmediatamenteSerial.println (F ("Inicializando dispositivos I2C ...")); mpu.initialize (); // verifica la conexión Serial.println (F ("Probando las conexiones del dispositivo ...")); Serial.println (mpu.testConnection ()? F ("Conexión de MPU6050 exitosa"):F ("Error de conexión de MPU6050")); // esperar a que esté listo // cargar y configurar el DMP Serial.println (F ("Inicializando DMP ...")); devStatus =mpu.dmpInitialize (); // proporcione aquí sus propias compensaciones giroscópicas, escaladas para sensibilidad mínima mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1788); // asegúrese de que funcionó (devuelve 0 si es así) if (devStatus ==0) {// enciende el DMP, ahora que está listo Serial.println (F ("Habilitando DMP ...")); mpu.setDMPEnabled (verdadero); // habilita la detección de interrupciones de Arduino Serial.println (F ("Habilitando la detección de interrupciones (interrupción externa de Arduino 0) ...")); attachInterrupt (0, dmpDataReady, RISING); mpuIntStatus =mpu.getIntStatus (); // establece nuestro indicador DMP Ready para que la función main loop () sepa que está bien usarlo Serial.println (F ("DMP listo! Esperando la primera interrupción ...")); dmpReady =verdadero; // obtener el tamaño de paquete DMP esperado para una comparación posterior packetSize =mpu.dmpGetFIFOPacketSize (); } else {// ¡ERROR! // 1 =falló la carga de memoria inicial // 2 =fallaron las actualizaciones de la configuración DMP // (si se va a romper, normalmente el código será 1) Serial.print (F ("DMP Initialization failed (code")); Serial. print (devStatus); Serial.println (F (")")); } // configurar LED para salida pinMode (bt, INPUT); } // ==============================================================// ===BUCLE DEL PROGRAMA PRINCIPAL ===// ==============================================================bucle vacío () {si (digitalRead (bt) ==ALTO) {x ++; retraso (150); } if ((x% 2) ==0) {// si la programación falló, no intente hacer nada if (! dmpReady) return; // espere la interrupción de MPU o paquetes adicionales disponibles mientras (! mpuInterrupt &&FIFoCount  1 paquete disponible // (esto nos permite leer más inmediatamente sin esperar una interrupción) FIFOCount - =packetSize; #ifdef OUTPUT_READABLE_YAWPITCHROLL // muestra los ángulos de Euler en grados mpu.dmpGetQuaternion (&q, FIFoBuffer); mpu.dmpGetGravity (&gravedad, &q); mpu.dmpGetYawPitchRoll (ypr, &q, y gravedad); Serial.print ("ypr \ t"); Serial.print (ypr [0] * 180 / M_PI); Serial.print ("\ t"); Serial.print (ypr [1] * 180 / M_PI); Serial.print ("\ t"); Serial.println (ypr [2] * 180 / M_PI); si ((ypr [1] * 180 / M_PI) <=-25) {BTSerial.write ('F'); } más si ((ypr [1] * 180 / M_PI)> =25) {BTSerial.write ('B'); } más si ((ypr [2] * 180 / M_PI) <=-25) {BTSerial.write ('L'); } más si ((ypr [2] * 180 / M_PI)> =20) {BTSerial.write ('R'); } else {BTSerial.write ('S'); } #endif}} else {BTSerial.write ('S'); }} 

Esquemas

Sistema de automatización del hogar basado en aplicaciones de Android con IOT Caja de botones DAW para racks de batería electrónica Roland