Braço Robótico 6 GDL Controlado por Nunchuk com Arduino Mega

Componentes e Materiais

• 1x Kit Braço Robótico 6 GDL (6 graus de liberdade)
• 1x Controle Nunchuk (Wii)
• 1x Arduino Mega 2560
• 1x Shield de Controle

Aplicativos e Serviços Online

• Arduino IDE

Sobre o Projeto

Braços robóticos são incríveis! Fábricas no mundo todo os usam para pintar, soldar e transportar coisas com precisão. Também os encontramos em exploração espacial, veículos operados remotamente subaquáticos e até em aplicações médicas!

E agora você pode ter uma versão mais barata deles na sua casa, escritório ou laboratório! Cansado de fazer um trabalho repetitivo? Programe seu próprio robô para ajudá-lo... ou para bagunçar as coisas! :D

Neste tutorial, mostro como montar um braço robótico e como programá-lo usando um Arduino Mega. Também quis experimentar um método diferente para controlar um braço robótico: usando um Nintendo Nunchuk! Eles são baratos, fáceis de encontrar e têm vários sensores.

Existem várias formas de usar este tutorial. Se você não tem um kit de braço robótico (e não quer comprar ou construir um), ainda pode usá-lo para aprender sobre programação Arduino e como interligar um Nunchuk Wii aos seus próprios projetos. Também pode praticar suas habilidades de eletrônica e mecânica.

Passo 1: Ferramentas e Materiais

As seguintes ferramentas e materiais foram usados neste projeto:

• Ferro de solda e fio. Tive que soldar alguns terminais nos fios do Nunchuk para conectá-lo ao Arduino;
• Tubo termorretrátil. Algumas peças foram usadas para melhor isolamento dos condutores;
• Chave de fenda. A estrutura é montada usando parafusos e porcas;
• Braço robótico mecânico de mesa 6 eixos (link). Este kit incrível já vem com vários componentes. É confiável e fácil de montar;
• Fonte de alimentação 12V (2A ou mais);
• Controle Nunchuk (link). Ele se conecta à placa Arduino e é usado para controlar o braço robótico;
• Fios jumper macho (4 fios);
• Arduino Mega (link / link / link). Note que o kit de braço robótico que usei também tem um pacote de placa e controlador que já vem com esta placa Arduino. Se você não estiver usando um desses kits, pode usar outras placas Arduino também;

Fui informado posteriormente que existe um adaptador Nunchuk que facilita a conexão a uma protoboard (link / link). É uma boa opção se você quiser economizar tempo na soldagem e não quiser destruir o conector original, como descrito no Passo 9.

O kit Sain Smart 6-axis mechanical desktop arm já vem com os seguintes componentes:

• Arduino Mega 2560 R3
• Shield de controle
• Módulo Transceptor Sem Fio NRF24L01+
• MPU6050 giroscópio de 3 eixos e acelerômetro de 3 eixos
• 71x parafuso M3X8, 47x porca M3
• 2x suporte U, 5x suporte de servo
• 4x servo 9kg, 2x servo 20kg
• 6x bandeja de servo metálica
• 3x suporte U, 21x suporte angular reto
• 3x rolamento de flange, 1x garra

Você pode encontrar outros kits de braço robótico online, ou até projetar o seu. Existem alguns projetos incríveis que você pode imprimir em 3D.

Nos próximos 7 passos, mostrarei como montar o kit do braço antes de conectar os circuitos. Se você não tem um kit semelhante, sinta-se à vontade para pular alguns passos. Você pode usar outro kit de braço robótico, montá-lo e pular diretamente para as etapas de eletrônica e programação.

Em cada passo, há um GIF animado mostrando como meu braço robótico foi montado. Só roda na versão desktop do site.

Passo 2: Montando o Braço Robótico Pt1 - Base

A primeira parte a ser montada é a base do robô. É feita de dois suportes em formato U, unidos costas com costas usando quatro parafusos e porcas M3, como mostrado nas imagens. Provavelmente é a parte mais fácil de montar.

Passo 3: Montando o Braço Robótico Pt2 - Servo #1

O primeiro servomotor é montado perpendicular à base, usando um suporte de servo. Este perfil é fixado à base usando quatro parafusos e porcas M3. O Servo #1 é colocado no topo e fixado com quatro parafusos e porcas M3. Um chifre circular metálico é fixado ao eixo do servo. O kit vem com vários chifres plásticos que não serão usados na montagem do robô.

Passo 4: Montando o Braço Robótico Pt3 - Servo #2

Outro suporte de servo é montado perpendicular ao anterior. É conectado ao chifre do servo #1 usando quatro parafusos M3. O Servo #2 é instalado com quatro parafusos e porcas M3, e também usa um chifre circular metálico. Um suporte U é então fixado ao chifre usando quatro parafusos. Note que um parafuso M3 é usado oposto ao eixo do servo. Ele dá estabilidade à estrutura. Um rolamento encaixa neste parafuso e é travado com outra porca M3. Assim, o suporte U fica firmemente preso ao eixo central do servo #2.

Passo 5: Montando o Braço Robótico Pt4 - Servo #3

Outro suporte U é montado usando quatro parafusos e porcas M3. Na outra extremidade, o servo #3 é instalado, usando um chifre circular metálico e quatro parafusos. Um suporte de servo é conectado ao motor, e um perfil em L é ligado ao suporte de servo usando alguns parafusos e porcas. Note que outro rolamento é usado oposto ao eixo do servo, como descrito antes.

Passo 6: Montando o Braço Robótico Pt4 - Servo #4

Outro suporte U é conectado ao perfil em L usando um conjunto de quatro parafusos e porcas M3. Similarmente ao passo anterior, o servo #4 é montado no suporte U usando quatro parafusos. Outro suporte de servo é conectado ao servo.

Passo 7: Montando o Braço Robótico Pt4 - Servo #5

O quinto servo é conectado perpendicular ao servo #4 usando outro suporte de servo, instalado com quatro parafusos e porcas M3.

Passo 8: Montando o Braço Robótico Pt4 - Servo #6

A garra é então conectada ao eixo do servo #5. No topo, o servo #6 é conectado usando alguns parafusos, porcas e um chifre metálico. A garra tem engrenagens que transformarão a rotação do servo em movimento linear da garra.

Passo 9: Preparando o Controle Nunchuk

Para este projeto, decidi usar um controle Nintendo Nunchuk por vários motivos:

• São baratos! Réplicas podem ter qualidade inferior, mas não precisei de um controle robusto para este projeto;
• São fáceis de encontrar! Existem vários originais e réplicas baratas online;
• Têm muitos sensores! Cada controle tem dois botões (Z e C), um joystick de dois eixos (X e Y) e um acelerômetro de três eixos;
• Têm uma biblioteca Arduino. Robert Eisele projetou uma biblioteca incrível e fácil de usar para ler sensores do Nunchuk. Confira: https://www.xarg.org/2016/12/using-a-wii-nunchuk-with-arduino/

Infelizmente, joysticks Nunchuk têm um conector complicado, difícil de interligar com outras eletrônicas. Para conectá-lo ao Arduino, tive que cortar seu cabo e expor seus fios. Assim, não funcionará mais com um Nintendo Wii... :/

Primeiro, cortei o conector do joystick e removi o isolamento dos fios. Usando um multímetro e baseando-me na cor de cada fio, determinei a função de cada fio (Vcc, GND, SCL e SDA) baseado no esquemático do conector mostrado na imagem. A cor dos fios não tem padrão. Já ouvi as seguintes possibilidades:

Original: SDA=verde, SCL=amarelo, 3V3=vermelho, GND=branco
Réplica #1: SDA=amarelo, SCL=branco, 3V3=verde, GND=vermelho
Réplica #2: SDA=azul, SCL=branco, 3V3=rosa, GND=verde

Soldei os fios a um jumper macho, para facilitar a conexão à placa Arduino. Usei ferro de solda e tubo termorretrátil, como mostrado nas imagens.

Passo 10: Conectando os Circuitos

Uma vez que a estrutura está montada e os conectores do Nunchuk prontos, você estará pronto para conectar os circuitos. Usei o shield de controle que veio com meu kit de braço robótico. Ele facilita a conexão dos componentes, pois já vem com conectores específicos para servomotores, fonte de alimentação, etc.

Nunchuk:

• Pino 6 (SCL) => Arduino Mega Pino 21 (SCL) (no shield)
• Pino 1 (SDA) => Arduino Mega Pino 20 (SDA) (no shield)
• Pino 3 (Vcc) => Arduino Mega Pino 3V3 (no shield)
• Pino 4 (Gnd) => Arduino Mega Pino Gnd (no shield)

Se estiver usando Arduino Uno, os pinos SCL e SDA do Nunchuk devem ser conectados a pinos diferentes do Arduino:

• Pino 6 (SCL) => Arduino Uno Pino A5
• Pino 1 (SDA) => Arduino Uno Pino A4
• Pino 3 (Vcc) => Arduino Uno Pino 3V3
• Pino 4 (Gnd) => Arduino Uno Pino Gnd

Servos:

• Terminal 11 do shield => Servo #1
• Terminal 12 do shield => Servo #2
• Terminal 13 do shield => Servo #3
• Terminal 8 do shield => Servo #4
• Terminal 9 do shield => Servo #5
• Terminal 10 do shield => Servo #6

Se não estiver usando o shield de controle, use a seguinte configuração de pinos:

• Arduino Pino 11 => Servo #1 (Sinal)
• Arduino Pino 12 => Servo #2 (Sinal)
• Arduino Pino 13 => Servo #3 (Sinal)
• Arduino Pino 8 => Servo #4 (Sinal)
• Arduino Pino 9 => Servo #5 (Sinal)
• Arduino Pino 10 => Servo #6 (Sinal)
• Arduino GND => Servos GND
• Fonte 6V => Servos Vcc

Você também precisará conectar uma fonte externa de 12V. Sugiro uma com mais de 2A de saída. Os servos consomem muita energia, e se a fonte não for potente o suficiente, os servos vibrarão e esquentarão muito. Também perderão força.

Não conecte a fonte de energia até ter feito o upload do código Arduino (mostrado nos próximos passos). Há um botão de energia no shield. Mantenha-o na posição desligada. Conecte um cabo USB no Arduino e prossiga para o próximo passo.

Passo 11: Configurando a Arduino IDE

Agora que o hardware está pronto, é hora de trabalhar no código Arduino.

1. Baixe e instale a versão mais recente da Arduino IDE em https://www.arduino.cc/en/main/software.

2. Adicionando as bibliotecas

Para este projeto usei a incrível biblioteca Nunchuk do Robert Eisele! Você pode encontrar mais sobre ela no site dele: https://www.xarg.org/2016/12/using-a-wii-nunchuk-with-arduino/

Baixe a biblioteca em https://github.com/infusion/Fritzing/tree/master/Wii-Nunchuk

Navegue até Sketch -> Include Library -> Manage Libraries na sua Arduino IDE para adicionar a biblioteca.

Como a biblioteca funciona?

A biblioteca Nunchuk vem com um conjunto de funções para ler os sensores do controle:

• nunchuk_buttonZ(): retorna 1 se o botão Z estiver pressionado, ou 0 se não;
• nunchuk_buttonC(): retorna 1 se o botão C estiver pressionado, ou 0 se não;
• nunchuk_joystickX(): retorna valor X do joystick (entre -127 e 127);
• nunchuk_joystickY(): retorna valor Y do joystick (entre -127 e 127);
• nunchuk_pitch(): retorna o ângulo do controle em radianos (entre -180º e 180º);
• nunchuk_roll(): retorna o ângulo de roll do controle em radianos (entre -180º e 180º).

Os ângulos são retornados em radianos. Converto esses valores para graus no meu código Arduino.

Passo 12: Código Arduino

Baixe o arquivo sketch do Arduino. Conecte o cabo USB na porta USB do computador e faça o upload do código. O upload leva algum tempo. Você pode usar esse tempo para dar um 'like' e 'compartilhar' este tutorial enquanto espera! :D

Após o upload completar, desconecte o cabo USB, conecte a fonte de alimentação e ligue o botão de energia. O código começará a rodar imediatamente.

Aviso: quando o código começar a rodar, o braço robótico se moverá muito rápido para sua posição inicial. Tenha cuidado para não se machucar ou danificar equipamentos próximos durante a inicialização!

Possivelmente você terá que substituir o ângulo inicial de cada servomotor dependendo de como seus servos foram montados.

Código explicado:

Antes do setup, o código importa as bibliotecas usadas no sketch (nunchuk.h, wire.h e servo.h). Pinos a serem usados são definidos, e variáveis globais são declaradas. As variáveis inteiras angle# armazenam a posição inicial para cada servo. Se quiser que seu robô inicie em posição diferente, altere os valores nessas variáveis.

Variáveis servo#_speed definem a velocidade de movimento de cada servo. Se quiser que um servo específico se mova mais rápido, aumente seu valor. Variáveis angle#min e angle#max são usadas para limitar o ângulo máximo e mínimo para cada servo. Você pode definir essas variáveis para evitar colisões entre juntas consecutivas do robô.

//Incluir bibliotecas
#include <nunchuk.h>
#include <wire.h>
#include <servo.h>

//definir variáveis
#define SERV1 8
#define SERV2 9
#define SERV3 10
#define SERV4 11
#define SERV5 12
#define SERV6 13

Servo s1; Servo s2; Servo s3; Servo s4; Servo s5; Servo s6;

//ângulos iniciais
int angle1 = 90; int angle2 = 30; int angle3 = 0;
int angle4 = 90; int angle5 = 90; int angle6 = 45;

//velocidades
int servo1_speed = 3; int servo2_speed = 3; int servo3_speed = 3;
int servo4_speed = 1; int servo5_speed = 1;

//limites
int angle1min = 0; int angle1max = 180;
int angle2min = 0; int angle2max = 180;
int angle3min = 0; int angle3max = 180;
int angle4min = 0; int angle4max = 180;
int angle5min = 0; int angle5max = 180;
int angle6min = 0; int angle6max = 180;

boolean display_angles = true;

Durante o setup, cada servo é anexado a um pino específico e sua posição é iniciada. Comunicação serial (para Monitor Serial) e comunicação I2C com o Nunchuk também são iniciadas aqui.

void setup() {
  s1.attach(SERV1); s1.write(angle1);
  s2.attach(SERV2); s2.write(angle2);
  s3.attach(SERV3); s3.write(angle3);
  s4.attach(SERV4); s4.write(angle4);
  s5.attach(SERV5); s5.write(angle5);
  s6.attach(SERV6); s6.write(angle6);
  Serial.begin(9600);
  Wire.begin(); nunchuk_init();
}

O loop principal é repetido continuamente. O status do Nunchuk é lido a cada ciclo. Dependendo das leituras, diferentes comandos são executados.

void loop() {
  if (nunchuk_read()) {
    int x = nunchuk_joystickX();
    int y = nunchuk_joystickY();
    boolean z = nunchuk_buttonZ();
    boolean c = nunchuk_buttonC();
    float pitch = nunchuk_pitch();
    float roll = nunchuk_roll();
    // ... lógica de controle (ver código completo no arquivo nunchuk.ino)
  }
}

O joystick X controla o servo #1 (rotação esquerda/direita). O joystick Y controla o servo #3 (movimento cima/baixo). O servo #2 permanece fixo neste código. A rotação da garra é dada pelos ângulos de roll e pitch do controle, medidos pelo acelerômetro. Para facilitar o controle, o ângulo da garra só é atualizado quando os botões C ou Z são pressionados. A garra fecha quando ambos os botões são pressionados; ao soltar qualquer um, o robô abre a garra. Há um bloco de código no final que exibe no Monitor Serial o ângulo atual de cada servomotor, útil para escolher os ângulos iniciais.

Passo 13: Uso

Agora que tudo está pronto, alimente o robô e divirta-se! O Nunchuk controla os cinco movimentos mostrados nas imagens: rotação direita/esquerda, movimento cima/baixo, rotação da garra, movimento cima/baixo da garra e abertura/fechamento da garra. Você pode combinar esses movimentos para realizar diferentes tarefas. Pode modificar o código para ter movimentos diferentes baseados em combinações dos botões e ângulos do joystick.

Código

nunchuk.ino (disponível para download)

GitHub: https://github.com/infusion/Fritzing/tree/master/Wii-Nunchuk