Braço robótico controlado por gestos manuais usando arduino nano

Conexão de circuito entre MPU6050 e Arduino Nano:

Conexão de circuito entre servo motores e Arduino Nano:

Um sensor flexível contém dois pinos. Não contém terminais polarizados. Portanto, o pino um P1 é conectado ao pino analógico A0 do Arduino Nano com um resistor pull-up de 10k e o pino dois P2 é aterrado no Arduino.

Montagem do MPU6050 e sensor Flex nas luvas

Montamos o MPU6050 e o Flex Sensor em uma luva de mão. Aqui, uma conexão com fio é usada para conectar a luva e o braço robótico, mas pode ser feita sem fio usando uma conexão RF ou uma conexão Bluetooth.

Após cada conexão, a configuração final do Braço Robótico controlado por gestos se parece com a imagem abaixo:

Programando Arduino Nano para braço robótico

Como de costume, o código completo junto com um vídeo de trabalho é fornecido no final deste tutorial. Aqui, algumas linhas importantes de código são explicadas.

1. Primeiro, inclua os arquivos de biblioteca necessários. A biblioteca Wire.h é usada para comunicação I2C entre Arduino Nano e MPU6050 e servo.h para controlar servo motor.

#incluir #incluir

2. Em seguida, os objetos para o servo de classe são declarados. Como usamos quatro servo motores, quatro objetos como servo_1, servo_2, servo_3, servo_4 são criados.

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

3 - Em seguida, o endereço I2C de MPU6050 e as variáveis ​​a serem usadas são declarados.

const int MPU_addr = 0x68; // Endereço MPU6050 I2C int16_t axis_X, axis_Y, axis_Z; int minVal = 265; int maxVal = 402; duplo x; double y; duplo z;

4. Em seguida, na configuração de vazio , uma taxa de transmissão de 9600 é definida para a comunicação serial.

Serial.begin (9600);

E a comunicação I2C entre o Arduino Nano e o MPU6050 é estabelecida:

Wire.begin (); // Iniciar comunicação I2C Wire.beginTransmission (MPU_addr); // Inicie a comunicação com MPU6050 Wire.write (0x6B); // Grava no Registro 6B Wire.write (0); // Grava 0 no registro 6B para redefinir Wire.endTransmission (true); // Termina a transmissão I2C

Além disso, quatro pinos PWM são definidos para conexões de servo motor.

servo_1.attach (2); // Forward / Reverse_Motor servo_2.attach (3); // Up / Down_Motor servo_3.attach (4); // Gripper_Motor servo_4.attach (5); // Left / Right_Motor

5. Em seguida, na função de loop vazio , estabeleça novamente a conexão I2C entre o MPU6050 e o Arduino Nano e, em seguida, comece a ler os dados dos eixos X, Y e Z do registro do MPU6050 e armazene-os nas variáveis ​​correspondentes.

Wire.beginTransmission (MPU_addr); Wire.write (0x3B); // Comece com registrador 0x3B Wire.endTransmission (false); Wire.requestFrom (MPU_addr, 14, verdadeiro); // Lê 14 registros axis_X = Wire.read () << 8-Wire.read (); axis_Y = Wire.read () << 8-Wire.read (); axis_Z = Wire.read () << 8-Wire.read ();

Depois disso, mapeie o valor mínimo e máximo dos dados do eixo do sensor MPU6050 no intervalo 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);

Em seguida, use a fórmula a seguir para calcular os valores x, y, z em termos 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);

Em seguida, leia os dados de saída analógica do sensor flex no pino A0 do Arduino Nano e, de acordo com o valor digital do sensor flex, defina o ângulo do servo da garra. Portanto, se os dados do sensor flexível forem maiores que 750, o ângulo do servo motor da garra é 0 grau e se menor que 750 é 180 graus.

int gripper; int flex_sensorip = analogRead (A0); if (flex_sensorip> 750) { pinça = 0; } else { garra = 180; } servo_3.write (garra);

Em seguida, o movimento do MPU6050 no eixo X de 0 a 60 é mapeado em termos de 0 a 90 graus para o movimento para frente / reverso do servo motor do braço robótico.

if (x> = 0 && x <= 60) { int mov1 = map (x, 0,60,0,90); Serial.print ("Movimento em F / R ="); Serial.print (mov1); Serial.println ((char) 176); servo_1.write (mov1); }

E o movimento do MPU6050 no eixo X de 250 a 360 é mapeado em termos de 0 a 90 graus para o braço robótico de movimento PARA CIMA / PARA BAIXO do servo motor.

senão if (x> = 300 && x <= 360) { int mov2 = map (x, 360,250,0,90); Serial.print ("Movimento para cima / para baixo ="); Serial.print (mov2); Serial.println ((char) 176); servo_2.write (mov2); }

O movimento do MPU6050 no eixo Y de 0 a 60 é mapeado em termos de 90 a 180 graus para o movimento esquerdo do servo motor do braço robótico.

if (y> = 0 && y <= 60) { int mov3 = map (y, 0,60,90,180); Serial.print ("Movimento à esquerda ="); Serial.print (mov3); Serial.println ((char) 176); servo_4.write (mov3); }

O movimento do MPU6050 no eixo Y de 300 a 360 é mapeado em termos de 0 a 90 graus para o movimento direito do braço robótico do servo motor.

else if (y> = 300 && y <= 360) { int mov3 = map (y, 360,300,90,0); Serial.print ("Movimento à direita ="); Serial.print (mov3); Serial.println ((char) 176); servo_4.write (mov3); }

Trabalho de braço robótico controlado por gestos usando Arduino

Por fim, faça o upload do código para o Arduino Nano e use a luva de mão montada com o MPU6050 e sensor Flex.

1. Agora, mova a mão para baixo para mover o braço robótico para frente e mova para cima para mover o braço robótico para cima.

2. Em seguida, incline a mão para a esquerda ou direita para virar o braço robótico para a esquerda ou direita.

3. Dobre o cabo flexível conectado com o dedo da luva para abrir a garra e, em seguida, solte-o para fechá-lo.

O trabalho completo é demonstrado no vídeo abaixo.