Controlando braço robótico com Joystick

Mais um tutorial para quem curte robótica, dessa apreenderemos como controlar um braço robótico usando um Arduino UNO e dois módulos joystick.

Usaremos um Braço Robótico de MDF com 4 servos motores 9G, a parte eletrônica será montada em uma protoboard de 830 pontos, onde faremos as ligações dos dois módulos joysticks.

Material Necessário

• Arduino UNO R3;
• 1x Braço robótico;
• 4x Micro Servos 9g SG90;
• 1x Fonte chaveada 9V 1A com plug P4 (para conectar no Arduino);
• Protoboard 400/830 pontos;
• Jumpers Macho/Fêmea;
• Jumpers Macho/Macho;

Você pode também comprar o Kit Completo deste tutorial clicando neste link.

Montando o Projeto

A primeira parte é a montagem do Braço Robótico com os 4 Servos, nesta etapa não temos nenhum conceito de programação ou eletrônica envolvidos, basta montar o braço e os servos, como neste tutorial o nosso foco é a eletrônica e a programação, não vamos detalhar o processo de montagem do braço, mas você pode baixar um tutorial neste link, dependendo do modelo de braço que você comprou pode haver algumas diferenças como o tutorial do link, mas no geral este tutorial atende muito bem.

Após a montagem, o braço deve estar como na imagem abaixo:

Agora que o braço está montando, vamos partir para a montagem dos joysticks na protoboard, que na verdade é bastante simples, montar o braço em si é até mais complicado!

A conexão dos joysticks, servos e Arduino ficará assim:

Cada Joystick controlará dois servos motores, movimentando o joystick na horizontal (eixo X) um dos servos receberá os comandos deste movimento, e movimentando na vertical (eixo Y) um outro servo receberá essas instruções de movimento, e assim controlaremos 4 servos usando dois joysticks.

Cada joystick tem 5 pinos (GND, 5V, VRX, VRY, SW), vamos utilizar os 4 primeiros pinos. Param começar iremos conectar o GND (conexão preta) e o 5V (conexão vermelha) de cada joystick nos respectivos GND e 5V da protoboard (parte superior da protoboard na imagem), e depois faremos o mesmo com o GND e 5V do Arduino.

Agora ligaremos os pinos VRX e VRY de cada joystick no Arduino, teremos VRY (conexão azul) na entrada A0 e VRY (conexão verde )na entrada A1 do Arduino, isto para o joystick esquerdo.

Para o joystick direito, ligaremos o pino VRY (conexão azul) na entrada A3 e o pino VRX (conexão verde) na entrada A2 do Arduino.

Essas conexões dos joystick serão responsáveis por “capturar” o movimento feito e enviar um valor correspondente para o Arduino, que enviará um comando de movimento para os servos.

E falando em servos, vamos conectar o GND (conexão preta) e o 5V (conexão vermelha) de cara micro servo nos respectivos GND e 5V da protoboard (como pode ser visto na parte superior da imagem).

Obs.: O pino/fio da terra do micro servo pode ser preto ou marrom, o fio de energia é vermelho e o de sinal é amarelo ou laranja.

Agora vamos conectar o fio de sinal dos servos (conexão amarela/laranja) no Arduino, o fio de sinal da base será ligado na porta 11, o da garra será ligado na porta 6, o de extensão será ligado na 10 e o de altura ligaremos na 9.

Abaixo segue uma tabela detalhando as ligações desse projeto:

Abaixo segue uma imagem da montagem final do projeto:

Mergulhando no projeto

Desenvolvendo o Código

Abra a IDE do Arduino e digito o código abaixo.

//Para usar a biblioteca VarSpeedServo
#include "VarSpeedServo.h"
 
//Definição dos objetos servos do braço robótico
VarSpeedServo servo1;//Base
VarSpeedServo servo2;//Extensão
VarSpeedServo servo3;//Altura
VarSpeedServo servo4;//Garra
 
//Definição das entradas analogicas do Joytick
//Joystick Esquerdo
int potpin1 = A0;//VRy
int potpin2 = A1;//VRx
//Joystick Direito
int potpin3 = A2;//VRx
int potpin4 = A3;//VRy
 
//Variaveis
int val1;
int val2;
int val3;
int val4;
 
//Valores iniciais de posição de cada servo
static int s1 = 70;
static int s2 = 110;
static int s3 = 100;
static int s4 = 80;
 
/*
A função setup() é executada apenas uma vez no inicio do programa.
Emite instruções para preparar o programa antes que o loop principal
seja executado.
*/
void setup()
{
 Serial.begin(9600);//Inicia a porta serial, configura a taxa de dados para 9600bps
 //Anexa o objeto servo ao pino
 servo1.attach(11); //Base, pino digital 11
 servo2.attach(10); //Extensão, pino digital 10
 servo3.attach(9); //Altura, pino digital 9
 servo4.attach(6); //Garra, pino digital 6
 //Move todo o braco para posicao inicial
 servo1.write(70);//Base
 servo2.write(110);//Extensão
 servo3.write(100);//Altura
 servo4.write(80);//Garra
}
 
//A função loop()executa continuamente enquanto o Arduino estiver ligado
void loop()
{
 //Controle da base do braço
 val1 = analogRead(potpin1);//Lê o valor do pino analógico especificado(A0VRy, joystick Esquerdo)
 //Para direita
 if (val1 < 100)
 {
   s1 = s1 - 2;
   if (s1 <= 10)
   {
     s1 = 10;
   }
 servo1.write(s1);//Posição em graus para o servo
 delay(50);//Espera 50 milessegundos
 }
 
//Para esquerda
 if (val1 > 900)
 {
   s1 = s1 + 2;//soma
   if (s1 >= 170)
   {
     s1 = 170;
   }
  servo1.write(s1);
  delay(50);
 }
 
 // Controle da extensão do braço
 val2 = analogRead(potpin2);
 //Para trás
 if (val2 > 900)
 {
   s2 = s2 - 2;
   if (s2 <= 10)
   {
     s2 = 10;
   }
  servo2.write(s2);
  delay(50);
 }
 
 //Para frente
 if (val2 < 100)
 {
  s2 = s2 + 2;
  if (s2 >= 170)
 {
   s2 = 170;
 }
  servo2.write(s2);
  delay(50);
 }
 
 // Controle da altura do braço
 //Abaixar o braço
 val3 = analogRead(potpin3);
 if (val3 < 100)
 {
  s3 = s3 - 2;
  if (s3 <= 10)
 {
  s3 = 10;
 }
  servo3.write(s3);
  delay(50);
 }
 
 //Levantar o braço
 if (val3 > 900)
 {
   s3 = s3 + 2;
   if (s3 >= 170)
   {
     s3 = 170;
   }
   servo3.write(s3);
   delay(50);
 }
 
 // Controle da garra do braço
 val4 = analogRead(potpin4);
 //Abrir a garra
 if (val4 < 100)
 {
   s4 = s4 - 2;
   if (s4 <= 80)
   {
    s4 = 80;
   }
  servo4.write(s4);
  delay(50);
 }
 
//Fechar a garra
 if (val4 > 900)
 {
   s4 = s4 + 2;
   if (s4 >= 130)
 {
   s4 = 130;
 }
 servo4.write(s4);
 delay(50);
 }
 
 //Exibe os valores analogicos na tela
 Serial.print(val1);
 Serial.print(" : ");
 Serial.print(val2);
 Serial.print(" : ");
 Serial.print(val3);
 Serial.print(" : ");
 Serial.print(val4);
 Serial.println();
}

Software

Primeiramente devemos fazer o download da biblioteca VarSpeedServo e depois adiciona-la as bibliotecas existentes da sua instalação do Arduino, neste vídeo você pode ver como adicionar novas bibliotecas no Arduino.

Na primeira linha estamos adicionando a biblioteca VarSpeedServo no projeto.

#include
"VarSpeedServo.h" //Para usar a biblioteca VarSpeedServo

Depois vamos instanciar 4 objetos (neste caso estamos falando de programação orientada a objetos) da biblioteca VarSpeedServo, um para cada servo do projeto, é através desses objetos, que vamos passar os comandos para os servos motores.

VarSpeedServo servo2;//Extensão
VarSpeedServo servo1;//Base
VarSpeedServo servo3;//Altura
VarSpeedServo servo4;//Garra

Depois vamos definir as entradas analógicas de cada joystick:

//Joystick Esquerdo
int potpin1 = A0; //VRy 
int potpin2 = A1; //VRx

//Joystick Direito 
int potpin3 = A2; //VRx 
int potpin4 = A3; //VRy 

Neste trecho acima estamos definindo onde cada pino, de cada joystick será conectado no Arduino. A abreviatura potpin significa: potênciometro-pino, como veremos na parte de hardware o módulo joystick tem dois potenciômetros “embutidos”.

Depois vamos instanciar algumas variáveis que usaremos no código:

//Valores iniciais de posição de cada servo
static int s1 = 70;
static int s2 = 110;
static int s3 = 100;
static int s4 = 80;

Depois temos a função setup onde vamos configurar a porta serial e os objetos dos servos:

//Inicia a porta serial, configura a taxa de dados para 9600 bps
Serial.begin(9600);

//Anexa o objeto servo ao pino correspondente
servo1.attach(11); //Base, pino digital 11
servo2.attach(10); //Extensão, pino digital 10
servo3.attach(9); //Altura, pino digital 9
servo4.attach(6); //Garra, pino digital 6
//Move todo o braço para posição inicial
servo1.write(70);//Base
servo2.write(110);//Extensão
servo3.write(100);//Altura
servo4.write(80);//Garra

Depois temos a função loop onde vamos receber os valores dos joysticks e os enviar para os servos, e  com este valores iremos fazer a lógica de movimentação do braço.

Controle da base do braço:

     val1 = analogRead(potpin1); //Lê o valor do pino analógico especificado(A0 VRy, joystick Esquerdo)
  

Movimentando a base do braço para a direita:

if (val1 < 100) //Se o valor do pino analógico val1 é menor que 100<br>
{<br>
 s1 = s1 - 2; //Subtrai 2 de s1<br>
 if (s1 <= 10)//Se o valor de s1 é menor e igual a 10<br>
 {<br>
   s1 = 10; //É designado 10 a s1<br>
 }<br>
servo1.write(s1);//Posição em graus para o servo<br>
delay(50);//Espera 50 milissegundos<br>
}

Movimentando a base do braço para esquerda:

if (val1 > 900)
{
s1 = s1 + 2;//Soma 2 a s1
if (s1 >= 170)
{
s1 = 170
}
servo1.write(s1);
delay(50);
}

Controlando a extensão do braço:

val2 = analogRead(potpin2);
//Para trás
if (val2 > 900) 
{
  s2 = s2 - 2;
  if (s2 <= 10)
  {
   s2 = 10;
  }
 servo2.write(s2);
 delay(50);
}
//Para frente
if (val2 < 100)
{ 
  s2 = s2 + 2;
  if (s2 >= 170)
 {
   s2 = 170;
 }
servo2.write(s2);
delay(50);
}

Controlando a altura do braço:

//Abaixar o braço
val3 = analogRead(potpin3);
if (val3 < 100)
{
  s3 = s3 - 2; 
 if (s3 <= 10)
 {
  s3 = 10;
 }
servo3.write(s3);
delay(50);
}
//Levantar o braço
if (val3 > 900)
{
 s3 = s3 + 2;
 if (s3 >= 170)
 {
  s3 = 170;
 }
servo3.write(s3);
delay(50);
}

Controlando a garra do braço:

val4 = analogRead(potpin4);
//Abrir a garra
if (val4 < 100) {
  s4 = s4 - 2;
  if (s4 <= 80)
  {
    s4 = 80;
  }
  servo4.write(s4);
  delay(50);
}
//Fechar a garra
if (val4 > 900) {
  s4 = s4 + 2;
  if (s4 >= 130)
  {
    s4 = 130;
  }
  servo4.write(s4);
  delay(50); 
}

Hardware

Micro Servo 9g SG9

O servo motor é um dispositivo que pode girar de 0 graus a 180 graus a partir de um comando de controle. O comando de controle é um pulso temporizado. A posição vai depender de quanto tempo o pulso fica em nível lógico alto (geralmente 5V) e quanto tempo fica em nível lógico baixo (geralmente 0V). Por padrão temos que enviar para o servo um pulso a cada 20ms. Internamente o servo possui um circuito capaz de traduzir o pulso de controle em um determinado grau de posicionamento.

É importante sempre alimentar o servo a partir de sua própria fonte de energia. Não o ligue a partir da fonte de 5V do Arduino, pois isso resultará em barulho e pode causar danos ao Arduino. Utilize uma fonte de 5V externa ou uma bateria e lembre-se de conectar o terra (GND) do Arduino ao terra da fonte externa.

Módulo Joystick

O Módulo Joystick tem seu princípio de funcionamento através do controle de dois potenciômetros e um botão, cada um
deles tem uma entrada para controlar o eixo X e uma para o eixo Y,
sendo que o botão (quando você preciona o Joystick) refere-se ao eixo Z. A pinagem do módulo é a seguinte:

• +5V: 3,3-5V
• GND: GND
• VRx: Saída Analógica Eixo X
• VRy: Saída Analógica Eixo Y
• SW: Saída Digital Eixo Z

Conclusão

Este projeto tem um resultado final muito interessante, quando pegamos os joysticks e controlamos o braço sentimos uma sensação de recompensa imediata, todo o esforço desprendido no projeto se faz valer a pena.

E a montagem do projeto em si não é complexa, o código é um pouco longo mas também não é difícil de entender. A parte mais trabalhosa é a montagem do braço robótico em si.

No fim, este é um excelente projeto para atrair crianças para a área de eletrônica/programação, ao ver o braço se movendo, os pequenos terão bons momentos de diversão e curiosidade.

Referências

Culkin, J; Hagan, E. Aprenda Eletrônica com Arduino – Um Guia Ilustrado de Eletrônica para Iniciantes. 1a Edição. São Paulo: Novatec, 2019.

McRoberts, M. Arduino Básico. 2a Edição. São Paulo: Novatec, 2015.

https://www.arduino.cc/