Documente Academic
Documente Profesional
Documente Cultură
FACULDADE DE TECNOLOGIA
FTL069 PROJETO DE FINAL DE CURSO II
MANAUS
AGOSTO – 2010
UNIVERSIDADE FEDERAL DO AMAZONAS
FACULDADE DE TECNOLOGIA
FTL069 PROJETO DE FINAL DE CURSO II
DEPARTAMENTO:
Departamento de Eletrônica e Telecomunicações
CURSO:
Engenharia da Computação
TITULO DE TRABALHO:
Realização de um controlador utilizando Redes Neurais para o controle de estabilização
do Pêndulo de Furuta
ALUNO:
César Vieira Rocha
PROFº ORIENTADOR:
Dr.-Ing. Vicente Ferreira de Lucena Júnior
MANAUS
AGOSTO – 2010
UNIVERSIDADE FEDERAL DO AMAZONAS
FACULDADE DE TECNOLOGIA
FTL069 PROJETO DE FINAL DE CURSO II
BANCA EXAMINADORA
(ASSINATURA)
(ASSINATURA)
(ASSINATURA)
cheguei.
v
Sumário
Abreviações ................................................................................................................................... xi
Resumo ......................................................................................................................................... 16
Abstract ........................................................................................................................................ 17
1 Introdução............................................................................................................................. 18
1.1 Motivação ..................................................................................................................... 18
1.2 Objetivo ........................................................................................................................ 18
1.3 Organização da Monografia ......................................................................................... 19
3 Concepção ............................................................................................................................. 49
3.1 Plataforma utilizada ...................................................................................................... 49
3.2 Modelo Matemático ...................................................................................................... 50
3.3 Controlador de Estabilização ........................................................................................ 57
3.4 Controlador de Torque (Swing-up) ............................................................................... 59
3.5 União dos Controladores .............................................................................................. 60
3.6 Rede Neural .................................................................................................................. 62
3.6.1 Treinamento ...................................................................................................... 64
4 Resultados ............................................................................................................................. 66
4.1 Comparação das saídas ................................................................................................. 68
4.1.1 Controlador de Estabilização ............................................................................ 68
5 Conclusão .............................................................................................................................. 74
5.1 Resultados ..................................................................................................................... 74
5.2 Experiências.................................................................................................................. 74
5.3 Problemas ..................................................................................................................... 75
Apêndice A ................................................................................................................................... 77
Apêndice B ................................................................................................................................... 81
Apêndice C ................................................................................................................................... 83
vii
Agradecimentos
Eu gostaria de agradecer ao Prof. Dr.-Ing. Vicente Ferreira de Lucena Júnior por acreditar no
trabalho de conclusão de curso, bem como em outros projetos que pude participar no decorrer da
minha graduação.
Eu gostaria de agradecer aos amigos Thiago Brito, Mauro Freitas e Claudio Eduardo, que me
ajudaram muito e com quem pude realizar troca de conhecimento no decorrer de minha
formação. Eu gostaria também de agradecer a Ana Cristina que me ajudou muito no meu último
E por fim, mas não menos importante, gostaria de dar um agradecimento especial a minha
família. Meus pais, José Rocha e Maria José, que sempre me apoiaram nos momentos difíceis e
sempre me aconselharam de forma que pude encontrar o melhor caminho para todas as
dificuldades que encontrei. Meu irmão, Daniel, que é mais que um irmão, é meu melhor amigo e
sempre me apoiou em tudo que decidi fazer, estando sempre ao meu lado. E sua esposa
Daryanne, que sempre ao lado dele também me apoiou e ajudou em todos os momentos que
precisei.
viii
Lista de Figuras
Figura 4.8 - Comparação entre o controlador inteligente e o PD para controle do torque. .......... 69
Figura 4.9 - Comparação entre uma rede de 1 neurônio e o controlador PD. ............................... 70
Figura 4.10 - Comparação entre uma rede de 2 neurônios e o controlador PD. ........................... 70
Figura 4.11 - Comparação entre uma rede de 3 neurônios e o controlador PD. ........................... 71
Figura 4.12 - Comparação entre uma rede de 4 neurônios e o controlador PD. ........................... 71
Figura 4.13 - EQM entre a saída da RN e do REL para o controle de estabilização. ................... 72
Figura 4.14 - EQM entre a saída da RN e do PD para o controle de torque. ................................ 73
Figura A.1 - Menu Principal. ........................................................................................................ 77
Figura A.2 - Menu de Instalação. .................................................................................................. 77
Figura A.3 - Ícone do 6713DSK Diagnostics Utility. ................................................................... 78
Figura A.4 - Software de diagnóstico. .......................................................................................... 78
Figura A.5 - Alterando o compilador do Matlab........................................................................... 79
Figura B.1 - Peças para montar estrutura em "L". ........................................................................ 81
Figura B.2 - Estrutura para fixação do motor. .............................................................................. 81
Figura B.3 - Conexão de alumínio com encoder na extremidade. ................................................ 81
Figura B.4 - Haste de balanço. ...................................................................................................... 82
Figura B.5 - Pêndulo de Furuta finalizado. ................................................................................... 82
Figura B.6 - Fixação traseira dos fios. .......................................................................................... 82
Figura B.7 - Fixação lateral dos fios. ............................................................................................ 82
Figura B.8 - Fixação frontal dos fios. ........................................................................................... 82
Figura C.1 - Menu de configuração do Simulink. ......................................................................... 83
Figura C.2 - Configuração do Device Type. ................................................................................. 83
Figura C.3 - Configuração do Real-Time Workshop. ................................................................... 84
Figura C.4 - Re-build do sistema. ................................................................................................. 84
x
Lista de Tabelas
Tabela 2.1 - Comparação entre o cérebro humano e o computador [RuNo04]. ........................... 37
Tabela 2.2 - Funções de Transferência. ........................................................................................ 40
Tabela 3.1 - Valores empíricos de peso e medida. ........................................................................ 58
Tabela 3.2 - Valores dos ganhos. .................................................................................................. 58
Tabela 3.3 - Ganhos proporcional e derivativo. ............................................................................ 59
Tabela 3.4 - Decisão da rede neural. ............................................................................................. 62
xi
Abreviações
PD Proporcional Derivativo
BP Backpropagation
CC Cascade
I/O Input/Output
DC Corrente Direta
Terminologia
Pêndulo de Furuta Um sistema composto por dois braços que se movimentam, um braço
com movimentação horizontal e o outro braço com movimentação na
vertical. O braço da horizontal é impulsionado por um motor, o
impulso causado nele provoca o movimento do segundo braço. A
movimentação tem o intuito de manter o braço de movimentação
vertical estabilizado no ponto mais alto de sua trajetória.
Sistemas de São sistemas complexos criados para controlar uma determinada tarefa.
Controle Um sistema de controle é um programa (em nível de software) ou um
circuito (em nível de hardware) que estará implementando um
controlador para o sistema que se deseja manipular.
Malha Aberta É um sistema de controle direto, ou seja, o sistema recebe uma entrada,
passa por um controlador e depois define uma saída.
Inércia É uma propriedade física da matéria, que define que todo corpo em
repouso, tende a permanecer em repouso e todo corpo em movimento,
tende a permanecer em movimento, ou seja, a tendência é que a
matéria não modifique seu estado de movimentação.
Rede Neural Rede neural é um sistema distribuído baseado em ligações e nós. São
utilizadas como método de solução de problemas e seu funcionamento
é baseado no cérebro humano, de onde vem seu nome. Soluciona
problemas errando, fazendo descobertas, aprendendo e adquirindo
experiência para problemas determinados.
Entradas (Inputs) São os valores que precisam ser enviados para as redes. São valores de
amostragem feitos no problema que se deseja resolver, por exemplo, se
a rede irá calcular a aproximação de uma função, as entradas serão os n
primeiros termos da série, dessa forma ela irá aprender baseado nos
padrões que foi recebido.
Saída desejada A saída desejada é o valor que o usuário pretende obter após o
(Targets) funcionamento da rede. A rede utilizará as entradas para realizar os
cálculos e tentar aproximar ao máximo da saída desejada inserida pelo
desenvolvedor.
Época Época é o nome dado para o ciclo de cálculo do neurônio. Uma rede
que realiza o treinamento em 10 épocas, por exemplo, ela teve 10
ciclos de cálculo. Problemas complexos geralmente necessitam de
muitas épocas para que a aproximação seja feita.
xv
Resumo
Os controladores tanto de hardware como de software são cada vez mais utilizados no projeto
de sistemas. Nos estudos de sistemas de controle há uma busca por sistemas que cada vez
envolva menos ação humana, para diminuir o tempo de resposta e garantir a precisão. Essa
precisão de tempo e resposta rápida é possível ser garantida com controladores inteligentes.
Embora as mais variadas teorias mostrem como são possíveis as aproximações dos
controladores proporcionais, derivativos e integrativos para solução de problemas, os
controladores inteligentes são uma boa escolha na decisão para otimização do tempo. O uso
de rede neural é uma boa opção a ser considerada, pois aproximando a entrada fornecida com
a saída desejada é possível obter uma saída ótima no menor tempo possível. Essa
aproximação rápida é importante, pois a estabilização do sistema é de grande valia no sistema
de controle para equilíbrio de robôs, controle de trajetória, etc. O projeto apresentado trata de
um pêndulo de Furuta, mas pode ser feita uma analogia com problemas de maior
complexidade. O controle inteligente do pêndulo de Furuta mostrará que a teoria de redes
neurais é capaz de substituir e aperfeiçoar de forma satisfatória os controladores clássicos.
17
Abstract
The controllers as much of hardware as of software are used more and more in the system
projects. The population turns to systems that involve less human action, to reduce the answer
time and assure the precision. The time precision and fast answer is possible to be guaranteed
with intelligent controllers. Although the most varied theories show how are possible the
approaches of proportional, derivative and integrative controllers, for problem solution, the
intelligent controllers are still a great choice in the decision for time optimization. The use of
neural network is a great option, because approximating the entrance supplied with the target
is possible to obtain an output within the smallest possible time. That fast approach is
important, because the stabilization of the system is valuable in the control system, for robots'
balance, path control, etc. The presented project treats of Furuta’s pendulum, but an analogy
with larger complexity problems can be made. The intelligent control of Furuta’s pendulum
will show that the theory of neural networks is capable to substitute and to improve other
controllers in a satisfactory way.
18
1 Introdução
1.1 Motivação
O estudo de sistemas de controle é cada vez mais importante para a engenharia. A população
vem procurando uma forma de automatizar serviços, uma forma de usar máquinas para
realizar os trabalhos que sejam complexos. A pesquisa em sistemas de controle é muito
ampla, um controle pode ser desenvolvido para as mais diversas aplicações como: controle da
trajetória de um projétil, controle da aceleração de trens, controle de movimentação de um
robô a fim de se manter erguido, controle de lançamento de foguetes e etc. Cada um desses
sistemas envolve cálculos complexos e necessitam de tomar decisões rápidas para manter a
estabilização do sistema e evitar comportamento indesejado. Nessa monografia um
controlador inteligente será realizado para alcançar a estabilização do Pêndulo de Furuta. Mas
o que tem de especial nesta estabilização? O pêndulo de Furuta é invertido, a ação de controle
na estabilização desse sistema é similar a todos os problemas de controle citados acima. A
motivação para este trabalho, é que a solução do problema de conseguir a estabilização do
pêndulo pode, por exemplo, ser utilizada para conseguir o ponto de equilíbrio de um robô
bípede, ou seja, a mesma teoria pode ser aplicada para sistemas mais complexos e também
será possível demonstrar as vantagens da utilização de um controlador inteligente para a
solução de problemas de controle. Para a realização desse controlador várias abordagens
podem ser utilizadas, como: controladores PD, PID, inteligentes, etc. Neste trabalho será
utilizado um controlador inteligente, baseado em redes neurais, mas primeiramente um PD foi
utilizado para obtenção dos dados de treinamento da rede. Depois o PD será substituído pelo
controlador inteligente e poderá ser mostrada a vantagem em sua utilização.
1.2 Objetivo
O objetivo geral deste projeto é realizar a estabilização do pêndulo de Furuta utilizando um
controle inteligente baseado em redes neurais. Os objetivos específicos são:
2 Parte Teórica
Uma breve visão geral será apresentada nesta seção com objetivo de familiarizar o leitor com
as teorias que explicam a abordagem utilizada na realização deste trabalho. Esta seção será
subdividida em Pêndulo de Furuta, onde será apresentada uma visão geral do pêndulo,
Modelo Físico do Pêndulo, onde será apresentada a teoria física para a modelagem
matemática do sistema; Equações de Lagrange, onde será apresentada a teoria utilizada para
modelar as equações do movimento; Linearização, onde será apresentada a teoria utilizada
para transformar sistemas não-lineares em lineares; Forças Contrárias ao Movimento, onde
serão discutidas as forças que podem dificultar o movimento e que também necessitam ser
levado em consideração; Controlador PD, onde será discutida a teoria do controlador
proporcional derivativo; e por fim Redes Neurais, onde serão discutidas as diferentes
arquiteturas de rede e como modelar uma rede neural.
A decisão sobre qual abordagem deve ser utilizada será feita baseada nos requisitos. Os
requisitos principais para realizar este trabalho são:
• Necessidade de um modelo matemático do pêndulo para a realização do controlador;
• Utilização do modelo matemático para encontrar as funções de transferência que serão
usadas para modelar o controlador;
• Utilização do controlador para obter os valores de treinamento da rede neural;
• Decisão sobre qual arquitetura de rede será ideal para a obtenção da estabilização do
pêndulo de Furuta;
• Treinamento da rede neural;
• Acoplamento da rede neural no sistema com intuito de fornecer o controle de
estabilização para o pêndulo.
O controle de estabilização deve ser preciso, porque no caso de uma rede neural mal treinada,
o pêndulo poderá não estabilizar, ou estabilizar por alguns segundos e depois deixar seu ponto
de equilíbrio.
O Pêndulo de Furuta é uma plataforma interessante para apresentar uma visão geral sobre
teoria de controle e modelagem de sistemas dinâmicos, sendo de grande utilidade para o
desenvolvimento e estudo das leis de controle não-linear. O fato de o sistema ser não-linear
também acrescenta complexidade no trabalho, pois na modelagem do controle, que será
utilizado neste trabalho, é necessário fazer a realização da linearização da função para o ponto
de equilíbrio desejado e desta forma tornar a estabilização do sistema possível.
Quando se obtém a equação do espaço, a sua primeira derivada dará a equação da velocidade,
ou seja:
dS (Equação 2)
v=
dt
Como estamos trabalhando com movimento nos três eixos (x,y,z), então a derivada precisa ser
realizada em cada eixo e a velocidade terá a mesma composição do espaço:
Depois de tomada a derivada de cada posição e encontrada a velocidade nos três eixos, a
velocidade total do sistema pode ser encontrada apenas somando as velocidades de cada eixo:
v = vx+vy+vz. Para realizar o calculo da energia essa velocidade total precisa ser elevada ao
quadrado, pois a expressão de calculo da energia é dada por:
1 (Equação 4)
K= m ∫ v 2 dm
2
U = mg ∫ rdm (Equação 5)
para energia potencial gravitacional. As equações de energia precisam ser encontradas para
todos os pontos que compõem o movimento, como: pilar central (centro de massa), braço
horizontal, braço vertical e massa de balanço. A massa de balanço é inserida na extremidade
do pêndulo e é utilizada como ponto de equilíbrio do braço vertical. Depois de calculada as
energias cinética e potencial gravitacional, a energia total é dada por:
K = K CM + K BH + K BV + K MB (Equação 6)
U = U CM + U BH + U BV + U MB (Equação 7)
L = K −U (Equação 8)
t2
(Equação 9)
S = ∫ L(q, qɺ , t )dt
t1
d ∂L ∂L (Equação 10)
− =0
dt ∂qɺi ∂qi
2.4 Linearização
A linearização é utilizada para transformar um sistema não-linear em um sistema linear
equivalente. Existem mais de uma abordagem para a solução deste problema. Nesta seção
serão mostradas duas abordagens: Série de Taylor e Linearização com feedback.
df (Equação 12)
f ( x) = f ( x ) + ( x − x ) + ...
dx x=x
para x suficientemente perto de x , os termos maiores serão perto de zero, então eles podem
ser tirados para obter a aproximação:
f ( x) ≈ f ( x ) + a ( x − x ) (Equação 13)
Desde que f ( x ) = 0 , a equação diferencial não-linear pode ser aproximada perto do ponto de
equilíbrio para:
xɺ = a ( x − x ) (Equação 14)
25
δ xɺ = aδ x (Equação 15)
por alguma função geral fi. Supondo que os pontos de equilíbrio são dados por
x1 , x2 ,..., xn , u1 , u2 ,..., um , então:
O ponto de equilíbrio deve fazer todas as funções fi iguais a zero, então todos os estados do
sistema param de mover quando ele atinge o equilíbrio. A linearização de fi no ponto de
equilíbrio é dada por:
n
∂f i m
∂f i (Equação 18)
f i ( x1 ,..., xn , u1 ,..., um ) ≈ ∑ (xj − xj ) + ∑ (u j − u j )
j =1 ∂x j j =1 ∂u j
xj =x j u j =u j
n
∂f i m
∂f i (Equação 19)
δ xɺi = ∑ δ xj + ∑ δuj
j =1 ∂x j j =1 ∂u j
xj =x j u j =u j
O objetivo da linearização da entrada e da saída é obter leis de controle para um sistema não-
linear na forma seguinte:
u = p ( x ) + q ( x )v (Equação 21)
de tal forma, que o processo controlado será linear. Então, os resultados de linearização da
entrada e saída na função de transferência linear entre v e y:
onde, r denota o grau relativo do sistema não-linear. Este grau relativo operando no ponto x0 é
definido por um inteiro que satisfaça:
Enquanto, os termos de maior grau das derivadas de Lie podem ser escritos como:
As derivadas com relação ao tempo da saída do sistema podem ser expressas como funções
algébricas das derivadas de Lie.
dy
= L f h( x)
dt
.
.
(Equação 26)
.
d r −1 y
= Lrf−1h( x)
dt r −1
dr y
r
= Lrf h( x) + Lg Lrf−1h( x)u
dt
As equações anteriores mostram que o grau relativo representa quantas vezes a saída deve ser
diferenciada com relação ao tempo para recuperar explicitamente a entrada u.
27
Como pode ser observado na Figura 2.2, quando o motor aplica o torque T para levantar o
pêndulo para sua posição de equilíbrio, o braço sofre uma força que o “puxa” para baixo. Essa
força tem uma aceleração chamada aceleração da gravidade, que é constante em 9,81m/s2. Ao
modelar o sistema essa força é considerada e calculada como energia, pois da mesma maneira
que ela tenta impedir o braço de subir, ela também o ajuda a descer.
Em física, existe um conceito chamado conversão de energia que pode ser aplicado a
movimentos de rotação da mesma maneira que movimentos lineares, este conceito diz: “A
quantidade total de energia de um sistema isolado permanece constante” [ReHaKr03]. O que
quer dizer que a energia não pode ser criada e nem destruída. O sistema discutido neste
trabalho não é um sistema isolado. Nele há perda de energia, mas uma parte do principio pode
ser utilizada. Se a energia não pode ser criada e nem destruída, para ela se manter a mesma ela
precisa mudar de forma, se transformar em outro tipo de energia. E é exatamente isso o que
acontece em um movimento de rotação (o braço do pêndulo com giro na vertical). Quando o
pêndulo inicia seu torque, ele tem energia cinética, mas a medida que o braço vai subindo
para o ponto de equilíbrio, está energia cinética vai diminuindo e transformando em energia
potencial gravitacional, quando o braço atinge o ponto de equilíbrio a energia cinética foi
28
• Força Centrípeta
A força centrípeta (Figura 2.3) é uma força resultante que puxa o corpo para fora da trajetória
de um movimento circular. Essa força não atinge movimentos retilíneos porque esses
movimentos têm velocidade modular constantes. Objetos que se deslocam em arco, mesmo
que possuem velocidades constantes, eles têm variação na direção do movimento, como a
velocidade é um vetor que possui módulo, direção e sentido, uma variação na direção implica
em uma mudança no vetor velocidade. O movimento circular é composto por duas
acelerações, aceleração tangencial, que modifica o módulo da velocidade, e uma aceleração
centrípeta, que modifica a direção do movimento. Então mesmo que os movimentos circulares
tenham velocidades constantes em módulo, ainda assim existe uma aceleração, que é a
aceleração que modifica a direção.
Onde:
• Força Centrífuga
A força centrífuga é uma pseudo força ou força inercial, que existe apenas para um
observador parado em relação a um referencial animado de movimento de rotação. A força
centrífuga atua radialmente a partir do centro de rotação (Figura 2.4).
Algumas vezes a força centrífuga é erroneamente confundida com a força centrípeta, mas as
duas são exatamente o oposto. Enquanto a força centrípeta tende a “puxar” o corpo para o
centro da rotação, a força centrífuga tende a “empurrar” o corpo para fora da rotação. Essa
força é paralela ao plano determinado pelo eixo de rotação, mais especificamente pelo vetor
velocidade angular ω e pelo raio r. Essa força pode ser calculada da seguinte maneira:
Fcf = − mω × (ω × r ) (Equação 30)
2.5.4 Fricção
A fricção nada mais é que o atrito causado no momento do movimento. No caso que está
sendo estudado este atrito é composto por: atrito estático e atrito viscoso. Um modelo de
fricção é chamado de Fricção de Coulomb, que é descrito pela equação:
F f = µk Fn (Equação 33)
Onde:
igual a 17,4x10-6. É um coeficiente pequeno com relação a outros fluidos, mas que no
momento do movimento pode influenciar na estabilização ou não do sistema. A força
necessária para vencer a viscosidade do ar é dada pela expressão definida por Newton:
∂u (Equação 34)
τ =µ
∂y
Onde:
µ é o coeficiente de viscosidade
Alguns fluidos como água, ou a maioria dos gases satisfazer esse critério de Newton e são
conhecidos como fluidos newtoniano. Os não newtonianos tem comportamento mais
complexo e não-linear.
2.6 Controlador PD
Como foi dito anteriormente, as tarefas que eram realizadas manualmente agora estão sendo
realizadas por processos automatizados. Para isso, os sistemas de controle automático estão
desempenhando um papel fundamental. Um sistema de controle é uma junção de
componentes que controlam o sistema de tal forma a produzir a saída desejada. Um ponto
fundamental no estudo de controle é a obtenção do modelo matemático que representa uma
relação entre a entrada e a saída. Há dois tipos de modelo em sistema de controle, o sistema
de malha aberta e o sistema de malha fechada.
Pode-se dizer que as vantagens para o uso do sistema de malha fechada são:
• Estabilização do sistema;
• Correção de perturbações;
por uma constante e aplica no atuador de forma a diminuir a diferença entre os dois valores.
Quando o sinal de controle é linearmente proporcional ao sinal de erro, o controlador é
chamado de proporcional. A equação é dada por:
u = K pe (Equação 35)
de (Equação 36)
u = KD
dt
• Entendendo o controlador PD
A saída de um sistema apresenta certa inércia com relação a modificações na variável de
entrada. Esta inércia faz parte da dinâmica do sistema que faz com que a mudança na variável
de controle provoque mudança na saída da planta somente após certo tempo. Outro modo de
entender é que dependendo do sistema, há um atraso do sinal que corrige o erro, mas esse fato
é responsável por transitórios com grande amplitude e período de oscilação, gerando respostas
instáveis. Quando se combina o controlador proporcional com o derivativo, o controlador
proporcional antecipa a ação de controle na tentativa de deixar o processo mais rápido, então
o sinal de controle aplicado é proporcional a uma predição da saída do processo. A estrutura
de um controlador PD é dada por:
Dessa forma, a ação tende a aumentar a estabilidade relativa do sistema e a tornar a resposta
transitória da mesma mais rápida. Limitando o ganho da parte derivativa em altas-freqüências
através do acréscimo de um pólo p, a função de transferência do controlador PD é dada por:
p
K 1 + Td p s +
u ( s) spTd 1 + pTd
GPD = = K 1 + =
(Equação 39)
r (s) s+ p ( s + p)
Nessa configuração o zero do controlador está sempre à direita do pólo, o que o torna um
compensador de avanço de fase e se aumentarmos o Td, o zero do controlador tende a origem,
o que mostra a predominância da ação derivativa.
Há diversos modelos de topologias de rede na literatura, nesta seção será apresentada a teoria
de três topologias: PERCEPTRON, para apresentar o surgimento das redes, Feed-forward
Backpropation, pois é uma alternativa de rede multicamadas, e por fim, Cascade-forward
Backpropation, um avanço da implementação do backpropation original. E também será feita
uma breve descrição dos algoritmos de calculo do erro e das funções de ativação da rede.
Embora a modelagem de RNA’s seja baseada no cérebro humano, ainda há uma grande
diferença de funcionamento. O cérebro humano tem 1.000 vezes mais neurônios do que
existem portas lógicas na CPU de um computador [RuNo04]. O computador tem a vantagem
da velocidade de cálculo, um computador pode realizar uma instrução em um nanossegundo,
enquanto os neurônios são milhões de vezes mais lentos, necessitando um milissegundo. Mas
essa diferença de velocidade é compensada devido ao fato de todos os neurônios e sinapses
estarem ativos ao mesmo tempo, enquanto que os computadores têm número muito baixo de
CPU’s, dessa forma o cérebro embora seja mais lento em velocidade de comutação, o cérebro
acaba sendo 100.000 vezes mais rápido no que faz [RuNo04]. Uma comparação grosseira dos
recursos computacionais com relação ao cérebro pode ser observada na Tabela 2.1.
• Funções de Transferência
Antes de apresentar as funções de transferência um neurônio de entrada simples é apresentado
(Figura 2.13) com as devidas notações que serão utilizadas no decorrer do trabalho.
a = f ( wp + b) (Equação 40)
39
Onde:
a é a saída do sistema;
w é o peso da conexão;
p é a entrada da rede;
b é o bias.
No gráfico apresentado na Figura 2.14 será mostrado a influência do peso e do bias na saída
final do sistema. O bias é uma unidade especial da camada de entrada utilizada para aumentar
os graus de liberdade, permitindo uma melhor adaptação, por parte da rede neural, ao
conhecimento fornecido a ela.
A função de transferência pode ser linear ou não-linear. A função é escolhida de modo que
satisfaça alguma especificação do problema que o neurônio está sendo modelado para
resolver. As funções são utilizadas para criar neurônios que: classifiquem entradas em duas
categorias distintas, aproximem a saída da entrada fornecida, limitem a saída entre 0 e 1, etc.
Na Tabela 2.2 será apresentada um resumo das principais funções de transferência, mostrando
sua notação e relação entre entrada e saída.
a=1 n≥0
a = +1 n≥0
Linear a=n
40
a=n 0≤n≤1
a=1 n>1
a=n -1 ≤ n ≤ 1
a=1 n>1
Log-Sigmoid 1
a=
1 + e−n
a=n n≤n
Na abordagem com mais de uma entrada os cálculos serão realizados utilizando vetores. Será
montado um vetor de entradas e um vetor de pesos. A equação matemática será:
41
onde, a notação em negrito é utilizada para representar os vetores. O neurônio tem um bias b,
que é somado com o peso de entrada para a entrada n da rede, que é dada pela expressão a
seguir:
A mesma abordagem mostrada pode ser utilizada para o caso de mais de um neurônio. É
possível projetar redes que tenham mais de um neurônio na camada. Na Figura 2.16 é
mostrada a arquitetura de uma rede de camada simples, mas com três neurônios na camada.
Como pode ser observado na Figura 2.16, os valores dos pesos de cada entrada são
conectados para cada neurônio da camada, ou seja, o número de pesos será o número de
entradas vezes o número de neurônios.
O problema com a arquitetura de camada simples, é que essa topologia permite apenas a
solução de problemas linearmente separáveis, ao lidar com problemas inseparáveis
linearmente é necessário adotar uma topologia de multicamadas. Na Figura 2.17 é mostrado
um exemplo de problema linearmente separável e um de inseparável linearmente.
42
Figura 2.17 - (a) Problema linearmente separável. (b) Problema inseparável linearmente.
Como pode ser observada na Figura 2.18 a notação para uma rede multicamadas é um pouco
diferente. Para os vetores de entrada, saída e bias foi adicionado um número sobrescrito que
identifica de qual camada o vetor pertence. As equações para cada camada é definida por:
a1 = f 1 (W 1 p + b1 )
a 2 = f 2 (W 2 a1 + b 2 ) (Equação 44)
a 3 = f 3 (W 3 a 2 + b3 )
43
a 3 = f 3 (W 3 f 2 (W 2 f 1 (W 1 p + b1 ) + b 2 ) + b3 ) (Equação 45)
A rede feedback (Figura 2.20), ou rede recorrente existem conexões entre os neurônios de
saída com os demais neurônios de entrada. Neste tipo de RNA é necessário armazenar os
valores prévios de saída e os estados de ativação de alguns neurônios. Essa topologia é cíclica
e utiliza a saída para alimentar de volta sua próprias entradas. Isso significa que os níveis de
ativação da rede formam um sistema dinâmico que pode atingir um estado estável ou exibir
oscilações, ou mesmo apresentar um comportamento caótico. Essas redes são realimentadas.
• Treinamento e Aprendizagem
Antes da utilização de uma rede ela precisa ser devidamente treinada para obter os pesos de
cada neurônio. Para a realização desse treinamento existem dois tipos: supervisionado e não-
supervisionado.
Com esses métodos de treinamento e aprendizagem as redes podem ser utilizadas para
calcular realizar previsões para séries temporais, séries lineares e não-lineares. Ao projetar a
rede é dado como entrada x termos da série e como saída desejada é fornecido o termo x+1.
Quando a rede for treinada os pesos serão ajustados para aprender sobre a série dada, dessa
forma a rede quando executada irá aproximar da série temporal original, pois ela aprendeu o
padrão da série original.
• Perceptron
A rede Perceptron foi desenvolvida em 1957 por Frank Rosenblatt. Ela é caracterizada como
uma rede de alimentação direta, com aprendizagem supervisionada e utilizada para problemas
linearmente separáveis. Nessa seção será feita uma breve introdução do perceptron para poder
entrar na topologia que realmente será utilizada na concepção deste trabalho.
A rede perceptron pode ser vista como um classificador binário que mapeia as entradas x
(onde x é um vetor no caso de várias entradas) para encontrar um valor de saída f(x) (onde f(x)
será um valor binário).
1 se w ⋅ x + b > 0
f ( x) =
0 caso contrário
Se durante o treinamento a rede apresentar a saída correta, nenhuma mudança é realizada, por
outro lado, se a saída estiver incorreta os pesos serão atualizados. O algoritmo de
aprendizagem do neurônio não finalizará com sucesso se o problema não for linearmente
separável.
45
Variáveis e Parâmetros:
b(n): bias;
1o Passo:
2o Passo:
Acrescentar o vetor de entrada x(n) e a saída desejada d(n), de cada par do conjunto de
treinamento T={(x,d)};
Calcular o erro da saída da unidade com a seguinte fórmula: e(n) = d (n) − y (n) ;
Atualizar o vetor de pesos para cada uma das unidades da rede seguindo a regra:
w(n + 1) = w(n) = he(n) x(n) .
3o Passo:
Incrementar o passo de tempo n, voltar ao 2o Passo. Fazer isso até que e(n)=0, para
todos os elementos do conjunto de treinamento em todas as unidades da rede.
A função de transferência utilizada pelo perceptron é a hard limit, pois como pode ser
observado na Tabela 2.2, essa função apresenta saída binária, se enquadrando perfeita na
função do perceptron como classificador binário.
46
• Backpropagation
A arquitetura backpropagation foi estudada pela primeira vez em 1974 por Paul Werbos, mas
apenas nos anos 80 ela foi publicada. Nos anos 80 ela foi redescoberta independentemente por
David Rumelhart, Geoffrey Hinton e Ronald Williams e também por David Parker e Yann Le
Cun [HaDeBe96]. Esta rede foi desenhada para funcionar como uma rede multicamadas, com
realimentação e modo de treinamento supervisionado.
Alguns estudos têm mostrado que durante o treinamento, as redes BP tendem a desenvolver
relações internas entre as camadas como se organizassem os dados de treinamento dentro de
classes e padrões [HiSe87]. Esta tendência pode ser entendida como se algumas camadas da
rede se associassem com objetos específicos dos padrões de entrada durante o treinamento.
Desta forma, a rede encontra uma forma de representar internamente os padrões de forma a
permitir a geração da saída desejada quando uma entrada de treinamento é proporcionada.
Propagação:
3o Passo: Calcular o sinal de erro, fazendo a saída y j = O j (n) , agora O j (n) será a resposta da
rede, e o calculo do sinal de erro é feito através da fórmula, e j (n) = d j (n) − O j (n) . Este sinal
de erro será utilizado para comutar os valores de erro das camadas anteriores e fazer as
correções necessárias nos pesos.
Retro propagação
4o Passo: Calcular os erros locais para cada camada, desde a camada de saída até a camada de
entrada. O gradiente local é definido por: δ (n) = e j (n)O j (n)(1 − O j (n)) , para a camada de
saída e δ (n) = O j (n)(1 − O j (n))∑ δ k w jk , para as demais camadas, onde δ k é o erro da camada
anterior.
Após o calculo dos erros de cada camada, é necessário calcular o ajuste dos pesos de cada
conexão: ∆wkj (n + 1) = α wkj (n) + ηδ j y j , para o cálculo dos ajustes dos pesos e
∆wkj (n + 1) = w(n) + ∆wkj (n) , para atualizar os pesos.
Onde:
η é a taxa de aprendizado;
δ j é o erro do neurônio;
• O erro da rede está baixo, sendo pouco alterado durante o treinamento, ou seja, o erro
mínimo foi alcançado;
• Cascade-forward Backpropagation
Essa abordagem é uma modificação da rede backpropagation normalmente utilizada. A
abordagem de correlação em cascada (CC) é atribuída a Scott Fahlman [Scha97]. A rede CC é
uma estrutura feedforward com arquitetura modificada. Como modificação, o algoritmo de
treinamento emprega várias modificações originais, incluindo a habilidade de acrescentar
unidades quando necessário.
48
• A saída da rede tem uma conexão de passagem direta para todas as entradas da rede e
entradas das camadas seqüentes;
3 Concepção
Nessa seção será apresentada a plataforma utilizada para realizar o projeto, o modelo
matemático do sistema, o controlador de estabilização, o controlador de torque (swing-up)
construído para obter dados de treinamento e a rede neural criada e treinada para a solução do
problema.
Para a realização deste trabalho, foi utilizado o Matlab Simulink, cada controlador é um
componente de uma rede montada na ferramenta citada. À medida que os controladores forem
sendo explicados, será mostrado os componentes separados da rede.
• Sensor ótico instalado juntamente com o motor, para poder obter valores da posição do
braço que se movimenta na horizontal;
• Sensor ótico instalado na parte superior, no braço de revolução vertical, para obter
valores de posição do pêndulo;
Foi utilizado um computador Intel Pentium 4, CPU 2.80GHz, 512RAM com os seguintes
softwares instalados:
Outras versões podem ser utilizadas, mas o usuário precisa preocupar-se com as
compatibilidades. As versões apresentadas acima foram as utilizadas no experimento, logo
não há problemas de incompatibilidade. O projeto foi realizado no Laboratório de Automação
Industrial e Robótica da Universidade Federal do Amazonas.
vx = (ra 'cos φ + ra cos φ ') − (rp ' senφ senθ + rp senφ ' senθ + rp senφ senθ ')
vx = −ra senφφɺ − rp cos φ senθθɺ − rp senφ cos θθɺ (Equação 47)
v y = (ra ' senφ + ra senφ ') + (rp 'cos φ senθ + rp cos φ ' senθ + rp cos φ senθ ')
v y = ra cos φφɺ − rp senφ senθφɺ + rp cos φ cos θθɺ
vz = (rp 'cos θ + rp cos θ ') = − rp senθθɺ
vx2 = ra2 sen 2φφɺ2 + ra rp senφ cos φ senθφɺ2 + ra rp sen 2φ cos θθφ
ɺ ɺ + r r senφ cos φ senθφɺ2 + r 2 cos 2 φ sen 2θφɺ2 +
a p p
v = r sen θθɺ
2
z
2
p
2 2
52
2 2 2 2
Agora fazendo v =vx +vy +vz , obtemos:
Depois de obtida a velocidade total ao quadrado, é possível obter as expressões para energia
do sistema. A energia do sistema é dividida em quatro partes: energia do centro de rotação,
energia do braço horizontal, energia do braço vertical e energia da massa de balanceamento.
Os cálculos para as energias são feitos da seguinte forma:
Centro de Rotação:
1 (Equação 50)
K= ∫ J φɺ2 dm
2
2K = J φɺ2
Braço Horizontal:
l
1a m
K = ∫ v 2 ( s, 0) a ds
20 la
1 a 2 ɺ2
l la la la
Braço Vertical:
lp
mp
2 K = ∫ v 2 (ra , s ) ds
lp
0
lp lp lp lp
mp m ɺ ɺ mp mp
2K = ∫ r a
2
lp
φɺ2 ds + ∫ rp2 sen 2θφɺ2 p lp
ds + ∫ 2ra rp cos θθφ
lp
ds + ∫ rp2θɺ 2
lp
(Equação 52)
ds
0 0 0 0
1 ɺ ɺ + 1 m l 2θɺ 2
2 K = m p la2φɺ2 + l p2 sen 2θφɺ2 m p + m p la l p cos θφθ p p
3 3
1 ɺ ɺ + 1 m l 2θɺ 2
2 K = m p (la2 + l p2 sen 2θ )φɺ2 + m p la l p cos θφθ p p
3 3
lp
mp
U = g ∫ rz (la , s ) ds
lp
0
lp
gm p
U= ∫r p cos θ ds (Equação 53)
lp 0
gm p cos θ l p2
U=
lp 2
1
U= gm p cos θ l p
2
Massa de Balanceamento:
U = Mg ∫ rp cos θ ds
(Equação 55)
U = Mgl p cos θ
1 1
K = J φɺ2 + ma la2φɺ2 + m p (la2 + l p2 sen 2θ )φɺ2 + m p la l p cos θφθ ɺɺ+
3 3 (Equação 56)
1
m p l p2θɺ 2 + M (la2 + l p2 sen 2θ )φɺ2 + 2Mla l p cos θφθ
ɺ ɺ + Ml 2θɺ 2
p
3
54
1 (Equação 57)
U= gm p cos θ l p + Mgl p cos θ
2
d ∂L ∂L
τφ = − (Equação 58)
dt ∂φɺ ∂φ
d ∂L ∂L
τθ = −
dt ∂θɺ ∂θ
1 1
L = J φɺ2 + ma la2φɺ2 + m p la2φɺ2 + m p l p2 sen 2θφɺ2 + m p la l p cos θφθɺɺ+
3 2 (Equação 59)
1
m pl p2θɺ 2 + Mla2φɺ2 + Ml p2 sen 2θφɺ2 + 2Mla l p cos θφθ
ɺ ɺ + Ml 2θɺ 2 −
p
3
1
gm p l p cos θ − Mgl p cos θ
2
Agora as derivadas parciais serão retiradas para depois substituir nas equações lagrangeanas.
Componente: φ
∂L (Equação 60)
=0
∂φ
Componente: φɺ
∂L 1 1 1
= ( J + ( M + ma + m p )la2 + ( M + m p )l p2 sen 2θ )φɺ + ( M + m p )la l p cos θθɺ
∂φɺ 3 3 2
Componente: θ
Componente: θɺ
∂L 1 1 (Equação 63)
= ( M m p )la l p cos θφɺ + ( M + m p )l p2θɺ
∂θɺ 2 3
Para facilitar o calculo serão inseridas algumas variáveis para a diminuição das equações:
1
α ≜ J + ( M + ma + m p )la2
3
1
β ≜ ( M + m p )l p2
3 (Equação 64)
1
γ ≜ ( M + m p )la l p
2
1
δ ≜ ( M + m p ) gl p
2
Agora os valores das Equações 60, 61, 62, 63 e 64 podem ser substituídos nas equações
lagrangeanas (Equação 58) e resultará nas seguintes equações:
τ φ = [α + β sen 2θ ]φɺɺ + [γ cos θ ]θɺɺ + [ β cos θ senθθɺ]φɺ + [ β cos θ senθφɺ − γ senθθɺ]θɺ (Equação 67)
D1,1 D1,2 C1,1 C1,2
α + β sen 2θ γ cos θ
D(φ ,θ ) ≜
γ cos θ β
0
g (φ , θ ) ≜
−δ senθ
Como é um modelo não-linear, ele precisa ser linearizado para o controlador ser criado.
Reescrevendo a equação 68, obtém:
d φɺ φɺ (Equação 71)
= D (φ , θ )(τ − C (φ , θ , φɺ, θɺ) − g (φ , θ ))
−1
dt θɺ ɺ
θ
φ
ɺ
φ
x≜
θ
θɺ
dx (Equação 72)
= f ( x, τ )
dt
d (δ x) ∂f ∂f (Equação 73)
= δx+ τ ≜ Aδ x + Bτ
dt ∂x 0 ∂τ 0
57
com δ x ≜ x − x0 . As matrizes precisam ser encontradas para cada posição que se deseja. No
caso do pêndulo de Furuta o que se deseja é que ele se estabilize elevando o braço ao topo.
Considerando que a condição inicial do pêndulo (quando ele está em repouso) é 0 radiano,
então o ponto mais alto será π radianos. Fazendo a posição de equilíbrio x0 = (0, 0, π , 0) é
possível obter a matriz:
0 1 0 0 0 0
0 δγ β γ
0 − 0 −
αβ − γ 2 αβ − γ 2 αβ − γ 2
A= , B = ,
0 0 0 1 0 0
αδ γ α
0 0 − 0 2
αβ − γ 2 αβ − γ
2
αβ − γ
com autovalores:
αδ
0, 0, ± .
αβ − γ 2
A matriz N foi dada acima, assim como os valores de τ . As entradas são dadas por x e são
caracterizadas por valores de posição do sistema (ângulos), R é um valor decidido pelo
projetista e normalmente é “1”, a matriz Q também é decidida pelo projetista e normalmente é
uma matriz diagonal. Tendo em posse todos esses valores calcula-se a equação de Riccati,
dada pela equação:
AT S + SA − ( SB + N ) R −1 ( BT S + N T ) + Q = 0 (Equação 75)
58
Com essa equação é obtido o valor de S, e com todos os valores disponíveis, basta substituir
na equação:
K = R −1 ( B T S + N T ) (Equação 76)
Os valores empíricos de massa e comprimento das hastes estão dispostos na Tabela 3.1. Esses
valores são necessários para obter os valores numéricos das matrizes e posteriormente o
ganho.
Utilizando os valores apresentados na Tabela 3.1, foi possível realizar os cálculos para
obtenção dos ganhos para cada entrada do sistema de estabilização, tais ganhos são
apresentados na Tabela 3.2.
K1 K2 K3 K4
Depois de obtidos os dados o bloco do Simulink que irá controlar pode ser construído. Aqui
não abordará como ele é adicionado, se o leitor tem dúvidas em como utilizar o Simulink
recomenda-se a leitura da ajuda do toolbox. Na Figura Figura 3.3 é mostrado o bloco.
Esses valores entram no bloco e passam pelos ganhos apresentados na Tabela 3.2 para a
otimização da saída. A saída desse bloco será passada para a placa.
Kp Kd
150 21
Com posse dos ganhos o componente de controle no Matlab Simulink pode ser criado. Na
Figura 3.4 esse componente é mostrado.
São só necessários os dados do braço da horizontal, porque somente ele é ligado diretamente
ao motor. Não existe torque no braço vertical, ele apenas tem um sensor para indicar posição,
60
mas a velocidade dele é gerada através do impulso causado pelo braço da horizontal. A
entrada time é o clock do sistema, pois o controlador, de acordo com a estabilização, causa um
atraso para a “injeção” de torque, impedindo assim a desestabilização do sistema.
Os gráficos da Figura 3.6 mostram os valores de entrada do sistema. São divididos em posição
e velocidade para os dois braços do pêndulo. Pode-se notar uma instabilidade em algumas
partes do gráfico de posição, essas instabilidades são os pontos onde o sistema estava tentando
estabilizar, elas ocorrem em dois pontos, pois foi aplicado um distúrbio externo para causar
nova movimentação e a amostragem conter além de dados de estabilização, conter também
dados de distúrbio e nova tentativa.
Para treinar uma rede neural, além de dados de entrada, são necessários dados de uma saída
desejada, então quando foram salvas as amostras de entrada, também foram salvas amostras
de saída (Figura 3.7).
Na Figura 3.7 é mostrada a saída do sistema sem controle neural. Essa saída é utilizada na
criação da rede neural. Ela servirá como saída desejada no momento do treinamento da rede.
Fornecendo uma entrada original e uma saída desejada correta, a rede irá treinar e aprender o
que deve fazer para seguir os padrões fornecidos. De posse dos dados de entrada e das saídas
desejadas, a rede neural já pode ser criada e treinada para a resolução do problema.
Rede: Resultado:
Depois de decidida a arquitetura da rede e as entradas e saídas desejadas (Figuras 3.6 e 3.7), a
rede agora pode ser construída e treinada. A rede foi construída utilizado o toolbox do
Simulink. Para acessá-lo basta digitar nntool na linha de comando do Matlab e uma interface
gráfica abrirá com a opção de criar nova rede (Figura 3.8).
A Figura 3.8 é a janela de criação de redes neurais, se o usuário for inserir os dados de entrada
e saídas desejadas (targets) manualmente, basta clicar em New Network. As janelas de Inputs
e Targets são devido a possibilidade que essa ferramenta dá de importar variáveis do Matlab.
Ao clicar em New Network abrirá uma janela (Figura 3.9) com as possibilidades de
arquitetura, entradas, saídas desejadas, algoritmos de treinamento, algoritmo de adaptação,
número de camadas, e etc.
Depois de criada a rede desejada, o botão View que pode ser visto na Figura 3.8 estará
habilitado. Ao clicar nessa opção abrirá uma nova janela (Figura 3.10) com opções para
treinar a rede, definir número de épocas, objetivo do treinamento, visualização da rede, e etc.
Como foi mostrado na Tabela 3.4, a rede escolhida foi a Cascade-Forward Backpropagation,
nas próximas subseções serão mostradas as funções utilizadas para treinamento, desempenho
e transferência da rede criada.
64
3.6.1 Treinamento
A função de treinamento utilizada neste trabalho é uma função com otimização chamada
Levemberg-Marquardt. Este trabalho não aprofundará matematicamente no âmbito do
funcionamento desta função, o que será feito é apenas uma descrição.
A função provê uma solução numérica para o problema de minimizar uma função, geralmente
não-linear, com um grupo de parâmetros. Esse problema surge principalmente na
minimização de quadrados de uma curva ou em programação não-linear. A LMA está entre o
algoritmo de Gauss-Newton (GNA) e do método de gradiente descendente. A LMA é mais
robusta do que a GNA, o que significa que em muitos casos ela encontra a solução, mesmo
que comece muito distante do mínimo final, mas por outro lado, parâmetros razoáveis de
inicio causam uma lentidão na LMA. A LMA foi escolhida como função de treinamento deste
projeto devido ao fato de o sistema ser não-linear e apresentar parâmetros de entrada caóticos.
Comparando os parâmetros de entrada da rede e o parâmetro de saída desejada, existem
muitos ruídos, pois foram causados distúrbios externos na rede, isso faz com que a rede
apresente um parâmetro de entrada bem complexo para aproximação. Visto que, a função
Levemberg-Marquardt é rápida para parâmetros que iniciam longe do mínimo final e que são
não-lineares, essa escolha pareceu ser a mais indicada para a conclusão do projeto.
Essa formula irá pegar a saída desejada realizar uma subtração com a saída original e elevar
ao quadrado, o resultado será o erro. Baseado em um erro decidido pelo projetista, essa
função mostrará se a rede é satisfatória para o projeto ou não. A medida que o erro está sendo
calculado é possível observar se a rede projetada está convergindo para o esperado ou se
mantendo constante.
A escolha da tan-sigmoid foi feita por causa de ser uma função exponencial dependente da
época, ou seja, ela cobriria todas as entradas da rede, com ruído ou não.
A escolha da função linear para a camada final da rede foi feita baseado no padrão do projeto
de redes. Como ela funciona como um classificador, essa função é utilizada como padrão nas
saídas de redes projetadas.
66
4 Resultados
É possível observar na Figura 4.1 que a rede alcançou o objetivo em apenas 4 épocas, com
apenas 1 neurônio na camada, o que torna a rede extremamente satisfatória e eficiente. A rede
se estabilizou em 2.5297x10-29. Com uma resposta tão rápida e eficiente, pode-se perceber
que a rede terá um tempo de estabilização muito curto, sendo perfeita para o caso do controle
do pêndulo que necessita de respostas em tempo real, para que o pêndulo não saia do ponto de
equilíbrio.
O controlador de torque (swing-up) como poderá ser observado nas Figuras 4.2, 4.3, 4.4 e 4.5,
não obteve uma resposta tão rápida e com apenas um neurônio. Isso se deve ao fato deste
controlador causar o impulso para colocar o pêndulo na posição de equilíbrio. Para realizar
esta tarefa, o controlador precisa comparar posição de ambos os braços, verificar posição
desejada, medir velocidade, decidir o módulo e direção do torque, de forma que impulsione
para cima, sem causar queda para o outro lado e no caso de já haver a estabilização, o
controlador deve causar o torque para mantê-lo lá, não causando sua queda. Para a realização
desta tarefa existe um intervalo muito grande de possibilidades, o que torna uma tarefa difícil
para a rede projetada.
67
Observando a Figura 4.2 que o uso de apenas 1 neurônio para o controlador de torque não é
viável, pois sua resposta é lenta e muito afastada do objetivo. O máximo de amplitude de
performance alcançada pela rede com 400 épocas foi 25,2963, o que é inaceitável para o
projeto, então foi adicionado mais um neurônio (Figura 4.3). A resposta caiu para 4,77422
com o mesmo número de épocas, mas continua sendo inviável, então mais um neurônio é
adicionado (Figura 4.4). Com 3 neurônios na primeira camada, a resposta começa a ficar
condizente com o necessário para o projeto, se aproximando do objetivo, que é alcançar uma
amplitude de performance o mais próximo de 0. Foi conseguida uma performance de 1,65455
em 400 épocas, o que está muito bom em comparação com os resultados anteriores, mas para
este projeto está sendo procurada uma rede que se aproxime mais do objetivo, então mais um
neurônio é adicionado (Figura 4.5). Com 4 neurônios na primeira camada, a rede se acomoda
em 1,669923x10-5 em 400 épocas. É uma resposta baixa comparando com o controlador de
estabilização, mas os dois controladores têm propriedades diferentes e não devem ser
68
comparados, e mesmo que a resposta seja mais baixa, com 4 neurônios o resultado é aceitável
para o projeto, pois a performance está próxima do objetivo.
Depois de criado o sistema (Figura 4.6) foram realizados testes para comparar as saídas dos
dois controladores e verificar a compatibilidade e também foi realizado o calculo do erro
quadrático médio, para observar se há e qual a amplitude do erro entre o controlador neural e
o controlador clássico.
No gráfico da Figura 4.7, a linha azul representa o controlador inteligente e a linha verde o
controlador REL. No gráfico da esquerda pode-se observar claramente a estabilização perfeita
do controlador inteligente. O controlador inteligente tem comportamento tão similar com o
controlador REL que não é possível observar a linha azul, as duas se sobrepõe. No gráfico da
direita foi causado um deslocamento no eixo y do controlador inteligente, deixando possível a
observação dos dois comportamentos, e mais uma vez fica claro a similaridade do
comportamento de estabilização.
Na Figura 4.8 pode ser percebido que todas as saídas, mesmo a com apenas 1 neurônio, tem
um comportamento similar, mas como foi mencionado acima, uma pequena diferença na
saída pode causar o desequilíbrio do pêndulo, então o objetivo era encontrar uma rede que
tivesse uma aproximação ótima com menor número de neurônios. O gráfico da Figura 4.9
mostra a comparação entre a saída do controlador inteligente de 1 neurônio e o controlador
PD.
A Figura 4.9 mostra que há diversos pontos de erro na aproximação. Com a utilização dessa
rede até poderia ser obtido um torque necessário para a elevação do pêndulo, mas os pontos
de falha na aproximação poderiam causar instabilidade, saindo assim do ponto de equilíbrio.
Depois de obtidas todas as saídas do sistema com e sem controle inteligente, agora é possível
calcular o erro quadrático médio entre eles.
Como era esperado, o erro obtido pelo controlador inteligente é extremamente baixo, da
ordem de 10-26, ou seja, o controlador inteligente supriu as necessidades e substituiu o
controlador REL perfeitamente. Nos gráficos apresentados na Figura 4.14, é feita uma
comparação entre os erros com cada arquitetura proposta para o controle de torque.
73
Fazendo uma comparação entre o gráfico do EQM e dos gráficos de saída, apresentados
anteriormente, é possível perceber que os erros são causados onde houve falhas de
aproximação da função. Observando a Figura 4.14, o gráfico de 1 neurônio, é possível
perceber que o erro foi muito alto e em pontos do inicio do movimento e um pico entre os
instantes 10 e 15 segundos do movimento, sendo assim essa rede não foi satisfatória. No
gráfico de 2 neurônios, houve erro apenas no inicio do movimento, mas houve dois picos de
erro muito altos. Nos gráficos de 3 e 4 neurônios o erro é similar, foi reduzido a apenas um
pico no inicio do movimento. A escolha da rede de 4 neurônios, foi devida a intensidade do
erro, embora a rede de 3 neurônios haja apenas um pico no início, esse pico é da intensidade
de pouco mais de 3000, enquanto que na rede de 4 neurônios o mesmo pico tem intensidade
de menos de 600.
74
5 Conclusão
5.1 Resultados
O objetivo deste trabalho foi o projeto de um controlador inteligente utilizando redes neurais
para controlar a estabilização de um pêndulo de Furuta. O sistema de pêndulo que foi
controlado foi desenvolvido pela empresa canadense Quanser Consulting Inc.
O projeto consiste dos passos: utilização de um controlador clássico para obter os dados de
treinamento da rede neural, projeto do controlador inteligente, criação do sistema no Matlab
Simulink, estabelecimento de comunicação entre o computador e o hardware do pêndulo,
estabilização do sistema e coleta de dados para comparação das duas abordagens.
O controlador clássico forneceu os dados de entrada e de saída desejada para o projeto da rede
neural. O projeto do controlador inteligente foi realizado utilizando a topologia Cascade-
Forward Backpropagation de duas camadas. Na primeira camada a função de transferência
utilizada foi a Tangente Sigmoid e na segunda camada foi utilizada uma função linear. O
algoritmo de treinamento utilizado foi o Levemberg-Marquardt, realizando o erro mínimo
quadrático como função de performance. Depois de treinada, a rede foi inserida no sistema
criado no Matlab Simulink para funcionar como controlador de estabilização e torque. A
comunicação entre o computador e o pêndulo foi utilizando o Real-Time Windows Target.
5.2 Experiências
Eu adquiri várias experiências trabalhando neste projeto. Durante os estudos para realização
dos controladores, foi possível utilizar todo o conhecimento que adquiri durante minha
formação e absorver novos conhecimentos e experiências que ainda não tinha.
5.3 Problemas
Eu tive alguns problemas com relação ao hardware utilizado. O primeiro problema foi com
relação a comunicação entre o computador e o hardware. Houve problemas para encontrar a
compatibilidade certa entre os softwares e a comunicação não estava sendo realizada
corretamente. O segundo problema foi com relação a falta de documentação para
especificação quanto as versões que deveriam ser utilizadas. Isso dificultou a busca da
solução, mas devo agradecer ao fabricante, pois sempre foram muito solícitos quando enviava
dúvidas sobre a instalação e funcionamento. E, por fim, todos os problemas foram resolvidos
e o projeto pode ser finalizado com sucesso.
76
Referências Bibliográficas
[CaPr08] Cazzolato, B. S.; Prime, Z..: Technical Report: On the dynamics of the Furuta
pendulum.Universidade de Adelaide, Australia. 2008.
[Wiki10] Viscosidade:
http://pt.wikipedia.org/wiki/Viscosidade
Acessado em: 04/07/10.
[RuNo04] Russel, S., Norvig, P.: Inteligência Artificial. Ed. Campus, 2004.
[HaDeBe96] Hagan, M.T., Demuth, H.B. e Beale, M.: Neural Network Design. Ed.
Thomson, 1996.
[HiSe87] Hinton, G.E., e Sejnowski, T.J.: Neural Networks architectures for AI. Seatle-
WA, 1987.
[Scha97] Schalkoff, R.J.: Artificial Neural Networks. Ed. McGraw Hill, 1997.
77
Apêndice A
Nessa subseção será demonstrado como proceder na instalação do conteúdo do CD. Este
conteúdo é o que garante o funcionamento e comunicação da placa com o computador.
Depois de inserido o CD do Code Composer Studio no driver abrirá um menu com opções de
documentação e instalação (Figura A.1).
Depois de clicado na primeira opção Install Products abrirá outro menu com os softwares que
devem ser instalados. Na Figura A.2 esse menu é mostrado juntamente com a ordem que deve
ser instalado cada componente.
Depois de instalada cada opção terá sido criado dois ícones no Desktop: 6713 DSK CCStudio
v3.1 e 6713DSK Diagnostics Utility v3.1. Depois de esses passos terem sido seguidos o cabo
USB da placa já poderá ser ligado no computador para reconhecimento do driver. O driver é
78
Depois de clicado no ícone, será aberto um software que realiza um teste completo na placa e
conexões. Este software (Figura A.4) realizará testes na memória flash da placa, na
comunicação USB, memória externa, leds, etc.
Para utilizar o software apresentado na Figura A.4, o usuário deve primeiro conectar a placa
ao computador, através da porta USB. Depois de realizada a conexão o usuário pode abrir o
software e apenas dar um clique na opção Start. Quando feito isso, o software irá iniciar um
diagnóstico completo do sistema informando possíveis falhas ou informando se o diagnóstico
foi finalizado com sucesso.
• Matlab 7.0;
• Simulink;
• Microsoft Visual C++ 6.0 Standard Edition;
79
No Matlab há apenas uma configuração a ser feita. O compilador padrão reconhecido pela
placa é o Microsoft Visual C++, mas o compilador padrão do Matlab é outro, então o usuário
deve modificar o compilador, para realizar essa modificação o usuário deve digitar na linha de
comando do Matlab: “mex –setup”. Esse comando irá perguntar qual o compilador que o
usuário deseja estabelecer como padrão (Figura A.5).
Apêndice B
Para montar o hardware é necessário utilizar as peças de alumínio (Figura B.1) que compõem
o sistema para montar uma armação em “L” (Figura B.2) que sustentará o motor e o pêndulo.
Figura B.1 - Peças para montar estrutura em Figura B.2 - Estrutura para fixação do motor.
"L".
Essa peça será fixada no eixo do motor. O motor deve ser fixado no topo da estrutura em “L”.
O estudante primeiramente deverá fixar o motor, e em seguida fixar a peça mostrada na
Figura B.3, no eixo do motor. No topo da peça mostrada na Figura B.3 deverá ser fixada a
haste mostrada na Figura B.4. A configuração final deverá ficar igual à Figura B.5.
82
Depois de todas as peças devidamente montadas é necessário atentar para a fixação dos fios.
Nas Figuras B.6, B.7 e B.8 será mostrada a fixação ideal para o bom funcionamento do
pêndulo.
Figura B.6 - Fixação traseira dos fios. Figura B.7 - Fixação lateral dos fios.
Apêndice C
Para realizar uma conexão entre o Matlab/Simulink e uma placa externa algumas
configurações são necessárias. O usuário deve abrir o modelo do Simulink e acessar o menu
Tools Real-Time Workshop Options. Esse menu abrirá uma tela (Figura C.1) de
configuração.
Ao clicar no menu opções do Simulink o usuário terá opções de modificar tipo do device,
implementações de hardware, arquivos de instalação, etc. A primeira opção a ser modificada
é o tipo de device, nessa opção o usuário deve escolher “32-bit Real-Time Windows Target”
(Figura C.2).
Depois de selecionado o device type a tela do usuário deve se parecer com a Figura C.2.
Agora o usuário deve abrir a opção Real-Time Workshop para verificar se os arquivos de
compilação estão corretos, normalmente esses arquivos são estabelecidos automaticamente
quando o device type é escolhido, mas é aconselhável fazer uma checagem depois de
configurado o passo anterior. A tela do usuário deve se parecer com a Figura C.3.
Se as telas estão com as mesmas configurações da apresentada neste trabalho, então o usuário
pode aplicar as configurações (Apply) e confirmar a operação (OK). Lembrando que depois de
realizada essa operação o modelo do Simulink precisa ser compilado novamente, para fazer
isso, basta o usuário clicar na opção Re-build (Figura C.4).