Novo Braço Robotico Arduino com Tutorial de Construção

Atualmente ter um Braço Robotico Arduino sem ter que gastar muito dinheiro é seu atual desejo?

Então, eu tenho uma boa notícia para você: é possível, eu já construi um há muito tempo atrás e recentemente eu otimizei o projeto e gostaria de compartilhar com você como fazer um Braço Robotico também!

Relaxe, pois você não precisará cortar MDF ou se preocupar com impressão 3D para fazer esse tipo de projeto.

O que você irá precisar para a parte estrutural é algumas unidades de palitos de picolé (isso mesmo!), alguns alfinetes, cola para unir tudo e componentes eletrônicos típicos de um Braço Robotico Arduino.

Esse talvez seja o seu primeiro projeto maker e DIY de Robótica com Arduino a definitivamente pôr a mão na massa.

Quer ver?

Então continue neste artigo e siga o passo a passo descrito para ter sucesso na construção do seu Braço Robotico Arduino:

👨‍💻 Comprar Agora – Kit Iniciante Arduino com Tutorial e + 20 Projetos ✅

Como surgiu esse projeto?

O Braço Robotico que você está prestes a construir:

Possui uma história peculiar por trás.

E essa história se dá no ano de 2015 onde consegui uma bolsa para desenvolver projetos de robótica e de eletrônica na Universidade da cidade onde habitava.

Além disso, graças a esse período de desenvolvimento de projetos com Arduino que decidi cursar Engenharia, especificamente a Mecatrônica.

Portanto, esse projeto que você está tendo a oportunidade de construir, foi validado na UFV como um projeto de Robótica Educacional promissor.

Veja só, esse sou eu apresentando o Braço Robotico desenvolvido na época:

Sendo assim, após alguns anos dessa época, resolvi aprimorar o projeto e desenvolver melhor sua programação e sua estrutura mecânica para que qualquer leigo na área pudesse construir um Braço Robotico de forma prática e fácil.

Para que isso fosse possível, precisei replicar do zero o exato Braço Arduino em um programa de modelagem tridimensional a fim de que o passo a passo de como fazer um Braço Robotico ficasse o máximo didático possível.

Portanto fique ligado nos próximos passos para a montagem definitiva do projeto.

Quais são as utilidades de um Braço Robotico?

Antes de entrarmos na parte definitiva de construção do Braço Robotico Arduino, devemos nos perguntar: onde encontramos esse tipo de tecnologia?

Então, reuni aqui alguns exemplos em nossa sociedade em que Braços Robóticos são bastante úteis.

Eles são encontrados nos seguintes ambientes:

Na Indústria

Certamente esse tipo de tecnologia está muito presente em inúmeras indústrias e possui como objetivo automatizar processos e acelerar a produção no chão de fábrica, bem como os controladores lógicos programáveis (CLPS).

Há alguns anos atrás, devido ao alto custo envolvido, os Braços Robóticos Industriais eram usados principalmente por grandes e lucrativas indústrias que produziam produtos de alto valor.

Mas nos dias de hoje a evolução da tecnologia está mudando a maneira como pensamos sobre a produção e a robótica de baixo custo, ou seja, Braços Robóticos estão cada vez mais presentes em fábricas já que os ganhos com a aplicação dessa tecnologia nesse ambiente refletem em maior lucro, economia de recursos e agilidade na produção.

Em Missões Espaciais

Já outra utilidade desse tipo de tecnologia é encontrada em robôs espaciais como o astromóvel Curiosity.

Ele possui um Braço Mecâncio de 2.1 metros de comprimento que é bastante útil para coletar amostras do solo, escavar e peneirar os resíduos.

Outra aplicação é o uso dessa tecnologia em naves e cápsulas espaciais:

Como Prótese Biônica

Com o desenvolvimento da tecnologia, braços biônicos estão se tornando cada vez mais acessíveis para a população.

Por exemplo, é possível encontrar protótipos ativados através do cérebro por um valor muito acessível atualmente.

Além disso, a resposta a estímulos cerebrais é muito eficiente o que permite pessoas segurarem desde objetos pequenos e delicados, como ovos, a coisas mais pesadas e maciças.

Como hobby

Outra principal utilidade, mas não menos importante, que muitos da área de eletrônica e robótica gostam, é poder construir seus próprios projetos e ter a chance de criar algo do zero.

• Saiba como criar projetos de qualidade com o melhor Curso de Eletrônica, um grátis e outro pago, e aprenda de forma online uma área que tem muita demanda por profissionais atualmente!

Você não concorda que a melhor sensação de projetos de robótica é ver eles funcionando depois de construídos?

Porventura você não concorde comigo, mas, aposto que seu primeiro acender de LED’s com Arduino foi uma sensação inédita e fabulosa: ver as luzes cintilando e operando de acordo com a programação criada não tem preço.

Talvez essa sensação não tenha sido a sua, mas com certeza foi a minha quando construí meus primeiros projetos usando luzes!

E, é isso que você irá sentir durante a construção deste Braço Robotico Arduino e no final, quando o mesmo estiver se movimentando de acordo com os potenciômetros.

Projetos assim que unem criatividade e robótica são os meus favoritos e se deixar, passo o dia construindo coisas.

Tutorial de construção do Braço Robotico Arduino

Calibração dos Servos Motores e dos Potenciômetros

Antes de colocar a mão na massa você precisa configurar todos os servos, menos o servo da garra, para a posição central de 90º.

Mas como fazer esse ajuste?

Apenas siga a montagem do seguinte circuito abaixo mudando os seus servos para calibrar todos e insira o código que está a seguir no seu Arduino:

Talvez você também se interesse por esse tutorial: servo motor arduino, como ligar?

#include <Servo.h>  // Inclua a biblioteca do Servo Motor

Servo meuservo;  // Crie uma variável objeto para controlar o Servo

int potpin = 0;  // Pino Analógico usado para conectar o potenciômetro
int val;    // Variável de leitura do valor do Pino Analógico

void setup() {
  meuservo.attach(9);  // Conecta o Servo no pino 9 do objeto Servo
  Serial.begin(9600);
}

void loop() {
  val = analogRead(potpin);            // Faz a leitura do potenciÔmetro (valor entre 0 e 1023)
  Serial.print("Valor analogico lido: ");
  Serial.println(val);
  val = map(val, 0, 1023, 0, 180);     // Faz a conversão para ser utilizado como graus no Servo (valor entre 0 e 180 graus)
  meuservo.write(val);                  // Configura o servo de acrodo com o valor convertido
  delay(15);                           // Espera o Servo completar o ângulo 
}

Com tudo montado você irá abrir o monitor serial e girar o potenciômetro de forma que o valor analógico lido seja de 512.

Lembrando que você deve repetir isso para todos os servos que for utilizar, mas não para o servo da garra.

Combinado?

Então vamos para a montagem de fato!

Montagem estrutural

Para você construir esse Braço Robotico inédito, sugiro ter em mãos os seguintes materiais:

• 1 x Cola Instantânea (do tipo TekBond);
• 1 x Cola Quente;
• 1 x Pacote de Palitos (os palitos devem possuir 11,5 cm de comprimento);
• 5 x Alfinetes;
• 2 x Parafusos 1/8 por 3/4 (para segurar a garra) e 2x porcas;
• 1 x Fita adesiva ou fita isolante para segurar os palitos e impedir de trincarem quando forem furados;
• 2 x Engrenagens (as que utilizo é um par retirado de uma impressora velha onde ambas possuem diâmetro de 1,5cm);
• 1 x Arame de 20 cm de comprimento e 2 mm de espessura (para fazer a comunicação servo-garra);
• 2 x Cotonetes (para impedir de o arame envergar);

Já para furar e cortar tudo isso, recomendo você se equipar com:

• Alicate de corte (para cortar a madeira, fios, alfinete, etc);
• Ferro de solda velho ou que não irá prejudicar suas soldas com estanho (para fazer furos na madeira);
• Chave Philipis.

Montagem da base do Braço Robótico Arduino

Primeiramente, é preciso construir a plataforma de sustentação de todo o projeto.

No meu caso, juntei 10 palitos e os uni na extremidade.

Veja só:

• Base 1 – Usada para a protoboard + circuito + Arduino;
• Base 2 – Usada para os potenciômetros.

Servo motor da base

Para fixar nosso primeiro servo é preciso fazer um apoio para ele da seguinte forma:

• 3 – Conjunto de 6 a 7 palitos de 5 cm de comprimento empilhados um cima do outro;
• 4 – Palitos que irão fixar o servo com a ajuda de seus parafusos.

Como eu irei utilizar os servos em projetos futuros além deste Braço Arduino, irei preferir parafusa-los na madeira, como você deve ter notado na imagem acima.

Montagem da base dos Servos Motores 2 e 3

Já para os servos do ombro e do cotovelo (servos 2 e 3), precisaremos de uma base para fixa-los.

Veja a imagem abaixo em que essa base está melhor representada:

• 5 – Parafuso utilizado para prender o eixo na base – isso gerará mais estabilidade para o seu Braço Robotico Arduino;
• 6 – Base para suportar os servos 2 e 3.

Note que você deve prender o eixo do servo 1 na base dos servos 2 e 3 (utilize o parafuso que veio com ele).

Já para mover todo o conjunto, você deve colar o atuador do seu servo na base, assim:

Construção da estrutura de locomoção do Braço Arduino

Agora é hora de você construir os mecanismos que irão movimentar o Braço Mecânico de fato, ou seja, o “ombro” e o “cotovelo”.

Veja só:

• 7 – Conjunto referente ao ombro;
• 8 – Conjunto referente ao cotovelo.

PS: Tenha atenção nessa etapa do tutorial de como fazer um Braço Robotico pois ela é fundamental para a movimentação correta do nosso projeto.

Para o cotovelo, teremos a seguinte estrutura:

• 9 – Estrutura de locomoção do cotovelo;
• 10 – O comprimento dessa peça que vai colada no atuador do servo é de 5,5 cm.

Veja que as setinhas menores estão apontando para a posição de cada alfinete utilizado no Braço Robotico Arduino.

Prefira utilizar alfinetes ao invés de parafusos pela sua praticidade e por serem fáceis de perfurar os palitos.

Sendo assim, o próximo passo é medir distância do eixo do servo até a base:

Mas você deve estar se perguntando, qual é essa altura e onde a obtenho?

Ela é oriunda dessa distância abaixo:

Onde, no meu caso, D está próximo de 2,2 cm.

Mas porque dessa medida?

Igual você deve ter notado, essa medida é necessária para o palito de sustentação de todo o conjunto do Braço Robotico Arduino.

Veja só:

PS: Não cole os palitos 11 e 12 na base ainda.

• 11 – Palito de sustentação do conjunto ombro+cotovelo. Esta peça possui 4,5 cm de comprimento;
• 12 – 2 x Calços de 1 cm de comprimento para dar maior aderência e fixação quando colados.

Observe que no palito de sustentação há um alfinete que servirá para unir os dois servos e o conjunto de locomoção do nosso Braço Arduino.

Depois que você já tiver obtido a medida da posição do alfinete (D = 2,2 cm), e tiver com a estrutura do cotovelo montada, o próximo passo deverá ser construir o ombro que ficará assim:

• 13 – Estrutura de locomoção do ombro.
• 14 – Palito de picolé que vai colado no atuador do servo (em cinza);

Portanto, para colar a peça 14 no atuador do servo você pode utilizar um palito de mais ou menos 3 cm, ou seja, do mesmo comprimento do atuador do servo.

Observe:

• 15 – Cole essas duas peças em um ângulo de mais ou menos de 90°, para elas poderem se movimentar assim:

Finalmente, essa etapa de construção deverá ficar assim:

• A esquerda – Locomoção do ombro;
• A direita – Locomoção do cotovelo.

Não se esqueça do alfinete que irá unir todo o conjunto ombro/cotovelo no palito de sustentação.

Como mencionado anteriormente, ele se passa no interior das pecinhas dos servos motores.

Depois que finalizar essa estrutura de locomoção do Braço Robotico Arduino, cole-a na base dos servos 2 e 3 e cole também os servos motores.

Mas, para fixar os servos nessa base você pode colá-los diretamente, o que não acho uma boa opção se você for utilizá-los em projetos futuros, ou pode fazer uma adaptação utilizando seus parafusos, por exemplo:

• 16 – Parafusos que fixam os servos na base.

Para fazer isso funcionar você deve colar duas tiras de palito de picolé de forma que fiquem bem presas e de forma que você consiga parafusar o servo no meio delas.

DICA: Pegue uma chave Philips e vá forçando o parafuso contra a madeira até que ele entre por completo. Depois é só colocar o servo motor na posição inserindo o parafuso novamente.

Feito isso, basta colar as tiras de palito com os servos parafusados na base, respeitando a distancia entre os servos, assim:

• D – Distância equivalente a 3,7 cm.

PS: Cole primeiro a estrutura ombro/cotovelo e, após, insira os servos pois essa medida pode variar com o tipo de servo que estiver utilizando.

Feito isso, corte 2 tiras de palito com comprimento de 3,5 cm, ou seja, da mesma altura do seu servo, e cole-as na base de forma que fiquem encostando na lateral dos servos.

Assim:

• 17 – Apoios estabilizadores para os servos.

Posicionamento do Servo Motor 4

Estamos quase finalizando nosso projeto!

Agora, precisamos construir nossa garra com o Servo Motor Tower Pro de 9g.

Esse servo irá fechar e abrir a garra de acordo com o acionamento do pushbutton.

Observe como deverá ficar:

Utilize o palito de 10 cm de comprimento (de acordo com a imagem acima) para servir como sustentação para seu servo motor e para sua garra.

Você deve fura-lo com alfinetes para os servos locomoverem o Braço Robotico Arduino respeitando as distâncias abaixo:

• D1 – 3,3 cm;
• D2 – 6 cm.

Agora, para o servo, faça o seguinte apoio:

• 18 – Arame de 15 cm de comprimento e 2 mm de espessura com 2 pedaços de  cotonete para impedir seu envergamento.
• 19 – Conjunto palitos de apoio para fixar o parafuso do servo (1cmx1cm);

Caso você também não quiser parafusar o servo você tem a opção de colá-lo na madeira.

Se for parafusa-lo, não se esqueça de passar bastante cola e prender bem firme a madeira uma na outra para impedir que ela se rompa quando o parafuso estiver perfurando-a.

Construção da garra do seu Braço Robótico Arduino

Para a garra, você precisará fazer uma estrutura bem simples.

Veja só:

• D1 – 3 cm;
• 20 – Peça de 2cm de comprimento que é usada para dar mais apoio a base da garra (quando colada).

Observe que há dois furos nessa peça. Isso é necessário para poder passar o parafuso e prender as engrenagens.

DICA 1: Utilize algo quente para perfurar a madeira, como um ferro de solda velho e encaixe a madeira nos eixos dos potenciômetros como na imagem acima. No meu caso, eu utilizei um ferro de solda antigo para não danificar a ponta do ferro que uso em soldas de estanho.

O diâmetro desse furo irá depender da engrenagem que estiver utilizando. No meu caso essa medida está próxima de 0,4 cm.

DICA: Caso os palitos trincarem, passe cola instantânea em volta do furo para impedir os palitos de se partirem ao meio.

A montagem final do mecanismo da garra do Braço Arduino ficará da seguinte forma após você ter feito o furo para o parafuso poder fixar as engrenagens:

Já as medidas e as peças usadas nesse conjunto são as seguintes:

• 21 – Garra;
• 22 – Palito (3 cm de comprimento) que através do arame executa o movimento do servo e da garra;
• 23 – Engrenagem utilizada que deve ser colada na peça 21;
• 24 – Base da garra e de todo esse conjunto.

Observe na imagem acima que a garra se encaixa perfeitamente após fazermos alguns cortes na madeira.

DICA: Não aperte os parafusos de forma que o servo precise de mais do que sua capacidade de torque (força) para mover a garra. Portanto, sugiro que deixe uma folga no sistema.

Além disso para melhorar a aderência ao pegar objetos, você pode colar 2 pedaços de EVA na extremidade da garra, veja só:

• E1 – 2 Pares de EVA de 3 cm de comprimento e 1,5 cm de largura.

Construção do Braço de Comandos (potenciômetros)

Assim que acabar de construir todo o braço, parta para a construção do nosso Braço de Comandos que ficará da seguinte forma:

DICA 1: Não cole os potenciômetros na madeira para ser possível regular a posição do seu braço robotico futuramente.

Nessa ilustração, temos o seguinte:

• 25 – Potenciômetro responsável por movimentar o servo do cotovelo através de um palito de comprimento 5 cm;
• 26 – Potenciômetro que movimenta o servo do ombro através de um palito palito de comprimento 6 cm);
• 27 – Potenciômetro que movimenta o servo da base através de um palito palito de comprimento 8 cm);
• 28 – Botão que abre e fecha a garra.

Para esse último componente, o botão, faça uma base de uns 4 a 5 palitos e depois insira o switch colando-o por cima dos palitos.

Posteriormente, você deve conectá-lo ao Arduino e para isso você deve soldar dois fios nos seus terminais ficando atento as conexões internas desse tipo de botão:

Os pinos que “não estão conectados” você deve direcionar um deles para o Arduino e o outro para o GND.

No próximo tópico iremos abordar o circuito e a montagem dos componentes com mais detalhes.

Base de comandos alternativa

Se você preferir, pode optar por construir uma base de potenciômetros mais compacta como no exemplo que fiz abaixo:

Você pode colar a base de potenciômetros ao lado onde se localiza o circuito e, assim, economizar espaço no projeto e deixa-lo mais reduzido.

Montagem dos componentes do Braço Robotico Arduino

Chegamos na parte elétrica do nosso projeto e para construir o circuito você irá precisar dos seguintes componentes:

• 4 x Servo Motores Tower Pro;
• 4 x Potenciômetros de 10kOhms;
• 1 x Botão;
• 1 x Arduino Uno;
• 1 x Fonte de Alimentação para inserir na protoboard;
• 1 x Fonte de 9V ou uma bateria de 9V;
• Alguns fios/jumpers.

Veja a montagem dos componentes na imagem abaixo:

NOTE: O Arduino será alimentado pela porta Vin e não por uma porta USB. Então, fique atento às conexões!

Caso você não possua muito conhecimento sobre Arduino e gostaria de se aprofundar nessa tecnologia, recomendo acessar agora o artigo com tudo que você precisa saber sobre a plataforma.

Ainda sim, caso você deseja um guia completo, um treinamento que te mostre todo o caminho certo a percorrer a fim de evitar erros de iniciantes. recomendo acessar o artigo onde indico os melhores Cursos de Arduino preparados para se fazer este ano: Cursos Grátis e Pagos.

Voltando no projeto do Braço, não se preocupe caso não possuir o mesmo servo motor que estou utilizando aqui no projeto – de engrenagem metálica, você pode optar por utilizar o servo SG90 que o braço robotico ainda funcionará.

Caso você quiser saber as diferenças entre ambos servos utilizados, veja a tabela abaixo:

Especificações	SG90	MG90S
Torque a 4.8V	1.2 kgf·cm	1.8 kgf·cm
Torque a 6.0V	1.6 kgf·cm	2.2 kgf·cm
Peso	9 g	13.4 g
Dimensões	22.2 x 11.8 x 31	22.5 x 12 x 35.5
Engrenagem	Nylon	Metálica

Como estamos utilizando uma fonte de alimentação que nos fornece aproximadamente 4.8V, nossos servos trabalham com um torque de 1.8 kgf·cm (MG90) e 1.2 kgf·cm (SG90).

A definição dessa grandeza física – torque – está relacionada a capacidade de um motor de realizar uma rotação em volta de seu eixo.

Ou seja, quanto maior o torque, mais força um servo motor terá para levantar os objetos e os palitos de picolé.

Além disso, outra diferença clara entre esses dois componentes é que um possui engrenagens metálicas (MG90) e o outo possui sua engrenagem de nylon (SG90).

Braço Robótico Arduino Código Utilizado

O código utilizado para controlar os servos motores é o seguinte:

/*

 Controlando um Braço Robotico Arduino com 4 servos, 3 potenciômetros e 1 switch.
  Por: Flávio Babos
 Mais projetos como esse, acesse: <https://flaviobabos.com.br>
 
*/

#include <Servo.h> // Biblioteca do servo

// -- Declarando os servos como objetos

Servo servogarra; 
Servo servobase;
Servo servoombro;
Servo servocotovelo;


// -- Declarando variáveis globais --

// Relacionando as portas analógicas aos potenciômetros
int pot1 = 0;  // Pot. da base       
int pot2 = 1;  // Pot. do ombro 
int pot3 = 2;  // Pot. do cotovelo 

// Variaveis que representam o ângulo que cada servo irá fazer
int ang1;          
int ang2; 
int ang3;

int botao = 10;     // Atribuindo a porta digital ao push button
int garraabre = 0; // Angulo usado para abrir a garra
int garrafecha = 100;  // Angulo usado para fechar a garra

bool estadobotao;   // Variável usada para ler o estado do botao, 'bool' quarda uma condição verdadeira ou falsa

void setup() {

  // Diz ao arduino em quais pinos os servos estão conectados
  servobase.attach(9); 
  servoombro.attach(8);
  servocotovelo.attach(7);       
  servogarra.attach(6);
  
  // Declare o botao como input pois, o arduino fará a leitura de 
  // um botão externo para checar se ele está pressionado ou não
  pinMode(botao, INPUT_PULLUP);   

  // Inicializa a porta serial da IDE
  Serial.begin(9600);

}

void loop() {
  
  // Variável que recebe a informação se o botão está pressionado ou não
  estadobotao = digitalRead (botao);  

  if(estadobotao == LOW){  // Se o botão estiver pressionado 
   servogarra.write(garrafecha);   // Servo Motor executa o fechamento da garra 
   Serial.print("GARRA: fechada"); // Printa no Monitor Serial o status atual
   delay(15);
   }
    
   else{                   // Se o botão não estiver pressionado   
     servogarra.write(garraabre);  // Servo Motor realiza a abertura da garra 
     Serial.print("GARRA: aberta"); // Printa no Monitor Serial o status atual
     delay(15);
     }
      
  ang1 = analogRead(pot1);            // Lê o valor do potênciometro 1 (valor entre 0 e 1023)
  ang1 = map(ang1, 0, 1023, 0, 180);     // Transforma esse valor em graus (valor entre 0 e 180)
  servobase.write(ang1);                    // Faz o servo girar de acordo com o valor transformado
  delay(15);  

  ang2 = analogRead(pot2);            // Lê o valor do potênciometro 2 (valor entre 0 e 1023)
  ang2 = map(ang2, 0, 1023, 0, 160);     // Transforma esse valor em graus (valor entre 0 e 160)
  servoombro.write(ang2);                  // Faz o servo girar de acordo com o valor transformado
  delay(15); 

  ang3 = analogRead(pot3);            // Lê o valor do potênciometro 3 (valor entre 0 e 1023)
  ang3 = map(ang3, 0, 1023, 0, 160);     // Transforma esse valor em graus (valor entre 0 e 160)
  servocotovelo.write(ang3);                // Faz o servo girar de acordo com o valor transformado
  delay(15); 
  
  Serial.print("    Servo BASE: ");    // Escreve na tela o ângulo que o servo da base está executando
  Serial.print(ang1); Serial.print("º");
  Serial.print("    Servo OMBRO: ");   // Escreve na tela o ângulo que o servo do ombro está executando
  Serial.print(ang2); Serial.print("º");
  Serial.print("   Servo COTOVELO: "); // Escreve na tela o ângulo que o servo do cotovelo está executando
  Serial.print(ang3); Serial.print("º");
  Serial.println(" ");                 // Salta uma linha na leitura para recomeçar o loop novamente
   
  }

Explicação do código

BIBLIOTECA USADA

Primeiro de tudo devemos incluir a biblioteca do Servo Motor:

#include <Servo.h> // Biblioteca do servo

VARIÁVEIS GLOBAIS

Posteriormente, declare os servos motores utilizados como objetos para serem controlados pelo programa:

Servo servogarra; 
Servo servobase;
Servo servoombro;
Servo servocotovelo;

As próximas variáveis que você irá criar relacionam os valores obtidos no potenciômetro com os respectivos ângulos que os servos irão rotacionar.

A lógica para isso acontecer você irá aprender dentro do loop, mas por agora não se esqueça de declarar tais variáveis globais:

int pot1 = 0;  // Pot. da base       
int pot2 = 1;  // Pot. do ombro 
int pot3 = 2;  // Pot. do cotovelo 

int ang1;          
int ang2; 
int ang3;
int garraabre = 0; // Angulo usado para abrir a garra
int garrafecha = 100;  // Angulo usado para fechar a garra

Por fim e não menos importante, declare o pino em que o botão se encontra conectado na porta digital do Arduino: D10 e, além disso, crie uma variável para ler o estado desse botão:

int botao = 10;     
bool estadobotao; 

CONFIGURANDO A FUNÇÃO NATIVA SETUP ()

Geralmente a primeira coisa que fazemos no setup () é definir os pinos que os componentes externos estão conectados.

Veja só:

  servobase.attach(9); 
  servoombro.attach(8);
  servocotovelo.attach(7);       
  servogarra.attach(6);

Definimos nomes para os servos para facilitar na hora da programação e na montagem da estrutura do braço:

Em seguida declare o botão, com o auxílio do pinMode(), como um componente de entrada (INPUT) e inicialize a comunicação serial a 9600 bps:

pinMode(botao, INPUT_PULLUP);   
 
Serial.begin(9600);
servogarra.write(garraabre);

CONFIGURANDO A FUNÇÃO NATIVA LOOP ()

Dentro do loop() comece fazendo a leitura do estado do botão: pressionado –  HIGH, não pressionado – LOW.

estadobotao = digitalRead (botao);  

A CONDIÇÃO IF()…ELSE

Utilizamos essa função como uma condição para verificar se o botão estiver pressionado, fazer a ação de fechar a garra e usamos a função else para, senão estiver pressionado, abrir a garra.

Veja só como essa lógica é simples:

  if(estadobotao == LOW){  
   servogarra.write(garrafecha);   
   Serial.print("GARRA: fechada");
   delay(15);
   }
    
   else{                 
     servogarra.write(garraabre);  
     Serial.print("GARRA: aberta"); 
     delay(15);
     }

Servo.write () é o comando da biblioteca do servo que executa o ângulo que estiver dentro dos parênteses e Serial.print () é a função que imprime o estado atual do servo motor no monitor serial.

E, falando em monitor serial, você poderá acompanhar ao vivo o circuito e ter um feedback de como os servos são responsivos de acordo com o movimento dos potenciômetros.

PARTE ESSENCIAL DO CÓDIGO

As linhas seguintes são cruciais para o devido funcionamento dos servos motores:

ang1 = analogRead(pot1);            
  ang1 = map(ang1, 0, 1023, 0, 179);     
  servobase.write(ang1);                    
  delay(15);  

  ang2 = analogRead(pot2);            
  ang2 = map(ang2, 0, 1023, 0, 160);     
  servoombro.write(ang2);                  
  delay(15); 

  ang3 = analogRead(pot3);            
  ang3 = map(ang3, 0, 1023, 0, 160);     
  servocotovelo.write(ang3);
  delay(15); 

A lógica funciona assim:

1. as variáveis ang1, ang2 e ang3 irão receber os valores de cada potenciômetro pot1, pot2 e pot3 que estão associados a cada servo motor diferente;
2. Posteriormente esse valor precisa ser transformado em um valor referente a graus. Dessa forma, utilizamos a função map Arduino para converter os valores analógicos 0 à 1023 lidos pelos potenciômetros para valores em graus que variam de 0 a 179;
3. Finalmente, com a ajuda da função servo.write(), o servo irá girar de acordo como ângulo que lhe foi informado.

PARTE FINAL: IMPRIMINDO NO MONITOR SERIAL

Por fim, termine de printar os ângulos dos servos restantes para verificar se tudo está funcionando como esperado:

Serial.print("    Servo BASE: ");    
  Serial.print(ang1); Serial.print("º");
  Serial.print("    Servo OMBRO: "); 
  Serial.print(ang2); Serial.print("º");
  Serial.print("   Servo COTOVELO: ");
  Serial.print(ang3); Serial.print("º");
  Serial.println(" "); 

Dessa forma, você poderá acompanhar ao vivo o que está ocorrendo com o circuito:

Projeto finalizado

Se você seguiu firme na construção do Braço Robótico Arduino até aqui e concluiu todas as etapas de montagem, é muito provavel que o projeto que você montou se parecer com o Braço a seguir:

Veja o vídeo abaixo e note como se dá seu movimento:

O Braço Robótico Arduino está um pouco instável devido ao potenciômetro do servo do cotovelo estar dando mal contato.

Além disso, não foi falado aqui, mas, para minimizar qualquer instabilidade no funcionamento dos servos recomendo utilizar no circuito um capacitor de 470uF e bons potenciômetros, claro!

Crie seus próprios projetos de robótica e automação em casa e aprenda a programar Arduino do absoluto zero sem pagar por isso: Apostila PDF Aprenda Arduino do Absoluto Zero com 10 Projetos Prontos e Práticos, baixe agora:

Caso deseja se aprofundar mais no mundo da Robótica e nas áreas que a compõem como a eletrônica, a mecânica e a programação, te convido a acessar o artigo do melhor Curso de Robótica feito para se fazer este ano.

• Veja também: Os melhores robos aspiradores para comprar este ano!

E aí, gostou desse tutorial de como fazer um Braço Robotico Arduino?

Então comenta aqui abaixo e me deixe saber!

E, se você ficar preso em algum lugar deste projeto, sinta-se à vontade para enviar suas perguntas na seção de comentários, combinado?

Até o próximo projeto!