Você está na página 1de 84

UNIVERSIDADE FEDERAL DO AMAZONAS

FACULDADE DE TECNOLOGIA
FTL069 PROJETO DE FINAL DE CURSO II

Realização de um controlador utilizando Redes Neurais para o controle de


estabilização do Pêndulo de Furuta

CÉSAR VIEIRA ROCHA


Orientação: Prof. Dr.-Ing. VICENTE FERREIRA DE LUCENA JÚNIOR

MONOGRAFIA APRESENTADA COMO PARTE DO


CRITÉRIO DE AVALIAÇÃO DA DISCIPLINA
FTL069 PROJETO DE FINAL DE CURSO II.

MANAUS
AGOSTO – 2010
UNIVERSIDADE FEDERAL DO AMAZONAS
FACULDADE DE TECNOLOGIA
FTL069 PROJETO DE FINAL DE CURSO II

RELATÓRIO DE 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 – AM, AGOSTO de 2010

MANAUS
AGOSTO – 2010
UNIVERSIDADE FEDERAL DO AMAZONAS
FACULDADE DE TECNOLOGIA
FTL069 PROJETO DE FINAL DE CURSO II

CÉSAR VIEIRA ROCHA

Realização de um controlador utilizando Redes Neurais para o controle de


estabilização do Pêndulo de Furuta

Relatório da disciplina Projeto de Final de Curso II

BANCA EXAMINADORA

(ASSINATURA)

Prof. Dr.-Ing. VICENTE FERREIRA DE LUCENA JÚNIOR.


PRESIDENTE DA BANCA

(ASSINATURA)

Prof. Dr. RAIMUNDO DA SILVA BARRETO.


MEMBRO DA BANCA

(ASSINATURA)

Prof. Dr. JOÃO EDGAR CHAVES FILHO.


MEMBRO DA BANCA

MÉDIA FINAL: ______________

DATA DE REALIZAÇÃO DO EXAME: _____/_____/______


Dedico este trabalho a minha família, a todos os

meus amigos, pois considero todos muito

importantes em minha vida e também a meus

professores, pois sem eles eu não chegaria aonde

cheguei.
v

Sumário

Agradecimentos ........................................................................................................................... vii

Lista de Figuras .......................................................................................................................... viii

Abreviações ................................................................................................................................... xi

Terminologia ................................................................................................................................ xii

Resumo ......................................................................................................................................... 16

Abstract ........................................................................................................................................ 17

1 Introdução............................................................................................................................. 18
1.1 Motivação ..................................................................................................................... 18
1.2 Objetivo ........................................................................................................................ 18
1.3 Organização da Monografia ......................................................................................... 19

2 Parte Teórica ........................................................................................................................ 20


2.1 Pêndulo de Furuta ......................................................................................................... 20
2.2 Modelo Físico do Pêndulo ............................................................................................ 21
2.3 Equações de Lagrange .................................................................................................. 23
2.4 Linearização .................................................................................................................. 24
2.4.1 Série de Taylor .................................................................................................. 24

2.4.2 Linearização com feedback ............................................................................... 25

2.5 Forças Contrárias ao Movimento ................................................................................. 27


2.5.1 Força Gravitacional........................................................................................... 27

2.5.2 Força Centrípeta e Centrífuga ........................................................................... 28

2.5.3 Força de Coriolis ............................................................................................... 30

2.5.4 Fricção .............................................................................................................. 31

2.6 Controlador PD ............................................................................................................. 32


2.6.1 Malha Aberta .................................................................................................... 32

2.6.2 Malha Fechada .................................................................................................. 33

2.6.3 Controle Proporcional ....................................................................................... 33

2.6.4 Controle Proporcional Derivativo (PD) ............................................................ 34


vi

2.7 Redes Neurais ............................................................................................................... 36


2.7.1 Redes Neurais Naturais ..................................................................................... 36

2.7.2 Redes Neurais Artificiais .................................................................................. 37

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

3.6.2 Função de Desempenho .................................................................................... 64

3.6.3 Função de Transferência ................................................................................... 64

4 Resultados ............................................................................................................................. 66
4.1 Comparação das saídas ................................................................................................. 68
4.1.1 Controlador de Estabilização ............................................................................ 68

4.1.2 Controlador de Torque (Swing-up) ................................................................... 69

4.1.3 Erro quadrático médio ...................................................................................... 72

5 Conclusão .............................................................................................................................. 74
5.1 Resultados ..................................................................................................................... 74
5.2 Experiências.................................................................................................................. 74
5.3 Problemas ..................................................................................................................... 75

Referências Bibliográficas .......................................................................................................... 76

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

meu potencial e pela oportunidade de aprendizado que me proporcionou no decorrer deste

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

ano de graduação e quem colaborou muito para a realização deste trabalho.

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 2.1 - Pêndulo de Furuta. ..................................................................................................... 21


Figura 2.2 - Esquema de Forças. ................................................................................................... 27
Figura 2.3 - Força Centrípeta. ....................................................................................................... 28
Figura 2.4 - Força Centrífuga. ....................................................................................................... 29
Figura 2.5 - Força de Coriolis. ...................................................................................................... 30
Figura 2.6 - Sistema de Malha Aberta. ......................................................................................... 32
Figura 2.7 - Controle de Temperatura. .......................................................................................... 33
Figura 2.8 - Planta com controlador proporcional. ....................................................................... 34
Figura 2.9 - Planta com controlador proporcional derivativo. ...................................................... 34
Figura 2.10 - Ação proporcional derivativa. ................................................................................. 35
Figura 2.11 - Representação de um neurônio natural. .................................................................. 37
Figura 2.12 - Representação de um neurônio artificial. ................................................................ 38
Figura 2.13 - Neurônio de entrada simples [HaDeBe96]. ............................................................. 38
Figura 2.14 - Influência do peso e do bias. ................................................................................... 39
Figura 2.15 - Neurônio de múltiplas entradas. .............................................................................. 40
Figura 2.16 - Rede de camada simples, mas com múltiplos neurônios. ....................................... 41
Figura 2.17 - (a) Problema linearmente separável. (b) Problema inseparável linearmente. ......... 42
Figura 2.18 - Neurônios com múltiplas camadas. ......................................................................... 42
Figura 2.19 - Arquitetura feedforward. ......................................................................................... 43
Figura 2.20 - Arquitetura feedback. .............................................................................................. 43
Figura 3.1 - Plataforma utilizada na concepção. ........................................................................... 49
Figura 3.2 - Plano cartesiano do pêndulo de Furuta...................................................................... 51
Figura 3.3 - Bloco do Simulink para controle de estabilização. ................................................... 58
Figura 3.4 - Bloco do Simulink para controle de torque. .............................................................. 59
Figura 3.5 - Sistema de controle do pêndulo de Furuta. ............................................................... 60
Figura 3.6 - Amostragem retirada do sistema sem rede neural. .................................................... 61
Figura 3.7 - Saída do sistema sem controle neural. ....................................................................... 61
Figura 3.8 - Janela do nntool. ........................................................................................................ 62
Figura 3.9 - Criação de uma rede neural. ...................................................................................... 63
Figura 3.10 - Janela de treinamento da rede. ................................................................................ 63
Figura 3.11 - Arquitetura da rede utilizada. .................................................................................. 65
Figura 4.1 - Treinamento do controlador de estabilização (1 neurônio). ...................................... 66
Figura 4.2 - Treinamento do controlador de swing-up (1 neurônio). ............................................ 67
Figura 4.3 - Treinamento do controlador de swing-up (2 neurônios). .......................................... 67
Figura 4.4 - Treinamento do controlador de swing-up (3 neurônios). .......................................... 67
Figura 4.5 - Treinamento do controlador de swing-up (4 neurônios). .......................................... 67
Figura 4.6 - Sistema de controle do pêndulo de Furuta usando redes neurais. ............................. 68
Figura 4.7 - Comparação entre o controlador inteligente e o REL para estabilização. ................. 69
ix

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

PID Proporcional Integrativo Derivativo

RNN Redes Neurais Naturais

RNA Redes Neurais Artificiais

BP Backpropagation

CC Cascade

I/O Input/Output

CPU Unidade Central de Processamento

DC Corrente Direta

DSK Development Starter Kit

PWM Pulse Width Modulation

LQR Regulação Quadrática Linear

LMA Algoritmo Levemberg-Marquardt

GNA Algoritmo Gauss-Newton

REL Realimentação de Estados Lineares

EQM Erro Quadrático Médio


xii

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.

Controlador Controlador é um sistema criado para controlar a realização de uma


determinada tarefa. Ele pode ser implementado tanto em hardware,
como em software.

Modelagem Modelagem é a ação de abstrair as funcionalidades de um sistema,


descrevendo-os utilizando notação matemática ou diagramas.

Planta Planta é a descrição de um sistema utilizando notação de diagramas.


Obter a planta é ter a descrição de todas as funcionalidades e objetivos
de um sistema descrito em uma notação simples de ser visualizada e
compreendida.

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.

Realimentação Realimentação é quando a saída de um sistema de controle influência


na entrada, ou seja, quando o sistema obtém uma saída, essa saída é
realimentada para o inicio do sistema para novo processamento. Isso
acontece quando o sistema precisa verificar a saída para tomar uma
decisão de qual deve ser a próxima ação.
xiii

Malha Fechada É um sistema de controle com realimentação, onde o sistema verifica


sua saída para tomar decisões ou usá-lo nos novos cálculos de saída.

Referencial Sistema de coordenadas utilizado para medir e registrar grandezas


físicas.

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.

Neurônio É uma célula do sistema nervoso responsável pela condução do


impulso nervoso. O impulso nervoso carrega as informações até o
cérebro e do cérebro para o resto do corpo.

Sinapse É o ponto onde as extremidades dos neurônios vizinhos se encontram e


o impulso nervoso pode passar de um para outro e ser propagado.

Dendrito Os dendritos são projeções do neurônio e agem como condutor dos


impulsos nervosos. Ele funciona como entrada sináptica para o
neurônio.

Axônio O axônio é responsável pela condução dos impulsos elétricos que


partem do corpo celular, ou seja, funciona como saída sináptica.

Perceptron É um modelo de rede neural artificial desenvolvida em 1957 por Frank


Rosenblatt. Funciona como um classificador, mapeando as entradas e
liberando uma saída binária, que pode ser visto como um verdadeiro e
falso.
xiv

Backpropagation É um modelo de rede neural artificial, também conhecida como


propagação do erro. Ela é utilizada para resolver problemas mais
complexos, como aproximação de funções.

Cascade É a rede backpropagation com modificações no funcionamento. A


Backpropagation modificação mais clara é que ela funciona em forma de cascata,
ligando cada entrada diretamente para todas as camadas e neurônios
seguintes.

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.

Pesos Os pesos são variáveis calculadas para o ajuste da rede ao tentar


aproximar os valores da saída desejada. Para cada conexão da rede,
existe um peso associado, existem diversos algoritmos de cálculo de
peso.

Bias Assim como os pesos, é uma variável de ajuste, para obtenção do


melhor resultado, mas os bias são ligados por neurônio e não por
conexão, ou seja, cada neurônio tem um bias.

Função de As funções de transferência são as funções utilizadas para a saída do


Transferência neurônio, podem ser funções de aproximação, de classificação. Essas
funções ajudam no treinamento e adaptação da rede, a escolha da
função correta é importante na realização de um projeto.

É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

Treinamento Treinamento é a ação de baseada em uma entrada e em uma saída


desejada para que a rede realize cálculos e aproxime esses padrões para
obter a saída ótima do sistema.

Aprendizagem Aprendizagem é a ação que a rede realiza para reconhecer padrões. A


aprendizagem é baseada no conceito de “vivência” da rede, ou seja,
quanto mais detalhes a rede tiver de entrada, maior e mais rápida será a
aprendizagem.

Matlab É uma ferramenta de programação para cálculos matemáticos e projeto


de controladores. O Matlab utiliza o conceito de toolbox (caixa de
ferramentas) para cada projeto a ser realizado, por exemplo, tem
toolbox para processamento de sinas, de imagens, para redes neurais,
controladores PD, PID, etc.

Simulink Simulink é uma ferramenta que compõe o Matlab. Nela é possível


realizar projetos utilizando o conceito de diagramas. Não é necessária
programação, apenas arrastar e soltar os componentes e interligá-los
para obter o resultado desejado.
16

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:

• Simulação do sistema com um controlador PD e um controlador de realimentação de


estados lineares para obtenção dos dados de treinamento.
• Construção e treinamento da rede neural.
• Substituição dos controladores pelo controlador neural.
• Alcançar estabilização do pêndulo.
19

1.3 Organização da Monografia


A monografia foi organizada da seguinte maneira: Capítulo 2, introduz importantes teorias
para o entendimento do projeto e sua implementação, por exemplo, teoria sobre as
ferramentas matemáticas necessárias para o projeto, redes neurais e controladores; Capítulo 3,
cobre a concepção do trabalho, como o trabalho foi implementado; Capítulo 4, explica os
resultados obtidos com o trabalho; Capítulo 5, resume os principais pontos do projeto e indica
as experiências adquiridas e os problemas obtidos durante o projeto.
20

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.

2.1 Pêndulo de Furuta


O Pêndulo de Furuta (Figura 2.1), ou também conhecido como pêndulo invertido rotacional,
nada mais é que um braço dirigido com movimentação na horizontal com um pêndulo
inserido na sua extremidade que é livre para rotacionar na vertical.
21

Figura 2.1 - Pêndulo de Furuta.

O Pêndulo de Furuta foi desenvolvido no Instituto de Tecnologia de Tóquio por Katsuhisa


Furuta [CaPr08]. Como características do pêndulo pode-se dizer que ele é sub-atuado e
extremamente não-linear devido a forças externas, como: força gravitacional, Coriolis e
centrípeta. Outra característica é a instabilidade no seu ponto de equilíbrio e isso adiciona
muita complexidade na modelagem do sistema. Ao modelar esse sistema é necessário não só
um controlador de torque no motor, mas também um controlador de estabilidade, pois de nada
adiantará um torque que o coloque no ponto de equilíbrio, mas sem um controle que o
mantenha lá. Como foi dito, as forças externas adicionam complexidade ao sistema, pois
necessitam ser modeladas matematicamente junto com as equações de movimento, pois essa
modelagem fará o controle de erro para ajustar a posição. Se as forças externas não forem
modeladas, o pêndulo não terá um movimento correspondente com o esperado, pois as forças
interferiram na estabilidade do sistema. Nesse caso as forças costumam serem modeladas para
adicionar um controle de compensação de fricção e demais forças externas [Gäfv98].

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.

2.2 Modelo Físico do Pêndulo


Ao modelar um sistema a primeira coisa que deve ser feita é encontrar as equações físicas que
o descrevem. No caso do pêndulo é necessário encontrar as equações do movimento para
poder modelar a velocidade, a energia, o controle de torque e compensação de fricção. Como
pode ser observado na Figura 2.1, o pêndulo apresenta dois braços com revoluções distintas, o
primeiro braço apresenta uma revolução na horizontal em um ângulo ϕ com um comprimento
ra, e o segundo braço apresenta uma revolução na vertical em um ângulo θ com um
comprimento rp. A descrição física do espaço desses braços pode ser encontrada como uma
22

composição de componentes inter-relacionadas no eixo x, y e z, pois a movimentação do


ângulo é feita nas três dimensões.

r (ra , rp ) = (rx (ra , rp ), ry (ra , rp ), rz (ra , rp ))T (Equação 1)

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:

v(ra , rp ) = (vx (ra , rp ), v y (ra , rp ), vz (ra , rp ))T (Equação 3)

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

para energia cinética, e:

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)

para energia cinética total, e:

U = U CM + U BH + U BV + U MB (Equação 7)

para energia potencial gravitacional total.


23

2.3 Equações de Lagrange


Depois de entendido como encontrar as funções de energia do sistema é necessário fazer um
estudo sobre as equações de Lagrange, pois utilizando essa ferramenta matemática, será
possível encontrar as equações de torque.

Utilizando Lagrange as equações de movimento de um sistema podem ser deduzidas. Ao


contrário das Leis de Newton, o método de Lagrange não necessita identificação das forças
envolvidas. Dessa forma, as equações de Lagrange são utilizadas para simplificar a
modelagem de sistemas complexos, principalmente quando não é necessário saber as forças
que causam o movimento da partícula [CaMa01].

A posição de uma partícula é definida pelo seu vetor de posição r , que pode ser decomposto
em componentes ao longo do plano cartesiano x, y e z (como mostrado na subseção anterior).
Para especificar a posição de uma partícula são necessárias três coordenadas. No entanto, é
possível conhecer a posição de determinados sistemas a partir de um número inferior de
coordenadas. O número de graus de liberdade é a quantidade de variáveis independentes
necessárias para conhecer a posição de um sistema.

Para definir completamente a posição de um corpo com S graus de liberdade, serão


necessárias S variáveis independentes. Essas variáveis são conhecidas como coordenadas
generalizadas. A escolha dessas coordenadas é livre, não existe uma única opção, o que
permite que ao realizar o modelo, o engenheiro decida de maneira a simplificar ao máximo os
cálculos. A escolha dessas coordenadas é chamada de parametrização do sistema.

Na formulação do calculo do lagrangeano, o sistema é caracterizado por uma determinada


função que depende das coordenadas generalizadas (q), e das suas derivadas temporais ( qɺ ) e
também do tempo. A função designada como lagrangeana do sistema é dada por: L(q, qɺ , t) e
pode ser escrita como:

L = K −U (Equação 8)

onde K é a soma de todas as energias cinéticas e U a soma de todas as energias potenciais


gravitacionais do sistema.

Utilizando o principio de ação mínima, também conhecida como principio de Hamilton, a


evolução do sistema, ou seja, q(t), em dois instantes de tempo pode ser escrita como:

t2
(Equação 9)
S = ∫ L(q, qɺ , t )dt
t1

Desenvolvendo a integral mostrada acima, é possível mostrar que a minimização da ação


conduz a um conjunto de equações diferenciais que são conhecidas como equações de
Lagrange, que podem ser descritas como:
24

d  ∂L  ∂L (Equação 10)
 − =0
dt  ∂qɺi  ∂qi

para i = 1, 2, ..., s. O i representa as coordenadas generalizadas, ou seja, terá uma equação de


lagrange para cada coordenada generalizada do sistema. Essa equação também pode ser
chamada de equações diferenciais do movimento. A resolução dessas equações para o sistema
apresentado neste trabalho irá resultar nas equações de torque aplicado nos ângulos de cada
braço, mas essa resolução será apresentada posteriormente.

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.

2.4.1 Série de Taylor


Para linearizar sistemas não lineares uma abordagem que pode ser utilizada é a expansão das
funções em Séries de Taylor. Considerando uma função f(x), e supondo que x é um ponto
onde f ( x ) = 0 . Neste caso, o ponto x é chamado o ponto de equilíbrio do sistema xɺ = f ( x) ,
desde que xɺ = 0 quando x = x (o sistema atingirá o equilíbrio em x ). A expansão da serie de
Taylor de f(x) em torno do ponto x é dado por:

`df 1 d2 f 1 d3 f (Equação 11)


f ( x) = f ( x ) + (x − x ) + (x − x ) + 2
( x − x )3 + ...
dx x=x 2 dx 2 x=x
6 dx 3 x=x

que pode ser escrita como:

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

Para completar a linearização, um estado de perturbação é inserido por: δ x = x − xɺ . E usando


o fato de que δ xɺ = xɺ , o modelo de linearizado é obtido:

δ xɺ = aδ x (Equação 15)

• Estendendo para funções de múltiplos estados e entradas


A extensão para funções de múltiplos estados e entradas é muito similar com o processo
mostrado anteriormente. Supondo que a evolução do estado xi é dada por:

xɺi = f i ( x1 , x2 ,..., xn , u1 , u2 ,..., um ) (Equação 16)

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:

f i ( x1 , x2 ,..., xn , u1 , u2 ,..., um ) = 0 ∀i ∈{1, 2,..., n} (Equação 17)

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

Se o estado de perturbação e entradas são definidos δ x j = x j − x j (para 1 ≤ j ≤ n) e


δ u j = u j − u j (para 1 ≤ j ≤ m), a dinâmica linearizada do estado xi são dadas por:

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

2.4.2 Linearização com feedback


Em caso de sistemas de tempo contínuo um dos métodos que podem ser utilizados para a
linearização de um sistema não-linear é a linearização com feedback [Sala09]. Quando as
entradas do processo (u) aparecem na forma linear na equação do espaço de estado como
segue:

xɺ = f ( x) + g ( x)u (Equação 20)


y = h( x)

onde, x = [x1, ..., xn]T é o vetor de estados, u é a entrada manipulada e y é a saída do


controlador do sistema. Em geral, f, g e h são representados como vetor de aperfeiçoamento.
26

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:

y (s) 1 (Equação 22)


=
v( s ) β r s + ... + β1s + β 0
r

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:

Lg Lif−1h( x) = 0 ∀ i < r e x perto de x0 (Equação 23)


Lg Lrf−1h( x) ≠ 0 ∀ x perto de x0

onde, Lg e Lf são derivadas de Lie definidas como:


n
∂h
L f h( x) = ∑ f i ( x ) ( x)
i =1 ∂xi
(Equação 24)
n ∂L f h
Lg L f h( x) = ∑ g i ( x) ( x)
i =1 ∂xi

Enquanto, os termos de maior grau das derivadas de Lie podem ser escritos como:

Lαf h( x) = L f ( Lαf −1h) (Equação 25)

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

2.5 Forças Contrárias ao Movimento


Na realização da modelagem matemática do modelo, as forças externas precisam ser
consideradas, pois do contrário o sistema não funcionará como esperado. As forças externas
que agem em um sistema como o pêndulo de Furuta são: gravitacional, centrípeta e
centrifuga, coriolis e fricção.

2.5.1 Força Gravitacional


O exemplo mais simples de força externa é a gravitacional. Ela é simples, pois é parte do
nosso cotidiano. Todos os corpos na Terra estão sujeitos a essa força e com o pêndulo não
seria diferente. A força gravitacional age “puxando” todos os corpos para baixo, no sentido da
Terra, então quando o pêndulo de Furuta adiciona o torque no motor para conseguir levantar o
pêndulo para o ponto de equilíbrio, esse pêndulo sofre uma força em sentido contrário, que
“tenta” mantê-lo o mais próximo da Terra (Figura 2.2).

Figura 2.2 - Esquema de Forças.

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

totalmente transformada e agora só existe energia potencial gravitacional. E o mesmo ocorre


caso o braço saia do seu ponto de equilíbrio, ele irá perder energia potencial gravitacional e
ganhar energia cinética. Como foi dito, não é uma conservação perfeita, devido ao sistema
não estar isolado, mas essa energia potencial precisa ser considerada no modelo matemático
do controlador. O cálculo da energia potencial gravitacional foi demonstrado na subseção 2.2.

2.5.2 Força Centrípeta e Centrífuga

• 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.

Figura 2.3 - Força Centrípeta.

A força é dada pela fórmula:


 
F = ma (Equação 27)

e a aceleração, que neste caso é a aceleração centrípeta, é dada por:


2 (Equação 28)
 v
acp = − rˆ
r
29

então a força centrípeta pode ser calculada como:


2 (Equação 29)
 v
F =m rˆ
r

Onde:

m é a massa (em quilogramas)

v é a velocidade linear do corpo (em metros por segundo)

r é o raio da trajetória percorrida pelo corpo (em metros)

• 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).

Figura 2.4 - Força Centrífuga.

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)

que em módulo pode ser descrita como:


 
Fcf = mω 2 r (Equação 31)
30

2.5.3 Força de Coriolis


Em um referencial em rotação uniforme, os corpos em movimento, tais que visto por um
observador no mesmo referencial, aparecem sujeitos a uma força perpendicular a direção do
seu movimento (Figura 2.5).

Figura 2.5 - Força de Coriolis.

Esta força é chamada Força de Coriolis em homenagem ao engenheiro francês Gustave-


Gaspard Coriolis.

Os corpos em movimento em relação ao referencial em rotação também são sujeitos uma


força radial, perpendicular ao eixo de rotação: a força centrífuga, que foi discutida na
subseção anterior. A força centrífuga e a força de Coriolis são, portanto, duas parcelas da
força inercial total necessária à descrição dos movimentos dos corpos observados a partir de
referenciais não inerciais que giram em relação a um referencial inercial. Sendo parcelas de
força inercial, as duas não são consideradas forças na definição formal da palavra, e sim
pseudo forças. É considerada uma pseudo força ao invés de força, quando não é possível
encontrar a reação do par ação-reação da componente desejada.

A representação vetorial da força de Coriolis pode ser dada por:


  
Fc = 2m(v × ω ) (Equação 32)

A força de Coriolis é perpendicular ao eixo de rotação do referencial e ao vetor de velocidade


do corpo em movimento. Se o corpo se afasta do eixo de rotação, a força é exercida no
sentido contrário da rotação. Se o corpo se aproxima do eixo de rotação, a força é exercida no
mesmo sentido do eixo de rotação. Modelar esta força para experimentos com pêndulo é
importante, pois ela causa modificação no plano do movimento de um pêndulo, como foi
demonstrado por Foucault em experimentos com pêndulo [Wolf05].
31

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:

Ff é a força de fricção máxima

µ é o coeficiente de fricção, que é uma propriedade empírica dos materiais

Fn é a força normal exercida entre as superfícies.

Quando as superfícies em contato se movem, a fricção entre as duas superfícies é convertida


de energia cinética para energia térmica. Essa propriedade pode trazer más conseqüências,
como por exemplo, superaquecimento de peças levando a danificar o circuito, ou no caso do
trabalho apresentado, impedir o movimento correto do pêndulo e atrapalhar o controle de
estabilização, pois a força de atrito é sempre oposta ao movimento. Atrito não é uma força
fundamental, mas ocorre por causa das forças eletromagnéticas entre partículas carregadas
que constituem as superfícies de contato.

2.5.4.1 Atrito Estático


Atrito estático é a fricção que ocorre quando o movimento será iniciado. Todas as peças
como, rolamentos e escovas dos motores estão em repouso, ao iniciar o movimento haverá um
atrito que tentará impedir o movimento, pois de acordo com a primeira lei de Newton, todo
corpo em repouso, tende a permanecer em repouso. Ao projetar um controlador para um
sistema é necessário levar em consideração o atrito, pois esse atrito causará uma perda de
torque no inicio do movimento. Então, uma forma de acabar com essa perda de torque é
projetar um controlador com uma compensação, essa compensação irá calcular o coeficiente
de atrito e levá-lo em consideração no momento de adicionar o torque no motor, assim o
torque será dado para colocar o pêndulo na posição de equilíbrio já com um valor que suprirá
a perda de ganho que o atrito causaria.

2.5.4.2 Atrito Viscoso


A viscosidade é a propriedade dos fluidos correspondente ao transporte microscópico de
quantidade de movimento por difusão molecular [Wiki10]. Quanto maior a viscosidade,
menor será a velocidade. No caso apresentado, a viscosidade será constante, pois não haverá
mudança de estado no movimento, não haverá um movimento que passe de um tipo de fluido
para outro. O atrito viscoso precisa ser considerado, pois o trabalho proposto não é um
trabalho isolado, não está sendo montado no vácuo, então ao iniciar o movimento e tentar
elevar o pêndulo, o braço tem contato com o ar, que apresenta um coeficiente de viscosidade
32

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:

τ é a força necessária para vencer a viscosidade

µ é o coeficiente de viscosidade

E a derivada parcial é o gradiente do movimento.

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.

2.6.1 Malha Aberta


Sistemas de malha aberta são sistemas que a saída não tem efeito sobre a ação do controle.
Em outras palavras, o sistema de malha aberta é um sistema não realimentado, ou seja, a saída
não influenciará em nada na entrada e não haverá comparações com a entrada.

Figura 2.6 - Sistema de Malha Aberta.

Na Figura 2.6 é mostrado um exemplo simples de um sistema de malha aberta. A entrada é


um sinal para ligar ou desligar o atuador, esse atuador irá iniciar o movimento de uma esteira
33

para transporte de material. A saída do sistema não influência na decisão, o sistema só


receberá o sinal de ativação, para ligar ou desligar, a saída final não importa para o controle.

As características de um sistema de malha aberta são:

• A saída é baseada na experiência do projetista, conduzindo a uma saída desejada;

• O sistema não reagirá a distúrbios;

• Os sistemas são mais simples de projetar.

2.6.2 Malha Fechada


Em um sistema de malha fechada, a variável que está sendo controlada tem um sensor e seus
valores são medidos durante o processo, porque os valores medidos irão realimentar o
processo, e sua saída é influenciada na sua nova entrada. Um exemplo simples de malha
fechada é um controlador para temperatura de um ar-condicionado (Figura 2.7). O usuário
define a temperatura que deseja, o compressor do ar-condicionado irá ligar para atingir a
temperatura desejada, mas terá um sensor para verificar se essa temperatura foi alcançada, se
ela foi alcançada o compressor irá desligar se não o compressor irá manter-se ligado. Esse é
um exemplo de controle realimentado, a entrada do controlador depende de uma comparação
da saída.

Figura 2.7 - Controle de Temperatura.

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;

• Diminuir o efeito de variações dos parâmetros, dos erros e dos ruídos.

2.6.3 Controle Proporcional


O controlador proporcional atua como uma correção de erro entre o valor de saída e o valor de
entrada. Ele faz a multiplicação da diferença entre o valor desejado e o valor da saída (erro)
34

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)

onde Kp é o ganho proporcional. Esse ganho proporcional é a constante multiplicada para


aperfeiçoar a saída do sistema. Na Figura 2.8 é mostrado um sistema com um controlador
proporcional.

Figura 2.8 - Planta com controlador proporcional.

O controlador proporcional, para sistemas de ordens altas, grandes valores de realimentação


proporcional, tipicamente o levará à instabilidade. No projeto de controladores proporcionais
existe um limite no ganho de realimentação proporcional, para obter uma resposta estável
com um bom amortecimento.

2.6.4 Controle Proporcional Derivativo (PD)


A realimentação derivativa apresenta-se da forma:

de (Equação 36)
u = KD
dt

onde KD é o ganho derivativo. A realimentação derivativa é utilizada em conjunto com a


realimentação proporcional (Figura 2.9) para aumentar o amortecimento do sistema e
geralmente melhorar sua estabilidade.

Figura 2.9 - Planta com controlador proporcional derivativo.


35

A realimentação puramente derivativa não é prática do ponto de vista de implementação


experimental, pois se o erro e(t) permanecesse constante, a saída do controlador derivativo
seria zero e um termo proporcional seria necessário para fornecer um sinal de controle. No
controle derivativo a correção depende da taxa de variação do erro.

• 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:

 de(t )  (Equação 37)


u (t ) = K  e(t ) + Td 
 dt 

Considerando-se que e(t) pode ser aproximado por:

de(t ) (Equação 38)


e(t + Td ) ≈ e(t ) + Td
dt

tem-se que u (t ) ≈ K e (t + Td ) , ou seja, o sinal de controle é proporcional a estimativa do erro


de controle Td unidades de tempo a frente. Em outras palavras, a predição é feita extrapolando
o valor do erro pela reta tangente a curva do erro no instante t (Figura 2.10).

Figura 2.10 - Ação proporcional derivativa.


36

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.

2.7 Redes Neurais


As RNA’s (redes neurais artificiais) são baseadas nas RNN’s (redes neurais naturais). Nessa
seção será apresentada uma visão geral sobre o funcionamento dos neurônios naturais, e
depois será feita uma comparação com as redes neurais.

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.

2.7.1 Redes Neurais Naturais


Como foi dito anteriormente, as RNA’s teve como base o funcionamento o cérebro humano.
O processamento das informações no cérebro mediante nossos sensores naturais, os sentidos,
é uma forma paralela de processamento. O tecido nervoso é constituído por células nervosas e
fibras nervosas, que são formadas por várias classes de células. A célula nervosa é chamada
de neurônio, e é a unidade mais funcional do sistema nervoso. Há diferentes tipos de
neurônios, como: bipolares, com duas prolongações de fibras, e multipolares, com numerosas
prolongações. Há também neurônios de diferentes funções, como: sensoriais, motores e de
associação. O corpo do neurônio (Figura 2.11) é composto de um núcleo. A soma de todas as
atividades que ocorrem e o meio de transporte e conexões das informações são feitas através
das sinapses. O dendrito é a parte que cuida das conexões de entrada das informações e o
axônio é a parte que cuida das conexões de saída das informações. As saídas são sinais e
impulsos nervosos que são passados para as células nervosas.
37

Figura 2.11 - Representação de um neurônio natural.

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.

Computador Cérebro Humano

Unidades computacionais 1 CPU, 108 portas lógicas 1011 neurônios

Unidades de armazenamento RAM de 1010 bits 1011 neurônios

Disco de 1011 bits 1014 sinapses

Tempo de Ciclo 10-9 segundo 10-3 segundo

Largura de Banda 1010 bits/s 1014 bits/s

Atualizações de memória/s 109 1014

Tabela 2.1 - Comparação entre o cérebro humano e o computador [RuNo04].

2.7.2 Redes Neurais Artificiais


Como foi explicado anteriormente, um neurônio é uma célula cerebral que tem como função
coletar informações, processá-las e enviar os sinais necessários na forma de sinais elétricos.
Acredita-se que as informações processadas pelo cérebro são baseadas em redes de neurônios
38

[RuNo04], por esta razão os trabalhos em inteligência artificial concentraram-se em


desenvolver redes neurais artificiais, tentando assim criar uma imitação do cérebro humano
para solução de problemas. Na Figura 2.12 é mostrada a arquitetura de um neurônio artificial.

Figura 2.12 - Representação de um neurônio artificial.

Observando as Figuras 2.11 e 2.12 é possível perceber a semelhança no modo de


funcionamento. O dendrito é representado pelas entradas x1, x2, ..., xn, o axônio é a saída da
rede e a camada onde se encontra a função de ativação representa a sinapse. A função de
ativação, ou função de transferência como também é chamada, é uma função matemática que
delimita a saída.

• 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.

Figura 2.13 - Neurônio de entrada simples [HaDeBe96].

A saída do neurônio apresentada na Figura 2.13 pode ser calculada como:

a = f ( wp + b) (Equação 40)
39

Onde:

a é a saída do sistema;

f é a função de transferência escolhida;

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.

Figura 2.14 - Influência do peso e do bias.

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.

Nome Relação entrada/saída Ícone

Hard Limit a=0 n<0

a=1 n≥0

Symmetrical Hard Limit a = -1 n<0

a = +1 n≥0

Linear a=n
40

Saturating Linear a=0 n<0

a=n 0≤n≤1

a=1 n>1

Symmetric Saturating Linear a = -1 n < -1

a=n -1 ≤ n ≤ 1

a=1 n>1

Log-Sigmoid 1
a=
1 + e−n

Hyperbolic Tangent Sigmoid en − e−n


a=
en + e− n

Positive Linear a=0 n<0

a=n n≤n

Competitive a = 1 neurônio com n máximo

a = 0 todos outros neurônios

Tabela 2.2 - Funções de Transferência.

• Neurônios com múltiplas entradas


Na maioria dos projetos de sistemas os neurônios têm mais de uma entrada. Na Figura 2.15
será mostrada a arquitetura de um neurônio com R entradas.

Figura 2.15 - Neurônio de múltiplas entradas.

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

a = f(Wp+b) (Equação 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:

n = w1,1 p1 + w1,2 p2 + ... + w1, R pR + b (Equação 42)

A expressão escrita na forma matricial é dada por:

n = Wp+b (Equação 43)

e o valor a mostrado acima é a saída da rede.

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.

Figura 2.16 - Rede de camada simples, mas com múltiplos neurônios.

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.

• Neurônios com múltiplas camadas


Uma evolução no estudo de redes neurais foi o surgimento das redes multicamadas. Cada
camada tem sua própria matriz de pesos, seu próprio vetor de bias, um vetor de entradas n e
um vetor de saída a. A arquitetura da rede multicamadas é mostrada na Figura 2.18.

Figura 2.18 - Neurônios com múltiplas camadas.

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

podendo reescrever a saída como a combinação de todas as camadas:

a 3 = f 3 (W 3 f 2 (W 2 f 1 (W 1 p + b1 ) + b 2 ) + b3 ) (Equação 45)

• Arquitetura Feedforward e Feedback


A rede feedforward (Figura 2.19) não existe conexão entre os neurônios de saída com os
neurônios de entrada. Essa rede não utiliza valores prévios de saída como ativação de algum
estado do neurônio. Conhecida como arquitetura de pré-alimentação, essa rede é acíclica e
apresenta uma alimentação direta. Essa alimentação representa uma função de uma entrada
atual; desse modo, ela não tem nenhum estado interno além dos pesos.

Figura 2.19 - Arquitetura feedforward.

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.

Figura 2.20 - Arquitetura feedback.

O objetivo da realimentação é fazer a rede convergir e se estabilizar em algum instante t, após


algumas interações. Esse tipo de rede é importante quando se trabalha com memórias
associativas (onde um novo caso apresentado é associado a um dos padrões previamente
treinados).
44

• 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.

O treinamento supervisionado é ajustar os pesos de acordo com um conjunto de dados de


entrada (chamados de conjunto de treinamento). Esse conjunto de dados é uma combinação
de informações de entrada e saída desejada sobre o conhecimento que a rede deve aprender.
Dessa forma, para cada entrada os pesos dos neurônios serão ajustados gradativamente. O
objetivo para isso é que depois de treinada, a rede passará a reconhecer padrões que sejam
semelhantes aos padrões inseridos como entrada.

O treinamento não-supervisionado deixa a rede livre para organizar as informações


apresentadas conforme a proximidade de identificação de um neurônio. Para cada padrão de
entrada, apenas um neurônio será identificado com a entrada e terá seu peso ajustado para a
melhor identificação da entrada inserida. Os neurônios vizinhos também terão os pesos
ajustados, mas não com a mesma intensidade, desta forma a rede garante que um neurônio
terá prioridade na identificação do padrão, mas garantindo também que os seus semelhantes
estarão próximos.

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

Durante o processo de treinamento do perceptron, a rede buscará um conjunto de pesos que


defina uma reta que separará as classes diferentes. Quando esse conjunto é inserido os pesos
serão calculados e alcançados, durante o processo se a saída estiver incorreta, esses pesos
serão ajustados segundo um algoritmo de aprendizagem descrito abaixo.

Variáveis e Parâmetros:

x(n): vetor de entrada;

w(n): vetor de pesos;

b(n): bias;

y(n): resposta real;

d(n): resposta desejada;

e(n): erro na saída;

h: taxa de aprendizagem, constante positiva entre 0 e 1;

n: contador dos passos.

1o Passo:

Inicializa os valores do vetor de peso e da taxa de aprendizagem.

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 a resposta real do perceptron, utilizando a fórmula:


y (n) = f ( w(n) x(n) + b(n)) , onde f é a função de transferência utilizada;

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.

A RNA BP é composta de um conjunto predefinido de entradas e saídas desejadas realizando


um ciclo de propagação e adaptação. Depois de o padrão de entrada ter sido aplicado na rede,
ela se propaga camada por camada até gerar uma saída. O padrão de saída gerado é
comparado com o a saída desejada e é calculado um sinal de erro para cada camada da rede. O
sinal de erro calculado é transmitido para trás, camada por camada, que contribuiu para a
saída da rede. Cada camada recebe uma porção desse erro, de acordo com a sua influência na
saída. Esse processo irá se repetir até que o sinal de erro convirja em um valor aceitável, que é
determinado pelo projetista da rede. Esse sinal de erro colabora para o ajuste dos pesos com o
intuito de minimizar o próximo erro que será calculado, causando assim a convergência da
rede de tal forma que ela possa reconhecer todos os padrões dados como entrada do
treinamento. Conforme a rede vai sendo treinada as camadas intermediárias irão se ajustar
fazendo com que as diferentes camadas aprendam a reconhecer diferentes valores do conjunto
de entrada.

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.

• Treinamento de uma rede Backpropagtion


1o Passo: Adiciona um vetor de entrada, x p = ( x p1 , x p 2 ,..., x pN )T .

Propagação:

2o Passo: Depois de apresentado o exemplo do conjunto de treinamento T = {x(n), d (n)} ,


sendo x(n) a entrada apresentada à rede e d(n) a saída desejada, calcular o valor de ativação e
a saída para cada camada da rede, da seguinte maneira:
m
1
v j = ∑ w ji xi + b , para o calculo de ativação e f (v) = , para o calculo da saída da
i =1 1 + e( − av )
camada, utilizando a função sigmóide, como exemplo, ou outra função se necessário. Utilize a
saída das camadas como entrada das camadas seguintes, até a última camada. A saída da
última camada é a resposta da rede.
47

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 constante de momento, quando α = 0, está função funciona como a regra delta


comum;

η é a taxa de aprendizado;

δ j é o erro do neurônio;

y j a saída produzida pelo neurônio.

5o Passo: Esse passo é o passo de interação, os itens 2, 3 e 4 referentes a propagação, cálculo


do erro e retro propagação, apresentando novos estímulos de entrada, até que as condições de
treinamento sejam alcançadas. As condições são duas:

• O erro da rede está baixo, sendo pouco alterado durante o treinamento, ou seja, o erro
mínimo foi alcançado;

• O número máximo de épocas (ciclos) 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 abordagem CC tem vantagens, em termos de hardware e software. Em termos de hardware


temos:

• A abordagem CC não requer estimativa de prioridade quanto ao tamanho da rede, em


termos de camadas e tamanho das camadas (excluindo entradas de I/O);

• A saída da rede tem uma conexão de passagem direta para todas as entradas da rede e
entradas das camadas seqüentes;

• Unidades no centro da rede são seletivamente acrescentadas, de acordo com a


necessidade. A originalidade da criação de nós dinamicamente, usando uma medida de
correlação de erro, é uma das características mais importantes dessa abordagem. Além
disso, as unidades não são camadas, elas são cascatas. Então, uma unidade recebe
ativação de todas as entradas da rede e também das entradas das camadas pré-
adicionadas.

Em termos de software temos:

• A incorporação da “paciência” no algoritmo de aprendizagem, de que finaliza o


treinamento se o erro não tem modificação para um percentual fixo desde a última
época;

• O “congelamento” de pesos de unidades, desse modo necessitando de menos


treinamento e diminuindo o custo computacional;

• O uso da correlação de erro para decidir um “candidato” a unidade que será


adicionada.
49

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.

3.1 Plataforma utilizada


Para a solução deste problema a plataforma utilizada foi o Mechatronics Control Kit
desenvolvido pela empresa canadense Quanser Consulting Inc.. Essa plataforma disponibiliza
de todo equipamento necessário para montar e implementar o experimento do pêndulo de
Furuta (Figura 3.1).

Figura 3.1 - Plataforma utilizada na concepção.

O kit de desenvolvimento disponibiliza um pacote de instalação, com todos os programas


necessários para o funcionamento, bem como exemplos para deixar o usuário familiarizado
com a ferramenta. No Apêndice A, será mostrado um manual de instalação do kit, no
Apêndice B, será mostrado um manual de montagem do hardware e no Apêndice C, será
mostrado um manual de conexão entre o computador e o kit.
50

Em termos de hardware o kit é composto de:

• Motor DC de 24 volts para provocar o torque no pêndulo;

• 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;

• C6713DSK da Texas Instruments, para o onde o código é executado;

• Placa de amplificador PWM;

• E as peças de alumínio que compõem a montagem do pêndulo.

Foi utilizado um computador Intel Pentium 4, CPU 2.80GHz, 512RAM com os seguintes
softwares instalados:

• Windows XP – Professional 2002 – Service Pack 3;

• Matlab 7.0 com Simulink e Real-Time Workshop;

• Microsoft Visual C++ 6.0 Standard Edition;

• Real-Time Windows Target 2.5.

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.

3.2 Modelo Matemático


Como foi mencionado na parte teórica, o primeiro passo para a construção de um controlador
é a modelagem matemática do sistema. Os passos para a criação do modelo matemático
utilizado neste trabalho foi proposto por Magnus Gäfvert [Gäfv98]. Na Figura 3.2 é mostrado
o sistema descrito em um plano cartesiano para que suas coordenadas sejam calculadas.
51

Figura 3.2 - Plano cartesiano do pêndulo de Furuta.

Com a representação das coordenadas cartesianas do pêndulo é possível iniciar o cálculo de


suas componentes, seguindo os passos apresentados na parte teórica. Primeiramente as
coordenadas do espaço são retiradas para cada eixo de movimento:

rx = ra cos φ − rp senφ senθ


ry = ra senφ + rp cos φ senθ
(Equação 46)
rz = rp cos θ

Depois de obtidas as equações do espaço, sabe-se que calculando as derivadas dessas


equações, as velocidades serão obtidas:

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θθɺ

Elevando todas componentes ao quadrado, obtemos:

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

ɺ ɺ + r r sen 2φ cos θφθ


rp2 senθ senφ cos φ cos θφθ ɺ ɺ + r 2 senφ senθ cos φ cos θθφ ɺ ɺ + r 2 sen 2φ cos 2 θθɺ 2
a p p p (Equação 48)
v y = ra cos φφɺ − ra rp senφ cos φ senθφɺ + ra rp cos φ cos θθφ
2 2 2 2 2 2 ɺ ɺ − r r senφ cos φ senθφɺ2 + r 2 sen 2φ sen 2θφɺ2 −
a p p

r senθ senφ cos φ cos θφθ


2 ɺ ɺ + r r cos φ cos θφθ
2 ɺ ɺ − r senφ senθ cos φ cos θθφ
2 ɺ ɺ + r cos 2 φ cos 2 θθɺ 2
2
p a p p p

v = r sen θθɺ
2
z
2
p
2 2
52

2 2 2 2
Agora fazendo v =vx +vy +vz , obtemos:

v 2 = (ra2 + rp2 sen 2θ )φɺ2 + 2ra rp cos θθφ


ɺ ɺ + r 2θɺ 2
p
(Equação 49)

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

Equação 50 foi calculada a energia cinética, e U = 0 , para energia potencial gravitacional.


Não há energia potencial gravitacional, pois o centro de rotação encontra-se na origem.

Braço Horizontal:
l
1a m
K = ∫ v 2 ( s, 0) a ds
20 la

1  a 2 ɺ2 
l la la la

K = ma  ∫ ra φ ds + ∫ rp sen θφ ds + 2 ∫ ra rp cos θφθ ds + ∫ rp2θɺ 2 ds 


2 2 ɺ2 ɺ ɺ (Equação 51)
2  0 0 0 0 
la
1  r3  1 l3
K = maφɺ2  a  = maφɺ2 a
2  3la  0 2 3la
1
2 K = ma la2φɺ2
3

Na equação 51 a energia cinética foi calculada, e U = 0 , para energia potencial gravitacional.


O braço horizontal também não há energia potencial gravitacional, pois o braço é fixado no
centro de rotação, que como foi dito encontra-se na origem.
53

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:

2 K = M  ∫ ra2φɺ2 + ∫ rp2 sen 2θφɺ2 ds + 2∫ ra rp cos θφθ ɺ ɺds + r 2θɺ 2 ds 


∫p 

(Equação 54)
2 K = M la2φɺ2 + l p2 sen 2θφɺ2 + 2la l p cos θφθ
ɺ ɺ + l 2θɺ 2 
p 
ɺ ɺ
2 K = M (la + l p sen θ )φ + 2Mla l p cos θφθ + Ml pθ
2 2 2 2 ɺ 2 ɺ2

U = Mg ∫ rp cos θ ds
(Equação 55)
U = Mgl p cos θ

Depois de calculada todas as energias (cinética e potencial) do sistema, agora é preciso


encontrar as energias totais, que é a soma de todas as energias. Para o calculo da energia
cinética total, usa-se K = K cr + K bh + K bv + K M e para energia potencial total, usa-se
U = U cr + U bh + U bv + U M .

Substituindo os valores encontrados anteriormente na soma da energia total, obtém:

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

Depois de encontrada as equações de energia total do sistema é hora de montar o lagrangeano


(Equações 8 e 10) para obter as equações do movimento. As equações lagrangeanas são dadas
por:

d  ∂L  ∂L
τφ =  − (Equação 58)
dt  ∂φɺ  ∂φ
d  ∂L  ∂L
τθ =  −
dt  ∂θɺ  ∂θ

Calculando o lagrangeano, obtém:

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: φ

Não existe componente em φ , então a derivada parcial deste termo é zero.

∂L (Equação 60)
=0
∂φ

Componente: φɺ

∂L ∂φɺ 2 1 ∂φɺ2 ∂φɺ2 1 ∂φɺ2 ∂φɺ


=J + mala2 + m p la2 + m p l p2 sen 2θ + m pla l p cos θθɺ +
∂φɺ ɺ
∂φ 3 ∂φɺ ɺ
∂φ 3 ∂φ ɺ ∂φɺ
∂φɺ2 ∂φɺ2 ∂φɺ (Equação 61)
Mla2 + Ml p2 sen 2θ + 2 Mla l p cos θθɺ
∂φɺ ∂φɺ ∂φɺ

∂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: θ

∂L 1 1 ɺ ɺ + ( M + 1 m ) gl senθ (Equação 62)


= ( M m p )l p2 senθ cos θφɺ2 − ( M + m p )la l p senθθφ
∂θ
p p
3 2 2
55

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 θθɺɺ + 2β cos θ senθφθ


ɺ ɺ − γ senθθɺ 2 (Equação 65)

τ θ = γ cos θφɺɺ + βθɺɺ − β cos θ senθφɺ2 − δ senθ

Com a equação 65, uma descrição matricial pode ser realizada:

 φɺɺ   φɺ  (Equação 66)


D(φ , θ )   + C (φ , θ , φɺ, θɺ)   + g (φ , θ ) = τ
 θɺɺ  θɺ 
   

Onde, a matriz D, representa a matriz de inércia, a matriz C, representa a matriz centrípetal e


de Coriolis e a matriz g, representa a matriz de gravitação. Reescrevendo as equações de
movimento dadas acima, teremos:

τ φ = [α + β sen 2θ ]φɺɺ + [γ cos θ ]θɺɺ + [ β cos θ senθθɺ]φɺ + [ β cos θ senθφɺ − γ senθθɺ]θɺ (Equação 67)
D1,1 D1,2 C1,1 C1,2

τ θ = [γ cos θ ]φɺɺ + [ β ]θɺɺ − [ β cos θ senθφɺ]φɺ − [δ senθ ]


D2,1 D2,2 C2,1 g 2,1
56

Substituindo na Equação 66 os valores encontrados na Equação 67 obtém as matrizes:

α + β sen 2θ γ cos θ 
D(φ ,θ ) ≜  
γ cos θ β 

 β cos θ senθθɺ β cos θ senθφɺ − γ senθθɺ  (Equação 68)


C (φ , θ , φɺ, θɺ) ≜  
 β cos θ senθφɺ 0 

 0 
g (φ , θ ) ≜  
 −δ senθ 

As matrizes D (φ , θ ) e C (φ , θ , φɺ, θɺ) satisfazem a propriedade fundamental:

N (φ , θ , φɺ, θɺ) = D (φ , θ ) − 2C (φ , θ , φɺ, θɺ) (Equação 69)

com a matriz simétrica:

 0 γ senθθɺ − 2β cos θ senθφɺ  (Equação 70)


N (φ ,θ , φɺ, θɺ) =  
ɺ ɺ
 −γ senθθ + 2 β cos θ senθφ 0 

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  θɺ  ɺ
θ 

e introduzindo a variável de estado:

φ 
 ɺ
φ
x≜ 
θ 
 
 θɺ 
 

a equação de estado será obtida:

dx (Equação 72)
= f ( x, τ )
dt

com f aproximadamente definido. O modelo linearizado no ponto de equilíbrio


x = (φ , φɺ , θ , θɺ ) , τ = 0 é obtido da equação:
0 0 0 0 0 0

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 

Encontrada todas as equações gerais que descreve o sistema matematicamente, o próximo


passo é desenvolver os controladores. Serão utilizados dois controladores, o controlador de
realimentação de estados livres para estabilizar o sistema, e o controlador PD para causar o
torque no motor (swing-up).

3.3 Controlador de Estabilização


O controle de balanço do pêndulo é realizado utilizando um controlador de realimentação de
estados lineares. Este controle é quem causa a estabilização do sistema.

Depois de obtidas as matrizes A, B e os autovalores do sistema, utilizando o LQR (algoritmo


de regulação quadrática linear) é possível calcular a matriz de ganhos para o controlador. Para
utilizar esse controlador a lei τ = − Kx minimiza a função de custo:

(Equação 74)
J (τ ) = ∫ ( xT Qx + τ T Rτ + 2 xT Nτ )dt
0

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)

e será obtidos os valores ótimos para o ganho.

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.

mp (kg) lp (m) ma (kg) la (m) M (kg) J [kg.m2]

0.0194 0.109855 0.0267 0.0454 0.0045 9.883x10-7

Tabela 3.1 - Valores empíricos de peso e medida.

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

-5,4502 -2,1003 -62,7014 -8,1168

Tabela 3.2 - Valores dos ganhos.

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.

Figura 3.3 - Bloco do Simulink para controle de estabilização.

Onde as entradas são:

x1k é o ângulo do braço da horizontal;

x2k é a velocidade angular do braço da horizontal;

x3k é o ângulo do braço da vertical;

x4k é a velocidade angular do braço da vertical.


59

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.

Depois de apresentado o controlador de estabilidade, o próximo passo é criar o controlador de


torque (swing-up) do sistema.

3.4 Controlador de Torque (Swing-up)


O controlador de torque é o componente que causa a movimentação do pêndulo. Esse
componente tem a tarefa de impulsionar o pêndulo para a posição de equilíbrio. Para a
realização dessa tarefa, foi utilizado o controlador proporcional derivativo (PD). Esse
controlador segue a seguinte expressão:

K p (u (3) − u (1)) − K d u (2) (Equação 77)

Seguindo a teoria apresentada neste trabalho é possível encontrar o ganho proporcional e o


ganho derivativo. Os valores encontrados são apresentados na Tabela 3.3.

Kp Kd

150 21

Tabela 3.3 - Ganhos proporcional e derivativo.

Com posse dos ganhos o componente de controle no Matlab Simulink pode ser criado. Na
Figura 3.4 esse componente é mostrado.

Figura 3.4 - Bloco do Simulink para controle de torque.

Onde as entradas são:

x1k é o ângulo do braço da horizontal;

x2k é a velocidade angula do braço da horizontal;

time é o clock do sistema.

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.

3.5 União dos Controladores


Depois do controlador de estabilização e o de torque terem sido concebidos, o sistema todo
pode ser montado no Simulink. A montagem deste sistema é importante para obter os valores
de treinamento da rede neural. Na Figura 3.5 é mostrado o sistema completo.

Figura 3.5 - Sistema de controle do pêndulo de Furuta.

O sistema completo apresentado na Figura 3.5 tem como composição o controlador de


estabilização e o controlador de torque. As entradas Encoder Input#1 e 2 recebem os valores
de posição dos dois braços, depois são passados por uma derivação para encontrar a
velocidade angular em cada braço e em seguida vão para os controladores. Há um bloco
chamado de Control Final que faz uma comparação para saber se é necessário estabilizar ou
causar o torque, baseada nessa decisão a saída dele irá para o PWM Output para fornecer a
ação correta para o motor. Foram inseridas variáveis nesse sistema para armazenar os valores
de entrada e os valores de saída (Figura 3.6).
61

Figura 3.6 - Amostragem retirada do sistema sem rede neural.

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).

Figura 3.7 - Saída do sistema sem controle neural.


62

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.

3.6 Rede Neural


Depois de obtido os dados de entrada e saída desejada através do controlador montado
anteriormente, é possível modelar a rede neural que será utilizada como controlador. Foram
apresentadas algumas arquiteturas de rede na parte teórica, na Tabela 3.4. É apresentada a
decisão na escolha da arquitetura para este projeto.

Rede: Resultado:

Percepton É utilizada apenas para problemas


linearmente separáveis.

Backpropagation Não obteve resultado satisfatório. Com 400


épocas convergiu em 20.354 sendo que o
objetivo era 0.

Cascade Forward Backpropagation Resultado satisfatório. Com 400 épocas


convergiu em 1.69923x10-5.

Tabela 3.4 - Decisão da rede neural.

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).

Figura 3.8 - Janela do nntool.


63

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.

Figura 3.9 - Criação de uma rede neural.

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.

Figura 3.10 - Janela de treinamento da rede.

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.

3.6.2 Função de Desempenho


A função de desempenho utilizada é o mínimo erro quadrático. O funcionamento desta
abordagem segue a fórmula:

MSE = (esperado − original )2

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.

3.6.3 Função de Transferência


A rede projetada para este projeto foi uma rede Cascade Forward Backpropagation de duas
camadas, sendo que, a primeira camada tem uma função de transferência tan-sigmoid
(também conhecida como Hyperbolic Tangent Sigmoid, Tabela 2.2) e a segunda camada uma
função de transferência linear (Figura 3.11).
65

Figura 3.11 - Arquitetura da rede utilizada.

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

Depois de decidida a topologia da rede, suas funções de treinamento, entradas e saídas


desejadas, a rede foi submetida ao treinamento. Como parâmetro de treinamento, foi utilizado
400 épocas (ciclos) e iniciou-se o treinamento com uma rede apresentando apenas um
neurônio e se a resposta não era satisfatória o número de neurônios da camada foi sendo
aumentado. O primeiro treinamento realizado foi para a rede que irá comportar como
controlador de estabilização (Figura 4.1).

Figura 4.1 - Treinamento do controlador de estabilização (1 neurônio).

É 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

Figura 4.2 - Treinamento do controlador de Figura 4.3 - Treinamento do controlador de


swing-up (1 neurônio). swing-up (2 neurônios).

Figura 4.4 - Treinamento do controlador de Figura 4.5 - Treinamento do controlador de


swing-up (3 neurônios). swing-up (4 neurônios).

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 treinadas ambas as redes, controlador de estabilização e controlador de swing-up,


elas devem ser adicionadas no projeto do Matlab Simulink para substituir o controlador PD e
o controlador de realimentação de estados lineares (Figura 4.6).

Figura 4.6 - Sistema de controle do pêndulo de Furuta usando redes neurais.

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.

4.1 Comparação das saídas


Para validar e mostrar que o controlador neural está tendo o comportamento adequado na
tarefa de controlar o pêndulo de Furuta, nesta seção será apresentado a comparação entre as
saídas dos controladores desenvolvidos e do controlador neural.

4.1.1 Controlador de Estabilização


O controlador de estabilização foi o que obteve melhor resposta com a rede neural (Figura
4.1), seu comportamento ficou muito similar ao do controlador REL (realimentação de
estados lineares – Figura 4.7).
69

Figura 4.7 - Comparação entre o controlador inteligente e o REL para estabilização.

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.

4.1.2 Controlador de Torque (Swing-up)


Como foi mencionado anteriormente, o controle inteligente do torque obteve uma dificuldade
maior no momento de estabilizar a saída, necessitando o aumento do número de neurônios na
primeira camada. Nessa seção são comparadas as saídas do controlador PD com as saídas de
cada rede proposta, mostrando assim as vantagens do aumento do número de neurônios na
aproximação da saída. Na Figura 4.8 é mostradas todas as saídas em gráficos separados.

Figura 4.8 - Comparação entre o controlador inteligente e o PD para controle do torque.


70

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.

Figura 4.9 - Comparação entre uma rede 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.

Figura 4.10 - Comparação entre uma rede de 2 neurônios e o controlador PD.


71

Na Figura 4.10 é mostrado a comparação para o controlador inteligente de 2 neurônios. É


possível perceber que a aproximação está alcançando o ponto ótimo desejado, mas ainda há
erros de aproximação no inicio do movimento e alguns pontos de falha no pico central, entre
os tempos de 5 e 10 segundos, e no momento da estabilização entre os tempos de 10 e 20
segundos.

Figura 4.11 - Comparação entre uma rede de 3 neurônios e o controlador PD.

Na Figura 4.11 é feita a comparação com o controlador inteligente de 3 neurônios. Os pontos


de falha da aproximação no pico e no momento da estabilização já desapareceram, ou seja, a
aproximação conseguiu cobrir esses pontos, mas ainda há falha no inicio do movimento. É
possível observar a curva azul, ou seja, elas ainda não se sobreporam e está havendo uma
diferença de resultados entre os dois controladores.

Figura 4.12 - Comparação entre uma rede de 4 neurônios e o controlador PD.


72

Na Figura 4.12 é mostrado o controlador inteligente de 4 neurônios. Neste gráfico é possível


perceber que a aproximação ótima foi encontrada. O comportamento dos dois gráficos está
igual, não é mais possível ver a linha azul, ou seja, elas se sobreporam. O controlador de 4
neurônios conseguiu obter uma aproximação ótima, assim como o controlador de
estabilização havia conseguido. No gráfico da direita foi feito um deslocamento do eixo y para
deixar clara a similaridade entre os dois controladores.

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.

4.1.3 Erro quadrático médio


Como foi mostrado na seção 3.6.2, o erro quadrático médio é uma relação entre a saída
desejada e a saída obtida. Esse erro mostra os pontos de falha do sistema e o grau de falha.
Como já foi visto, o controlador inteligente para o controle de estabilização e foi obtida uma
taxa de performance muito próxima do objetivo, isso quer dizer que a rede “aprendeu” com o
controlador REL e terá uma saída extremamente similar. No gráfico da Figura 4.13 é
mostrado o valor do erro entre a saída desejada e a saída obtida pela RN.

Figura 4.13 - EQM entre a saída da RN e do REL para o controle de estabilização.

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

Figura 4.14 - EQM entre a saída da RN e do PD para o controle de torque.

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.

Os resultados foram obtidos utilizando as saídas do controlador clássico e as saídas do


controlador inteligente. Com essas saídas foi possível gerar gráficos dos erros obtidos entre as
abordagens e gerar gráficos da saída para realizar uma comparação entre as duas abordagens.
A rede neural se comportou exatamente como o esperado, encontrando o ponto de equilíbrio
do pêndulo com maior precisão. As duas saídas se comportaram com extrema similaridade,
alcançando um erro mínimo e dessa forma, o pêndulo de Furuta foi controlado e estabilizado
utilizando o controlador neural.

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.

Meus conhecimentos sobre sistemas de controle, redes neurais, cálculos de linearização e


modelagem matemática foram ampliados e posso afirmar que essas novas experiências serão
de grande valia para o meu futuro, seja trabalhando ou continuando meus estudos a níveis de
mestrado e doutorado.
75

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.

[Gäfv98] Gäfvert, M.: Modelling the Furuta Pendulum. Department of Automatic


Control, Lund Institute of Technology, 2009.

[CaMa01] Carvalho, M.I.B.; Matos, A.C.C.: Mecânica Lagrangeana. Faculdade de


Engenharia da Universidade do Porto, Porto, Portugal, 2001.

[Sala09] Salahshoor, K.: Adaptive Feedback Linearization Control of Nonlinear


Processes using Neural Networn based approaches . Petroleum University of
Technology, Iran, 2009.

[ReHaKr0] Resnick, R., Halliday, D. e Krane, K.S.: Física 1. Ed.5a, 2003.

[Wolf05] The Foucault Pendulum.


http://www.animations.physics.unsw.edu.au/jw/foucault_pendulum.html
Acessado em: 04/07/10.

[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).

Figura A.1 - Menu Principal.

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.

Figura A.2 - Menu de Instalação.

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

reconhecido automaticamente, mas deve ser instalado utilizando a opção de procurar em


disco, depois de selecionada essa opção o Windows irá encontrar o driver automaticamente e
instalá-lo. Para realizar um teste de conexão e verificar se o driver foi instalado com sucesso,
o usuário deverá clicar no ícone do programa de diagnóstico (Figura A.3).

Figura A.3 - Ícone do 6713DSK Diagnostics Utility.

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.

Figura A.4 - Software de diagnóstico.

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.

Depois de instalados os softwares de identificação da placa, os softwares utilizados para a


realização do projeto devem ser instalados. Os softwares necessários são:

• Matlab 7.0;
• Simulink;
• Microsoft Visual C++ 6.0 Standard Edition;
79

• Real Time Windows Target;

As versões descritas acima foram as utilizadas na realização deste trabalho, é importante


ressaltar que a modificação na versão de um dos softwares acarreta uma modificação nos
demais. As versões descritas acima têm perfeita compatibilidade, então elas são
recomendadas.

A ordem de instalação é a apresentada anteriormente, o Matlab 7.0 e o Simulink são


instalados juntamente, quando o usuário instalar o Matlab o Simulink é instalado
automaticamente. Depois disso o usuário deve instalar o Microsoft Visual C++ 6.0 Standard
Edition. Depois de instalado os componentes acima o usuário deve abrir o Matlab para poder
realizar a instalação do Real Time Windows Target (RTW). Uma vez que o Matlab está aberto
o usuário deve escrever na linha de comando: “rtw –install”. Com esse comando o RTW será
instalado automaticamente. Pronto, agora todos os componentes estão instalados, então o
usuário deve configurar o Matlab e os drivers da placa para serem reconhecidos.

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).

Figura A.5 - Alterando o compilador do Matlab.

Depois de modificado o compilador e instalados os componentes, a configuração dos drivers


da placa deve ser feita para que eles sejam reconhecidos pelo Matlab. O usuário precisa abrir
o diretório “Matlab\RTW\WindowsTarget\WindowsTarget 2.5” que está no CD que contem
80

os exemplos e copiar os seguintes arquivos: c6xbd.h, c6xen.h, c6xpwm.h, c6xen.dll,


c6xpwm.dll, c6xen.tlc e c6xpwm.tlc. Depois de copiados eles devem ser colados no diretório
c:\MATLAB\rtw\c\mechkit. O diretório final (mechkit) não existirá, o usuário deverá
adicioná-lo. Depois de realizada essa operação o Matlab já reconhecerá os drivers, mas o
usuário necessita copiar o arquivo “c6xlib.mdl” para a pasta onde está o projeto do sistema
criado no Simulink. O arquivo está no diretório
“Matlab\RTW\WindowsTarget\WindowsTarget 2.5” e a pasta onde o projeto está
armazenado o usuário que decide, ela pode ser copiada para qualquer pasta que o usuário
deseje. O importante é que este arquivo esteja junto com o arquivo do sistema criado no
Simulink.
81

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".

Continuando a montagem do pêndulo de Furuta existe uma conexão de alumínio com um


encoder posicionado na extremidade (Figura B.3).

Figura B.3 - Conexão de alumínio com encoder na extremidade.

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

Figura B.4 - Haste de balanço. Figura B.5 - Pêndulo de Furuta finalizado.

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.

Figura B.8 - Fixação frontal dos fios.


83

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.

Figura C.1 - Menu de configuração do Simulink.

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).

Figura C.2 - Configuração do Device Type.


84

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.

Figura C.3 - Configuração do Real-Time Workshop.

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).

Figura C.4 - Re-build do sistema.

Pronto, agora o modelo está configurado e pronto para ser executado.