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 MDF;
- 4x Micro Servos 9g SG90;
- 1x Fonte chaveada 12V 1ª 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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 |
#include "VarSpeedServo.h"//Para usar a biblioteca VarSpeedServo //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 9600 bps //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(A0 VRy, 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(); } |
Mergulhando no projeto
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.
|
1 2 |
#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.
|
1 2 3 4 |
VarSpeedServo servo2;//Extensão VarSpeedServo servo1;//Base VarSpeedServo servo3;//Altura VarSpeedServo servo4;//Garra |
Depois vamos definir as entradas analógicas de cada joystick:
|
1 2 3 4 5 |
//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:
|
1 2 3 4 5 |
//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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
//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:
|
1 2 |
val1 = analogRead(potpin1);//Lê o valor do pino analógico especificado(A0 VRy, joystick Esquerdo) |
Movimentando a base do braço para a direita:
|
1 2 3 4 5 6 7 8 9 10 |
if (val1 < 100) //Se o valor do pino analógico val1 é menor que 100 { s1 = s1 - 2; //Subtrai 2 de s1 if (s1 <= 10)//Se o valor de s1 é menor e igual a 10 { s1 = 10; //É designado 10 a s1 } servo1.write(s1);//Posição em graus para o servo delay(50);//Espera 50 milissegundos } |
Movimentando a base do braço para esquerda:
|
1 2 3 4 5 6 7 8 9 10 |
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
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
|
1 2 3 4 5 6 7 |
O JOYSTICK ARDUINO 3 EIXOS TEM SEU PRINCÍPIO DE FUNCIONAMENTO ATRAVÉS DO CONTROLE DE 2 POTENCIÔMETROS E UM BOTÃO. DUAS DAS ENTRADAS DOS POTENCIÔMETROS REFEREM- SE AOS EIXOS X E Y, SENDO QUE O BOTÃO QUANDO PRESSIONADO REFERE-SE AO EIXO Z. LOGO ESTE JOYSTICK CONTÉM O TOTAL DE TRÊS INTERFACES DE ENTRADAS QUE SÃO UTILIZADAS PARA CONECTAR AO EIXO X, Y E Z. PINAGEM: – +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.
Deixe uma resposta