Exercício 3: Manipulador 3R. SIMULAÇÃO VIA SOFTWARE do Espaço de trabalho no plano X-Y.

O aluno deverá alterar o código apresentado para o manipulador 2 R e adaptá-lo para um manipulador 3R. As equações de X e Y (posição do efetuador final) foram encontradas no Exercício 2 desta atividade, pelo método geométrico. Os seguintes dados devem ser utilizados:
  • Comprimento elo 1: L1 = 12 (u.a.)
  • Comprimento elo 2: L2 =9 (u.a.)
  • Comprimento elo 3: L3 = 7 (u.a.)
Possibilidades de valores dos ângulos de juntas:
  • Theta1: de 0 a 90^{\circ}
  • Theta2: de 0 a 90^{\circ}
  • Theta3: de 0 a 180^{\underline{\circ}}
Sugestão: o aluno deverá programar primeiramente o código do exemplo para um manipulador 2R (Exercício 1) para ter certeza que seu código está validado e, só depois, abrir um novo arquivo e programar o 3R.

Passo 1

O que o enunciado pede e quais são os dados fornecidos.
  • Pedida: adaptar o código de um manipulador planar 2R para um manipulador planar 3R e simular (computar e desenhar) o espaço de trabalho no plano X\!-\!Y do efetuador final.
  • Dados (pegados do enunciado):
    • Comprimentos: L_1=12 (u.a.), L_2=9 (u.a.), L_3=7 (u.a.).
    • Limites dos ângulos das juntas:
      • \theta_1 varia de 0 a 90^\circ.
      • \theta_2 varia de 0 a 90^\circ.
      • \theta_3 varia de 0 a 180^\circ.
  • O objetivo prático para a prova: gerar um conjunto de pontos (X,Y) alcançáveis pelo efetuador e exibir graficamente o espaço de trabalho (por exemplo, um scatter plot ou imagem preenchida).
Observação: nada mais é necessário do enunciado (não há figura faltando). Vou agora mostrar passo a passo como obter as fórmulas e como transformar isso em código que você pode executar (por exemplo em MATLAB/Octave).

Passo 2

Equações de cinemática direta (forward kinematics) do manipulador 3R — dedução geométrica, com explicação didática.
  • Ideia geométrica simples: cada elo contribui com um vetor no plano. A posição do efetuador é a soma vetorial dos três elos apontando nas direções dadas pelos ângulos acumulados.
  • Se as juntas são rotacionais em série, o ângulo absoluto do segundo elo é \theta_1+\theta_2 e o do terceiro é \theta_1+\theta_2+\theta_3.
  • Portanto a coordenada X do efetuador é a soma das projeções horizontais dos três elos e a coordenada Y é a soma das projeções verticais:
X = L_1\cos(\theta_1) + L_2\cos(\theta_1+\theta_2) + L_3\cos(\theta_1+\theta_2+\theta_3),
Y = L_1\sin(\theta_1) + L_2\sin(\theta_1+\theta_2) + L_3\sin(\theta_1+\theta_2+\theta_3).
  • Explicação das variáveis:
    • L_1,L_2,L_3 são os comprimentos dos elos (unidades arbitrárias).
    • \theta_1,\theta_2,\theta_3 são os ângulos das juntas, medidos em radianos ao usar funções trigonométricas no código.
    • A função \cos e \sin retornam as projeções do comprimento do elo ao longo dos eixos X e Y, respectivamente.
  • Observação prática: no código costuma-se trabalhar com graus no laço de varredura por ser mais intuitivo, mas ao calcular \cos e \sin é preciso converter para radianos usando a relação \text{rad}=\pi/180\cdot\text{deg}.

Passo 3

Como discretizar os ângulos (amostragem) e trade-offs (resolução vs tempo/memória).
  • Escolha de passo padrão: 1^\circ é uma boa resolução para visualizar bem o espaço de trabalho, porém gera muitos pontos: número de combinações =(90-0)/1+1 para \theta_1 é 91, idem para \theta_2, e para \theta_3 com 180 graus é 181. Produto: 91\times91\times181\approx1{,}5\times10^{6} pontos — pesado, mas geralmente aceitável em máquinas modernas.
  • Reduzir o passo para 2^\circ dá ~187k pontos (bem mais rápido). Se a memória for um problema, use 2^\circ ou 3^\circ.
  • Estratégia prática: começar com passo maior (por exemplo 2^\circ) para validar o código e depois refinar para 1^\circ se precisar de maior resolução.
  • Importante: use vetorização quando possível ou elimine pontos duplicados (por exemplo arredondar e aplicar unique) antes de plotar — isso reduz custo de plotagem.

Passo 4

Algoritmo passo a passo para gerar e desenhar o espaço de trabalho (forma imperativa fácil de acompanhar).
  1. Definir L_1,L_2,L_3.
  2. Definir vetores de ângulo em graus: \theta_1^{\circ} de 0 a 90 com passo escolhido, \theta_2^{\circ} de 0 a 90, \theta_3^{\circ} de 0 a 180.
  3. Converter esses vetores para radianos: \theta = \text{deg}\cdot\pi/180.
  4. Fazer laços aninhados (ou usar \text{ndgrid}) para gerar todas as combinações (\theta_1,\theta_2,\theta_3).
  5. Para cada tripla, calcular X e Y usando as fórmulas do Passo 2.
  6. Acumular os pontos (X,Y) num array.
  7. Opcional: arredondar os pontos a um número razoável de casas (ex.: 4 casas decimais) e eliminar duplicatas.
  8. Plotar os pontos com plot/scatter usando axis equal para visualizar corretamente as distâncias.
  9. (Opcional) Desenhar também o contorno (convex hull) ou algumas configurações do manipulador para validação visual.

Passo 5

Dicas práticas de implementação e validação (truques que facilitam muito na prova ou tarefa prática).
  • Validação incremental: primeiro faça o código com L_3=0 (caso 2R). Se o resultado bater com o seu exercício anterior 2R, então reative L_3 para 3R.
  • Para economizar memória, não armazene todos os pontos com muita precisão: arredonde e aplique unique.
  • Se for usar laços triplos (mais simples de entender), use pré-alocação do array ou escreva os pontos em uma matriz grande com índice incremental — evita alocação dinâmica lenta.
  • Se desejar velocidade: usar ndgrid + operações element-wise e depois transformar em vetor (com (:)) é bastante rápido em MATLAB/Octave.
  • Para plotagem fina: usar 'MarkerSize',1 e '.' para scatter; para preencher o interior do workspace pode-se usar scatter + convhull ou técnicas de imagem binária.

Passo 6

Um exemplo de como desenhar uma configuração do manipulador (para testar se as fórmulas estão corretas).
  • Dados \theta_1,\theta_2,\theta_3 (em rad):
    • Ponto da junta 0 (base): P_0=(0,0).
    • Ponto da junta 1: P_1=(L_1\cos\theta_1,\;L_1\sin\theta_1).
    • Ponto da junta 2: P_2=P_1 + (L_2\cos(\theta_1+\theta_2),\;L_2\sin(\theta_1+\theta_2)).
    • Efetuador P_3=P_2 + (L_3\cos(\theta_1+\theta_2+\theta_3),\;L_3\sin(\theta_1+\theta_2+\theta_3)).
  • Para visualizar: plotar linhas entre P_0\to P_1\to P_2\to P_3 e marcar as juntas com círculos. Isso confirma geometricamente que a cinemática direta está correta.

Passo 7

Avisos finais e sugestões de parâmetros para a prova/tarefa.
  • Comece com passo 2^\circ para depurar. Se tudo certo, rode com 1^\circ para o resultado final.
  • Se precisar entregar uma figura limpa, salve a imagem com print -dpng ou saveas.
  • Se o computador ficar lento ao plotar 1,5M pontos, reduza o marcador ou aplique unique para remover pontos repetidos.

Resposta

% Código MATLAB/Octave para calcular e desenhar o espaço de trabalho do manipulador 3R
% (Ajuste “step_deg” para controlar resolução: 1 = fino, 2 = mais rápido)
L1 = 12;
L2 = 9;
L3 = 7;
% resolução em graus (mude para 1, 2, 3 conforme necessidade)
step_deg = 1;
t1_deg = 0:step_deg:90;
t2_deg = 0:step_deg:90;
t3_deg = 0:step_deg:180;
% converter para radianos
deg2rad = pi/180;
t1 = t1_deg * deg2rad;
t2 = t2_deg * deg2rad;
t3 = t3_deg * deg2rad;
% Método vetorizado com ndgrid (mais rápido que loops aninhados em MATLAB)
[T1, T2, T3] = ndgrid(t1, t2, t3);
% calcular coordenadas X e Y usando as fórmulas da cinemática direta
Xall = L1cos(T1) + L2cos(T1 + T2) + L3cos(T1 + T2 + T3);
Yall = L1
sin(T1) + L2sin(T1 + T2) + L3sin(T1 + T2 + T3);
% transformar em vetores coluna
Xvec = Xall(😃;
Yvec = Yall(😃;
% reduzir duplicatas: arredondar para evitar diferenças numéricas muito pequenas
pts = unique(round([Xvec, Yvec], 4), ‘rows’);
% plot do espaço de trabalho
figure(‘Color’,‘w’);
plot(pts(:,1), pts(:,2), ‘.’, ‘MarkerSize’, 1);
axis equal;
grid on;
xlabel(‘X (u.a.)’);
ylabel(‘Y (u.a.)’);
title(sprintf(‘Espaço de trabalho 3R (L = [%d, %d, %d], passo = %d^\circ)’, L1, L2, L3, step_deg));
% Opcional: desenhar algumas configurações do manipulador para checar geometria
% escolha algumas triplas de ângulos para visualizar
sample_angles_deg = [0 0 0; 45 45 90; 90 0 180]; % cada linha: [t1 t2 t3] em graus
hold on;
for k = 1:size(sample_angles_deg,1)
th = sample_angles_deg(k,:) * deg2rad;
p0 = [0,0];
p1 = p0 + [L1cos(th(1)), L1sin(th(1))];
p2 = p1 + [L2cos(th(1)+th(2)), L2sin(th(1)+th(2))];
p3 = p2 + [L3cos(th(1)+th(2)+th(3)), L3sin(th(1)+th(2)+th(3))];
plot([p0(1) p1(1) p2(1) p3(1)], [p0(2) p1(2) p2(2) p3(2)], ‘-o’, ‘LineWidth’, 1.2, ‘MarkerSize’, 4);
end
legend({‘Pontos do espaço de trabalho’,‘Configurações exemplo’}, ‘Location’, ‘bestoutside’);
hold off;

Exercícios relacionados