CENTRO UNIVERSITÁRIO DO TRIÂNGULO
INSTITUTO DE CIÊNCIAS EXATAS E TECNOLÓGICAS
CURSO DE CIÊNCIA DA COMPUTAÇÃO
Desenvolvimento de um sistema para o
controle de um braço robótico
Felipe Luís Aquino Pereira da Rocha
Uberlândia, Novembro/2003
CENTRO UNIVERSITÁRIO DO TRIÂNGULO
INSTITUTO DE CIÊNCIAS EXATAS E TECNOLÓGICAS
CURSO DE CIÊNCIA DA COMPUTAÇÃO
Desenvolvimento de um sistema para o
controle de um braço robótico
Felipe Luís Aquino Pereira da Rocha
Monografia apresentada ao Curso de
Ciência da Computação do Centro
Universitário do Triângulo - Unit, como
requisito básico à obtenção do grau de
Bacharel em Ciência da Computação,
sob a orientação do Professor Doutor
Elmo Batista de Faria.
Uberlândia, Novembro/2003
Desenvolvimento de um sistema para o
controle de um braço robótico
Felipe Luís Aquino Pereira da Rocha
Monografia apresentada ao Curso de Ciência da Computação do Centro
Universitário do Triângulo - Unit, como requisito básico à obtenção do
grau de Bacharel em Ciência da Computação.
Prof. Dr. Elmo Batista de Faria
(Orientador)
Profª. Ms. Eliane Teresa Borela
(Avaliadora)
(Profª. Ms. Silvia Fernanda Martins Brandão)
(Coordenadora do Curso de Ciência da Computação)
Uberlândia, Novembro/2003
ii
Dedico esta obra às pessoas que contribuíram para que eu alcançasse
este ponto, professores, namorada, amigos e, principalmente, meus pais
e familiares; e ainda, em memória de Lilu Dala e Cocota Marisa.
iii
RESUMO
Diante do crescimento dos sistemas robóticos, e do surgimento da
disciplina Robótica no Centro Universitário do Triângulo surgiu a
necessidade da criação de uma plataforma para estudos e testes, foi
onde surgiu a idéia de criar um braço robótico controlado por um sistema
computacional. A construção desta plataforma embasou-se em várias
técnicas e estudos de eficiência já comprovados no mundo industrial, a
exemplo disto, hoje em dia, tem-se uma diversidade de robôs
empregados nos mais diversos segmentos industriais. Este trabalho
inicialmente descreve os materiais físicos que são empregados na
construção de robôs, bem como: motores, técnicas de interfaceamento da
porta paralela, controladores, e ainda, controle inteligente. São mostrados
os conceitos necessários para que se possa movimentar um braço
robótico no espaço, descrevendo as técnicas de cinemática direta e
inversa e sobre os coeficientes de Denavit-Hartenberg e como utilizá-los.
Finalmente, a construção e manipulação do braço, deslocando-o e
executando algumas tarefas. Neste sentido, vale ressaltar que a
automação está cada dia mais presente nos meios industriais, tornado
este
trabalho
uma
oportunidade
para
o
aprofundamento
dos
conhecimentos nesta área e também, como referência para futuros
trabalhos realizados na disciplina e no assunto.
iv
SUMÁRIO
LISTA DE FIGURAS..................................................................................vii
LISTA DE TABELAS...................................................................................ix
1. INTRODUÇÃO....................................................................................... 1
2. Técnicas para o Desenvolvimento de Robôs......................................... 3
2.1. Motores ............................................................................................. 3
2.1.1. Motor de Passo............................................................................ 3
2.1.2. Motor de Corrente Contínua ........................................................ 5
2.2. Interfaceando Periféricos Através da Porta Paralela ........................ 6
2.3. Tecnologia PWM (Pulse Width Modulation)...................................... 8
2.4. Controladores ................................................................................. 10
2.5. Controladores de Torque Computados ........................................... 12
2.6. Sistemas de Controle Inteligente .................................................... 12
2.6.1. Redes Neurais ........................................................................... 12
2.6.2. Lógica Nebulosa ........................................................................ 14
2.6.3. Visão Robótica........................................................................... 15
2.7. Conclusão ....................................................................................... 16
3. Técnicas para o Posicionamento de robôs ....................................... ...17
3.1. Cinemática Direta e Inversa............................................................ 17
3.2. Cálculo dos coeficientes de Denavit e Hartenberg (DH) ................. 18
3.3. Coordenadas .................................................................................. 22
3.4 Conclusão ........................................................................................ 23
4. Estudo de Caso ................................................................................... 24
v
4.1. Cálculo da Cinemática Direta.......................................................... 24
4.2. Cálculo da Cinemática Inversa ....................................................... 28
4.3. Desenvolvimento do sistema para o controle do braço robótico..... 30
4.4. Conclusão ....................................................................................... 41
5. Conclusão ............................................................................................ 42
REFERÊNCIAS BIBLIOGRÁFICAS......................................................... 45
vi
LISTA DE FIGURAS
Figura 2.1 - Pinos da Porta Paralela .......................................................... 6
Figura 2.2 - Acionamento da Porta Paralela - Linguagem C...................... 8
Figura 2.3 – Modulação em Largura de Pulsos ........................................ 9
Figura 3.1 – Notação de Denavit e Hartenberg ....................................... 18
Figura 3.2 – Multiplicação das Matrizes Intermediárias (DH)................... 20
Figura 3.3 – Matriz (DH) .......................................................................... 20
Figura 3.4 – Coordenadas do Robô......................................................... 22
Figura 4.1 – Matriz DH............................................................................. 25
Figura 4.2 – Matriz DH do elo 1 ............................................................... 25
Figura 4.3 – Matriz DH do elo 2 ............................................................... 25
Figura 4.4 – Matriz DH do elo 3 ............................................................... 25
Figura 4.5 – Matriz resultante Τ12 ............................................................. 26
Figura 4.6 – Matriz resultante Τ23 ............................................................. 26
Figura 4.7 – Matriz resultante Τ23 (Simplificada) ....................................... 27
Figura 4.8 – Tela Principal ....................................................................... 31
Figura 4.9 – Tela Cinemática Direta ........................................................ 31
Figura 4.10 – Tela Cinemática Inversa .................................................... 32
Figura 4.11 – Implementação da classe Robo - Robo.h ....................... ...33
Figura 4.12 – Implementação da classe Robo - Robo.cpp ................... ...36
Figura 4.13 – Implementação da classe Motor - Motor.h......................... 37
Figura 4.14 – Implementação da classe Motor - Motor.cpp ..................... 38
vii
Figura 4.15 – Implementação da classe PortaParalela - PortaParalela.h 39
Figura 4.16 –Implementação da classe PortaParalela-PortaParalela.cpp40
viii
LISTA DE TABELAS
Tabela 2.1 – Informação dos Pinos da Porta Paralela............................... 7
Tabela 2.2 – Configuração da Porta Paralela ............................................ 8
Tabela 4.1 – Coeficientes Denavit-Hartenberg (DH)................................ 24
ix
1 - Introdução
Diante de tamanha automação nos parques industriais e da
crescente onda de utilização de computadores pessoais para as mais
diversas situações é que surgiu a oportunidade da produção deste
documento, visando mostrar os passos necessários para que se possa
construir um software para o controle de robôs de pequeno e médio porte.
A produção deste documento também surgiu da necessidade de
um material acessível e de fácil entendimento para os alunos que
estudam a disciplina de Robótica, visando mostrar os conceitos e técnicas
básicas para o entendimento deste segmento da Informática, Mecânica e
Eletrônica.
Assim como visto em fábricas e parques industriais, os robôs
executam
as
mais
diversificadas
tarefas
como
empacotamento,
empilhamento, controles de qualidade, automações em linha de
produção, em casos mais específicos, cuidam de doentes, substituem
animais de estimação, dentre estes exemplos, encontram-se vários outros
que provam que a utilização destes seres inanimados veio para ficar e
evoluir com o decorrer do tempo e utilização, sendo então adequados
para novas tarefas a cada instante.
Um dos grandes motivos que tornam o robô uma ferramenta
presente no mundo atual, está no fato de possuírem algumas qualidades
1
que os tornam para empresas, de modo geral, economicamente viáveis
com relação aos funcionários humanos, a exemplo pode-se citar o fato de
não se cansarem, não necessitarem de salário, possuírem um alto nível
de qualidade de serviço executado, não necessitarem de condições
ambientais especiais, tais como ar condicionado, luz e silêncio, porém, em
contra partida, os robôs necessitam de aprendizado, memória e possuem
movimentos limitados comparando-se à realidade humana.
Sendo assim, este documento torna-se uma ferramenta para
aqueles que se interessam por robôs controlados por computadores
pessoal e não sabem por onde começar, possibilitando para a estas
pessoas, um inicio em sua linha de pesquisa, para que possam construir
seus próprios robôs controlados por seus computadores.
No Capítulo 1, é apresentada uma prévia do que está por vir,
juntamente com o escopo do trabalho.
No
Capítulo
2
são
mostradas
algumas
técnicas
para
o
desenvolvimento de robôs onde aborda um conteúdo sobre as
necessidades físicas para a construção de um robô.
O Capítulo 3 aborda as técnicas para o posicionamento de robôs,
explicando como aplicar os conhecimentos da cinemática à robótica para
que se possa movimentar um braço robótico no espaço.
No Capítulo 4 é apresentado o Estudo de Caso que é o momento
onde é exposta a construção do software para o controle do braço
robótico, utilizando as técnicas neste documento apresentadas.
O Capítulo 5 é a parte final, onde é feito juntamente com a
conclusão um relatório de como foi o desenvolvimento deste documento.
2
2 - Técnicas para o Desenvolvimento de Robôs
Neste capítulo, são mostrados conceitos pertinentes à robótica tais
como,
motores
de
passo,
motores
de
corrente
contínua,
o
interfaceamento da porta paralela de um computador pessoal, tecnologias
de controle de acesso ao meio, controladores, sistemas inteligentes e
ainda, visão robótica onde, em alguns casos, são mostrados conceitos e
exemplos para um melhor entendimento.
2.1 - Motores
Motores são transdutores. Transformam a energia em que são
submetidos em outra forma de energia, sendo esta, elétrica, motora, entre
outras. Aqui, serão abordados dois modelos de motores, os chamados
motores de passo e os de corrente contínua, cada um com suas
particularidades e funcionalidades.
2.1.1- Motor de Passo
Os motores de passo transformam a energia elétrica em energia
mecânica e, uma vez que são de fácil adaptação à lógica digital, sua
utilização
está
cada
vez,
mais
popular.
Vários
periféricos
de
computadores os usam em inúmeras aplicações, como mesas gráficas,
unidades de disco, impressoras e etc. Não só na informática, mas
também na robótica, o uso destes motores é cada vez mais presente
sendo encontrados em sistemas de movimentação de braços mecânicos
3
e etc. Com o auxílio desses motores, pode-se criar interfaces entre o
computador e o movimento mecânico, constituindo, assim, a chave para a
robótica.
O motor de passo é eletromagnético. Ele converte mecanicamente
pulsos digitais em incrementos de rotação do eixo. A rotação não só tem
uma relação direta ao número de pulsos, mas sua velocidade é
relacionada à freqüência dos mesmos, os motores de passo deslocam-se
por impulsos ou passos discretos e exibem três estágios: parados,
ativados com rotor travado (bobinas energizadas) ou girando, em passos.
Entre cada passo, o motor pára na posição (com sua carga) sem a ajuda
de embreagens ou freios. Assim, um motor de passo pode ser controlado
de uma forma que o faz girar um certo número de passos, produzindo um
movimento mecânico por uma distância específica, e então, segura a sua
carga quando pára. Além disso, pode-se repetir a operação quantas
vezes se desejar. [1]
Com a lógica apropriada, os motores de passo podem ser
bidirecionais, síncronos, prover aceleração rápida, parar, reverter e
conectar-se facilmente com outros mecanismos digitais. [1]
A classificação dos motores de passo é subdividida de acordo com
a forma em que é gerado o campo rotativo (enrolamento unipolar ou
bipolar no estator). Os mais usados são os unipolares, geralmente com
quatro bobinas. Neles, cada fase consiste de um enrolamento com
derivação central, ou mesmo de dois enrolamentos separados, de forma
que o campo magnético possa ser invertido sem a necessidade de se
inverter o sentido da corrente. [2]
Os motores bipolares, como possuem muitas bobinas na mesma
carcaça possuem fios mais finos ou um menor número de espiras,
4
desenvolvem momentos inferiores aos dos unipolares, porém possuem
uma resolução maior, isto é, maior número de passos por volta completa.
A máxima freqüência de rotação é limitada pelo rotor magnetizado, que
induz uma tensão no estator. Desse modo, motores com velocidades
relativamente elevadas usam, normalmente, rotores de ferro doce,
unipolares e com menos pólos que o estator. Os enrolamentos são
ligados em seqüência, às vezes em grupos. [2]
2.1.2 - Motor de Corrente Contínua
São motores comuns, giram em velocidade constante, pois
possuem apenas dois estágios de operação. Nos motores de corrente
continua a parte móvel, o rotor, encontra-se no meio de um campo
magnético que pode ser produzido por um ímã permanente ou por um
eletroímã. Ao se aplicar uma tensão continua entre as escovas do coletor,
as bobinas do induzido serão percorridas por uma corrente continua que
irá criar um campo magnético. Isto provocará uma interação entre os
campos magnéticos criados, o campo do indutor e o campo do induzido,
o que irá produzir um binário de forças na periferia do rotor que fará com
que este apresente um movimento giratório. [2]
A velocidade de um motor de corrente continua apresenta-se
sempre dependente da intensidade da corrente que atravessa o induzido,
variando a tensão aplicada nos terminais do induzido a velocidade pode
aumentar ou diminuir; em igual analogia, o número de espiras das
bobinas do induzido também é outro fator que carece de especial
atenção, porque faz variar o campo magnético e por conseqüência a
velocidade. E, além destes três fatores a velocidade ainda depende, do
fluxo do pólo e do número de pólos do indutor, e a mesma, por vezes tem
de ser ajustada ao sistema a que o motor será relacionado. [2]
5
2.2 – Interfaceando Periféricos Através da Porta Paralela
A porta paralela é uma interface de comunicação entre o
computador e um periférico. Quando a IBM criou seu primeiro PC
(Personal Computer), a idéia era conectar a essa porta uma impressora,
mas atualmente, são vários os periféricos que se utilizam desta porta para
enviar e receber dados para o computador, por exemplo, têm-se
scanners, câmeras de vídeo, unidade de disco removível e outros. 0
Figura 2.1 – Pinos da Porta Paralela. [3]
A IBM definiu um padrão para a porta paralela da impressora. Esta
porta usa um conector fêmea DB-25S no computador, e, no cabo, um
conector DB-25P macho e um conector Centronics macho de 36 pinos,
usado para ser conectado em impressoras paralelas de padrão
Centronics. Esta diferença nos conectores do cabo é possível porque
apenas a metade os pinos do conector Centronics são usados, o restante
constitui-se de conexões terra. [3]
De acordo com a figura acima, onde mostra o layout de uma porta
paralela, a tabela abaixo expõe o fluxo de energia em cada pino e
também sua funcionalidade planejada pela IBM:
6
Tabela 2.1 Informação dos Pinos da Porta Paralela [3]
←Entrada
→ Saída
Pino no DB25
Pino no
Centronics
Nome do Sinal
Bit do
Registrador
→
1
1
-Strobe
C0-
→
2
2
Data 0
D0
→
→
→
→
→
→
→
3
4
5
6
7
8
9
3
4
5
6
7
8
9
Data 1
Data 2
Data 3
Data 4
Data 5
Data 6
Data 7
D1
D2
D3
D4
D5
D6
D7
←
10
10
-Ack
S6+ IRQ
←
11
11
+Busy
S7-
←
12
12
+PaperEnd
S5+
←
13
13
+Select In
S4+
→
14
14
-AutoFd
C1-
←
15
32
-Error
S3+
→
16
31
-Init
C2+
→
17
36
-Select
C3-
==
18 ~ 25
19-30, 33, 17,
16
Observações
Envie um pulso >
0,5us para enviar
o dado
Bit menos
significativo
Enviar um pulso
baixo de
aproximadamente
5us, depois de
aceitar a
interrupção
Alto para
Ocupado / Fora
de Linha / Erro
Alto para
impressora sem
papel
Alto pra
impressora
selecionada
Envie um sinal
baixo para
avançar uma
linha
Baixo para Erro /
Fora de Linha /
Sem Papel
Envie um pulso
baixo com mais
de 50us para
iniciar a
impressora
Envie um pulso
baixo para
selecionar a
impressora
Terra
A IBM definiu três endereços base de entrada/saída para a porta
paralela. A porta paralela padrão usa o endereço de entrada/saída 0x378,
em versões mais antigas era usado o endereço 0x278, enquanto que, o
endereço
da
porta
paralela
usada
em
adaptadores
de
vídeo
monocromáticos é o endereço 0x3BC. Cada porta dessas possui 3
endereços: dados, status e controle. Esses endereços estão em ordem
seqüencial. Isso quer dizer que se a porta de dados tem o endereço
7
0x038, então o endereço correspondente de status é 0x0379 e o de
controle é 0x037a. [4]
Tabela 2.2 – Configuração da Porta Paralela. [3]
Impressora
Porta de Dados
Status
Controle
LPT1
0x0378
0x0379
0x037a
LPT2
0x0278
0x0279
0x027a
LPT3
0x03bc
0x03bd
0x03be
Para exemplificar o uso da porta paralela, é mostrado na Figura 2.2
um exemplo implementado em linguagem C:
//Este exemplo envia sinal para a Porta Paralela LPT1:
#include <stdio.h>
#include <dos.h>
#define LPT1 0x378
int main(void)
{
unsigned char Valor=128;
//Em binário: 10000000
while( Valor > 0 )
{
outportb(LPT1, Valor); // Envia o valor para a Porta LPT1
printf("\nPressione uma tecla para ascender o próximo LED...");
getch( );
Valor = Valor >> 1; //A cada passagem, o bit 1 é movido para à
//
direita
}
}
Figura 2.2 – Acionamento da Porta Paralela - Linguagem C
2.3 – Tecnologia PWM (Pulse Width Modulation)
É a técnica utilizada quando se deseja controlar algum dispositivo
com máxima precisão e com tempos mais curtos de correção de erros.
Em português, PWM significa Modulação por Largura de Pulso; este tipo
de modulação mantém a amplitude dos pulsos constantes e sua largura
varia proporcionalmente aos valores de f(t) (sinal modulador) nos
instantes correspondentes, como mostra a Figura 2.3 [5]
8
Figura 2.3 – Modulação em Largura de Pulsos. [5]
A grande vantagem do uso de circuitos PWM como controladores
contra os circuitos resistivos é quanto à eficiência. Enquanto o PWM
trabalha com eficiência quase 1 (menos de 1% de perda), para um circuito
resistivo trabalhando a 50% da carga, 50% vai realmente para
alimentação da carga e 21% é perdido em aquecimento nos resistores.
Isto é uma grande vantagem para fontes de energia renovável. [5]
Uma outra grande vantagem é que, na modulação de largura de
pulso, os pulsos estão com o valor nominal de pico, gerando um maior
torque nos motores. Um controlador resistivo, já que deverá ter uma
tensão reduzida, poderá causar parada de um motor devido ao torque
reduzido. Além disso, é possível usar potenciômetros menores para
controlar uma variedade de cargas, ao contrário dos resistivos que usam
potenciômetros grandes e caros. [5]
Uma das desvantagens do PWM é a complexidade e a
possibilidade de gerar interferência de rádio freqüência (RFI). A RFI pode
ser minimizada colocando o controlador perto da carga e em alguns
casos, usando filtros adicionais. [5]
9
2.4 – Controladores
Os motores de passo unipolares são controlados facilmente
através de apenas um transistor por enrolamento, enquanto nos bipolares
são necessários quatro transistores em ponte. É possível, nesse segundo,
utilizar apenas dois transistores por enrolamento, desde que a fonte seja
simétrica, o que tornaria o circuito um pouco mais complexo. Mas, em
ambos os casos, uma lógica de controle é exigida para que o motor possa
girar corretamente. [2]
Caso o controle do motor de passo seja feito pelo computador, os
estágios de excitação poderão ser acoplados diretamente a um dos
conectores de saída, deixando para o software a tarefa de estabelecer os
movimentos do motor, ou seja, sentido de rotação (horário / anti-horário),
em passos inteiros ou meio passos e a variação dos tempos entre os
passos, que definirá a precisa regulação da velocidade. Pela contagem do
número de passos, será possível seguir continuamente a posição do
objeto acionado pelo motor. [2]
Uma outra opção para comandar esses motores é através de
circuitos lógicos discretos que comandarão os transistores de saída e as
bobinas do motor, existindo para estes casos, CIs específicos para estas
funções. [2]
Dentre estes controladores, pode ser usado os controladores PI
(Proporcional-Integral), PD (Proporcional-Diferencial) ou ainda PID
(Proporcional-Integral-Derivativo).
Em muitos processos, do uso doméstico ao industrial, há
necessidade de se manter um ou mais parâmetros estáveis ou, pelo
10
menos, dentro de uma certa faixa de variação. Pode ser a pressão de um
líquido ou de um gás, e ainda, a rotação de um motor.
Uma vez falando de controladores, os mesmos, possuem alguns
conceitos que são:
•
Setpoint: é uma variável aplicada no controlador que define
o valor desejado para a variável do processo.
•
Variável do processo: é a variável que vem do processo e é
aplicada no controlador para comparação com o valor
desejado (setpoint). Também chamada de medida.
•
Variável de controle: variável que sai do controlador e é
aplicada no processo para ajustar o parâmetro que se
deseja controlar, cujo resultado será dado pela variável de
processo. [6]
O Controlador Proporcional, não possui uma boa atenuação das
variações, o que ocorre um deslocamento (offset), exigindo a correção
manual.
O Controlador Proporcional-Integral, já possui um melhor controle,
eliminando o deslocamento (offset), mas a regulação ainda não é das
melhores.
O Controlador Proporcional-Integral-Diferencial é uma forma
refinada de controle, usada quando as mais simples se mostram
insuficientes, possui sob seu controle, a ação da derivada que tende a se
opor às variações da variável do processo, fazendo o ganho total do
controle se mover para um caminho diferente na aproximação para o
11
setpoint. Isto conduz a uma estabilização mais rápida e uniforme do
processo.
2.5 – Controladores de Torque Computados
Os controladores de torque computados são controladores regidos
pelo conhecimento de uma rede neural, onde no treinamento da rede, é
ensinado a mesma, o controle de variáveis como, em um exemplo bem
prático, variáveis, sendo, posições, velocidades e acelerações das juntas
de um robô e a rede será capaz de retornar a sua compensação com o
torque para cada junta do robô.
2.6 – Sistemas de Controle Inteligente
As técnicas aqui mostradas, aliadas ao poder computacional,
tornam-se grandes ferramentas para os sistemas robóticos uma vez que
podem desenvolver funções pseudo-humanas que são a inteligência e
visão, Para tanto, neste tópico serão abordadas as técnicas de Redes
Neurais, Lógica Nebulosa e, Visão Robótica.
2.6.1 – Redes Neurais
As redes neurais artificiais que são utilizadas em engenharia,
computação, robótica, foram inspiradas nas redes neuronais biológicas.
No entanto, convencionou-se chamar redes neurais artificiais a
toda topologia de processamento de sinais constituída de vários
elementos, processadores simples altamente interconectados, sendo
assim, são estruturas baseadas no conexionismo. [7]
Características típicas de Redes Neurais Artificiais (RNA):
12
Características Positivas:
•
Capacidade de Aprendizado: RNA não são programadas,
mas treinadas com padrões de treinamento. Podem ser
adaptadas através das entradas.
•
Paralelismo: RNA são massivamente paralelas e são,
portanto,
muito
bem
adequadas
para
uma
simulação/implementação em computação paralela.
•
Representação
distribuída
do
conhecimento:
o
conhecimento é armazenado de forma distribuída em seus
pesos. O que aumenta a tolerância do sistema a falhas de
neurônios individuais; permite o processamento paralelo.
•
Tolerância à falhas: o sistema pode ser mais tolerante a
falhas
de
neurônios
individuais
que
algoritmos
convencionais. A rede deve, no entanto, ser treinada para
apresentar
esta
característica.
Nem
toda
rede
é
automaticamente tolerante a falhas.
•
Armazenamento associativo da informação: para um certo
padrão de entrada a RNA fornece o padrão que lhe é mais
próximo. O acesso não é feito por endereçamento.
•
Robustez contra perturbações ou dados ruidosos: quando
treinadas para tanto as redes neurais são mais robustas a
padrões incompletos (ruidosos). [7]
13
Características Negativas:
•
Aquisição de conhecimento só é possível através de
aprendizado:
principalmente
devido
à
representação
distribuída é muito difícil (exceção: rede de Hopfield para
problemas de otimização) introduzir conhecimento prévio em
uma RNA. Isto é muito comum em sistemas de IA
simbólicos.
•
Não é possível a introspecção: não é possível analisar o
conhecimento ou percorrer o procedimento para a solução,
como é possível com os componentes de explicação de
sistemas especialistas.
•
Difícil dedução lógica (seqüencial): é virtualmente impossível
obter-se cadeias de inferência lógica com redes neurais.
•
Aprendizado é lento: principalmente redes completamente
conectadas e quase todas as variantes dos algoritmos
backpropagation são muito lentas. [7]
2.6.2 – Lógica Nebulosa
A Lógica Nebulosa permite criar sistemas especialistas utilizando
variáveis lingüísticas para criar uma base de regras. Expressões
lingüísticas são típicas da natureza humana de tomar decisões. Por
exemplo: "Se estiver quente vou ligar o ar condicionado no máximo”.
Quente e máximo não significam um valor particular de temperatura e
potência, mas podem assumir uma faixa considerável de valores.
Pessoas diferentes também podem ter diferentes acepções para o mesmo
14
conceito lingüístico. Sistemas nebulosos são sistemas baseados em
conhecimento (sistemas especialistas). [7]
2.6.3 – Visão Robótica
A utilização de imagens para percepção, por robôs móveis, do
mundo exterior tem sido um desafio importante para as equipes de
pesquisadores que desenvolvem atividade na área da Visão Robótica. [8]
A área da visão robótica encontra-se na observação do mundo
animal e também nos recursos computacionais de processamentos de
imagens digitais como sendo suas fontes inspiradoras mais importantes
para a interpretação do mundo externo do robô.
De fato, o próprio ser humano usa o sistema visual, com muita
eficiência, em muitas das suas atividades. As tentativas já realizadas, de
simulação e implementação artificial de capacidades visuais, têm revelado
estar-se perante de um problema muito complexo e de difícil resolução
global. Esta dificuldade tem levantado a questão de qual o grau em que
as capacidades visuais humanas e dos animais restantes podem ser
imitadas e utilizadas em robôs. A resposta a esta questão tem vindo a ser
procurada, por alguns pesquisadores, em estudos de psico-fisiologia da
visão. [8]
A introdução de visão num robô móvel traduz-se num significativo
aumento das suas capacidades sensoriais, portanto, um correspondente
aumento de versatilidade e segurança na operação do robô. Espera - se,
da visão robótica, soluções ou simplificações para problemas de detecção
e localização de objetos ou obstáculos, úteis no desempenho de tarefas
de manipulação ou navegação. [8]
15
2.7 – Conclusão
Neste
capítulo
foram
mostradas
técnicas
de
fundamental
importância para a construção de um braço robótico, e ainda o necessário
para movimentar o braço do robô. Técnicas de como controlar e acessar
os motores, no caso, os controladores e o interfaceamento via porta
paralela, respectivamente. Expôs também que é possível aplicar à
robótica, conhecimentos de outras áreas computacionais, tanto em
controladores quanto em programas para controlar o robô e também, o
uso de processamento digital de imagens, para obter a visão robótica.
Neste sentido, faz-se valer que para a situação aqui apresentada
será usado o motor de passo para a movimentação do robô uma vez que
seu manuseio é de maior confiabilidade, e praticidade e ainda, não será
feito o uso de técnicas de controle inteligente e nem de controladores uma
vez que o controle do robô vai ser feito pelo software a ser desenvolvido
neste estudo necessitando da interação do usuário para o controle do
braço robótico.
O domínio destas técnicas, acrescido do conhecimento do próximo
capítulo vão servir como base de conhecimento necessário para a
construção de um software para o controle de um braço robótico.
16
3 – Técnicas para o Posicionamento de robôs
Este capítulo é composto pela descrição de técnicas usadas para o
cálculo do deslocamento de um robô. Usando conceitos de cinemática
pertencentes à física, é feita a descrição de como os usar para se obter o
deslocamento robótico. Sendo assim, tópicos como cinemática direta,
cinemática inversa, cálculo de coeficientes de Denavit–Hartenberg e ainda
cálculo de coordenadas, serão aqui expostos.
3.1 – Cinemática Direta e Inversa
A cinemática é o estudo dos movimentos dos corpos sem levar em
conta as forças que o provocam.
O problema da Cinemática Direta de robôs consiste em determinar
a posição final do efetuador conhecendo os ângulos entre as juntas.
No problema da Cinemática Inversa, os ângulos devem ser
determinados em função da posição final do efetuador no espaço. Esta
situação pode levar a condição de existência de zero, uma ou muitas
soluções, dependendo do:
•
Número de juntas utilizadas.
•
Tamanho dos elos.
•
Tipos de juntas.
17
3.2 – Coeficientes de Denavit e Hartenberg (DH)
A notação de Denavit - Hartenberg é uma ferramenta utilizada para
sistematizar a descrição cinemática de sistemas mecânicos articulados
com
N
graus
de
liberdade
[8].
Nesta
técnica,
são
utilizadas
transformações de rotação de coordenadas para determinar uma matriz
de transformação da posição final do robô no espaço. [9]
Figura 3.1 – Notação de Denavit e Hartenberg [9]
Estes eixos de juntas devem ter duas normais conectadas neles,
uma para cada um dos elos. A posição relativa destes dois elos
conectados (elo i-1 e elo i) é dada por d i , que é a distância medida ao
longo do eixo da junta entre suas normais.
O ângulo de junta θ i entre as normais é medido em um plano
normal ao eixo da junta. Assim, d i e θ i podem ser chamados
18
respectivamente de distância e ângulo entre elos adjacentes. Eles
determinam a posição relativa de elos vizinhos.
Um elo i poderá estar conectado, no máximo a dois outros elos (elo
i-1 e elo i+1). Assim, dois eixos de junta são estabelecidos em ambos
terminais de conexão. O significado dos elos, do ponto de vista
cinemático, é que eles mantêm uma configuração fixa entre suas juntas
que podem ser caracterizadas por dois parâmetros: ai e α i .
O parâmetro ai é a menor distância medida ao longo da normal
comum entre os eixos de junta (isto é, os eixos z i −1 e z i para a junta i e
junta i+1, respectivamente) Assim, ai e α i , podem ser chamados
respectivamente, comprimento e ângulo de twist (torção) do elo i. Eles
determinam a estrutura do elo i.
Assim sendo, quatro parâmetros: ai , α i , d i e θ i são associados
com cada elo do manipulador. No momento em que se estabelece uma
convenção de sinais para cada um destes parâmetros, estes constituem
um conjunto suficiente para determinar a configuração cinemática de cada
elo do manipulador e, podendo observar que estes quatro parâmetros
aparecem em pares:
•
( ai , α i ) que determinam a estrutura do elo e os parâmetros
da junta.
•
( d i , θ i ) que determinam a posição relativa de elos vizinhos.
Para descrever a translação e rotação entre dois elos adjacentes,
Denavit
e
Hartenberg
propuseram
um
método
matricial
para
19
estabelecimento sistemático de um sistema de coordenadas fixas para
cada elo de uma cadeia cinemática articulada. [9]
A representação de Denavit - Hartenberg (DH) resulta na obtenção
de uma matriz de transformação homogênea 4 X 4, representando cada
sistema de coordenadas do elo na junta, em relação ao sistema de
coordenadas do elo anterior, sendo esta transformação composta por:
1 - Rotação θ i ao redor do eixo z i −1 ;
2 - Translação d i ao longo do eixo z i −1 ;
3 - Translação ai ao a longo de eixo xi ;
4 - Rotação de α i ao redor do eixo xi ;
eq. 3.1
Ai = Rot (z , θ )Trans ( z , d )Trans (x, a )Rot ( x, α )
⎡cθ
⎢ sθ
Ai = ⎢
⎢ 0
⎢
⎣ 0
− sθ
0
cθ
0
0
1
0
0
0 ⎤ ⎡1
0 ⎥⎥ ⎢⎢ 0
0 ⎥ ⎢0
⎥⎢
1 ⎦ ⎣0
0
0
1
0
0
1
0
0
0 ⎤ ⎡1
0 ⎥⎥ ⎢⎢ 0
d ⎥ ⎢0
⎥⎢
1 ⎦ ⎣0
0
0
1
0
0
1
0
0
a ⎤ ⎡1
0 ⎥⎥ ⎢⎢ 0
0 ⎥ ⎢0
⎥⎢
1 ⎦ ⎣0
0
0
cα
sα
− sα
cα
0
0
0⎤
0 ⎥⎥
0⎥
⎥
1⎦
Figura 3.2 – Multiplicação das Matrizes Intermediárias (DH)
Assim, a partir de transformações sucessivas, podem ser obtidas
as coordenadas do elemento terminal de um robô (último elo), expressas
matematicamente no sistema de coordenadas fixas à base. [9]
⎡cos θ i
⎢ senθ
i
Ai = ⎢
⎢ 0
⎢
⎣ 0
− senθ i cos α i
cos θ i cos α i
senθ i senα i
− cos θ i senα i
senα i
0
cos α i
0
ai cos θ i ⎤
ai senθ i ⎥⎥
di ⎥
⎥
1 ⎦
Figura 3.3 – Matriz (DH) [9]
20
A representação DH de um elo rígido dependerá de quatro
parâmetros associados a este elo. Estes parâmetros descrevem
completamente o comportamento cinemático de uma junta prismática ou
revoluta. Estes quatro parâmetros são definidos a seguir:
•
θ i é o angulo de junta obtido entre os eixos xi −1 e xi no eixo
z i −1 .
•
d i é a distância entre a origem do (i-1)-ésimo sistema de
coordenadas até a interseção do eixo z i −1 com o eixo xi ao
longo do eixo z i −1 .
•
ai é a distância (off-set) entre a interseção do eixo z i −1 com
o eixo xi até a origem o i-ésimo sistema de referência ao
longo do eixo xi (ou a menor distância entre os eixos z i −1 e
z i ).
•
α i é o ângulo off-set entre os eixos z i −1 e z i medidos no
eixo xi . [9]
Para uma junta rotacional, d i , ai , e α i são os parâmetros da junta,
variando o seu valor na rotação do elo i em relação ao elo i-1. Para uma
junta prismática, θ i , ai e α i são os parâmetros da junta, enquanto d i é a
variável de junta (deslocamento linear). [9]
21
3.3 – Coordenadas
Figuras 3.4 – Coordenadas do Robô. [9]
Assim sendo, um sistema de coordenadas cartesianas ortogonal
( xi , y i , z i ) pode ser estabelecido para cada elo no seu eixo de junta,
onde i= 1, 2, . . , N (N número de graus de liberdade) mais o sistema de
coordenadas da base. Assim, uma junta rotacional tem somente 1 grau de
liberdade, e cada sistema de coordenadas ( xi , y i , z i ) do braço do robô
corresponde a junta i+1, sendo fixo no elo i. [9]
Quando o acionador ativa a junta i, o elo i deve mover-se com
relação ao elo i-1. Assim, o i-ésimo sistema de coordenadas é solidário ao
elo i, se movimentando junto com o mesmo. Assim, o i-ésimo sistema de
coordenadas se movimentará com o elemento terminal (elo n). As
coordenadas da base são definidas como o sistema de coordenadas 0
( x0 , y 0 , z 0 ), também chamado de sistema de referência inercial. Os
sistemas de coordenadas são determinados e estabelecidos obedecendo
três regras:
1 - O eixo z i −1 é colocado ao longo do eixo de movimento da junta i.
22
2 - O eixo xi é normal ao eixo z i −1 , e apontando para fora dele.
3 - O eixo y i completa o sistema utilizando a regra da mão direita.
Através destas regras observa - se que:
1 - A escolha do sistema de coordenadas é livre, podendo ser
colocada em qualquer parte da base de suporte, enquanto que a posição
do eixo z 0 , deverá ser a do eixo de movimento da primeira junta.
2 - O último sistema de coordenadas (i-ésimo) pode ser colocado
em qualquer parte do elemento terminal, enquanto que o eixo xi é normal
ao eixo z i −1 . [9]
3.4 – Conclusão
Este
capítulo
expôs
técnicas
importantes
relacionadas
ao
posicionamento de um braço robótico no espaço, como os conceitos de
Cinemática, coeficientes de Denavit-Hartenberg, e ainda uma visão sobre
como manipular, lidar com as coordenadas do ponto a ser movimentado.
Sendo assim, o uso dos coeficientes de Denavit-Hartenberg torna a
parte de cálculos mais prática, uma vez que, exige do leitor apenas o
conhecimento básico de algumas regras de trigonometria para que sejam
feitos os cálculos referentes ao posicionamento do robô.
O conteúdo deste capítulo acrescido ao conteúdo do capítulo
anterior habilita à produção do próximo capítulo expondo um estudo de
caso
onde
coloca
em
prática
as
teorias
aqui
mostradas,
o
desenvolvimento dos cálculos e a produção do software para o controle
do braço robótico.
23
4 – Estudo de Caso
Neste capítulo é apresentado o estudo de caso deste trabalho,
formado
pela
apresentação
dos
cálculos
necessários
para
o
posicionamento de um robô no espaço e também, do código fonte do
programa que aplica os cálculos aqui desenvolvidos para movimentar o
braço.
4.1 – Cálculo da Cinemática Direta
No cálculo da cinemática direta, os ângulos de movimentação do
robô são conhecidos, sendo então necessário fazer o calculo da posição
final do articulador, ou seja, é necessário fazer o cálculo das coordenadas
X, Y e Z do respectivo ponto, em função de θ 1 , θ 2 e θ 3 .
Para isso, é tomado como base a tabela dos coeficientes DH e
então, são feitos alguns cálculos de multiplicações de matrizes para que
se possa chegar às 3 coordenadas X, Y, Z.
Tabela 4.1 - Coeficientes Denavit-Hartenberg (DH)
Elo
1
α
90º
2
3
θ
θ1
a
12 cm
d
d1
0º
θ2
26 cm
d2
0º
θ3
18 cm
d3
Sendo Α i , a matriz genérica proposta por Denavit-Hartenberg,
24
atribui-se a cada elo do robô, uma matriz contendo seus parâmetros e
coeficientes:
⎡cos θ i
⎢ senθ
i
Αi = ⎢
⎢ 0
⎢
⎣ 0
− cos α i senθ i
cos α i cos θ i
senα i
0
senα i senθ i
− senα i cos θ i
cos α i
0
ai cos θ i ⎤
ai senθ i ⎥⎥
di ⎥
⎥
1 ⎦
Figura 4.1 – Matriz DH
então, tem – se Α1 , Α 2 e Α 3 respectivamente:
⎡cos θ 1
⎢ sen θ
1
Α1 = ⎢
⎢ 0
⎢
⎣ 0
− cos α 1 sen θ 1
cos α 1 cos θ 1
sen α 1
0
sen α 1 sen θ 1
− sen α 1 cos θ 1
cos α 1
0
a1 cos θ 1 ⎤
a1 sen θ 1 ⎥⎥
d1 ⎥
⎥
1
⎦
Figura 4.2 – Matriz DH do elo 1
⎡cos θ 2
⎢ senθ
2
Α2 = ⎢
⎢ 0
⎢
⎣ 0
− cos α 2 senθ 2
cos α 2 cos θ 2
senα 2
0
senα 2 senθ 2
− senα 2 cos θ 2
cos α 2
0
a 2 cos θ 2 ⎤
a 2 senθ 2 ⎥⎥
d2 ⎥
⎥
1
⎦
Figura 4.3 – Matriz DH do elo 2
⎡cos θ 3
⎢ sen θ
3
Α3 = ⎢
⎢ 0
⎢
⎣ 0
− cos α 3 sen θ 3
cos α 3 cos θ 3
sen α 3
0
sen α 3 sen θ 3
− sen α 3 cos θ 3
cos α 3
0
a 3 cos θ 3 ⎤
a 3 sen θ 3 ⎥⎥
d3 ⎥
⎥
1
⎦
Figura 4.4 – Matriz DH do elo 3
Do resultado de Α1 x Α 2 tem – se Τ12 :
25
(cθ1 (− cα 2 sθ 2 )) +
(cθ1 (sα 2 sθ 2 )) +
(cθ1a 2 cθ 2 ) + ⎤
((− cα1sθ1 )(cα 2 cθ 2 )) + ((− cα1sθ1 )(− sα 2 cθ 2 )) + ((− cα1sθ1 )(a 2 sθ 2 )) + ⎥⎥
((sα1sθ1 )sα 2 )
((sα1sθ1 )cα 2 )
((sα1sθ1 )d 2 ) + (a1cθ1 )⎥⎥
(sθ1a 2 cθ 2 ) + ⎥
(sθ1 (sα 2 sθ 2 )) +
(sθ1 (− cα 2 sθ 2 )) +
((cα1cθ1 )(a 2 sθ 2 )) + ⎥⎥
((cα1cθ1 )(cα 2 cθ 2 )) + ((cα1cθ1 )(− sα 2 cθ 2 )) + ((
− sα 1cθ1 )d 2 ) + ⎥
((− sα1cθ1 )cα 2 )
((− sα1cθ1 )sα 2 )
⎥
(a1sθ1 )
⎥
(sα1 (cα 2 cθ 2 )) +
(sα1 (− sα 2 cθ 2 )) +
(sα1a 2 sθ 2 ) + ⎥
⎥
(cα1sα 2 )
(cα1cα 2 )
(cα1d 2 ) + d1 ⎥
⎡
⎢ (cθ1cθ 2 ) +
⎢((− cα sθ )sθ )
1 1 2
⎢
⎢
⎢
⎢ (sθ cθ ) +
2
1 2
Τ1 = ⎢
⎢ ((cα 1cθ1 )sθ 2 )
⎢
⎢
⎢
⎢
sα 1 sθ 2
⎢
0
⎣⎢
0
0
⎦⎥
1
Figura 4.5 – Matriz resultante Τ1
2
Sendo Τ23 o resultado de Τ12 x Α 3 , tem – se:
⎡
⎢
⎢
⎢
⎢
⎢ ⎛⎛ ( ) ⎞
⎟
⎢ ⎜ ⎜ ((
) )⎠
⎢ ⎝⎝
))
⎢⎛ ⎛ ( (
⎢ ⎜ ⎜ ((
)( ))
⎢ ⎜⎜ ⎜⎜
⎢ ⎝ ⎝ (( ) )
⎢
⎢
⎢
⎢
⎢
⎢
⎢
⎢
⎢
⎢ ⎛⎜ ⎛⎜ ( ) ⎞⎟
⎢ ⎝ ⎝ (( ) ) ⎠
⎢
⎞⎞
⎢ ⎛ ⎛ ⎛⎜ ⎛⎜
⎟⎟
⎠⎠
⎜
⎝ ⎝
⎜
⎢
⎞⎞
⎢ ⎜ ⎜ ⎛⎜ ⎛⎜ ⎞⎟ ⎛⎜
⎟⎟
⎠⎠
⎢ ⎜ ⎜ ⎝ ⎝ ⎠⎝
⎜
⎜
⎞ ⎞
⎢ ⎜ ⎜ ⎛⎜ ⎛⎜
⎟ ⎟
⎠ ⎠
⎢ ⎝⎝ ⎝⎝
⎢
⎢
⎢
⎢
⎢
⎢
(( ) )
⎢
⎢ ⎛⎜ ⎛⎜ ( ( )) ⎞⎟
⎢ ⎝⎝ ( ) ⎠
⎢
⎢
⎢⎣
+
cθ cθ
1 2
cθ
− cα sθ
1 1
cθ
sθ
+
− cα sθ
1 1
sα sθ
1 1
3
Τ2 =
2
− cα sθ
2 2
1
+
cα cθ
2 2
sα
3
1
cα cθ
1 1
− sα cθ
1 1
sα sθ
1 2
sα
1
+
+
cα cθ
2 2
cα sα
1 2
0
sα
2
cθ
⎞
⎟
⎠
⎞
⎟
⎟
⎟
⎟⎟
⎠
⎛
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎝
⎞
⎟
⎟
⎟
⎟
⎟
⎟
⎞
⎟ ⎛⎜
⎟
⎟⎜
⎟
⎟ + ⎟ ⎜ cα cθ
⎟⎝
3 3
⎠
⎟
⎟
⎟
⎟
⎟
⎟
⎠
⎛
⎛
⎞⎞
⎜
⎜
⎟⎟
⎜ cθ ⎜ − cα sθ ⎟ ⎟ +
⎜
⎜
⎟⎟
2 2 ⎠⎠
⎝ 1⎝
⎛
⎜
⎜
⎜
⎝
⎛
⎜
⎜ − cα sθ
⎜
⎝
1 1
⎛
⎜
⎜
⎜
⎝
⎞⎛
⎟⎜
⎟ ⎜ cα cθ
⎟⎜
⎠⎝
2 2
cθ
⎞
⎟
⎟
⎟
⎠
⎞
⎟
⎟
⎟
⎠
⎞
⎟
⎟ sα
⎟
⎠ 2
⎛
⎜
⎜ sα sθ
⎜
⎝ 1 1
− sα cθ
2 2
cα
⎞
⎟
⎟
⎟
⎠
⎞
⎟
⎟
⎟
⎠
+
sα sθ
2 2
1
+
2
⎛⎛ ( ) ⎞
⎜⎜
⎟(
⎝ ⎝ (( ) ) ⎠
)) ⎞
⎛⎛ ( (
⎜⎜
⎟
⎜ ⎜ (( )( )) ⎟ (
⎜ ⎜ ((
) ) ⎟⎠
⎝⎝
⎛ ⎛ ( ( ))
⎜⎜
))
⎜ ⎜ (( )(
⎜ ⎜ ((
) )
⎝⎝
+
sθ cθ
1 2
+
cα cθ
1 1
sθ
3
⎞
⎟
⎟
⎟
⎟⎟
⎠
sθ
sθ
− cα sθ
3 3
⎛
⎜
⎜
⎝
+
⎞
⎟
⎟
⎟
⎟
⎠
sα
3
− cα sθ
2 2
1
cα cθ
1 1
sθ
+
sα
cα cθ
3 3
2
+
sα sθ
2 2
1
− sα cθ
2 2
cα cθ
1 1
⎠
+
cα cθ
2 2
− sα cθ
1 1
)⎞⎟
2
− sα cθ
1 1
⎛
⎜
⎜
⎜
⎜
⎜
⎜⎛⎛
⎜⎜⎜
⎜⎜⎜
⎜⎜ ⎜ ⎝⎜
⎝⎝
⎞
⎟
⎟
⎟⎛
⎟⎜
⎟⎜
sα sθ
⎞ ⎟⎜
⎞
3 3
⎟ ⎟⎝
⎟
⎟
− cα sθ ⎟ sθ ⎟⎟ ⎟
⎟
1 1 ⎠ 2 ⎠ ⎟⎠
⎛
⎜
⎜ cθ cθ
⎜
⎝ 1 2
⎞
⎟
⎟ +
⎟
⎠
⎞
⎟
⎟
⎟
⎠
⎛
⎜
⎜
⎜
⎜
⎝
⎛ ⎛ ( ( ))
⎜⎜
)(
))
⎜ ⎜ ((
⎜ ⎜ (( ) )
⎝⎝
⎛
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎜
⎝
+
⎞
⎟
⎟
⎟
⎠
⎞
⎟
⎟
⎠
+
⎞
⎟
⎟
⎟
⎟
⎟
⎟
⎞
⎟ ⎛⎜
⎟
⎟⎜
⎟
⎟ + ⎟ ⎜ − sα cθ
⎟⎝
3 3
⎠
⎟
⎟
⎟
⎟
⎟
⎟
⎠
⎛
⎜
⎜
⎜
⎝
⎛
⎜
⎜ − cα sθ
⎜
⎝
1 1
⎛
⎜
⎜
⎜
⎝
⎞⎛
⎟⎜
⎟ ⎜ cα cθ
⎟⎜
⎠⎝
2 2
cθ
⎞
⎟
⎟
⎟
⎠
⎞
⎟
⎟ sα
⎟
⎠ 2
⎛
⎜
⎜ sα sθ
⎜
⎝ 1 1
⎞
⎟
⎟
⎟
⎠
+
sα sθ
2 2
1
− cα sθ
1 1
− sα cθ
2 2
sα sθ
1 1
cα
+
2
⎞
⎟
⎟
⎟
⎠
⎞
⎟
⎟
⎟
⎠
cα
⎞
⎟
⎟
⎟
⎟
⎠
⎞
⎟
⎟
⎟
⎠
− cα sθ
2 2
1
− cα sθ
1 1
cθ
sα
cα
2
+
⎞
⎟
⎟
⎟
⎠
sα
3
⎛⎛ (
⎜⎜
⎝ ⎝ ((
+
) ⎞
⎞
⎟ ( )⎟
) )⎠
⎠
)) ⎞
⎛⎛ ( (
⎞
⎜⎜
⎟
⎟
)⎟
⎜ ⎜ (( )( )) ⎟ (
⎜ ⎜ ((
⎟
) ) ⎟⎠
⎝⎝
⎠
⎛ ⎛ ( ( ))
⎞ ⎞
⎜⎜
⎟ ⎟
(
(
)(
)
)
⎜⎜
⎟ ⎟
⎟ ⎟
⎜ ⎜ ((
)
)
⎝
⎠ ⎠
⎝
1
cα cθ
1 1
⎞
⎟
)⎟
⎟
⎠
⎞
⎟
⎟
⎟
⎠
sθ
+
sθ
− sα cθ
2 2
cα
cα cθ
1 1
+
sθ
− sα cθ
3 3
sα
2
+
sα sθ
2 2
1
− sα cθ
2 2
cα cθ
1 1
+
− sα cθ
1 1
cα
cα
3
2
+
sθ
((
+
sθ
3
⎞
⎟
⎠
)( ))
⎛ ⎛ ( ( )) ⎞
⎞
⎜⎜
⎟ ( )⎟
⎝⎝ ( ) ⎠
⎠
sα
((
1
sα sθ
1 2
− cα sθ
3 3
((
+
+
cα cθ
2 2
cα cθ
3 3
cα sα
1 2
sα
+
))
⎛
⎛
⎞
⎛
⎞⎞
⎜
⎜
⎟
⎜
⎟⎟
⎜⎜ sα ⎜ − sα cθ ⎟ ⎟⎟ + ⎜ cα cα ⎟ sα
⎝ 1 2 ⎠
2 2 ⎠⎠
3
⎝ 1⎝
0
⎛⎛( (
⎜⎜
⎝⎝ (
((
1
)( ))
)) ⎞
⎟(
) ⎠
sα sθ
1 2
cα cθ
2 2
cα sα
1 2
sα sθ
3 3
+
− sα cθ
3 3
)⎞⎟
⎠
))
⎛
⎛
⎞
⎛
⎞⎞
⎜
⎜
⎟
⎜
⎟⎟
⎜⎜ sα ⎜ − sα cθ ⎟ ⎟⎟ + ⎜ cα cα ⎟ cα
⎝ 1 2 ⎠
2 2 ⎠⎠
3
⎝ 1⎝
0
+
sα
+
2
cα
cα cθ
1 1
sα sθ
1 2
1
cα cθ
2 2
cα sα
1 2
((
+
d
+
a sθ
2 2
+
)( ))
)) ⎞
⎞
⎟ ( )⎟
) ⎠
⎠
d
+
2
a cθ
3 3
a sθ
1 1
+
+
a sθ
3 3
))
⎛
⎛
⎞
⎛
⎞⎞
⎜
⎜
⎟
⎜
⎟⎟
⎜⎜ sα ⎜ − sα cθ ⎟ ⎟⎟ + ⎜ cα cα ⎟ d
⎝ 1 2 ⎠ 3
2 2 ⎠⎠
⎝ 1⎝
((
sα a sθ
1 2 2
+
3
2
sθ a cθ
1 2 2
⎛⎛( (
⎜⎜
⎝⎝ (
+
a sθ
3 3
+
− sα cθ
1 1
sα
+
2
− sα cθ
2 2
cα cθ
1 1
+
a cθ
3 3
sθ
sα sθ
2 2
1
+
a cθ
1 1
cα cθ
2 2
((
+
+
2
− cα sθ
2 2
1
+
3
+
− sα cθ
1 1
+
cα cθ
2 2
− sα cθ
1 1
sθ
d
+
a sθ
2 2
d
cα cθ
1 1
cα cθ
1 1
+
2
cθ a cθ
1 2 2
2
− cα sθ
2 2
1
+
− cα sθ
1 1
+
sα sθ
3 3
a sθ
3 3
2
sα sθ
1 1
+
sθ cθ
1 2
+
sα sθ
2 2
− cα sθ
1 1
3
+
+
cα cθ
2 2
sα sθ
1 1
+
⎞
⎟
⎟
⎠
⎞
⎟
⎟
⎟
⎠
)) ⎞
⎞
⎛⎛ ( (
⎟
⎜⎜
⎟
(
(
)(
)
)
(
)
⎟
⎜⎜
⎟
⎟
⎜ ⎜ (( ) ) ⎟
⎠
⎠
⎝⎝
⎞
⎛ ⎛ ( ( ))
⎞
⎜⎜
⎟ ⎟
(
(
)(
)
)
⎜⎜
⎟ ⎟
⎜ ⎜ (( ) ) ⎟ ⎟
⎠ ⎠
⎝⎝
)
⎛ (
⎞
⎜
⎟
(
(
)(
)
)
⎜
⎟
⎜ (( ) ) ( ) ⎟
⎝
⎠
⎞
⎛⎛ ( ) ⎞
⎜⎜
⎟ ( )⎟
⎠
⎝ ⎝ (( ) ) ⎠
)) ⎞
⎛⎛ ( (
⎞
⎜⎜
⎟
⎟
(
)
(
(
)(
)
)
⎜⎜
⎟
⎟
⎟
⎜ ⎜ ((
⎟
)
)
⎠
⎝⎝
⎠
⎛ ⎛ ( ( ))
⎞ ⎞
⎜⎜
⎟ ⎟
)) ⎟ ⎟
⎜ ⎜ (( )(
⎟ ⎟
⎜ ⎜ ((
) )
⎠ ⎠
⎝⎝
(
)
⎛
⎞
⎜
⎟
(
(
)(
)
)
⎜
⎟
⎜ ((
) ) ( ) ⎟⎠
⎝
cθ
⎛
⎛
⎞⎞
⎜
⎜
⎟⎟
⎜ cθ ⎜ − cα sθ ⎟ ⎟ +
⎜
⎜
⎟⎟
2 2 ⎠⎠
⎝ 1⎝
⎞
⎟
⎟ +
⎟
⎠
− sα cθ
1 1
+
3
⎛
⎜
⎜
⎜
⎜
⎝
⎛ ⎛ ( ( ))
⎜⎜
)(
))
⎜ ⎜ ((
⎜⎜
(( ) )
⎝⎝
⎞
⎟
⎟
⎠
⎞
⎟
⎟
⎟
⎠
⎞
⎟
⎟
⎟⎛
⎟⎜
⎟⎜
a cθ
⎞ ⎟⎜
⎞
⎟ ⎟⎝ 3 3
⎟
⎟
− cα sθ ⎟ sθ ⎟⎟ ⎟
⎟
1 1 ⎠ 2 ⎠ ⎟⎠
⎛
⎜
⎜ cθ cθ
⎜
⎝ 1 2
sθ cθ
1 2
3
cα cθ
2 2
⎞
⎟
⎟ +
⎟
⎠
⎛
⎜
⎜
⎜
⎜
⎜
⎜⎛⎛
⎜⎜⎜
⎜⎜⎜
⎜⎜ ⎜ ⎜
⎝⎝⎝
sα sθ
1 1
2
− cα sθ
2 2
sθ
3
⎞
⎟
⎟
⎟
⎠
⎞
⎟
⎟
⎟⎛
⎟⎜
⎟⎜
− cα sθ
⎞ ⎟⎜
⎞
3 3
⎟ ⎟⎝
⎟
⎟
− cα sθ ⎟ sθ ⎟⎟ ⎟
⎟
1 1 ⎠ 2 ⎠ ⎟⎠
⎛
⎜
⎜ cθ cθ
⎜
⎝ 1 2
sα sθ
1 1
cθ
sθ
+
⎛
⎜
⎜
⎜
⎜
⎜
⎜⎛⎛
⎜⎜⎜
⎜⎜⎜
⎜⎜ ⎜ ⎝⎜
⎝⎝
− cα sθ
1 1
+
cα cθ
1 1
⎞
⎟
⎠
⎞
⎟
⎟
⎟
⎠
sθ
2
sθ cθ
1 2
⎛
⎜
⎜
⎝
⎛
⎜
⎜
⎝
+
+
) ( ) )
+
cα d
1 2
+ d
1
1
Figura 4.6 – Matriz resultante Τ2
3
26
+
⎤
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥
⎥⎦
Aplicando valores dos respectivos ângulos α i conforme a tabela
DH à matriz Τ23 acima, obtém-se o resultado:
⎡
⎢ (cθ1cθ 2 )cθ3 +
⎢
⎢ cθ (−sθ )sθ
2 3
⎢ 1
⎢
⎢
⎢ (sθ1cθ 2 )cθ3 +
⎢
Τ23 = ⎢ ⎛⎜ sθ ⎛⎜ −sθ ⎞⎟ ⎞⎟sθ
2 ⎠⎠ 3
⎢ ⎝ 1⎝
⎢
⎢
⎢ (sθ 2 )cθ3 +
⎢
(cθ2 )sθ3
⎢
⎢
⎢
0
⎣
(
(
)
(
)
(
(
(
((cθ1cθ2 )(−cα3sθ3 ))+
(cθ1(−sθ2 ))cθ3
)
)
sθ1
((sθ1cθ2 )(−sθ3 ))+
((sθ1(−sθ2 ))(cθ3 ))
cθ1
((sθ2 )(−sθ3 ))+
(( cθ2 )(cθ3 ))
0
0
0
)
)
⎛
⎜
⎜
⎜⎜
⎝
⎞
⎟
⎟
⎟⎟
⎠
(cθ1cθ2 )(a3cθ3 )+ ⎤
⎥
(cθ1(−sθ2 ))(a3sθ3 )+ ⎥
⎥
((cθ1a 2cθ2 )+(a1cθ1))⎥⎥
((sθ1cθ2 )(a3cθ3 ))+ ⎥
⎥
((sθ1(−sθ2 ))(a3sθ3 ))+⎥
⎥
((sθ1a 2cθ2 )+(a1sθ1)) ⎥⎥
((sθ2 )(a3cθ3 ))+ ⎥
⎥
(cθ2 (a3sθ3 ))+ ⎥
⎥
⎥
(a 2sθ2 )
1
⎥
⎦
Figura 4.7 – Matriz resultante Τ2 (Simplificada)
3
Sendo:
senθi = si
eq. 4.1
cosθi = ci
eq. 4.2
sen(θ1 + θ 2 ) = s12
eq. 4.3
cos(θ1 + θ 2 ) = c12
eq. 4.4
considerações de simplificação e representação de operações, a partir
dos elementos a14 , a24 , a34 da matriz acima, tem-se então os pontos x, y e
z finais necessários para a movimentação do robô pelo método da
Cinemática Direta, são eles:
px = c1 (c23 + c23a3 + c2 a2 + a1 )
eq. 4.5
p y = s1 (c 23 + c 23 a 3 + c 2 a 2 + a1 )
eq. 4.6
pz = s23 + s23a3 + s2 a2
eq. 4.7
27
4.2 – Cálculo da Cinemática Inversa
Para o uso da técnica da Cinemática Inversa, os valores de x, y e z
do ponto a ser alcançado, são conhecidos, fazendo-se necessário o
cálculo dos ângulos que, uma vez aplicados aos elos posicionará o
manipulador nas coordenadas x, y e z do ponto desejado.
A resolução não é sistemática e, depende da configuração de cada
robô, podendo ainda, existir múltiplas soluções.
Para a obtenção dos ângulos, é feito o equacionamento dos
elementos a14 , a 24 e a34 da matriz resultante Τ23
px = c1 (c23 + c23a3 + c2 a2 + a1 )
eq. 4.8
p y = s1 (c 23 + c 23 a 3 + c 2 a 2 + a1 )
eq. 4.9
pz = s23 + s23a3 + s2 a2
eq. 4.10
para então, poder isolar os ângulos θ1 , θ 2 e θ3 .
Elegendo o elemento a34 da matriz resultante Τ32 , obtém-se a
equação:
s1 px − c1 p y = 0
eq. 4.11
⎞
⎟⎟
⎠
eq. 4.12
Tem-se então θ1 :
⎛ py
⎝ px
θ1 = arctg ⎜⎜
Elegendo os elementos a14 e a 24 da matriz resultante Τ32 , e
equacionando-os simultaneamente, obtém-se a equação:
28
c1 px + s1 p y = c23 + c23a3 + c2 a2
eq. 4.13
pz = s23 + s23a3 + s2 a2
eq. 4.7
px' = c1 px + s1 p y − c23
eq. 4.14
p 'y = p z − s23
eq. 4.15
Fazendo:
Substituindo pz tem-se:
px' = c23a3 + c2 a2
eq. 4.16
p 'y = s23a3 + s2 a2
eq. 4.17
Racionalizando ambas as equações e adicionando seus termos,
tem-se:
2
c3 =
2
px' + p 'y − a32 − a22
2a2 a3
eq. 4.18
Uma vez que pode-se ter θ3 do arco cosseno, é obtido o valor de
s3 e o aplica normalmente na rotina tangente:
(
s3 = ± 1 − c32
)
eq. 4.19
onde, por substituição, encontra-se o valor de θ 3 que é dado por:
29
⎛ s3 ⎞
⎟⎟
c
⎝ 3⎠
θ 3 = arctg ⎜⎜
eq. 4.20
Equacionando simultaneamente as equações 4.20 e 4.21, obtém se:
s2 =
(c3a3 + a2 ) p 'y − s3a3 px'
(c3a3 + a2 )2 + s32a32
eq. 4.21
c2 =
(c3a3 + a2 ) px' + s3a3 p 'y
(c3a3 + a2 )2 + s32a32
eq. 4.22
Como os denominadores são iguais e ambos positivos, é então
obtido θ 2 :
⎛ (c3 a3 + a 2 ) p 'y − s3 a3 p x'
θ 2 = arctg ⎜
⎜ (c a + a ) p ' + s a p '
2
3 3 y
x
⎝ 3 3
⎞
⎟
⎟
⎠
eq. 4.23
4.3 – Desenvolvimento do Software para o controle do braço robótico
Diante das técnicas, métodos, cálculos e coeficientes neste
trabalho apresentados e estudados, torna-se possível a construção de um
software para a manipulação do braço robótico.
Este software aqui apresentado está implementado na linguagem
C++, usando, como ambiente de programação o Visual C.Net da
Microsoft, possuindo uma interface gráfica, para entrada de dados e
interação usuário/robô onde são inseridos os ângulos, ou as coordenadas
finais do ponto que se deseja alcançar.
30
Figura 4.8 – Tela Principal
Figura 4.9 – Tela Cinemática Direta
31
Figura 4.10 – Tela Cinemática Inversa
A seguir, são apresentados os códigos fontes das seguintes
classes, Robo, Motor e PortaParalela. Uma vez que, são implementadas
usando o conceito de orientação a objeto estas classes são divididas em
dois arquivos: um sendo de terminação .h contendo a declaração dos
tipos de acesso do método e o tipo do retorno de cada método e também,
um arquivo com a terminação .cpp contendo a implementação dos
métodos declarados em seu respectivo arquivo .h.
A classe Robo é a classe principal da aplicação, é a responsável
por controlar as outras duas classes, Motor e PortaParalela, onde
instancia 3 classes Motor, uma vez que o robô que se deseja controlar
possui 3 motores e ainda uma classe PortaParalela para fazer a
comunicação do computador com o robô. As seqüências S são relativas
aos motores sendo que cada tipo de motor tem uma seqüência de
acionamento diferente. Sendo também, de responsabilidade desta classe
o cálculo dos coeficientes tanto da cinemática direta, as coordenadas do
32
ponto P(x, y, z), quanto da cinemática inversa, θ1 , θ 2 e θ 3 .
#if
!defined(AFX_ROBO_H__AC9D3DCF_EF54_4400_B690_0C18A76A2330__INCLUDED_)
#define AFX_ROBO_H__AC9D3DCF_EF54_4400_B690_0C18A76A2330__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "motor.h"
#include "portaparalela.h"
#define Esquerda 0
#define Direita 1
class Robo
{
public:
Robo();
virtual ~Robo();
private:
PortaParalela P;
Motor M1(), M2(), M3();
int S1[8], S2[8], S3[8];
float Teta1, Teta2, Teta3;
void acionaMotor();
void setS3();
void setS2();
void setS1();
};
#endif
//
!defined(AFX_ROBO_H__AC9D3DCF_EF54_4400_B690_0C18A76A2330__INCLUDED_)
Figura 4.11 – Implementação da classe Robo – Robo.h
33
#include "stdafx.h"
#include "Prj_Mono_Robo.h"
#include "robo.h"
#include <math.h>
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
Robo::Robo(): M1(25,9), M2(25,9), M3(25,9), A1(12), A2(26), A3(18),
a_um(0), a_dois(0), a_tres(0)
{
setS1();
setS2();
setS3();
}
Robo::~Robo()
{
}
void Robo::setS1()
{
S1[0] = 0x0a;
S1[1] = 0x02;
S1[2] = 0x06;
S1[3] = 0x04;
S1[4] = 0x05;
S1[5] = 0x01;
S1[6] = 0x09;
S1[7] = 0x08;
}
void Robo::setS2()
{
S1[0] = 0x0a;
S1[1] = 0x02;
S1[2] = 0x06;
34
S1[3] = 0x04;
S1[4] = 0x05;
S1[5] = 0x01;
S1[6] = 0x09;
S1[7] = 0x08;
}
void Robo::setS3()
{
S1[0] = 0x0a;
S1[1] = 0x02;
S1[2] = 0x06;
S1[3] = 0x04;
S1[4] = 0x05;
S1[5] = 0x01;
S1[6] = 0x09;
S1[7] = 0x08;
}
void Robo::acionaMotor(double teta1, double teta2, double teta3)
{
if(teta1 < 0)
P.acionaMotor(M1.calculaPassos(teta1),S1,Esquerda);
if(teta1 > 0)
P.acionaMotor(M1.calculaPassos(teta1),S1,Direita);
if(teta2 < 0)
P.acionaMotor(M2.calculaPassos(teta2),S2,Esquerda);
if(teta2 > 0)
P.acionaMotor(M2.calculaPassos(teta2),S2,Direita);
if(teta3 < 0)
P.acionaMotor(M3.calculaPassos(teta3),S3,Esquerda);
if(teta3 > 0)
P.acionaMotor(M3.calculaPassos(teta3),S3,Direita);
}
double Robo::calculaPx(double teta1, double teta2, double teta3)
{
double p_x;
p_x = cos(teta1) * ( (cos(teta2) + cos(teta3)) + ( (cos(teta2) + cos(teta3)) * A3 ) + (
cos(teta2) * A2) + A1);
35
return p_x;
}
double Robo::calculaPy(double teta1, double teta2, double teta3)
{
double p_y;
p_y = sin(teta1) * ( (cos(teta2) + cos(teta3)) + ( (cos(teta2) + cos(teta3)) * A3) +
(cos(teta2) * A2) + A1);
return p_y;
}
double Robo::calculaPz(double teta1, double teta2, double teta3)
{
double p_z;
p_z = ( (sin(teta2) + sin(teta3)) + ( (sin(teta2) + sin(teta3)) * A3) + (sin(teta2) * A2));
return p_z ;
}
double Robo::calculaTeta1(double pontoX, double pontoY)
{
double teta_1;
teta_1 = atan(pontoX / pontoY);
return teta_1;
}
double Robo::calculaTeta2(double pontoX, double pontoY)
{
double teta_2;
teta_2 = atan( ( ( ( (pow(pontoX,2) + pow(pontoY,2) - pow(A2, 2) - pow (A3, 2)) / (2 *
A2 * A3)) * A3) + A2) * pontoY ) - (((sqrt(1 - pow(((pow(pontoX,2) + pow(pontoY,2) pow(A2, 2) - pow (A3, 2)) / (2 * A2 * A3)),2))) * (A3) * (pontoX))) /
( ( ( ( (pow(pontoX,2) + pow(pontoY,2) - pow(A2, 2) - pow (A3, 2)) / (2 * A2 *
A3)) * A3) + A2) * pontoX ) - (((sqrt(1 - pow(((pow(pontoX,2) + pow(pontoY,2) - pow(A2, 2) pow (A3, 2)) / (2 * A2 * A3)),2))) * (A3) * (pontoY)));
return teta_2;
}
double Robo::calculaTeta3(double pontoX, double pontoY)
{
double teta_3;
teta_3 = atan(sqrt(1 - pow( ( (pow(pontoX,2) + pow(pontoY,2) - pow(A2, 2) - pow
(A3, 2)) / (2 * A2 * A3)),2)) / ( (pow(pontoX,2) + pow(pontoY,2) - pow(A2, 2) - pow (A3, 2) ) /
(2 * A2 * A3) ) );
return teta_3;
}
Figura 4.12 – Implementação da classe Robo – Robo.cpp
36
A classe Motor é responsável por fazer o cálculo de adequação das
características do motor de acordo com a especificação do fabricante,
onde calcula a relação entre o número de passos e a quantidade de
graus.
#if
!defined(AFX_MOTOR_H__D90761E9_CA94_430C_900A_4745757ABD33__INCLUDED_)
#define AFX_MOTOR_H__D90761E9_CA94_430C_900A_4745757ABD33__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <math.h>
class Motor
{
public:
int calculaPassos(float angulo);
Motor(int passos, int angulo);
virtual ~Motor();
private:
void setAnguloDefault(float angulo);
void setPassosDefault(int passos);
int PassosDefault;
float AnguloDefault;
};
#endif
//
!defined(AFX_MOTOR_H__D90761E9_CA94_430C_900A_4745757ABD33__INCLUDED_)
Figura 4.13 – Implementação da classe Motor – Motor.h
#include "stdafx.h"
#include "Prj_Mono_Robo.h"
#include "Motor.h"
#ifdef _DEBUG
37
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
// Construction/Destruction
Motor::Motor(int passos, double angulo): PassosDefault(0), AnguloDefault(0)
{
setPassosDefault(passos);
setAnguloDefault(angulo);
}
Motor::~Motor()
{
}
int Motor::calculaPassos(double angulo)
{
int passos;
double pas;
pas = (angulo*PassosDefault)/AnguloDefault;
if(pas <= (floor(pas)+0.5))
passos = (int)floor(pas);
else
passos = (int)ceil(pas);
return passos;
}
void Motor::setPassosDefault(int passos)
{
PassosDefault = passos;
}
void Motor::setAnguloDefault(double angulo)
{
AnguloDefault = angulo;
}
Figura 4.14 – Implementação da classe Motor – Motor.cpp
38
Na
classe
PortaParalela
faz-se
o
interfaceamento
entre
computador e o robô, onde através do número da porta especificada é
enviado os bits necessários para o acionamento do devido motor do robô.
#if
!defined(AFX_PORTAPARALELA_H__DD072B83_CD38_44D1_8A18_A84CB7B2B56B__I
NCLUDED_)
#define
AFX_PORTAPARALELA_H__DD072B83_CD38_44D1_8A18_A84CB7B2B56B__INCLUDE
D_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <conio.h>
class PortaParalela
{
public:
void acionaMotor(int passos, int sequencia[8], int sentido);
PortaParalela();
virtual ~PortaParalela();
private:
int Sequencia[8];
int Porta;
};
#endif
//
!defined(AFX_PORTAPARALELA_H__DD072B83_CD38_44D1_8A18_A84CB7B2B56B__I
NCLUDED_)
Figura 4.15 – Implementação da Classe Porta Paralela – PortaParalela.h
39
#include "stdafx.h"
#include "Prj_Mono_Robo.h"
#include "PortaParalela.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
PortaParalela::PortaParalela(): Porta(0x378)
{
}
PortaParalela::~PortaParalela()
{
}
void PortaParalela::acionaMotor(int passos, int sequencia[8], int sentido)
{
for(int i=0; i<passos; i++)
{
if(sentido == 1)
{
for(int j=0; j<=6; j++)
_outp(Porta,sequencia[j]);
}
else
{
for(int j=6; j>=0; j--)
_outp(Porta,sequencia[j]);
}
}
limpaPorta();
}
void PortaParalela::limpaPorta(void)
{
_outp(Porta,0);
}
Figura 4.16 – Implementação da Classe Porta Paralela – PortaParalela.cpp
40
4.4 – Conclusão
O desenvolvimento deste capítulo é de fundamental importância
para este documento uma vez que fez o uso de todos os conceitos aqui
mostrados.
Para que os resultados finais das coordenadas do ponto P(x, y, z),
e dos ângulos θ1 , θ 2 e θ3 fossem obtidos, foi feito o uso da trigonometria
para poder resolver os equacionamentos com ângulos e medidas relativas
aos elos do robô. O conhecimento desta área da matemática é de grande
valor para interessados em robótica uma vez que os cálculos são uma
regra, e erros de cálculo podem prejudicar o projeto, fazendo com que o
robô tenha reações não esperadas após a implementação dos cálculos.
De igual valor, tem-se o conhecimento em programação de
computadores, para que se possa desenvolver o software para o controle
do braço robótico. De acordo com a situação aqui apresentada foi usado
a plataforma Visual C .NET por ser uma ferramenta de fácil manuseio e
compreensão, possibilitando que se produza o código fonte em linguagem
C++ que é de grande portabilidade.
Neste
sentido,
o
conhecimento
matemático
associado
à
programação de computadores é o principal elo para que se possa
construir um robô e fazer sua respectiva movimentação.
No
capítulo
seguinte,
é
apresentado
um
relatório
do
desenvolvimento deste documento juntamente com sua conclusão.
41
5 – Conclusão
Com a eminente era tecnológica muitos conceitos e teorias
relacionados à informática foram criados, algumas teorias evoluiriam-se e
outras extinguiram-se. As primeiras por serem de grande utilidade à
humanidade já as segundas por sua ineficiência e pouca praticidade
comprovadas no dia a dia, foi então que neste universo também surgiu o
conceito de manipuladores que eram usados para trabalhar com materiais
de alto risco. Devido sua praticidade, operabilidade e eficiência
comprovadas e ainda, a popularização dos computadores este conceito
sofreu sua evolução passando a chamar-se Robótica.
As informações que são mostradas nesse documento deixam claro
que a teoria da robótica surgiu para ficar, sendo a mesma acessível e de
fácil entendimento, o que a torna cada vez mais presente tanto no
cotidiano das pessoas, em suas casas e serviços, quanto nas empresas,
em seus parques industriais, assim como visto em uma linha de produção
de automóveis.
Para que fosse possível a criação do software para o controle do
braço robótico, era necessário que primeiramente o braço existisse, sendo
então criado uma estrutura metálica na forma de um braço robótico onde,
sobre esta plataforma, seria criado o robô. Foi também, criado um circuitoimpresso contendo alguns resistores e algumas portas lógicas, visando
criar uma lógica de acionamento dos motores, para que, de acordo com o
42
comando
enviado
pelo
software,
os
motores
específicos
se
movimentassem gerando então o esperado movimento robótico.
Desejando controlar a movimentação do braço, foram usados os
coeficientes DH para fazer o cálculo de sua cinemática, sendo esta parte,
de grande contribuição para estudantes e interessados em robótica, onde
expõe as equações resultantes dos processos percorridos, eliminando
assim a necessidade de refazer os cálculos que aqui foram apresentados.
No desenvolvimento dos cálculos matemáticos, para a obtenção
das equações resultantes dos coeficientes de DH, fez-se o uso da
multiplicação de matrizes, para que se pudesse obter uma matriz
resultante, Τ23 , que representasse as outras matrizes envolvidas no
processo, e, com o auxílio desta matriz tornou-se possível calcular os
coeficientes para a Cinemática Direta. Para o cálculo dos coeficientes da
Cinemática Inversa foi feito também o uso de uma teoria fundamental da
Matemática, a Trigonometria, para que fosse feito o equacionamento
entre
os
ângulos
envolvidos
juntamente
com
suas
relações
trigonométricas fundamentais como seno, cosseno, tangente, arctg e as
medidas dos elos.
Para o desenvolvimento do software, foi utilizada a linguagem
Visual C++ devido sua facilidade em trabalhar com a entrada/saída de
dados através da porta paralela e, sendo também, outra contribuição
deste
documento,
onde
apresenta
o
código
fonte
do
software
desenvolvido para que se possa por em pratica as técnicas, teorias e
cálculos aqui apresentados.
O software criado para desenvolver a movimentação é baseado
nas duas técnicas da cinemática de robôs, a Direta e a Inversa, sendo
que o mesmo, disponibiliza para o usuário por qual método vai ser feita a
43
movimentação.
Uma vez que o objetivo deste documento era mostrar os passos
necessários para o desenvolvimento de um software para o controle de
um braço robótico, constata se que o mesmo foi alcançado, e ainda,
disponibiliza um material com o conteúdo muito rico referente aos cálculos
das cinemáticas, uma vez que para a obtenção dos mesmos foram gastas
varias horas de resoluções matemáticas, habilitando os leitores a
dispensarem menos tempo no percorrer de seu processo.
Neste sentido, fica aqui registrado uma documentação para
iniciantes, estudantes ou ainda interessados no assunto, que poderão
fazer desta, um guia para o início de seus estudos.
44
Referências Bibliográficas:
[1] – O QUE SÃO MOTORES DE PASSO? Disponível na Internet.
http://www.geocities.com/CollegePark/Dorm/8863/motordepasso.htm
.
Acessado dia 06/05/2003 às 18:00 hs.
[2] - ROBÓTICA - MOTOR DE PASSO. Disponível na Internet.
http://www.mrshp.hpg.ig.com.br/rob/m_passo.htm.
Acessado
dia
06/05/2003 às 18:04 hs.
[3] – ROBÓTICA – PORTA PARALELA. Disponível na Internet.
http://www.mrshp.hpg.ig.com.br/rob/paralela.htm.
Acessado
dia
06/05/2003 às 18:30 hs.
[4] - INTERFACING THE IBM PC PARALLEL PRINTER PORT. Disponível
na
Internet.
http://www.ee.washington.edu/circuit_archive/text/para-
port.html. Acessado dia 06/05/2003 às 20:00 hs.
[5]
–
MODULAÇÃO
PWM.
Disponível
http://locksmith.orcishweb.com/academic-files/pwm.html.
na
Internet.
Acessado
dia
06/05/2003 às 20:30 hs.
[6] - Controles PID (proporcional, integral e diferencial). Disponível na
Internet. http://www.cpunet.com.br/bluesite/eng/proc/pid1.htm . Acessado
dia 06/05/2003 às 21:00 hs.
[7] - 6ª SEMANA DE ENGENHARIA ELÉTRICA DA UNB. Disponível na
Internet. http://www.ene.unb.br/~adolfo/ISI/sene_si.pdf . Acessado dia
08/05/2003 às 16:40 hs.
[8] - VISÃO PARA ROBÓTICA MÓVEL: DETECÇÃO DE OBSTÁCULOS
45
SOBRE
PAVIMENTO
PLANO.
Disponível
na
Internet.
http://www.isr.ist.utl.pt/vislab/thesis/gaspar-MScThesis.pdf . Acessado dia
08/05/2003 às 16:45 hs.
[9] - DENAVIT, J., HARTENBERG, R.: “A kinematic notation for lower-pair
mechanisms based on matrices” , ASME J. on Applied Mechanics, 1955,
pp. 215-221.
[10] – Disponível na Internet
www.fem.unicamp.br/ensino/mecatronica/controle/Din%E2mica_.PDF
.
Acessado dia 30/05/2003 às 17:50 hs.
[11] – Paul, Richard P. “Robot Manipulators: Mathematics, Programming,
and Control”, The Mit Press, 1981
46