Roberto Thiago Alberici PDF

UNIVERSIDADE DE SO PAULO
ESCOLA DE ENGENHARIA DE SO CARLOS
TRABALHO DE CONCLUSO DE CURSO
THIAGO ALBERICI ROBERTO
CLCULO DA CINEMTICA INVERSA DO ROB

MANIPULADOR PUMA 560 UTILIZANDO
ALGORITMOS GENTICOS
So Carlos
2012
2
THIAGO ALBERICI ROBERTO
CLCULO DA CINEMTICA INVERSA

DO ROB MANIPULADOR PUMA 560
UTILIZANDO ALGORITMOS
GENTICOS
Trabalho de Concluso de Curso apresentado

Escola de Engenharia de So Carlos, da
Universidade de So Paulo
Curso de Engenharia De Computao com

nfase em Robtica
ORIENTADOR: Valdir Grassi Jr.
So Carlos
2012
3
4
5
"Tenha em mente que tudo que voc aprende na
escola trabalho de muitas geraes. Tudo isso
posto em sua mo como sua herana para que
voc receba-a, honre-a, acrescente a ela e, um dia,
fielmente, deposite-a nas mos de seus filhos".
_____________________________
Albert Einsten, The World As I See It
6
7
Agradecimentos
A todos os professores que eu tive na graduao, que me proporcionaram conhecimento

para poder fazer esse e todos os projetos feitos durante a graduao. Aos funcionrios e outros
professores que de alguma forma deram suporte aos alunos trabalhando para que o curso esteja
sempre em melhoria.
Ao professor Valdir Grassi Jr. Pelo apoio, incentivo e orientao durante o

desenvolvimento desse projeto.
A minha famlia que sempre me apoiou e me deu foras em todos os projetos da minha
vida. Principalmente meus pais (Edvaldo e Lizete) e meu irmo (Vinicius). Sem eles, nada disso
teria sido possvel. Agradeo tambm a Camila, que me acompanhou durante todos esses anos
de faculdade, tambm me apoiando em todas as minhas decises.
Aos amigos que durante os anos de faculdade, dividiram a repblica comigo, sempre
proporcionando um ambiente alegre e de boa convivncia. E principalmente, agradeo a todos
os meus colegas de sala. Sem eles, o curso nunca teria sido o mesmo. Noites de estudo, de festa,
de confraternizao. Tudo isso foi muito importante no s na minha formao acadmica, mas
principalmente na minha formao como pessoa. Obrigado!
8
9
Resumo
Resolver a cinemtica de um rob manipulador um clculo de grande importncia na

rea de robtica, uma vez que esses robs so usados em escala comercial e em vrias pesquisas
cientficas. No entanto, esse um clculo que pode ser de grande complexidade. Este trabalho
tem como objetivo propor uma maneira alternativa para o clculo da cinemtica inversa de
robs manipuladores. Como referncia experimental para esse estudo, tomou-se o rob Puma
560 e foi implementado um sistema evolutivo baseado em algoritmos genticos na linguagem C.
Para os testes do mtodo proposto, os resultados foram divididos em duas principais categorias
(clculo da posio final do manipulador e clculo da posio e orientao final do
manipulador). O mtodo proposto foi analisado quanto preciso e quanto ao tempo de
processamento. Atravs de mdias e desvio-padro de uma bateria de 100 testes para cada
configurao, pode-se concluir que o mtodo muito eficaz para exemplos onde s a posio
final considerada. J para quando a complexidade do problema aumenta muito (considerando
a orientao do manipulador) o algoritmo mostrou-se apenas razovel. Para tal clculo, chegou-
se a concluso que em trabalhos futuros, o algoritmo deve sofrer melhorias.
Palavras-chave: Robs Manipuladores, Puma 560, Cinemtica Inversa, Sistemas

Evolutivos, Algoritmos Genticos.
10
11
Abstract
Solve the kinematics of a robot manipulator is a calculation of great importance in
robotics, since these robots are used on a commercial scale and in various scientific research.
However, this can be a very complex calculation. This paper proposes an alternative way to
calculate the inverse kinematics for robot manipulators. As an experimental reference for this
study, the robot Puma 560 was chosen and an evolutionary system based on Genetic Algorithms
has been implemented in C. For testing the proposed method, the results were separated in two
main categories: the end effector position calculation of the manipulator and the end position
and orientation of the manipulator. The proposed method was analyzed for accuracy and
processing time. With averages and standard deviation of 100 tests sequence to each
configuration, it can be concluded that the method is very effective for examples where only the
final position is considered, and that the algorithm is reasonable when the complexity of the
problem increases greatly (considering the orientation of the manipulator). For this calculation,
it was concluded that in future works, the algorithm must have improvements.
Keywords: Robot Manipulators, Puma 560, Inverse Kinematic, Evolutionary Systems,

Genetic Algorithm.
12
Sumrio
1. Introduo ........................................................................................................................... 16
2. Fundamentao Terica ...................................................................................................... 19
2.1. Puma 560 ......................................................................................................................... 19
2.2. Cinemtica Direta............................................................................................................ 22
2.3. Matrizes de Rotao ........................................................................................................ 24
2.4. Algoritmos Genticos ...................................................................................................... 25
2.5. Trabalhos Relacionados .................................................................................................. 27
3. Metodologia ........................................................................................................................ 29
3.1. Desenvolvimento em C ................................................................................................... 29
3.2. Cinemtica Direta............................................................................................................ 29
3.3. Estrutura dos Indivduos e Criao da Populao ........................................................... 30
3.4. Avaliao da Populao .................................................................................................. 31
3.5. Eliminao dos Menos Aptos .......................................................................................... 32
3.6. Cruzamento da Populao ............................................................................................... 32
3.7. Mutao ........................................................................................................................... 32
3.8. Critrios de Parada .......................................................................................................... 32
3.9. Entrada e Sada de Dados ................................................................................................ 32
4. Resultados e Discusso ....................................................................................................... 34
4.1. Posio ............................................................................................................................ 34
4.2. Posio + Orientao....................................................................................................... 37
5. Concluso ............................................................................................................................ 40
5.1. Dificuldade e Limitaes ................................................................................................ 40
5.2. Contribuies .................................................................................................................. 40
5.3. Trabalhos Futuros............................................................................................................ 40
Referncias .................................................................................................................................. 41
Apndice A Cinemtica Inversa com Algoritmo Gentico em C ............................................ 42
13
Lista de Ilustraes
Figura 1 - Puma 560[2] ............................................................................................................. 16
Figura 2 - Configuraes do Puma 560[2] ................................................................................ 17
Figura 3 - Esquema de Medidas do Puma560[2] ...................................................................... 20
Figura 4 - Representao de Denavit-Hartenberg[2] ................................................................ 22
Figura 5 - Rotao Roll-Pitch-Yaw[1] ....................................................................................... 24
Figura 6 - Fluxograma do Algoritmo Gentico.......................................................................... 25
14
Lista de Tabelas
Tabela 1 - Mtodo de Denavit-Hartenberg................................................................................. 23
Tabela 2 - Parmetros de Denavit-Hartenberg .......................................................................... 23
Tabela 3 - Resultados do Teste 1 ................................................................................................ 34
15
1. Introduo
Robs manipuladores vm sendo utilizados em larga escala no ambiente cientfico. As
aplicaes variam desde um rob explorador que analisa rochas e as escava em outro planeta,
at simples operaes em linhas de produo como soldagem de peas mecnicas.
Tais aplicaes tm em comum a necessidade de preciso de localizao de um ponto
ao final do brao robtico, onde se localiza o efetuador. Esse clculo envolve todas as juntas de
um rob manipulador, sejam elas prismticas (promovem um deslocamento longitudinal em
parte do brao robtico) ou de rotao (promovem um deslocamento angular em parte do brao
robtico).
O clculo da posio final do efetuador a partir dos valores dos ngulos de cada junta
conhecido como cinemtica direta. J o inverso, ou seja, a determinao de quais ngulos
devem ser utilizados para que uma posio final conhecida seja alcanada, chamado de
cinemtica inversa.
Para a cinemtica direta, existe um mtodo relativamente simples e eficaz, que resolve o
problema de maneira direta e funciona para qualquer modelo de rob. Basta seguir um
algoritmo e uma resposta nica e verdadeira ser encontrada.
J para a cinemtica inversa, o problema no de to fcil soluo. No existe uma
regra geral para a resoluo de todos os casos. Existem vrios mtodos de se encontrar a soluo
e, principalmente, existe mais de uma soluo para o mesmo ponto. Essas caractersticas podem
ser verificadas no rob Puma 560 (Figura 1).
Figura 1 - Puma 560[2]
16
O problema das vrias solues, pode ser facilmente observado, imaginando o
manipulador como um brao humano. Para alcanar um objeto com a mo, existem vrias
configuraes que se pode fazer com o brao. Essas configuraes para o Puma 560 esto
ilustradas na Figura 2 a seguir.
Figura 2 - Configuraes do Puma 560[2]
Esse conjunto de fatores, faz com que a implementao da cinemtica inversa seja
demasiadamente custosa e complicada. Por isso, alm de a soluo analtica ou geomtrica, que
so mais comumente utilizadas, outros mtodos de soluo desse problema podem se tornar
viveis. Visto que o mais proibitivo nos mtodos comuns do clculo da cinemtica inversa
muitas vezes a complexidade, a utilizao de um clculo atravs de mtodos numricos,
utilizando-se algoritmos evolutivos torna-se justificada.
Existem diversos tipos de sistemas evolutivos, como algoritmos que simulam colnia de
formigas, enxame de abelhas, dentre outros. Porm o mais difundido o Algoritmo Gentico.
O algoritmo gentico tem como principais caractersticas resolver problemas complexos
atravs de algoritmos relativamente simples, que se baseiam na Teoria da Evoluo e na
Gentica criando modelos que se adaptam de maneira eficaz em vrias reas do conhecimento.
Em resumo, algoritmos genticos buscam simular uma populao de indivduos, que
evoluem atravs de processos como reproduo, mutao, seleo natural e outros conceitos
evolucionistas, para que ao final os indivduos resultantes sejam os mais adaptados possveis ao
ambiente em que vivem.
Analogamente, para a Cinemtica Inversa, pode-se criar uma populao, onde os
indivduos so possveis ngulos para as juntas do Puma 560. Esses indivduos sofrem as
diversas adaptaes e se tornam indivduos que possuem os melhores ngulos que resultam em
uma posio e orientao escolhidas para o efetuador. Resolvendo assim, o problema da
Cinemtica Inversa.
O presente trabalho busca, portanto, implementar um algoritmo gentico para a
resoluo do problema da cinemtica inversa do rob Puma 560. O algoritmo ser desenvolvido
na linguagem C e os resultados obtidos sero analisados e estudados, revelando assim, a
viabilidade ou no desse modo de abordagem do problema da cinemtica inversa.
17
O captulo 2 trata da reviso bibliogrfica, onde a fundamentao terica necessria
para o projeto, assim como o levantamento bibliogrfico de pesquisas e trabalhos que serviram
de base para a soluo proposta nesse projeto sero apresentadas.
O captulo 3 apresentar os mtodos utilizados para a resoluo do problema. nesse
captulo que o algoritmo que foi utilizado ser apresentado, detalhado e discutido.
O captulo 4 discorre sobre a apresentao, anlise e discusso dos resultados obtidos
atravs do cdigo do programa.
O captulo 5 por fim, apresenta as consideraes finais e concluses do projeto, assim
como propostas de trabalhos futuros.
18
2. Fundamentao Terica
Neste captulo sero introduzidos os principais conceitos utilizados na elaborao desse
projeto. Para isso, sero analisadas as caractersticas mecnicas e funcionais do rob escolhido
como referncia, o equacionamento da cinemtica direta para robs manipuladores, o sistema de
matrizes de rotao utilizado e uma viso geral de algoritmos genticos. Por fim, ser feito um
levantamento de trabalhos que incentivaram essa pesquisa.
2.1. Puma 560
Criado pela empresa Unimation, o Puma 560 da srie Puma 500 utilizado tanto em
aplicaes comerciais como em ambientes de estudo como laboratrios de faculdade. Como j
foi mencionado anteriormente, trata-se de um rob manipulador. O Puma possui seis juntas de
rotao unidas por elos, e um efetuador ao final do brao.
Para os testes desse trabalho, resolveu-se modelar o Puma 560 com um segmento na
extremidade do punho, gerando um novo ponto de posio final, e fazendo com que o clculo da
posio e da orientao final do rob seja mais interessante para demonstrar os objetivos
propostos no trabalho.
Um esquema do rob em questo, com marcaes de dimenses e sistemas de
coordenadas est ilustrado a seguir na Figura 3.
19
Figura 3 - Esquema de Medidas do Puma560[2]
20
Os tamanhos de cada elo foram retirados de medidas feitas em laboratrio por outros
trabalhos [4], sendo eles:
a2 = 43,20cm, a3 = 2,00cm, d3 = 14,90cm, d4 = 43,20cm e d7 = 10,00cm.
A exceo quanto a junta d7 que teve sua medida criada para efeitos de estudo para
esse trabalho.
Alm disso, para efeitos de simulao, foi considerado o incio do rob como a posio
exata da primeira junta e todos os ngulos das juntas variando entre -180 e + 180.
21
2.2. Cinemtica Direta
Como j mencionado anteriormente neste trabalho, cinemtica direta de um rob

manipulador o estudo da posio do seu efetuador em relao aos valores das suas juntas.
Logo, atravs dela, tambm possvel definir qual ser a posio e orientao do sistema de
coordenadas do efetuador em relao ao sistema de coordenadas inicial, fixo na base (primeiro
elo).
Como visto na figura anterior (Figura 3), alm do sistema de coordenadas inicial e final,
define-se tambm um sistema para cada uma das demais juntas. A definio de todos esses
sistemas de coordenadas, foi realizada seguindo um mtodo conhecido como Representao de
Denavit-Hartenberg, atravs do qual, possvel determinar a posio e a orientao do sistema i
em relao ao sistema anterior (i1), pelo uso de matrizes homogneas, relacionando a
transformao entre estes sistemas.
Figura 4 - Representao de Denavit-Hartenberg[2]
Dado um rob composto por juntas de rotao e elos entre elas, representado
anteriormente na Figura 4, podem-se definir tambm os Parmetros de Denavit-Hartenberg,
sendo:
ai-1 o comprimento do elo (distncia entre Zi e Zi+1 ao longo de Xi-1);
i-1 a toro do elo (ngulo entre Zi e Zi+1 em torno de Xi-1);
di o deslocamento entre elos (distncia entre Xi-1 e Xi ao longo de Zi-1);
i o ngulo da junta (ngulo entre Xi-1 e Xi em torno de Zi-1).
Conhecidas as notaes e parmetros, o sistema de coordenadas de cada junta, assim

como os parmetros de Denavit-Hartenberg, podem ser definidos atravs do mtodo
demonstrado na Tabela 1 a seguir:
22
Tabela 1 - Mtodo de Denavit-Hartenberg
- Numerar os elos a partir da base imvel do manipulador. (elo 0);
- Desenhar linhas ao longo dos eixos de cada junta;
- Para o Primeiro Elo (i=0):

{0} = {1} para 1 = 0 escolhido;
d1 = 0 constante;
- Para i=1 at i =n-1;

- Posicionar a origem de Oi onde a perpendicular comum entre os eixos i e i+1
encontra com o eixo i. Se os eixos i e i+1 se cruzam, posicionar Oi nessa interseco.
Se i e i+ so paralelos, escolher Oi de forma conveniente;
- Definir o eixo Zi ao longo do eixo da junta i;
- Definir o eixo Xi ao longo da perpendicular comum entre os eixos i e i+1. Se os eixos

se interceptam, definir Xi normal ao plano contendo os dois eixos.
- Definir Yi de acordo com a regra da mo direita.
- Para o ltimo Elo (i = n):

Xi se alinha com Xi-1 para n = 0;
Origem de {N} escolhida para que dn = 0;
O resultado dos sistemas de coordenadas pode ser verificado na Figura 3 j

apresentada, e os parmetros definidos pelo mtodo podem ser encontrados a seguir na
Tabela 2.
Tabela 2 - Parmetros de Denavit-Hartenberg

i i-1 ai-1 di i
1 0 0 0 1
2 -90 0 0 2
3 0 a2 d3 3
4 -90 a3 d4 4
5 90 0 0 5
6 -90 0 0 6
7 0 0 d7 0
Dessa forma, a posio e a orientao do efetuador em relao base so obtidas por

uma composio de transformaes homogneas consecutivas, partindo-se do sistema da base
para o sistema do efetuador.
Para calcular a matriz de transformao de um sistema Oi-1 para o seguinte Oi basta
seguir as seguintes transformaes:
= Rotao (X,i-1) Translao(X, ai-1) Rotao(Z, i) Translao(Z, di)
23
Logo:
=[ ][ ]=
[ ]
Dessa forma, para obter a matriz de transformao de T07, basta calcular:
= ;
O clculo da matriz final de transformao entre o sistema inicial e final que conclui
a cinemtica direta ( ) ser realizado posteriormente no captulo 3.
2.3. Matrizes de Rotao
Para uma fcil visualizao da orientao final do efetuador, foi utilizado nesse
trabalho, o sistema de rotao Roll-Pitch-Yaw. Esse sistema de rotao prev que toda rotao
pode ser representada pela combinao de trs rotaes consecutivas ao redor de cada eixo do
sistemas de coordenadas inicial.
Considerando os ngulos roll para a rotao em torno de z, pitch para a rotao em
torno de y e yaw para a rotao em torno de x, conforme a Figura 5 a seguir.
Figura 5 - Rotao Roll-Pitch-Yaw[1]
Sendo roll = , pitch = e yaw = . A matriz final de Rotao pode ser apresentada
como na equao [1] a seguir:
24
Rxyz = Rz,, Ry,, Rx,
=[ ] [ ] [ ]
[ ]
Esse ser o sistema de rotao adotado nos clculos posteriores, no captulo 3.
2.4. Algoritmos Genticos
Sistemas Evolutivos podem ser considerados como uma rea de inteligncia

computacional que se baseia em empregar processos evolutivos sobre uma populao de
indivduos que evoluem de acordo com processos inspirados pelas leis evolucionistas como o
Darwinismo.
A definio dos diferentes tipos de Sistemas Evolutivos muitas vezes semelhante e
redundante, j que aconteceram por volta da mesma poca, e sempre a partir de um mesmo
princpio.
Nos Algoritmos Genticos, alm do princpio evolucionista, utiliza-se de operadores
genticos, tais como: reproduo, mutao e eliminao dos menos aptos, em algoritmos
iterativos para alcanar indivduos adaptados o suficientemente para resolver um problema.
A Figura 7 a seguir, mostra um resumo de como a dinmica do algoritmo gentico
usado nesse trabalho funciona. Em seguida, cada parte do fluxograma explicada de maneira
mais especfica.
Figura 6 - Fluxograma do Algoritmo Gentico
25
2.4.1. Inicializao
Como base de funcionamento para os Algoritmos Genticos, uma populao de

tamanho fixo de indivduos criada. Essa populao criada de forma aleatria, com valores
aleatrios para cada indivduo. Existem ainda, outras maneiras de se inicializar a populao,
sendo possvel levar em considerao algum conhecimento prvio na inicializao da mesma.
Cada um desses indivduos criados tm uma estrutura composta por diversos parmetros
que sero detalhados no captulo 3. Porm, para melhor exemplificao, os principais
parmetros so as possveis solues para um problema, que no contexto desse trabalho, so
equivalentes aos valores de ngulos das juntas do rob manipulador.
Esses parmetros podem ser comparados essncia daquele indivduo, como um
cromossomo. Ainda nessa comparao, cada ngulo representado pode ser comparado um
gene daquele cromossomo. A representao escolhida foi em valores numricos para os ngulos
em radianos. Porm, a mesma poderia ter sido feita com valores binrio, hexadecimais, dentre
outros.
2.4.3. Clculo do Fitness
Uma funo (no escopo desse trabalho, a cinemtica direta) associa uma nota
determinado indivduo. assim que se pode mensurar o quo adaptado aquele indivduo est.
Essa nota chamada de fitness, e nesse caso, foi definido como quanto menor, melhor.
A escolha da funo de avaliao depende muito do problema e da maneira de
representao dos indivduos. Indivduos representados por valores binrios, por exemplo,
requereriam uma funo de avaliao completamente diferente.
O mais importante que essa funo consiga dar uma nota pra cada indivduo,
separando os mais adaptados dos menos adaptados. A maneira especfica de como essa nota
calculada, ser detalhada posteriormente no captulo 3.
2.4.4. Eliminao dos Menos Aptos
A cada anlise da populao, uma anlise de aptido realizada. Se aps certo nmero
pr-definido de geraes o fitness do melhor indivduo no est se alterando, todos os demais
indivduos com exceo do melhor (elitismo) so eliminados, simulando um genocdio. Essa
tcnica ajuda a prevenir a convergncia para mnimos e mximos locais.
Gerar novamente novos indivduos faz com que um maior espao de busca seja
analisado, promovendo uma maior variabilidade nos indivduos. O melhor indivduo salvo
para no se perder a referncia do melhor resultado encontrado at ento.
2.4.5. Seleo e Reproduo
De maneira iterativa, as populaes vo sendo substitudas por novas geraes. A

seleo dos indivduos feita a partir da funo de fitness j explicada. Essa funo seleciona
qual o individuo daquela populao com a melhor nota.
Selecionado o melhor indivduo, existem vrios mtodos para se realizar a reproduo.
Na clonagem, uma cpia idntica dos indivduos transferida para a nova populao. J no
cruzamento indivduos so de alguma forma associado a outros.
Alguns mtodos de cruzamento conhecidos so a Roleta Russa, onde pra cada pai um
indivduo selecionado ao acaso para o cruzamento e o Torneio de N, onde para cada pai, n
indivduos so selecionados ao acaso, e o melhor deles que cruzar com o pai para gerar um
novo descendente.
Para esse projeto, foi utilizado o cruzamento do melhor, onde o melhor indivduo da
populao cruza com todos os outros para gerar novos descendentes.
26
2.4.6. Mutao
Por fim, aleatoriamente, alguns indivduos passam por um processo de mutao.

Pequenas modificaes na estrutura de cada indivduo (como a soma de uma pequena quantia
randmica no valor de algum ngulo) so feitas, promovendo novamente uma maior
variabilidade, e causando uma diversificao interessante para que se possa encontrar um
resultado novo. A mutao de uma parte da caracterstica de um indivduo pode ser considerada
como um gene diferente em um cromossomo, que pode gerar uma caracterstica nova, que ajude
ou no para a sobrevivncia do mesmo.
2.4.7. Critrio de Parada
Como na natureza, o algoritmo gentico est sempre em evoluo. Portanto, deve-se

criar um critrio de parada, onde os resultados daquele momento sejam tomados como resposta.
Nesse projeto, o critrio adotado como parada foi a diferena entre o erro do melhor indivduo
com um erro mnimo pr-definido, garantindo uma soluo satisfatria. Porm, caso isso no
ocorra em at 1 segundo, a evoluo tambm encerrada.
2.5. Trabalhos Relacionados
Os trabalhos relacionados a seguir, buscam exemplificar trabalhos de diversas

naturezas, voltados resoluo da cinemtica inversa utilizando-se de algoritmos genticos.
Cada um deles, com uma abordagem prpria, contribuiu para a anlise e sedimentao de
conceitos para que esse projeto fosse criado.
Dentre os diversos trabalhos relacionados pesquisados na rea, seis trouxeram
informaes relevantes para a motivao desse projeto.
Uma das maneiras mais simples do uso de algoritmos genticos para o clculo da
cinemtica inversa foi encontrada em Scofano [7]. A motivao era resolver a cinemtica
inversa para o rob Braid, de 25 elos e com dois graus de liberdade por elo, em duas dimenses.
Porm, por se tratar de um atuador binrio, apenas um conjunto de solues era possvel. O
posicionamento final era restringido h um conjunto de pontos no espao.
Uma primeira evoluo para esse trabalho foi encontrada em Nunes [6] e em Nunes,
Rosado e Grandinetti [10]. Agora, o rob utilizado o Robix RCS-6, de 3 graus de liberdade.
Os resultados continuam em duas dimenses, porm agora se trata de um atuador contnuo
(repostas em certo espao continuo, no mais pontuais). Alm disso, ambos os trabalhos
realizam tambm um planejamento de uma trajetria descrita pelo rob. O algoritmo gentico
calcula os pontos iniciais e finais desejados, e os pontos intermedirios so obtidos atravs do
clculo de uma trajetria cbica. Nunes [6] ainda faz a comparao dos resultados
implementados no MatLab e em linguagem C, concluindo que a ltima possui melhores
resultados e rapidez de processamento.
Como sugesto para trabalhos futuros, Nunes [6] prope a resoluo para um sistema
em trs dimenses. Trabalho de Ramrez e Rubiano [11] resolve o problema da cinemtica
inversa para a posio final, com o rob Teachbot-01, de 3 graus de liberdade, porm dessa vez
em trs dimenses. Uma caracterstica interessante desse trabalho a forma de visualizao de
resultados implementada, possibilitando uma imagem prxima do que seria a configurao final
do rob em questo.
Chapelle e Bidaud [9], resolvem o problema da posio para um outro rob que trabalha
em ambientes de trs dimenses, o Puma560. O rob possui 6 graus de liberdade, porm, s os
3 primeiros ngulos influenciam no clculo da posio final do rob. O clculo do
posicionamento utilizando o algoritmo gentico obteve sucesso.
Por fim, o trabalho de Santos, Lopes e Gebara [8] resolve a cinemtica inversa para
posio, usando algoritmos genticos, para o rob Puma560, porm agora, adicionando um
segmento ao final do brao robtico. Essa alterao faz com que os seis ngulos influenciem no
27
clculo da posio, aumentando a complexidade do problema. Alm disso, o planejamento de
trajetria feito, porm agora o algoritmo gentico usado para calcular todos os pontos da
trajetria. Para a otimizao dos resultados, um mtodo de reduo progressiva do espao de
busca foi utilizado.
Analisando todos esses trabalhos, esse trabalho tenta conciliar o aprendizado passado
em cada um deles, para reproduzir a tcnica de encontrar a cinemtica inversa para o Puma 560,
em trs dimenses, com seis juntas de rotao. Considerou-se um segmento ao final do brao
robtico, para a maior complexidade de resultados. Considerou-se ainda, no s a posio do
efetuador, como sua orientao. O algoritmo ser implementado na linguagem C. Como em
outros trabalhos, o algoritmo gentico ser analisado quanto viabilidade da soluo
encontrada.
.
28
3. Metodologia
A presente seo discutir qual a metodologia utilizada para implementar cada parte do
programa. Todas as consideraes aqui tm como base os conceitos tericos fundamentados no
captulo 2.
importante ressaltar que foi adotado um mtodo de resoluo para o problema,
separado em trs modos:
No primeiro modo, apenas a posio final do efetuador levada em considerao, um
clculo simples, direto, que desconsidera a orientao e gera um resultado que pode variar entre
as vrias configuraes do puma 560 pode gerar para um mesmo ponto.
No segundo modo, assim como no primeiro, a posio final do efetuador o objetivo da
soluo encontrada. Porm uma configurao de ngulos iniciais tomada como base para a
resoluo do problema. Esse modo tem como objetivo aproximar a configurao da resposta
encontrada a uma configurao anterior. Dessa forma, o manipulador no faria um movimento
muito grande para mover entre duas posies prximas em uma trajetria.
No terceiro e ltimo modo, alm da posio final, a orientao final desejada tambm
calculada. Esse clculo feito levando em considerao os parmetros de rotao roll, pitch e
yaw.
3.1. Desenvolvimento em C
O desenvolvimento do programa que calcula a cinemtica inversa atravs de algoritmos

genticos foi feito na linguagem C, no sistema operacional Windows.
Como no se trata de uma aplicao embarcada, e apenas uma simulao, o sistema
operacional oferece compatibilidade para grande maioria dos softwares utilizados no
desenvolvimento do programa.
A linguagem C, apesar de no possuir muitas ferramentas de visualizao simples como
possuem outras linguagens como MATLAB e Java, bem otimizada para realizar todas as
contas e de fcil implementao.
Todo cdigo foi feito a partir do incio, sendo que as nicas bibliotecas prontas
utilizadas foram as que so prprias da linguagem C.
3.2. Cinemtica Direta
No Captulo 2, pode-se observar quais so os parmetros e configuraes gerados pelo

algoritmo de Denavit-Hartenberg. Observou-se tambm, como a transformao de um sistema
para o outro pode ser obtida.
Dito isso, as multiplicaes de matrizes foram realizadas e a matriz final encontrada foi:
Considerando:
s1 = sen(1) e c1 = cos(1)
s2 = sen(2) e c2 = cos(2)
s3 = sen(3) e c3 = cos(3)
s4 = sen(4) e c4 = cos(4)
s5 = sen(5) e c5 = cos(5)
s6 = sen(6) e c6 = cos(6)
s23 = sen(2+ 3); c23 = cos(2+ 3)
29
Tem-se que:
= ;
=[ ], onde:
= c1*(c23*((c4*c5*c6) - (s4*s6)) - (s23*s5*c6)) + s1*((s4*c5*c6) + (c4*s6))

= s1*(c23*((c4*c5*c6) - (s4*s6)) - (s23*s5*c6)) - c1*((s4*c5*c6) + (c4*s6))
= -s23*((c4*c5*c6) - (s4*s6)) - (c23*s5*c6)
= c1*(c23*(-(c4*c5*s6) - (s4*c6)) + (s23*s5*s6)) + s1*((c4*c6) - (s4*c5*s6))
= s1*(c23*(-(c4*c5*s6) - (s4*c6)) + (s23*s5*s6)) - c1*((c4*c6) - (s4*c5*s6))
= -s23*(-(c4*c5*s6) - (s4*c6)) + (c23*s5*s6)
= -c1*((c23*c4*s5) + (s23*c5)) - (s1*s4*s5)
= -s1*((c23*c4*s5) + (s23*c5)) + (c1*s4*s5)
= (s23*c4*s5) - (c23*c5)
px = c1*(c23*(-c4*s5*d7 + a3)-s23*(c5*d7 + d4) + a2*c2) - s1*(s4*s5*d7 + d3)
py = s1*(c23*(-c4*s5*d7 + a3) - s23*(c5*d7 + d4) + a2*c2) + c1*(s4*s5*d7 + d3)
pz = s23*(c4*s5*d7-a3) - c23*(c5*d7 + d4) - a2*s2
Uma anlise rpida, permite dizer que os valores px, py, pz indicam quais so os valores
do ponto [X,Y,Z] respectivamente, encontrados para os valores de ngulos de entrada da
cinemtica direta. Da mesma forma, os valores, r11, r12, r13, r21, r22, r23, r31, r32, r33 indicam a
matriz de rotao do efetuador em relao base. Essa matriz de rotao pode ser comparada
com a matriz de rotao gerada com os parmetros de rotao Roll-Pitch-Yaw discutidos no
captulo anterior.
3.3. Estrutura dos Indivduos e Criao da Populao
Para que o algoritmo gentico tenha um bom funcionamento, necessrio definir uma
boa estruturao de cada indivduo.
No caso desse projeto, cada indivduo composto da seguinte forma:
Elementos principais, que definem todas as caractersticas do problema:
1, 2, 3, 4, 5, 6 Responsveis por armazenar o valor do ngulo de cada junta do

rob gerados por aquele indivduo. Esse conjunto de informao que d a identidade de cada
indivduo da populao.
Elementos de consulta, que so resultado de processamentos realizados com os

elementos principais:
r11, r12, r13, r21, r22, r23, , r31, r32, r33 Armazenam os valores de orientao encontrados
pelo resultado do clculo da cinemtica direta para o conjunto de ngulos do indivduo.
x, y, z Armazenam os valores da posio final do efetuador calculados pela cinemtica

direta para o conjunto de ngulos do indivduo.
Fitness Responsvel por armazenar a nota retornada da funo de avaliao do

algoritmo gentico.
30
Erro Responsvel por armazenar o erro do indivduo em relao ao fitness perfeito
(zero).
De acordo com o mtodo de inicializao escolhido, consiste em gerar valores
aleatrios entre -180 e +180 para os ngulos 1, 2, 3, 4, 5, 6 de cada indivduo.
3.4. Avaliao da Populao
Existem no programa trs variveis principais de avaliao.
A primeira (fitxyz) responsvel por avaliar a posio de cada indivduo. calculada somando-
se as diferenas entre as posies desejadas e obtidas.
fitx = mdulo(x-result[x])
fity = mdulo(y-result[y])
fitz = mdulo(z-result[z])
fitxyz = (fitx+fity+fitz);
A segunda (fitth) responsvel por avaliar a distncia de cada ngulo de um indivduo

dos ngulos iniciais. calculada somando-se as diferenas entre os ngulos iniciais e os do
indivduo.
fit1 = mdulo(th1-thini1)
fitth = (fit1+fit2+fit3+fit4+fit5+fit6)*180/pi;
Por fim, a terceira(fitr) responsvel por avaliar a distncia entre a orientao obtida e a
desejada. calculada somando-se as diferenas entre os ndices da matriz de rotao Roll-Pitch-
Yaw desejada com os ndices obtidos pela cinemtica direta.
fit11 = mdulo(rx1-result[3])
fit21 = mdulo(ry1-result[6])
fit31 = mdulo(rz1-result[9])
fitr = (fit11+fit12+fit13+fit21+fit22+fit23+fit31+fit32+fit33);
A partir da, o clculo do fitness feito de acordo com o modo de execuo que est
sendo usado.
Se o modo apenas a posio, fitness = fitxyz. Se o modo est buscando a posio
levando em considerao os ngulos iniciais, fitness = 100*fitxyz + fitth. A multiplicao do
valor de fitxyz por 100 serve para deixar os valores na mesma ordem de grandeza e,
consequentemente, mesma importncia na conta.
Se o terceiro modo for usado, onde a orientao tambm considerada, o clculo do
fitness fica: fitness = 10*fitxyz + fitr. Novamente, a multiplicao do valor de fitxyz por 10
31
serve para deixar os valores na mesma ordem de grandeza e, consequentemente, mesma
importncia na conta.
3.5. Eliminao dos Menos Aptos
Depois de certo nmero de geraes em que o melhor indivduo no evolui mais, uma
rotina de elitismo chamada. Essa rotina elimina todos os indivduos com exceo do melhor.
Porm dessa vez, os novos indivduos gerados, so criados com valores aleatrios entre -360 e
+360. Posteriormente, os valores menores que -180 e maiores que +180 so normalizados
para -180 e + 180 respectivamente.
Isso faz com que mais valores na borda sejam gerados, o que aumenta a velocidade de
evoluo em alguns casos, j que o mtodo de cruzamento escolhido aproxima os valores para
valores intermedirios, pois feito uma mdia de valores.
3.6. Cruzamento da Populao
Para o cruzamento dos indivduos e consequente formao de uma nova gerao o

mtodo do cruzamento do melhor implementado da seguinte maneira:
Um indivduo selecionado aleatoriamente. O valor de cada ngulo desse indivduo
somado ao valor do ngulo respectivo do melhor indivduo e dividido por dois. A mdia de cada
ngulo ento atribuda a um indivduo da nova populao.
O procedimento repetido para cada indivduo da nova populao, com exceo do
melhor, que copiado na ntegra.
3.7. Mutao
A mutao ocorre para causar variabilidade gentica. Para toda gerao, gerada uma
probabilidade de mutao, um nmero aleatrio entre 1 e 100. Se esse nmero estiver entre 1 e
5, 20% dos indivduos sofreram mutao. Se estiver entre 5 e 10, 10% dos indivduos sofreram
mutao. Entre 10 e 30, 7% dos indivduos sofrem mutaes, entre 30 e 50, 3% dos indivduos
sofrem mutaes, e entre 50 e 80, 1% dos indivduos sofre mutao. Para nmeros entre 80 e
100 no ocorre nenhuma mutao.
Aps definido o nmero de mutaes, sorteia-se quais indivduos sero os que iro
sofrer a mutao, e para cada um deles, sorteia-se ainda nmeros entre -18 e + 18 para serem
adicionados a cada ngulo.
Posteriormente, os valores menores que -180 e maiores que +180 so normalizados
para -180 e + 180 respectivamente, para manter os resultados condizentes.
3.8. Critrios de Parada
Para cada modo de operao do algoritmo, um erro diferente calculado. No primeiro e

segundo modo, descritos no comeo desse captulo, o erro analisado a varivel fitxyz, descrita
no item 3.5. J para o ltimo modo, o erro a soma do fitxyz com o fitr, descrito no mesmo
item.
Em todos esses casos, se o erro obtido for inferior a um erro pr-estipulado, o algoritmo
para de evoluir e devolve o melhor indivduo como resposta. Se por acaso o algoritmo levar
mais de 1 segundo para evoluir, o critrio de parada tambm acionado.
3.9. Entrada e Sada de Dados
32
Para entrada de dados, exemplos de execuo so definidos, onde devem ser
configurados o modo de execuo, e os valores necessrios para cada modo.
O modo 1 requer apenas uma posio final (X,Y,Z).
No modo 2, alm da posio final, devem ser configurados os ngulos iniciais thini1,
thini2, thini3, thini4, thini5, thini6
No modo 3, devem ser configurados a posio final, e os parmetros roll, pitch e yaw da
orientao desejada em relao ao sistema base.
A sada tambm dependente do modo de configurao. Em todos os casos, os ngulos
de cada junta e a posio final do efetuador so exibidos. Porm, somente no modo 3, exibida
tambm a matriz de rotao Roll-Pitch-Yaw.
33
4. Resultados e Discusso
Ao presente captulo, caber a anlise dos resultados gerados pelo programa, assim
como a discusso da confiabilidade e viabilidade dos mesmos. Alm de analisar os resultados
gerados, importante ressaltar quais foram as entradas usadas para colher tais resultados.
Para uma melhor compreenso, os resultados sero divididos entre os testes para a
posio e os testes para posio e orientao do manipulador. A simulao foi divida em 6
testes.
Para cada um dos testes descritos a seguir, foram analisados 100 resultados. O melhor
resultado de cada teste, assim como a mdia dos valores encontrados e o desvio padro, so
exibidos nas tabelas a seguir. Nos valores de erros das tabelas, o Erro da Posio, a soma dos
erros das posies x, y e z. O Erro nos ngulos Iniciais a soma da distncia de todos os
ngulos encontrados com o seu respectivo ngulo inicial. Por fim, o Erro de Orientao a
soma da diferena entre cada posio da matriz de rotao encontrada e da desejada.
4.1. Posio
4.1.1. Teste 1
Objetivo: Simples comprovao do modo 1 (s a posio final) para um ponto A

qualquer.
Modo: 1.
Valores de Posio Desejados:
x = 3,40cm; y = 20,84cm; z = -20,67cm.
Possvel soluo que gera a posio e orientao desejadas:
1= 30, 2= -40, 3= 60, 4= 20, 5= 25, 6= 30.
Tabela 3 - Resultados do Teste 1

Teste 1 100 valores Melhor Mdia Desvio Padro
Tempo(s) 0,024 0,145 0,248
Nmero de Iteraes 340 1998 3408
Erro na Posio (cm) 0,01 0.13 0,29
Posio encontrada para o melhor:

x = 3,40cm; y = 20,84cm; z = -20,66cm.
ngulos encontrados para o melhor:
1= -66,00; 2= -136,92; 3= 120,02; 4= -45,31; 5= 27,83; 6= -11,62.
Analisando os resultados anteriores, pode-se concluir que so resultados muito

satisfatrios, j que uma tima preciso na localizao da posio final foi garantida e o tempo
de execuo foi bem baixo.
34
4.1.2. Teste 2
Objetivo: Simples comprovao do modo 1 (s a posio final) para um ponto B

qualquer prximo de A.
Modo: 1.
x = 7,19cm; y = 24,15cm; z = -16,89cm.
1= 35, 2= -45, 3= 50, 4= 5, 5= 60, 6= 90.

Tempo(s) 0,007 0,123 0,226
Erro na Posio (cm) 0,02 0,09 0,06

x = 7,19cm; y = 24,15cm; z = -16,88cm.
1= -63,97; 2= -140,37; 3= 136,28; 4= -12,77; 5= -77,49; 6= -157,86.

Alm disso, pode-se perceber que os valores de ngulos encontrados so bem diferentes
dos conhecidos na possvel soluo. Isso prova a multiplicidade de resultados do manipulador,
j que um resultado satisfatrio com outra configurao foi encontrado para a mesmo posio
do efetuador.
Percebe-se no teste 2, em relao ao teste 1, que para sair do Ponto A (baseado nos
ngulos: 1= 30, 2= -40, 3= 60, 4= 20, 5= 25, 6= 30) e caminhar at o ponto B prximo
de A, ocorreu um grande deslocamento angular (1= -63,97; 2= -140,37; 3= 136,28; 4= -
12,77; 5= -77,49; 6= -157,86).
35
4.1.3. Teste 3
Objetivo: Comprovar a diferena entre os modos 1 (s a posio final) e 2 (posio final

+ ngulos iniciais) para o mesmo ponto B prximo de A.
Modo: 2
x = 7,19cm; y = 24,15cm; z = -16,89cm.
1= 35, 2= -45, 3= 50, 4= 5, 5= 60, 6= 90.
Valor dos ngulos iniciais:
1= 30, 2= -40, 3= 60, 4= 20, 5= 25, 6= 30.

Tempo(s) 0,066 0,092 0,164
Erro na Posio (cm) 0,06 0,08 0,02
Erro nos ngulos
109,97 339,88 111,69
Iniciais (graus)

x = 7,17cm; y = 24,15cm; z = -16,85cm.
1= 32,28; 2= -55,61; 3= 61,20; 4= 36,28; 5= 16,60; 6= -36,20.

Alm disso, pode-se perceber que os valores de ngulos encontrados dessa vez so bem
mais prximos aos passados como ngulos iniciais. Isso prova que a aproximao implementada
para ngulos iniciais funciona de maneira correta.
Diferentemente do que aconteceu at ento com o Erro na Posio, o Erro nos ngulos
Iniciais apresentou uma mdia e desvio padro alto. O que indica que o algoritmo nem sempre
est chegando a uma soluo satisfatria.
Percebe-se no teste 3, em relao ao teste 1, que para sair do Ponto A (baseado nos
ngulos: 1= 30, 2= -40, 3= 60, 4= 20, 5= 25, 6= 30) e caminhar at o ponto B prximo
de A, ocorreu um pequeno deslocamento angular (1= 32,28; 2= -55,61; 3= 61,20; 4=
36,28; 5= 16,60; 6= -36,20). Isso demonstra a eficcia do modo 2 (teste 3) em relao ao
modo 1(teste 2).
36
4.2. Posio + Orientao
4.2.1. Teste 4
Objetivo: Simples comprovao do funcionamento do modo 3 (posio final +

orientao final).
Modo = 3.
x = 45,20cm; y = 14,90cm; z = -53,20cm.
1= 2= 3= 4= 5= 6=0.
Parmetros de rotao escolhidos:
yaw = 0, pitch = 180 e roll = 180.
Matriz de rotao definida pelos parmetros Roll, Pitch e Yaw: [ ].

Tempo(s) 1,00 1,000 0,000
Erro na Posio (cm) 0,11 0,37 0,85
Erro na Orientao 0,16 3,97 2,43

x = 45,20cm; y = 14,90cm; z = -53,20cm.
1= -142,93; 2= -179,86; 3= -175,84; 4= -72,04; 5= -2,74; 6= -70,99.
Matriz de rotao encontrada para o melhor: [ ]

satisfatrios, j que uma tima preciso na localizao da posio final foi garantida, assim
como uma tima preciso na matriz de rotao. Porm, j possvel perceber que o algoritmo
no convergiu em tempo suficiente, parando apenas no limite de 1 segundo. Apesar disso, o
resultado ainda muito satisfatrio.
37
4.2.2. Teste 5
Objetivo: Comprovao do funcionamento do modo 3 (posio final + orientao final)

para mesma posio com orientaes diferentes (Orientao 1).
Modo = 3.
x = 43,70cm; y = 11,55cm; z = 42,00cm.
yaw = 0, pitch = -90 e roll = 180.

Tempo(s) 1,000 1,000 0,000
Erro na Posio (cm) 0,05 0,23 0,68

x = 43,75cm; y = 11,55cm; z = 42,00cm.
1= -3,84; 2= -103,81; 3= 15,25; 4= -36,09; 5= 4,34; 6= 36,43.
Analisando os resultados anteriores, pode-se concluir que so resultados satisfatrios, j

que uma tima preciso na localizao da posio final foi garantida, seguida de uma boa
preciso na matriz de rotao. O tempo de execuo novamente ultrapassou o limite de 1
segundo.
38
4.2.3. Teste 6
Objetivo: Comprovao do funcionamento do modo 3 (posio final + orientao final)

para mesma posio com orientaes diferentes (Orientao 2).
Modo = 3.
x = 43,70cm; y = 11,55cm; z = 42,00cm.
yaw = 0, pitch = 0 e roll = 180.

Tempo(s) 1,000 1,000 0,000
Erro na Posio (cm) 0,02 0,36 1,22

x = 43,70cm; y = 11,55cm; z = 41,98cm.
1= -151,88; 2= -87,46; 3= 167,66; 4= 152,54; 5= -77,09; 6= 27,97.
Analisando os resultados anteriores, pode-se concluir que so resultados razoveis, j

que uma tima preciso na localizao da posio final foi garantida, seguida de uma preciso
ruim na matriz de rotao. O tempo de execuo novamente ultrapassou o limite de 1 segundo.
A anlise da mdia e do desvio padro do Erro na Orientao revela que os valores de
um modo geral esto distantes do objetivo de preciso.
39
5. Concluso
O presente trabalho contou com uma variedade grande de testes, porm todos para
provar um mesmo objetivo, o clculo da cinemtica inversa para o Puma560 utilizando-se
algoritmos genticos.
Os diferentes testes foram realizados, porque o trabalho tentou explorar vrias reas de
utilizao da cinemtica inversa, tentando retirar todas as informaes possveis provenientes
desse clculo.
Ficou evidenciado que o algoritmo gentico resolveu muito bem problemas simples
como a definio da posio do efetuador.
Quando se trata de problemas mais complexos, como definio de posio e orientao
do efetuador, o algoritmo gentico obteve uma soluo satisfatria, porm consideravelmente
mais lenta e menos precisa.
Pela anlise final dos resultados, pode-se concluir que o objetivo desse trabalho foi
cumprido. A resoluo do problema utilizando algoritmos genticos completamente vivel e
pode ser uma tima alternativa para os mtodos convencionais.
O tempo de execuo, mesmo nos piores casos, no so proibitivos, e a preciso,
mesmo nos piores casos, mais do que suficiente para a maioria das aplicaes. Portanto, o
resultado satisfatrio, porm depende muito da aplicao.
5.1. Dificuldade e Limitaes
As maiores dificuldades encontradas na execuo desse trabalho, esto relacionadas

com a convergncia do algoritmo gentico. Conforme o problema foi crescendo e a
complexidade aumentando, maiores eram as dificuldades de fazer o algoritmo evoluir em um
tempo hbil.
Percebeu-se que quanto mais valores so levados em considerao na funo de fitness,
maior a chance de uma dada populao inicial randmica ficar presa em mnimos e mximos
locais.
Para amenizar esse problema, mais operadores genticos foram criados e diferentes
tcnicas foram testadas. Isso gerou outra dificuldade, balancear inmeras variveis em busca de
um bom resultado.
5.2. Contribuies
Dentre as contribuies desse trabalho, vale citar que foi um estudo completo do
Puma560, considerando toda a sua mecnica e geometria, no espao de trs dimenses, com
todas as juntas existentes. Logo, pode-se entender bem o funcionamento desse manipulador
robtico.
Alm disso, foi feito um bom estudo sobre tcnicas e parmetros de algoritmos
genticos, e dos clculos de cinemticas direta e inversa.
5.3. Trabalhos Futuros
Da anlise dos dados obtidos, tem-se motivao para uma melhor estruturao de um
novo algoritmo gentico, com diferentes mtodos de fitness e diferentes operadores genticos,
para que uma maior preciso e eficincia sejam alcanados.
Para complementar o estudo realizado, poderia ser adicionado ao cdigo, uma tcnica
de clculo de trajetria, no se restringindo mais h apenas pontos isolados. Aps isso, existe
tambm a possibilidade de se considerar o problema do desvio de obstculos no planejamento
da trajetria.
40
Referncias
[1] Mark W. Spong; Seth Hutchinson; M. Vidyasagar; "Robot Modeling and Control", John
Wiley, 2006.
[2] John J. Craig; "Introduction to Robotics: Mechanics and Control", 3rd edition, Pearson-
Prentice Hall, 2005.
[3] Evolutionary Computation: A Unified Approach, Kenneth A. De Jong, MIT Press,

Cambridge, 2006.
[4] Peter I. Corke, Brian Armst rong-Hdouvry, A Search for Consensus Among Model
Parameters Reported for the PUMA 560 Robot.
[5] http://www.antenen.com/htdocs/downloads/files/files_dl/puma560.pdf, Acessado em

15/11/12, Datasheet do rob Puma560.
[6] Nunes, Luiz Eduardo Nicolini do Patrocnio, Gerao e otimizao de trajetrias de um

manipulador robtico utilizando algoritmos genticos, Universidade Estadual Paulista,
Guaratinguet, 2007.
[7] Felipe S. Scofano, Obteno da Cinemtica Inversa de Robs 2D Binrios Hiper-

Redundantes por Algoritmos Genticos, Pontifcia Universidade Catlica do Rio de Janeiro.
[8] Alfranci Freitas Santos, Heitor Silvrio Lopes, Munif Gebara Junior, Cinemtica Inversa de
Trajetrias de Manipuladores Robticos Redundantes utilizando Algoritmos Genticos com
Reduo progressiva do espao de busca, Centro Federal de Educao Tecnolgica do Paran,
2005.
[9] F. Chapelle, P., Bidaud, A, Closed Form for Inverse Kinematics Approximation of
General 6R Manipulators using Genetic Programming, Universit Paris, 2001.
[10] Luiz Eduardo Nicolini do Patrocnio Nunes, Victor Orlando Gamarra Rosado, Francisco
Jos Grandinetti, Aplicao de algoritmos genticos e polinmios cbicos na gerao de
trajetrias de um manipulador robtico, Universidade de Taubat.
[11] J. Ramrez A., A. Rubiano F, Optimization of Inverse Kinematics of a 3R Robotic

Manipulator using Genetic Algorithms, World Academy of Science, Engineering and
Technology, 2011.
41
Apndice A Cinemtica Inversa com Algoritmo Gentico em C
A seguir encontra-se o cdigo completo utilizado no presente projeto, desenvolvido em
C, para calcular a cinemtica inversa utilizando algoritmos genticos.
/*Libraries*/
#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"
#include <iostream>
#include <windows.h>
#include <fstream>
#include <sys/timeb.h>
/*Definies Matemticas*/
#define pi acos(-1.0)
/*Dimenses do Rob em cm - A Search for Consensus Among Model Parameters Reported for the PUMA 560
Robot*/
double a2 = 43.2;
double a3 = 2.0;
double d3 = 14.9;
double d4 = 43.2;
double d7 = 10.0;//Valor fictcio, pois o brao foi inventado apenas para simulao.
/*Valores para a Posio Desejada*/

double x, y, z;
/*ngulos Iniciais*/
double thini1; double thini2; double thini3; double thini4; double thini5; double thini6;
/*Valores para a Orientao Desejada*/
double yaw, pitch, roll;
double sroll, croll, spitch, cpitch, syaw, cyaw;//Seno e Cosseno dos ngulos roll, pitch e yaw.
double rx1,rx2,rx3,ry1,ry2,ry3,rz1,rz2,rz3;//Valores de translao.
/*Modo de Operao*/
double mode;//0 - Posio, 1 - Posio + ngulos Anteriores, 2 - Posio + Orientao.
double samples = 100;//Nmero de amostras para cada teste.
/*Variaveis usadas para calculos estatisticos*/

double media_tempo, desvpadr_tempo;
double media_interacoes, desvpadr_interacoes;
double media_erropos, desvpadr_erropos;
double media_erroant, desvpadr_erroant;
double media_erroori, desvpadr_erroori;
/*Prametros do Algoritmo Evolutivo*/

#define pop 100//Tamanho da populao.
double acerto = 0.1;//Erro mximo permitido.
double genoTaxa = 200;//Diferena entre bests para incrementar o genocidio.
double genocidio = 10;//Nmero de genoTaxas necessrias para ocorrer o genocidio.
/*Estrutura de cada indivduo*/

struct individuo{
double th1, th2, th3, th4, th5, th6;
double r11, r12, r13, r21, r22, r23, r31, r32, r33;
double x,y,z;
double fitness;
double erropos, erroant, erroori;
double erro;
};
/*Estrutura das Respostas*/

struct respostas{
double x,y,z;
42
double th1, th2, th3, th4, th5, th6;
double r11, r12, r13, r21, r22, r23, r31, r32, r33;
double fitness;
double erropos, erroant, erroori;
double tempo;
int geracoes;
};
/*Definindo as Populaes*/
struct individuo parents[pop];//Populao de Pais
struct individuo childrens[pop];//Populao de Filhos
struct respostas resposta[100];//Populao de Respostas
/*Funo que calcula a posio x,y,z pela cinemtica direta*/

double * cinematicaDireta(int num_indiv)
{
double s1, s2, s3, s4, s5, s6;//Seno dos ngulos.
double c1, c2, c3, c4, c5, c6;//Cosseno dos ngulos.
double s23, c23;//Seno e Cosseno da soma dos ngulos.
double r11, r21, r31, r12, r22, r32, r13, r23, r33;//Valores de rotao.
double px, py, pz;//Valores de translao.
double th1 = parents[num_indiv].th1;

s1 = sin(th1); s2 = sin(th2); s3 = sin(th3); s4 = sin(th4); s5 = sin(th5); s6 = sin(th6);//Definio do seno dos

ngulos.
c1 = cos(th1); c2 = cos(th2); c3 = cos(th3); c4 = cos(th4); c5 = cos(th5); c6 = cos(th6);//Definio do
cosseno dos ngulos.
s23 = sin(th2+th3); c23 = cos(th2+th3);//Definio do seno e do cosseno das somas dos ngulos.
r11 = c1*(c23*((c4*c5*c6)-(s4*s6)) - (s23*s5*c6))+s1*((s4*c5*c6)+(c4*s6));//Linha 1, coluna 1, da

matriz de transformao.
r21 = s1*(c23*((c4*c5*c6)-(s4*s6)) - (s23*s5*c6))-c1*((s4*c5*c6)+(c4*s6));//Linha 2, coluna 1, da matriz
de transformao.
r31 = -s23*((c4*c5*c6)-(s4*s6))-(c23*s5*c6);//Linha 3, coluna 1, da matriz de transformao.
r12 = c1*(c23*(-(c4*c5*s6)-(s4*c6))+(s23*s5*s6))+s1*((c4*c6)-(s4*c5*s6));//Linha 1, coluna 2, da matriz

de transformao.
r22 = s1*(c23*(-(c4*c5*s6)-(s4*c6))+(s23*s5*s6))-c1*((c4*c6)-(s4*c5*s6));//Linha 2, coluna 2, da matriz
de transformao.
r32 = -s23*(-(c4*c5*s6)-(s4*c6))+(c23*s5*s6);//Linha 3, coluna 2, da matriz de transformao.
r13 = -c1*((c23*c4*s5)+(s23*c5))-(s1*s4*s5);//Linha 1, coluna 3, da matriz de transformao.

r23 = -s1*((c23*c4*s5)+(s23*c5))+(c1*s4*s5);//Linha 2, coluna 3, da matriz de transformao.
r33 = (s23*c4*s5)-(c23*c5);//Linha 3, coluna 3, da matriz de transformao.
px = c1*(c23*(-c4*s5*d7+a3)-s23*(c5*d7+d4)+a2*c2)-s1*(s4*s5*d7+d3);//Linha 1, coluna 4, da matriz de

transformao.
py = s1*(c23*(-c4*s5*d7+a3)-s23*(c5*d7+d4)+a2*c2)+c1*(s4*s5*d7+d3);//Linha 2, coluna 4, da matriz
de transformao.
pz = s23*(c4*s5*d7-a3)-c23*(c5*d7+d4)-a2*s2;//Linha 3, coluna 4, da matriz de transformao.
parents[num_indiv].r11 = r11;
43
parents[num_indiv].x = px;
parents[num_indiv].y = py;
parents[num_indiv].z = pz;
double result[12] = {px,py,pz, r11,r12,r13,r21,r22,r23,r31,r32,r33};//Reultados da translao e da rotao.
return result;
}
/*Clculo da funo de Fitness*/

double nota(int num_indiv)
{
double *result = cinematicaDireta(num_indiv);//Recebe os valores da cinemtica direta.
/*Atribui os valores calculados para o individuo*/

/*Calcula o fitness para o individuo*/

double fitness;//Fitness total.
double fitx, fity, fitz;//Fitness da posio.
double fit1, fit2, fit3, fit4, fit5, fit6;//Fitness dos ngulos anteriores.
double fit11, fit12, fit13, fit21, fit22, fit23, fit31, fit32, fit33;//Fitness dos ngulos de rotao.
double fitxyz = -1, fitr = -1, fitth = -1;//Fitness de cada modo.
/*Posio*/
fitx = x-result[0]; if(fitx<0) fitx = fitx*(-1);
fity = y-result[1]; if(fity<0) fity = fity*(-1);
fitz = z-result[2]; if(fitz<0) fitz = fitz*(-1);
fitxyz = (fitx+fity+fitz);
fitness = fitxyz;
parents[num_indiv].erro = fitxyz;
/*ngulos Iniciais*/
if(mode == 1){
fit1 = th1-thini1; if(fit1<0) fit1 = fit1*(-1);
fitth = (fit1+fit2+fit3+fit4+fit5+fit6)*180/pi;
fitness = 100*fitxyz + fitth;
parents[num_indiv].erro = fitxyz;
}
/*Orientao*/
if(mode == 2){
fit11 = rx1-result[3]; if(fit11<0) fit11 = fit11*(-1);
fit21 = ry1-result[6]; if(fit21<0) fit21 = fit21*(-1);
fit31 = rz1-result[9]; if(fit31<0) fit31 = fit31*(-1);
fitr = (fit11+fit12+fit13+fit21+fit22+fit23+fit31+fit32+fit33);
fitness = fitxyz + fitr;
44
parents[num_indiv].erro = 10*fitxyz + fitr;
}
parents[num_indiv].erropos = fitxyz;
parents[num_indiv].erroant = fitth;
parents[num_indiv].erroori = fitr;
return fitness;
}
int main()
{
/*Variveis para contar tempo*/
struct timeb ini, fim;
srand(time(NULL));//Gerando numeros aleatorios.
int best = 0;//Posio do melhor.

int kill = 0;//Constante de genocdio.
double bestant = 10000000;//Melhor da gerao anterior, valor alto para no entrar a primeira vez no kill++.
int parent1 = 0, parent2 = 0;//Escolha dos dois individuos para o cruzamento.
int mut = 0, muta = 0, mutb = 0;//Nmeros para armazenar os valores de escolha da mutao.
double plus = 0.0;//Nmero a ser somado para que ocorra a mutao.
int geracoes_cont = 0;//Nmero de geraes.
int best_resposta = -1;//Melhor resposta da Bateria de Respostas.
double resposta_ant;//Resposta anterior da Bateria de Respostas.
/*Bateria de Testes*/
for(int teste=1;teste<=6;teste++){
/*Bateria de Respostas*/
for(int tries=0;tries<samples;tries++){
ftime(&ini);//Reseta a contagem de Tempo.

geracoes_cont = 0;//Reseta a contagem de Iteraes.
//Teste s com a Posio final - Aleatria.

if(teste == 1){
mode = 0;
x = 3.40; y = 20.84; z = -20.67;
//Teste s com a Posio final - Valor para todos os ngulos zeros.

}else if(teste == 2){
mode = 0;
x = 7.19; y = 24.15; z = -16.89;
//Teste com a Posio Final + ngulos Anteriores - Valor para todos os ngulos zeros.
mode = 1;
x = 7.19; y = 24.15; z = -16.89;
thini1 = 30*pi/180; thini2 = -40*pi/180; thini3 = 60*pi/180; thini4 =
20*pi/180; thini5 = 25*pi/180; thini6 = 30*pi/180;
//Teste com a Posio + Orientao - Valor para todos os ngulos zeros, sem rotao.
mode = 2;
x = 45.20, y = 14.90, z = -53.20;
yaw = 0*pi/180, pitch = 180*pi/180, roll = 180*pi/180;
sroll = sin(roll); croll = cos(roll);

spitch = sin(pitch); cpitch = cos(pitch);
syaw = sin(yaw); cyaw = cos(yaw);
rx1 = croll*cpitch;
rx2 = -sroll*cyaw+croll*spitch*syaw;
rx3 = sroll*syaw+croll*spitch*cyaw;
ry1 = sroll*cpitch;
ry2 = croll*cyaw+sroll*spitch*syaw;
ry3 = -croll*syaw+sroll*spitch*cyaw;
45
rz1 = -spitch;
rz2 = cpitch*syaw;
rz3 = cpitch*cyaw;
//Teste com a Posio + Orientao - 1a. Orientao Escolhida

mode = 2;
//d7 = 0; a3 = 0;//Mudando os parametros do rob para uma melhor
visualizao.
x = 43.70, y = 11.55, z = 42.00;
yaw = 0*pi/180, pitch = -90*pi/180, roll = 180*pi/180;

rx1 = croll*cpitch;
ry1 = sroll*cpitch;
rz1 = -spitch;
rz2 = cpitch*syaw;
rz3 = cpitch*cyaw;
//Teste com a Posio + Orientao - 2a. Orientao Escolhida

mode = 2;
//d7 = 0; a3 = 0;//Mudando os parametros do rob para uma melhor
visualizao.
x = 43.70, y = 11.55, z = 42.00;
yaw = 0*pi/180, pitch = 0*pi/180, roll = 180*pi/180;

rx1 = croll*cpitch;
ry1 = sroll*cpitch;
rz1 = -spitch;
rz2 = cpitch*syaw;
rz3 = cpitch*cyaw;
}
//Inicializao da populao original randmicamente.

for(int i=0; i<pop; i++){
parents[i].th1 = rand()%36000;
parents[i].th1 = ((parents[i].th1/100.0f)-180)*pi/180;parents[i].th1;
}
/*Avaliao*/
while (1){
/*Clculo das notas de cada individuo*/
46
parents[i].fitness = nota(i);
}
/*Clculo do melhor individuo*/

if(parents[i].fitness <= parents[best].fitness){
best = i;
}
}
/*Aumentando a constante de genocdio, caso a nota do melhor continue a

mesma*/
if((bestant - parents[best].fitness) <= genoTaxa){
kill++;
}
/*Genocidio. Recria todos os individuos, com exceo do melhor*/

if(kill >= genocidio){
if(i != best){
parents[i].th1 = ((parents[i].th1/100.0f)-
360)*pi/180;
360)*pi/180;
360)*pi/180;
360)*pi/180;
360)*pi/180;
360)*pi/180;
}
/*Regularizando Individuos*/
if(parents[i].th1 > 180*pi/180) parents[i].th1 =
180*pi/180;
else if(parents[i].th1 < -180*pi/180) parents[i].th1 = -
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
}
kill = 0;//Reseta a contagem de genocidio.
}
47
/*Seleo*/
for(int i=0; i < pop; i++){
parent1 = best;
parent2 = rand()%pop;//Sorteia um indivduo.
/*Com exceo do melhor, cruza*/

if (i == best)
childrens[i] = parents[best];
else{
childrens[i].th1 =
(parents[parent1].th1+parents[parent2].th1)/2;
childrens[i].th2 =
childrens[i].th3 =
childrens[i].th4 =
childrens[i].th5 =
childrens[i].th6 =
}
/*Nova gerao*/
parents[i] = childrens[i];
}
/*Mutao*/
muta = rand()%100;//Sorteia um nmero, dependendo do resultado decide
quantas vezes mutar.
if(muta>80 && muta>=50)
mut = 1;
else if(muta<50 && muta>=30)
mut = 3;
mut = 7;
mut = 10;
mut = 20;
/*Muta o numero de vezes escolhidas*/

for(int i=0; i< mut; i++){
/*Escolhe algum aleatoriamente para mutar, com exceco do
melhor*/
mutb = rand()%pop;
if(mutb != best){
plus = rand()%3600;
plus = (plus/100.0f)-18.00;
parents[mutb].th1 = parents[mutb].th1 + plus;
plus = rand()%3600;
plus = (plus/100.0f)-18.00;
plus = rand()%3600;
plus = (plus/100.0f)-18.00;
plus = rand()%3600;
plus = (plus/100.0f)-18.00;
plus = rand()%3600;
plus = (plus/100.0f)-18.00;
plus = rand()%3600;
plus = (plus/100.0f)-18.00;
}
48
/*Regularizando Individuos*/
if(parents[mutb].th1 > 180*pi/180) parents[mutb].th1 =
180*pi/180;
else if(parents[mutb].th1 < -180*pi/180) parents[mutb].th1 = -
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
180*pi/180;
}
/*Armazenando qual foi o best do ltimo melhor individuo*/

bestant = parents[best].fitness;
/*Atualizando o Clculo do Tempo de Execuo*/

ftime(&fim);
/*Atualizando o Clculo do Numero de Geraes*/

geracoes_cont++;
/*Parando a simulao quando a preciso for atingida ou passar mais de 1

segundo*/
if(parents[best].erro < acerto || (((double)
fim.time+((double)fim.millitm*0.001))-((double)ini.time+((double)ini.millitm*0.001))) >= 1.0)
break;
}
/*Armazenando Respostas*/
resposta[tries].x = parents[best].x;
resposta[tries].y = parents[best].y;
resposta[tries].z = parents[best].z;
resposta[tries].th1 = parents[best].th1;
resposta[tries].r11 = parents[best].r11;
resposta[tries].fitness = parents[best].fitness;
resposta[tries].erropos = parents[best].erropos;
resposta[tries].erroant = parents[best].erroant;
resposta[tries].erroori = parents[best].erroori;
49
resposta[tries].tempo = (((double) fim.time+((double)fim.millitm*0.001))-
((double)ini.time+((double)ini.millitm*0.001)));
resposta[tries].geracoes = geracoes_cont;
}
/*Escolhendo a melhor resposta*/

best_resposta = 0;
resposta_ant = 1000000;
if(resposta[best_resposta].fitness > resposta[tries].fitness)
best_resposta = tries;
}
/*Impresso dos resultados*/

printf("\n\tTeste %d\n",
teste);
printf("\nResultados dos cem:\n\n");

if(mode == 0){
printf("\n[Tempo em s], [Iteracoes], [Erro Posicao]\n");
media_tempo = 0; desvpadr_tempo = 0;
media_interacoes = 0; desvpadr_interacoes = 0;
media_erropos = 0; desvpadr_erropos = 0;
printf("%.3lf, %d, %.2lf\n",
resposta[tries].tempo, resposta[tries].geracoes, resposta[tries].erropos);
media_tempo = media_tempo + resposta[tries].tempo;
media_interacoes = media_interacoes + resposta[tries].geracoes;
media_erropos = media_erropos + resposta[tries].erropos;
}
media_tempo = media_tempo/samples;
media_interacoes = media_interacoes/samples;
media_erropos = media_erropos/samples;
desvpadr_tempo = desvpadr_tempo + pow((resposta[tries].tempo -
media_tempo),2);
desvpadr_interacoes = desvpadr_interacoes + pow((resposta[tries].geracoes -
media_interacoes),2);
desvpadr_erropos = desvpadr_erropos + pow((resposta[tries].erropos -
media_erropos),2);
}
desvpadr_tempo = sqrt(desvpadr_tempo/(samples-1));
desvpadr_interacoes = sqrt(desvpadr_interacoes/(samples-1));
desvpadr_erropos = sqrt(desvpadr_erropos/(samples-1));
printf("\nMedias:\n");
printf("%.3lf, %.0lf, %.2lf\n",
media_tempo, media_interacoes, media_erropos);
printf("\nDesvio Padrao:\n");
printf("%.3lf, %.0lf, %.2lf\n",
desvpadr_tempo, desvpadr_interacoes, desvpadr_erropos);
}
if(mode == 1){
printf("\n[Tempo em s], [Iteracoes], [Erro Posicao], [Erro Angulo Inicial]\n");
media_erroant = 0; desvpadr_erroant = 0;
printf("%.3lf, %d, %.2lf, %.2lf\n",
resposta[tries].tempo, resposta[tries].geracoes, resposta[tries].erropos,
resposta[tries].erroant);
50
media_erroant = media_erroant + resposta[tries].erroant;
}
media_erroant = media_erroant/samples;
media_tempo),2);
media_erropos),2);
desvpadr_erroant = desvpadr_erroant + pow((resposta[tries].erroant -
media_erroant),2);
}
desvpadr_erroant = sqrt(desvpadr_erroant/(samples-1));
printf("%.3lf, %.0lf, %.2lf, %.2lf\n",
media_tempo, media_interacoes, media_erropos, media_erroant);
desvpadr_tempo, desvpadr_interacoes, desvpadr_erropos, desvpadr_erroant);
}
if(mode == 2){
printf("\n[Tempo em s], [Iteracoes], [Erro Posicao], [Erro Orientacao]\n");
media_erroori = 0; desvpadr_erroori = 0;
printf("%.3lf, %d, %.2lf, %.2lf\n",
resposta[tries].tempo, resposta[tries].geracoes, resposta[tries].erropos,
resposta[tries].erroori);
media_erroori = media_erroori + resposta[tries].erroori;
}
media_erroori = media_erroori/samples;
media_tempo),2);
media_erropos),2);
desvpadr_erroori = desvpadr_erroori + pow((resposta[tries].erroori -
media_erroori),2);
}
desvpadr_erroori = sqrt(desvpadr_erroori/(samples-1));
51
media_tempo, media_interacoes, media_erropos, media_erroori);
desvpadr_tempo, desvpadr_interacoes, desvpadr_erropos, desvpadr_erroori);
}
printf("\nResultados do melhor:\n\n");
printf("\nPosicao (em cm) Desejada:\nX = %.2lf, Y = %.2lf, Z = %.2lf\n",
x, y, z);
printf("\nPosicao (em cm) Encontrada:\nX = %.2lf, Y = %.2lf, Z = %.2lf\n",
resposta[best_resposta].x, resposta[best_resposta].y, resposta[best_resposta].z);
if(mode == 1){
printf("\nAngulos (em graus) Iniciais:\nth1: %.2lf, th2: %.2lf, th3: %.2lf, th4: %.2lf,
th5: %.2lf, th6: %.2lf\n",
thini1*180/pi, thini2*180/pi, thini3*180/pi, thini4*180/pi, thini5*180/pi,
thini6*180/pi);
}
printf("\nAngulos (em graus) Encontrados:\nth1: %.2lf, th2: %.2lf, th3: %.2lf, th4: %.2lf, th5:
%.2lf, th6: %.2lf\n",
resposta[best_resposta].th1*180/pi, resposta[best_resposta].th2*180/pi,
resposta[best_resposta].th3*180/pi,
resposta[best_resposta].th4*180/pi, resposta[best_resposta].th5*180/pi,
resposta[best_resposta].th6*180/pi);
if(mode == 2){
printf("\nMatriz de Rotacao Row, Pitch Yaw:\n");
printf("[%.2lf, %.2lf, %.2lf]\n[%.2lf, %.2lf, %.2lf]\n[%.2lf, %.2lf, %.2lf]\n",
resposta[best_resposta].r11, resposta[best_resposta].r12,
resposta[best_resposta].r13,
resposta[best_resposta].r23,
resposta[best_resposta].r33);
}
if(mode == 0){
printf("\nErro da Posicao: %.2lf\n",
resposta[best_resposta].erropos);
}
if(mode == 1){
printf("\nErro da Posicao: %.2lf. Erro dos Angulos Iniciais: %.2lf\n",
resposta[best_resposta].erropos, resposta[best_resposta].erroant);
}
if(mode == 2){
printf("\nErro da Posicao: %.2lf. Erro da Orientacao: %.2lf\n",
resposta[best_resposta].erropos, resposta[best_resposta].erroori);
}
printf("\nO calculo foi realizado em apoximadamente %.3fs, e em %d iteracoes\n\n",
resposta[best_resposta].tempo, resposta[best_resposta].geracoes);
}
//getchar();
return 0;
}
52

Roberto Thiago Alberici PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Roberto Thiago Alberici PDF

Caricato da

Copyright:

Formati disponibili

UNIVERSIDADE DE SO PAULO

ESCOLA DE ENGENHARIA DE SO CARLOS

TRABALHO DE CONCLUSO DE CURSO

THIAGO ALBERICI ROBERTO

CLCULO DA CINEMTICA INVERSA DO ROB

CLCULO DA CINEMTICA INVERSA

Trabalho de Concluso de Curso apresentado

Curso de Engenharia De Computao com

ORIENTADOR: Valdir Grassi Jr.

A todos os professores que eu tive na graduao, que me proporcionaram conhecimento

Ao professor Valdir Grassi Jr. Pelo apoio, incentivo e orientao durante o

Resolver a cinemtica de um rob manipulador um clculo de grande importncia na

Palavras-chave: Robs Manipuladores, Puma 560, Cinemtica Inversa, Sistemas

Keywords: Robot Manipulators, Puma 560, Inverse Kinematic, Evolutionary Systems,

Figura 1 - Puma 560[2]

Figura 2 - Configuraes do Puma 560[2]

2.1. Puma 560

Como j mencionado anteriormente neste trabalho, cinemtica direta de um rob

Figura 4 - Representao de Denavit-Hartenberg[2]

Conhecidas as notaes e parmetros, o sistema de coordenadas de cada junta, assim

- Desenhar linhas ao longo dos eixos de cada junta;

- Para o Primeiro Elo (i=0):

- Para i=1 at i =n-1;

- Definir o eixo Zi ao longo do eixo da junta i;

- Definir o eixo Xi ao longo da perpendicular comum entre os eixos i e i+1. Se os eixos

- Definir Yi de acordo com a regra da mo direita.

- Para o ltimo Elo (i = n):

O resultado dos sistemas de coordenadas pode ser verificado na Figura 3 j

Tabela 2 - Parmetros de Denavit-Hartenberg

Dessa forma, a posio e a orientao do efetuador em relao base so obtidas por

= Rotao (X,i-1) Translao(X, ai-1) Rotao(Z, i) Translao(Z, di)

Dessa forma, para obter a matriz de transformao de T07, basta calcular:

2.3. Matrizes de Rotao

Figura 5 - Rotao Roll-Pitch-Yaw[1]

Esse ser o sistema de rotao adotado nos clculos posteriores, no captulo 3.

2.4. Algoritmos Genticos

Sistemas Evolutivos podem ser considerados como uma rea de inteligncia

Figura 6 - Fluxograma do Algoritmo Gentico

Como base de funcionamento para os Algoritmos Genticos, uma populao de

2.4.3. Clculo do Fitness

2.4.4. Eliminao dos Menos Aptos

2.4.5. Seleo e Reproduo

De maneira iterativa, as populaes vo sendo substitudas por novas geraes. A

Por fim, aleatoriamente, alguns indivduos passam por um processo de mutao.

2.4.7. Critrio de Parada

Como na natureza, o algoritmo gentico est sempre em evoluo. Portanto, deve-se

2.5. Trabalhos Relacionados

Os trabalhos relacionados a seguir, buscam exemplificar trabalhos de diversas

O desenvolvimento do programa que calcula a cinemtica inversa atravs de algoritmos

3.2. Cinemtica Direta

No Captulo 2, pode-se observar quais so os parmetros e configuraes gerados pelo

= c1*(c23*((c4*c5*c6) - (s4*s6)) - (s23*s5*c6)) + s1*((s4*c5*c6) + (c4*s6))

3.3. Estrutura dos Indivduos e Criao da Populao

Elementos principais, que definem todas as caractersticas do problema:

1, 2, 3, 4, 5, 6 Responsveis por armazenar o valor do ngulo de cada junta do

Elementos de consulta, que so resultado de processamentos realizados com os

x, y, z Armazenam os valores da posio final do efetuador calculados pela cinemtica

Fitness Responsvel por armazenar a nota retornada da funo de avaliao do

3.4. Avaliao da Populao

Existem no programa trs variveis principais de avaliao.

A segunda (fitth) responsvel por avaliar a distncia de cada ngulo de um indivduo

3.5. Eliminao dos Menos Aptos

3.6. Cruzamento da Populao

= c1(c23((c4c5c6) - (s4s6)) - (s23s5c6)) + s1((s4c5c6) + (c4*s6))

/Valores para a Posio Desejada/

/Variaveis usadas para calculos estatisticos/

/Prametros do Algoritmo Evolutivo/

/Estrutura de cada indivduo/

/Estrutura das Respostas/

/Funo que calcula a posio x,y,z pela cinemtica direta/

r11 = c1(c23((c4c5c6)-(s4s6)) - (s23s5c6))+s1((s4c5c6)+(c4*s6));//Linha 1, coluna 1, da

r12 = c1(c23(-(c4c5s6)-(s4c6))+(s23s5s6))+s1((c4c6)-(s4c5*s6));//Linha 1, coluna 2, da matriz

r13 = -c1((c23c4s5)+(s23c5))-(s1s4s5);//Linha 1, coluna 3, da matriz de transformao.

px = c1(c23(-c4s5d7+a3)-s23(c5d7+d4)+a2c2)-s1(s4s5d7+d3);//Linha 1, coluna 4, da matriz de

/Clculo da funo de Fitness/

/Atribui os valores calculados para o individuo/

/Calcula o fitness para o individuo/

/Clculo do melhor individuo/