controle neuro-fuzzy para um manipulador robÓtico
TRANSCRIPT
UNIVERSIDADE FEDERAL DO PARANÁ
SETOR DE CIÊNCIA E TECNOLOGIA
CURSO DE ENGENHARIA ELÉTRICA
EDUARDO DELINSKI DOS SANTOS
FELIPE ESCOBAR PIRES
CONTROLE NEURO-FUZZY PARA UM MANIPULADOR ROBÓTICO
CURITIBA – 2011
2
EDUARDO DELINSKI DOS SANTOS
FELIPE ESCOBAR PIRES
CONTROLE NEURO-FUZZY PARA UM MANIPULADOR ROBÓTICO
Trabalho de Conclusão de Curso de
Engenharia Elétrica, Departamento
de Engenharia Elétrica, Setor de
Ciência e Tecnologia, Universidade
Federal do Paraná, sob a orientação
do Prof. Dr. Gideon Villar Leandro.
CURITIBA – 2011
3
EDUARDO DELINSKI DOS SANTOS
FELIPE ESCOBAR PIRES
CONTROLE NEURO-FUZZY PARA UM MANIPULADOR ROBÓTICO
TRABALHO APRESENTADO AO CURSO DE ENGENHARIA ELÉTRICA, DA
UNIVERSIDADE FEDERAL DO PARANÁ, COMO REQUISITO PARA A
OBTENÇÃO DO TÍTUL OD GRADUAÇÃO.
BANCA AVALIADORA
PROF. DR. GIDEON VILLAR LEANDRO
PROF. DR. GUSTAVO OLIVEIRA
PROFA. DRA. GISELLE LOPES FERRARI
CURITIBA, JULHO DE 2011.
4
RESUMO
Manipuladores robóticos são altamente utilizados na indústria automatizada devido ao
fato de possuirem maior versatilidade, produtividade e eficiência. No campo da
robótica, os servomotores são os mais utilizados, pois possuem torque elevado e alta
precisão. Neste trabalho foram desenvolvidos controladores para controlar a resposta do
servomotor, adaptando a velocidade de deslocamento angular em função da tarefa que o
manipulador irá desempenhar. A técnica de controle escolhida foi o Neuro-Fuzzy, que
combina a natureza não Booleana da Lógica Fuzzy e a capacidade de aprendizado das
Redes Neurais Artificiais. O objetivo desse estudo é implementar de forma prática essa
técnica de controle em um protótipo de manipulador robótico.
Palavras chave: Neuro-Fuzzy, servomotor, manipulador robótico, Lógica Fuzzy, Redes
Neurais.
5
ABSTRACT
Robotic manipulators are highly used in automated industry due to the fact that they
have more versatility, productivity and efficiency. In the field of robotics, servomotors
are most used, because they have higher torque and high precision. In this work was
developed controllers to control the response of the servomotor, adapting it’s speed in
regard of the task the manipulator will perform. The chosen control technique was
Neuro-Fuzzy, which combines the non-Boolean nature of Fuzzy Logic and the learning
capabilities of the Artificial Neural Network. With this study we aim to implement this
technique in a robotic manipulator prototype.
Keywords: Neuro-Fuzzy, servomotor, robotic manipulator, Fuzzy Logic, Neural
Networks.
6
SUMÁRIO
LISTA DE FIGURAS ................................................................................................. 8 1 INTRODUÇÃO ................................................................................................. 10
1.1 Objetivos .................................................................................................... 10 1.2 Justificativa ................................................................................................ 11
2 O MANIPULADOR ROBÓTICO .................................................................... 12 2.1 Introdução ao Manipulador ...................................................................... 12 2.2 Partes do Manipulador .............................................................................. 12 2.3 Grau de Liberdade .................................................................................... 14 2.4 Configuração do Robô ............................................................................... 15 2.5 Sistemas de Acionamento .......................................................................... 15 2.6 Unidade de Controle .................................................................................. 17 2.7 Dinâmica do Braço Robótico ..................................................................... 18
3 LÓGICA FUZZY E REDES NEURAIS .......................................................... 20 3.1 Introdução ................................................................................................. 20 3.2 Lógica Fuzzy .............................................................................................. 20
3.2.1 O Processo de Controle por Lógica Fuzzy ........................................ 22 3.2.2 Fuzzyficação ....................................................................................... 23 3.2.3 Inferência Fuzzy................................................................................. 25 3.2.4 Defuzzyficação ................................................................................... 28
3.3 Redes Neurais ............................................................................................ 32 3.3.1 Introdução .......................................................................................... 32 3.3.2 Modelo Geral de Neurônio ................................................................ 33 3.3.3 Redes Neurais ..................................................................................... 36 3.3.4 Redes Neurais Multicamadas ............................................................ 36 3.3.5 Treinamento da RNA ........................................................................ 39 3.3.6 Algoritmo de Retropropagação ......................................................... 40 3.3.7 Projeto das RNAs ............................................................................... 44
4 CONTROLADORES ........................................................................................ 45 4.1 Controle ..................................................................................................... 45
4.1.1 Controlador Proporcional, Integral, e Derivativo (PID) .................. 45 4.1.2 Ajuste do Compensador PID ............................................................. 47 4.1.3 O Algoritmo de Ajuste Ziegler-Nichols ............................................. 48 4.1.4 Modelo PID Discreto .......................................................................... 49
4.2 O Controlador PI Fuzzy ............................................................................ 49 4.3 Controle Adaptativo de um PID usando RNAs Recursivas ..................... 50 4.4 Neuro-Fuzzy............................................................................................... 56
5 PARTE PRÁTICA ............................................................................................ 58 5.1 Servomotores ............................................................................................. 58 5.2 Obtenção da Função de Transferência do Servomotor ............................ 61 5.3 Kits de Desenvolvimento ........................................................................... 64 5.4 Construção do Protótipo ........................................................................... 65 5.5 Implementação do Sistema de Controle ................................................... 71
6 RESULTADOS OBTIDOS ............................................................................... 73 6.1 Simulações ................................................................................................. 73
6.1.1 PID ...................................................................................................... 73 6.1.2 PI Fuzzy .............................................................................................. 74
7
6.1.3 PID Neural ......................................................................................... 75 6.2 Resultados Práticos ................................................................................... 76
6.2.1 PID ...................................................................................................... 76 6.2.2 PI Fuzzy: ............................................................................................ 78 6.2.3 PID Neural ......................................................................................... 81 6.2.4 Neuro-Fuzzy ....................................................................................... 83
7 CONCLUSÃO ................................................................................................... 87 8 BIBLIOGRAFIA ............................................................................................... 88
8
LISTA DE FIGURAS
Figura 1: Junta de rotação ........................................................................................... 14 Figura 2: Robô articulado ............................................................................................ 15 Figura 3: Controle em Malha Fechada ......................................................................... 18 Figura 4: Diagrama do funcionamento do controle por Lógica Fuzzy .......................... 22 Figura 5: Diferentes tipos de funções de pertinência .................................................... 23 Figura 6: Função de pertinência triangular para a variável linguística VAR ................. 25 Figura 7: Métodos de defuzzyficação .......................................................................... 30 Figura 8: Neurônio artificial estático ........................................................................... 33 Figura 9: Diversas funções de ativação........................................................................ 34 Figura 10: Representação de uma rede MLP ............................................................... 37 Figura 11: Esquematização do processo do algoritmo Backpropagation ...................... 41 Figura 12: Controlador PID ......................................................................................... 46 Figura 13: PID Neural ................................................................................................. 52 Figura 14: Diagrama de Blocos com PID Neural e Modelo de Referência ................... 54 Figura 15: Um modelo de servomotor típico ............................................................... 58 Figura 16: Relação da largura de pulso enviada ao servo com a rotação angular do mesmo ........................................................................................................................ 59 Figura 17: Componentes internos de um servomotor ................................................... 60 Figura 18: A interface para obtenção do modelo com as opções utilizadas e os resultados .................................................................................................................... 62 Figura 19: Kit Arduino Mega ...................................................................................... 65 Figura 20: Esquema inicial do protótipo do braço robótico .......................................... 66 Figura 22: Esquema final de construção do braço robótico .......................................... 67 Figura 23: Vista lateral (esquerda) e frontal (direita) do manipulador .......................... 69 Figura 24: Vista lateral do manipulador com antebraço e garra ................................... 69 Figura 25: Especificações e dimensões do servo HXT 900 .......................................... 70 Figura 26: Imagem real do servomotor HXT 900 ........................................................ 70 Figura 27: Diagrama de blocos do controlador PID ..................................................... 73 Figura 28: Resposta do PID a uma referência de 90° ................................................... 74 Figura 29: Diagrama de blocos do controlador PI Fuzzy ............................................. 74 Figura 30: Resposta do PI Fuzzy a uma referência de 90° ........................................... 75 Figura 31: Resposta do PID Neural a uma referência de 90°........................................ 75 Figura 32: Resposta do PID para referência de 90° ...................................................... 77 Figura 33: Fluxograma para código do PID ................................................................. 78 Figura 34: Funções de pertinência das entradas (em cima) e saídas (em baixo) ............ 79 Figura 35: Resposta do controlador PI Fuzzy .............................................................. 79 Figura 36: Fluxograma para o código do PI Fuzzy ...................................................... 80 Figura 37: Resposta do PID-Neural ............................................................................. 81 Figura 38: Fluxograma para o código do PID Neural................................................... 82 Figura 39: Resposta dos Controladores Neuro-Fuzzy .................................................. 84 Figura 40: Fluxograma para o código do Neuro-Fuzzy Concorrente ............................ 85 Figura 41: Fluxograma para o código do Neuro-Fuzzy Cooperativo ............................ 86
9
LISTA DE TABELAS
Tabela 1: Tabela com os efeitos dos parâmetros do PID .............................................. 47 Tabela 2: Regras Fuzzy ............................................................................................... 79
10
1 INTRODUÇÃO
Este projeto consiste na construção de um manipulador articulado com 3 graus
de liberdade (movimentos para frente, para cima e um movimento angular da garra) e
no desenvolvimento de controladores do tipo PID Neuro-Fuzzy para controlar seus
movimentos, que possuirá no seu órgão terminal um suporte para uma garra. Através de
um sistema de comunicação com o computador, os dados serão passados para o sistema
de controle, que guardará em sua memória o percurso que o braço seguirá. Quando o
programa estiver sendo executado, será transmitido pelo controlador o sinal de controle
para os servomotores, que irão mover o braço robótico e o atuador na extremidade dele.
1.1 Objetivos
Objetivo geral:
Desenvolver num sistema embarcado a lógica NEURO-FUZZY para
movimentar e controlar a posição um manipulador robótico articulado, que terá 3 graus
de liberdade, e com uma garra no seu órgão terminal, dessa forma o braço pegará
pequenos objetos num campo limitado.
11
Objetivos específicos:
• Construir o braço robótico.
• Programar um sistema microcontrolado utilizando a lógica Neuro-Fuzzy como
base para a técnica de controle do posicionamento do manipulador.
• Testar seus movimentos.
1.2 Justificativa
Em muitas situações é necessário substituir o ser humano em tarefas em que ele
não pode realizar, por causa de suas próprias limitações físicas, ou por envolverem
condições desagradáveis ou extremas. Devido a essas necessidades este projeto propõe a
construção de um braço robótico.
A utilização do braço robótico contribui em vários fatores como exemplificado a
seguir:
• Fatores técnicos: flexibilidade na gama de produtos fabricados, incremento
da precisão, força, rapidez, uniformidade e suporte a ambientes hostis,
incremento dos índices de qualidade e redução do número de peças
rejeitadas.
• Fatores econômicos: utilização eficiente de unidades de produção, com
intensivo aumento de produtividade (inexistência de interrupções, etc),
redução do tempo de preparação da fabricação.
• Fatores sociológicos: redução do número de acidentes, afastamento do ser
humano de locais perigosos para a saúde. Redução de horários de trabalho,
aumento do poder de compra.
12
2 O MANIPULADOR ROBÓTICO
2.1 Introdução ao Manipulador
O tipo mais comum de robô é o braço robótico, que na indústria, é normalmente
formado por sete segmentos e unido por seis junções, utilizando-se de sensores de
movimento para ter certeza de seu trajeto.
Um robô industrial com seis junções lembra um braço humano. Ele tem o
equivalente a um ombro, cotovelo e pulso. A base é montada presa em uma superfície
estática em vez de um corpo móvel. O robô industrial tem seis graus de liberdade, o que
significa que ele pode se mover em seis direções diferentes. Já um braço humano tem
sete graus de liberdade.
A função de um braço robótico é mover um órgão terminal de um lugar para o
outro. Você pode acoplar todo tipo de órgãos terminais a um braço robótico. O órgão
terminal mais comum é uma versão simplificada de mão, que pode apanhar e carregar
diferentes objetos.
2.2 Partes do Manipulador
Os manipuladores robóticos possuem três partes principais: uma base fixa, um
braço articulado, e uma unidade de controle. Os manipuladores robóticos possuem um
determinado numero de graus de liberdade, que é o número de variáveis que podem
alterar sua posição.
13
Base Fixa
A base fixa consiste normalmente em um estrutural presa ao chão, mas que pode
estar presa às paredes ou ao teto, ou seja, normalmente ela se encontra num lugar fixo,
mas nada impede de que seja montada em cima de outra máquina ou mesmo sobre uma
plataforma móvel.
Braço Articulado
O braço articulado é formado por várias partes: elos, juntas, atuadores de juntas,
sensores de posição de juntas e órgão terminal. Elos são as partes rígidas de um braço
robótico, comparáveis aos ossos do braço de uma pessoa. Juntas são as partes do braço
robótico que permitem uma conexão móvel entre dois elos. Os tipos mais comuns de
juntas são: deslizantes e rotativas. Atuadores produzem os movimentos no braço quando
recebem um sinal de entrada. O tipo de atuador vai depender do tipo de junta de que se
terá no braço. Os sensores de posição de juntas codificam informações sobre as posições
das juntas sendo enviadas como sinais ao controlador do robô. Os órgãos terminais
freqüentemente são garras ou ferramentas especializadas.
Juntas
A junta rotacional: Gira em torno de uma linha imaginaria estacionaria chamada
de eixo de rotação. Ela abre e fecha como uma dobradiça, com indicado pela Figura 1.
14
Figura 1: Junta de rotação Órgão Terminal
Órgão terminal é o termo usado para descrever a mão ou ferramenta que esta
conectada ao pulso do braço robótico. O órgão terminal é o responsável por realizar a
manipulação de objetos em diferentes tamanhos, formas e materiais, porém esta
manipulação depende da aplicação ao qual se destina.
2.3 Grau de Liberdade
Grau de liberdade é o número de articulações em um braço robótico. Quando o
movimento relativo da junta ocorre em um único eixo, a articulação tem um grau de
liberdade. Quando o movimento é por mais de um eixo, a articulação tem dois graus de
liberdade. Sendo assim, cada junta pode definir um ou dois graus de liberdade,
dependendo da junta, e o numero de graus de liberdade do braço robótico será igual à
soma de dos graus de liberdade de todas as suas juntas.
15
2.4 Configuração do Robô
Robô Articulado
Estes tipos de robôs, possuem 3 juntas rotativas, conforme ilustrada a Figura 2.
Eles são os mais usados nas indústrias, por terem uma configuração semelhante ao do
braço humano. Este modelo de configuração e o mais versátil dos manipuladores, pois
assegura maiores movimentos dentro de um espaço compacto.
Figura 2: Robô articulado
2.5 Sistemas de Acionamento
Os acionadores são dispositivos responsáveis pelo movimento das articulações e
do desempenho dinâmico do robô.
16
Servomotor
Servomotores são compostos por motores DC e um redutor de velocidades, junto
com um sensor de posição e um sistema de controle realimentado. Em outras palavras,
os servos-motores podem ser considerados como sendo motores comandados em
posição, já que, do ponto de vista de quem os utiliza, o controle interno em malha
fechada é irrelevante. Os servos-motores são pequenos, com ampla variação de torques.
O mecanismo de posicionamento ajusta a posição angular por meio de um sinal que lhe
é enviado.
Enquanto esse sinal estiver na entrada, o servo irá manter a sua posição angular.
Em geral o sinal é do tipo PWM, ou seja, a posição angular irá depender da largura do
pulso enviado.
As vantagens dos Servos-motores como acionadores elétricos para
manipuladores são:
• Controle preciso.
• Estrutura simples e fácil manutenção.
• Baixo custo comparado aos outros acionadores.
As desvantagens:
• Não pode manter um momento constante nas mudanças de velocidade de
rotação.
• Sujeitos a danos para cargas pesadas suficientes para parar o motor.
• Baixa razão de potência de saída do motor e seu peso, necessitando um
motor grande no braço.
Resumindo, os acionadores elétricos são melhores em aplicações envolvendo:
17
• Alta precisão de posição;
• Transferência de carga de tamanho pequeno e médio;
2.6 Unidade de Controle
A unidade de controle recebe sinais de entrada dos sensores do robô e transmite
sinais de saída para os atuadores do robô. Há dois tipos de sistemas de controle de
robôs: malha aberta e malha fechada.
No esquema do tipo malha aberta, não há sensor medindo como o manipulador
realmente se moveu em resposta aos sinais enviados para os atuadores, e
conseqüentemente não há sinais de realimentação do manipulador para o controlador.
Portanto não há maneira de se saber a posição atual do manipulador. Tudo o que se sabe
é onde ele deveria estar e não se ele realmente alcançou a posição desejada.
No sistema de malha fechada, depois que o controlador envia sinais ao atuador
para mover o manipulador, um sensor no manipulador robótico, retorna um sinal ao
controlador.
O sistema de controle de qualquer robô é realizado por meio de um sistema de
“software” e “hardware”. Este sistema processa os sinais de entrada e converte estes
sinais em uma ação ao qual foi programado.
O sistema de hardware constitui de servomotores e sensores. Um dos fatores
mais importantes é a utilização de sensores, pois consistem em verificar o estado atual
do dispositivo a ser controlado e comparar essa medida com um valor pré-definido. Esta
comparação resultara num erro, ao qual o sistema de controle fará os ajustes necessários
para reduzir o erro à zero. Um esquema simples de malha fechada e apresentado em
diagrama de blocos na Figura 3.
18
Figura 3: Controle em Malha Fechada
2.7 Dinâmica do Braço Robótico
O desempenho dinâmico do braço robótico esta associado à velocidade de
resposta, estabilidade e precisão. A velocidade de resposta refere-se à destreza do braço
robótico ao mover-se de um lugar para outro num certo período de tempo. A
estabilidade pode ser estimada com base no tempo necessário para amortecer as
oscilações que ocorrem durante o movimento de uma posição para a outra. Porém ao
alterar a estabilidade do braço pode-se alterar a velocidade de resposta do mesmo.
A precisão esta relacionada com a velocidade de resposta e com a estabilidade,
pois é uma medida de erro na posição. A precisão de movimento esta intrinsecamente
correlacionada com três características, como segue:
• Resolução espacial
• Precisão dos dispositivos
• Repetibilidade
A resolução espacial depende diretamente do controle de sistema e das
inexatidões mecânicas do braço robótico. O sistema de controle é o responsável por
controlar todos os incrementos individuais das articulações. Já as inexatidões
relacionam-se com a qualidade dos componentes que formam o robô.
19
A precisão relaciona-se com a resolução espacial, pois a precisão depende dos
incrementos que as juntas podem realizar para se movimentar e atingir um ponto
determinado.
Por fim, a repetibilidade esta relacionada com a capacidade do braço robótico de
posicionar repetidamente seu pulso num ponto determinado. Estes movimentos podem
sofrer influencias das partes mecânicas, da flexibilidade e das limitações do sistema de
controle.
20
3 LÓGICA FUZZY E REDES NEURAIS
3.1 Introdução
3.2 Lógica Fuzzy
A Lógica Fuzzy, a qual tem base na Teoria dos Conjuntos, fundamenta-se no
conceito de que no mundo real, o controle realizado pelos seres humanos não se
constitui de valores Booleanos, verdadeiro ou falso (comumente com valores atribuídos
de 1 e 0, respectivamente). Ao se deparar com situações que exigem uma resposta, os
seres humanos não reagem com um sinal exato com valor definido.
Por exemplo, ao se dirigir um carro, digamos que o carro acabe desviando-se um
pouco para um dos lados. Nosso instinto é o de avaliar superficialmente de quanto foi o
desvio e reagir com uma ação no sentido contrário, proporcionalmente. Pode ser que o
carro vire um pouco para a direita, ou muito para a direita. Essas atribuições linguísticas
são chamados na Lógica Fuzzy de variáveis linguísticas. No caso do carro, o condutor
sabe que o carro virou pra direita, mas não tem certeza de quantos graus exatamente,
mas ele tem noção aproximada da intensidade que pode ser atribuída ao desvio: um
pouco, muito, quase nada. Por meio dessa avalição ele pode reagir e virar o volante na
direção contrária, com uma intensidade aproximadamente equivalente ao desvio.
Digamos que o carro vire um pouco para a direita, o condutor irá virar o volante um
pouco para a esquerda. É claro que o movimento correspondente a “um pouco”
realizado pelo condutor tem grandes chances de não ser o valor exato necessário para
que o carro fique centralizado na pista novamente (apesar de ter grandes chances de
21
estar próximo ao valor necessário), mas o processo se repete, até que se atinja um
resultado satisfatório comparado ao desejado.
Com base nesse raciocínio percebeu-se que era possível realizar ações de
controle por meio de variáveis linguísticas que denotam certa qualidade, e por sua vez
atribuir um grau relativo a essa qualidade ás variáveis de entrada. Esse tratamento é
muito mais acessível, necessitando-se apenas do conhecimento dos limites que definem
cada variável linguistica. Nesse momento entra o conhecimento do especialista, alguém
que conhece o processo e tem noções sobre as ações a serem tomadas em cada caso, e
como classificar as entradas com as variáveis linguísticas.
Por meio do conhecimento do especialista pode-se então estabeler uma série de
regras que constituem o controle por Lógica Fuzzy. Por meio dessas regras o sistema
Fuzzy avalia as entradas e obtém as saídas. As regras são da forma “se ... então”, como
mostrado a seguir (utilizando o exemplo do carro):
Se desvio foi MUITO PARA DIREITA então volante deve ser MUITO PARA ESQUERDA
Essas regras podem ter qualquer número de entradas e saídas, constituindo-se de
todas as combinaçães possíveis de entradas. Utilizando esse racíocínio simples com
natureza humana, a Lógica Fuzzy se mostrou uma alternativa de controle muito
interessante, pois seu projeto e sua implementação são relativamente simplificados.
22
3.2.1 O Processo de Controle por Lógica Fuzzy
Ao se utilizar o controle fuzzy, deve-se ter em mente que o controle é realizado
em 3 principais etapas: Fuzzyficação, Inferência e Defuzzyficação. Trata-se então, de
maneira simplificada, de passar os valores do mundo real (chamados no âmbito da
Lógica Fuzzy de valores crisp) para os valores fuzzy (constituídos de uma variável
linguística e um grau de pertinência), avaliar todas as combinações dessas entradas
atráves das regras fuzzy (onde algumas regras serão ativadas enquanto outras não), e,
por fim, agregar os resultados fuzzy de saída das regras em um valor crisp, o qual será
retornado ao sistema como um novo sinal de controle. Esse processo se repete durante
todo o funcionamento do sistema. O diagrama da Figura 4 ilustra a interação da Lógica
Fuzzy com o sistema a ser controlado. A seguir serão discutidas todas as etapas do
controle por Lógica Fuzzy.
Figura 4: Diagrama do funcionamento do controle por Lógica Fuzzy
23
3.2.2 Fuzzyficação
Esse processo inicial consiste em atribuir uma variável linguística e um grau de
pertinência a uma entrada crisp utilizando as chamadas funções de pertinência, obtendo
então um valor fuzzy. Essas funções podem adquirir diversas formas, como ilustrado
pela figura 5. Geralmente utiliza-se a função triangular pela facilidade de
implementação computacional e cálculos.
Figura 5: Diferentes tipos de funções de pertinência
Quando um valor crisp de entrada pertence a uma faixa de valores de uma
função de pertinência, ou seja, está contido entre os valores máximo e mínimo da
função de pertinência (eixo x), a ele é atribuída a variável linguística que representa essa
função de pertinência. Seu grau de pertinência é o resultado da equação da função de
pertinência a qual ele pertence (eixo y). Isto é, tendo-se uma certa função de pertinência
f(x), com f(x) = 0 para os valores MIN e MAX dessa função, pode-se obter o grau de
pertinêcia de uma certa entrada crisp X calculando-se f(X), estando o X contido no
24
intervalo entre os valores MIN e MAX, ou seja, pertencendo a essa função de
pertinência. Pelo fato de as funções de pertinência serem comumente representadas por
funções normalizadas, o grau de pertinência sempre excursa entre 0 e 1. Digamos que
f(x) represente a variável linguística VAR (que pode ser, por exemplo, GRANDE,
FRACO, DIREITA, etc). Tem-se então uma entrada associada a um grau de pertinencia
na forma:
(VAR/f(X))
Onde VAR é a variável linguística atribuída a entrada crisp X e f(X) é o grau de
pertinência calculado através da função de pertinência da variável VAR. Esse é o valor
fuzzy da entrada crisp X. O exemplo a seguir ilustra esse procedimento.
Exemplo:
Sendo a variável linguística VAR representada pela seguinte função triangular
de pertinência (ilustrada na figura 6):
>
≤≤−−
≤≤−−
<
=
cx,
cxbb),x)/(c(c
bxaa),a)/(b(x
ax,
f(x)
0
0
Onde a = 1, b = 2, c = 3.
25
Figura 6: Função de pertinência triangular para a variável linguística VAR
Para uma entrada crisp de valor 2,5 (que encontra-se dentro dos valores com
grau de pertinênica não zerados de VAR) tem-se então o seu grau de pertinência
calculado por:
f(2,5) = (3 – 2,5)/(3 – 2) = 0.5
O valor fuzzyficado para 2.5 é VAR com grau de pertinência 0.5, ou (VAR/0,5).
Esse processo constituí a chamada Fuzzificação. Trata-se então da passagem dos valores
crisp para os valores fuzzy, que serão então avaliados na próxima etapa.
3.2.3 Inferência Fuzzy
Após a obtenção de todos os valores fuzzy a partir das entradas crisp, deve-se,
então, relacioná-los com uma saída fuzzy, utilizando as regras fuzzy. Combina-se todas
as entradas, e para cada combinação atribuí-se uma saida fuzzy (ou quantas saídas
forem necessárias). Esse processo constituí a Inferência Fuzzy, etapa na qual realiza-se
o controle do sistema propriamente dito. As regras fuzzy são da forma:
26
Se (entrada 1) = VAR1 e (entrada 2) = VAR2 então (saída) = VAR3
Existem dois tipos de principais de inferência Fuzzy, o tipo Mandani e o tipo
Sugeno. A principal diferença entre eles está no resultado das regras fuzzy. Na regra
mostrada acima, a saída é um valor fuzzy, o que caracteriza um controle do tipo
Mandani. O tipo Sugeno utiliza uma função de saída que resulta diretamente em uma
valor crisp, sem haver desfuzzyficação, da seguinte forma:
Se (entrada 1) = VAR1 e (entrada 2) = VAR2 então (saída) = f(entrada1, entrada2)
Note que a aplicação das regras fuzzy sobre o conjunto fuzzy de entrada resulta
em um valor fuzzy de saída. O seu grau de pertinência é calculado por meio do uso dos
operadores lógicos E, OU e NÃO, os quais devem manter suas características como na
lógica Booleana. Nos exemplos de regras mostrados até agora, utilizou-se o operador E
(“Se ... E .. então ...”). Comumento, esses operadores são substituídos pelas seguintes
funções:
E(x , y) = min(x, y)
OU(x, y) = max(x, y)
NÂO(x) = 1 – x
Onde x e y são os graus de pertinência das entradas que estão sendo operadas
pela regras fuzzy. Isto ocorre porque essas funções representam corretamente a saída
dos operadores.
27
O número de regras fuzzy é definido pelo número de entradas e pelo número de
variáveis linguísticas para cada entrada. Por exemplo, se tivermos duas entradas, ENT1
e ENT2, e cada uma tiver 5 funções de pertinência (representadas pelas variáveis
linguísticas A, B, C, D e E), então o número de combinações das entradas é:
5² = 25 regras
Isso vem do fato de que como se tem 5 variáveis linguísticas diferentes para
cada entrada, então pode-se combiná-las de 25 diferentes maneiras, como mostrado a
seguir:
Se ENT1 = A e ENT2 = A então ...
Se ENT1 = A e ENT2 = B então ...
Se ENT1 = A e ENT2 = C então ...
Se ENT1 = A e ENT2 = D então ...
Se ENT1 = A e ENT2 = E então ...
Se ENT1 = B e ENT2 = A então ...
E assim por diante, até todas as combinações serem realizadas. Note que com o
aumento linear do número de entradas, o número de regras cresce exponencialmente. Se
forem 3 entradas ao invés de 2 , tem-se:
5x5x5 = 5³ = 125 regras
Daí tira-se a seguinte expressão:
28
Número de regras = (número de variáveis linguísticas para cada entrada)(número de entradas)
Essa expressão só é válida no caso de todas as entradas terem o mesmo número
de variáveis linguísticas. Além disso, nada impede o projetista das regras de
negligenciar algumas combinações (talvez combinações que ele saiba que não têm
muita influência no sistema ou que nunca ocorrerão na prática) ou de reduzir o número
de variáveis linguísticas das entradas (o que resultaria em um controle menos preciso,
mas não necessaramente menos eficiente), ambos reduziriam o número de regras.
Mais de uma regra pode ser ativada de uma vez, resultando em mais de um valor
de saída fuzzy. Esses valores são então agregados utilizando uma função para realizar
essa etapa, normalmente se faz max(x, y, ...) de todas as saídas ativadas. Obtendo-se
apenas um conjunto fuzzy de saída.
3.2.4 Defuzzyficação
Após a passagem das entradas pelas regras obtém-se um conjunto fuzzy de
saída. Para se obter uma saída crisp, que pode ser aplicada no sistema a ser controlado,
deve-se agrupar os resultados da inferência em apenas um valor. Esse processo é
chamado de defuzzyficação, pois ocorre o inverso do que ocorreu na entrada da Lógica
Fuzzy.
Existem diversas técnicas de defuzzyficação, sendo que cada uma tem suas
vantagens e desvantagens, como facilidade de implementção, menor custo
computacional, valores de saída melhor ponderados, etc. A seguir são demonstradas
algumas dessas técnicas:
29
Meio dos máximos:
Consiste em calcular a média de todos os pontos de máximo do conjunto fuzzy
de saída, ou seja, faz-se o somatório dos valores crisp correspondentes aos valores fuzzy
com maior grau de pertinência e divide-se esse somatório pelo número de máximos (no
caso de funções contínuas utiliza-se a integral ao invés do somatório). O resultado é o
valor crisp de saída.
Primeira dos máximos:
Esse método é mais simples, pois utiliza apenas o menor valor crisp do conjunto
de máximos, isto é, o limite inferior do maior máximo. Este valor é a saída crisp.
Última dos máximos:
Semelhante ao método Primeira dos Máximos, com a diferença de que utiliza o
maior valor crisp do conjunto dos máximos, ou seja , o limite superior.
Centro de área ou Centróide:
Trata-se de um método muito utilizado que obtém o valor crisp de saída com
base no centro da área do conjunto fuzzy. O resultado é o somatório de todos valores
crisp do conjunto multiplicados por seus respectivos graus de pertinência, que então é
30
dividido pelo somatório de todos os graus de pertinência do conjunto, como indicado
pela equação a seguir:
∗=∑∑
)(
)(
xf
xfxA
Onde A é o valor crisp de saída e f(x) é o grau de pertinência para cada valor do
conjunto. Os resultados gráficos dos valores crisp obtidos por cada método são
mostrados na figura 7.
Figura 7: Métodos de defuzzyficação
31
Tendo então sido utilizado um desses métodos para se obter a saída da Lógica
Fuzzy, pode-se aplicá-la ao sistema a ser controlado, para que após isso o procedimento
se repita com a nova realimentação.
32
3.3 Redes Neurais
3.3.1 Introdução
Uma rede neural artificial é caracterizada por dois fatores:
1 – O conhecimento é adquirido através de um processo de aprendizagem.
2 – Forças de conexão entre neurônios, conhecidas como pesos, são utilizados
para armazenar o conhecimento adquirido.
Desta maneira podemos citar algumas características especiais das Redes
Neurais Artificiais ou RNA:
• Generalização: capacidade de aprender através de padrões de entrada/saída e
apresentar respostas, estipulando valores de saída, para padrões de entrada não vistos
durante o treinamento.
• Adaptabilidade: através da alteração em seus pesos podem adaptar-se a novos
padrões.
• Tolerância a falhas: se tornam robustas quando da existência de condições
adversas, que propiciam uma degradação suave em seu desempenho, ao invés de
degradação catastrófica.
• Não-linearidade: é capaz de representar sistemas com características não-
lineares.
33
3.3.2 Modelo Geral de Neurônio
O neurônio formal é um sistema dinâmico por ter memória materializada pelo
retardo. Um neurônio é estático quando os valores de entrada (xj) e de saída (y) se
referem ao mesmo instante, ou seja, o retardo interno do neurônio é nulo. A partir do
momento quando se fizer referencia ao neurônio artificial se estará fazendo referencia
ao neurônio estático.
Figura 8: Neurônio artificial estático
O neurônio artificial (Fig. 8) é composto por três elementos básicos:
1. Um conjunto de conexões de entrada: cada entrada i é ponderada por um peso
sináptico wi. Logo um sinal de entrada xj na entrada i do neurônio k é multiplicado pelo
peso wi. O uso do bias, x0, tem o papel de polarização, aumentar ou diminuir a
influência dos valores das entradas na resposta de saída do neurônio.
2. Um operador de agregação: é responsável pela combinação dos sinais de
entrada ponderados pelos respectivos pesos das conexões do neurônio, comumente
34
utiliza-se um operador de soma. As entradas são combinadas para que seja produzido
um estado de ativação pela função que esta sendo utilizada para tal propósito, como
descrito na próxima estrutura.
3. Uma função de ativação: é uma função geralmente não linear, com a
finalidade de introduzir a característica de não linearidade a rede a neural. O intervalo
de ativação dos neurônios é confinado ao intervalo, normalmente unitário [0 1] ou [-1
1], assim restringindo a amplitude de saída do neurônio a um valor finito.
A Figura 9 mostra algumas funções comumente usadas.
Figura 9: Diversas funções de ativação
35
Principais finalidades de algumas funções de ativação:
• Linear: é uma função que armazena a entrada e não limita a saída;
• Rampa: e uma função de aproximação não-linear;
• Degrau: é uma função que limita a saída a valores do tipo binário;
• Tangente hiperbólica: é uma que assume valores no intervalo de -1 e +1;
• Sigmóide: é uma função limitada que assume valores entre um intervalo
superior e inferior (0 e 1), porém sem jamais alcançá-los.
O neurônio da Figura 8 pode descrito pela seguinte equação matemática:
+= ∑
=
n
iii xwxwfy
100
Se colocarmos o Bias como sendo uma entrada sempre com o mesmo valor:
= ∑
=
n
iii xwfy
0
Escrevendo no formato de matrizes:
( )00xwxwfy T +=
( )xwfy T=
36
Onde x é o vetor das entradas e v é o vetor dos pesos:
[ ] [ ]nT xxxxkx L2111)( ==
[ ] [ ] Tn
T wwwwkw L2111)( ==
3.3.3 Redes Neurais
Uma RNA é um sistema composto por vários neurônios. Alguns neurônios
recebem excitações do exterior e são chamados neurônios de entrada. Outros têm suas
respostas usadas fora da rede e são chamados neurônios de saída. Os neurônios que não
são nem entrada nem saída são conhecidos como neurônios internos. Estes neurônios
internos á rede tem grande importância e são conhecidos como “neurônios escondidos”.
A configuração em multicamadas (MLP - “Multi Layer Perceptron”) é a
configuração mais utilizada, pois foi visto que esta configuração pode aproximar
qualquer função, dependendo do numero de neurônios presentes na estrutura da rede.
3.3.4 Redes Neurais Multicamadas
Diferentemente das redes de camada única que tem a limitação de apenas
resolver problemas com características lineares, as redes MLP incorporam as
características não-lineares para resolução de problemas. As entradas das unidades
neurais de uma determinada camada são provenientes das camadas anteriores e sua
37
saída é conectada às unidades das camadas posteriores. Não ocorrem conexões entre
unidades da mesma camada.
Uma MLP é tipicamente formada por:
• Camada de entrada: aonde a informação é apresentada á rede;
• Camada intermediária: aonde ocorre a maior parte do processamento
• Camada de saída: aonde o resultado é concluído e apresentado.
Figura 10: Representação de uma rede MLP
O fluxo da informação se propaga de camada em camada, percorrendo as
camadas da esquerda à direita, como mostra o esquema da Figura 10.
Escolha dos parâmetros das MLP
Basicamente precisam-se escolher três elementos para se configurar uma rede
MLP:
1- O numero de camadas intermediarias e o numero de neurônios em cada
camada.
38
2- A função de ativação para cada camada.
3- Os tipos de conexões ou pesos.
A determinação da quantidade de camadas a serem empregadas depende de
alguns fatores como, a complexidade da função a ser aprendida, pois à medida que se
segue da primeira camada intermediária em direção a camada de saída, as funções
implementadas dentro da rede vão se tornando mais complexas.
O número de neurônios determina a capacidade da rede em resolver problemas
de determinada complexidade. Logo quanto maior o número de neurônios, maior a
complexidade da rede e maior será o alcance em termos possíveis soluções.
As formulas se baseiam para apenas uma saída de uma rede igual a da Figura 10,
ou seja, para uma RNA do tipo MLP.
mibvbvxvfvfy i
L
l
n
jljljili ,,2,1;0
1 1012 K=
+
+= ∑ ∑
= =
( )( )bWbVxVfWfy TT0012 ++=
Considerando entrada de polarização na rede MLP e funções de ativação do tipo
linear na camada de entrada, tem-se a saída z do neurônio da camada intermediaria
como:
= ∑
=
n
iijij xwfz
01
39
Onde f(1) é a função de ativação da camada intermediaria, j o numero do
neurônio da camada escondida e i o numero do neurônio de entrada. A saída da rede y é
calculada como:
= ∑
=
M
jjkjk zwfy
02
Onde f(2) seria a função de ativação do neurônio de saída e k o numero do
neurônio de saída.
Na forma de matrizes:
( )xWfz T11=
( )zWfy T22=
Onde:
[ ]TTzz 1≡
3.3.5 Treinamento da RNA
O processo de treinamento da RNA consiste em ajustar os pesos das conexões e
níveis dos bias, melhorando o seu desempenho. Através das modificações nos
parâmetros, a rede responderá de maneira nova, se adaptando ao ambiente. Como pode
ser percebido, o conhecimento passado a rede é armazenado nas suas conexões.
40
Basicamente existem três tipos de treinamento:
1-Treinamento supervisionado
2-Treinamento não supervisionado
3-Treinamento por reforço
O treinamento supervisionado caracteriza-se pela disponibilidade de
conhecimento ou informação sobre o sistema na forma de padrões entrada / saída. Os
parâmetros da rede são ajustados tendo como base o sinal de erro e os padrões de
treinamento. O sinal de erro é definido como a diferença para uma mesma entrada entre
a saída da rede e a saída desejada. A desvantagem desse método é que rede pode não
aprender novas estratégias para situações particulares que não foram consideradas no
conjunto de treinamento.
O treinamento não adaptativo, ou offline, é aquele onde a rede é inicialmente
treinada utilizando um conjunto de padrões de entrada saída. O treinamento adaptativo,
ou online, destina-se para o processo de treinamento onde a rede é treinada de forma
permanente enquanto está sendo utilizada.
3.3.6 Algoritmo de Retropropagação
Existe uma grande variedade de algoritmos para o treinamento de uma rede
neural, mas o mais popular é o algoritmo Backpropagation.
O algoritmo se constitui basicamente em duas etapas, a etapa forward onde as
entradas da rede são propagadas através dela, camada por camada, mantendo os pesos
fixos. A saída gerada é então comparada com a saída desejada, assim se é calculando
um sinal de erro. Na segunda etapa, esse erro é retropropagado (backward), o sinal do
41
erro gerado é propagado da camada de saída para a camada de entrada, podendo assim
cada elemento da rede receber a porção do erro relativa à sua contribuição ao erro total,
de maneira que ao final do processo a rede se equivale o mais próximo o possível da
resposta.
Neste momento os pesos sinápticos baseado no sinal de erro recebido serão
ajustados para cada elemento de modo a fazer a rede convergir para um estado no qual a
resposta desejada se equivale o mais próximo possível à resposta obtida.
Figura 11: Esquematização do processo do algoritmo Backpropagation
Passos para o treinamento
1. Inicialização: recomenda-se colocar valores aleatórios aos pesos e níveis de
bias, em uma distribuição uniforme, cuja média deverá ser zero.
42
2. Apresentação dos exemplos de treinamento (offline ou não adaptativo): para
os exemplos apresentados em uma época (conjunto de treinamento) à rede realiza-se a
propagação do sinal e depois a retropagação do erro com a correção nos pesos.
3. Propagação dos sinais: um vetor de sinais x(n) é aplicado à entrada da rede e
calcula-se o sinal de saída para todos os neurônios, começando da camada de entrada
até a camada de saída. Em seguida, calcula-se o erro para cada neurônio da camada de
saída, pela comparação entre y(n) com o vetor de sinais de saída desejados d(n). desta
forma calcula-se com este erro, o erro médio global. O erro é dado por:
)()( nynderro −=
Em que:
• y (n) é a resposta calculada;
• d (n) é a resposta desejada.
4. Retropropagação dos sinais de erro: calculam - se os gradientes locais para
todos os neurônios da camada de saída.
A taxa de aprendizagem η é responsável pela velocidade com que se dá a busca
no espaço de peso, em direção aos valores que resultam um erro global mínimo.
Em seguida, calculam-se os ajustes para os pesos daquela camada, bem como os
de bias, os quais devem ser somados aos valores atuais. Esta correção é dada pela
aplicação da regra delta, com o objetivo de minimizar o erro.
43
Formulação Matemática do algoritmo Backpropagation
A atualização dos pesos nas ligações da rede utilizando a função de ativação
sigmóide seria:
miyYe iii ,,2,1 K=−=
( ) mieyy iiii ,,2,112K=−=δ
( ) Liwzzm
iiillli ,,2,11
1
21K=−= ∑
=
δδ
njLlxww ljljlj ,,1,0,,2,1111 KK ==+= δη
Llmizww ililil ,,1,0,,2,1222 KK ==+= δη
Na forma matricial:
yYe −=
( )eydiagydiag }{1}{2 −=δ
( ) 21 }{1}{ δδ Wzdiagzdiag −=
TxWW )( 111 δη+= TzWW )( 2
22 δη+=
44
3.3.7 Projeto das RNAs
Em linhas gerais, o projeto de criação de uma RNA pode ser descrito nas 5
etapas a seguir:
1. Coleta e Seleção de Dados do sistema: A coleta e seleção dos dados têm
propósito de minimizar o erro, cobrindo todo campo de extensão do problema. Esses
dados podem ser divididos em dados para treinamento e dados para validação. Os dados
de treinamento são usados para treinar inicialmente a rede, enquanto os dados de
validação para verificar posteriormente o desempenho da rede, isto é, se as dados
apresentados à rede são adequados;
2. Configuração da Rede: destina-se a escolha do tipo de rede ser usada, a
quantidade de camadas, números de neurônios e determinação do algoritmo de
treinamento e etc.
3. Treinamento: O treinamento deve ser interrompido quando a rede apresentar
uma boa capacidade de generalização e quando a taxa de erro for suficientemente
pequena, ou seja, igual ou menor que o erro admissível ou necessário. Logo, deve-se
encontrar um ponto ótimo de parada com um erro mínimo e alta capacidade de
generalização.
4. Teste: neste momento o conjunto de teste é utilizado para determinar o
desempenho da rede com dados que não foram previamente utilizados no treinamento.
5. Integração: é a etapa final do projeto no qual a rede já treinada e validada
poderá ser aplicada ao objeto de estudo.
45
4 CONTROLADORES
4.1 Controle
O objetivo do controlador sobre a planta é fazer com que ela siga um sinal de
referencia desejado e alem de manter a saída da planta constante para uma faixa de
cargas aplicadas sobre ela.
Os controladores do tipo PID são os controladores mais utilizados na indústria,
por esta razão também são base para controladores mais complexos.
4.1.1 Controlador Proporcional, Integral, e Derivativo (PID)
Normalmente o controlador PID é dada pela equação:
∂
∂++= ∫ t
teTddte
TiteKptu
t )()(
1)()(
0τ
Onde u(t) é o sinal que será aplicado na planta, chamado de sinal de controle,
e(t) é definido como sendo o erro entre o sinal da saída da planta com relação ao sinal
da referencia, e(t) = r(t) – y(t). Ti é o tempo de integração, e Td é o tempo de derivação,
Kp é chamado de ganho do regulador. A figura 12 mostra os principais sinais no
sistema de malha fechada.
46
Figura 12: Controlador PID
O controlador proporcional mais o derivativo (PD) acrescentam um zero no
sistema, e esse zero pode aumentar o amortecimento do sistema, melhorando a
estabilidade e reduzindo o tempo de acomodação. O zero apresentado também pode
melhorar o tempo de subida pode acrescentar um sobre nível na resposta.
O controlador com proporcional e integral (PI), alem de poder eliminar o erro
em regime permanente, em malha fechada ele da uma resposta mais rápida para a
planta.
Para se ajustar o compensador PID normalmente se escolhe Kp para se obter a
velocidade desejada de resposta, depois se escolhe a razão de Ti para encontrar o
desempenho em regime permanente desejado, o que pode fazer com que seja necessário
reajustar o parâmetro Kp. Ao final processo de ajuste se necessário adiciona-se a ação
da parte derivativa para poder reduzir o sobre nível e o tempo de acomodação.
Resumidamente os efeitos dos parâmetros são:
- Aumentando-se a razão de reajuste (Ti) e o ganho, aumenta se a velocidade de
resposta e reduz-se o erro em regime permanente.
- Aumentando-se a razão de reajuste reduz a estabilidade do sistema.
- Aumentando se o tempo de derivação aumenta a estabilidade do sistema.
47
Tabela 1: Tabela com os efeitos dos parâmetros do PID Resposta Tempo de
Subida Sobre
elevação Tempo de
estabilização Erro em regime
permanente Kp Diminui Aumenta Não altera Diminui Ki Diminui Aumenta Aumenta Elimina Kd Não Altera Diminui Diminui Não altera
As características de desempenho de um sistema de controle em muitos casos
são especificadas em termos de sua resposta transitória no domínio do tempo. Os quatro
termos de maior importância num sistema de malha fechada são:
- Tempo de subida: É o tempo que se leva para a saída da planta ir de 10% a
90% do valor desejado.
- Sobre elevação: É o valor máximo que a resposta pode achegar em regime
permanente, o valor é dado normalmente em %.
- Tempo de estabilização: É o tempo em que a resposta leva para ficar dentro de
uma faixa especificada.
- Erro final ou em regime permanente: É a diferença entre a saída estacionária ou
regime permanente e a saída desejada.
4.1.2 Ajuste do compensador PID
Para que a planta apresente o comportamento desejado em malha fechada, é
necessário ajustar os parâmetros do compensador PID, para que isso seja possível
existem diversos métodos de ajuste. Um método é a calibragem direta dos parâmetros
através da resposta apresentada no sistema, outra técnica para sintonia ou calibração do
regulador PID é usando Ziegler-Nichols.
48
4.1.3 O Algoritmo de Ajuste Ziegler-Nichols
O algoritmo é baseado em observações empíricas de estratégias de ajuste do PID
para diversos tipos de processos, existem dois métodos para a escolha do primeiro
conjunto de parâmetros para o controlador PID.
Método da Resposta ao Degrau
O método consiste em aplicar um degrau unitário na entrada da planta em malha
aberta e retirar dois parâmetros dela, a inclinação da tangente ascendente da curva da
resposta e o tempo de atraso aparente. O método tende a produzir um sistema cuja
resposta transitória oscilatória e que necessitando realizar a sintonização mais uma vez.
Outro problema é que a planta precisa estar em malha aberta para que os parâmetros
sejam medidos, desta forma que a resposta em malha aberta seja estável.
Método da Máxima Sensibilidade
O método de sintonia se baseia em encontrar o ganho em que a resposta de
Nyquist do sistema cruza o ponto crítico, experimentalmente pode se aumentar o ganho
do proporcional até que a resposta da planta apresenta oscilações sustentadas, feito isso
se mede o tempo entre as oscilações.
Uma complicação deste método é do fato de funcionar somente para plantas de
ordem maior que 2, e que não sejam criticamente amortecido ou superamortecidos, pois
não apresentam oscilações na resposta transitória.
49
4.1.4 Modelo PID Discreto
Para o modelo discreto, é apresentado o PID de Posição e o PID de Velocidade.
O algoritmo do PID de Posição é chamado assim porque ele possui um sinal de controle
inicial, 0u , como base.
( )0
0
)1()()()()( u
T
neneKTdne
T
KTneKnu
s
n
ii
s +−−
++= ∑=
O algoritmo do PID de Velocidade usa, ao contrário da referencia fixa utilizada
no algoritmo posicional, o valor controle anterior como referência. Em essência, o
controle é calculado como uma mudança.
( ) ( ) 0)2()1(2)()()1()()1()( uneneneT
KTdne
T
KTneneKnunu
si
s +−+−−++−−+−=
O modelo discreto irá trabalhar com um período de amostragem Ts, que deve ser
o menor tempo possível, assim o controlador funcionará melhor e terá menos
distorções. Porem tempos muito curtos resulta em amostras repetidas e com isso
cálculos desnecessários.
4.2 O Controlador PI Fuzzy
Um dos tipos de controlador Fuzzy implementados nesse projeto é o PI Fuzzy,
que utiliza como entradas o erro da referência em relação ao sinal de saída, e a derivada
50
desse erro (variação do erro com relação ao erro anterior). Na verdade, somente isso,
caracteriza um controle do tipo PD Fuzzy, então para se configurar o controlador PI
FUZZY se integra a saída do controlador PD Fuzzy, ou em termos discretos, é realizado
um somatório da saída do controlador, tornando-se um controle PI Fuzzy.
4.3 Controle Adaptativo de um PID usando RNAs Recursivas
O controlador é uma rede neural baseada nas equações discretas do controlador
PID, onde os ganhos Kp, Ki e Kd , não permanecem fixos , mas são atualizados a cada
interação. Os ganhos são calibrados on-line usando um sistema Jacobiano e utilizando
um algoritmo de gradiente descendente no algoritmo de treinamento.
Para poder modelar a rede neural como um PID primeiramente precisamos
passar a equação do PID contínuo para o discreto.
A equação do controlador PID no domínio S pode ser dada como:
)1
()(
)(
s
sKd
s
KiKp
sE
sU
τ+++=
Neste modelo, o termo derivativo é utilizado com uma aproximação da derivada,
para se reduzir o efeito do ruído nas medidas. E a representação desta equação no tempo
discreto se dará através da passagem do domínio S para o domínio Z, utilizando a
transformação bilinear, ou conhecida também como método de Tustin.
+
−≡
−
−
1
1
1
12
z
z
TS
51
O sinal de controle será constituído desta forma:
)()()()( nwKdnvKineKpnu ++=
Onde v(n) é o termo integral e w(n) é o termo derivativo.
[ ])1()(2
)1()( −++−= neneT
nvnv
[ ])1()()1()(0
1 −−+−= nenenpnpα
α
)(2
)( 0 nwnpα
=
)(2
)(0
npKd
nKdw
=
α
T+= τα 20
T−= τα 21
A partir dessas equações discretas modelou-se uma rede com apenas 3 neurônios
na camada escondida, com funções de ativação do tipo linear e com uma realimentação
interna na camada escondida com tempo de atraso de uma amostragem. A entrada para
a rede seria o sinal de erro, enquanto a saída seria o sinal de controle. Dessa forma a
rede pode ser representada através de três matrizes.
52
=
12
1
1
TW
−
=
201
012
000
T
TR
=
02
2
α
KdKiKpW
Os valores de W1 seriam os ganhos dos pesos entre a camada de entrada e a
camada escondida, W2 seriam os ganhos entre a camada escondida e a camada de saída.
T seria o tempo de amostragem. E a matriz R seria os ganhos dos parâmetros recursivos
da rede.
Figura 13: PID Neural
Pela figura se observa que a rede possui quatro parâmetros que podem ser
alterados: Kp, Ki, 0
2
α
Kd e
0
1
α
α. Enquanto os outros parâmetros ou são dependente
destes quatro ou são fixos.
A saída do controlador, u(n), é:
53
)()()()( 3*
21 nOKdnOKinOKpnu ++=
)()( 1 nOne =
[ ])1()(2
)1()()( 22 −++−== neneT
nOnOnv
[ ])1()()1()()( 33 −−+−== nenenOnOnp α
0
2*
α
KdKd = e
0
1
α
αα =
A adaptação da rede se realiza através do algoritmo de treinamento baseado no
método do gradiente que atualiza os parâmetros variáveis da rede, tendo como base o
erro entre o valor da saída do controlador, u(n), e o valor desejado, d(n).
Pode-se realizar um treinamento offline, com um conjunto de dados para as
saídas desejadas conforme o sinal de erro na entrada do controlador, gerados a partir da
simulação de um controlador PID. Pode-se optar por não realizar o treinamento offline e
utilizar os parâmetros contidos num PID já ajustado ao sistema.
Para a realização do treinamento offline utiliza-se as seguintes equações na
atualização dos parâmetros:
( )1)()()1( OnenKpnKp −−=+ η
( )2)()()1( OnenKinKi −−=+ η
( )3** )()()1( OnenKdnKd −−=+ η
54
∂
∂−−=+
αηαα 3* )()()()1(
OnKdnenn
Para o treinamento online da rede neural, projeta-se um sistema que servirá de
referencia para o ajuste do controlador. Na medida do tempo, devido a minimização do
erro pelo controlador, a resposta da planta vai se aproximando da resposta do modelo.
Figura 14: Diagrama de Blocos com PID Neural e Modelo de Referencia
A saída de referencia é gerada on-line, a partir do modelo construído com base
no modelo geral para equações de segunda ordem:
22
2
2)(
nn
n
rm wSwS
wSG
++=
ξ
Utilizando-se de novo da aproximação bilinear, se obtêm:
55
[ ])2()1(2)(1
)2()1()(00
2
0
1 −+−++−−−−= nrnrnrc
nyc
cny
c
cny rmrmrmrmrmrm
144
22
2
0 ++=TT
cτξτ
28
2
2
1 +−
=T
cτ
144
22
2
2 +−=TT
cτξτ
Para um sistema que possui apenas uma entrada e uma saída, SISO, e o tempo de
amostragem for suficientemente pequeno, o sistema jacobiano pode ser aproximado
para:
)1()(
)1()(
)(
)()(
−−
−−≈
∂
∂=
nunu
nyny
nu
nynJp
O método utilizado na atualização dos parâmetros é um pouco diferente do
utilizado no treinamento offline, pois agora não se este interessado na minimização
imediata dos erros.
A maior diferença é a utilização do erro2 e do jacobiano, que são utilizados para
melhorar o desempenho e minimizar o efeito do erro na atualização dos ganhos do PID
Neural
( )( ))()(2)()()1( 1 nJpneOnenKpnKp −−−=+ η
( )( ))()(2)()()1( 2 nJpneOnenKinKi −−−=+ η
( )( ))()(2)()()1( 3** nJpneOnenKdnKd −−−=+ η
56
( ))()(2)()()()1( 3* nJpneO
nKdnenn −
∂
∂−−=+
αηαα
4.4 Neuro-Fuzzy
A integração das redes neurais e dos sistemas de inferência fuzzy podem ser
divididos em 3 categorias principais: cooperativo, concorrente e modelos neuro-fuzzy
integrados.
O grande interesse nessa união é devido ao fato de que essas duas técnicas juntas
podem prover uma maneira melhor de resolver problemas do que outros métodos. Ao
fato que juntas elas tem a capacidade de armazenar informação nos pesos das conexões
da rede neural, dessa forma havendo aprendizado, e a capacidade de se estruturar regras,
que são de fácil compreensão, sendo essa característica dos sistemas de inferência
fuzzy. Dessa maneira pode-se ater dizer que essas duas técnicas são complementares.
Os sistemas cooperativos são aqueles sistemas onde uma das duas técnicas altera
algum parâmetro da outra, podendo-se dizer que uma vai aperfeiçoar a tarefa realizada
pela outra técnica, mas elas estão claramente separadas.
No modo concorrente uma técnica apenas da assistência a outra, por exemplo,
como conseguir algum parâmetro que não pode ser feito de forma direta, mas mesmo
assim, as duas técnicas estão separadas e os sistemas permaneçam mesmos durante o
processo.
O terceiro tipo é onde de fato de funde as duas técnicas. Dessa união se pode ter
redes neurais que possuem neurônios fuzzy, neurônios que no lugar da função de
57
ativação se tem o processo de inferência fuzzy, ou sistemas baseados como se fossem
redes neurais, mas que implementam a capacidade de inferência de um sistema fuzzy.
No nosso trabalho optamos pelo modo cooperativo, dessa maneira poderias se
utilizar às capacidades de ambas as técnicas, pois para haver essa cooperação não seria
necessário método de desenvolvimento diferente dos que são normalmente utilizados
para cada uma das técnicas individualmente.
No método utilizado o algoritmo do PID Neural será utilizado em conjunto com
um sistema Fuzzy de inferência do tipo Mandani, alterando a taxa de aprendizado dos
parâmetros da Rede. O sistema FUZZY irá controlar a quantidade que o erro irá
influenciar no ajuste dos parâmetros, uma melhoria da função implementada pelo
sistema jacobiano.
58
5 PARTE PRÁTICA
5.1 Servomotores
Servomotores são uma categoria de motores que têm como principais
características o controle de sua posição angular por meio de PWM (Pulse Width
Modulation) e a sua alta capacidade de torque. Tais características fizeram com que os
servomotores fossem altamente utilizados nas áreas de aeromodelismo e robótica. A
Figura 15 apresenta um típico servomotor.
Figura 15: Um modelo de servomotor típico
Os servomotores têm a capacidade de obter torque muito superior ao
normalmente obtido por motores DC. Isso decorre do fato de eles realizarem
movimentos curtos (0 a 180° usualmente) e relativamente lentos, quando comparados a
outros tipos de motores. Na prática eles sacrificam a sua velocidade por mais torque, o
que é possível devido a existência de um sistema redutor de velocidade conectado ao
eixo de giro do servomotor. Esse sistema é constituído por uma série de engrenagens
que reduzem o arco de giro do servo, que ao invés de girar diversas voltas, realiza
apenas uma parte de uma volta.
59
Deve se deixar claro que o motor que movimenta o servomotor nada mais é do
que um pequeno motor DC. O sistema redutor e um sistema de realimentação é que
diferenciam os servomotores dos outros motores. Como mencionado anteriormente, os
servomotores têm sua posição angular controlada por PWM, isto é, sua posição depende
de uma sequência de pulsos de entrada com diferentes larguras, mas que mantêm uma
mesma frequência (50 Hz, um pulso a cada 20 ms). Em geral, um pulso de largura 1 ms
resulta no movimento do servo para a posição de 0°, enquanto que um pulso de 2 ms
resulta no movimento do servo para a posição de 180°, sendo que quaisquer larguras
intermediárias a esses valores resultarão em ângulos intermediários, proporcionalmente.
A largura de pulso de 1,5 ms normalmente resulta em uma posição central. A figura 16
ilustra essas situações. Note que tais valores são apenas generalizações, cada modelo de
servo motor possui características diferentes, podendo ter valores de largura de pulso
que excursionam além dos citados. Internamente, o que acontece é que o motor DC
recebe diferentes níveis de tensão concordantes com a largura de pulso de entrada, o que
resulta nas diversas posições angulares de saída.
Figura 16: Relação da largura de pulso enviada ao servo com a rotação angular do mesmo
60
Além desse mecanismo de largura de pulso, os servomotores possuem um
sistema de realimentação negativa que os permite saber se estão realmente na posição
desejada. Trata-se de um potênciometro acoplado ao eixo do motor DC (conectado
através do sistema de engrenagens), o qual realimeta uma tensão que é então comparada
à tensão que deveria haver devido ao pulso de entrada. Esse procedimento é
normalmente realizado por um circuito lógico que faz as devidas conversões de tensão
para largura de pulso e vice-versa. O servomotor então movimenta-se em direção a
posição desejada e compara a saída com a entrada, corrigindo quaisquer diferenças.
Trata-se então de um sistema interno de controle de posição. A figura 17 mostra os
componentes internos de um servomotor.
Figura 17: Componentes internos de um servomotor
61
5.2 Obtenção da Função de Transferência do Servomotor
O processo de obtenção da função de transferência dos servomotores utilizados
para a construção do manipulador robótico foi feita utilizando dados coletados por meio
de testes realizados sobre o próprio servomotor.
Foram coletados dois tipos de dados: posição do servomotor em relação ao valor
lido pelo conversor A/D ligado ao servomotor, e posição do servomotor em função do
tempo. O segundo tipo de dado foi utilizado para a obtenção da função de transferência,
enquanto que o primeiro foi utilizado para obter uma função entre o ângulo e o valor
AD correspondente, de forma a poder ter conhecimento da posição onde o servomotor
está. Dessa forma pode-se fazer a conversão dos dados A/D obtidos no tempo para
ângulos. O hardware utilizado na coleta de dados não será discutido nesse momento.
Por enquanto, basta saber que os valores A/D foram obtidos por meio de uma
realimentação dos servomotores utilizando potenciômetros.
Tendo esse conjunto de dados no tempo pode-se então obter a função de
trasferência do servomotor. Para tal foi utilizado um toolbox do software matemático
Matlab, o System Identification Tool, o qual possibilita ao usuário obter a função de
transferência de um sistema apenas usando vetores com dados de entrada e saída. Esse
toolbox permite escolher as características da função de transferência a ser obtida,
como, por exemplo, número de pólos, número de zeros, entre outras.
Após várias combinações de opções, chegou-se a conclusão de que a melhor
resposta vinha de uma função de transferência com 2 pólos. Note que nesse momento
foi necessário fazer um ajuste no ganho da função de transferência, definindo-o com o
valor de 180, referente ao valor final no qual o servo deve estar (devido as limitações
físicas do servomotor, ele nunca passa de 180°). Os pólos foram calculados com base
62
nesse valor de ganho. A Figura 18 ilustra a interface do System Ientification Tool, com
as opções que foram selecionadas para obter o modelo a esquerda, e os resultados
calculados a direita.
Figura 18: A interface para obtenção do modelo com as opções utilizadas e os resultados
É importante mencionar que para se obter uma função de transferência cuja
resposta no tempo fosse compatível com os dados coletados foi necessário aumentar o
número de iterações do toolbox, caso contrário, a curva obtida não chegava ao valor de
180° dentro do tempo medido na prática. A função de transferência obtida foi a
seguinte:
3,10332,20
10859,12
4
++=
ss
x
X
Y
63
A partir dessa função de transferência (contínua), foi obtida a função de
transferência discreta, pelo método de Tustin (usando tempo de amostragem de 20 ms, o
período do PWM enviado ao servomotor), mostrada a seguir:
665,0631,1
532,1064,3532,12
2
+−
++=
zz
zz
X
Y
Após a obtenção da função de transferência, pode-se visualizar o grau de acerto
da curva obtida pelo processo. No caso dos dados do servo, foi obtido um acerto de
87,28 %, o que resulta em uma função de transferência bastante realista.
Tendo a função de transferência do servo, foi possível então passar para a etapa
de simulação das técnicas de controle usando o próprio Matlab.
64
5.3 Kits de Desenvolvimento Plataforma Arduino:
Arduino é uma plataforma de hardware e software open-source baseado numa
placa para o microcontrolador ATMega, bastante flexivel e de grande facilidade de
implementação. Algumas vantagens da plataforma Arduino:
• É um sistema bastante barato: pode-se montar a placa ou adquiri-la.
• Multiplataforma: Seu ambiente de programação é simples e desenvolvido em Java,
o que o programa possível de rodar em diversos sistemas operacionais.
• É codigo aberto de software: O Arduino possui uma linguagem de programação
muito similar ao C++, podendo dessa forma utilizar as diversas bibliotecas desta
linguagem. Ele também pode utilizar a biblioteca do gcc para a arquitetura AVR, o
AVR-GCC. Além do fato de ser um software de código aberto possuindo dessa
maneira muitas bibliotecas para diversas finalidades.
• Código aberto de Hardware: A plataforma Arduino é baseada no uso do
microcontrolador ATMEGA, e devido ao fato de ser aberto, o hardware é atualizado
constantemente o que resulta em melhorias, atualizações e novas versões de placas.
Outra característica do Arduino é sua facilidade para aprender e programar na
sua plataforma, com um site que possui muitos códigos exemplos para aprender como
funciona. Sua programação também é simples devido a que ele não necessita de um
gravador externo, apenas de um cabo USB e de seu programa. Um kit de
desenvolvimento é mostrado na figura 19.
65
Figura 19: Kit Arduino Mega Kit PIC 18fUSB:
No inicio do projeto foi optado por usar o Kit 18fUSB, o qual utiliza o
microcontrolador PIC18F4550. A vantagem deste microcontrolador é em razão de
possuir bibliotecas disponibilizadas pela Microchip, o que no inicio do projeto
colaborou com a obtenção dos dados para a função de transferência. Mas depois desse
momento o kit foi trocado pela plataforma Arduino.
5.4 Construção do Protótipo
Na construção do protótipo do manipulador robótico, a primeira decisão a ser
tomada foi o tipo de material pelo qual a estrutura seria constituída. Decidiu-se utilizar
madeira do tipo MDF, a qual é bastante leve e fácil de trabalhada, além de ter um baixo
custo. Inicialmente as partes de madeira foram juntadas utilizando cola para madeira,
mas esse método logo se mostrou ineficaz pelo fato de que grandes partes das junções
do braço tinham uma área muito pequena de contato. A estratégia de construção foi
então alterada para a utilização de parafusos para unir as partes de madeira, resultando
em uma maior facilidade de alteração e desmonte das peças, caso fosse necessário. Essa
66
decisão foi fundamental no decorrer do desenvolvimento da parte prática, quando foram
necessárias mudanças na estrutura do manipulador robótico devido ao peso da garra e a
instabilidades no movimento. Alguma partes do manipulador ainda fizeram o uso da
cola, como a base (onde havia uma maior área de contato entre as partes coladas),
enquanto que outras junções utilizaram tanto cola como um parafuso, no caso de áreas
onde ocorria movimento em torno do eixo do parafuso e a inclusão de mais de um
parafuso na região danificaria a madeira, pois a área era reduzida.
O modelo inicial para o manipulador robótico consistia de uma base plana
próxima ao solo, uma haste vertical e um antebraço formado por uma haste horizontal
com um desvio angular a uma certa distância da haste vertical, como mostrado pela
figura 20. Note que exitia uma pequena haste entre a ponta do antebraço e a garra. Essa
haste seria livre (sem controle ou fixação) fazendo que, com a força da gravidade, a
garra sempre apontasse para o solo com um ângulo de 90°, independentemente da altura
ou orientação angular do antebraço. Perceba ainda, pela figura 20, as indicações dos 3
graus de liberdade controlados: base, antebraço e garra.
Figura 20: Esquema inicial do protótipo do braço robótico
67
Na media que a construção do protótipo foi se desenvolvendo, percebeu-se uma
série de falhas nesse esquema inicial, sendo a principal delas em relação a capacidade
dos servomotores de levantarem a garra. Por meio de testes, verificou-se que os
servomotores não eram capazes nem de levantar o antebraço e a garra dessa maneira,
quanto mais um objeto. Através de pesquisas e observações, a solução encontrada foi a
inclusão de uma haste maior para o antebraço que se estendia de um comprimento
semelhante para ambas as direções (direita e esquerda), a partir do topo da haste
vertical. O lado do antebraço oposto ao da garra possuiria um contrapeso de peso
equivalente ao da garra (em torno de 100 g), de forma que quando o servomotor tivesse
que mover a garra, esse contrapeso o auxiliaria. Essa solução mostrou-se extremamente
eficaz, permitindo ao servomotor levantar a garra e um objeto que não fosse muito
pesado. A figura 21 ilustra esse novo esquema de montagem, bem como uma mudança
na estrutura da base do manipulador robótico, onde foi construída uma caixa vasada em
duas laterias, permitindo a inserção do circuto que realizará a alimentação e o controle
dos sermotores.
Figura 21: Esquema final de construção do braço robótico
68
Outra mudança realizada foi a não inclusão da pequena haste livre que ligaria a
garra ao antebraço. Optou-se por parafusar a garra na extremidade do antebraço (com a
mesma orientação que essa extremidade). Desse modo, com a variação do ângulo do
antebraço, e consequentemente de sua altura, a garra tem uma orientação diferente. A
inclinação da ponta do antebraço foi definida de modo que a altura mínima do antebraço
faça com que a garra fique próxima ao solo, orientada com um ângulo próximo de 90°
em relação a ele, como na Figura 21.
Além dessas mudanças, um ponto importante a se mencionar é o acoplamento
dos potenciômetros nos servos da base e do antebraço. Devido a necessidade de
realimentação das técnicas de controle, esse potênciometros precisavam estar no mesmo
eixo que os servomotores que realimentariam. Para tal, foram constrúidas estruturas em
“L” nas quais esse potenciômetros foram fixados com cola de secagem rápida. No caso
da base, a estrutura em “L” envolveu completamente o comprimento vertical do eixo,
enquanto que no antebraço, essa estrutura estava posicionada de forma perpendicular a
ele. No fim, esse esquema de estrutura de realimentação acabou sendo fundamental para
remediar o problema de estabilidade nesses dois eixos de movimento. Quando o
servomotor atingia certas posições (normalmente perto do ângulo de 90°), todo o eixo
de movimento (a haste vertical, no caso da base, e a haste do horizontal, no caso do
antebraço) entrava em um estado oscilatório em seus respectivos graus de movimento.
Com uma boa fixação das estruturas em “L”, esse problema foi resolvido.
Quanto a ligações elétricas, ambos os potênciometros tiveram seus terminais
extremos conectados por um mesmo fio, respectivamente, ao VCC e GND do kit
Arduino. Os pinos centrais dos potenciômetros foram conectados a duas entradas A/D
diferentes do kit. Os servomotes foram conectados em 3 entradas específicas para
servomotores no kit, cada uma com 3 pinos, VCC, GND e sinal. A figura 22 e a Figura
69
23 ilustram o esquema final de construção do braço robótico. Nela estão indicadas as
dimensões e os locais onde estão os servomotores e potenciômetros.
Figura 22: Vista lateral (esquerda) e frontal (direita) do manipulador
Figura 23: Vista lateral do manipulador com antebraço e garra
70
Os servomotores utilizados na parte prática são do modelo HXT 900, fabricados
pela Hextronik. Suas especificações e dimensões estão indicadas na Figura 24. A figura
25 contém a imagem real do servomortor em questão. Devido ao fato desse modelo de
servomotor não atingir completamente o movimento de 0° a 180°, optou-se por limitá-lo
a excursão angular de 10° a 170°, levando em conta, também, as carcterística vibratórias
do servomotor quando levado aos seus extremos.
Figura 24: Especificações e dimensões do servo HXT 900
Figura 25: Imagem real do servomotor HXT 900
71
5.5 Implementação do Sistema de Controle
Toda implementação prática das técnicas de controle desse projeto foram feitas
em software no kit Arduino, o qual utiliza uma linguagem de programação semelhante
ao C e C++. O ambiente de desenvolvimento utilizado foi o ambiente do próprio
Arduino.
A realimentação utilizada partiu dos potenciômetros acoplados ao eixo dos
servomotores da base e do antebraço. A tensão resultante do movimento dos
servomotores foi então realimentada em duas entradas analógicas do kit que possuem
um conversor A/D.
Primeiramente, foi realizada uma coleta de dados para se definir uma função que
relacionasse o ângulo do servomotor com a largura de pulso do PWM enviada a ele. Por
meio de observação, obtiveram-se valores de largura de pulso que resultavam em um
conjunto de ângulos que foram marcados na base do manipulador robótico, ao redor do
eixo de movimento do servomotor. Usando esses dados em conjunto com o Matlab, foi
possível obter uma aproximação de uma função que os relacionasse. A função obtida foi
a seguinte:
3006,5067522,90098,0arg 2 ++= ÂnguloÂngulopulsodeuraL
Com essa equação em mãos, foi implementado um programa que recebesse um
ângulo do usuário e retornasse o valor lido pelo conversor A/D, proveniente da
realimentação do potenciômetro. Para que fosse possível obter o erro por meio dos
valores A/D lidos, foi necessário encontrar uma relação entre os valores A/D e o ângulo
ao qual eles correspondiam, e para tal, foi utilizado esse programa. Tendo posse desse
72
novo conjunto de dados, o Matlab foi utilizado novamente para se obter uma
aproximação da curva que relaciona valor A/D e ângulo. Os resultados obtidos foram os
seguintes:
Base: 1171,483086,0000057,0 2 −+−= ADADÂngulo
Antebraço: 2343,2171982,0000081694,0 2 +−−= ADADÂngulo
A diferença nas equações resulta do fato de o potenciômetro foi acoplado a cada
servomotor em uma posição angular diferente, mesmo que os dois servomotores sejam
iguais e estivesse na mesma posição angular. Com essas equações, foi possível
implementar os códigos para cada técnica de controle.
73
6 RESULTADOS OBTIDOS
6.1 Simulações
As figuras a seguir ilustram os diagramas de blocos e resultados dos métodos de
controle simulados. Em todos os casos, os gráficos se referem a sinais de entrada com
referência em 90°. Todas as simulações foram feitas no Simulink, com exceção do PID
Neural, o qual teve sua simulação feita em código, no próprio Matlab.
6.1.1 PID
Diagrama de blocos:
Figura 26: Diagrama de blocos do controlador PID
74
Resultado gráfico:
0 1 2 3 4 5 6 7 80
10
20
30
40
50
60
70
80
90
Tempo (s)
Angulo
(gra
us)
Figura 27: Resposta do PID a uma referência de 90°
6.1.2 PI Fuzzy
Diagrama de blocos:
Figura 28: Diagrama de blocos do controlador PI Fuzzy
75
Resultado gráfico:
0 1 2 3 4 5 6 7 80
10
20
30
40
50
60
70
80
90
Tempo (s)
Angulo
(gra
us)
Figura 29: Resposta do PI Fuzzy a uma referência de 90°
6.1.3 PID Neural
Resultado gráfico:
0 1 2 3 4 5 6 7 80
10
20
30
40
50
60
70
80
90
Tempo (s)
Angulo
(gra
us)
Figura 30: Resposta do PID Neural a uma referência de 90°
76
6.2 Resultados Práticos
A seguir são mostrados os resultados práticos obtidos com as implementações
dos métodos de controle. Também é mostrado o fluxograma ilustrando o funcionamento
do código de cada método.
6.2.1 PID
Para não haver uma resposta muito abrupta, foi optado por uma resposta com um tempo
de subida de aproximadamente 3 segundos, sem sobre elevação, com o tempo de
acomodação mais rápido possível, e um erro em regime permanente de
aproximadamente 1% ou menos de 1 grau. Para a implementação do controlador foi
escolhido o algoritmo de PID de velocidade. Os parâmetros utilizados no controlador
foram:
91572183760.00003414== PKK
572183760.00341491== Ii
KT
K
0== DKKTd
77
0 1 2 3 4 5 6 7 80
10
20
30
40
50
60
70
80
90
Tempo (s)
Angulo
(gra
us)
Figura 31: Resposta do PID para referência de 90°
Como pode ser observado pela Figura 31, o tempo de subida foi de
aproximadamente 3,4 s, valor próximo ao simulado. No entanto, o tempo de
acomodação foi muito grande (em torno de 6,1 s).
78
Figura 32: Fluxograma para código do PID
6.2.2 PI Fuzzy:
Para o controlador PI Fuzzy, foi decidido apenas o tempo de subida de 3
segundos, devido à característica do controlador que apresentou um comportamento
bastante estável e linear. As funções de pertinência utilizadas estão ilustradas na Figura
33. A tabela 2 contém as regras fuzzy utilizadas.
79
Figura 33: Funções de pertinência das entradas (em cima) e saídas (em baixo)
Tabela 2: Regras fuzzy Erro\ Variação do erro Negativo Zero Positivo
Negativo Negativo Negativo Negativo
Zero Negativo Zero Positivo
Positivo Positivo Positivo Positivo
0 1 2 3 4 5 6 7 80
10
20
30
40
50
60
70
80
90
Tempo (s)
Angulo
(gra
us)
Figura 34: Resposta do controlador PI Fuzzy
80
Como observado pela figura 34, o tempo de subida utilizando o PI Fuzzy foi de
aproximadamente 3 s, enquanto que na simulação o tempo obtido foi de 3,2 s. Note
também que não há sobre-elevação é o tempo de acomodação é de 4s.
Figura 35: Fluxograma para o código do PI Fuzzy
81
6.2.3 PID Neural
Para os testes com o PID Neural, não foi realizado um treinamento prévio da
rede offline, pois se preferiu ao invés disso utilizar os parâmetros, (Kp, Ki e Kd) já
contidos no controlador PID.
Para o modelo de referencia foram escolhidos os parâmetros 1.11=τ e 1=ξ ,
que resultam num modelo com tempo de subida próximo de 3 segundos e sem sobre
elevação. Com relação ao algoritmo de aprendizado, a taxa de aprendizado teve de ser
escolhida para que não fosse demasiadamente grande a ponto de fazer o sistema oscilar
devido a grande variações dos parâmetros ou excessivamente pequena, fazendo com que
a atualização dos pesos acontecesse de forma muito lenta. Assim foi utilizado
-13101×=η , onde valores um pouco acima ja começam a apresentar respostas não
confiáveis.
0 1 2 3 4 5 6 7 80
10
20
30
40
50
60
70
80
90
Tempo (sec)
Angulo
(gra
us)
Referencia
Movimento 1
Movimento 3
Movimento 5
Figura 36: Resposta do PID-Neural
82
Na Figura 36 foram mostrados os gráficos do ângulo de saída da base, fazendo a
transição entre 0 até 90 graus. No gráfico podemos ver que com o passar do tempo a
resposta de saída vai tendendo a ficar cada vez mais próxima com a resposta do modelo
de referencia.
Figura 37: Fluxograma para o código do PID Neural
83
6.2.4 Neuro-Fuzzy
Para o controlador Neuro-Fuzzy concorrente foi construído utilizando o
controlador Fuzzy e o PID-Neural, demonstrados anteriormente, em paralelo.
A idéia era fazer com que a resposta do controlador fosse uma combinação da
resposta dos dois controladores, uma resposta mais linear como o do PI Fuzzy e a
capacidade de se adaptar as respostas desejadas como PID-Neural. Adotou-se uma taxa
para a saída de cada controlador, a fim de fazer com que se possa definir a proporção de
que cada um terá na formação do sinal de controle. Os pesos utilizados na prática foram
de 30% PID Neural e 70% PI Fuzzy.
Para o Neuro-Fuzzy cooperativo utilizou se o sistema Fuzzy como um dos
parâmetros para o treinamento da rede neural. Para a entrada do Fuzzy foi utilizado o
erro em relação da referencia e o erro com relação a saída do modelo de referencia.
( )( )( )FuzzycrispsaidanJpneOnenKpnKp )()(2)()()1( 1 −−−=+ η
( )( )( )FuzzycrispsaidanJpneOnenKinKi )()(2)()()1( 2 −−−=+ η
( )( )( )FuzzycrispsaidanJpneOnenKdnKd )()(2)()()1( 3** −−−=+ η
( )( )FuzzycrispsaidanJpneO
nKdnenn )()(2)()()()1( 3* −
∂
∂−−=+
αηαα
84
0 1 2 3 4 5 6 7 80
10
20
30
40
50
60
70
80
90
Tempo (sec)
An
gulo
(gra
us
)
Referência
Concorrente
Coperativo 1
Coperativo 2
Figura 38: Resposta dos Controladores Neuro-Fuzzy
A figura 38 mostra a resposta do modo Concorrente e do modo Cooperativo, no
primeiro e do segundo movimento realizado pelo controlador, demonstrando a sua
capacidade de adaptação.
85
Neuro-Fuzzy Concorrente:
Figura 39: Fluxograma para o código do Neuro-Fuzzy Concorrente
86
Neuro-Fuzzy Cooperativo:
Figura 40: Fluxograma para o código do Neuro-Fuzzy Cooperativo
87
7 CONCLUSÃO
O objetivo desse trabalho foi estudar, compreender, simular, e implementar o
controle Neuro-Fuzzy em um manipulador robótico de 3 graus de liberdade. Foi
construído um protótipo, usando servomotores, no qual foram implementados todos os
tipos de controle aqui apresentados. Todos tiveram resultados satisfatórios, no entanto
pode-se perceber, comparando os resultados gráficos, que o PI Fuzzy se sobresai em
relação ao outros métodos de controle, com sua estabilidade de movimento e melhor
tempo de subida. É possível perceber, também, que controle Neuro-Fuzzy Concorrente
foi o que teve uma resposta mais próxima do PI Fuzzy, mas ainda mantém as
características do controle PID Neural. O controle Neuro-Fuzzy Cooperativo teve um
bom resultado, melhorando seu desempenho com a realização de novos movimentos,
como é possível perceber pelos gráficos. Conclui-se então que o controle Neuro-Fuzzy
em geral tem um grande potencial, combinando as características de ambos de acordo
com os parâmetros configurados.
Esse trabalho deve, então, ser visto como um ponto de partida para futuros
desenvolvimentos e aprimoramentos das técnicas aqui apresentadas. Existe muito a se
melhorar, e esperamos que esse estudo seja útil nesse processo.
88
8 BIBLIOGRAFIA
[1] Controle de um Braço Robótico Utilizando uma Abordagem de Agente Inteligente,
Tarig Ali Abdurrahman El Shheibia, Campina Grande – PB, Julho de 2001.
[2] Controle Fuzzy para Braço Robótico Utilizando a Abordagem Adaptativa Neuro-
Fuzzy (ANFIS) do Matlab, João Rodolfo Côrtes Pires e Cairo Lúcio Nascimento Júnior.
[3] Desenvolvimento de um Sistema para o Controle de um Braço Robótico, Felipe Luís
Aquino Pereira da Rocha, Uberlândia, Novembro/2003.
[4] Sistema de Controle de Braço Mecânico Automatizado, João Paulo de Lima, Saraiva
Julyana da Rocha Maranhão & Thiago Luiz Alves Listo, Belém – PA, 2008.
[5] Adaptive PID Control of a Nonlinear Servomechanism Using Recurrent Neural
Networks, Reza Jafari1 and Rached Dhaouadi.
[6] Neural Network Control of Nonlinear Discrete-Time Systems, Jagannathan
Sarangapani, The University of Missouri, Rolla, Missouri.
[7] Optimised Training Techniques for Feedforward Neural Networks, Leandro Nunes
& de Castro Fernando José Von Zuben.
[8] Redes Neurais Aplicadas em Estratégias de Controle Não Linear, Laércio Ender.
[9] Contribuições à análise de Robustez de Sistemas de Controle Usando Redes
Neurais, Oscar Gabriel Filho.
[10] Indrodução às Redes Neurais Artificiais, Jorge M. Barreto.
www.inf.ufsc.br/~barreto/tutoriais/Survey.pdf
89
[11] Controle Neural Inverso para um Servomotor, Elton Rafael Alves, Belém – Pará,
Dezembro – 2008.
[12] Adaptation of Fuzzy Inference System Using Neural Learning, A. Abraham.
[13] Discrete-Time Control System, Katsuhiko Ogata. Prentice Hall, Englewood Cliffs,
1994
[14] Leonid Reznik, Fuzzy Controllers, Ed Newnes, Melbourne, 1997.