Braço Robótico com Arduino

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!

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.

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.

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

• Fios Jumper macho-macho
• 1X Kit Braço Robótico
• 1X Arduino UNO
• 2X Protoboards
• 2X Módulos joystick
• 4X Micro Servo Motor SG90
• 1X Adaptador P4/KRE fêmea
• 4X Suporte para 4 pilhas
• 4X Pilhas AA

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.

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

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.

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:

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.

by Manuela Macedo

Circuito Integrado Ponte H L293D - Controlando motor DC no Arduino

Controlando motor DC com o CI Ponte H L293D

Neste tutorial, você aprenderá a controlar motores DC utilizando o Circuito Integrado (CI) ponte H L293D. Aqui nós abordaremos a função dos CI's, o uso de uma ponte H e finalizaremos com a utilização do CI ponte H L293D em conjunto com um Arduino UNO.

O que é um CI?

CI é uma abreviação para Circuito Integrado. Hoje em dia, podemos encontrar Os circuitos integrados em quase todos os equipamentos eletrônicos e é inegável que eles revolucionaram o mundo da eletrônica. Os circuitos integrados foram inventados Em meados do século XX, com o avanço da área da computação.Os CI's vieram para reduzir o espaço que os componentes eletrônicos dos computadores ocupavam, incorporando miniaturas de diversos componentes: transistores, diodos, resistores e capacitores, em uma pequena lâmina de silício.

O que é uma ponte H?

Na robótica, para locomoção de robôs, os motores de corrente contínua ou motores DC (direct current), são muito utilizados. Esses motores demandam de uma corrente superior à que as portas do Arduino conseguem fornecer, portanto, se estes forem utilizados usado de forma incorreta, podem acabar danificando a porta em questão e até mesmo a placa como um todo.

As portas do Arduino podem fornecer uma corrente máxima de 40mA nas portas digitais.

O problema da alta corrente poderia facilmente ser resolvido com uso de transistores, porém, no momento em que quiséssemos realizar a inversão do motor teríamos um problema em função da quantidade de transistores requerida. Basicamente, a movimentação de um motor DC ocorre quando este é  submetido a uma corrente contínua, no entanto, caso a polaridade da alimentação do mesmo seja alterada, este passará a se movimentar no sentido contrário. Dessa forma para cumprir este objetivo, nós utilizamos o circuito ponte H, que por sua vez, consiste em quatro transistores necessários para a realização da inversão da polaridade.

Usando uma Ponte H para controlar motores

A ponte H é uma configuração eletrônica que permite controlar a direção e a velocidade de motores DC. É chamada de "ponte" porque, visualmente, se assemelha a uma ponte em esquemas elétricos, e "H" devido à sua forma.

O que pode ser feito com uma Ponte H

Com uma ponte H, podemos controlar a direção de rotação de um motor DC simplesmente invertendo a polaridade de sua alimentação. Além disso, usando modulação por largura de pulso (PWM), podemos controlar a velocidade do motor.

Modelos mais conhecidos de Ponte H

Existem diversos CI's populares que contêm uma ponte H, como o L298 e o L293. O L298 é capaz de controlar motores mais potentes em comparação ao L293D, mas ambos são amplamente usados em projetos de robótica e automação.

Como funciona a ponte H?

As pontes H consistem em um conjunto de quatro chaves que são acionadas de forma alternada. De acordo com a configuração entre as chaves, temos o motor se movimentando em um sentido, no sentido contrário, ou desligado.

Quando as quatro chaves estão abertas, o motor está desligado, como mostra o exemplo da esquerda. Quando o par S1-S3 estiver acionado, isto é, quando as chaves em questão estiverem fechadas, o motor girará em um sentido, como mostra o exemplo do centro. Em contrapartida, quando o par S2-S4 estiver acionado, o motor girará em sentido contrário, como mostra o exemplo da direita.

Circuito integrado Ponte H L293D

O CI L293D é utilizado com o propósito de possibilitar o controle de motores e a velocidade dos mesmos. As vantagens do uso desse CI são a baixa complexidade e a presença de dois circuitos ponte H, isto é, pode-se utilizá-lo no controle de dois motores simultaneamente. Na figura abaixo podemos ver a pinagem do CI.

Os pinos Enable são utilizados para habilitar as portas de saída e também podem ser utilizados para controle da velocidade do motor. O CI L293D pode suportar dois motores para controle simultâneo, neste caso, liga-se cada porta do motor em uma porta de saída do mesmo lado.

Diferenças entre o L293D e o L298

O L293D e o L298 são dois drivers de motor muito populares. O L293D é mais compacto e possui dois circuitos ponte H, enquanto o L298 é mais robusto e pode lidar com correntes mais altas. Uma vantagem do L293D é que ele possui diodos de proteção internos, enquanto no L298, eles precisam ser adicionados externamente.

Aplicações do L293D

O L293D é versátil e pode ser usado para controlar motores DC e motores de passo. Além disso, ele pode ser encontrado em shields e módulos, tornando sua implementação mais fácil e rápida. Usar um shield ou módulo facilita a conexão com plataformas como o Arduino e também oferece proteções adicionais ao circuito.

Shields e Módulos

Existem shields e módulos disponíveis no mercado que integram o L293D, facilitando a conexão com microcontroladores. Usar esses módulos simplifica o processo de montagem e oferece proteções adicionais, como diodos e capacitores. No entanto, em aplicações específicas, pode ser mais vantajoso criar seu próprio circuito.

Mãos à obra - Controlando motor DC - CI Ponte H L293D

Agora, vamos testar o CI L293D para fazermos a inversão dos motores A e B.

Componentes necessários

Para esse exemplo, utilizaremos:

• Placa Arduino UNO ou similar
• 2 Motores DC
• Protoboard
• Alimentação externa
• CI ponte H L293D

Montando o projeto

Prossiga com a montagem para os dois motores conforme esquema abaixo. Em seguida, abordaremos a montagem do circuito para uso de um único motor.

Garanta que seu Arduino e a fonte externa estejam desligados durante a montagem.

Clique aqui para a montagem com apenas um motor

Conectando o Arduino ao computador

Conecte seu Arduino ao computador e abra a IDE Arduino.

Primeiramente, selecionaremos qual placa e porta você deseja usar para fazer o upload do programa no Arduino. Dentro do Arduino IDE, clique no menu Ferramentas(tools) e abra o submenu Placa(Board) e selecione a placa que você usará no projeto.

Em seguida, no menu Ferramentas(Tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado. Geralmente aparece o nome da placa Arduino: “COM3 (Arduino/Genuino Uno)”.

Programando

Crie um no programa (sketch) e salve com o nome de “controle_motores”.

Para controlarmos os motores é necessário o uso da biblioteca específica.

-Instalando a biblioteca

Para download da biblioteca, clique aqui >> Biblioteca L293D

Descompacte a pasta "Firmware". Em seguida, basta mover a pasta para o local:

Windows: “Meus documentos\Arduino\libraries”

Mac: “Documents/Arduino/libraries”

Depois desse processo, a biblioteca estará disponível em “Sketch -> Incluir Biblioteca” na próxima vez que o IDE for aberto.

-Código exemplo

Com a biblioteca instalada e o programa salvo, escreva o seguinte código nela.

//Controlando motores DC com L293D
#include "Arduino.h"
#include "DCMDriverL293D.h"

#define ENABLE_1  13
#define IN_1  12
#define IN_2  11
#define ENABLE_2  10
#define IN_3  9
#define IN_4  8

DCMDriverL293D Motor(ENABLE_1,IN_1,IN_2,ENABLE_2,IN_3,IN_4);

void setup() 
{
   
}
void loop() 
{
    
    Motor.setMotorA(200,1);//gira um lado em um sentido
    delay(2000);
    Motor.setMotorA(200,0);//gira em sentido contrário
    delay(2000);
    Motor.stopMotors(); //para os motores
    delay(2000);
    Motor.setMotorB(200,1);//gira o outro lado em um sentido
    delay(2000);
    Motor.setMotorB(200,0);//gira em sentido contrário
    delay(2000);
    Motor.stopMotors();
    delay(2000);
    }

Colocando pra funcionar

Se seu projeto está com tudo certo, teremos os motores realizando os movimentos:

• Motor A gira em um sentido por dois segundos,
• Motor A gira pelo sentido oposto por dois segundos,
• Motores param por dois segundos,
• Motor B gira em um sentido por dois segundos,
• Motor B gira pelo sentido oposto por dois segundos,
• Motores param por dois segundos.

Entendendo a fundo

Entendendo o Software

No software, começamos com a inclusão das bibliotecas necessárias.

#include "Arduino.h" 
#include "DCMDriverL293D.h"

Depois definimos os pinos que estão conectados ao CI.

#define ENABLE_1 13 
#define IN_1 12 
#define IN_2 11 
#define ENABLE_2 10 
#define IN_3 9
#define IN_4 8

Então definimos ao Arduino o uso dos motores por:

DCMDriverL293D Motor(ENABLE_1,IN_1,IN_2,ENABLE_2,IN_3,IN_4);

Movimentando os motores

Para fazermos os motores se movimentarem precisamos informar sua direção e sua velocidade:

Motor.setMotorA(200,1);//gira um lado em um sentido 
delay(2000);

Nesta movimentação dos motores, se alterarmos o primeiro parâmetro entre 0 e 255, alteraremos sua velocidade, e se alterarmos o segundo parâmetro entre 0 e 1, alteramos sua direção de giro. Para movimentar o outro motor é necessário apenas trocar setMotorA por setMotorB.

Considerações finais

Esperamos que se divirtam com seus motores e seus projetos de robótica. Deixe suas dúvidas, sugestões, ou até mesmo a foto do seu projeto nos comentários.

Mais detalhes em instalação de bibliotecas em DHT11 e DHT22 | Sensor de umidade e Temperatura com Arduino.

Entenda mais sobre protoboard's em Como usar uma Protoboard?

by Equipe Nascente Mecânica