Brazo robótico controlado por gestos de mano con arduino nano

Conexión de circuito entre MPU6050 y Arduino Nano:

Conexión de circuito entre servomotores y Arduino Nano:

Un sensor flexible contiene dos pines. No contiene terminales polarizados. Entonces, el pin uno P1 está conectado al Pin analógico A0 del Arduino Nano con una resistencia pull-up de 10k y el pin dos P2 está conectado a tierra a Arduino.

Montaje de MPU6050 y sensor flexible en guantes

Hemos montado el MPU6050 y el sensor Flex en un guante de mano. Aquí se utiliza una conexión por cable para conectar el guante y el brazo robótico, pero se puede hacer inalámbrica mediante una conexión RF o una conexión Bluetooth.

Después de cada conexión, la configuración final para el brazo robótico controlado por gestos se ve como la siguiente imagen:

Programación de Arduino Nano para brazo robótico

Como de costumbre, al final de este tutorial se proporciona el código completo junto con un video funcional. Aquí se explican algunas líneas importantes de código.

1. Primero, incluya los archivos de biblioteca necesarios. La biblioteca Wire.h se utiliza para la comunicación I2C entre Arduino Nano y MPU6050 y servo.h para controlar el servomotor.

#incluir #incluir

2. A continuación, se declaran los objetos para la clase servo. Como usamos cuatro servomotores, se crean cuatro objetos como servo_1, servo_2, servo_3, servo_4.

Servo servo_1; Servo servo_2; Servo servo_3; Servo servo_4;

3. A continuación, se declara la dirección I2C de MPU6050 y las variables que se utilizarán.

const int MPU_addr = 0x68; // MPU6050 Dirección I2C int16_t axis_X, axis_Y, axis_Z; int minVal = 265; int maxVal = 402; doble X; doble y; doble z;

4. A continuación, en la configuración de vacío , se establece una velocidad en baudios de 9600 para la comunicación serial.

Serial.begin (9600);

Y se establece la comunicación I2C entre Arduino Nano y MPU6050:

Wire.begin (); // Iniciar el cable de comunicación I2C.beginTransmission (MPU_addr); // Inicie la comunicación con MPU6050 Wire.write (0x6B); // Escribe en el registro 6B Wire.write (0); // Escribe 0 en el registro 6B para restablecer Wire.endTransmission (verdadero); // Finaliza la transmisión I2C

Además, se definen cuatro pines PWM para las conexiones del servomotor.

servo_1.attach (2); // Forward / Reverse_Motor servo_2.attach (3); // Up / Down_Motor servo_3.attach (4); // Gripper_Motor servo_4.attach (5); // Motor izquierdo / derecho

5. A continuación, en la función de bucle vacío , vuelva a establecer la conexión I2C entre el MPU6050 y Arduino Nano y luego comience a leer los datos del eje X, Y, Z del registro de MPU6050 y almacénelos en las variables correspondientes.

Wire.beginTransmission (MPU_addr); Wire.write (0x3B); // Comience con regsiter 0x3B Wire.endTransmission (false); Wire.requestFrom (MPU_addr, 14, verdadero); // Leer 14 registros axis_X = Wire.read () << 8-Wire.read (); axis_Y = Wire.read () << 8-Wire.read (); axis_Z = Wire.read () << 8-Wire.read ();

Después de eso, asigne el valor mínimo y máximo de los datos del eje del sensor MPU6050 en el rango de -90 a 90.

int xAng = map (axis_X, minVal, maxVal, -90,90); int yAng = map (axis_Y, minVal, maxVal, -90,90); int zAng = map (axis_Z, minVal, maxVal, -90,90);

Luego, use la siguiente fórmula para calcular los valores x, y, z en términos de 0 a 360.

x = RAD_TO_DEG * (atan2 (-yAng, -zAng) + PI); y = RAD_TO_DEG * (atan2 (-xAng, -zAng) + PI); z = RAD_TO_DEG * (atan2 (-yAng, -xAng) + PI);

Luego lea los datos de salida analógica del sensor flexible en el pin A0 del Arduino Nano y, de acuerdo con el valor digital del sensor flexible, establezca el ángulo del servo de la pinza. Entonces, si los datos del sensor flexible son mayores que 750, el ángulo del servomotor de la pinza es 0 grados y si es menor que 750 es 180 grados.

pinza int; int flex_sensorip = analogRead (A0); if (flex_sensorip> 750) { pinza = 0; } else { pinza = 180; } servo_3.write (pinza);

Luego, el movimiento del MPU6050 en el eje X de 0 a 60 se asigna en términos de 0 a 90 grados para el movimiento de avance / retroceso del servomotor del brazo robótico.

if (x> = 0 && x <= 60) { int mov1 = map (x, 0,60,0,90); Serial.print ("Movimiento en F / R ="); Serial.print (mov1); Serial.println ((carácter) 176); servo_1.write (mov1); }

Y el movimiento de MPU6050 en el eje X de 250 a 360 está mapeado en términos de 0 a 90 grados para el brazo robótico de movimiento ARRIBA / ABAJO del servomotor.

de lo contrario, si (x> = 300 && x <= 360) { int mov2 = map (x, 360,250,0,90); Serial.print ("Movimiento arriba / abajo ="); Serial.print (mov2); Serial.println ((carácter) 176); servo_2.write (mov2); }

El movimiento del MPU6050 en el eje Y de 0 a 60 se asigna en términos de 90 a 180 grados para el movimiento izquierdo del brazo robótico del servomotor.

if (y> = 0 && y <= 60) { int mov3 = map (y, 0,60,90,180); Serial.print ("Movimiento a la izquierda ="); Serial.print (mov3); Serial.println ((carácter) 176); servo_4.write (mov3); }

El movimiento del MPU6050 en el eje Y de 300 a 360 se asigna en términos de 0 a 90 grados para el movimiento derecho del brazo robótico del servomotor.

si no (y> = 300 && y <= 360) { int mov3 = map (y, 360,300,90,0); Serial.print ("Movimiento a la derecha ="); Serial.print (mov3); Serial.println ((carácter) 176); servo_4.write (mov3); }

Funcionamiento del brazo robótico controlado por gestos usando Arduino

Finalmente, cargue el código en Arduino Nano y use el guante de mano montado con el MPU6050 & Flex Sensor.

1. Ahora mueva la mano hacia abajo para mover el brazo robótico hacia adelante y muévala hacia arriba para mover el brazo robótico hacia arriba.

2. Luego, incline la mano hacia la izquierda o hacia la derecha para girar el brazo robótico hacia la izquierda o hacia la derecha.

3. Doble el cable flexible adjunto con el dedo del guante de mano para abrir la pinza y luego suéltelo para cerrarlo.

El trabajo completo se demuestra en el video que se muestra a continuación.