Braço Robótico Arduino Controlado por Gestos Manuais – Construção Passo a Passo

Componentes e Materiais

Arduino UNO	×	1
PCB Personalizado JLCPCB	×	1
Servo Motor MG996R	×	6
Pacote de Bateria 5V	×	1
Controlador PCA9685 8-Canais 8W 12V FET Driver I2C	×	1
Módulo Bluetooth HC-05	×	2
Driver de Motor de Passo SparkFun A4988	×	1
Motor de Passo NEMA-17	×	1
Protoboard (genérica)	×	1
Unidade de Medida Inercial (IMU) 6 DOF	×	1
Arduino Nano R3	×	1
Sensor Flex	×	1

Ferramentas e Máquinas Necessárias

• Impressora 3D (genérica)

Sobre o Projeto

Apresentando o Braço Robótico DIY Controlado por Gestos Humanos.

Filmes como Pacific Rim, Avatar e outros de ficção científica sugeriram a capacidade de sinergia com robôs – onde seus movimentos podem ser aprimorados com assistência robótica.

E se pudéssemos construir o mesmo robô industrial, mas em escala menor?

Este projeto é uma tentativa de alcançar isso.

Este é um Braço Robótico Arduino que pode ser programado ou até controlado por Gestos Manuais.

Mantendo a convenção do traje do Homem de Ferro, cada iteração seria conhecida como Mark. Este protótipo seria conhecido como MARK 1. Podemos esperar mais iterações para melhorar o braço robótico original.

Veja o Tutorial Completo do Braço Robótico DIY (controlado por Gestos Manuais) Aqui

Visão Geral

Neste tutorial, construiremos um Robô de seis eixos controlado por gestos manuais usando uma Luva Robótica. E imitando gestos humanos naturais como beliscar ou rotação do pulso para a esquerda, você poderá abrir/fechar ou rotacionar o braço robótico esquerda/direita respectivamente. Em efeito, controlando manualmente um Braço Robótico.

Encontre mais detalhes no artigo original

Características do MARK 1:

• Rotação de 6 Eixos
• Portátil
• Controle do Robô com Gestos Humanos
• Pode ser pré-programado para executar funções básicas
• Pode ser controlado sem fio a distância
• Suporta carga de 600g (Carga Máx 1kg)

Lista de Peças

O Braço Robótico é totalmente personalizável. Você pode comprar o seu ou imprimir em 3D. Se escolher imprimir 3D, sem problemas. Há uma lista de diferentes robôs que usam servomotores, então a teoria do que estamos construindo ainda se aplica.

Para este projeto, este protótipo (Mark 1) seria impresso em 3D pois me dá mais espaço para criar peças personalizadas.

Braço Robótico: Thingiverse Braço Robótico Impresso 3D (créditos: Wonder Tiger):

• Parte 1: Peças da Garra
• Parte 2: Base e Mesa Giratória
• Parte 3: Núcleo do Braço Robótico

Você pode encontrar mais informações sobre esta construção, junto com os tipos de parafusos das peças acima. O tempo de impressão pode chegar a 40 horas. No entanto, isso reduz o custo de comprar um Braço Robótico.

Luva Robótica: Arquivos STL da Luva Robótica (créditos: Roman 13)

A Luva Robótica foi uma adição estética ao projeto, mas você pode muito bem usar uma luva de obra para implementar o Braço Robótico.

Nota: para mãos maiores, imprima em escala 105%

Como Funciona

No geral, estamos enviando um sinal (via Bluetooth) da Luva Robótica para o servomotor. Quando um valor é recebido, o driver do servo envia um sinal para um servomotor específico movendo o Braço Robótico.

Agora, se adicionarmos múltiplos servos e mais sensores, podemos controlar cada Motor.

Se pensarmos em um Braço Robótico como uma série de servomotores coordenando entre si para realizar uma função, podemos criar um braço robótico controlado por uma luva robótica.

O Arduino da Luva Robótica usa sensores para comunicar com o Arduino do Braço Robótico e envia dados para mover um Servo ao ângulo desejado.

Você pode estar se perguntando, quais sensores a Luva Robótica usa?

Para o MARK 1, usaríamos Sensores Flex e um acelerômetro (MPU6050)

• Sensores Flex – Baseado no grau de curvatura desta peça plástica, a resistência muda, afetando a corrente. Esta medição é usada para detectar mudanças no movimento da mão.
• Acelerômetros – Para gestos mais naturais, um acelerômetro pode detectar mudança na rotação do braço e pulso.

Estamos usando estes sensores para detectar mudança em um gesto. Podemos então enviar um valor mapeado de um gesto para o Braço Robótico controlar um servomotor via Bluetooth. E com gestos suficientes, o braço robótico ganha vida!

Mapeamento do Braço Robótico

O seguinte representa uma tabela de mapeamento dos valores enviados ao Braço Robótico pela Luva. Isso pode ser encontrado no artigo original. Cada um tendo uma chave para caracterizar sua função. (P – Mindinho, L – Direita, etc.)

Nota: "F" maiúsculo (finger) representa a direção oposta da rotação do servomotor

Montagem das Peças

Braço Robótico – Montagem

Comprar um Braço Robótico pode ser bem caro. Para manter este braço dentro do orçamento, imprimir em 3D foi a melhor opção.

Isso ajuda a longo prazo, pois há muitos exemplos de braço robótico impresso em 3D que podem ser personalizados, ex.: adicionar LED, criar suporte de câmera com garra:

Como mencionado anteriormente, o Braço Robótico foi modelado baseado no Braço Robótico do Thingiverse. Escolhi este exemplo pois era um excelente design fornecendo seis eixos, bem documentado, e tinha força/robustez. Você pode acessar o Braço Robótico do Wonder Tiger na Lista de Peças.

Você também pode encontrar meus remixes para um Suporte de Câmera Braço Robótico. Cobriremos isso mais em um lançamento futuro. No entanto, as peças podem levar coletivamente pelo menos 40 horas para imprimir todas as partes.

Você pode encontrar muitas outras alternativas de Braço Robótico Impresso 3D também.

Apresentando o Servomotor e Driver

Dado que o Braço Robótico é idealmente uma série de motores coordenando juntos, podemos teoricamente anexar vários motores que podem ser todos alimentados pelo Arduino. Neste projeto, usaremos o Driver de Servo PCA9685 para alimentar o Servo MG966R.

Nota: Use uma fonte de alimentação externa ao alimentar cada Motor. O Arduino não pode fornecer energia suficiente para controlar todos os motores. Neste projeto, uma bateria RC 5V, 2200 mAh foi usada.

O diagrama de fiação do Arduino deve parecer como abaixo:

NEMA-17 para Rotação da Base

Como o Robô estava começando a ganhar peso, e o servomotor MG966R não era potente o suficiente para rotacionar o Braço Robótico na base. Para rotacionar o Braço Robótico, um motor mais robusto que um servomotor seria necessário.

Um Motor de Passo (NEMA-17) pode ser usado devido à sua precisão e alto torque, ajudando o Braço Robótico a rotacionar suavemente para controles de gesto.

O NEMA-17 e o Driver A4988 são usados para controlar a direção do Motor, você pode ver no diagrama abaixo:

E finalmente, o diagrama a seguir mostra o diagrama de fiação da montagem final do Braço Robótico completo.

Montagem da Eletrônica

O diagrama de fiação abaixo mostra a montagem final de todas as partes eletrônicas para criar um Braço Robótico, incluindo o módulo Bluetooth. Cobriremos o processo de pareamento abaixo.

Sensor Flex Humano

Mantendo a estética do Braço Robótico, você pode imprimir uma Manopla Exoesqueleto 3D para usar como sua Luva Robótica.

No entanto, você pode usar uma Luva de Obra padrão para prototipar a Luva Robótica. Este design 'Exoesqueleto Robô Luva' apenas combinou bem com o design do Braço Robótico.

A Luva Robótica consiste nos seguintes componentes:

• Sensor Flex – Baseado na curvatura do dedo, a corrente muda, o que podemos usar para enviar sinal ao Motor
• Acelerômetro (MPU6050) – Podemos controlar o Motor mapeando gestos humanos dos planos X, Y, Z
• LED – O LED acende quando um controle de gesto humano foi enviado ao Arduino
• Módulo Bluetooth (HC-05) – Enviando dados ao HC-05 Receptor do Braço Robótico
• Arduino Nano – O microcontrolador atua como o cérebro da Luva Robótica

O diagrama a seguir é ótimo para testar o sensor flex e o Acelerômetro.

Importante: O Braço Robótico será tão preciso quanto os controles da Luva Robótica, então vale a pena acertar isso.

Configurando o Bluetooth (Mestre e Receptor)

O Braço Robótico Arduino comunica via Bluetooth usando módulos HC-05. Abaixo destacam as informações críticas.

Módulo	Configuração
Luva Robótica HC-05	Mestre
Braço Robótico HC-05	Escravo

Nota: Baud Rate definido em 4800

Programação Arduino

Você pode baixar o seguinte código abaixo:

Nota: Todos os outros códigos de teste e a versão mais recente podem ser encontrados no Repo Git Arduino Robotic Arm

Programando o Braço Robótico

O código do Braço Robótico usa a biblioteca HCPCA9685 (para o Driver de Servo). Assim, podemos alimentar múltiplos servomotores, todos controlados por um Arduino. No código, podemos começar adicionando esta biblioteca e declarando as variáveis do servo.

As seguintes variáveis são usadas para encontrar o incremento anterior/atual e obter a posição atual do Servo.

/* Incluir biblioteca HCPCA9685 */
#include "HCPCA9685.h"
/* Endereço escravo I2C para o dispositivo/módulo. Para o HCMODU0097 o endereço I2C padrão
é 0x40 */
#define I2CAdd 0x40
/* Criar instância da biblioteca */
HCPCA9685 HCPCA9685(I2CAdd);
// posição inicial de estacionamento do motor
const int servo_joint_L_parking_pos = 60;
// Grau de sensibilidade do servo robô - Intervalos
int servo_joint_L_pos_increment = 20;
// Acompanhar o valor atual das posições do motor
int servo_joint_L_parking_pos_i = servo_joint_L_parking_pos;
// Ângulo mínimo e máximo do servomotor
int servo_joint_L_min_pos = 10;
int servo_joint_L_max_pos = 180;

Inicialize a Porta Serial na Taxa Baud 4800 para iniciar a comunicação Bluetooth

Serial.begin(4800); // Inicializar taxa de comunicação padrão do módulo Bluetooth

Na seção loop(), estamos constantemente verificando se algum dado está vindo da luva robótica. Se verdadeiro, armazenaremos o dado recebido na variável 'state'. E dependendo do caractere dado, usaremos isso para mover o(s) motor(es).

A seção a seguir descreve o código:

O código do Braço Robótico pode ser visto como uma série de servomotores trabalhando juntos para simular movimentos humanos. O código é o mesmo, com Servos sendo acionados por um Driver de Servo baseado nos valores do Bluetooth.

// Definindo o driver do servo. Endereço 0x40 é o endereço I2C padrão.
#define I2CAdd 0x40
int response_time = 5; // Intervalo de recebimento de valores da Luva Robótica
// Verifica se dados estão vindo da porta serial
if (Serial.available() > 0) {
  state = Serial.read(); // Lê os dados da porta serial
  Serial.print(state); // Imprime o valor enviado
  // Bloco de código de funcionalidade do motor
}

Baseado no valor atual do 'state', o driver do servo enviaria um sinal ao respectivo Motor.

Por exemplo, se dobrarmos os dedos. O valor 'f' seria enviado pela luva robótica (via Bluetooth) onde o Braço Robótico leria este dado e dispararia uma função para rotacionar o respectivo servomotor. Este processo é repetido em um loop infinito.

if (Serial.available() > 0) { // Verifica se dados estão vindo da porta serial
  state = Serial.read(); // Lê os dados da porta serial
  Serial.print(state); // Imprime o valor enviado
  // Para nomenclatura dos motores, consulte o artigo/tutorial
  // Mover (Rotação Base) Motor de Passo Esquerda
  if (state == 'S') {
    baseRotateLeft();
    delay(response_time);
  }
}

Nota: O código implementa uma parada dura, para impedir o Motor de exceder seu ângulo máximo, o que pode estriar as engrenagens do motor.

HCPCA9685.Servo(0, servo_joint_L_parking_pos_i); // Aciona o servomotor no canal 0 para o ângulo desejado.
// Mover Motor Garra Para Baixo
if (state == 'f') {
  if (servo_joint_3_parking_pos_i < servo_joint_3_max_pos) {
    HCPCA9685.Servo(4, servo_joint_3_parking_pos_i);
    delay(response_time);
    Serial.println(servo_joint_3_parking_pos_i);
    servo_joint_3_parking_pos_i = servo_joint_3_parking_pos_i + servo_joint_3_pos_increment;
  }
}
void baseRotateLeft() {
  digitalWrite(stepPin, LOW); // Gira em direção baseada em HIGH, LOW
  delayMicroseconds(stepDelay); // Altera velocidade do motor de passo
}

Se o valor do servomotor for menor que a rotação máxima, continue girando. Se atingiu a rotação máxima de 180 graus, pare.

servo_joint_3_parking_pos_i < servo_joint_3_max_pos

Onde servo_joint_3_max_pos é a posição máxima do Motor.

Nota: O código implementa uma parada dura para impedir o Motor de exceder seu ângulo máximo, o que pode estriar as engrenagens do motor.

Programando o Sensor Flex

O código do Braço Robótico pode ser encontrado no GitHub. Se você trabalhar no projeto, contribua com sua própria versão no Repo Git. Isso ajudaria a construir um índice de diferentes versões e funcionalidades do Braço Robótico.

O código já foi documentado (Também disponível no Git). No entanto, cobriremos os pontos-chave:

Definiremos os cinco sensores:

// LED NO PINO 3
int pinkie_Data = A1;
int finger_Data = A2;
int thumb_Data = A3;
// const int MPU_addr = 0x68;
const int MPU2 = 0x69, MPU1 = 0x68;

Nota: 0x68 e 0x69 representam o Endereço I2C dos 2 Acelerômetros MPU6050

// Com que frequência enviar valores ao Braço Robótico
int response_time = 1000;

O código a seguir descreve o Arduino lendo os valores dos sensores:

// ler valores dos Sensores Flex para Arduino
pinkie = analogRead(pinkie_Data);
finger = analogRead(finger_Data);
thumb = analogRead(thumb_Data);

Ler a posição atual do Acelerômetro:

GetMpuValue1(MPU1);
GetMpuValue2(MPU2);

Calibrando os valores:

O código a seguir calibra para encontrar o limite superior e inferior do Sensor Flex. Para recalibrar a luva flex, pressione o botão reset no Arduino.

if (bool_caliberate == false ) {
  delay(1000);
  thumb_high = (thumb * 1.15);
  thumb_low = (thumb * 0.9);
  finger_high = (finger * 1.03);
  finger_low = (finger * 0.8);
  pinkie_high = (pinkie * 1.06);
  pinkie_low = (pinkie * 0.8);
  bool_caliberate = true;
}

Verificaremos constantemente se o valor atual excedeu o limite superior ou inferior definido do flex baseado na calibração. Se o sensor flex for acima ou abaixo deste valor, dados são enviados ao Braço Robótico para mover um servomotor específico em uma direção específica.

// dedo 1 - Garra Dobrar/Abrir
if (finger >= finger_high) {
  Serial.print("F");
  delay(response_time);
}
if (finger <= finger_low) {
  Serial.print("f");
  delay(response_time);
}

Programando o Braço Robô

Resultados – Retorno

O Braço Robótico é preciso o suficiente para mover objetos. No entanto, exigirá algum trabalho para mover objetos complexos, ou mesmo competir com os 'milhões de anos' que os seres humanos têm em destreza... embora gastando mais tempo trabalhando no código, a precisão do Robô pode ser melhorada significativamente.

Se você gostaria de melhorar o código, contribua para o Repo Git Arduino Robot Arm e construa seu braço. Vamos tornar isso aberto para outros construírem!

Por fim, também somos capazes de controlar o Robô através de gestos manuais e programar o Robô para automatizar tarefas básicas.

Próximos Passos

E é isso para o MARK 1 pessoal! Se você gostou deste projeto, considere apoiar minha página no Patreon.

Código

Trechos de código disponíveis no repositório GitHub: github.com/EbenKouao/arduino-robot-arm e github.com/EbenKouao/arduino-robotic-arm

Peças Personalizadas e Gabinetes

• Thingiverse - Parte 1
• Thingiverse - Parte 2
• Thingiverse - Parte 3
• Thingiverse - Parte 4

Esquemáticos

Repositório do Braço Robótico: github.com/EbenKouao/arduino-robot-arm