Universidade Federal de Santa Catarina

Centro Tecnológico, de Ciências Exatas e Educação

Departamento de Engenharia de Controle, Automação e Computação

Anderson Carneiro
André Victor Meinertz
Gabriel Puquevicz Strassmann
Pedro Arthur Viana Barreto Corrêa

Introdução à Robótica Industrial: Trabalho Prático 2

Blumenau
2021.2
 Anderson Carneiro
André Victor Meinertz
Gabriel Puquevicz Strassmann
Pedro Arthur Viana Barreto Corrêa

Introdução à Robótica Industrial: Trabalho Prático 2

Trabalho elaborado para a disciplina de

Introdução à Robótica Industrial 2021.2 do
curso de Engenharia de Controle e Automação
da Universidade Federal de Santa Catarina –
UFSC Blumenau.

Prof. Dr. Leonardo Mejia Rincon

Blumenau
2021.2
1 INTRODUÇÃO

Neste segundo trabalho da disciplina de Introdução à Robótica Industrial serão

abordados a cinemática direta e inversa de manipuladores. Para isso então, serão apresentados
e estudados o método geométrico para a obtenção da cinemática tanto direta quanto inversa.
Outro método utilizado será o de Denavit and Hartenberg, este será o mais aplicado neste
trabalho, visto que possui uma formulação mais direta se comparado com o método
geométrico.

2 MÉTODOS E MATERIAIS

Para a realização das simulações deste trabalho foram utilizados os softwares Matlab e
Octave para o cálculo e simulação das atividades. Já para a elaboração das imagens foi
utilizado principalmente o Paint.
3 QUESTÕES PROPOSTAS

3.1 Questão 1
Robôs para paletização são cada vez mais comuns na indústria devido à sua facilidade
de implementação em tarefas de paletização e ao seu relativo baixo custo comparado com
outras alternativas robotizadas. Robôs de paletização ou Robôs paletizadores como aquele
mostrado na Fig. 1. São cadeias cinemáticas (fechadas ou híbridas) cuja principal
característica é o paralelismo entre os seus elos, o que permite facilmente alocar todos os
motores na base do mesmo.

Figura 1: Robô Industrial FANUC M-410iC/185.

Resolva: Para a cadeia cinemática mostrada na Fig. 2, obtenha o modelo matemático

que define a sua cinemática inversa usando o método geométrico e considerando as
dimensões: La = 2.5 [m], Lb = 0.75[m], Lc = 0.4[m], Ld = 0.15[m]. Obtenha também o
volume de trabalho para o manipulador considerando os parâmetros limite: −110º ≤ 𝜃0≤ 110º;
65º ≤ 𝜃1 ≤ 150º; 10º ≤ 𝜃1 ≤ 100º.
Uma simulação auxiliar implementada no Geogebra é apresentada na seção do
Trabalho 2 intitulada “Simulação” a fim de auxiliar no entendimento do funcionamento do
mesmo.
 Figura 2: Dimensões do braço robótico a estudar.

Resolução:
Para a obtenção do modelo matemático utilizando a cinemática inversa, será feito uma
simplificação para a melhor visualização dos parâmetros em questão:

Figura 3: Adaptação do braço robótico.

 Fazendo a análise dos pontos A e B, chega-se nas seguintes expressões:

𝐿𝑐 ∙ cos 30° ∙ cos 𝜃0 𝐿𝑐 ∙ cos 30° ∙ sin 𝜃0

𝐴=( , , 𝐿𝑑 )
2 2

𝐿𝑐 ∙ cos 𝜃0 ∙ cos 𝜙 𝐿𝑐 ∙ sin 𝜃0 ∙ cos 𝜙

𝐵 = (𝑃𝑥 − , 𝑃𝑦 − , 𝑃𝑧 )
2 ∙ cos 45° 2 ∙ cos 45°

Sendo que 𝜃0 é definido como:

𝑃𝑦
𝜃0 = 𝑎𝑟𝑐𝑡𝑎𝑛 ( )
𝑃𝑥

O valor de “𝑒” pode ser expresso através da seguinte equação da distância euclidiana
entre os pontos 𝐴 e 𝐵:

2
𝑒 = √(𝐵𝑥 − 𝐴𝑥 )2 + (𝐵𝑦 − 𝐴𝑦 ) + (𝐵𝑧 − 𝐴𝑧 )2

Aplicando a lei cossenos, chega-se em uma expressão para o valor de 𝛾:

(𝐿𝑎 )2 = (𝐿𝑎 )2 + 𝑒 2 − 2 ∙ 𝐿𝑎 ∙ 𝑒 ∙ cos 𝛾

𝑒
𝛾 = 𝑎𝑟𝑐𝑐𝑜𝑠 ( )
2 ∙ 𝐿𝑎

Aplicando a lei dos senos, chega-se em uma expressão para o valor de 𝛽:

𝑒 𝐿𝑎
=
sin 𝛽 sin 𝛾

𝑒 ∙ sin 𝛾
𝛽 = 𝑎𝑟𝑐𝑠𝑖𝑛 ( )
𝐿𝑎
 O ângulo 𝛼 é representado pela seguinte expressão:

𝐵𝑧 − 𝐴𝑧
𝛼 = 𝑎𝑟𝑐𝑡𝑎𝑛
2
√ 2
( (𝐵𝑥 − 𝐴𝑥 ) + (𝐵𝑦 − 𝐴𝑦 ) )

Com esses ângulos encontrados, agora pode-se chegar nas expressões para os ângulos
𝜃0 , 𝜃1 e 𝜃2 :

𝛼 + 𝛾 + 𝜃2 = 180
𝜃2 = 180 − 𝛼 − 𝛾

𝛽 = 𝜃2 − 𝜃1
𝜃1 = 𝜃2 − 𝛽

Portanto, os termos encontrados através do método da cinemática inversa são os

seguintes:

𝑃𝑦
𝜃0 = 𝑎𝑟𝑐𝑡𝑎𝑛 ( )
𝑃𝑥
𝜃1 = 𝜃2 − 𝛽
𝜃2 = 180 − 𝛼 − 𝛾

Para a obtenção do volume de trabalho será feita a cinemática direta do manipulador.

Para isso calcula-se os seguintes pontos:

𝐿𝑐 ∙ cos 30° ∙ cos 𝜃0 𝐿𝑐 ∙ cos 30° ∙ sin 𝜃0

𝐴=( , , 𝐿𝑑 )
2 2

𝐵 = (𝐷𝑥 − (𝐿𝑎 + 𝐿𝑏 ) ∙ cos(180° + 𝜃1 ) ∙ cos 𝜃0 ; 𝐷𝑦 − (𝐿𝑎 + 𝐿𝑏 )

∙ cos(180° + 𝜃1 ) ∙ sin 𝜃0 ; 𝐷𝑧 − (𝐿𝑎 + 𝐿𝑏 ) ∙ sin(180° + 𝜃1 ))
 𝐶 = (𝐴𝑥 − 𝐿𝑎 ∙ cos 𝜃0 ∙ cos 𝜃2 ; 𝐴𝑦 − 𝐿𝑎 ∙ sin 𝜃0 ∙ cos 𝜃2 ; 𝐿𝑑 + 𝐿𝑎 ∙ sin 𝜃2 )

𝐷 = (𝐸𝑥 − 𝐿𝑎 ∙ cos 𝜃0 ∙ cos 𝜃2 ; 𝐸𝑦 − 𝐿𝑎 ∙ sin 𝜃0 ∙ cos 𝜃2 ; 𝐸𝑧 + 𝐿𝑎 ∙ sin 𝜃2 )

𝐸 = (𝐴𝑥 − 𝐿𝑏 ∙ cos 𝜃0 ∙ cos 𝜃1 ; 𝐴𝑦 − 𝐿𝑏 ∙ sin 𝜃0 ∙ cos 𝜃1 ; 𝐿𝑑 − 𝐿𝑏 ∙ sin 𝜃1 )

𝐿𝑐 ∙ cos 𝜃0 𝐿𝑐 ∙ sin 𝜃0
𝑃 = (𝐵𝑥 + ; 𝐵𝑦 + ;𝐵 )
2 ∙ cos 45° 2 ∙ cos 45° 𝑧

Como os limites de cada ângulo são:

−110 ≤ 𝜃0 ≤ 110°
65° ≤ 𝜃1 ≤ 150°
10° ≤ 𝜃2 ≤ 100°

Gerando um algoritmo com as equações acima encontradas, pode-se chegar no volume

de trabalho do manipulador utilizando o Matlab:

Figura 4: Volume de trabalho do manipulador.

Figura 5: Visão superior do volume de trabalho do manipulador.
3.2 Questão 2
A Empresa ABB. lhe contratou para auxiliar na execução de um novo projeto de robô
industrial baseado no robô comercial IRB14000 (Yumi) mostrado nas Figuras 6, 7 e 8. O
novo robô, que será chamado UFSC-BOT, usará como elementos pré-fabricados os braços do
IRB14000, mas terá as duas juntas iniciais perpendiculares ao plano de base. como mostrado
na sequência e respeitando as dimensões originais dos braços do IRB-14000.

Figura 6: IRB14000.

Figura 7: Sistema UFSC-BOT).

 Figura 8: Dimensões dos braços do IRB14000 (Yumi).

Para o sistema UFSC-BOT realize as seguintes tarefas:

• Calcule a cinemática direta do manipulador para os dois braços usando o Método de

DH.
• Estime uma distância “L” mínima necessária para que os dois braços compartilhem
um espaço de trabalho em formato de domo como aquele mostrado na Figura 3 e em
que irão manipular de maneira colaborativa uma caixa de dimensões 100[cm] x 40
[cm].

Resolução:

Primeiramente foi definido as referências, para isso foi considerado o braço robótico
totalmente esticado.
A figura abaixo ilustra como ficou esquematizado o problema:
 Figura 9: Esquematização do braço robótico.

Com os referenciais definidos, podemos preencher a tabela do método de Denavit and

Harternberg.
A distância entre o referencial zero foi tomado como sendo aproximadamente 320 cm,
já que não sabemos exatamente o valor dessa distância. A tabela ficou da seguinte forma:

𝑖 𝛼 𝑎 𝑑 𝜃
0
𝑇1 0° -320 0 0°
1
𝑇2 90° -30 166 𝜃1
2
𝑇7 −90° 30 0 𝜃2
7
𝑇3 90° 40,5 251,5 𝜃7
3
𝑇4 −90° -40,5 0 𝜃3
4
𝑇5 90° 27 265 𝜃4
5 −90° -27 0 𝜃5
𝑇6
6
𝑇𝑝 0° 0 136 𝜃6
 Com a tabela completa pode-se montar as matrizes de transformação, que ficaram da
seguinte forma:

1 0 0 −320
0 0 1 0 0
𝑇1 = [ ]
0 0 1 0
0 0 0 1

𝑐1 0 𝑠1 0
1 𝑠 0 −𝑐1 −30
𝑇2 = [ 1 ]
0 1 0 166
0 0 0 1

𝑐2 0 −𝑠2 0
2 𝑠 0 𝑐2 −30
𝑇7 = [ 2 ]
0 −1 0 0
0 0 0 1

𝑐7 0 𝑠7 0
7 𝑠 0 𝑐7 40,5
𝑇3 = [ 7 ]
0 1 0 251,5
0 0 0 1

𝑐3 0 −𝑠3 0
3 𝑠 0 𝑐3 40,5
𝑇4 = [ 3 ]
0 −1 0 0
0 0 0 1

𝑐4 0 𝑠4 0
4 𝑠 0 −𝑐4 27
𝑇5 = [ 4 ]
0 1 0 265
0 0 0 1

𝑐5 0 −𝑠5 0
5 𝑠 0 𝑐5 27
𝑇6 = [ 5 ]
0 −1 0 0
0 0 0 1
 𝑐6 −𝑠6 0 0
6 𝑠 𝑐6 0 0
𝑇𝑇𝑝 =[ 6 ]
0 1 1 136
0 0 0 1

Fazendo a multiplicação das matrizes, considerando os ângulos 𝜃 = 0, temos a

seguinte matriz de transformação:

0
𝑇𝑇𝑝 = 0𝑇1 ∙ 1𝑇2 ∙ 2𝑇7 ∙ 7𝑇3 ∙ 3𝑇4 ∙ 4𝑇5 ∙ 5𝑇6 ∙ 6𝑇𝑇𝑝

1 0 0 −320
0 0 1 0 37,5
𝑇𝑇𝑝 =[ ]
0 0 1 856
0 0 0 1

Ambos os braços terão as mesmas matrizes de transformação, com exceção da matriz

0
de 𝑇1, que ficará da seguinte forma:

1 0 0 320
0 0 1 0 0
𝑇1 = [ ]
0 0 1 0
0 0 0 1

E assim multiplicando todos os termos teremos a seguinte matriz de transformação:

1 0 0 320
0 0 1 0 37,5
𝑇𝑇𝑝 =[ ]
0 0 1 856
0 0 0 1

Sabendo que a única matriz de transformação que difere um braço do outro é a

primeira, e ainda que um braço robótico está a 320 cm a esquerda, ou seja, -320 cm, e o outro
está a 320 a direita, ou seja, 320 cm, o parâmetro L é igual a 𝐿 = 320 + 320 = 740 𝑐𝑚.
 QUESTÃO 3) Proponha um modelo analítico da cinemática inversa dos manipuladores
mostrados na Fig. 6. usando o método de DH. Verifique se é possível encontrar o modelo
completo (posição e orientação) ou se o modelo analítico só consegue resolver a posição do
mesmo.

Figura 6: Cadeias cinemáticas a serem estudadas.

Resolução:

a) Adicionam-se os sistemas de coordenadas locais em cada eixo:

Para cada nó adjacente, deve-se encontrar as variáveis 𝛼, 𝑎, 𝑑 e 𝜃:

𝒊 𝜶𝒊 𝒂𝒊 𝒅𝒊 𝜽𝒊

𝑇01 90° 0 𝐿1 𝜃1

𝑇12 0° 𝐿2 0 𝜃2 + 90°

𝑇23 0° 𝐿3 0 𝜃3
Em seguida, calculam-se as matrizes de transformação. Segundo o método de Denavit-
Hartenberg, a matriz que relaciona nós adjacentes é a seguinte:

𝑐𝜃𝑖 −𝑠𝜃𝑖 . 𝑐𝛼𝑖 𝑠𝜃𝑖 . 𝑠𝛼𝑖 𝑎𝑖 . 𝑐𝛼𝑖

𝑠𝜃 𝑐𝜃𝑖 . 𝑐𝛼𝑖 −𝑐𝜃𝑖 . 𝑠𝛼𝑖 𝑎𝑖 . 𝑠𝛼𝑖
[ 𝑖 ]
0 𝑠𝛼𝑖 𝑐𝛼𝑖 𝑑
0 0 0 1
Assim, a primeira matriz é dada por:

𝑐𝜃1 −𝑠𝜃1 . 𝑐90 𝑠𝜃1 . 𝑠90 0

𝑠𝜃 𝑐𝜃𝑖 . 𝑐90 −𝑐𝜃1 . 𝑠90 0
𝑇01 = [ 𝑖 ]
0 𝑠90 𝑐90 𝐿1
0 0 0 1
𝑐𝜃1 0 𝑠𝜃1 0
𝑠𝜃 0 −𝑐𝜃1 0
𝑇01 = [ 𝑖 ]
0 1 0 𝐿1
0 0 0 1
A segunda matriz:

𝑐(𝜃2 + 90°) −𝑠(𝜃2 + 90°). 𝑐0 𝑠(𝜃2 + 90°). 𝑠0 𝐿2 . 𝑐0

𝑠(𝜃 + 90°) 𝑐(𝜃2 + 90°). 𝑐0 −𝑐(𝜃2 + 90°). 𝑠0 𝐿2 . 𝑠0
𝑇12 = [ 2 ]
0 𝑠0 𝑐0 0
0 0 0 1
𝑐(𝜃2 + 90°) −𝑠(𝜃2 + 90°) 0 𝐿2
𝑠(𝜃 + 90°) 𝑐(𝜃2 + 90°) 0 0
𝑇12 = [ 2 ]
0 0 1 0
0 0 0 1
E a terceira:

𝑐𝜃3 −𝑠𝜃3 . 𝑐0 𝑠𝜃3 . 𝑠0 L3 . 𝑐0

𝑠𝜃 𝑐𝜃3 . 𝑐0 −𝑐𝜃3 . 𝑠0 𝐿3 . 𝑠0
𝑇23 = [ 3 ]
0 𝑠0 𝑐0 0
0 0 0 1
𝑐𝜃3 −𝑠𝜃3 0 L3
𝑠𝜃 𝑐𝜃3 0 0
𝑇23 = [ 3 ]
0 0 1 0
0 0 0 1
Com as três matrizes em mãos, a matriz que relaciona a base com o efetuador final é
dada pela multiplicação das três matrizes subsequentes da cadeia cinemática. Esta, expressa
tanto a posição quanto a orientação do efetuador final.

𝑇03 = 𝑇01 ∗ 𝑇12 ∗ 𝑇23

Esse cálculo pode ser executado no Matlab com o seguinte código:

 syms a1; syms a2; syms a3;
syms alpha1; syms alpha2; syms alpha3;
syms L1; syms L2; syms L3;
syms theta1; syms theta2; syms theta3;

T1 = [cosd(theta1) 0 sind(theta1) 0;
sind(theta1) 0 -cosd(theta1) 0;
0 1 0 L1;
0 0 0 1];

T2 = [cosd(theta2 + 90) -sind(theta2 + 90) 0 L2;

sind(theta2 + 90) cosd(theta2 + 90) 0 0;
0 0 1 0;
0 0 0 1];

T3 = [cosd(theta3) -sind(theta3) 0 L3;

sind(theta3) cosd(theta3) 0 0;
0 0 1 0;
0 0 0 1];

A = T1*T2*T3

O resultado é uma matriz 4x4 da forma:

𝑚11 𝑚12 𝑚13 𝑚14
𝑚 𝑚22 𝑚23 𝑚24
[ 21 ]
𝑚31 𝑚32 0 𝑚34
0 0 0 1
Onde:

𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90) 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1

𝑚11 = cos ( ) ∗ cos ( ) ∗ cos ( ) − cos ( )
180 180 180 180
𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90)
∗ 𝑠𝑖𝑛 ( ) ∗ 𝑠𝑖𝑛 ( )
180 180

𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90) 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1

𝑚12 = − 𝑐𝑜𝑠 ( ) ∗ 𝑐𝑜𝑠 ( ) ∗ 𝑠𝑖𝑛 ( ) − 𝑐𝑜𝑠 ( )
180 180 180 180
𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90)
∗ 𝑠𝑖𝑛 ( ) ∗ 𝑐𝑜𝑠 ( )
180 180

𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1
𝑚13 = 𝑠𝑖𝑛 ( )
180

𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90)

𝑚14 = 𝐿2 ∗ 𝑐𝑜𝑠 ( ) + 𝐿3 ∗ 𝑐𝑜𝑠 ( ) ∗ 𝑐𝑜𝑠 ( )
180 180 180

𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90) 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1

𝑚21 = 𝑐𝑜𝑠 ( ) ∗ 𝑠𝑖𝑛 ( ) ∗ 𝑐𝑜𝑠 ( ) − 𝑠𝑖𝑛 ( )
180 180 180 180
𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90)
∗ 𝑠𝑖𝑛 ( ) ∗ 𝑠𝑖𝑛 ( )
180 180
 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90) 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1
𝑚22 = − 𝑐𝑜𝑠 ( ) ∗ 𝑠𝑖𝑛 ( ) ∗ 𝑠𝑖𝑛 ( ) − 𝑠𝑖𝑛 ( )
180 180 180 180
𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90)
∗ 𝑠𝑖𝑛 ( ) ∗ 𝑐𝑜𝑠 ( )
180 180

𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1
𝑚23 = −𝑐𝑜𝑠 ( )
180

𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎1 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90)

𝑚24 = 𝐿2 ∗ 𝑠𝑖𝑛 ( ) + 𝐿3 ∗ 𝑠𝑖𝑛 ( ) ∗ 𝑐𝑜𝑠 ( )
180 180 180

𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90) 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90)

𝑚31 = 𝑐𝑜𝑠 ( ) ∗ 𝑠𝑖𝑛 ( ) + 𝑠𝑖𝑛 ( ) ∗ 𝑐𝑜𝑠 ( )
180 180 180 180

𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90) 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎3 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90)

𝑚32 = 𝑐𝑜𝑠 ( ) ∗ 𝑐𝑜𝑠 ( ) − 𝑠𝑖𝑛 ( ) ∗ 𝑠𝑖𝑛 ( )
180 180 180 180

𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎2 + 90)
𝑚34 = 𝐿1 + 𝐿3 ∗ 𝑠𝑖𝑛 ( )
180

B) Primeiramente adicionam-se os sistemas de coordenadas locais em cada eixo:

Para cada nó adjacente, deve-se encontrar as variáveis 𝛼 , 𝑎 , 𝑑 e 𝜃 :

𝒊 𝜶𝒊 𝒂𝒊 𝒅𝒊 𝜽𝒊

𝑇01 0° 𝑑1 0 −90°

𝑇12 0° 𝑑2 0 −90°

𝑇23 0° 0 𝑑3 +90°

𝑇34 0° 𝑙4 0 −90°

𝑇45 −90° 0 0 0°
Em seguida, calculam-se as matrizes de transformação. Segundo o método de Denavit-
Hartenberg, a matriz que relaciona nós adjacentes é a seguinte:

𝑐𝜃𝑖 −𝑠𝜃𝑖 . 𝑐𝛼𝑖 𝑠𝜃𝑖 . 𝑠𝛼𝑖 𝑎𝑖 . 𝑐𝛼𝑖

𝑖 𝑠𝜃 𝑐𝜃𝑖 . 𝑐𝛼𝑖 −𝑐𝜃𝑖 . 𝑠𝛼𝑖 𝑎𝑖 . 𝑠𝛼𝑖
𝑇𝑖−1 =[ 𝑖 ]
0 𝑠𝛼𝑖 𝑐𝛼𝑖 𝑑𝑖
0 0 0 1
No Matlab, podemos usar o trecho:
T = [cosd(theta) -sind(theta)*cosd(alpha) sind(theta)*sind(alpha) a*cosd(alpha);
sind(theta) cosd(theta)*cosd(alpha) -cosd(theta)*sind(alpha) a*sind(alpha);
0 sind(alpha) cosd(alpha) d ;
0 0 0 1 ];
E alterar os valores de alpha, a, d e theta para encontrar as matrizes.

Assim, a primeira matriz é dada por:

0 1 0 𝑑1
−1 0 0 0
𝑇1 = [ ]
0 0 1 0
0 0 0 1
A segunda matriz:

0 1 0 𝑑2
−1 0 0 0
𝑇2 = [ ]
0 0 1 0
0 0 0 1
A terceira:

0 −1 0 0
1 0 0 0
𝑇3 = [ ]
0 0 1 𝑑3
0 0 0 1
A quarta:

0 1 0 𝑙4
−1 0 0 0
𝑇4 = [ ]
0 0 1 0
0 0 0 1
A quinta:
1 0 0 0
0 0 1 0
𝑇5 = [ ]
0 −1 0 0
0 0 0 1
A multiplicação das matrizes da cadeia cinemática dá o modelo da posição e orientação
da garra em relação à base:

𝑇𝑒𝑓 = 𝑇1 ∗ 𝑇2 ∗ 𝑇3 ∗ 𝑇4 ∗ 𝑇5
 −1 0 0 𝑑1
0 0 −1 −𝑑2 − 𝑙4
𝑇𝑒𝑓 =[ ]
0 −1 0 𝑑3
0 0 0 1
C) Primeiramente adicionam-se os sistemas de coordenadas locais em cada eixo:

Para cada nó adjacente, deve-se encontrar as variáveis 𝛼 , 𝑎 , 𝑑 e 𝜃 :

𝑖 𝛼𝑖 𝑎𝑖 𝑑𝑖 𝜃𝑖

𝑇01 0° 0 𝑑1 0°
𝑇12 0° 𝐿1 0 𝜃2
𝑇23 0° 𝐿2 0 𝜃3 − 90°
𝑒𝑓 −90° 𝐿3 0 0°
𝑇3

Em seguida, calculam-se as matrizes de transformação. Segundo o método de Denavit-

Hartenberg, a matriz que relaciona nós adjacentes é a seguinte:

𝑐𝜃𝑖 −𝑠𝜃𝑖 . 𝑐𝛼𝑖 𝑠𝜃𝑖 . 𝑠𝛼𝑖 𝑎𝑖 . 𝑐𝛼𝑖

𝑖 𝑠𝜃 𝑐𝜃𝑖 . 𝑐𝛼𝑖 −𝑐𝜃𝑖 . 𝑠𝛼𝑖 𝑎𝑖 . 𝑠𝛼𝑖
𝑇𝑖−1 =[ 𝑖 ]
0 𝑠𝛼𝑖 𝑐𝛼𝑖 𝑑𝑖
0 0 0 1
No Matlab, podemos usar o trecho:
T = [cosd(theta) -sind(theta)*cosd(alpha) sind(theta)*sind(alpha) a*cosd(alpha);
sind(theta) cosd(theta)*cosd(alpha) -cosd(theta)*sind(alpha) a*sind(alpha);
0 sind(alpha) cosd(alpha) d ;
0 0 0 1 ];
E alterar os valores de alpha, a, d e theta para encontrar as matrizes.
Assim, a primeira matriz é dada por:

1 0 0 0
0 1 0 0
𝑇1 = [ ]
0 0 1 𝑑1
0 0 0 1
𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎2 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎2
𝑐𝑜𝑠 ( ) −𝑠𝑖𝑛 ( ) 0 𝑙1
180 180
𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎2 𝑝𝑖 ∗ 𝑡ℎ𝑒𝑡𝑎2
𝑇2 = 𝑠𝑖𝑛 ( ) 𝑐𝑜𝑠 ( ) 0 0
180 180
0 0 1 0
[ 0 0 0 1]
𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎3 − 90) 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎3 − 90)
𝑐𝑜𝑠 ( ) −𝑠𝑖𝑛 ( ) 0 𝑙2
180 180
𝑇3 = 𝑠𝑖𝑛 (𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎3 − 90)) 𝑐𝑜𝑠((𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎3 − 90))/180) 0 0
180
0 0 1 0
[ 0 0 0 1]

1 0 0 0
0 0 1 −𝑙3
𝑇𝑒𝑓 =[ ]
0 −1 0 0
0 0 0 1
Assim, a multiplicação das matrizes da cadeia cinemática dá a relação entre o efetuador final
e a base e expressa tanto a posição quanto a orientação do efetuador final.

𝑇0𝑒𝑓 = 𝑇1 ∗ 𝑇2 ∗ 𝑇3 ∗ 𝑇𝑒𝑓
𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎3 − 90) 𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎3 − 90)
𝑐𝑜𝑠 ( ) −𝑠𝑖𝑛 ( ) 0 𝑙2
180 180
= 𝑠𝑖𝑛 (𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎3 − 90)) 𝑐𝑜𝑠 (
𝑝𝑖 ∗ (𝑡ℎ𝑒𝑡𝑎3 − 90)
) 0 0
180 180
0 0 1 0
[ 0 0 0 1]
Questão 4) O corpo humano tem inspirado a construção de robôs humanoides desde há
muitas décadas (Veja fig. 7). Em relação às extremidades superiores, um dos sistemas mais
complexos que existe é o AIST HRP-2 (veja Fig. 7.(b)). E cuja cadeia cinemática é mostrada
na Gig. 8.

𝐅𝐢𝐠𝐮𝐫𝐚 𝟕: Robôs humanoides, (a) – Honda ASIMO, (b) − AIST HRP − 2, (3) − Fujitsu HOAP − 2.

𝐅𝐢𝐠𝐮𝐫𝐚 𝟖: Cadeia cinemática do robô AIST HRP − 2.

Usando como base a estrutura cinemática das duas extremidades superiores da cadeia
cinemática mostrada na Fig. 8, resolva:
➢ Encontre o modelo da cinemática inversa para as duas extremidades superiores (deixando o
restante da cadeia cinemática estática);
➢ Realize as medições dos comprimentos do braço e do antebraço de algum dos membros da
equipe e implemente computacionalmente a cinemática usando as dimensões obtidas;
➢ Pense em uma tarefa quotidiana que uma pessoa pode realizar usando os dois braços
(Carregar uma caixa, empurrar um objeto, abrir a tampa de um pote) e implemente uma
simulação de como a sua cadeia cinemática executaria esta tarefa.

𝐑𝐞𝐬𝐨𝐥𝐮çã𝐨:

a) Inicialmente foram realizadas as tabelas do método DH para ambos os braços utilizando as

seguintes referências para as tabelas:

Para o braço direito:

I α a d θ
𝟎 0 L6 𝜃0
𝑻𝟏 -90°

𝟏 +90° L5 0 −90° + 𝜃1
𝑻𝟐

𝟐 +90° 0 L4 90° + 𝜃2
𝑻𝟑

𝟑 -90° L3 0 𝜃3
𝑻𝟒

𝟒
𝑻𝟓 +90° 0 L2 90° + 𝜃4

𝟓 +90° L1 0 𝜃5
𝑻𝟔
E para o braço esquerdo:

I α a d θ
𝟎 0 L6 𝜃0
𝑻𝟏 -90°

𝟏 +90° L5 0 90° + 𝜃1
𝑻𝟐

𝟐 -90° 0 L4 −90° + 𝜃2
𝑻𝟑

𝟑 +90° L3 0 𝜃3
𝑻𝟒

𝟒
𝑻𝟓 -90° 0 L2 −90° + 𝜃4

𝟓 -90° L1 0 𝜃5
𝑻𝟔

Agora que temos as tabelas de DH preenchidas vamos fazer as matrizes de transformação

homogêneas:

Para o lado direito:

𝑐𝑜𝑠(𝜃0 ) 0 −𝑠𝑖𝑛(𝜃0 ) 0
𝟎
𝑻𝟏 = [ 𝑠𝑖𝑛(𝜃0 ) 0 𝑐𝑜𝑠(𝜃0 ) 0]
0 −1 0 𝐿6
0 0 0 1

𝑐𝑜𝑠(−90° + 𝜃1 ) 0 𝑠𝑖𝑛(−90° + 𝜃1 ) 0
𝟏
𝑻𝟐 = [ 𝑠𝑖𝑛(−90° + 𝜃1 ) 0 −𝑐𝑜𝑠(−90° + 𝜃1 ) 𝐿5]
0 1 0 0
0 0 0 1

𝑠𝑖𝑛(90° + 𝜃2 ) 0 𝑠𝑖𝑛(90° + 𝜃2 ) 0
𝟐
𝑻𝟑 = [𝑐𝑜𝑠(90° + 𝜃2 ) 0 −𝑐𝑜𝑠(90° + 𝜃2 ) 0]
0 1 0 𝐿4
0 0 0 1

𝑐𝑜𝑠(𝜃3 ) 0 −𝑠𝑖𝑛(𝜃3 ) 0
𝟑
𝑻𝟒 = [ 𝑠𝑖𝑛(𝜃3 ) 0 𝑐𝑜𝑠(𝜃3 ) −𝐿3]
0 −1 0 0
0 0 0 1
 𝑐𝑜𝑠(90° + 𝜃4 ) 0 𝑠𝑖𝑛(90° + 𝜃4 ) 0
𝟒
𝑻𝟓 = [ 𝑠𝑖𝑛(90° + 𝜃4 ) 0 −𝑐𝑜𝑠(90° + 𝜃4 ) 0 ]
0 1 0 𝐿2
0 0 0 1

𝑐𝑜𝑠(𝜃5 ) 0 𝑠𝑖𝑛(𝜃5 ) 0
𝟓
𝑻𝟔 = [ 𝑠𝑖𝑛(𝜃5 ) 0 −𝑐𝑜𝑠(𝜃5 ) 𝐿1]
0 1 0 0
0 0 0 1

E para o lado esquerdo:

𝑐𝑜𝑠(𝜃0 ) 0 −𝑠𝑖𝑛(𝜃0 ) 0
𝟎
𝑻𝟏 = [ 𝑠𝑖𝑛(𝜃0 ) 0 𝑐𝑜𝑠(𝜃0 ) 0]
0 −1 0 𝐿6
0 0 0 1

𝑐𝑜𝑠(90° + 𝜃1 ) 0 𝑠𝑖𝑛(90° + 𝜃1 ) 0
𝟏
𝑻𝟐 = [ 𝑠𝑖𝑛(90° + 𝜃1 ) 0 −𝑐𝑜𝑠(90° + 𝜃1 ) 𝐿5]
0 1 0 0
0 0 0 1

𝑐𝑜𝑠(−90° + 𝜃2 ) 0 −𝑠𝑖𝑛(−90° + 𝜃2 ) 0
𝟐
𝑻𝟑 = [𝑠𝑒𝑛(−90° + 𝜃2 ) 0 𝑐𝑜𝑠(−90° + 𝜃2 ) 0]
0 −1 0 𝐿4
0 0 0 1

𝑐𝑜𝑠(𝜃3 ) 0 𝑠𝑖𝑛(𝜃3 ) 0
𝟑
𝑻𝟒 = [ 𝑠𝑖𝑛(𝜃3 ) 0 −𝑐𝑜𝑠(𝜃3 ) 𝐿3]
0 1 0 0
0 0 0 1

𝑐𝑜𝑠(−90° + 𝜃4 ) 0 −𝑠𝑖𝑛(−90° + 𝜃4 ) 0
𝟒
𝑻𝟓 = [ 𝑠𝑖𝑛(−90° + 𝜃4 ) 0 𝑐𝑜𝑠(−90° + 𝜃4 ) 0]
0 −1 0 𝐿2
0 0 0 1
 𝑐𝑜𝑠(𝜃5 ) 0 −𝑠𝑖𝑛(𝜃5 ) 0
𝟓
𝑻𝟔 = [ 𝑠𝑖𝑛(𝜃5 ) 0 𝑐𝑜𝑠(𝜃5 ) −𝐿1]
0 −1 0 0
0 0 0 1

Agora com todas as matrizes montadas podemos prosseguir, devido a complexidade e

o tamanho das multiplicações recorremos as ferramentas MatLab e Octave para realizar as
multiplicações matriciais para identificar a cadeia cinemática, desenvolvemos a seguinte
simulação para obter a cadeia cinemática:

O resultado é uma matriz demasiadamente grande até mesmo para apresentá-la aqui no
trabalho, então será anexado junto ao envio do trabalho um arquivo no formato .txt com a
cadeia cinemática.

b) Para a letra “b” do exercício foram feitas as seguintes medidas, onde L6 = 11cm, L5 = 15
cm, L4 = 12 cm, L3= 12 cm, L2 = 13 cm e por fim L1 = 8 cm:
 Com as medidas em mãos nós as aplicamos as medidas na simulação anteriormente
apresentada nesta questão, quanto aos ângulos consideramos todos eles em suas posições
“neutras”, ou seja, utilizamos eles com o valor de zero:

E obtemos as os seguintes resultados para o braço direito e esquerdo respectivamente:

c) Para a terceira parte da questão resolvemos representar o movimento do exercício de
academia chamado rosca direta com a barra W, demonstrado na seguinte imagem:

Para tal movimento o antebraço (𝜃4 ) deve rotacionar em 30 graus, o cotovelo (𝜃3 ) deve
se girar em até um ângulo de 90 graus e o ombro (𝜃1 ) deve ser rotacionado levemente em 10
graus. Adicionando essas entradas na simulação podemos obter as seguintes matrizes para cada
braço (direito e esquerdo, respectivamente):

OBS: Eu (André Victor Meinertz) durante a realização desta atividade utilizei o

programa Octave para fazer todas as simulações, porém não consegui fazer os gráficos devido
a alguns problemas na programação dos quais não achamos as soluções.
 QUESTÃO 5) Usando um algoritmo de cálculo numérico como aquele mostrado em
aula calcule a cinemática inversa do manipulador 9R planar de modo que nenhum dos elos ou
juntas do manipulador colidam com as paredes ou contra o próprio robô,e que o efetuador final
(Ef) consiga pegar a engrenagem localizada em P(75 [u.c],100 [u.c]).Considere que todos os
elos do manipulador tem comprimento L = 20 [u.c]

𝐅𝐢𝐠𝐮𝐫𝐚 𝟗: Representação da questão 9.

𝐑𝐞𝐬𝐨𝐥𝐮çã𝐨:

Primeiramente, será necessário encontrar as equações da cinemática inversa do atuador 9R planar:

𝐅𝐢𝐠𝐮𝐫𝐚 𝟏𝟎: Cadeia cinemática do atuador 9R planar.

As posições x e y de cada junta A até I são dadas por:

𝐴𝑥 = 0
𝐴𝑦 = 0

𝐵𝑥 = 𝑙1 . cos(θ1 )
𝐵𝑦 = 𝑙1 . sen(θ1 )

𝐶𝑥 = 𝑙1 . cos(θ1 ) + 𝑙2 . cos(θ1 + θ2 )
 𝐶𝑦 = 𝑙1 . sen(θ1 ) + 𝑙2 . sen(θ1 + θ2 )

𝐷𝑥 = 𝑙1 . cos(θ1 ) + 𝑙2 . cos(θ1 + θ2 ) + 𝑙3 . cos(θ1 + θ2 + θ3 )

𝐷𝑦 = 𝑙1 . sen(θ1 ) + 𝑙2 . sen(θ1 + θ2 ) + 𝑙3 . sen(θ1 + θ2 + θ3 )

𝐸𝑥 = 𝑙1 . cos(θ1 ) + 𝑙2 . cos(θ1 + θ2 ) + 𝑙3 . cos(θ1 + θ2 + θ3 ) + 𝑙4 . cos(θ1 + θ2 + θ3 + θ4 )

𝐸𝑦 = 𝑙1 . sen(θ1 ) + 𝑙2 . sen(θ1 + θ2 ) + 𝑙3 . sen(θ1 + θ2 + θ3 ) + 𝑙4 . sen(θ1 + θ2 + θ3 + θ4 )

𝐹𝑥 = 𝑙1 . cos(θ1 ) + 𝑙2 . cos(θ1 + θ2 ) + 𝑙3 . cos(θ1 + θ2 + θ3 ) + 𝑙4 . cos(θ1 + θ2 + θ3 + θ4 )

+ 𝑙5 . cos(θ1 + θ2 + θ3 + θ4 + θ5 )
𝐹𝑦 = 𝑙1 . sen(θ1 ) + 𝑙2 . sen(θ1 + θ2 ) + 𝑙3 . sen(θ1 + θ2 + θ3 ) + 𝑙4 . sen(θ1 + θ2 + θ3 + θ4 )
+ 𝑙5 . sen(θ1 + θ2 + θ3 + θ4 + θ5 )

𝐺𝑥 = 𝑙1 . cos(θ1 ) + 𝑙2 . cos(θ1 + θ2 ) + 𝑙3 . cos(θ1 + θ2 + θ3 ) + 𝑙4 . cos(θ1 + θ2 + θ3 + θ4 )

+ 𝑙5 . cos(θ1 + θ2 + θ3 + θ4 + θ5 ) + 𝑙6 . cos(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 )
𝐺𝑦 = 𝑙1 . sen(θ1 ) + 𝑙2 . sen(θ1 + θ2 ) + 𝑙3 . sen(θ1 + θ2 + θ3 ) + 𝑙4 . sen(θ1 + θ2 + θ3 + θ4 )
+ 𝑙5 . sen(θ1 + θ2 + θ3 + θ4 + θ5 ) + 𝑙6 . sen(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 )

𝐻𝑥 = 𝑙1 . cos(θ1 ) + 𝑙2 . cos(θ1 + θ2 ) + 𝑙3 . cos(θ1 + θ2 + θ3 ) + 𝑙4 . cos(θ1 + θ2 + θ3 + θ4 )

+ 𝑙5 . cos(θ1 + θ2 + θ3 + θ4 + θ5 ) + 𝑙6 . cos(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 )
+ 𝑙7 . cos(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 )
𝐻𝑦 = 𝑙1 . sen(θ1 ) + 𝑙2 . sen(θ1 + θ2 ) + 𝑙3 . sen(θ1 + θ2 + θ3 ) + 𝑙4 . sen(θ1 + θ2 + θ3 + θ4 )
+ 𝑙5 . sen(θ1 + θ2 + θ3 + θ4 + θ5 ) + 𝑙6 . sen(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 )
+ 𝑙7 . sen(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 )

𝐼𝑥 = 𝑙1 . cos(θ1 ) + 𝑙2 . cos(θ1 + θ2 ) + 𝑙3 . cos(θ1 + θ2 + θ3 ) + 𝑙4 . cos(θ1 + θ2 + θ3 + θ4 )

+ 𝑙5 . cos(θ1 + θ2 + θ3 + θ4 + θ5 ) + 𝑙6 . cos(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 )
+ 𝑙7 . cos(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 )
+ 𝑙8 . cos(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 + θ8 )
 𝐼𝑦 = 𝑙1 . sen(θ1) + 𝑙2 . sen(θ1 + θ2 ) + 𝑙3 . sen(θ1 + θ2 + θ3 ) + 𝑙4 . sen(θ1 + θ2 + θ3 + θ4 )
+ 𝑙5 . sen(θ1 + θ2 + θ3 + θ4 + θ5 ) + 𝑙6 . sen(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 )
+ 𝑙7 . sen(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 )
+ 𝑙8 . sen(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 + θ8 )

A posição do efetuador final em função das posições angulares será dada pelas equações:
𝐸𝑓𝑥 = 𝑙1 . cos(θ1 ) + 𝑙2 . cos(θ1 + θ2 ) + 𝑙3 . cos(θ1 + θ2 + θ3 ) + 𝑙4 . cos(θ1 + θ2 + θ3 + θ4 )
+ 𝑙5 . cos(θ1 + θ2 + θ3 + θ4 + θ5 ) + 𝑙6 . cos(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 )
+ 𝑙7 . cos(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 )
+ 𝑙8 . cos(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 + θ8 )
+ 𝑙9 . cos(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 + θ8 + θ9 )
𝐸𝑓𝑦 = 𝑙1 . sen(θ1 ) + 𝑙2 . sen(θ1 + θ2 ) + 𝑙3 . sen(θ1 + θ2 + θ3 ) + 𝑙4 . sen(θ1 + θ2 + θ3 + θ4 )
+ 𝑙5 . sen(θ1 + θ2 + θ3 + θ4 + θ5 ) + 𝑙6 . sen(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 )
+ 𝑙7 . sen(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 )
+ 𝑙8 . sen(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 + θ8 )
+ 𝑙9 . sen(θ1 + θ2 + θ3 + θ4 + θ5 + θ6 + θ7 + θ8 + θ9 )

A definição destes parâmetros no Matlab é dada pelo seguinte código:

% Cinematica direta
Ax = 0;
Ay = 0;

Bx = L1*cosd(Theta1);
By = L1*sind(Theta1);

Cx = L1*cosd(Theta1) + L2*cosd(Theta1 + Theta2);

Cy = L1*sind(Theta1) + L2*sind(Theta1 + Theta2);

Dx = L1*cosd(Theta1) + L2*cosd(Theta1 + Theta2) + L3*cosd(Theta1 + Theta2

+ Theta3);
Dy = L1*sind(Theta1) + L2*sind(Theta1 + Theta2) + L3*sind(Theta1 + Theta2
+ Theta3);

Ex = L1*cosd(Theta1) + L2*cosd(Theta1 + Theta2) + L3*cosd(Theta1 +

Theta2 + Theta3) + L4*cosd(Theta1 + Theta2 + Theta3 + Theta4);
Ey = L1*sind(Theta1) + L2*sind(Theta1 + Theta2) + L3*sind(Theta1 +
Theta2 + Theta3) + L4*sind(Theta1 + Theta2 + Theta3 + Theta4);

Fx = L1*cosd(Theta1) + L2*cosd(Theta1 + Theta2) + L3*cosd(Theta1 +

Theta2 + Theta3) + L4*cosd(Theta1 + Theta2 + Theta3 + Theta4) +
L5*cosd(Theta1 + Theta2 + Theta3 + Theta4 + Theta5);
Fy = L1*sind(Theta1) + L2*sind(Theta1 + Theta2) + L3*sind(Theta1 +
Theta2 + Theta3) + L4*sind(Theta1 + Theta2 + Theta3 + Theta4)+
L5*sind(Theta1 + Theta2 + Theta3 + Theta4 + Theta5);
Gx = L1*cosd(Theta1) + L2*cosd(Theta1 + Theta2) + L3*cosd(Theta1 +
Theta2 + Theta3) + L4*cosd(Theta1 + Theta2 + Theta3 + Theta4) +
L5*cosd(Theta1 + Theta2 + Theta3 + Theta4 + Theta5)+ L6*cosd(Theta1 +
Theta2 + Theta3 + Theta4 + Theta5 + Theta6);
Gy = L1*sind(Theta1) + L2*sind(Theta1 + Theta2) + L3*sind(Theta1 +
Theta2 + Theta3) + L4*sind(Theta1 + Theta2 + Theta3 + Theta4)+
L5*sind(Theta1 + Theta2 + Theta3 + Theta4 + Theta5) + L6*sind(Theta1 +
Theta2 + Theta3 + Theta4 + Theta5 + Theta6);

Hx = L1*cosd(Theta1) + L2*cosd(Theta1 + Theta2) + L3*cosd(Theta1 +

Theta2 + Theta3) + L4*cosd(Theta1 + Theta2 + Theta3 + Theta4) +
L5*cosd(Theta1 + Theta2 + Theta3 + Theta4 + Theta5)+ L6*cosd(Theta1 +
Theta2 + Theta3 + Theta4 + Theta5 + Theta6)+ L7*cosd(Theta1 + Theta2 +
Theta3 + Theta4 + Theta5 + Theta6 + Theta7);
Hy = L1*sind(Theta1) + L2*sind(Theta1 + Theta2) + L3*sind(Theta1 +
Theta2 + Theta3) + L4*sind(Theta1 + Theta2 + Theta3 + Theta4)+
L5*sind(Theta1 + Theta2 + Theta3 + Theta4 + Theta5)+ L6*sind(Theta1 +
Theta2 + Theta3 + Theta4 + Theta5 + Theta6)+ L7*sind(Theta1 + Theta2 +
Theta3 + Theta4 + Theta5 + Theta6 + Theta7);

Ix = L1*cosd(Theta1) + L2*cosd(Theta1 + Theta2) + L3*cosd(Theta1 +

Theta2 + Theta3) + L4*cosd(Theta1 + Theta2 + Theta3 + Theta4) +
L5*cosd(Theta1 + Theta2 + Theta3 + Theta4 + Theta5)+ L6*cosd(Theta1 +
Theta2 + Theta3 + Theta4 + Theta5 + Theta6)+ L7*cosd(Theta1 + Theta2 +
Theta3 + Theta4 + Theta5 + Theta6 + Theta7) + L8*cosd(Theta1 + Theta2 +
Theta3 + Theta4 + Theta5 + Theta6 + Theta7 + Theta8);
Iy = L1*sind(Theta1) + L2*sind(Theta1 + Theta2) + L3*sind(Theta1 +
Theta2 + Theta3) + L4*sind(Theta1 + Theta2 + Theta3 + Theta4)+
L5*sind(Theta1 + Theta2 + Theta3 + Theta4 + Theta5)+ L6*sind(Theta1 +
Theta2 + Theta3 + Theta4 + Theta5 + Theta6)+ L7*sind(Theta1 + Theta2 +
Theta3 + Theta4 + Theta5 + Theta6 + Theta7)+ L8*sind(Theta1 + Theta2 +
Theta3 + Theta4 + Theta5 + Theta6 + Theta7 + Theta8);

Efx = L1*cosd(Theta1) + L2*cosd(Theta1 + Theta2) + L3*cosd(Theta1 +

Theta2 + Theta3) + L4*cosd(Theta1 + Theta2 + Theta3 + Theta4) +
L5*cosd(Theta1 + Theta2 + Theta3 + Theta4 + Theta5)+ L6*cosd(Theta1 +
Theta2 + Theta3 + Theta4 + Theta5 + Theta6)+ L7*cosd(Theta1 + Theta2 +
Theta3 + Theta4 + Theta5 + Theta6 + Theta7)+ L8*cosd(Theta1 + Theta2 +
Theta3 + Theta4 + Theta5 + Theta6 + Theta7 + Theta8)+ L9*cosd(Theta1 +
Theta2 + Theta3 + Theta4 + Theta5 + Theta6 + Theta7 + Theta8 + Theta9);
Efy = L1*sind(Theta1) + L2*sind(Theta1 + Theta2) + L3*sind(Theta1 +
Theta2 + Theta3) + L4*sind(Theta1 + Theta2 + Theta3 + Theta4)+
L5*sind(Theta1 + Theta2 + Theta3 + Theta4 + Theta5)+ L6*sind(Theta1 +
Theta2 + Theta3 + Theta4 + Theta5 + Theta6)+ L7*sind(Theta1 + Theta2 +
Theta3 + Theta4 + Theta5 + Theta6 + Theta7)+ L8*sind(Theta1 + Theta2 +
Theta3 + Theta4 + Theta5 + Theta6 + Theta7 + Theta8)+ L9*sind(Theta1 +
Theta2 + Theta3 + Theta4 + Theta5 + Theta6 + Theta7 + Theta8 + Theta9);

Este trecho de código é utilizado tanto no arquivo general.m quanto no funcionobjetivo.m.

A resolução desta questão no Matlab consiste na adaptação do algoritmo estudado em
aula de um caso 4R para uma versão de 9R. Isso é possível aumentado a quantidade de variáveis
referentes às barras e a quantidade de variáveis calculadas pela rotina devec3 através do
parâmetro D. Foram adicionados também os comandos necessários para o plot das barras
adicionadas.
 Na configuração da função objetivo se fez necessária que as iterações nas quais
houvesse colisões com as paredes ou entre as hastes fossem penalizadas de forma a não serem
consideradas. Para isto, foram definidas três retas representantes das paredes e em seguida fora
utilizada a função polyxpoly, que recebe como parâmetros quatro vetores de coordenadas
referentes a duas sequências de retas planares e retorna dois vetores de coordenadas contendo
os pontos de intersecção entre estes dois conjuntos de retas.
Este teste precisou ser realizado duas vezes, uma para as colisões da cadeia cinemática
do robô com as paredes e uma segunda vez para verificar colisões dentro da própria cadeia
cinemática. O código que verifica colisões é o seguinte:
%calcula as intersecções
Box1X = 0;
Box1Y = 50;
Box2X = 100;
Box2Y = 50;
Box3X = 100;
Box3Y = 100;
Box4X = 0;
Box4Y = 100;

X2 = [Box1X, Box2X, Box3X, Box4X];

Y2 = [Box1Y, Box2Y, Box3Y, Box4Y];
X1 = [Ax, Bx, Cx, Dx, Ex, Fx, Gx, Hx, Ix, Efx];
Y1 = [Ay, By, Cy, Dy, Ey, Fy, Gy, Hy, Iy, Efy];

[XI,YI] = polyxpoly(X1,Y1,X2,Y2);

if (isempty([XI,YI])==0)
pen = pen + 999999999999999;
end

X2 = [Ax, Bx, Cx, Dx, Ex, Fx, Gx, Hx, Ix, Efx];
Y2 = [Ay, By, Cy, Dy, Ey, Fy, Gy, Hy, Iy, Efy];

[XI,YI] = polyxpoly(X1,Y1,X2,Y2);

if (size(XI,1) > 10)

pen = pen + 999999999999999;
end

Com todos os parâmetros devidamente configurados, o programa foi executado com um limite
de três mil iterações, resultando em um tempo de execução de aproximadamente quarenta e
cinco minutos. O gráfico resultante foi o seguinte:
 Figura 11: Posições angulares encontradas.

Os valores angulares encontrados foram:

Theta1: 74.693516599746940
Theta2: 54.419540420473780
Theta3: 3.088690215795685e+02
Theta4: 3.006382167597080e+02
Theta5: 5.868500959958030
Theta6: 70.018010234510370
Theta7: 2.722615022214949e+02
Theta8: 3.182463041656704e+02
Theta9: 1.033306031623771e+02