motor de passo - computacao.unitri.edu.br€¦ · documento, visando mostrar os passos necessários...
TRANSCRIPT
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 ............................................................. 26 21Τ
Figura 4.6 – Matriz resultante ............................................................. 26 32Τ
Figura 4.7 – Matriz resultante (Simplificada) ....................................... 27 32Τ
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 DB-25
Pino no Centronics Nome do Sinal Bit do
Registrador Observações
→ 1 1 -Strobe C0- Envie um pulso > 0,5us para enviar
o dado
→ 2 2 Data 0 D0 Bit menos significativo
→ 3 3 Data 1 D1 → 4 4 Data 2 D2 → 5 5 Data 3 D3 → 6 6 Data 4 D4 → 7 7 Data 5 D5 → 8 8 Data 6 D6 → 9 9 Data 7 D7
← 10 10 -Ack S6+ IRQ
Enviar um pulso baixo de
aproximadamente 5us, depois de
aceitar a interrupção
← 11 11 +Busy S7- Alto para
Ocupado / Fora de Linha / Erro
← 12 12 +PaperEnd S5+ Alto para
impressora sem papel
← 13 13 +Select In S4+ Alto pra
impressora selecionada
→ 14 14 -AutoFd C1-
Envie um sinal baixo para
avançar uma linha
← 15 32 -Error S3+ Baixo para Erro / Fora de Linha /
Sem Papel
→ 16 31 -Init C2+
Envie um pulso baixo com mais
de 50us para iniciar a
impressora
→ 17 36 -Select C3-
Envie um pulso baixo para
selecionar a impressora
== 18 ~ 25 19-30, 33, 17, 16 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 , que é a distância medida ao
longo do eixo da junta entre suas normais.
id
O ângulo de junta iθ entre as normais é medido em um plano
normal ao eixo da junta. Assim, e id 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: e ia iα .
O parâmetro é a menor distância medida ao longo da normal
comum entre os eixos de junta (isto é, os eixos e para a junta i e
junta i+1, respectivamente) Assim, e
ia
1−iz iz
ia 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: , ia iα , e id 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:
• ( , ia iα ) que determinam a estrutura do elo e os parâmetros
da junta.
• ( , id 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 ; 1−iz
2 - Translação ao longo do eixo ; id 1−iz
3 - Translação ao a longo de eixo ; ia ix
4 - Rotação de iα ao redor do eixo ; ix
( ) ( ) ( ) ( )αθ ,,,, xRotaxTransdzTranszRotAi = eq. 3.1
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡−
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡ −
=
100000000001
100001000010
001
1000100
00100001
100001000000
ααααθθ
θθ
cssc
a
dcssc
A i
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]
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡−
−
=
1000cos0
coscoscoscoscoscos
iii
iiiiiii
iiiiiii
i dsensenasensen
asensensen
Aαα
θαθαθθθαθαθθ
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 e no eixo
.
1−ix ix
1−iz
• é a distância entre a origem do (i-1)-ésimo sistema de
coordenadas até a interseção do eixo com o eixo ao
longo do eixo .
id
1−iz ix
1−iz
• é a distância (off-set) entre a interseção do eixo com
o eixo até a origem o i-ésimo sistema de referência ao
longo do eixo (ou a menor distância entre os eixos e
).
ia 1−iz
ix
ix 1−iz
iz
• iα é o ângulo off-set entre os eixos e medidos no
eixo . [9]
1−iz iz
ix
Para uma junta rotacional, , , e id ia 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θ , e ia iα são os parâmetros da junta, enquanto é a
variável de junta (deslocamento linear). [9]
id
21
3.3 – Coordenadas
Figuras 3.4 – Coordenadas do Robô. [9]
Assim sendo, um sistema de coordenadas cartesianas ortogonal
( , , ) 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 ( , , ) do braço do robô
corresponde a junta i+1, sendo fixo no elo i. [9]
ix iy iz
ix iy iz
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
( , , ), também chamado de sistema de referência inercial. Os
sistemas de coordenadas são determinados e estabelecidos obedecendo
três regras:
0x 0y 0z
1 - O eixo é colocado ao longo do eixo de movimento da junta i. 1−iz
22
2 - O eixo é normal ao eixo , e apontando para fora dele. ix 1−iz
3 - O eixo completa o sistema utilizando a regra da mão direita. iy
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 , deverá ser a do eixo de movimento da primeira junta. 0z
2 - O último sistema de coordenadas (i-ésimo) pode ser colocado
em qualquer parte do elemento terminal, enquanto que o eixo é normal
ao eixo . [9]
ix
1−iz
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 α θ a d 1 90º 1θ 12 cm d1
2 0º 2θ 26 cm d2
3 0º 3θ 18 cm d3
Sendo , a matriz genérica proposta por Denavit-Hartenberg, iΑ
24
atribui-se a cada elo do robô, uma matriz contendo seus parâmetros e
coeficientes:
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡−
−
=Α
1000cos0
coscoscoscoscoscos
iii
iiiiiii
iiiiiii
i dsensenasensen
asensensen
ααθθαθαθθθαθαθ
Figura 4.1 – Matriz DH
então, tem – se , e 1Α 2Α 3Α respectivamente:
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡−
−
=Α
1000cos0
coscoscoscoscoscos
111
1111111
1111111
1 dsensenasensen
asensensen
ααθθαθαθθθαθαθ
Figura 4.2 – Matriz DH do elo 1
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡−
−
=Α
1000cos0
coscoscoscoscoscos
222
2222222
2222222
2 dsensenasensen
asensensen
ααθθαθαθθθαθαθ
Figura 4.3 – Matriz DH do elo 2
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡−
−
=Α
1000cos0
coscoscoscoscoscos
333
3333333
3333333
3 dsensenasensen
asensensen
ααθθαθαθθθαθαθ
Figura 4.4 – Matriz DH do elo 3
Do resultado de x tem – se : 1Α 2Α 21Τ
25
( )( )( )
( )( )( )( )( )
( )( )
( )( )( )( )( )
( )( )
( )( )( )( )( )( ) (
( )( )( )
( )( )( )( )( )( )( )
( )( )( )( )( )
( )( )
( )( )( )( )( )( )
( )( )( )( )
( )( )( )
( )( )
)
⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢
⎣
⎡
+
++−+
+−
+
+
−
+−
+
−
+
+−+
+
+−
+
+−−
+
+−
+−
−
+
=Τ
1000121
221
21
221
21
22121
11
211
2211
221
211
2211
221
211
2211
221
211
21
11211
2211
221
211
2211
221
211
2211
221
211
21
21
ddc
sas
cc
css
sc
ccsss
sa
dcs
sacc
cas
ccs
cscc
sss
scs
cccc
scs
scc
cs
cadss
sasc
cac
css
cssc
ssc
sss
ccsc
scc
ssc
cc
α
θα
αα
θαα
αα
θααθα
θ
θα
θθα
θθ
αθα
θαθα
θαθ
αθα
θαθα
θαθ
θθα
θθ
θθα
θθα
θθ
αθα
θαθα
θαθ
αθα
θαθα
θαθ
θθα
θθ
Figura 4.5 – Matriz resultante 21Τ
Sendo o resultado de x 32Τ
21Τ 3Α , tem – se:
( )( )( )( )( )
( )( )( )( )( ) ( )( )
( )( )( )( )( )
( )( )( )( )( )
( )( )
( )( )( )( )( )( )( )
( )
( )( )( )( )( )
( )( )( )
( )( )( )( )( ) ( )
( )( )( )
( )( )( ) ( )( )( )
( )( )( )( )( )
( )
( )( )( )( )( )( )( )
( )( )( ) ( )( )( )
( )( )( )( )( )
( )
( )( )( )( )( )( )( )
( )( )( ) ( )( )( )
( )( )( )( )( )
( )
( )( )( )( )( )( )( )
( )( )( )( )( )( ) ( )
( )( )( )( )( )
( )( )( )( )( )( ) ( )
( )( )
( )( )( )( )( )( ) ( )
( )( )
( )( )( )( )( )( ) ( )
( )( )( ) ( )( )
⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢
⎣
⎡
⎟⎠
⎞⎜⎝
⎛⎟⎠⎞
⎜⎝⎛
⎟⎠
⎞⎜⎝
⎛⎟⎠⎞
⎜⎝⎛
⎟⎠
⎞⎜⎝
⎛⎟⎠⎞
⎜⎝⎛
⎟⎠
⎞⎜⎝
⎛⎟⎠⎞
⎜⎝⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎠
⎞⎜⎝
⎛⎟⎠⎞
⎜⎝⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎠
⎞⎜⎝
⎛⎟⎠⎞
⎜⎝⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎠
⎞⎜⎝
⎛⎟⎠⎞
⎜⎝⎛
⎟⎟⎟⎟⎟
⎠
⎞
⎜⎜⎜⎜⎜
⎝
⎛
⎟⎟⎟⎟⎟
⎠
⎞
⎜⎜⎜⎜⎜
⎝
⎛
⎟⎠
⎞⎜⎝
⎛⎟⎠⎞
⎜⎝⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟
⎠
⎞
⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟⎟
⎠
⎞
⎜⎜⎜⎜
⎝
⎛
⎟⎟
⎠
⎞
⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟⎟
⎠
⎞
⎜⎜⎜⎜
⎝
⎛
⎟⎟
⎠
⎞
⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎠
⎞⎜⎝
⎛⎟⎠⎞
⎜⎝⎛
++
++−
+
+
+
+−
+−
+
+
+−
+
+
+−
+
+
+−
+
+
+
−
+−
+
+
−
+
+−
+
+
−+
−
+
+−
−+
+−
+
+
−
+−
+
+
−
+
+−
+−
+
−
+
+−
+
+
+
+−
+
++−−
+
++−
+−
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟
⎠
⎞
⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
−
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
+−−
+
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
−
⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟
⎠
⎞
⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
−
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
−
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟
⎠
⎞
⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
−
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
+−−
+
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟
⎠
⎞
⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
−
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
−
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
−
⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟
⎠
⎞
⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
−
+⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
+−
+−
+
−
+
⎟⎟
⎠
⎞⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟
⎠
⎞⎜⎜
⎝
⎛
⎟⎟
⎠
⎞⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟
⎠
⎞⎜⎜
⎝
⎛⎟⎟
⎠
⎞⎜⎜
⎝
⎛
⎟⎟⎟
⎠
⎞
⎜⎜⎜
⎝
⎛
⎟⎟
⎠
⎞⎜⎜
⎝
⎛
⎟⎠⎞
⎜⎝⎛
⎟⎠⎞
⎜⎝⎛
⎟⎠⎞
⎜⎝⎛
⎟⎠⎞
⎜⎝⎛⎟⎠⎞
⎜⎝⎛
⎟⎠⎞
⎜⎝⎛
⎟⎠⎞
⎜⎝⎛
=
1000
1d
2d
1cα
2sθ
2a
1sα
3d
2cα
1cα
2cθ
2sα
1sα
3sθ
3a
2sα
1cα
2cθ
2cα
1sα
3cθ
3a
2sθ
1sα
3cα
2cα
1cα
2cθ
2sα
1sα
3cθ
3sα
2sα
1cα
2cθ
2cα
1sα
3sθ
3sα
2sθ
1sα
3sα
2cα
1cα
2cθ
2sα
1sα
3cθ
3cα
2sα
1cα
2cθ
2cα
1sα
3sθ
3cα
2sθ
1sα
3sθ
2sα
1cα
2cθ
2cα
1sα
3cθ
2sθ
1sα
1sθ
1a
2d
1cθ
1sα
2sθ
2a
1cθ
1cα
2cθ
2a
1sθ
3d
2cα
1cθ
1sα
2cθ
2sα
1cθ
1cα
2sθ
2sα
1sθ
3sθ
3a
2sα
1cθ
1sα
2cθ
2cα
1cθ
1cα
2sθ
2cα
1sθ
3cθ
3a
2sθ
1cθ
1cα
2cθ
1sθ
3cα
2cα
1cθ
1sα
2cθ
2sα
1cθ
1cα
2sθ
2sα
1sθ
3cθ
3sα
2sα
1cθ
1sα
2cθ
2cα
1cθ
1cα
2sθ
2cα
1sθ
3sθ
3sα
2sθ
1cθ
1cα
2cθ
1sθ
3sα
2cα
1cθ
1sα
2cθ
2sα
1cθ
1cα
2sθ
2sα
1sθ
3cθ
3cα
2sα
1cθ
1sα
2cθ
2cα
1cθ
1cα
2sθ
2cα
1sθ
3sθ
3cα
2sθ
1cθ
1cα
2cθ
1sθ
3sθ
2sα
1cθ
1sα
2cθ
2cα
1cθ
1cα
2sθ
2cα
1sθ
3cθ
2sθ
1cθ
1cα
2cθ
1sθ
1cθ
1a
2d
1sθ
1sα
2sθ
2a
1sθ
1cα
2cθ
2a
1cθ
3d
2cα
1sθ
1sα
2cθ
2sα
1sθ
1cα
2sθ
2sα
1cθ
3sθ
3a
2sα
1sθ
1sα
2cθ
2cα
1sθ
1cα
2sθ
2cα
1cθ
3cθ
3a
2sθ
1sθ
1cα
2cθ
1cθ
3cα
2cα
1sθ
1sα
2cθ
2sα
1sθ
1cα
2sθ
2sα
1cθ
3cθ
3sα
2sα
1sθ
1sα
2cθ
2cα
1sθ
1cα
2sθ
2cα
1cθ
3sθ
3sα
2sθ
1sθ
1cα
2cθ
1cθ
3sα
2cα
1sθ
1sα
2cθ
2sα
1sθ
1cα
2sθ
2sα
1cθ
3cθ
3cα
2sα
1sθ
1sα
2cθ
2cα
1sθ
1cα
2sθ
2cα
1cθ
3sθ
3cα
2sθ
1sθ
1cα
2cθ
1cθ
3sθ
2sα
1sθ
1sα
2cθ
2cα
1sθ
1cα
2sθ
2cα
1cθ
3cθ
2sθ
1sθ
1cα
2cθ
1cθ
32Τ
Figura 4.6 – Matriz resultante 32Τ
26
Aplicando valores dos respectivos ângulos iα conforme a tabela
DH à matriz acima, obtém-se o resultado: 32Τ
( )( )( )( )
( )( )( )( )( )
( )( )( )( )( )
( ) (( )( )( )
( )( )( )( )
( )( )( )( )
( )( )( )( )( )( )( )
( ) (( )( )( )( )( )
( )( )( )( )( )( )
( )( )( )( )( )( )
)
)
⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢
⎣
⎡
+
++−+
+
+−
+
−
+−
−
+
+
+−
+
−
+−
−
+
=Τ
⎟⎟⎟⎟
⎠
⎞
⎜⎜⎜⎜
⎝
⎛
⎟⎠⎞
⎜⎝⎛
⎟⎠⎞⎜
⎝⎛
10002sθ2a
3sθ3a2cθ
3cθ3a2sθ
03cθ2cθ
3sθ2sθ
3sθ2cθ
3cθ2sθ
1sθ1a2cθ2a1sθ
3sθ3a2sθ1sθ
3cθ3a2cθ1sθ
1cθ3cθ2sθ1sθ
3sθ2cθ1sθ
3sθ2sθ1sθ
3cθ2cθ1sθ
1cθ1a2cθ2a1cθ
3sθ3a2sθ1cθ
3cθ3a2cθ1cθ
1sθ3cθ2sθ1cθ
3sθ3cα2cθ1cθ
3sθ2sθ1cθ
3cθ2cθ1cθ
32
Figura 4.7 – Matriz resultante (Simplificada) 32Τ
Sendo:
ii ssen =θ eq. 4.1
ii c=θcos eq. 4.2
( ) 1221 ssen =+θθ eq. 4.3
( ) 1221cos c=+θθ eq. 4.4
considerações de simplificação e representação de operações, a partir
dos elementos , , 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:
14a 24a 34a
( )122323231 aacacccpx +++= eq. 4.5
( )122323231 aacaccsp y +++= eq. 4.6
2232323 asasspz ++= 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 , e da matriz resultante 14a 24a 34a 32Τ
( )122323231 aacacccpx +++= eq. 4.8
( )122323231 aacaccspy +++= eq. 4.9
2232323 asasspz ++= eq. 4.10
para então, poder isolar os ângulos 1θ , 2θ e 3θ .
Elegendo o elemento da matriz resultante , obtém-se a
equação:
34a 23Τ
011 =− yx pcps eq. 4.11
Tem-se então 1θ :
⎟⎟⎠
⎞⎜⎜⎝
⎛=
x
y
pp
arctg1θ eq. 4.12
Elegendo os elementos e da matriz resultante , e
equacionando-os simultaneamente, obtém-se a equação:
14a 24a 23Τ
28
223232311 acaccpspc yx ++=+ eq. 4.13
Fazendo:
2232323 asasspz ++= eq. 4.7
2311' cpspcp yxx −+= eq. 4.14
23' spp zy −= eq. 4.15
Substituindo tem-se: zp
22323' acacpx += eq. 4.16
22323' asaspy += eq. 4.17
Racionalizando ambas as equações e adicionando seus termos,
tem-se:
32
22
23
2'2'
3 2 aaaapp
c yx −−+= eq. 4.18
Uma vez que pode-se ter 3θ do arco cosseno, é obtido o valor de
e o aplica normalmente na rotina tangente: 3s
( )233 1 cs −±= eq. 4.19
onde, por substituição, encontra-se o valor de 3θ que é dado por:
29
⎟⎟⎠
⎞⎜⎜⎝
⎛=
3
33 c
sarctgθ eq. 4.20
Equacionando simultaneamente as equações 4.20 e 4.21, obtém se:
( )( ) 2
323
2233
'33
'233
2 asaacpaspaac
s xy
++
−+= eq. 4.21
( )( ) 2
323
2233
'33
'233
2 asaacpaspaac
c yx
++
++= eq. 4.22
Como os denominadores são iguais e ambos positivos, é então
obtido 2θ :
( )( ) ⎟
⎟⎠
⎞⎜⎜⎝
⎛
++
−+= '
33'
233
'33
'233
2yx
xy
paspaacpaspaac
arctgθ 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 circuito-
impresso 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, , 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.
32Τ
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 na Internet.
http://locksmith.orcishweb.com/academic-files/pwm.html. 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