Braço Robótico com Arduino

Você com certeza já viu, em vídeos ou livros, aqueles robôs com garras que “pegam” os objetos nas fábricas, não é mesmo? Nesse contexto, os braços robóticos ou garras robóticas são equipamentos fundamentais na execução de grandes processos produtivos, em especial nas linhas de produção, onde se deseja manusear uma série de objetos. Sob o mesmo ponto de vista, neste tutorial, você vai aprender a montar e programar um braço robótico semelhante de maneira simples, usando Arduino. do mesmo modo, você poderá utilizar o braço em conjunto com outros projetos, como um carrinho robô, e o que mais a sua criatividade permitir!

Braços robóticos industriais em linha de produção

Conforme apresentado na introdução, O braço robótico proposto nesse tutorial possui um mecanismo de funcionamento bastante simples. Isso porque ele é composto por quatro partes, cada uma acoplada por um servo motor diferente. Do mesmo modo, o usuário pode controlar esses motores, um a um, de maneira analógica, o que possibilita diversas combinações de movimentos.

Além disso, para montar a estrutura física do braço robótico, siga a sequência de passos disponível no link abaixo.

Manual de Montagem – Braço Robótico.

Partes de um braço robótico: cada uma controlada por um servo motor

Controle e montagem

Com o objetivo de atuar em pequenos projetos de robótica, o braço robótico controlado por Arduino, antes de mais nada, é uma ferramenta de baixo custo e de fácil montagem. Seus movimentos são guiados por 4 servo motores, os quais, por sua vez, podem ser controlados por potenciômetros ou por módulos joystick, através da placa Arduino.

Componentes usados para controle do braço robótico

No nosso caso à primeira vista, usaremos dois módulos joystick do tipo KY-023. Bem como você pode observar, esses componentes são semelhantes àqueles utilizados igualmente em vídeo games, e seu princípio de funcionamento ocorre através da atuação de dois potenciômetros e de um botão interno. Em suma, o dispositivo conta com 5 entradas, sendo duas para alimentação, uma digital para acionamento do botão, e as duas últimas para controle analógico do movimento nos eixos x e y.

Mãos à Obra – Braço Robótico com Joystick

Componentes necessários

Montando o circuito de controle do braço robótico

Inicialmente, vamos montar o circuito elétrico (hardware) do projeto. Porém, antes de tudo, desligue o cabo USB de seu Arduino e faça a montagem seguindo a ligação das figuras abaixo.

Parte 1: conexão dos joysticks ao Arduino

Além disso, fique atento à conexão dos pinos de ambos os módulos joysticks, conforme as imagens abaixo:

Joystick 1, para controle dos motores da base e da altura do braço.

Joystick 2, para controle dos motores da garra e do ângulo do braço.

Além da conexão dos joysticks, você deve conectar os servo motores do braço robótico ao Arduino. Sendo assim, utilizando o mesmo Arduino da montagem anterior, faça a seguinte ligação entre os componentes.

Parte 2: esquema de conexão dos servo motores ao Arduino.

Alimentação do projeto

Você deve ter observado, na parte 2 da montagem do circuito, o barramento o positivo dos servo motores está conectado ao “Vin” e não ao pino 5V, como fazemos usualmente. Isso ocorre porque, para alimentar esses motores, precisaremos de uma tensão superior a 5V. Para isso, utilizamos 4 pilhas, cada uma com 1,5V, e fazemos a seguinte conexão dessas pilhas ao Arduino:

Pilha e adaptador conectados ao Arduino.

Ademais, fique atento a essa conexão, verificando sempre se o positivo da pilha está conectado ao positivo do adaptador.

Programando o Arduino para controlar o Braço Robótico

Importação da biblioteca “VarSpeedServo”

Em paralelo à montagem do circuito, você deve implementar o código. Porém, antes disso, instale a biblioteca “VarSpeedServo” em seu computador, clicando no link abaixo:

VarSpeedServo-master

Além disso, para usar essa biblioteca no código, siga a sequência de passos abaixo:

1- Após a criação do sketch, selecione o ícone “sketch” e, em seguida, clique em “Adicionar biblioteca.ZIP”.

2- Agora, escolha o local onde você salvou o arquivo .zip da biblioteca. Imediatamente, clique no arquivo e no botão Abrir.

Dessa forma, após seguir os passos acima, você vai receber a mensagem de que a biblioteca está instalada e pode conferir em Sketch/Incluir Biblioteca.

Com isso, após a instalação da instalação da biblioteca, salve o sketch, de preferência, com o nome de “programa_braco_joystick”. Logo depois de salvar, copie e cole o código abaixo.

#include <VarSpeedServo.h> //biblioteca para controle da velocidade e da posição dos servos

#define servoBase   3  // Porta Digital do Servo da Base
#define servoAltura 4  // Porta Digital do Servo da Altura do Braço
#define servoAngulo 5  // Porta Digital do Servo do Ângulo do Braço
#define servoGarra  6  // Porta Digital do Servo da Garra

#define potBase    A0  // Porta Analógica do Potenciometro para Controle da base
#define potAltura  A1  // Porta Analógica do Potenciometro para Controle da altura do braço
#define potAngulo  A2  // Porta Analógica do Potenciometro para Controle do ângulo do braço
#define potGarra   A3  // Porta Analógica do Potenciometro para Controle da garra

#define botao_trava     8  // Porta Digital do Botao trava
#define botao_destrava  9  // Porta Digital do Botao trava
 
//Instanciação dos Objetos de Controle dos Servos

VarSpeedServo base; 
VarSpeedServo altura;
VarSpeedServo angulo;
VarSpeedServo garra;

//Variaveis para cálculo dos angulos
int leitura_Base;
int valor_Base;
int leitura_altura;
int valor_altura;
int leitura_angulo;
int valor_angulo;
int leitura_garra;
int valor_garra;

//Variaveis para controle dos botões
int estado_trava, estado_destrava;
int anterior_trava = HIGH;
int anterior_destrava = HIGH;
boolean travado = false;

void setup(){
  pinMode(botao_trava, INPUT_PULLUP);
  pinMode(botao_destrava, INPUT_PULLUP);

  //Usa o LED do Arduino para informar estado de congelado
  pinMode(13, OUTPUT);
  digitalWrite(13, LOW);
    
  //Configuração das Portas dos Servos
  base.attach(servoBase);
  altura.attach(servoAltura);
  angulo.attach(servoAngulo);
  garra.attach(servoGarra); 
}


void loop() {
 
  if (!travado) {
    leitura_Base = analogRead(potBase); //Leitura do Angulo do Potenciometro
    valor_Base = map(leitura_Base, 0, 1023, 0, 180); //Conversão do valor do potenciometro (de 0 até 1024) para o angulo (de 0 até 180)
    base.slowmove(valor_Base, 30); //envio do ângulo para o servo
                          
  
    leitura_altura = analogRead(potAltura);           //Leitura do Angulo do Potenciometro
    valor_altura = map(leitura_altura, 0, 1023, 180, 0); //Conversão do valor do potenciometro (de 0 até 1024) para o angulo (de 0 até 180) 
    altura.slowmove(valor_altura, 40); //envio do ângulo para o servo
    
    leitura_angulo = analogRead(potAngulo);           //Leitura do Angulo do Potenciometro
    valor_angulo = map(leitura_angulo, 0, 1023, 180, 0); //Conversão do valor do potenciometro (de 0 até 1024) para o angulo (de 0 até 180)
    angulo.slowmove(valor_angulo,40);                          //Envio do angulo para o Servo 
    
    leitura_garra = analogRead(potGarra);               //Leitura do Angulo do Potenciometro
    valor_garra = map(leitura_garra, 0, 1023, 0, 50); //Conversão do valor do potenciometro (de 0 até 1024) para o angulo (de 0 até 180)
    garra.slowmove(valor_garra, 40); //envio do ângulo para o servo                    
  }

  //Se o botao de congelar foi apertado
  estado_trava = digitalRead(botao_trava); 
  if (estado_trava != anterior_trava) {
     travado = true;
     digitalWrite(13, HIGH); //Informa o estado de congelado no LED interno do Arduino
  }
  anterior_trava = estado_trava;

  //Se o botao de descongelar foi apertado
  estado_destrava = digitalRead(botao_destrava); 
  if (estado_destrava != anterior_destrava) {
     travado = false;
     digitalWrite(13, LOW); //Informa o estado de congelado no LED interno do Arduino
  }
  estado_destrava = anterior_destrava;

}

Dessa forma, após testar tanto o código quanto a montagem, o resultado deve ser semelhante ao que aparece no gif:

Entendendo a fundo

Software

Vamos agora partir para a análise do código. Nele, podemos encontrar uma série de conceitos, como os de entradas analógicas e digitais, PWM e funções referentes ao controle de servo motores.

Biblioteca VarSpeedServo

Logo no início do programa, podemos observar a inclusão da biblioteca “VarSpeedServo.h”.

#include <VarSpeedServo.h> //biblioteca para controle da velocidade e da posição dos servos

Basicamente, essa biblioteca conta com uma série de funções específicas para controlar tanto a posição (em graus) quanto a velocidade de um servo motor.

Configuração dos motores

Neste código, cada um dos quatro servo motores é dado como um objeto. Consequentemente, devemos nomear cada um deles e fazer sua instanciação.

VarSpeedServo base; //servo para controle do motor da base do braço
VarSpeedServo altura; //servo para controle do motor da altura do braço
VarSpeedServo angulo; //servo para controle do motor do ângulo do braço
VarSpeedServo garra; //serve para controle do motor da garra.

Além disso, a partir do método “attach”, é feita a configuração das portas dos servos.

//Configuração das Portas dos Servos
  base.attach(servoBase); // servo base localizado no pino 3
  altura.attach(servoAltura); // servo altura localizado no pino 4
  angulo.attach(servoAngulo); //servo angulo localizado no pino 5
  garra.attach(servoGarra); //servo garra localizado no pino 6

Função analogRead()

A função “analogRead”, como o nome já indica, tem como objetivo ler o valor de um pino analógico do Arduino. Sendo assim, essa função irá mapear tensões entre 0V e 5V, a partir do potenciômetro, para valores inteiros de 0 a 1023.

leitura_Base = analogRead(potBase); //Leitura do Angulo do Potenciometro

Já a variável “leitura_base”, por sua vez, serve para armazenar esse valor de 0 a 1023, o qual representa a leitura do potenciômetro.

Função map()

A função “map()” é uma função matemática de referência do Arduino. Nesse sentido, ela é tem como objetivo fazer a conversão de valores de um determinado intervalo numérico para o outro.

valor_Base = map(leitura_Base, 0, 1023, 0, 180); //Conversão do valor do potenciometro (de 0 até 1024) para o angulo (de 0 até 180)

Assim, no nosso código, tal função atua da seguinte maneira: o valor lido no potenciômetro, entre 0 e 1023, e armazenado na variável “leitura_base” é convertido para um valor em ângulo, de 0 a 180. Em seguida, esse valor angular obtido é armazenado na variável “valor_base”.

Método slowmove

base.slowmove(valor_Base, 30); //envio do ângulo para o servo

Nessa parte do código, o método “slowmove” é aplicado a cada um dos objetos, ou melhor, a cada um dos motores: base, ângulo, altura e garra. Dessa forma, tal método tem como parâmetros a posição angular (“valor_base”) e a velocidade (30) com que o motor deve operar.

Controle dos botões

Ambos os joysticks possuem botões: o botão 8, no joystick 2 realiza a tarefa de travar os movimentos dos motores; já o botão 9, no joystick 1, tem a função de destravar esses motores. Dessa forma, a lógica desse mecanismo é apresentada no seguinte trecho de código:

//Se o botao de travar foi apertado
  estado_trava = digitalRead(botao_trava); 
  if (estado_trava != anterior_trava) {
     travado = true;
     digitalWrite(13, HIGH); //Informa o estado de travado no LED interno do Arduino
  }
  anterior_trava = estado_trava;

  //Se o botao de destravar foi apertado
  estado_destrava = digitalRead(botao_destrava); 
  if (estado_destrava != anterior_destrava) {
     travado = false;
     digitalWrite(13, LOW); //Informa o estado de destravado no LED interno do Arduino
  }
  estado_destrava = anterior_destrava;

}

Inicialmente, se a o botão de travamento for pressionado, seu estado é alterado, e, devido a isso, a variável de controle “travado” receberá o valor lógico “true”.

//Se o botao de travar foi apertado
  estado_trava = digitalRead(botao_trava); 
  if (estado_trava != anterior_trava) {
     travado = true;
     digitalWrite(13, HIGH); //Informa o estado de congelado no LED interno do Arduino
  }
  anterior_trava = estado_trava;

Do mesmo modo, quando o botão de destravamento estiver pressionado, seu estado também será alterado. No entanto, nesse caso, a variável de controle “travado” receberá o valor lógico “false”.

//Se o botao de descongelar foi apertado
estado_destrava = digitalRead(botao_destrava); 
if (estado_destrava != anterior_destrava) {
travado = false;
digitalWrite(13, LOW); //Informa o estado de congelado no LED interno do Arduino
}
estado_destrava = anterior_destrava;

Em paralelo a isso, no início do algoritmo, a condição estabelecida é de que, para que os motores atuem, a variável “travado” deve receber o valor lógico “false”. Dessa forma, consequentemente, a condição de acionamento dos motores será satisfeita somente se o botão de destravamento for pressionado.

Fechamento

Enfim, esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto! Compartilhe à vontade.

Manuela Macedo

2 Comments

Deixe uma pergunta, sugestão ou elogio! Estamos ansiosos para ter ouvir!Cancelar resposta

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.