UNIVERSIDADE FEDERAL DO CEARÁ

CENTRO DE TECNOLOGIA
TRABALHO FINAL DE CURSO EM ENGENHARIA ELÉTRICA

PROJETO, IMPLEMENTAÇÃO E ENSAIOS DE UM

CONTROLADOR PID UTILIZANDO FPGA

MATHEUS SALES BEZERRA

FORTALEZA
JUNHO 2010
 ii

MATHEUS SALES BEZERRA

PROJETO, IMPLEMENTAÇÃO E ENSAIOS DE UM

CONTROLADOR PID UTILIZANDO FPGA

Monografia submetida à Universidade Federal

do Ceará como parte dos requisitos para
obtenção do grau de Graduação em
Engenharia Elétrica.

Orientador: Dr. Arthur Plínio de Souza Braga.

Fortaleza
Junho 2010
 iv

DEDICATÓRIA

Dedico este trabalho aos meus pais que muito

contribuíram de forma direta ou indiretamente
para a elaboração e execução desta monografia.
À todos de minha família, e minha namorada.
Aos professores, colegas e funcionários da UFC.
À Deus por ter me concedido o dom da vida e do
entendimento.
 v

AGRADECIMENTOS

À minha mãe que muito me ajudou e apoiou assim como os familiares.

Aos meus amigos que construí durante essa árdua batalha de aprendizado e crescimento.

Ao Meu orientador, Prof. Dr. Arthur Plínio de Souza Braga, pelo seu incentivo na realização
deste trabalho e pela paciência, compreensão e atenciosidade. A você minha admiração e
agradecimentos.

Aos professores Otacílio da Mota Almeida, José Carlos, Ranoyca Nayana Alencar Leão e
Silva, e Demercil de Souza Oliveira Júnior, e ao mestrando Davi Nunes Oliveira que contribuíram
direta ou indiretamente para que eu conseguisse concluir este trabalho.
 vi
Bezerra, M.S. “PROJETO, IMPLEMENTAÇÃO E ENSAIOS DE UM CONTROLADOR PID
UTILIZANDO FPGA”. Universidade Federal do Ceará – UFC, 2010.

RESUMO

Com o crescimento da indústria de automação, e com as novas tecnologias emergentes, a

competitividade do mercado traz a necessidade de novas soluções que facilitem rápida adaptação às
novas demandas. Um controlador digital é uma ferramenta essencial em praticamente todas as
plantas industriais, sendo implementado em diferentes plataformas de hardware como
microcontroladores e CLPs. Uma alternativa atraente para a implementação de contralores digitais
que vêm ganhando interesse cada vez maior são os FPGAs (Field Programmable Gate Array).
Estes dispositivos lógicos programáveis, que competem diretamente com os ASICs (Application
Specific Integrated Circuit), possuem grande versatilidade de implementação de sistemas digitais
complexos, e um baixo consumo de energia. Este trabalho realiza a implementação de um
controlador PID (Proporcional-Integral-Derivativo) digital em um FPGA da família Cyclone II no
controle de uma planta não-linear de teste: um pêndulo amortecido. Esta planta é composta por um
motor fixo em uma haste girante, e o controlador deve manter esta haste estável em um determinado
ângulo pré-estabelecido com relação ao solo – o controlador projetado e implementado atua sobre o
motor através de um acionamento por PWM (Pulse Width Modulation). Como os dados de um
FPGA são digitais, utiliza-se um conversor AD para traduzir os dados analógicos das medidas do
ângulo da haste para o formato digital. Detalhes sobre o projeto, a planta, o interfaceamento com o
FPGA e os testes realizados são apresentados ao longo dos capítulos desta monografia. A parte
teórica utilizada no projeto, que envolve as áreas de Sistemas Lineares, Controle, e Eletrônica
Digital, é descrita nos capítulos iniciais. Os resultados obtidos são apresentados através dos
ambientes de desenvolvimento MATLAB® e Quartus II®.
 vii
Bezerra, M.S. “DESIGN, IMPLEMENTATION AND TESTING OF A PID CONTROLLER
USING FPGA. " Federal University of Ceará – UFC, 2010.

ABSTRACT

With the growth of automation industry, and with new emerging technologies, competitive
market brings the need for new solutions that facilitate rapid adaptation to new demands. A digital
controller is an essential tool in almost all industrial plants, being implemented on different
hardware platforms such as microcontrollers and PLCs. An attractive alternative for implementing
digital controller that have been gaining increasing interest are the FPGAs (Field Programmable
Gate Array). These programmable logic devices that compete directly with ASICs (Application
Specific Integrated Circuit), have great versatility in implementation of complex digital systems,
and low power consumption. This paper realizes the implementation of a PID (Proportional-
Integral-Derivative) digital in a Cyclone II FPGA family to control a nonlinear plant test: a damped
pendulum. This plant consists of a motor fixed on a rotating rod, and the controller must maintain
this stable stem at an angle predetermined with respect to the ground - the controller designed and
implemented acts on the drive motor through a PWM (Pulse Width Modulation). As data of an
FPGA are digital, it uses an AD converter to translate analog data measures the angle of the rod to
the digital format. Details about the project, the plant, interfacing with the FPGA and testing are
presented throughout the chapters in this monograph. The theoretical part used in the project, which
involves the areas of Linear Systems, Control and Digital Electronics, is described in the opening
chapters. The results are presented through the development environments and MATLAB ®
Quartus ® II.
 viii
SUMÁRIO

LISTA DE TABELAS............................................................................................................ ix
LISTA DE FIGURAS............................................................................................................. x

CAPÍTULO 1.
1.1 ORGANIZAÇÃO DO TRABALHO................................................................................. 2

CAPÍTULO 2.
2. O CONTROLADOR PID ...................................................................................................... 3
2.1 INTRODUÇÃO.................................................................................................................... 3
2.2 SINTONIA DO CONTROLADOR...................................................................................... 5
2.3 PID DISCRETO.................................................................................................................... 8
2.4 IMPLEMENTAÇÕES EM HARDWARE DO CONTROLADOR PID........................... 10
2.5 COMENTÁRIOS FINAIS.................................................................................................. 10

CAPÍTULO 3.
3. DISPOSITIVOS LÓGICOS PROGRAMÁVEIS................................................................. 16
3.1 INTRODUÇÃO.................................................................................................................. 16
3.2 PROGRAMAÇÃO DOS DISPOSITIVOS......................................................................... 22
3.3 PROTOTIPAGEM ............................................................................................................. 22
3.4 FAMÍLIA CICLONE II & FPGA....................................................................................... 24
3.5 CONCLUSÃO ................................................................................................................... 30

CAPÍTULO 4.
4.EXPERIMENTOS E RESULTADOS................................................................................... 31
4.1 DESCRIÇÃO DA PLANTA...............................................................................................31
4.2 ENSAIOS PARA IDENTIFICAÇÃO................................................................................. 35
4.3 ENSAIOS PID.....................................................................................................................36
4.4 ENSAIOS FPGA.................................................................................................................43
4.5 COMENTÁRIOS FINAIS.................................................................................................. 47

CAPÍTULO 5.
5.1 CONCLUSÕES...................................................................................................................48

REFERÊNCIAS BIBLIOGRÁFICAS.................................................................................. 50

APÊNDICE A.......................................................................................................................... 52
 ix

LISTA DE TABELAS

Tabela 2.1 - Tabela de sintonia de Ziegler-Nichols 1º método..................................................... 6

Tabela 2.2 - Tabela de sintonia de Ziegler-Nichols 2º método..................................................... 8
Tabela 2.3 - Recursos utilizados para gerar protótipos de hardware........................................... 11
Tabela 2.4 - Comparação das implemetações dos sistemas base-DA e base-IP.......................... 14
Tabela 3.1 - Características do dispositivo................................................................................... 26
Tabela 3.2 - Configuração e Teste................................................................................................ 29
 x

LISTA DE FIGURAS

Figura 2.1 - Planta do controle PID............................................................................................ 5

Figura 2.2 - Curva de resposta em forma de “S”........................................................................ 6
Figura 2.3 - Oscilação sustentada com período Pcr.....................................................................7
Figura 2.4 - Sistema de malha fechada com um controlador proporcional.................................8
Figura 2.5 - UML Diagrama de casses UML de um sistema de controle base-PID geral........ 13
Figura 2.6 - Resposta em malha fechada de um sistema de controle em base-DA...................14
Figura 3.1 - Árvore das famílias de dispositivos digitais.................................................. ........18
Figura 3.2 - Estrutura Interna de uma CPLD...................................................................... ......18
Figura 3.3 - Estrutura Interna de um FPGA..................................................................... .........19
Figura 3.4 - Projeto de Design Lógico Programável................................................................ 20
Figura 3.5 – Apresentação do FPGA...................................................................................... 24
Figura 3.6 - Diagrama Cyclone II EP2C20............................................................................. 25
Figura 3.7 - Modo Normal....................................................................................................... 26
Figura 3.8 - Modo Aritmético.................................................................................................. 27
Figura 3.9 - EP2C15 & Maior PLL, CLK[], DPCLK[] & Locais dos blocos de controle...... 28
Figura 3.10 - Bloco de controle de Clock..................................................................................28
Figura 3.11 - Estrutura Cyclone II IOE................................................................................... 29
Figura 4.1 - Planta real do projeto........................................................................................... 31
Figura 4.2 - Circuito de acionamento e conversão.................................................................. 32
Figura 4.3 - PWM exibido no Osciloscópio............................................................................ 32
Figura 4.4 - Fontes de alimentação DC................................................................................... 33
Figura 4.5 - Projeto da placa de circuito impresso................................................................. 33
Figura 4.6 - Placa da National Instruments para coletar dados................................................ 34
Figura 4.7 - Lógica de blocos Simulink................................................................................... 34
Figura 4.8 - resposta ao degrau da planta real.......................................................................... 36
Figura 4.9 - Diagrama 2º método Ziegler-Nichols................................................................... 37
Figura 4.10 - Código para testar de estabilidade........................................................................38
Figura 4.11 - Resposta ao degrau da função de teste............................................................... 39
Figura 4.12 - Gráfico PO versus ts para FT de segundo grau.................................................. 40
Figura 4.13 - Código para comparar e obter parâmetros PID................................................... 41
Figura 4.14 - Resposta ao degrau para valores de Csi............................................................. 42
Figura 4.15 - Resposta ao degrau da planta............................................................................. 42
Figura 4.16 - Saída discreta simulada no MATLAB............................................................... 43
Figura 4.17 - Diagrama de blocos QUARTUSII..................................................................... 44
Figura 4.18 - Resposta ao degrau do controlador real.............................................................. 45
Figura 4.19 - Controle com variação na referência.................................................................. 46
Figura 4.20 - Controle com perturbação da haste.................................................................... 46
Figura A.1 - PID discreto......................................................................................................... 52
Figura A.2 - Ilustração do software QUARTUS® II............................................................... 53
 xi

LISTA DE SÍMBOLOS

AD Analógico-digital
ADC A/D orD/A converters (Conversor Analógico/Digital ou
Digital/Analógico)
ASIC Application Specific Integrated Circuit (Circuito integrado de
aplicação específica)
BASE-DA Base aritmética distribuída
CLP Controlador lógico programável
CPLD ComplexProgrammable Logic Devices (Dispositivo lógico
programável complexo)
DLP Dispositivo lógico programável
EDIF Electronic Design Interchange Format (Formato Intermediário
para Intercâmbio de Projeto)
EEPROM Electrically-Erasable Programmable Read-Only Memory
EPLD Electrically Programmable Logic Device (Dispositivo lógico
programável eletricamente)
EPROM Electrically Programmable Read-Only Memory
FPAA FieldProgrammable Analog Array (Arranjo analógico
programável por campo)
FPGA FieldProgrammable Gate Array (Arranjo de Portas
Programável em Campo)
FSM Finite State Machine (máquinas de estados finitos)
FT Função de Transferência
GE General Electric
I/O Input/Output (Entrada/Saída)
JTAG Joint Test Action Group
LABs Logic Array Blocks (Blocos de arranjos lógicos)
LUT Lookup-Table (É um tipo de bloco lógico)
MIMO Multiple inputs and Multiple outputs (Múltiplas entradas e
múltiplas saídas)
MISO Multiple inputs and single output (Múltiplas entradas e saída
única)
PALA Programmable Associative Logic Array (Lógico Programável
Array Associativo)
PID Proporcional, integral e derivativo
PLA Programmable Logic Array (Array lógico programável)
PROM Programmable read-only memory (Memória programável
 xii
apenas de leitura)
PWM Pulse Width Modulation (Modulação por largura de pulso)
RAM Random Access Memory (Memória de acesso randômico)
ROM Read only memory (Memória somente de leitura)
SISO Single input and single output (Única entrada e única saída)
SPLD Simple Programmable Logic Device (Dispositivo lógico
programável simples)
SRAM Static Random Access Memory (Memória estática de acesso
aleatório)
UFC Universidade Federal do Ceará
UML Unified Modeling Language (Linguagem de modelagem
unificada)
VGA Video Graphics Array (Arranjo gráfico de vídeo)
 xiii

LISTA DE ABREVIATURAS E SIGLAS

Símbolo Nome Unidade Abreviatura

Kp Ganho proporcional admensional
Ki Ganho integrativo admensional
Kd Ganho derivativo admensional
Td Tempo derivativo Minutos min
Ti Tempo integral Minutos min
T Constante de tempo Segundos seg
G(s) Função de transferência estimada admensional
Gc Função do controlador admensional
e Erro admensional
ek-1 Erro instante anterior admensional
ek-2 Erro instante antes do anterior admensional
u Saída do controlador admensional
uk-1 Saída no instante anterior admensional
r, uc Entrada admensional
y(t) Saída admensional
P(k) Termo proporcional discreto admensional
D(k) Termo derivativo discreto admensional
I(k) Termo integrativo discreto admensional
CAPÍTULO 1

INTRODUÇÃO

Com um crescimento acelerado das técnicas de Controle Digital [JACQUOT,

1994] [ZIEGLER e NICHOLS, 1942], e das facilidades de implementação de Sistemas
Digitais Complexos em Dispositivos Lógicos Programáveis (DLPs) [TOCCI, 2003],
surgiram diversos controladores que combinam estes dois temas em diversas aplicações:
medições digitais (osciloscópio), máquinas de produção, indústria automobilística, etc.
Em vários artigos científicos atuais comenta-se a eficiência do uso de uma categoria de
DLP de grande versatilidade: os FPGAs (Field Programmable Gate Arrays) [TOCCI,
2003] [D’AMORE, 2005] [ALTERA, 2010a]. Estes dispositivos possuem uma
arquitetura interna que permite sua fácil utilização em variados propósitos. Dadas estas
facilidades, escolheu-se o FPGA como plataforma de hardware do presente trabalho.
Neste projeto, o controle de uma planta não-linear é realizado através de um
controlador PID digital implementado em FPGA. O controlador PID digital é bastante
conhecido e também possui vários trabalhos com o mesmo [RICHARD e ROBERT,
2001; WITTENMARK e ÅSTRÖM, 2003]. Para a proposta deste trabalho de um PID
implementado em FPGA, foram inicialmente estudados dois artigos tomados como
estudos de caso (não implementados) para a sintonia do controlador [CHAN, 2007;
GOMES, 2009]. O primeiro artigo estudado [CHAN, 2007] trata da implementação ao
realizar a comparação de três tipos de métodos para implementação do controle, todos
utilizando uma sintonia através do método de Ziegler/Nichols [ZIEGLER e NICHOLS,
1942] em complementação com o método do Relay [CHAN, 2007]. O segundo artigo
estudado foi [GOMES, 2009] comenta-se brevemente do que trata este artigo que
também não foi implementado, pelo mesmo motivo do artigo primeiro. Então a opção
que funcionou com a planta foi o método de [JACQUOT, 1994] retirado do seu livro.
Ele aborda a discretização dos valores para implementação digital.
 2

A sintonia trata das variáveis que deveram ser encontradas para o funcionamento
correto do controlador. Dependendo do overshooting ou do tempo de acomodação do
processo, poderão ser escolhidos variáveis diferentes para o controlador [ZIEGLER e
NICHOLS, 1942]. Neste trabalho, a sintonia do controlador foi realizada
algebricamente pela alocação de pólos [OGATA, 2003]. Os parâmetros calculados para
o controlador foram validados em simulação no software MATLAB, e em
implementação no FPGA.
A planta do projeto trata-se de um pêndulo amortecido composto por uma hélice
acoplada a um motor na extremidade de uma haste girante acoplada à uma base fixa
através de rolamentos (Seção 4.1). Isso faz com que a haste possa girar livremente com
a menor quantidade de atrito possível. O circuito de conversão AD é feito para coletar a
leitura do potenciômetro, que indica a posição da haste girante, e é enviada para o
FPGA. O motor é acionado através do controle da tensão por PWM. Esses sinais de
acionamento são gerados pelo controlador implementado no FPGA.
O motor DC escolhido funciona com corrente máxima de 1A e tensão máxima
de 12 V. Um contrapeso na ponta da haste oposta ao motor é utilizado para balancear o
peso do mesmo.
Este projeto aborda diversos assuntos estudados durante o curso de Engenharia
Elétrica, possibilitando um aprendizado bastante significativo nas áreas de Controle,
Sistemas Lineares, e Eletrônica Analógica e Digital. A Seção seguinte descreve como
estes assuntos estão distribuidos nos próximos capítulos, assim como os capítulos
relativos aos resultados e conclusões finais

1.1 – ORGANIZAÇÃO DO TRABALHO

No Capítulo 2 apresenta-se o controlador PID: o princípio de funcionamento,

métodos de sintonia e possíveis implementações digitais descritas em artigos e livros.
No Capítulo 3 comenta-se os Dispositivos Lógicos Programáveis suas
variedades encontradas no mercado, o dispositivo FPGA e sua família Cyclone II, com
suas características principais.
No Capítulo 4 mostra-se a planta considerada para testes, a interface para os
ensaios, os resultados obtidos em simulações e no sistema real.
No Capítulo 5 são apresentadas as conclusões e são propostos trabalhos futuros
nessa mesma linha de trabalho.
CAPÍTULO 2

O CONTROLADOR PID

Uma estratégia de controle amplamente utilizada em processos industriais é chamada de

controlador de três termos ou controlador PID (Proporcional-Integral-Derivativo)
[OGATA, 2003]. Neste capítulo será apresentado este controlador: a Seção 2.1
apresentará as características básicas do controlador PID, métodos conhecidos na
literatura para o ajuste dos parâmetros deste controlador são tratados na Seção 2.2, a
descrição do PID discreto é feita na Seção 2.3, exemplos de trabalhos que implementam
em FPGA o controlador PID discretizado são tratados na Seção 2.4; o Capítulo é
encerrado com os comentários finais da Seção 2.5.

2.1 INTRODUÇÃO

O controlador PID tem uma função de transferência no domínio de Laplace

conforme a Equação 2.1 [DORF e BISHOP, 1998]. A ação de controle deste
controlador é gerado a partir da combinação das ações proporcional, integral e
derivativa. O objetivo deste controlador é aproveitar as características particulares de
cada uma destas ações a fim de se obter uma melhora significativa do comportamento
transitório e em regime permanente do sistema controlado. Desta forma, têm-se três
parâmetros de sintonia no controlador: o ganho proporcional Kp, o termo integral Ki e o
termo derivativo KD.
Ki
Gc(s) = Kp + + KDs (2.1)
s

O controlador oferece um termo proporcional que reduz o tempo de

acomodação, o termo de integração elimina o erro de regime e o termo derivativo
 4

aumenta a estabilidade do sistema. A equação para a saída no domínio do tempo é

mostrado na equação 2.2 [DORF e BISHOP 1998].

de(t)
u(t) = Kpe(t) + Ki ∫ e(t)dt + KD (2.2)
dt

Sendo e(t) o erro que é a entrada do controlador, u(t) é a saída do controlador e

Kp, Ki, Kd são os ganhos do controlador. A função de transferência do termo derivativo
é mostrado na equação 2.3 [DORF e BISHOP 1998].

KDs
Gd (s) = (2.3)
τds + 1

Como a constante τd é muito menor que as constantes de tempo do processo,

então se pode desprezá-la. Considerando KD = 0 na equação 2.1, tem-se então o
controlador proporcional e integral (PI) da equação 2.4 [DORF e BISHOP 1998].
Quando Ki = 0 na equação 2.1 resulta na equação 2.5 [DORF e BISHOP 1998] que é o
chamado controlador proporcional derivativo (PD).

Ki
Gc (s) = Kp + (2.4)
s

Gc(s) = Kp + KDs (2.5)

Muitos processos industriais são controlados usando controladores do tipo PID

[OGATA, 2003]. A popularidade dos controladores PID pode ser atribuída parcialmente
ao seu bom desempenho em uma ampla faixa de condições de operação e parcialmente
à sua simplicidade funcional. Para implementar este controlador, há necessidade de se
determinar para um dado processo: o ganho proporcional (Kp), o ganho integral (Ki), e o
ganho derivativo (KD).
Pode haver casos em que a resposta a um distúrbio e a resposta à entrada de
referência tornem-se conflitantes, o que não pode ser satisfeito com um grau de
liberdade, mas se aumentado os graus de liberdade é possível solucionar este problema.
Com a utilização de controladores PID usando dois graus de liberdade, projeta-se
 5

sistemas de controle que satisfazem dois requisitos independentes ou, algumas vezes,
conflitantes como a característica de resposta à entrada de distúrbio e aquela de resposta
à entrada de referência.

2.2 SINTONIA DO CONTROLADOR

O processo de selecionar parâmetros do controlador que garantam uma dada

especificação de desempenho é conhecido como sintonia do controlador. Um método de
sintonia muito conhecido, e bastante utilizado pela sua facilidade de implementação foi
sugerido por Ziegler e Nichols, em 1942 [ZIEGLER e NICHOLS, 1942], e se baseia na
resposta ao degrau ou no valor de Kp que resulta em uma estabilidade marginal quando
somente uma ação proporcional é utilizada. Para melhor compreensão, tome-se como
exemplo de uma planta de controle (malha fechada com retroação negativa) na Figura
2.1: onde G(s) é a planta, Gc(s) é o controlador PID, R(s) é a entrada e Y(s) a saída.

Figura 2.1 – Planta do controle PID.

Utilizando o primeiro método de Ziegler e Nichols [ZIEGLER e NICHOLS,

1942], analisa-se a curva de resposta ao degrau de entrada numa planta. Este método é
funcional para plantas de primeira ordem, ou seja, se a planta não possui integradores
nem pólos complexos conjugados dominantes. Nestes casos, a curva de resposta ao
degrau unitário pode ter o aspecto de um “S”, como na Figura 2.2. Esse método se
aplica somente quando esta curva de resposta ao degrau tiver esse aspecto de “S”. Essa
curva de resposta pode ser gerada experimentalmente ou a partir de uma simulação
dinâmica da planta. A curva “S” pode ser caracterizada por duas constantes, o atraso L e
a constante de tempo T. O atraso e a constante de tempo são determinados desenhando-
se uma linha tangente com o eixo dos tempos e a linha r(t) = K, como mostra a Figura
2.2.
 6

Figura 2.2 – Curva de resposta em forma de “S”.

A função de transferência Y(s)/R(s) pode ser aproximada por um sistema de

primeira ordem com um atraso de transporte, como na equação 2.6 [DORF e BISHOP
1998].

Y(s) Ke− Ls
= (2.6)
R(s) Ts + 1

Tendo a curva de saída Figura 2.2 e os parâmetros L e T, então de acordo com a tabela
2.1, podem ser sugeridos os valores de Kp, Ti, TD.

Tabela 2.1 - Tabela de sintonia de Ziegler-Nichols 1º método [OGATA, 2003].

Tipo de controlador Kp Ti TD
P T/L ∞ 0
PI 0,9 T/L L/0,3 0
PID 1,2 T/L 2L 0,5 L

Neste método, a função de transferência do controlador torna-se [OGATA, 2003]:

 7

2
 1
 s+ 
 1  L
Gc (s) = Kp  1 + + Td.s  = 0, 6T  (2.7)
 Ti.s  s

A principal vantagem deste método (Curva de Reação “S”) deve-se ao fato de,
uma vez determinada a curva de reação do método, os parâmetros podem ser ajustados
imediatamente. Esta vantagem é particularmente útil em processos muito lentos, em que
pode passar muito tempo até que o sistema atinja a estabilidade crítica que é quando o
sistema fica marginalmente estável através de um ganho crítico(2º método de Ziegler e
Nichols).
A sua principal desvantagem decorre de grande parte dos sistemas serem mais
complexos do que um simples sistema de primeira ordem com atraso, o que significa
que é ainda necessário um último ajuste no ganho antes de se poder considerar que a
resposta do sistema é “aceitável”.
Existem tabelas desenvolvidas a partir deste método, apresentados por Cohen e
Coon [COHEN e COON, 1953] e por Chien, Hrones e Reswich [CHIEN e HRONES e
RESWICH, 1952], entre outros, que representam alguma melhoria deste método.
No segundo método de Ziegler e Nichols, define-se Ti=∞ e Td =0. Utilizando
somente a ação do controle proporcional (Figura 2.4), aumenta-se Kp de 0 ao valor
crítico Kcr no qual a saída exibe uma oscilação sustentada pela primeira vez. Caso a
saída não exiba nenhuma oscilação sustentada para qualquer valor que Kp, pode-se
assumir que este método não se aplica. Portanto, o ganho crítico Kcr, e o correspondente
período Pcr são determinados experimentalmente como na Figura 2.3.

Figura 2.3 – Oscilação sustentada com período Pcr.

 8

Figura 2.4 – Sistema de malha fechada com um controlador proporcional.

O controlador PID sintonizado pelo segundo método fornece a função de

controle da Equação 2.8 [DORF e BISHOP, 1998].

2
 4 
s + 
Pcr 
Gc (s) = 0, 075Kcr.Pcr  (2.8)
s

Utiliza-se a Tabela 2.2 para obtenção das constantes.

Tabela 2.2 – Tabela de sintonia de Ziegler-Nichols 2º método.

Tipo de controlador Kp Ti Td
P 0,5 Kcr ∞ 0
PI 0,45 Kcr 1/1,2 Pcr 0
PID 0,6 Kcr 0,5 Pcr 0,125 Pcr

2.3 PID DISCRETO

Segundo [WITTENMARK e ÅSTRÖM, 2003] tendo o diagrama da Figura 2.1 o

controlador PID pode ser expresso de maneira contínua ou analógica pela expressão
exposta na Equação 2.9.

 1 sTd 
Rc(s) = K  bR(s) − Y(s) + ( R(s) − Y(s) ) − Y(s)  (2.9)
 sTi 1 + sTd / N 

Fazendo-se uso desta equação, as variáveis de controle agora são K, b, Ti, Td e N,

onde N é um limitador do ganho derivativo; b é igual a w0/2 ; w0 é a velocidade do
sistema em malha-fechada; e Rc(s), R(s), Y(s) são respectivamente as transformadas de
 9

Laplace de rc, r e y. Para implementar o algoritimo no FPGA necessita-se discretizar a

fórmula. Discretizando os termos proporcional, derivativo e integrativo como na
equação 2.10, podemos desenvolver para a equação 2.11, onde k é o k-ésimo instante de
amostragem.

rc(k) = P(k) + I(k) + D(k) (2.10)

P(k) = K ( br(k) − y(k) )

K
I(k) = I(k − 1) + ( r(k − 1) − y(k − 1) ) (2.11)
Ti
Td KTdN
D(k) = D(k − 1) − ( y(k) − y(k − 1) )
Td + NT Td + NT

Na equação 2.11 temos os termos y(k) que é o sinal de feedback no instante k;

y(k-1) é o sinal de feedback no instante anterior k-1;r(k) é o sinal de comando no
presente instante;I(k-1) é o termo integral no instante anterior;D(k-1) é o termo
derivativo no instante anterior; K, b(wn/2), Ti, Td, N(limitador do ganho) são parâmetros
do controlador; e T é o período de amostragem.
Uma metodologia bastante aplicada, devido sua facilidade na implementação é
definida por [JACQUOT, 1994] em seu livro. Uma técnica para controlador em tempo
discreto, onde a saída do controlador é dada por uk mostrado na equação 2.12, onde uk-1
é a entrada no instante anterior, Ts é o tempo de amostragem, ek é o erro no instante, ek-1
é o erro no instante anterior, ek-2 erro no instante antes do anterior, Kp, Ki, Kd são as
constantes do controlador.
 Ki.Ts Kd 
uk = uk − 1 +  Kp + +  ek +
 2 Ts 
(2.12)
 Ki.Ts 2Kd  Kd
+ − Kp −  ek − 1 + ek − 2
 2 Ts  Ts

Sendo α o fator que multiplica o ek ,β o fator que multiplica ek-1, e γ o fator que
multiplica ek-2. Assim tem-se a saída do controlador que irá controlar a planta e o erro
serve de parâmetro para o controle atuar.
 10

2.4 IMPLEMENTAÇÕES EM HARDWARE DO CONTROLADOR PID

Nesta Seção será apresentado dois estudos de caso por artigos que descrevem sobre
implementações de controladores em FPGA’s, porém utilizando metodologias
diferentes de discretização, sintonia e implementação.

2.4.1 CASO DE ESTUDO I – GOMES, 2009

Segundo [GOMES, 2009], o projeto de um controlador utilizando o FPGA
(Field Progammable Gate Arrays) prevê principalmente portabilidade e praticidade,
com consumo de energia, alta velocidade de operação e larga capacidade de
armazenamento de dados.
Esse controle digital é mais vantajoso que o analógico em relação à obtenção do
resultado, pois tem uma melhor imunidade devido ao sinal discreto, também é
facilmente integrado com sistemas digitais e torna possível implementações de métodos
mais sofisticados.
Com a auto-sintonia espera-se identificar a saída do sistema e encontrar os
parâmetros do controlador automaticamente. O método de Ziegler-Nichols é prático e
direto enquanto o método do Relay-feedback é utilizado para obter os dados que serão
usados para a sintonia Ziegler-Nicols.
Este projeto [GOMES, 2009] pode ser implementado em qualquer sistema que
necessitem controlar usando um controlador PID auto-sintonizável.
Para a sintonia utiliza-se o método de Ziegler-Nicols através de duas técnicas: na
primeira o ganho proporcional é incrementado até que a saída do sistema em malha-
fechada tenha um período constante. Desta forma, o ultimo ganho Ku e o período de
oscilação Pu é determinado e qualquer ganho maior que Ku torna o sistema instável. A
segunda técnica consiste em aplicar um teste em malha aberta através de um distúrbio
de um degrau e pela resposta do sistema, o atraso, ou tempo de inatividade, e a taxa de
variação são calculadas e utilizadas para a frente do ajuste do controlador.
O ganho Ku é estimado a partir da saída do relé “h” e da saída da planta em
malha aberta “a”, como visto na equação (2.13).

Ku = 4.h / a.π (2.13)

Agora, com os parâmetros Ku e Pu, emprega-se o método de Ziegler-Nicols para

a sintonia, mas é preciso criar uma equação do PID para inserir na lógica do processador
 11

NIOS II. A partir da estrutura digital representada pela Equação 2.14a onde q0, q1 e q2
são constantes dependentes de Ts (período de amostragem) Kc, Ti e Td (Equação
2.14b).
u(t) = u(t-1) + q0.e(t)+q1.e(t-1)+q2.e(t-2) (2.14a)

 Ts Td 
q0 = Kc  1 + + 
 2.Ti Ts 
 Ts 2Td 
q1 = −Kc 1 − +  (2.14b)
 2.Ti Ts 
 Td 
q2 = Kc  
 Ts 
Em vez de usar o erro para o termo derivativo, é usada a saída do sistema para
evitar excessiva ação de controle, então substituindo os erros proporcional, derivativo e
integrativo [GOMES, 2009] tem-se a Equação 2.15.

u(t)=u(t-1)+Kc.{-y(t)+y(t-1)+Ts/Ti.e(t-1)+Td/Ts.[-y(t)+2y(t-1)-y(t-2)]} (2.15)

O processador NIOS II favorece a utilização em sistemas embarcados e

trabalhos no setor de automação industrial. Os recursos usados do módulo são
mostrados na tabela (2.3).

Tabela 2.3 - Recursos utilizados para gerar protótipos de hardware.

Total de elementos Registrador Lógico Bit de Memória Total de pinos
lógicos Dedicado
9% 5% 6% 12%

A programação do controlador foi feita em linguagem C/C++, usando o software

NIOS II IDE. Sendo criada uma library com funções para a criação do controlador PID.
A entrada é de 8 bits, mas pode ser mudada para 16bits se necessário. Esse sinal é
convertido para a base decimal. O degrau na entrada em primeiro momento é
trabalhando com o método do Relay-feedback em um sistema malha fechada, depois é
comparado o erro e mudada a amplitude da entrada para alto ou baixo dependendo do
Setpoint. Isto é feito para achar o valor do período Pu. O período encontrado é utilizado
no método de Ziegler-Nicols para fazer a sintonia. O sinal da entrada de 8bits vem do
conversor AD e o processador calcula os valores dos parâmetros q0, q1 e q2 , que são
 12

constantes do controlador, através de linhas de código onde recebem o valor do

resultado das equações 2.14b.
O sistema foi modelado no Matlab/Simulink a planta (2.16) é retirada em
[NASCIMENTO e YONEYAMA, 2000] cuja resposta é conhecida de modo que os
resultados podem ser comparados com os valores esperados.

10.e( −0.5.s)
G(s) = (2.16)
s+3

A simulação realizada tem como objetivo calcular os parâmetros q0, q1, q2.
Esses dados serão necessários para calcular uma entrada anterior vista na equação 2.14a.
Desta forma não será necessário discretizar a planta. O método apresentado neste artigo
não precisa de uma equação que corresponde a uma planta, ele ajusta automaticamente
o controlador a partir de uma planta desconhecida.
Os resultados práticos com o módulo embarcado foram aproximadamente iguais
aos teóricos feitos no MATLAB. Este projeto foi testado em uma planta no
MATLAB/SIMULINK e não um sistema real, então se espera que seja testado em um
sistema real e dê certo. Este estudo pode servir para futuras implementações em plantas
reais.

2.4.2 CASO DE ESTUDO II – CHAN, 2007

Em um outro artigo [CHAN, 2007] o autor utiliza um método de controle
utilizando base aritmética distribuída (base-DA) e controle PID (proporcional integral
derivativo) em FPGA. O método da base-DA poupa 80% de hardware e 40% de
consumo de energia comparado ao método da base-multiplicadora. Baseado em um
esquema LUT ( Lookup-Table), o controlador PID facilita e reduz os custos do projeto.
O projeto visa controlar a temperatura de uma lâmpada através de sensores que
captam as leituras e mandam para o controlador e posteriormente manda um sinal para o
bloco PWM que controla o ventilador. Utiliza o processador Xilinx que será falado
mais adiante.
Utilizando uma modelagem UML (Unified Modeling Language) [WOLF, 2001]
para ter uma idéia inicial deste projeto, porém não muito aprofundada, podemos ver a
divisão em módulos na figura 2.5.
 13

Figura 2.5 - UML Diagrama de casses UML de um sistema de controle base-PID geral.

Trabalhando com máquinas de estados finitos (FSM) para controlar a operação

do sistema em resposta à solicitação do usuário tais como: sintonia PID, ligar, esperar,
desligar, que pode ser construído usando a tecnologia FPGA.
O algoritmo de controle segundo [WITTENMARK, B. e ÅSTRÖM , J. 2003] é
discretizado e separado os termos proporcional, integral e derivativo. Depois de
discretizado far-se-á a implementação no FPGA.
A base-multiplicadora não está otimizada, então se faz necessário diminuir o
número de multiplicadores e somadores, usando o método DA, onde as operações de
multiplicação são substituídas por simples deslocamentos ou operações de adição.
A base-DA oferece 20% de iterações do total oferecido pela base multiplicadora.
Outra diferença está na freqüência da base-DA que permite freqüência máxima de 47
MHz com 456 mW de consumo de energia, e a base-multiplicadora 15 MHz com 756
mW de consumo de energia. Percebendo que uma maior frequncia não corresponde a
uma maior velocidade de computação de resposta.
O projeto [CHAN, 2007] é implementado usando-se o FPGA XC2S200E do
Xilinx, Inc. O XC2S200E contém 4704 LCs ( células lógicas),1176 CLBs ( blocos
lógicos configuráveis), 56-Kb de blocos de RAM (Random Access Memory), e 146
blocos de entrada/saída.
Uma análise de utilização de recursos dos métodos DA e multiplicador, mostra
que a base-multiplicador utiliza 97% dos recursos do FPGA, enquanto o DA utiliza
70%. Através da figura 2.6, pode-se perceber que ambos os métodos tem mesma
resposta ao degrau em malha-fechada, contudo o método DA oferece melhor
aproveitamento dos recursos.
 14

Figura 2.6 – Resposta em malha fechada de um sistema de controle em base-DA.

Ambos os modelos também demonstraram regulação similar aos distúrbios

introduzidos no sistema. Comparando com uma base-IP, que consiste de um
processador , memória e controlador, periféricos , e lógica personalizada , adicionados
no FPGA, bem como programação em C/C++. Para comparação com o método base-
DA podemos ver na tabela 2.4 que DA é mais eficiente.

Tabela 2.4 – Comparação das implemetações dos sistemas base-DA e base-IP.

Para a simulação no Matlab/Simulink foram postos cinco módulos com

utilizando blocos Simulink : incluindo controlador PID base-DA, gerador PWM, FSM
(Finite State Machine), interface ADC, e interface de teclado. Esta ferramenta é útil,
pois o usuário pode reconfigurar facilmente os blocos de acordo com o desempenho e
integra-los a vários projetos. Quatro RAMs são usadas como LUTs e armazena o
conteúdo das tabelas. Há dois geradores PWM i.e., ventilador PWM e lâmpada PWM,
enquanto o módulo da lâmpada PWM manipula o entradas de controle com valor
positivo, o módulo do ventilador de PWM manipula as entradas com valor negativo. A
largura de palavra da entrada de referência é reconfigurável em cada módulo gerador de
PWM.
 15

O FSM, interface ADC e módulos de interface de teclado também podem ser

feitos em Matlab/Simulink como blocos Simulink. No entanto, eles são módulos não
reconfiguráveis, uma vez que são específicos para a aplicação. A abordagem modular
para o projeto permite testar componentes individuais antes de implementar e testar o
sistema final sobre a configuração da prática. Os módulos podem assim ser testados
individualmente e depois integrados no sistema de circuito fechado.

2.5 COMENTÁRIOS FINAIS

Foi visto neste capítulo que o controlador PID possui diversas utilidades e seu
controle é bem utilizado nas indústrias para o controle de dispositivos. A sintonia do
controlador PID pode ser feita de diversas maneiras encontradas na literatura, no
entanto, deve-se escolher a que melhor se adéqua a seu projeto. Apresentado também a
discretização do controlador PID para implementação digital. Falou-se dos métodos
Ziegler/Nichols, um dos mais conhecidos na literatura, Base-DA, Base-IP, Relay.
(observados nos artigos [CHAN, 2007] e [GOMES, 2009]). A metodologia que será
adotada no trabalho é a proposta por [JACQUOT, 1994]. A vantagem de se utilizar
FPGA é que ele prevê principalmente a portabilidade e praticidade, com baixo consumo
de energia, alta velocidade de operação e larga capacidade de armazenamento de dados.
No capitulo seguinte será mostrado uma descrição dos FPGAs, mostrando suas
características físicas, e suas vantagens na utilização.
CAPÍTULO 3

DISPOSITIVOS LÓGICOS PROGRAMÁVEIS

Este capítulo trata da explicação sobre o que é um Dispositivo Lógico

Programável (DLP), e suas diversas formas e aplicações. Especificamente, será falado
sobre o FPGA - o tipo de DLP utilizado neste trabalho assim como a descrição da
Família Cyclone II da Altera e suas características para melhor entendimento dos
capítulos seguintes.

3.1 INTRODUÇÃO

Segundo [BARR, 1999], dispositivos lógicos programáveis são dispositivos

utilizados para implementar funções lógicas. Os DLPs são programados via software
fornecido pelos próprios fabricantes desses produtos. Em seu interior existem diversas
portas lógicas, flip-flops e registradores, que oferecem uma forma flexível de arranjo
destes componentes por hardware, ou seja, poderia substituir diversos componentes
como portas AND, OR e NOT por um único chip, usufruindo de todas as vantagens
disso, como um menor consumo, uma menor área utilizada na placa e a eliminação de
interconexões entre componentes. Além disso, o fato de ser reconfigurável permite
alterar o circuito lógico sem mudanças na placa. Dentro dos DLPs existe um conjunto
de macro-células conectadas entre si. Estas macro-células tipicamente compreendem
alguma quantidade de portas lógicas (AND e OR, por exemplo) e flip-flops. A
programação é feita por meio de campos elétricos induzidos no dispositivo.
Em 1970, a Texas Instruments desenvolveu um circuito integrado programável
por máscara baseado na memória associativa da IBM. Este componente, o TMS2000 era
programado alterando-se a camada de metal durante a fabricação [ZELENOVSKY e
MENDONÇA, 2002][MOORE, 1995]. O TMS2000 tinha até 17 entradas e 18 saídas
com 8 flip-flops JK como memória. A Texas criou o termo Programmable Logic Array
(PLA) para este dispositivo. Em 1973, a National Semiconductor introduziu um
 17

dispositivo PLA programável por máscara (DM7575) com 14 entradas e 8 saídas sem
registradores de memória. Foi mais popular que o da Texas, mas o custo de fazer a
máscara de metal limitou seu uso. Este dispositivo foi significativo porque era a base
para o array lógico programável em campo (field programmable logic array) produzido
pela Signetics em 1975, o 82S100. Em 1971, a General Electric (GE) estava
desenvolvendo um dispositivo lógico programável baseado na nova tecnologia PROM .
Este dispositivo experimental era melhor em relação ao ROM da IBM por permitir
lógica multiníveis. A Intel tinha acabado de introduzir a PROM “apagável” por
ultravioleta com gate flutuante e os pesquisadores da GE incorporaram esta tecnologia.
O dispositivo da GE foi o primeiro DLP regravável, precedendo a EPLD da Altera por
mais de uma década. A GE obteve muitas das primeiras patentes em dispositivos
lógicos programáveis. Em 1974 a GE fez um acordo com a Monolithic Memories para
desenvolver um dispositivo lógico programável por máscara incorporando as inovações
da GE. O dispositivo foi chamado 'Programmable Associative Logic Array' ou PALA.
O MMI5760 foi finalizado em 1976 e podia implementar circuitos multiníveis ou
seqüenciais de mais de 100 portas lógicas. O dispositivo era apoiado por ambiente de
projeto da GE onde as equações booleanas eram convertidas em padrões para a máscara
do dispositivo. Este componente nunca chegou a ser comercializado. Estes primeiros
DLPs são hoje classificados como SPLDs (Simple Programmable Logic Devices)
[ZELENOVSKY e MENDONÇA, 2002][MOORE, 1995].
Com a densidade dos chips aumentando a cada dia, os fabricantes passaram
também a produzir componentes com características semelhantes a esses primeiros
DLPs, mas cada vez maiores, não fisicamente e sim logicamente. A estes componentes
foi dado o nome de CPLD. Basicamente, um CPLD é um conjunto de múltiplas DLPs
simples e um barramento configurável de interconexão em um único chip. A densidade
destes componentes permite o desenvolvimento de circuitos muito mais complexos. De
fato, uma única CPLD pode facilmente substituir centenas de componentes da série
74xx (portas lógicas).
De forma didática, os DLPs podem ser divididos segundo suas arquiteturas em:
SPLD (Simple Programmable Logic Device), CPLD (Complex Programmable Logic
Devices), e FPGA (Field Programmable Gate Array), como se pode visualizar na
Figura 3.1 [BARR, M. 1999], onde é mostrado um pequeno esquema das arquiteturas
dos sistemas digitais.
 18

Figura 3.1 - Árvore das famílias de dispositivos digitais.

A Figura 3.2 contém um diagrama de blocos de um CPLD hipotética. Cada um

dos quatro blocos lógicos mostra o equivalente à uma DLP. No entanto, os atuais
CPLDs podem possuir mais (ou menos) blocos lógicos. Note que estes blocos possuem
eles mesmos as suas macro-células e conexões, exatamente como uma DLP.

Figura 3.2 - Estrutura Interna de uma CPLD

Diferente das interconexões configuráveis de um DLP, a matriz de conexões de

uma CPLD pode não ser totalmente conectável. Em outras palavras, algumas das
teoricamente possíveis conexões entre a saída de blocos lógicos e a entrada de outros,
podem não ser suportados no CPLD. O efeito prático disto é que o uso de 100% das
macro-células é difícil de ser atingido.
Devido ao fato dos CPLDs serem mais robustas que os SPLDs, o seu potencial
de uso é muito mais variável. É possível utilizá-las para simples aplicações como
decodificação de endereços, mas também é possível fazer uso das mesmas em lógicas
de controle de alto desempenho ou complexas máquinas de estado finito. Nas aplicações
que exigem lógica de alta performance, tradicionalmente as CPLDs são escolhidas ao
 19

invés dos FPGAs pois, por serem menos flexíveis internamente, possuem um atraso
(delay) interno usualmente menor (medido em nanosegundos).
Os FPGAs podem ser utilizados para a implementação de praticamente qualquer
design de hardware. Um dos usos mais comuns é o seu uso para a prototipação de
componentes que virão no futuro a transformar-se em ASIC (componentes prontos, em
pastilhas de silício). No entanto, não existem problemas em distribuirmos FPGAs em
produtos finais. Esta decisão requer basicamente uma análise de custo, uma vez que o
desenvolvimento de um ASIC é um processo bastante caro e inflexível, mas que gera
componentes de custos bastante reduzidos se produzidos em larga escala. Já os FPGAs
possuem flexibilidade e custo baixo de prototipação, mas preços finais pouco
competitivos se comparados à ASIC com alta escala de produção.
O desenvolvimento de um FPGA é fruto de uma evolução do conceito das
SPLD/CPLD, mas a sua arquitetura é um tanto distinta destes. Como se pode ver na
Figura 3.3, a arquitetura de um FPGA é composta de três estruturas básicas: blocos
lógicos, interconexão e blocos de I/O (Input/Output, Entrada/Saída). Os blocos de I/O
formam uma borda ao redor do dispositivo; cada um destes provê entrada, saída ou
acesso bi-direcional aos pinos de I/O de uso geral disponíveis na parte exterior do
componente. Dentro desta borda de blocos de I/O pode-se ver uma região retangular de
blocos lógicos e conectando-os, estas são as Interconexões Programáveis.

Figura 3.3 - Estrutura Interna de um FPGA

Os blocos lógicos em um FPGA podem ser tão simples e pequenos quanto as
macro-células do DLP (arquitetura conhecida como fine-grained) ou maiores e mais
complexas (coarse-grained). No entanto, um FPGA jamais comportar-se-á, no todo,
como um conjunto de DLPs, como acontece em um CPLD. Lembre-se que um bloco
lógico de CPLD contém múltiplas macro-células. Mas os blocos lógicos de um FPGA
geralmente não contêm mais que algumas portas lógicas e um flip-flop.
Por causa de todos os flip-flops extras a arquitetura do FPGA é muito mais
flexível que a de um CPLD. Isso faz deles melhor para aplicações baseadas em
 20

registradores e aplicações seqüenciais (pipelined). Usualmente FPGA’s são mais densos

e possuem um custo menor que os CPLD’s, então ele é de fato a melhor escolha para
grandes projetos lógicos [ZELENOVSKY e MENDONÇA, 2002][MOORE, 1995].
O processo de criação lógico digital não é muito diferente do desenvolvimento
de sistemas embarcados a que muitos estão acostumados. Uma estrutura de descrição de
hardware é escrita em uma linguagem de alto nível (usualmente VHDL e Verilog), o
código é compilado e copiado para ser executado. Descrever circuito como um
esquemático digital é também possível, mas isso é bem menos popular e mais complexo
que utilizar ferramentas baseadas em linguagens. Uma visão geral do processo de
desenvolvimento de hardware para dispositivos lógico programáveis é mostrado na
figura 3.4 [BARR, 1999].
Note que a principal diferença entre o design de hardware e software é a maneira
que o desenvolvedor precisa pensar para resolver um problema. Desenvolvedores de
software tendem a pensar seqüencialmente, mesmo quando estão desenvolvendo
aplicações multitarefa (multithreaded). As linhas de código sempre são escritas para
serem executadas em uma ordem, pelo menos dentro de uma tarefa (thread) em
particular. Mesmo havendo um sistema operacional usado para criar a aparência de
paralelismo, ainda há um núcleo de execução para o controle disso. Durante o projeto de
hardware os designers precisam pensar, e programar, em paralelo. Todos os sinais são
processados em paralelo, pois trafegam através de um caminho de execução próprio -
cada uma da série de macro-células e interconexões - até o destino do sinal de saída.
Dessa forma, a descrição do hardware cria estruturas que podem ser "executadas" todas
ao mesmo tempo. Note, no entanto, que a transferência entre as macro-células são
usualmente sincronizadas através de um sinal, como o de clock.

Figura 3.4 - Projeto de Design Lógico Programável

 21

Tipicamente, a etapa de início do projeto é seguida ou compartilhada com

períodos de simulação funcional. Este é o momento onde um simulador é utilizado para
a execução do projeto para confirmar se as saídas corretas estão sendo produzidas para
um conjunto de entradas de teste. Embora problemas como tamanho ou sincronismo
possam ainda alterar isto mais tarde, o projetista pode, pelo menos, certificar-se que a
sua lógica de funcionamento está correta antes de ir ao estágio seguinte de
desenvolvimento [BARR, 1999].
A compilação inicia somente depois que uma representação funcional correta do
hardware existe. Esta compilação consiste em duas etapas. Primeiro uma representação
intermediária do projeto do hardware é produzida. Este passo é chamado de síntese e o
resultado é uma representação chamada de netlist. O netlist é um dispositivo
independente, então o seu conteúdo não depende de um FPGA ou CPLD em particular,
ele é armazenado geralmente em um formato padrão, conhecido como EDIF (Electronic
Design Interchange Format) Formato Intermediário para Intercâmbio de Projeto
[BARR, 1999].
A segunda etapa neste processo de tradução é chamada de "place & route
(posicionar e rotear). Este passo envolve traçar as estruturas lógicas descritas na netlist
em macro-células, interconexões e pinos reais de entrada e saída. Este processo é
similar à etapa equivalente no processo de desenvolvimento de um aplaca de circuito
impresso, permitindo otimizações manuais ou automáticas das disposições. O resultado
deste processo é um bitstream. Este nome é usado genericamente, apesar do fato que
cada CPLD ou FPGA (ou família) ter seus próprios, geralmente proprietários, formatos
de bitstream. Para nós basta dizer que o bitstream são os dados binários que deverão ser
carregados no FPGA ou CPLD para fazer com que o chip execute um projeto em
particular [BARR, 1999].
Cada vez mais existem também depuradores disponíveis que permitem a
execução passo a passo da execução em dispositivos lógico programáveis. Obviamente
este tipo de integração específica para componentes requer um conhecimento amplo
sobre o funcionamento dos chips, normalmente fornecidos em parceria da empresa
desenvolvedora da ferramenta com a produtora do componente.
 22

3.2 PROGRAMAÇÃO DOS DISPOSITIVOS

Uma vez que se criou um bitstream para um FPGA ou um CPLD em particular

necessitaria baixá-lo, de algum modo, no dispositivo. O software QUARTUS II
(APÊNDICE Figura A.2), fornecido gratuitamente pela empresa ALTERA foi utilizado
para criar e carregar o bitstream para o FPGA. Este software faz a compilação do
código, em linguagem VHDL, e também carrega o bistream para o dispositivo digital
FPGA através do botão “programmer”. Além disso, o QUARTUS II possui
ferramentas para simulação de resultados através de formas de onda (waveforms), onde
são analisadas as variáveis do projeto como, por exemplo, a saída do PID.
Em dispositivos baseados em tecnologia SRAM, os índices de memória são
temporários e isso traz vantagens e desvantagens. A desvantagem óbvia é que todo o
bitstream precisa ser recarregado após cada restauração do sistema ou do chip, ou seja,
necessita de um chip de memória adicional para armazená-lo, mas isso também
significa que o conteúdo deste pode ser manipulado on-the-fly.
Agora compreendendo um pouco sobre a tecnologia provavelmente precisa-se
saber o que todos estes FPGA’s e CPLD’s estão fazendo dentro dos sistemas
embarcados. Entretanto, os seus usos são tão variados que torna-se impossível
generalizar.

3.3 PROTOTIPAGEM

Muitas vezes um FPGA ou um CPLD será usado em um sistema protótipo, pois

um dispositivo pequeno permite que os designers alterem a lógica facilmente durante o
desenvolvimento, facilitando etapas como a construção de placas e teste dos produtos.
Um dispositivo maior pode ser incluído para permitir a prototipagem de um projeto
system-on-chip, que eventualmente pode transformar-se em um ASIC. Seguindo a
mesma idéia básica é possível integrar em um único componente, grandes quantidades
de componentes menores, condição em que o dispositivo programável estará
substituindo um bloco mais caro, embora funcionalmente equivalente.
O FPGA é uma placa de circuito que contém em seu interior um núcleo
dedicado de processamento (como os processadores usuais) e também uma área de
lógica programável. Os fabricantes destes chips estão apostando que um processador
encaixado no interior de um dispositivo lógico programável vai necessitar de muito
menos portas de saída para aplicações típicas. A "parte fixa" do chip constitui um
 23

microprocessador totalmente funcional, e até mesmo alguma memória. Este chip

conecta também os pinos dedicados ao barramento de endereço e dados na parte externa
do núcleo; então uma parcela dos periféricos específicos da aplicação pode ser
desenvolvida utilizando a parte lógica programável do chip, com projetos próprios ou
núcleos IP (Intellectual Property).
Deve-se saber se há suficiente quantidade de pinos de I/O para o seu projeto,
pois esta é uma questão feita freqüentemente, e afeta bastante o custo do chip.
Conseqüentemente, muitos fabricantes oferecem o mesmo componente com diferentes
quantidades de pinos de I/O.
Obviamente o custo é um fator que precisa ser incluído em um produto final
baseado em FPGA ou CPLD. Escolher o dispositivo que possua os recursos mínimos
para o seu projeto pode ser a melhor opção.
As ferramentas mais populares para compilação e simulação VHDL e Verilog
são vendidas por terceiros. Estas ferramentas geralmente possuem suporte a uma lista de
FPGAs e CPLDs mais comuns. Isso significa que as ferramentas precisam compreender
o seu chip em particular e também informações de sincronismo relacionados à sua
ferramenta de posicionamento e roteamento (place and route tool), mas como explicado
anteriormente o software QUARTUS II® (gratuito) pôde suprir essa dificuldade.
Geralmente os CPLDs são mais rápidos e adicionam menos atrasos que os
FPGAs, entretanto, isso se deve à sua estrutura interna ser menos flexível. Assim, paga-
se pela velocidade extra. O que normalmente é perdido é a densidade. Em grandes
projetos é provável que se precise utilizar um componente mais lento. Ao utilizar um
FPGA o desempenho final só será conhecido no final do processo de roteamento. No
caso deste trabalho o FPGA foi escolhido, pois sua versatilidade é bastante útil para o
projeto de controladores, devido sua diversidade de ferramentas.
O consumo de energia, outra vantagem do FPGA, pode ser um fator importante
em alguns sistemas. Dispositivos baseados em EEPROM e FLASH tipicamente
requerem mais potência que os baseados em PROM, EPROM e SRAM. O FPGA possui
memória FLASH, SRAM e SDRAM, mas só serão usadas de acordo com a
necessidade.
Dispositivos programáveis estão disponíveis em todos os formatos de
encapsulamento. Suas escolha precisa ser direcionada a um deles se precisa de redução
de consumo de energia, redução de dissipação, tamanho e/ou custo ou aplicação.
 24

3.4 FAMÍLIA CICLONE II & FPGA

O baixo custo e um conjunto de funcionalidades otimizadas dos FPGAs da

família Cyclone II torna as soluções ideais para uma ampla área de utilização nos
setores: automotivos, comunicações, processamento de vídeo, teste e medição, entre
outras soluções do mercado. Uma foto do FPGA é mostrada na Figura 3.5 [ALTERA,
2010a] [ALTERA, 2010b].

Figura 3.5 – Apresentação do FPGA.

Dispositivos Cyclone ® II contém uma arquitetura de duas dimensões de linha e

coluna-base para implementar uma lógica personalizada. Coluna e linha interligam
diferentes velocidades a fim de fornecer sinal de interconexões entre matriz lógica
blocos (LABs), blocos de memória embutida e multiplicadores embutidos [ALTERA,
2010a].
Possuem uma interface com dispositivos de memórias DDR, DDR2, SDR,
SDRAM e QDII SRAM (acima de 167 MHz). Blocos de memória M4K são verdadeiros
blocos de memória dual-port com 4K bits memória mais paridade (4.608 bits). Estes
blocos de fornecimento dedicado de porta dupla, simples porta dupla, ou a memória
 25

simples acima de 36-bits de largura e até 260 megahertz. Esses blocos são organizados
em colunas em todo o dispositivo entre certos LABs (Logic Array Blocks). Cyclone II
oferecem dispositivos entre 119 a 1.152 Kbits de memória embutida. Na figura 3.6
[ALTERA, 2010a] é mostrado um diagrama dos dispositivos, inclusive os citados
anteriormente.

Figura 3.6 – Diagrama Cyclone II EP2C20.

Os dispositivos Cyclone II oferecem uma rede global de clock até quatro phase-
locked loops (PLL’s). Esses PLL's oferecem multiplicação e divisão de clock,
deslocamento de fase, e ciclo de trabalho programável, pode ser usado para minimizar o
atraso do clock e clock deslocado, e reduzir ou ajustar os tempos de clock-to-out (tco) e
set-up (Tsu). A rede global de clock consiste em até 16 linhas globais de clock essa
unidade de todo o dispositivo. O clock global da rede pode fornecer sinal para todos os
recursos dentro do dispositivo, como entrada /saída de elementos (IOEs), elementos
lógicos (LE’s), incorporado em multiplicadores e incorporado em blocos de memória.
As linhas de clock global também podem ser usadas para outros sinais altos de saída. As
PLL’s do Cyclone II têm prestação de propósito geral com a síntese do relógio e
deslocamento de fase, bem como saídas apoio I/O externas para a alta velocidade
diferencial.
 26

Tabela 3.1 – Características do dispositivo.

A matriz lógica é composta de LABs, com 16 elementos lógicos em cada LAB.

Uma LE é uma pequena unidade de lógica de prestação de implementação eficiente de
lógica de funções do usuário. LAB’s são agrupados em linhas e colunas em todo o
dispositivo. Dispositivos Cyclone II variam em densidade de 4.608 para 68.416 LE’s
como pode-se perceber na tabela 3.1.
Segundo os modos de operação o Quartus II ajusta automaticamente o LE para o
melhor modo de operação. Modo Normal (figura 3.7): apropriado para funções gerais da
lógica e funções de combinações; Modo Aritmético (figura 3.8): ideal para implementar
contadores, somadores, acumuladores e comparadores.

Figura 3.7 – Modo Normal.

 27

Figura 3.8 – Modo Aritmético.

Esses dispositivos são dotados de uma tecnologia DirectDriveTM, que faz conexão
estrutural MultiTrack entre LEs, blocos de memória M4K, multiplicadores embarcados,
e pinos de dispositivos I/O. O Quartus II oferece melhoria de desempenho e utilização
em todas as rotas do dispositivo. Até quatro PLL’s, com uma seleção dinâmica da
origem de clock; habilitado e desabilitado, também dinâmicos.
Nos modelos menores existem apenas os pinos DPCLK, e nos modelos maiores
do Cyclone II, como EP2C15, existem os pinos CDPCLK, que passam por um
multiplexador antes de chegarem no bloco de controle, como mostrado na figura 3.9; Já
os DPCLK [] vão direto para o bloco de controle.
A rede global de clock permite enviar sinais para o máximo de recursos que o
FPGA pode gerenciar sem exceder seu limite de dissipação de energia (fan-out), ou
seja, praticamente todos os recursos podem ter esse sinal como uma entrada. Das fontes
mencionadas, apenas dois pinos de relógio, duas saídas de relógio PLL, um pino
DPCLK, e um sinal gerado internamente são escolhidos para dirigir em um bloco de
controle do relógio. Figura 3.10 mostra um diagrama mais detalhado do bloco de
controle do relógio.
 28

Figura 3.9 - EP2C15 & Maior PLL, CLK[ ], DPCLK[ ] & Locais dos blocos de controle.

Figura 3.10 – Bloco de controle de Clock.

Os blocos de multiplicadores embarcados desenvolvidos para funções de

multiplicadores intensos no Processamento de Sinais Digitais (DSP), como FIR (Finite
Impulse Response), FFT (Fast Fourier Transform) e DCT (Discrete Cosine Transform);
Trabalha como um multiplicador de 18 bits e mais de dois multiplicadores
independentes de 9 bits. Desempenho esperado de 250 MHz.
IOEs (Estruturas de Entrada e Saída) do Cyclone II contêm um buffer I/O
bidirecional e três registradores para completar a taxa de transferência embarcada
 29

bidirecional de dados único. Figura 3.11 mostra o Cyclone II estrutura da OIE. A OIE
contém um registro de entrada, um registro de saída e uma saída permitem registrar.
Pode-se usar os registros de entrada para os tempos de instalação fácil e registros de
saída de clock rápido para tempos de saída. Além disso, pode-se usar a saída de enable
(OE) para registrar relógio rápido de saída de permitir sincronismo. O software de
Quartus II duplica automaticamente um registro OE único que controla a saída de vários
ou pinos bidirecional. Existe a possibilidade de usar IOE’s como entrada, saída ou pinos
bidirecionais.

Figura 3.11 – Estrutura Cyclone II IOE

Tabela 3.2 – Configuração e Teste.

 30

O FPGA possui circuitos JTAG BST que satisfazem os padrões da IEEE

(1149.1);Os dispositivos de JTAG também monitoram a operação da lógica, aceitando
vários comandos JTAG; Também aceita AS e PS. A placa que contém o FPGA pode ser
removida durante o funcionamento do resto do barramento, sem causar efeitos
indesejados, possuem suporte para qualquer seqüência de ativação de dispositivos e sem
ruídos no barramento durante a inserção da placa.

3.5 COMENTÁRIOS FINAIS

Existem inúmeras aplicações onde é melhor utilizar uma lógica dedicada

(ASIC), lógica configurável (DLP, CPLD, FPGA) ou lugares onde a melhor opção é
utilizar software. Existem razões válidas para qualquer uma destas escolhas e deve-se
estar atento às necessidades de uma aplicação em particular. No caso deste projeto
decidiu-se usar FPGA pela sua imensa versatilidade e possíveis futuras melhorias.
Enquanto o software e o hardware continuam a se expandir e integrar-se, nós devemos
acompanhar o processo e estar dispostos a aprender coisas novas.
CAPÍTULO 4

ESPERIMENTOS E RESULTADOS

Neste capítulo na Seção 4.1 será mostrado uma descrição da planta de teste
utilizada no projeto: estrutura física, interface, desenhos, diagramas; os ensaios para
identificação da planta na Seção 4.2; na Seção 4.3 apresentar-se-á controlador PID,
mostrando os resultados e comparações; finalmente na Seção 4.4 os testes com o FPGA
e Seção 4.5 Comentários finais.

4.1 DESCRIÇÃO DA PLANTA

A planta é constituída de uma base com haste de alumínio oca curvada fixada à
base, uma haste de alumínio oca com motor e hélice parafusados numa das pontas,
potenciômetro para medição do ângulo de rotação, enrolamentos e conexões com
parafusos como se pode observar na figura 4.1.

Figura 4.1 – Planta real do projeto.

 32

Os circuitos de acionamento e conversão analógico-digital (AD) apresentados na

Figura 4.2 enviam o sinal para controle por PWM (Figura 4.3) do motor, e recebem os
dados da posição angular da haste girante através das leituras do potenciômetro,
enviando-os para o FPGA. Os projetos das placas de conversão e controle de circuitos
impressos foram feitos segundo a Figura 4.5 Uma fonte DC alimenta o circuito de
acionamento com 12 Volts e outra fonte DC de 5 Volts alimenta o circuito de conversão
AD como mostrado na figura 4.4.

Figura 4.2 – Circuito de acionamento e conversão.

Figura 4.3 – PWM exibido no Osciloscópio.

 33

Utilizou-se uma placa da National Instruments (figura 4.6) para coletar os dados
e exibir na tela através da interface Simulink do MATLAB. No Simulink foi criado uma
lógica de blocos (figura 4.7) para exibição dos dados coletados da placa da National.

Figura 4.4 – Fontes de alimentação DC.

A placa possui espaços para dois motores sendo outro para aplicações futuras
para melhorar a linearidade da planta.

Figura 4.5 – Projeto da placa de circuito impresso.

 34

Figura 4.6 – Placa da National Instruments para coletar dados.

As leituras do Simulink são salvas em um arquivo “.mat” e podem ser

visualizadas utilizando o “Scope” ou plotando os dados colhidos.

Figura 4.7 – Lógica de blocos Simulink.

 35

Os bloco maior na esquerda “nidaq” é de onde recebe-se o sinal da placa e este

sinal é tratado pelos blocos seguintes para organizar os bits, ou seja, fazer a
transformação dos binários em decimal e depois plotar na tela.
Sabe-se que a planta é não linear, portanto para linearizá-la limitou-se o seu
ângulo de operação, que proporcionou uma aferição do potenciômetro equivalente a 100
decimal (os valores do ângulo são medidos entre 0 e 255 devido à saída de 8 bits do
ADC0808). Estes 100 equivalem a um ângulo de aproximadamente 45º, limite em que a
planta pode ser controlada. Caso tente controlar em um ângulo acima de 45º (ou 100) o
sistema se torna não linear, então o controle irá falhar.

4.2 ENSAIOS PARA IDENTIFICAÇÃO

A identificação da planta foi feita segundo [AGUIRRE, 2001]. Como a planta é

do tipo segunda ordem subamortecido, um possível modelo para afunção de
transferência é do tipo equação 4.1.a Tem-se que a partir da resposta ao degrau da
planta Figura 4.8 (página seguinte) o valor de ciclos visíveis é 3 então fator de
amortecimento ζ é igual a 0,2 dado pela equação 4.1.b [AGUIRRE, 2001].

K.wn 2
(4.1.a)
s 2 + 2ζwn.s + wn 2
0, 6
ζ = = 0, 2 (4.1.b)
3

Para achar a freqüência natural wn pega-se uma média do período e utilizando a

formula de wn como o equacionamento 4.2 [AGUIRRE, 2001].

6, 9
T= = 2,3s
3 (4.2)
2π
wn = = 2, 74rad / s
T

Para encontrar o ganho K, utiliza-se o equacionamento 4.3 [AGUIRRE, 2001].

 36

y(∞) − y(0− ) 69 − 0
K= = = 0, 46 (4.3)
A 150
Agora substituindo os valores de K, ζ, e wn encontrados, temos a seguinte função
da planta identificada em 4.4.

3, 458
Gp(s) = 2
(4.4)
s + 1, 097s + 7, 516

Figura 4.8 – resposta ao degrau da planta real.

4.3 ENSAIOS PID

Para o controlador PID tentou-se utilizar o método de Ziegler-Nichols, porém

não foi possível a sua implementação, pois para obtermos o Kcr o sistema deveria ser
marginalente estável. Para obter o sistema marginalmente estável a partir do sistema
controlado com a planta Gp de segunda ordem identificada, terá que existir pelo menos
dois pólos diferentes em cima do eixo imaginário y e não existir nenhum no SPD (semi
plano direito) [LATHI, 2007]. Segundo [ZIEGLER e NICHOLS, 1942] Ziegler-Nichols
 37

em seu segundo método, já que o primeiro é notório que não se adéqua, para se obter o
Kcr a função de transferência (FT) em malha fechada é controlada apenas pelo termo
proporcional como visto no capítulo 2 e ao fazer isso temos o seguinte processo
mostrado na figura 4.9.

Figura 4.9 – Diagrama 2º método Ziegler-Nichols.

Este sistema da figura 4.9 resultará na seguinte função de transferência dada pela
equação 4.5. Então para obter os pólos, o denominador deverá ser estudado.

Y Kp.3, 458
= 2 (4.5)
Uc s + 1, 097s + 7, 516 + Kp.3, 458

Sendo o denominador uma função de segunda ordem, pode-se apenas obter duas
raízes, mas para dar certo, estas raízes têm que ser puramente complexas, então,
segundo equacionamento 4.6 não é possível ter raízes complexas, mesmo variando Kp,
pois para ser puramente imaginário não poderia existir nenhuma parcela real, logo este
método não é aplicável para esta planta.

s 2 + 1, 097s + 7,516 + Kp.3, 458 = 0

−28,8605 − 13,832Kp − 1, 097
s12 = ± (4.6)
2
1, 097 28,86 − 13,83Kp
s12 = − ±
2 2

Por esse motivo, teve-se que modificar o método de sintonia do controlador,

então o método escolhido foi “Alocação de pólos”. Para aplicar este método fez-se o
seguinte teste: considerando a função de transferência com o controlador em malha
fechada dado pela equação 4.7, então dividindo o numerador e o denominador por Ti,
temos a equação 4.8. Agora se escolhe uma equação do terceiro grau com raízes pra
 38

tornar o sistema estável. Escolhem-se então as raízes: (-2-3j), (-2+3j), e – 6. Estas raízes
satisfazem a condição de estabilidade [LATHI, 2007]. Agora se faz uma comparação
entre as duas equações de terceiro grau, mostradas na equação 4.9.

3,458.kp.Td.Ti.s 2 +3,458kp.Ti.s+3,458kp
(4.7)
Ti.s3 +(1,097.Ti+3,458.kp.Td.Ti).s 2 +(7,516.Ti+3,458.kp.Ti).s+3,458.kp

kp
3,458.kp.Td.s 2 +3,458kp.s+3,458
Ti (4.8)
3 2 kp
s +(1,097+3,458.kp.Td).s +(7,516+3,458.kp).s+3,458.
Ti

s3 + 10s 2 + 37s + 78


 3 2 kp (4.9)
s +(1,097+3,458.kp.Td).s +(7,516+3,458.kp).s+3,458.
 Ti

Fazendo a comparação dos índices obtém-se que Ti, Td e Kp são

respectivamente 0,378 , 0,302 e 8,5263. Para testar se a função estabiliza mesmo,
utiliza-se o seguinte código MATLAB da figura 4.10.

syms Ti td kp s
Ti = 0.378;
Td = 0.302;
kp = 8.5263;
Gp = sym('3.458/(s ^ 2 + 1.097 * s + 7.516)');
Gc = kp * (1 + 1/(Ti * s) + s * Td);
aux = Gp * Gc/(1 + Gp * Gc);
aux2 = factor(aux);
[num, den] = numden(aux2);
num2 = subs(num/Ti);
den2 = subs(den/Ti);
num3 = sym2poly(num2);
den3 = sym2poly(den2);
nova_func = tf(num3, den3)
figure
step(nova_func, 'r')
axis( [0 2.5 0 1.4])

Figura 4.10 – Código para testar de estabilidade.

Este código da figura 4.10 gera a função de transferência do sistema em malha

fechada (equação 4.8) e calcula sua resposta ao degrau, dados os valores das constantes
do controlador. A figura 4.11 mostra a resposta ao degrau do nosso teste de alocação de
pólos.
 39

Step Response

1.2

0.8

Amplitude
0.6

0.4

0.2

0
0 0.5 1 1.5 2 2.5
Time (sec)

Figura 4.11 – Resposta ao degrau da função de teste.

Pode-se perceber que o sistema obtido esta estável e controlado através do ajuste
do PID. Agora faremos uma abordagem visando uma escolha embasada em fatores
previamente definidos.
Sendo as variáveis que se quer trabalhar: o oveshooting e o tempo de
acomodação do sistema e o pólos será feito o estudo para escolher os parâmetros
corretos para cada caso.
Para ajustar os pólos do sistema deve-se ajustar a freqüência natural wn do
sistema igual ou próxima à da planta. Obter a freqüência wn da planta (equação 4.4) foi
feito utilizando a equação 4.1.a [OGATA, 2003] que descreve a representação
matemática clássica de um sistema de segunda ordem sub-amortecido em função de wn
(freqüência natural), ζ (Csi-Fator de amortecimento), e K (ganho) onde wn é responsável
por alterações na fase e ζ na amplitude.
Então comparando as equações 4.1.a e 4.4, tem-se que wn é igual à raiz de 7,516
, ou seja, é aproximadamente igual a 2,74 rad/s. Agora o ajuste do fator de
amortecimento deve ser feito de acordo com o percentual de overshooting e o tempo de
acomodação segundo as equações 4.11 e 4.12.

−ζπ
1−ζ 2
PO = e (4.11)
4
ts =
ζwn (4.12)
 40

Então o PO e ts podem ser relacionados utilizando as equações 4.11 e 4.12 , e

formando-se a equação 4.13.

 
  −4  
 
  ts.wn  
 2

  4  
 1−  
 ts.wn  
PO = e 
(4.13)

Pode-se perceber segundo a equação 4.1.a e do gráfico gerado por ela, mostrado
na figura 4.12 a relação de PO (percentual de overshooting) e ts (tempo de
acomodação). Os dois são diretamente proporcionais, ou seja, numa função do tipo 4.1.a
os parâmetros se comportam como mostrado na figura 4.12. Para a planta de grau dois,
PO é diretamente proporcional à ts e inversamente proporcional ao fator de
amortecimento.

0.7

0.6

0.5

0.4
PO

0.3

0.2

0.1

0
0 5 10 15 20 25 30 35 40 45 50
ts(s)

Figura 4.12 – Gráfico PO versus ts para FT de segundo grau.

Para ajustar os pólos terá que ser feito uma comparação entre o denominador da
função 4.8 e uma função determinada por wn (mesmo da planta), fator de amortecimento
(escolhido conforme parâmetros para ajuste PO e ts) e o pólo real definido distante cerca
de 10 vezes distante do valor das raízes.
 41

Esta comparação foi feita com as equações 4.14 em que são desenvolvidos e
comparados seus índices para achar Kp, Ti, Td onde ‘p’ é o pólo definido, wn é o
mesmo da planta, e ζ é o fator de amortecimento definido.

 3 2 kp
s +(1,097+3,458.kp.Td).s +(7,516+3,458.kp).s+3,458.
 Ti (4.14)
(s 2 + 2wnζ.s + wn 2 ).(s − p)


Esta comparação foi feita utilizando um código MATLAB para agilizar, e

mostrado na figura 4.13.
clc
clear
syms kp Ti Td s wn zeta p
%dados
wn=2.7415;
zeta=0.7;
p=-10;
Gp=sym('3.458/(s^2+1.097*s+7.516)');
Gc=kp*(1+1/(Ti*s)+s*Td);
G=(wn^2+2*zeta*wn*s+s^2)*(s-p);
G1=subs(G);
G1=expand(G1);
G1=collect(G1);
G2=sym2poly(G1);
kp=solve(7.516+3.458*kp-G2(3),kp);
kp=double(kp)
auxs=subs(1.097+3.458*kp*Td);
Td=solve(auxs-G2(2),Td);
Td=double(Td)
auxs=subs(3.458*kp/Ti);
Ti=solve(auxs-G2(4),Ti);
Ti=double(Ti)
Gp=sym('3.458/(s^2+1.097*s+7.516)');
Gc=kp*(1+1/(Ti*s)+s*Td);
aux=Gp*Gc/(1+Gp*Gc);
aux2=factor(aux);
[num,den] = numden(aux2);
num2=subs(num/Ti);
den2=subs(den/Ti);
num3=sym2poly(num2);
den3=sym2poly(den2);
nova_func=tf(num3,den3)
step(nova_func,'g')

Figura 4.13 – Código para comparar e obter parâmetros PID.

A FT em malha fechada controlada pelo PID não é de grau dois, pois possui dois
zeros e três pólos como mostrado na figura 4.12, então a relação entre PO e ts irá mudar.
Resolveu-se então fazer testes para ver como a resposta ao degrau se comporta, caso
 42

variarmos o fator de amortecimento, já que temos wn fixo, observando as variações e

PO e ts ou ζ. Para isso foi criado um código MATLAB para gerar estas curvas, como
mostrado na figura 4.13. As curvas para vários valores de ζ são mostradas na figura
4.14. Pela figura 4.14, pode-se perceber que Csi é diretamente proporcional ao
overshooting e ao tempo de acomodação.

Figura 4.14 – Resposta ao degrau para valores de Csi.

Com essa observação podemos escolher o tipo de resposta que preferir de acordo
com Csi adotado. Adotar-se-á Csi igual a 0,3 e com código figura 4.13 tem-se Ti =
0,2189 ; Td = 0,6413 ; Kp = 4,7567.

Figura 4.15 – Resposta ao degrau da planta.

 43

Agora para achar o período de amostragem Ts utiliza-se a reposta da planta

equação 4.4 ao degrau, temos que Ts é menor que T/5 e maior que T/10 onde T é o
período atingido como mostra a figura 4.15. Observado na figura 4.15 que T é 0,67,
então: 0,067 < Ts < 0,134 , então Ts adotado foi 0,1s.

4.4 ENSAIOS FPGA

Tendo os valores Kp, Ti, Td, Ts aplicaremos a metodologia de [JACQUOT, R.

G. 1994] para implementação do PID discretizado no FPGA. Foi elaborado um código
MATLAB para simular o PID discreto de acordo com as definições do código em
VHDL. Teve-se que discretizar a planta Gp para fazer o código, para isso utilizou-se
funções do próprio MATLAB para isso. O código está apresentado no Apêndice A.
Com o código do PID discreto pôde-se observar que os parâmetros passados no
contínuo não seriam adequados no discreto fato que foi realmente observado nos testes
reais. Então observando o formato da saída, em decimal, foi-se modelando
manualmente os parâmetros a partir dos valores primários até chegar aos valores que
assentam a curva, mostrado na figura 4.16.

80
saida (decimal)

60

40

20

0
0 5 10 15 20 25 30 35 40 45 50
tempo(s)

150
pid (decimal)

100
saida do

50

0
0 5 10 15 20 25 30 35 40 45 50
tempo(s)

Figura 4.16 – Saída discreta simulada no MATLAB.

 44

O código em VHDL do controlador foi desenvolvido em parceria com o

mestrando Davi Nunes. As principais modificações do projeto desenvolvido em parceria
com o mestrando foram realizadas nos blocos relacionados ao PID e ao GERADOR,
conforme estrutura mostrada na figura 4.17 retirada do software QUARTUS II de onde
trabalhamos a compilação do código PID.
Param eter Value Type
divisor 270 Signed Integer
divisor2 2500 Signed Integer
CONVERSOR_AD asd[7..0]
NORMALIZA01
eoc INPUT EOC CLOCK_OUT OUTPUT clk_out
VCC
clk_in INPUT OUTPUT start OUTPUT potout[7..0]
VCC CLOCK_IN START CLOCK_IN SAIDA[7..0]
SW[7..0] INPUT POT_IN[7..0] POT_OUT[7..0] ENTRADA[7..0]
VCC ENTRADA[7..0] OUTPUT disp[7..0]
inst7
inst8

Parameter Value Type inst1

divisor 195 Signed Integer reset_cont2

aclr
unsigned compare
clk_placa

INPUT
q[7..0] dataa[7..0]
clk_placa clk_in clk_out clock ageb
VCC
up counter datab[]=255
cont2 inst2

inst9 START_AD
unsigned compare

dataa[7..0]
aleb
datab[]=128
Param eter Value Type
FATOR 5000 Signed Integer inst6
pid001 inst3 OUTPUT pwm_saida

REF[7..0] CLOCK1_OUT datab[7..0] OUTPUT

agb pwm_esp
POSICAO[7..0] OUTPID[7..0] dataa[7..0]
CLOCK_IN OUTPUT ref _out[7..0]
OUTPUT unsigned compare
LED_G[7..0]
inst16 pwm_out
inst4

datab[7..0] OUTPUT
agb pwm_saida2
GERADOR dataa[7..0]

CLOCK REFERENCIA[7..0] unsigned compare

pwm_out
asd[7..0]
inst

Param eter Value Type

FATOR 50000000 Signed Integer

Figura 4.17 – Diagrama de blocos QUARTUS II.

Trata-se a seguir de cada bloco do diagrama acima. O bloco ConversorAD

captura: (i) as leituras do ADC0808, (ii) o bit que encerra leitura (EOC), e (iii) o clock
de entrada que será dividido conforme o bit EOC vai para nível alto. O sinal do
potenciômetro é enviado para o segundo bloco NORMALIZA01 - este bloco recebe o
sinal de EOC e a Saída do POT_OUT do bloco ConversorAD, e realiza o cálculo de
uma média das leituras do potenciômetro, jogando este valor para a saída quando EOC é
nível alto. A saída do bloco NORMALIZA01 é enviada pelos pinos do FPGA para os
LEDS do kit de desenvolvimento no qual se encontra o FPGA, e para a leitura no
MATLAB. Os blocos PID, GERADOR, clk_placa e os comparadores (reset_cont2,
START_AD e dois pwm_out) geram o PWM para controlar o motor do pêndulo de
acordo com o sinal do bloco PID. No apêndice B está o código do PID comentado.
Utilizando os valores discretos simulados: Kp=2, Ti=2 e Td=6 temos o controle
obtido pela figura 4.17. Então no teste real a curva obtida foi a mostrada na figura 4.18.
 45

100
referência
90 saída

80

70

60
decimal

50

40

30

20

10

0
10 20 30 40 50 60 70 80 90 100 110 120
tempo(s)

Figura 4.18 – Resposta ao degrau do controlador real.

O controle foi feito para o degrau de referência 70 decimal e pode-se perceber

que o controle funcionou similarmente à simulação feita no MATLAB. Um detalhe
muito importante é que o código VHDL trunca os valores inteiros, porém fez-se um
“IF” com intuito de arredondar estes valores e não truncá-los. Isto foi determinante para
a estabilização do erro em regime. Vale salientar que na simulação feita no MATLAB
utilizou-se a função round para fazer o arredondamento assim como no VHDL.
Outro teste feito foi com vários degraus diferentes, apresentando um bom
desempenho como mostrado na figura 4.19. Pode-se perceber que o assentamento se dá
com aproximadamente 10 segundos em cada degrau e que estes valores podem ser
reduzidos de acordo com a necessidade de se aumentar ou diminuir um ou outro
parâmetro (PO ou ts). Modificando-se estes parâmetros terá que ser realizado a sintonia
do PID para atualizar as constantes do controlador.
Outro teste foi feito dando uma perturbação na haste e apresentou o seguinte
resultado mostrado na figura 4.20. Pôde-se perceber que a primeira perturbação de
aproximadamente 45º foi assentada em cinco segundos e a segunda perturbação de 90º
foi assentada em quinze segundos aproximadamente.
 46

100

90

80

70

60
decimal

50

40

30

20

10

0
50 100 150 200 250 300 350 400 450
tempo(s)

Figura 4.19 – controle com variação na referência.

200

180

160

140

120
decimal

100

80

60

40

20

0
50 100 150 200 250 300
tempo(s)

Figura 4.20 – controle com perturbação da haste.

 47

4.5 COMENTÁRIOS FINAIS

Os resultados demonstram o ótimo resultado na resposta do controlador:

velocidade e precisão. A velocidade na recuperação de tanto nas perturbações externas
como nos degraus variados e a precisão ao alcançar o valor desejado. A precisão foi
alcançada devido a um melhor estudo do código em VHDL fazendo com que os valores
calculados inteiros fossem os mais próximos dos valores em números reais obtidos em
simulação.
CAPÍTULO 5

CONCLUSÕES

5.1 CONCLUSÕES

Neste trabalho foram apresentados possíveis formas de sintonizar o PID, porém

usou-se apenas a mais viável para este determinado projeto de planta. A identificação
foi feita por apenas um método, e utilizado apenas um tipo de planta.
O trabalho foi realizado em sua grande parte em estudos e ensaios realizados no
laboratório GPAR (Grupo de Pesquisa em Automação e Robótica) da engenharia
elétrica da UFC.
O objetivo deste controlador é um pequeno grande passo para futuros
aperfeiçoamentos que podem ser feitos com o intuito de uma aplicação mais
automatizada e com fins de comercialização.
Um possível aperfeiçoamento deste trabalho pode ser feito no FPGA para que
todo o processo de identificação da planta se torne automatizado, bem como os
parâmetros do PID. Assim todo o sistema se concentrará apenas no FPGA, tornando-se
uma ferramenta bastante robusta para fins comerciais.
Para a construção deste projeto precisou-se de um estudo detalhado da
linguagem VHDL, [D’AMORE, 2005] pois suas peculiaridades fazem diferença na
obtenção de resultados. Uma dificuldade encontrada, por exemplo, foi que na
compilação os resultados são truncados e não arredondados, então se fez necessário
criar um modo de arredondar os parâmetros para obter uma maior precisão nos
resultados.
Outra dificuldade foi ajustar a parte física da planta, pois o material possuía uma
resistência de atrito que tornava a planta não linear, então foi preciso rever os
enrolamentos para deixá-los o mais livres de atrito possível.
 49

Há uma limitação da saída do PID, pois eles têm apenas 8 bits (255), então a
saída também tem um limite de 100 (faixa de linearidade da planta), ou seja, só controla
até a referência 100. Este pode ser um ajuste para melhorias futuras.
Apesar das dificuldades apresentadas, a implementação apresentou erro de
regime baixo (conforme pode-se observar nas Figuras 4.17 e 4.18). Este projeto servirá
de base para a implementação de outros controladores digitais no GPAR, e pode ser
utilizado como prática em disciplinas de graduação como Técnicas Avançadas de
Eletrônica Digital e Controle e Servomecanismos.
 50

REFERÊNCIAS BIBLIOGRÁFICAS

AGUIRRE, L. A. Introdução À Identificação de Sistemas: Técnicas Lineares e Não-

Lineares Aplicadas a Sistemas Reais. 2a Edição Revista e Ampliada, 2001.

BARR, M. "Programmable Logic: What's it to Ya?," Embedded Systems

Programming, , pp. 75-84, June, 1999.

CHAN ,Y. F. “Design and Implementation of Modular FPGA-Based PID Controllers”

IEEE TRANSACTIONS ON INDUSTRIAL ELECTRONICS, 2007.

CHIEN, K.L. e HRONES, J.A. e RESWICH, I.B. On the Automatic Control of

Generalized Passive Systems, Transaction ASME, 74, 1952

COHEN, G.H. e COON, G.A. Theoretical consideration of retarded control, Trans.ASME,

Vol.75, pp. 827-834, 1953

Cyclone II - http://www.altera.com/literature/hb/cyc2/cyc2_cii5v1_01.pdf Data:

acessado em 03/04/2010a às 09:00h.

D’AMORE, R. VHDL : descrição e síntese de circuitos digitais. Editora LTC., 2005.

FPGA- http://www.altera.com/literature/ug/ug_cii_starter_board.pdf Data:

acessado em 03/03/2010b às 09:00h.

GOMES, R. C. “IMPLEMENTATION AUTO-TUNING CONTROLLER USING

FPGA AND NIOS II PROCESSOR”, IX Simpósio Brasileiro de Automação
Inteligente – SBAI, 2009.

História dos programadores lógicos em: http://www.controllerbrasil.com.br/programadores-

lógicos. Data: 05/06/2010 ás 13:00h.

JACQUOT, R. G. “Modern digital Control Systems” 2nd ed., 1994.

LATHI, B.P. Sinais e Sistemas Lineares; tradução Gustavo Guimarães Parma – 2ªed.
Bookman., 2007.

MOORE, G. E. “Technical Digest International Electron Devices Meeting”, 1995.

NASCIMENTO, C. L. J. e YONEYAMA, T. Inteligência Artificial em Controle e

Automação, pela Editora Edgard Blücher, 2000.

OGATA, K. Engenharia de controle moderno tradução Paulo Álvaro Maya; 4ªed.

Prentice Hall, 2003.
 51

RICHARD, C. D. e ROBERT, H. B. Sistemas de Controle Modernos 8ed., 2001.

TOCCI, R. J. e WIDMER, N. S. “Sistemas Digitais: Princípios e aplicações,

Pearson Prentice Hall, 2003.

WITTENMARK, B. e ÅSTRÖM , J. “Computer Control: An Overview”, 2003.

WOLF, W. Computers as Components: Principles of Embedded Computing System

Design. San Francisco, CA: Morgan Kaufmann, 2001.

Xilinx - http://www.xilinx.com/support/documentation/data_sheets/ds160.pdf acessado em

20/05/2010 às 20:00h.

ZIEGLER, J. G. e NICHOLS, N. B. “Optimum settings for automatic controllers”, ASME,

1942.

ZELENOVSKY, R. e MENDONÇA, A. “PC: Um Guia Prático de Hardware e

interfaceamento” 3ªed., 2002.
 52

APÊNDICE A
CÓDIGO DA SIMULAÇÃO DO CONTROLADOR
clc
clear
syms Ti Td Kp Ts t
UK=0;
UK2=0;
y=0;
E1=0;
E2=0;
E3=0;
Ti=2;
Td=6;
Kp=2;
Ki=Kp*10/Ti;
Kd=Kp*Td/10;
Ts=0.1;
ALFA=(Kp + (Ki*Ts/2) + (Kd/Ts));
BETA=( (Ki*Ts/2) - Kp - (2*Kd/Ts) );
GAMA=( Kd/Ts );
Uc=ones(1,500)*70;
f=tf(3.458,[ 1 1.097 7.516]);
Gp=c2d(f,Ts);
[numGp, denGp]=tfdata(Gp,'v');
a1=numGp(2);
a0=numGp(3);
b2=denGp(1);
b1=denGp(2);
b0=denGp(3);
ut1=0;
ut2=0;
yt1=0;
yt2=0;
for x=1:500
t(x)= double(x/10);
y=a1/b2*(ut1)+a0/b2*(ut2)-b1/b2*(yt1)-b0/b2*(yt2);
E1=(Uc(x)-y);
err(x)=E1;
UK=(UK2*100 + 10*ALFA*E1 + 10*BETA*E2 + 10*GAMA*E3);
uk(x)=UK;
E3=E2;
E2=E1;
UK2=round(UK/100);
ut2=ut1;
yt2=yt1;
yt1=y;
pid(x)=round(UK/100);
if UK/100 > 255
pid(x)=255;
end
if UK/100 < 1
pid(x)=1;
end
ut1=pid(x);
saida(x)=y;
end
subplot(2,1,1)
stem(t,saida,'r')
subplot(2,1,2)
stem(t,pid)

Figura A.1 – Código PID discreto.

 53

Figura A.2 – Ilustração do software QUARTUS® II.

 54

APÊNDICE B
CÓDIGO VHDL DO CONTROLADOR

ENTITY pid001 IS
GENERIC ( FATOR : INTEGER :=5000000); --TAXA DE AMOSTRAGEM DO PID BASEADO NO
--EOC DO AD.
PORT (
REF : IN INTEGER RANGE 0 TO 255; --referência do gerador (degaus)
POSICAO : IN INTEGER RANGE 0 TO 255; -- posição da haste (saída do bloco
-- NORMALIZA01)
CLOCK_IN : IN BIT; -- clock de entrada 50MHz
CLOCK1_OUT : BUFFER BIT; -- clock de saída
OUTPID : OUT INTEGER RANGE 0 TO 255 :=0 -- saída do PID
);
END pid001;
ARCHITECTURE PID OF pid001 IS
SHARED VARIABLE ACUMULADOR : INTEGER RANGE -500 TO 500:=0;
CONSTANT ALFA : INTEGER:=145; -- contantes do processo definidas.
CONSTANT BETA : INTEGER:=-255;-- multiplicadas por 10
CONSTANT GAMA : INTEGER:=120;
BEGIN
--////////////////////////////////////////////////////////////////////////////////////////////
--Divisor de clock
--////////////////////////////////////////////////////////////////////////////////////////////
DIVISOR : PROCESS( CLOCK_IN ) --
DIVIDE O CLOCK DE ENTRADA POR UM FATOR
VARIABLE AUX : INTEGER RANGE 0 TO FATOR := 0;
BEGIN
IF(AUX = FATOR)THEN
AUX := 0;
CLOCK1_OUT <= '1';
 55

ELSIF( (CLOCK_IN'EVENT) AND (CLOCK_IN = '1') )THEN

AUX := AUX + 1;
IF (AUX = FATOR/2) THEN
CLOCK1_OUT <= '0';
END IF;
END IF;
END PROCESS DIVISOR;
--////////////////////////////////////////////////////////////////////////////////////////////
--Processo de Controle PID
--////////////////////////////////////////////////////////////////////////////////////////////
CONTROLE : PROCESS (CLOCK1_OUT)
VARIABLE E1 : INTEGER RANGE -500 TO 500:=0;
VARIABLE E2 : INTEGER RANGE -500 TO 500:=0;
VARIABLE E3 : INTEGER RANGE -500 TO 500:=0;
VARIABLE UK : INTEGER RANGE -250000 TO 255000:=0;
VARIABLE UK2 : INTEGER RANGE -255 TO 500:=0;
BEGIN
IF ((CLOCK1_OUT'EVENT) AND (CLOCK1_OUT = '1')) THEN
E1:=(REF-POSICAO);
UK:=((UK2*100) + (ALFA*E1) + (BETA*E2) + (GAMA*E3)); -- PID discreto
UK2:=(UK/100); -- instante anterior do PID.
IF (UK-100*UK2)>50 THEN -- IF para fazer arredondamento e não truncar.
UK2:=UK2+1; -- (essencial para manter um erro mínimo)
END IF;
E3:=E2; -- erro (k-2) recebe erro instante anterior (k-1)
E2:=E1; -- erro anterior recebe erro atual
ACUMULADOR:=(UK2); -- saída para o PID
IF (ACUMULADOR>255) THEN -- limitação da saída do PID em 255 (8bits).
ACUMULADOR:=255;
END IF;
IF (ACUMULADOR<0) THEN -- limita valor mínimo em 1.
ACUMULADOR:=1;
END IF;
OUTPID<=ACUMULADOR; -- saída para o pino de saída do bloco PID
END IF;
END PROCESS CONTROLE;
END PID;