curso: tÉcnico em mecatrÔnica 41ª... · interface arduino. ... 30 figura 17-tabela de gastos ......
TRANSCRIPT
CURSO: TÉCNICO EM MECATRÔNICA
Allan Gondin Dias Carvalho de Oliveira
Callebe Berni Cardoso
Giovanni Machado Prevedi
Leandro Abilio de Lima Pinto
Pedro Henrique Caldas
Braço Educacional Tecnicamente Operacional
(B.E.T.O)
São Caetano do Sul
2015
Allan Gondin Dias Carvalho de Oliveira
Callebe Berni Cardoso
Giovanni Machado Prevedi
Leandro Abilio de Lima Pinto
Pedro Henrique Caldas
Braço Educacional Tecnicamente Operacional
(B.E.T.O)
Trabalho de Conclusão de Curso do
último semestre de Mecatrônica,
apresentando à banca examinadora
do Centro Paula Souza Etec Jorge
Street, sob a orientação do Prof.
Jorge Sarapka.
São Caetano do Sul
2015
Nome do Orientador
Jorge Sarapka
BANCA EXAMINADORA
Prof. Jorge Sarapika
_______________________________________________________________
Prof. (nome do orientador) afiliações
Prof. (nome do orientador) afiliações
São Caetano do Sul
2015
DEDICATÓRIA
Dedicamos este trabalho aos nossos amigos, familiares, e a todos que nos
apoiaram durante todo o desenvolvimento deste trabalho de conclusão de curso.
AGRADECIMENTOS
Agradecemos a Deus por nos permitir a realizar mais este sonho. Aos
nossos familiares por nos apoiar nessa conquista. Aos nossos professores por
estar diariamente dispostos nos ajudar durante esta jornada.
EPÍGRAFE
“O único lugar aonde o sucesso vem antes do trabalho é no dicionário.”
(Albert Einstein - citado em Na flor da idade e na idade da flor - Página 9, Gênio
Eurípedes)
RESUMO
O presente trabalho teve como objetivo demonstrar um braço robótico
controlado remota ou automaticamente com comandos seriais através da
interface Arduino. Esse braço é controlado por cinco servomotores de alto
torque com o objetivo de aplicar a movimentação nas diversas juntas do braço,
além de serem abordados alguns tópicos de programação para a plataforma
Arduino, servomotores e controle proporcional.
Este projeto se divide em duas partes: programação e construção da
estrutura. A estrutura mecânica foi construída a partir de peças projetadas no
programa AutoCAD com material de acrílico que, incrementadas a
servomotores, possibilitam as articulações do braço. Com o auxilio de um micro
controlador modelo Arduino UNO, controlam-se as posições do servo via serial
no qual se atribui: A variável “O” para controle do servo do ombro, a variável
“C” tem a função de subir e descer o servo do cotovelo demonstrando os graus,
a variável “G” é utilizada para abrir e fechar garra e por fim a variável “B” para
movimentar a base da esquerda para a direita e da direita para a esquerda,
com isto marcam-se as posições corretas que o usuário deseja para
manipulação do objeto e com estas posições estabelecidas é possível
automatizar seus movimentos. Com os sinais gerados por esta porta envia-se
um sinal a PWM e cada servo, onde seus eixos posicionam-se no ângulo que
se deseja.
Palavras-chave: Servomotor, porta serial, automático, braço.
ABSTRACT
This study aimed to demonstrate a robotic arm controlled remotely or
automatically with serial commands via the Arduino interface. This arm is
controlled by servomotors five high torque in order to apply the movement in the
various joints of the arm, besides being addressed some scheduling threads to
Arduino platform servo and proportional control.
This project is divided into two parts: planning and construction of the structure.
The mechanical structure was built from parts designed in AutoCAD program
with acrylic material that augmented the servo motors, enable the joints of the
arm. With the aid of a microcontroller Arduino UNO model, control is the servant
positions via serial in which it attributes: The variable "O" for shoulder servo
control, the variable "C" has the function of up and down the elbow servo
showing degrees, the variable "G" is used to open and close claw and finally the
variable "B" to move the base from left to right and from right to left with that
mark the positions correct the user wants to manipulation of the object and with
these established positions you can automate their movements. With the
signals generated by this port sends a signal to PWM and each servant where
their axes are positioned at the angle you want.
Keywords: servomotor, serial port, automatic, arm.
LISTA DE FIGURAS
Figura 1-Eixo de articulação ombro com cotovelo ..................................................... 15
Figura 2-peça que compõe a estrutura do cotovelo .................................................. 15
Figura 3-Haste do ombro com fuso de 4,5 mm diâmetro e 140 mm de
comprimento ................................................................................................... 16
Figura 4- caixa da base e para acoplar os componentes .......................................... 16
Figura 5-Haste do braço cortada a laser ................................................................... 17
Figura 6-Parte interna do servo motor ....................................................................... 18
Figura 7-Servomotor com os componentes acoplados ............................................. 19
Figura 8-Demonstração pulso de 20ms .................................................................... 19
Figura 9-Posição do servo de acordo com o pulso ................................................... 20
Figura 10-Servomotor submetido a um torque de 1kgf/cm ....................................... 21
Figura 11-Diferentes servos ...................................................................................... 22
Figura 12-Conexões padrão ...................................................................................... 22
Figura 13-Arduino UNO ............................................................................................. 23
Figura 14-Tela serial de digitação dos membros e seus respectivos graus .............. 29
Figura 15-Tabela para anotar os graus ..................................................................... 29
Figura 16-Programa de trajetória e automatização do braço .................................... 30
Figura 17-Tabela de gastos....................................................................................... 33
Sumário
1 INTRODUÇÃO ................................................................................................ 12
2 Objetivo ........................................................................................................... 14
3 PROCESSO DE CONSTRUÇÃO ................................................................... 15
3.1 Estrutura mecânica ......................................................................................... 15
4 MONTAGEM BRAÇO ROBÓTICO. ................................................................ 17
4.1 Materiais utilizados ......................................................................................... 17
4.1.1 Acrílico ............................................................................................................ 17
4.1.2 Servo motor .................................................................................................... 18
5 PLATAFORMA ARDUINO. ............................................................................. 23
5.1 O que é o Arduíno? ........................................................................................ 23
5.2 O Hardware .................................................................................................... 23
5.2.1 Fonte de Alimentação ..................................................................................... 24
5.2.2 Núcleo CPU .................................................................................................... 24
5.3 Entradas e Saídas .......................................................................................... 24
5.3.1 Entradas Digitais ............................................................................................. 25
5.3.2 Entradas Analógicas ....................................................................................... 25
5.4 Pinos com funções especiais. ......................................................................... 25
5.4.1 Comparadores analógicos .............................................................................. 26
5.5 O software ...................................................................................................... 26
5.5.1 Estruturas do programa. ................................................................................. 27
5.5.2 Serial monitor .................................................................................................. 27
6 Lógica e programação .................................................................................... 28
6.1 Mapeando o braço no espaço ........................................................................ 28
6.2 Automatizando o braço ................................................................................... 29
7 CONCLUSÃO ................................................................................................. 30
7.1 Resultados obtidos ......................................................................................... 31
7.2 Dificuldades encontradas ................................................................................ 31
7.3 Pontos que ainda necessitam de melhoria e projetos futuros ......................... 31
8 Tabela de gastos ............................................................................................ 33
9 CRONOGRAMA. ............................................................................................ 34
10 REFERÊNCIAS BIBLIOGRÁFICAS. .............................................................. 35
11 Anexos ............................................................................................................ 36
11.1 Peça desenvolvida .......................................................................................... 36
11.2 Programação dos graus. ................................................................................. 37
11.3 Programação automática ................................................................................ 43
12
1 INTRODUÇÃO
Podemos definir um robô como um manipulador controlado automaticamente
ou manualmente através de lógicas ou sistemas desenvolvidos para programação
de cada eixo de articulação, tendo breves semelhanças com membros ou até
mesmo o corpo de um ser humano.
É um dos equipamentos mais utilizados dentro de indústrias e fábricas para
substituir funções humanas em determinados locais. Eles são responsáveis por
diversos trabalhos geralmente perigosos preservando assim a vida e integridade do
ser humano ou trabalhos que necessitem de alta demanda de serviço, além de
apresentar uma precisão maior e uniforme nos seus trabalhos realizados. Uma
vantagem enorme na utilização de robôs é que estes podem trabalhar por inúmeras
horas sem a necessidade de parar para descansar, salva a situação que requer
manutenção.
Neste projeto foi desenvolvido um braço robótico, que é comandado através
de lógicas e tecnologias de acesso simples e de fácil entendimento, além de utilizar
servomotores que proporcionam precisão e possuem altos torques, sendo são muito
utilizados em robótica e aeromodelos.
Outro fato em destaque deste protótipo são os softwares utilizados para
construção de toda a lógica de atuação do servo no espaço, podendo ser realizada
através de um micro controlador da plataforma “Arduino” de modelo UNO
trabalhando através de valores analógicos, PWM e comunicação via serial, já
acoplada no próprio micro controlador.
O objetivo desse projeto é o desenvolvimento de um braço robótico com
quatro graus de liberdade incluindo a garra na extensão final do protótipo.
Controlado através de comandos lógicos atribuídos para funcionamento automático
ou analógico, podendo assim movimentar cada eixo do braço através de um
comando serial no qual localizamos as posições do braço no espaço. O braço foi
desenvolvido e projetado desde sua estrutura mecânica fazendo peças de tamanhos
específicos para acoplar perfeitamente os servos de atuação do projeto; além de
proporcionar futura utilização deste projeto pelos alunos de eletrônica ou
mecatrônica, para fins acadêmicos.
13
Na monografia a seguir será abordado o desenvolvimento de todo o braço
robótico, isto contando suas partes físicas, mecânicas, tecnológicas, eletrônicas, que
o compõe, como as peças estruturais, servomotores, fonte de alimentação, interface
lógica e plataforma utilizada para o seu usual desenvolvimento. Cada item será
abordado individualmente, iniciando com a teoria não somente através dos textos,
como também imagens ou diagramas. Serão apresentados os materiais utilizados, e
valores gastos para o desenvolvimento do projeto, as dificuldades encontradas,
pontos fortes e os pontos que ainda necessitam de melhoria, os resultados obtidos
e, por fim a conclusão.
14
2 Objetivo
O projeto tem como objetivo ser utilizado para fins educativos demonstrando
como seria um braço robótico dentro de uma indústria porem em uma escala menor,
e também mostrar uma programação feita através de micro controlador Arduino para
o braço robótico realizar uma determinada função, como também mostrar que e
possível construir um braço robótico gastando pouco alem de auxiliar os alunos do
técnico de mecatrônica, robótica ou automação a terem maior contato com a
robótica e funcionará como um instrumento de ensino e aplicações dos
conhecimentos obtidos ao longo do curso, já que compra um braço robótico gera um
alto custo assim com o projeto seria mais acessível a todos.
15
3 PROCESSO DE CONSTRUÇÃO
3.1 Estrutura mecânica
No processo de construção do projeto, no qual cada desenho está ilustrado
nos anexos, foi desenvolvido com base em dois projetos já existentes, o layout do
braço robótico no qual foi utilizado para ensinar princípios de robótica na escola
técnica Jorge Street, e a base de lógica do projeto ARM5 do grupo “WR KITS”
utilizando pequenas adaptações de acordo com as particularidades do protótipo.
As dimensões da base fixa e móvel foram projetadas pelo grupo tendo como
base o robô da escola Jorge Street como citado anteriormente. São as peças que
formam a estrutura do braço, incluindo os eixos e os suportes estruturais que foram
projetados visando utilizar o mínimo de peso possível no sistema, para que desse
modo fosse possível levantar uma carga maior sem que houvesse uma quebra no
material utilizado, visualizado nas figuras 1 e 2 demonstradas a baixo.
Figura 1-Eixo de articulação ombro com cotovelo
Figura 2-peça que compõe a estrutura do cotovelo
16
Para os suportes das hastes do braço utilizamos um fuso sem fim de 4,5mm
de diâmetro e 150 mm na haste do ombro, 4,5mm diâmetro e 100 mm na haste do
cotovelo, como mostra a figura 3, em conjunto com porcas e arruelas.
Figura 3-Haste do ombro com fuso de 4,5 mm diâmetro e 140 mm de comprimento
Na movimentação oposta onde foi acoplado o servomotor utilizou-se também
um fuso de 8 mm de diâmetro e 70 mm de comprimento, preso por arruelas e porcas
como também citado anteriormente. Os desenhos foram feitos com o auxílio do
software AutoCAD 2014 e a usinagem das peças foram feitas a laser na empresa
“Acriplan indústria e comércio de acrílicos” onde o software utilizado para efetuar o
corte foi o CorelDraw 6, em uma placa de acrílico de 4mm, onde além de
proporcionar uma estética elegante, possui um baixo peso.
A caixa da base fora projetada com polietileno e fabricada utilizando às máquinas
industriais e furadeiras de bancada da própria instituição de ensino, assim
observado nas figuras 4 a caixa pronta apenas para acoplagem dos componentes.
Utilizada para acoplar os componentes do projeto para melhor visualização da parte
eletrônica.
Figura 4- caixa da base e para acoplar os componentes
17
4 MONTAGEM BRAÇO ROBÓTICO.
Esta parte do projeto consiste na junção de todos os objetos utilizados em sua
construção onde se explica como se propaga cada movimento do braço robótico.
Neste projeto se utiliza duas programações na qual uma complementa a
outra, primeiro armazena-se na memória do micro uma programação para
mapeamento do braço que facilitará discernir os graus no espaço para manipular
uma peça; a segunda executa outro programa que tem a função de acionamento
que o braço seguirá de forma infinita seus movimentos até que o operador decida
parar. Com os graus mapeados de cada servo, executam-se seus movimentos de
forma única, quando este estiver funcionando, o computador envia sinais ativando
motores que movem o braço, então dependendo do sinal que receber, ele executará
uma determinada função.
4.1 Materiais utilizados
4.1.1 Acrílico
Para a construção estrutural do braço foram utilizados acrílicos, pois além de
ser leve é fácil de trabalhar e de materiais leve nos proporciona uma estética muito
atraente, como visualiza-se na figura 5 a peça já cortada de uma das hastes do
braço, onde seu corte foi feito em maquinário a Laser, pois assim proporcionando
maior precisão em suas medidas.
Figura 5-Haste do braço cortada a laser
18
4.1.2 Servo motor
Na articulação do braço foram utilizados servomotores com torques e forças
iguais em cada articulação do braço e na base.
4.1.2.1 Funcionamento do Servo Motor
Utilizam-se servomotores quando se deseja utilizar movimentos precisos e de
forma controlada. A característica principal do servomotor é a capacidade que ele
proporciona ao braço de movimentação, mesmo quando sofre uma força em outra
direção. Para poder entender o funcionamento é necessário conhecer a parte
interna.
Figura 6-Parte interna do servo motor
4.1.2.2 Componentes de um Servo Motor.
Circuito de Controle – Este componente é responsável por monitorar o
potenciômetro e o seu acionamento do motor buscando obter uma posição pré-
determinada.
Potenciômetro – Aciona o eixo de saída do servo, além de monitorar a
posição do mesmo.
Motor – movimenta todas as engrenagens compostas como também o eixo
principal do servo.
19
Engrenagens – reduz a alta rotação do motor, aumenta o torque do eixo
Principal e movimentam o potenciômetro junto ao eixo.
Caixa do Servo – Comporta todos os componentes do servo como
visualizado na FIGURA 7.
Figura 7-Servomotor com os componentes acoplados
4.1.2.3 Controle do Servo Motor
Servomotores são alimentados com tensões de 4,8; 5 ou 7 V e captam um sinal
no formato PWM (Pulse Width Modulation). Este sinal varia de 0 V á 5 V. O circuito
de controle do servo monitora este sinal em intervalos de 20 ms. Se neste período, o
controle detecta uma mudança do sinal na sua largura, então ele altera a posição do
eixo para que a sua posição se equipare com o sinal recebido. Abaixo podemos
identificar a PWM enviando um pulso de 20ms.
Figura 8-Demonstração pulso de 20ms
20
O pulso de 1ms é correspondente a posição de 0 grau do servo ou todo a
esquerda. Já um pulso de 1,5 ms corresponde a uma posição central de 90 graus do
servo. E por fim um pulso de 2ms é equivalente à 180 graus (vide FIGURA 8). Com
isto podemos variar seu grau aplicando uma simples regra de três, por exemplo,
deseja-se que o motor fique em posição de 46 graus basta fazer a conta:
Grau ms
180-----------------2
46-----------------X
Então:
Figura 9-Posição do servo de acordo com o pulso
Uma vez que o servo recebe um sinal de 1,5 ms, ele verifica se o
potenciômetro encontra-se na posição correspondente, se ele estiver nada é feito.
Se o potenciômetro não estiver na posição correspondente ao sinal recebido, o
circuito de controle aciona o motor até que o potenciômetro esteja na posição
correta. A posição direcional de rotação do servo motor depende da posição do
21
potenciômetro. O motor vai girar no sentido desejado através do tempo do sinal
recebido assim levando o potenciômetro mais rapidamente na posição correta.
Quando tentar alterar a posição que se encontra o servo motor, observa-se
uma resistência feita pelo motor. Esta resistência é chamada de torque. O torque é
uma das principais características do servo motor. Medem-se o torque em kg/cm
(kilograma por centímetro) ou oz/in (onça por polegada) vide FIGURA 9.
Figura 10-Servomotor submetido a um torque de 1kgf/cm
4.1.2.4 Classificação dos Servomotores
Os servomotores podem ser classificados em: Standard (são os servos mais
comuns, grandes e robustos que pesam em torno de 35 gramas). Mini (são menores
que os standard pesando entre 20 a 28 gramas) e Micro (são pequenos e leves com
um bom torque, pesando entre 6 e 20 gramas).
22
Figura 11-Diferentes servos
4.1.2.5 Padrões de Conexão
Os fabricantes de servos obedecem a um padrão (Airtronics é uma exceção).
Figura 12-Conexões padrão
23
5 PLATAFORMA ARDUINO.
5.1 O que é o Arduíno?
Para controle de todo o braço utilizou-se o Arduino, pois além de ser de fácil
programação, na questão custo x benefício são os mais acessíveis.
Arduíno é uma plataforma de testes eletrônica desenvolvida com a finalidade
de permitir o desenvolvimento de controle de sistemas interativos como mostra a
figura 13, de custo baixo. Além disso, todo software, bibliotecas, hardware é
disponibilizado gratuitamente e sem patente, ou seja, pode ser reproduzido e usado
por todos sem a necessidade de pagamento de direitos autorais. Sua plataforma é
composta essencialmente de duas partes: O Hardware e o Software.
Figura 13-Arduino UNO
5.2 O Hardware
O hardware do Arduíno consiste em um microcontrolador simples e também
muito eficiente. O hardware que utilizaremos é do Arduíno UNO. Esse dispositivo é
seguido pelos seguintes dispositivos: Entradas e saídas digitais, um conversor serial
via (USB), um processador ATMEL, além de entradas analógicas ou saídas digitais,
fontes de alimentação via USB ligado em um computador e Pinos de alimentação 5V
e 3V além do GND.
24
5.2.1 Fonte de Alimentação
Ela tem a função de receber a energia de alimentação externa através USB
ou de um Jack com o positivo no centro, que pode ter uma tensão de no mínimo 6
Volts e no máximo 20 Volts e uma corrente mínima de 300mA. A fonte filtra toda
tensão de entrada e depois regula para duas saídas: 5 Volts e 3,3 Volts. O requisito
desta parte é entregar as tensões de 5 e 3,3 Volts para que o processador e os
demais circuitos funcionem.
5.2.2 Núcleo CPU
O núcleo de processamento de uma placa Arduína é um micro controlador,
uma CPU, basicamente um computador completo, incluindo uma memória RAM,
memória de programa (ROM), uma unidade de processamento de aritmética como
também os dispositivos de entrada e saída. E nesse dispositivo se concentra todo
hardware para obter dados externos, processar esses algoritmos e devolver para a
saída. Os desenvolvedores do Arduíno determinaram utilizar uma linha de
microcontroladores da empresa ATMEL, chamada ATMEGA. Existem placas
Arduíno oficiais com diversos modelos desta linha, como por exemplo, os chips
ATMEGA8, ATMEGA162 e ATMEGA328P. Esses modelos caracterizam a
quantidade de memória de programa e na configuração dos módulos de entrada e
saída disponíveis.
5.3 Entradas e Saídas
Utilizando-se o processador ATMEGA8 no qual o chip possui 28 pinos de
conexões elétricas, 14 de cada lado, é possível acessar as funções do
microcontrolador, enviar dados lógicos para dentro de sua memória e acionar
dispositivos externos.
25
5.3.1 Entradas Digitais
No total, o microcontrolador possui 20 pinos que podem ser utilizados como
entradas digitais sendo determinadas pelo operador, os 14 pinos digitais e também 6
pinos analógicos, que também podem ser entradas digitais. Quando um pino é
programado para funcionar como entrada digital, por via do programa que foi
estabelecido, coloca-se um código de comando que ao ser executado, executa uma
leitura da tensão aplicada ao pino que está sendo lido. Então, após a execução
deste comando, sabe-se que a posição encontra-se em um estado "alto" ou "baixo”.
Com isso o programa pode saber se um pino está alimentado com 0 (zero) ou 5
Volts.
5.3.2 Entradas Analógicas
Tem-se a disposição no Arduino uno 6 entradas analógicas que nos permite
fazer a aplicação de tensão externa além de sua leitura. Através da entrada
analógica, consegue-se, por exemplo, utilizar sensores que convertem alguma
grandeza física em um valor de tensão que depois é lido pela entrada analógica.
4.3.3 Saídas Digitais
Com uma saída digital podemos fazer com que um pino libere 0 volts ou 5
volts. Com um pino programado como saídas digitais podem acender um leitor
óptico, ligar um relé, acionar um motor, além de outros comandos. Podemos
programar o Arduíno para no máximo 20 saídas digitais, entretanto pode-se utilizar
um ou mais pinos para controlar um bloco de pinos.
5.4 Pinos com funções especiais.
No arduino existem pinos que possuem determinadas características
especiais e são estas características que foi maior utilização no projeto, pois nas
quais podem ser usadas através de configurações adequadas (bibliotecas
principalmente). São os PWM (Pulse WidthModulation) utilizado como uma saída
26
lógica, porém é uma saída digital que gera um sinal alternando de (0 e 1) onde
pode-se controlar seu nível alto. Utiliza-se para controlar velocidade de motores,
como também gerar tensões com valores controlados pelo programa. Estes são os
pinos 3, 5, 6, 9, 10 e 1.
Porta serial USART: Com esta porta pode-se utilizar um pino para transmitir e
outro para receber dados no formato assíncrono. O pino 0rx no qual recebe os
dados e pino 1 (tx envia dados).
5.4.1 Comparadores analógicos
Podem ser utilizados dois pinos para fazer comparações entre duas tensões
externas, e sem necessitar fazer um programa que leia essas tensões e compare
uma com a outra. Essa é uma forma rápida de comparar tensões externa. Isto
ocorre por um processo executado somente e pelo hardware sem envolver o
software. Com isso é possível ligar um botão para informar o software sobre
algumas mudanças de estado do circuito. Então cada vez que alguém apertar o
botão o programa salvo dentro do dispositivo desvia-se para um bloco que escolheu.
Usado para detectar eventos externos. Pinos SPI: É um padrão de comunicação
serial síncrono, mais rápida que a USART.
5.5 O software
O software é um ambiente de desenvolvimento integrado ao Arduino, como
também sendo uma mescla de um compilador GCC (C e C++) que ainda utiliza uma
interface gráfica construída em JAVA. Com isso cria-se um programa IDE simples de
utilizar e de estender suas programações com bibliotecas de fácil acesso. A IDE do
Arduino são basicamente dois: Permitir o desenvolvimento de um software e
transferi-lo à placa para que possa ser realizada a programação lógica.
27
5.5.1 Estruturas do programa.
No programa do Arduino é dividido em duas partes, o SETUP e o LOOP. No
SETUP é utilizado para configurações iniciais nos quais irão rodar apenas uma vez,
ele que starta a placa e a programação com as definições iniciam da lógica. Nela
informa-se o tipo de placa que utilizará como também atribuições de variáveis, e
nomear os pinos desejados de acordo com os caracteres a escolha do programador.
A função LOOP é a central de todo a programação, nela que se concentra
toda a lógica do projeto, o programa escrito dentro da função loop é executado
infinitamente, ou seja, ao terminar a execução da última linha do programa, ele se
auto inicia a partir da primeira linha da função loop e continua a executar até que a
placa seja desligada ou aperte-se o botão reset.
Importante ressaltar que quando um programa está terminado, compila-se o
mesmo para verifica se não há nenhum erro. Caso não contenha erro, pode ser
enviado para placa através do botão de upload. Após o envio os Led’s RX e TX
deverão piscar, informando que o código está sendo carregado. Logo após o
Arduíno começará a executar o programa que lhe foi enviado.
5.5.2 Serial monitor
Esse monitor é usado para que possa comunicar-se com a placa e o
computador, mas também é muito útil para a depuração do programa. Basicamente
conecta-se a placa no computador e através da tela podem ser visualizadas as
informações enviadas pela placa.
28
6 Lógica e programação
A base lógica do projeto como citada anteriormente foi utilizada a do
protótipo ARM5 do grupo “WR KIDS”, porém modificando algumas partes da
estrutura para cada necessidade, como por exemplo, suas variáveis que
estavam em inglês, e foi traduzida para o português. Utiliza-se duas
programações para desenvolvimento do projeto, uma para mapeamento do
braço no espaço e a outra para automatizar seus movimentos.
6.1 Mapeando o braço no espaço
Para o seu mapeamento utiliza-se uma programação desenvolvida pelo grupo
WR KITS onde é possível obter as posições de cada servo do braço digitando
apenas a letra correspondente de cada membro, sendo “G” para garra, “C” para o
cotovelo, “O” para o ombro e “B” para base, onde é enviados comandos via serial na
IDE do arduino, na qual é utilizada para encontrar cada grau do servo e apanhar um
determinado objeto, e transporta-lo para a posição final. Devem-se mapear todos os
movimentos de trajetória do braço, tanto inicial da peça quanto final da trajetória da
peça.
Para movimentar os servos basta digitar a letra correspondente de cada
membro do braço e o grau desejado para que seja possível fazer sua
movimentação, na figura abaixo observa a tela serial onde digitamos a primeira letra
de seus respectivos membros.
29
Figura 14-Tela serial de digitação dos membros e seus respectivos graus
Por exemplo, se deseja movimentar o ombro, então é digitado “O”
independente de ser maiúsculo ou minúsculo e 150’’, onde 150’’ é um grau qualquer
que se deseja mover o ombro.
Após todos os graus mapeados anota-se em uma tabela no respectivo
espaço correspondente a cada membro, para assim ser possível sua automatização.
Figura 15-Tabela para anotar os graus
6.2 Automatizando o braço
Para a automatização do projeto, utilizou-se outra programação na qual com o
mapeamento feito de cada parte do braço, alteram-se na estrutura LOOP as
posições iniciais, finais da peça e posição inicial do braço. Como visualizado na
30
figura 16 indicando primeiro o grau que o membro se encontra e para onde ele deve
se locomover, tanto para a trajetória inicial da peça quanto para a final peça.
Figura 16-Programa de trajetória e automatização do braço
Sempre após concluir uma trajetória, recomenda-se retornar a posição inicial
do braço, para assim evitar deslocamento indesejado, como também facilitando sua
movimentação.
7 CONCLUSÃO
31
Após a montagem pode-se observar que o braço estava tendo um sobre peso
no ombro devido às três partes que o compunha. Optou-se na retirada da ultima
parte para aliviar o peso, deixando assim o braço com 4 graus de liberdade incluindo
a garra. Mesmo tirado a terceira parte o ombro ainda estava com uma sobre carga
devida o motor não aguentar o peso, como solução optou-se em ligar dois motores
paralelos ao ombro para ter uma força maior.
A alimentação utilizada foi inicial foi duas fontes de alimentação 5V no qual
não era o suficiente para alimentar todos os motores. Utilizou-se então duas fontes
de alimentação nas quais uma de 7,5V exclusiva para o ombro outra de 5V exclusiva
base, cotovelo e garra.
7.1 Resultados obtidos
O braço robótico desenvolvido atende os objetivos propostos desde o
começo do trabalho, com uma programação pré-montada e de fácil acesso, pode
automatizar o mesmo com facilidade tendo que fazer apenas algumas alterações
nos graus, como também pode estudar e modificar o programa para assim o braço
seja comandado de acordo com os objetivos dos alunos.
7.2 Dificuldades encontradas
No decorrer do trabalho houve algumas dificuldades encontradas como:
Uma das peças secundaria do braço foi quebrada.
O servomotor utilizado no ombro não aguentava o peso exercido nele.
Tradução do programa do inglês para o português.
7.3 Pontos que ainda necessitam de melhoria e projetos futuros
Após a finalização do projeto, é possível aperfeiçoar alguns pontos como:
Diminuição de peso das partes da estrutura.
Construção de um novo braço utilizando motores de vidro elétrico.
Desenvolver uma interfase mais amigável.
32
Desenvolver uma esteira para movimentação nos eixos X e Y.
33
8 Tabela de gastos
Figura 17-Tabela de gastos
34
9 CRONOGRAMA.
35
10 REFERÊNCIAS BIBLIOGRÁFICAS.
UNIVAP. Braço robótico. Disponível em:
<http://biblioteca.univap.br/dados/000005/0000053d.pdf>. Acesso em: 14 de
Fevereiro de 2015.
ROBOTIZANDO. O que é arduino. Disponível em:
<http://www.robotizando.com.br/curso_arduino_o_que_e_arduino_pg1.php>. Acesso
em: 24 de novembro de 2014.
YOUTUBE / WRKITS. Construa e programe um braço robótico (Parte 4/9).
Disponível em:
<https://www.youtube.com/watch?v=pmKaPwweO0o> . Acesso em:14 de Janeiro de
2015.
YOUTUBE / WRKITS. Construa e programe um braço robótico (Parte 5/9).
Disponível em:
<https://www.youtube.com/watch?v=aPiqdbCJLQ>. Acesso em:15 de janeiro de
2015
YOUTUBE / WRKITS. Construa e programe um braço robótico (Parte 6/9).
Disponível em:
< https://www.youtube.com/watch?v=VZeoHLpLatA>. Acesso em:16 de Janeiro de
2015.
FIES. Servo motor. Disponível em:
<http://www.feis.unesp.br/Home/departamentos/engenhariaeletrica/aula-4---servo-
motor-13-03-2013-final.pdf>. Acesso em: 18 de novembro de 2014.
CIRCUITAR. Programação para arduino primeiros passos. Disponível em:
<https://www.circuitar.com.br/tutoriais/programacao-para-arduino-primeiros-
passos/>. Acesso em: 12 de Março de 2015
36
11 Anexos
11.1 Peça desenvolvida
37
11.2 Programação dos graus.
/*
Wagner Rambo / com alteracoes Allan Gondin
Controle dos servos do B.E.T.O em tempo real via serial monitor
INSTRUÇÕES
38
G - (0 - 180 GRAUS) : MOVIMENTA A GARRA
C - (0 - 180 GRAUS) : MOVIMENTA O COTOVELO
O - (0 - 180 GRAUS) : MOVIMENTA O OMBRO
B - (0 - 180 GRAUS) : MOVIMENTA A BASE
*/
//Bibliotecas auxiliares
#include <Servo.h>
//Definições de constantes
#define servoPinGarra 9
#define servoPinCotovelo 8
#define servoPinOmbro 7
#define servoPinBase 6
//Funções auxiliares
void splitString(char* data);
void setPosition(char* data);
// Atribuição de objetos (servos do braço)
Servo servo_base, servo_ombro, servo_cotovelo, servo_garra;
39
//Variáveis
char buffer[18]; //vetor para armazenar string de texto
//maior que o máximo permitido (16) para
//evitar estouros de buffer
void setup()
{
Serial.begin(9600); //inicia comunicação serial a 9600bps
Serial.flush(); //libera caracteres que estejam na linha
//serial, deixando-a pronta para in/outs
//configura os pinos dos servos como saída digital
pinMode(servoPinGarra, OUTPUT);
pinMode(servoPinCotovelo, OUTPUT);
pinMode(servoPinOmbro, OUTPUT);
pinMode(servoPinBase, OUTPUT);
//atribui os pinos do Arduino ao respectivo servo
servo_garra.attach(9);
servo_cotovelo.attach(8);
servo_ombro.attach(7);
servo_base.attach(6);
}
40
void loop()
{
if(Serial.available() > 0) //verifica se foi enviado um caractere
{ //para serial
int index = 0; //armazena a posição de um ponteiro para os
//caracteres do vetor
delay(100); //deixa o buffer encher
int numChar = Serial.available(); //atribui o numero de
//caracteres digitados
if(numChar > 15) numChar = 15; //evita o estouro do buffer
while(numChar--) //executa até que numChar seja zero
{
buffer[index++] = Serial.read(); //le a serial e armazena no vetor
}
splitString(buffer); //chama a função splitString com buffer como parametro
}
}
void splitString(char* data)
{
Serial.println(" ");
Serial.print(" Data de entrada: ");
Serial.println(data);
Serial.println("....................................");
41
Serial.print(">> ");
char* parameter; //variavel para acessar os elementos do vetor data
parameter = strtok (data, " ,"); //divide a string quando encontrar um espaço ou uma
//vírgula
while(parameter != NULL) //executa enquanto parameter não estiver vazia
{
setPosition(parameter);
parameter = strtok (NULL, " ,"); //preenche o vetor com caracteres NULL
}
//Limpa o texto e os buffers seriais
for(int x=0; x<16; x++)
{
buffer[x]='\0';
}
Serial.flush(); //libera caracteres que estejam na linha
//serial, deixando-a pronta para in/outs
}
void setPosition(char* data)
{
if((data[0] == 'g') || (data[0] == 'G')) //verifica letra inicial (qual servo)
{
int Ans = strtol(data+1, NULL, 10); //define Ans como numero na proxima parte do texto
42
Ans = constrain(Ans,0,180); //garante que Ans esteja entre 0 e 180
servo_garra.write(Ans); //atribui o grau da posição do eixo do servo
Serial.print("Garra esta setada para: ");
Serial.println(Ans);
}
if((data[0] == 'c') || (data[0] == 'C'))
{
int Ans = strtol(data+1, NULL, 10);
Ans = constrain(Ans,0,180);
servo_cotovelo.write(Ans);
Serial.print("Cotovelo esta setado para: ");
Serial.println(Ans);
}
if((data[0] == 'o') || (data[0] == 'O'))
{
int Ans = strtol(data+1, NULL, 10);
Ans = constrain(Ans,0,180);
servo_ombro.write(Ans);
Serial.print("Ombro esta setado para: ");
Serial.println(Ans);
}
43
if((data[0] == 'b') || (data[0] == 'B'))
{
int Ans = strtol(data+1, NULL, 10);
Ans = constrain(Ans,0,180);
servo_base.write(Ans);
Serial.print("Base esta setada para: ");
Serial.println(Ans);
}
}
// end setPosition
11.3 Programação automática
/*
ARM5 / B.E.T.O
Autor: Wagner Rambo com adaptação Allan Gondin
Data: Agosto 2014
Paradoxus-Duino
Arm5 - Movimentar um objeto
Garra (servoClaw) - 40º garra fechada, 135º garra aberta
44
Pulso Rotacional (servoFistRotate) - 0º pulso rotacionado para esquerda, 90º pulso centralizado,
180º pulso rotacionado para direita
Pulso (servoFist) - 0º pulso totalmente abaixado, 90º pulso na posição central, 180º pulso
totalmente erguido
*/
// Bibliotecas auxiliares
#include <Servo.h>
// Definição de constantes
#define servoPinFistRotate 1
#define servoPinFist 2
#define servoPinGarra 9
#define servoPinCotovelo 8
#define servoPinOmbro 7
#define servoPinBase 6
// ############# PROTÓTIPO DAS FUNÇÕES AUXILIARES ############# //
// Funções para movimento suave
void moveCotoveloUp (const int tempoDelay, int inicio, int fim); //função que movimenta o
cotovelo para cima
void moveCotoveloDown (const int tempoDelay, int inicio, int fim); //função que movimenta o
cotovelo para baixo
45
void moveOmbroAhead (const int tempoDelay, int inicio, int fim); //função que movimenta o
ombro para frente
void moveOmbroBack (const int tempoDelay, int inicio, int fim); //função que movimenta o
ombro para trás
void moveBaseRight (const int tempoDelay, int inicio, int fim); //função que movimenta a base
para direita (sentido horário)
void moveBaseLeft (const int tempoDelay, int inicio, int fim); //função que movimenta a base
para esquerda (sentido antihorário)
// Funções de Manipulação
void armOrigin (unsigned char baseInit, unsigned char baseEnd, unsigned char ombroInit,
unsigned char ombroEnd, unsigned char cotoveloInit, unsigned char cotoveloEnd);
void armOrigin2 (unsigned char baseInit, unsigned char baseEnd, unsigned char ombroInit,
unsigned char ombroEnd, unsigned char cotoveloInit, unsigned char cotoveloEnd);
void armDestination (unsigned char baseInit, unsigned char baseEnd, unsigned char ombroInit,
unsigned char ombroEnd, unsigned char cotoveloInit, unsigned char cotoveloEnd);
//
// positionArm HELP:
// positionArm(BASE INICIAL, BASE FINAL, OMBRO INICIAL, OMBRO FINAL, COTOVELO INICIAL,
COTOVELO FINAL, PUNHO INICIAL, PUNHO FINAL);
//
// ############################################################ //
// Atribuição de objetos (servos do braço)
Servo servo_base, servo_ombro, servo_cotovelo, servo_garra, servo_fist, servo_fist_rotate ;
// Configuração inicial do MCU
void setup()
46
{
pinMode(servoPinGarra, OUTPUT);
pinMode(servoPinCotovelo, OUTPUT);
pinMode(servoPinOmbro, OUTPUT);
pinMode(servoPinBase, OUTPUT);
pinMode(servoPinFistRotate, OUTPUT);
pinMode(servoPinFist, OUTPUT);
servo_garra.attach (9);
servo_cotovelo.attach (8);
servo_ombro.attach (7);
servo_base.attach (6);
servo_fist_rotate.attach (1);
servo_fist.attach (2);
servo_base.write (90); // Posicionamento inicial do Arm5
servo_ombro.write (90);
servo_cotovelo.write (90);
servo_fist.write (110);
servo_fist_rotate.write (90);
servo_garra.write (64); // ------------------------------
delay(4000);
} //end setup
//
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$ //
47
// $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ LOOP INFINITO
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ //
void loop()
{
// Objeto 01
armOrigin(90,30,/*base*/ 90,120,/*ombro*/ 90,180,/*cotovelo*/ 90,70); // Preencher Origem
aqui (2ºs parametros)
servo_garra.write(180); // pega objeto
delay(1000);
armOrigin(30,90,/*base*/ 120,90,/*ombro*/ 180,180,/*cotovelo*/ 70,110);
armOrigin2(90,164,/*base*/ 90,120,/*ombro*/ 180,180,/*cotovelo*/ 110,70); // Preencher
Destino aqui (2ºs parametros)
delay(500);
servo_garra.write(64); // solta objeto
delay(1000);
armDestination(164,90,/*base*/ 120,90,/*ombro*/ 180,90,/*cotovelo*/ 70,110);
servo_garra.write(64);
delay(290);
// armDestination(90,90,/*base*/ 100,100,/*ombro*/ 120,90,/*cotovelo*/ 110,110);
// End objeto 01
48
servo_base.write (90); // Posicionamento inicial do Arm5
servo_ombro.write (90);
servo_cotovelo.write(90);
servo_garra.write (64); // ------------------------------
delay(4000);
} //end void loop
// $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ LOOP INFINITO
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ //
// ############# DESENVOLVIMENTO DAS FUNÇÕES DE MANIPULAÇÃO ############# //
void armOrigin(unsigned char baseInit, unsigned char baseEnd, unsigned char ombroInit, unsigned
char ombroEnd, unsigned char cotoveloInit, unsigned char cotoveloEnd, unsigned char fistInit,
unsigned char fistEnd)
{
// Movimenta a base
if(baseInit < baseEnd)
{
moveBaseRight(10,baseInit,baseEnd);
delay(100);
}
else
{
moveBaseLeft(10,baseInit,baseEnd);
49
delay(100);
}
// End movimentação da base
// Movimenta o ombro
if(ombroInit < ombroEnd)
{
moveOmbroAhead(10,ombroInit,ombroEnd);
delay(100);
}
else
{
moveOmbroBack(10,ombroInit,ombroEnd);
delay(100);
}
// End movimentação do ombro
// Movimenta o cotovelo
if(cotoveloInit < cotoveloEnd)
{
moveCotoveloUp(10,cotoveloInit,cotoveloEnd);
delay(100);
}
else
{
moveCotoveloDown(10,cotoveloInit,cotoveloEnd);
delay(100);
50
}
// End movimentação do cotovelo
//Movimenta o punho
if(fistInit < fistEnd)
{
moveFistUp(10,fistInit,fistEnd);
delay(100);
}
else
{
moveFistDown(10,fistInit,fistEnd);
delay(100);
}
// End movimentação do punho
} //end armOrigin
void armOrigin2(unsigned char baseInit, unsigned char baseEnd, unsigned char ombroInit, unsigned
char ombroEnd, unsigned char cotoveloInit, unsigned char cotoveloEnd, unsigned char fistInit,
unsigned char fistEnd)
{
// Movimenta a base
if(baseInit < baseEnd)
{
moveBaseRight(10,baseInit,baseEnd);
51
delay(100);
}
else
{
moveBaseLeft(10,baseInit,baseEnd);
delay(100);
}
// End movimentação da base
// Movimenta o cotovelo
if(cotoveloInit < cotoveloEnd)
{
moveCotoveloUp(10,cotoveloInit,cotoveloEnd);
delay(100);
}
else
{
moveCotoveloDown(10,cotoveloInit,cotoveloEnd);
delay(100);
}
// End movimentação do cotovelo
// Movimenta o ombro
if(ombroInit < ombroEnd)
{
moveOmbroAhead(10,ombroInit,ombroEnd);
delay(100);
52
}
else
{
moveOmbroBack(10,ombroInit,ombroEnd);
delay(100);
}
// End movimentação do ombro
//Movimenta o punho
if(fistInit < fistEnd)
{
moveFistUp(10,fistInit,fistEnd);
delay(100);
}
else
{
moveFistDown(10,fistInit,fistEnd);
delay(100);
}
// End movimentação do punho
} //end armOrigin2
void armDestination(unsigned char baseInit, unsigned char baseEnd, unsigned char ombroInit,
unsigned char ombroEnd, unsigned char cotoveloInit, unsigned char cotoveloEnd, unsigned char
fistInit, unsigned char fistEnd)
53
{
// Movimenta o ombro
if(ombroInit < ombroEnd)
{
moveOmbroAhead(10,ombroInit,ombroEnd);
delay(100);
}
else
{
moveOmbroBack(10,ombroInit,ombroEnd);
delay(100);
}
// End movimentação do ombro
// Movimenta o cotovelo
if(cotoveloInit < cotoveloEnd)
{
moveCotoveloUp(10,cotoveloInit,cotoveloEnd);
delay(100);
}
else
{
moveCotoveloDown(10,cotoveloInit,cotoveloEnd);
delay(100);
}
// End movimentação do cotovelo
54
//Movimenta o punho
if(fistInit < fistEnd)
{
moveFistUp(10,fistInit,fistEnd);
delay(100);
}
else
{
moveFistDown(10,fistInit,fistEnd);
delay(100);
}
// End movimentação do punho
// Movimenta a base
if(baseInit < baseEnd)
{
moveBaseRight(10,baseInit,baseEnd);
delay(100);
}
else
{
moveBaseLeft(10,baseInit,baseEnd);
delay(100);
}
// End movimentação da base
55
} //end armDestination
// ################################################################################
//
// ############# DESENVOLVIMENTO DAS FUNÇÕES DE MOVIMENTAÇÃO SUAVE #############
//
void moveFistUp(const int tempoDelay, int inicio, int fim)
{
// tempoDelay sugerido: 5ms (Servo de alta performance)
// Exemplo: moveFistUp(10,20,90);
for(int i=inicio; i<fim; i++)
{
servo_fist.write(i);
delay(tempoDelay);
} //end for
} //end moveFistUp
void moveFistDown(const int tempoDelay, int inicio, int fim)
{
// tempoDelay sugerido: 5ms (Servo de alta performance)
// Exemplo: moveFistDown(10,90,20);
for(int i=inicio; i>fim; i--)
56
{
servo_fist.write(i);
delay(tempoDelay);
} //end for
} //end moveFistDown
void moveCotoveloUp(const int tempoDelay, int inicio, int fim)
{
// tempoDelay sugerido: 10ms (Servo de alto torque)
for(int i=inicio; i<fim; i++)
{
servo_cotovelo.write(i);
delay(tempoDelay);
} //end for
} //end moveElbowUp
void moveCotoveloDown(const int tempoDelay, int inicio, int fim)
{
// tempoDelay sugerido: 10ms (Servo de alto torque)
for(int i=inicio; i>fim; i--)
{
servo_cotovelo.write(i);
delay(tempoDelay);
} //end for
} //end moveElbowDown
void moveOmbroAhead(const int tempoDelay, int inicio, int fim)
57
{
// tempoDelay sugerido: 10ms (Servo de alto torque)
for(int i=inicio; i<fim; i++)
{
servo_ombro.write(i);
delay(tempoDelay);
} //end for
} //end moveShoulderAhead
void moveOmbroBack(const int tempoDelay, int inicio, int fim)
{
// tempoDelay sugerido: 10ms (Servo de alto torque)
for(int i=inicio; i>fim; i--)
{
servo_ombro.write(i);
delay(tempoDelay);
} //end for
} //end moveShoulderBack
void moveBaseRight(const int tempoDelay, int inicio, int fim)
{
// tempoDelay sugerido: 10ms (Servo de alto torque)
for(int i=inicio; i<fim; i++)
{
servo_base.write(i);
delay(tempoDelay);
} //end for
58
} //end moveFistRotateUp
void moveBaseLeft(const int tempoDelay, int inicio, int fim)
{
// tempoDelay sugerido: 10ms (Servo de alto torque)
for(int i=inicio; i>fim; i--)
{
servo_base.write(i);
delay(tempoDelay);
} //end for
} //end moveFistDown
// ################################################################################
//