Controle de Processos Com Octave

Controle de Processos – IT359
Prof. Dr. Luiz Augusto C. Meleiro

meleiro.it359@gmail.com – meleiro@ufrrj.br
Departamento de Engenharia Química
DEQ/UFRRJ
UNIVERSIDADE FEDERAL RURAL DO RIO DE JANEIRO

INSTITUTO DE TECNOLOGIA
DEPARTAMENTO DE ENGENHARIA QUÍMICA
CONTROLE DE PROCESSOS QUÍMICOS

COM O SOFTWARE GNU-OCTAVE
Prof. Dr. Luiz Augusto da Cruz Meleiro
UFRRJ
2021
SUMÁRIO
1 NOTAS SOBRE O OCTAVE 7
1.1 Instalação dos Pacotes: A versão atual (6.1.0 - Nov-2020) 7
1.2 Atualização da lista de Pacotes 7
1.3 Instalação de Pacotes Adicionais 7

1.3.1 Instalando Pacotes Adicionais 7
1.3.1.1 Instalando o pacote de processamento de sinais 8
1.3.1.2 Instalando o pacote de processamento simbólico 8
1.4 Habilitação dos Pacotes 8
1.5 Funções Específicas de Cada Pacote 8
2 RECURSOS AUXILIARES 9
2.1 Trabalhando com Álgebra Simbólica 9

2.1.1 Cálculo analítico da integral de uma função 9
2.1.2 Cálculo analítico da derivada de uma função 9
2.1.3 Operações com Polinômios 10
2.1.3.1 Conversão entre as formas simbólica e de coeficientes polinomiais 10
2.1.3.2 Cálculo do valor de um polinômio 10
2.1.3.3 Multiplicação de polinômios 11
2.1.3.4 Raízes de polinômios 11
3 TRANSFORMADAS DE LAPLACE 13
3.1 Transformada de Laplace 13
3.2 Transformada Inversa de Laplace – Método das Frações Parciais 13

3.2.1 O Polinômio D(s) Possui Raízes Reais e Distintas 14
3.2.2 O Polinômio D(s) Possui Raízes Complexas 15
3.2.3 O Polinômio D(s) Possui Raízes Reais e Iguais 15
4 FUNÇÕES DE TRANSFERÊNCIA 17
4.1 Introdução 17
4.2 Trabalhando com Funções de Transferência 17

4.2.1 Representações de uma função de transferência 17
Controle de Processos com Gnu-Octave

Material de apoio para a disciplina IT 359 – Controle de Processos
Prof. Luiz Augusto C. Meleiro - DEQ/UFRRJ – meleiro@ufrrj.br 1
4.2.2 Cálculo dos pólos, zeros e ganho estacionário 19
4.2.3 Operações com funções de transferência 20
5 COMPORTAMENTO DINÂMICO EM MALHA ABERTA 22
5.1 Respostas Dinâmicas de Processos de 1ª Ordem 22

5.1.1 Resposta de processos de 1ª ordem ao degrau 23
5.1.2 Resposta de processos de 1ª ordem ao impulso 25
5.1.3 Resposta de processos de 1ª ordem ao pulso 26
5.1.4 Resposta de processos de 1ª ordem à rampa 28
5.1.5 Resposta de processos de 1ª ordem a perturbações periódicas 30
5.2 Respostas Dinâmicas de Processos de 2ª Ordem 31

5.2.1 Resposta ao Degrau 32
5.2.1.1 Processos multicapacitativos 34
5.2.2 Resposta ao Impulso 36
5.2.3 Resposta ao Pulso 37
5.3 Respostas Dinâmicas de Processos Mais Complexos 39

5.3.1 Processos Com Dinâmica no Numerador 39
5.3.1.1 Processos com Resposta Inversa 40
5.3.2 Processo Integrador 42
5.3.3 Processos com Tempo Morto 43
6 PROJETO E ANÁLISE DE CONTROLADORES FEEDBACK 46
6.1 Exemplos de Aplicação de Controladores Feedback 46
7 PROJETO E ANÁLISE DE CONTROLE EM CASCATA 50
8 PROJETO E ANÁLISE DE CONTROLADORES FEEDFORWARD 51
9 REFERÊNCIAS BIBLIOGRÁFICAS 52

APRESENTAÇÃO
Este tutorial foi escrito para servir de suporte às aulas da disciplina IT 359, Controle
de Processos, do DEQ/UFRRJ.
O principal objetivo deste tutorial é apresentar aos discentes uma ferramenta
computacional com interface amigável para o estudo das principais técnicas de controle de
processos, o Software de Computação Científica GNU Octave.
O uso desse software permitirá que a disciplina de Controle de Processos possa ser
muito mais bem explorada e compreendida por meio da simulação de processos e da
avaliação computacional das técnicas de controle abordadas no curso.
A habilidade na utilização de softwares de computação científica e em técnicas de
programação são demandas crescentes no mercado de trabalho do engenheiro químico,
assim como no meio acadêmico.

LISTA DE FIGURAS
Figura 1. Resposta de um processo de 1ª ordem a um degrau unitário. ................................................................... 24
Figura 2. Resposta de um processo de 1ª ordem a um degrau de magnitude M. ...................................................... 24
Figura 3. Resposta de um processo de 1ª ordem a um degrau de magnitude M. ...................................................... 25
Figura 4. Resposta de um processo de 1ª ordem a um impulso unitário. ................................................................. 26
Figura 5. Resposta de um processo de 1ª ordem a um impulso de magnitude B. ..................................................... 26
Figura 6. Resposta de um processo de 1ª ordem a um pulso (P = 1, tw = 2). ........................................................... 28
Figura 7. Resposta de um processo de 1ª ordem a um pulso (P = 3, tw = 4). ........................................................... 28
Figura 8. Resposta de um processo de 1ª ordem à rampa (u’(t) = 0,5t). .................................................................. 30
Figura 9. Resposta de um processo de 1ª ordem ao seno. ....................................................................................... 31
Figura 10. Resposta de um processo de 2ª ordem a um degrau unitário. ................................................................. 33
Figura 11. Resposta de um processo de 2ª ordem a um degrau de magnitude M. .................................................... 33
Figura 12. Respostas ao degrau de um processo de 2ª ordem em função de ξ. ........................................................ 34
Figura 13. Respostas ao degrau de um processo de 2ª ordem multicapacitativo. ..................................................... 36
Figura 14. Resposta de um processo de 2ª ordem a um impulso unitário. ............................................................... 37
Figura 15. Resposta de um processo de 2ª ordem a um pulso unitário. ................................................................... 39
Figura 16 – Processos de 2ª ordem com dinâmica no numerador. .......................................................................... 40
Figura 17 – Processos de 2ª ordem com resposta inversa (zero positivo). ............................................................... 41
Figura 18 – Tanque de nível com vazão de saída constante. ................................................................................... 42
Figura 19 – Resposta ao degrau de um processo do tipo integrador. ....................................................................... 43
Figura 20 – Respostas ao degrau de processos de 1ª e 2ª ordens com tempo morto. ................................................ 45
Figura 21: Diagrama de blocos de um sistema de controle feedback (Seborg et al., 2011). ..................................... 46
Figura 22 – Respostas em malha fechada de um processo de 1ª ordem a perturbações no set-point (a) e na carga (b).
................................................................................................................................................................. 49

LISTA DE TABELAS
Tabela 1. Parâmetros utilizados na simulação de um sistema de controle feedback genérico. .................................. 47

LISTA DE QUADROS
Quadro 1 – Processamento simbólico (AlgebraSimbolica.m)................................................................................... 9
Quadro 2 – Cálculo de integral simbólica (CalculoIntegral.m). ................................................................................ 9
Quadro 3 – Cálculo de derivada simbólica (CalculoDerivada.m). ............................................................................ 9
Quadro 4 – Representações de polinômios (OperacaoPolinomio.m). ..................................................................... 10
Quadro 5 – Avaliação de polinômios (ValorPolinomio.m)..................................................................................... 11
Quadro 6 – Multiplicação de polinômios (MultiplicacaoPolinomios.m). ................................................................ 11
Quadro 7 – Operações com polinômios (RaizesPolinomio.m)................................................................................ 11
Quadro 8 – Transformadas de Laplace (TransfLaplace.m). .................................................................................... 13
Quadro 9 – Transformadas de Inversa Laplace (FracParciaisCaso1.m). ................................................................. 14
Quadro 10 – Transformadas de Inversa Laplace (FracParciaisCaso2.m)................................................................. 15
Quadro 11 – Transformadas de Inversa Laplace (FracParciaisCaso3.m)................................................................. 16
Quadro 12 – Formas de representar uma função de transferência (RepresentacoesFT.m)........................................ 17
Quadro 13 – Pólos, zeros e ganho estacionário de uma função de transferência (PolosZerosGanhoFT.m). .............. 19
Quadro 14 – Adição e multiplicação de funções de transferência (OperacoesComFT.m). ....................................... 20
Quadro 15 – Resposta ao degrau de um sistema de 1ª ordem (RespDegrauSist1aOrdem.m). .................................. 23
Quadro 16 – Resposta ao degrau de um sistema de 1ª ordem especificando o tempo de resposta
(RespDegrauSist1aOrdem_TempoExtra.m). ............................................................................................... 24
Quadro 17 – Resposta ao impulso de um sistema de 1ª ordem (RespImpulsoSist1aOrdem.m). ............................... 25
Quadro 18 – Resposta ao pulso de um sistema de 1ª ordem (RespPulsoSist1aOrdem.m). ....................................... 27
Quadro 19 – Resposta ao à rampa de um sistema de 1ª ordem (RespRampaSist1aOrdem.m). ................................. 29
Quadro 20 – Resposta ao seno de um sistema de 1ª ordem (RespSenoSist1aOrdem.m). ......................................... 30
Quadro 21 – Resposta ao degrau de um sistema de 2ª ordem (RespDegrauSist2aOrdem.m). .................................. 32
Quadro 22 – Resposta ao degrau de um sistema de 2ª ordem (RespDegrauSist2aOrdemFormaPadrao.m). .............. 33
Quadro 23 – Resposta ao degrau de um sistema de 2ª ordem multicapacitativo
(RespDegrauSist2aOrdemMulticapacitativom.m). ...................................................................................... 35
Quadro 24 – Resposta ao impulso de um processo de 2ª ordem (RespImpulsoSist2aOrdem.m). ............................. 36
Quadro 25 – Resposta ao pulso de um processo de 2ª ordem (RespPulsoSist2aOrdem.m). ..................................... 37
Quadro 26 – Resposta ao degrau de processos de 2ª ordem (RespDegrauSist2aOrdemComZeros.m). ..................... 39
Quadro 27 – Resposta (RespDegrauSit2aOrdemRespInversa.m). .......................................................................... 40
Quadro 28 – Resposta (RespDegrauProcessoIntegrador.m). .................................................................................. 42
Quadro 29 – Resposta ao degrau de um processo de 1ª ordem com tempo morto
(RespDegrauSist1aOrdemTempoMorto.m). ............................................................................................... 44
Quadro 30 – Código no Octave para problemas de controle servo (ControleFeedback_ProbServo.m). ................... 47
Quadro 31 – Código no Octave para problemas de controle regulador (ControleFeedback_ProbRegulador.m). ...... 48

1 NOTAS SOBRE O OCTAVE
O GNU Octave ou, simplesmente, Octave foi escrito por John W. Eaton (1988) e
possui compatibilidade quase integral com o Matlab, possuindo um grande número de
funções representadas de forma idêntica.
O Octave é uma linguagem computacional desenvolvida para computação
matemática. Possui uma interface em linha de comando para a solução de problemas
numéricos e também uma interface gráfica. Esse software faz parte do projeto GNU e é um
software livre sob os termos da licença GPL.
O Octave é uma linguagem de programação de alto nível, programada inicialmente
para o cálculo numérico. Fornece uma linha de comando conveniente para resolver
problemas que envolvem cálculo numérico e executa outras tarefas numéricas usando uma
linguagem que é bastante compatível com o Matlab. O Octave também possui ferramentas
para a resolução de problemas lineares numéricos comuns de álgebra, cálculo aproximado
de raízes de equações não-lineares, funções ordinárias, polinômios, cálculo de integrais,
integração numérica de equações diferenciais ordinárias e diferenciais-algébricas. O
Octave pode ser facilmente expandido e adaptado através de funções definidas pelo
usuário, escritas na própria linguagem ou usando módulos dinamicamente carregados
escritos em outras linguagens como C++, em C, em Fortran.
1.1 Instalação dos Pacotes: A versão atual (6.1.0 - Nov-2020)

A Maioria dos pacotes (packages) do Octave já vem instalada com a versão 6.1.0.
Para verificar os pacotes instalados, digite o seguinte comando na Janela de Comandos:
>> pkg list
1.2 Atualização da lista de Pacotes

Todos os pacotes podem ser atualizados para a versão mais recente executando o
seguinte comando na Janela de Comandos:
>> pkg update
1.3 Instalação de Pacotes Adicionais

O Octave Forge é uma coleção de pacotes de alta qualidade para o GNU Octave,
semelhante às toolboxes do Matlab. Para instalar pacotes extras, execute o seguinte
comando na Janela de Comandos:
>> pkg install -forge nome do pacote
A lista com os pacotes está disponível em: https://octave.sourceforge.io/packages.php
1.3.1 Instalando Pacotes Adicionais

Na disciplina de Controle de Processos – IT 359, nós faremos uso do pacote de
controle, que já é instalado automaticamente na versão 6.1.0 do Octave.
Contudo, há outro pacote que também será necessário nessa disciplina e que deve ser
instalado manualmente. Esse pacote é o de processamento de sinais.

1.3.1.1 Instalando o pacote de processamento de sinais
Para instalar esses pacotes, use o procedimento padrão de instalação, digitando os
seguintes comandos na Janela de Comandos:
>> pkg install -forge signal
1.3.1.2 Instalando o pacote de processamento simbólico

Para instalar este pacote, o mais recomendado é baixar o arquivo de instalação
completo e instalá-lo a partir do próprio Octave, da seguinte forma:
1. Procure na internet (google, por exemplo) por “symbolic octave bundle”.
2. Geralmente, a primeira opção é a página GitHub:
https://github.com/cbm755/octsympy/releases
3. Procure pelo arquivo “symbolic-win-py-bundle-2.9.0.tar.gz” e baixe em uma
pasta do seu computador.
4. Abra o Octave e navegue até a pasta onde o arquivo foi salvo.
5. Digite os seguintes comandos na Janela de Comandos para instalar o pacote
symbolic:
>> pkg install symbolic-win-py-bundle-2.9.0.tar.gz
1.4 Habilitação dos Pacotes

Vários pacotes já foram incluídos com o Octave, no entanto, eles devem ser
CARREGADOS a cada inicialização do software. Para carregar qualquer pacote, digite o
seguinte comando na Janela de Comandos:
>> pkg load nome do pacote
Por exemplo, para carregar os pacotes necessários para a disciplina de controle de

processos (IT359) digite na Janela de Comandos:
>> pkg load control

>> pkg load signal
>> pkg load symbolic
1.5 Funções Específicas de Cada Pacote

O Octave tem uma lista de funções específicas para cada pacote, que podem ser
visualizadas na documentação do software ou na página do Octave Forge:
▪ pkg control: https://octave.sourceforge.io/control/overview.html

▪ pkg signal: https://octave.sourceforge.io/signal/overview.html
▪ pkg symbolic: https://octave.sourceforge.io/symbolic/overview.html

2 RECURSOS AUXILIARES
2.1 Trabalhando com Álgebra Simbólica

O processamento de funções com álgebra simbólica pode ser útil em etapas
preliminares da execução de algumas técnicas de controle de processos.
2.1.1 Cálculo analítico da integral de uma função
Quadro 1 – Processamento simbólico (AlgebraSimbolica.m).

clearvars
clc
syms x; % Definine a variável "x" como simbólica
f=cos(2*x); % define a função a ser integrada

printf('A função f(x) é: \n'), disp(f)
disp(' ')
==================== RESULTADO =========================

A função f(x) é:
cos(2*x)
Outra opção para definir uma função é usar o comando “sym”, conforme exemplo
abaixo:
Quadro 2 – Cálculo de integral simbólica (CalculoIntegral.m).

syms t; % Definine a variável "t" como simbólica
f=sym('exp(-2*t)');
printf('A função f(t) a ser integrada é: \n'), disp(f)
disp(' ')
int_f=int(f,t); % Avalia a integral da função

printf('A integral de f(t) é: \n'), disp(int_f)
disp(' ')
==================== RESULTADO =========================

A função f(t) a ser integrada é:
-2*t
e
A integral de f(t) é:
-2*t
-e
-------
2
2.1.2 Cálculo analítico da derivada de uma função
Quadro 3 – Cálculo de derivada simbólica (CalculoDerivada.m).

clearvars
clc
syms x; % Definine a variável "x" como simbólica

f=sym('a*x^2+b*x+c');
printf('A função f(x) a ser derivada é: \n'), disp(f)

disp(' ')

dp_dx=int(f); % Avalia a derivada da função
printf('A derivada de f(x) é: \n'), disp(dp_dx)
==================== RESULTADO =========================

A função f(x) a ser derivada é:
2
a*x + b*x + c
A derivada de f(x) é:
3 2
a*x b*x
---- + ---- + c*x
3 2
2.1.3 Operações com Polinômios

O Octave pode ser utilizado para analisar sistemas descritos por funções de
transferência. Como uma função de transferência é uma razão de polinômios, é importante
entender como o Octave trabalha com polinômios.
No Octave os polinômios são representados por vetores linhas contendo os
coeficientes do polinômio em ordem decrescente. Por exemplo, o polinômio:
P ( s ) = s 3 + 3s 2 + 4 (1)
deve ser registrado no Octave da forma: >> p = [1,2,0,4] (ou, p = [1 2 0 4])
Deve-se ficar atento para a necessidade de entrar com os coeficientes na ordem

decrescente e que, além disso, todos os coeficientes devem ser informados, inclusive os
nulos.
2.1.3.1 Conversão entre as formas simbólica e de coeficientes polinomiais

Quadro 4 – Representações de polinômios (OperacaoPolinomio.m).
clearvars
clc
p=[1 2 0 3]; % Coeficientes de um polinômio de 3a ordem

printf('Coeficientes de um polinômio: \n'), disp(p)
disp(' ')
sp=poly2sym(p);
printf('Representação algébrica (simbólica) do polinômio: \n'), disp(sp)
disp(' ')
pol=sym2poly(sp); % converts from symbolic back to polynomial

printf('Representação na forma polinomial: \n'), disp(pol)
==================== RESULTADO =========================

Coeficientes de um polinômio:
1 2 0 3
Representação algébrica (simbólica) do polinômio:

3 2
x + 2*x + 3
Representação na forma polinomial:

1 2 0 3
2.1.3.2 Cálculo do valor de um polinômio

A função polyval é usada para calcular o valor de um polinômio para certo valor
da variável. Por exemplo, o programa para calcular n(2) é apresentado do Quadro 5.

n ( s ) = 3s 3 + 14s 2 + 9s + 4 (1)
Quadro 5 – Avaliação de polinômios (ValorPolinomio.m).

clearvars
clc
p=[3,14,9,4]; % Coeficientes de um polinômio de 2a ordem

printf('Coeficientes de um polinômio, p(s):'), disp(p)
disp(' ')
valor=polyval(p,2); % Coeficientes de um polinômio de 1a ordem

printf('Valor do polinômio: '), disp(valor)
==================== RESULTADO =========================

Coeficientes de um polinômio, p(s): 3 14 9 4
Valor do polinômio: 102
2.1.3.3 Multiplicação de polinômios

A multiplicação de polinômios é feita utilizando-se a função conv. Por exemplo, a
operação abaixo é feita como ilustrado no Quadro 6.
n ( s ) = ( 3s 2 + 2s + 1) ( s + 4 ) (2)
Quadro 6 – Multiplicação de polinômios (MultiplicacaoPolinomios.m).

clearvars
clc
p=[3,2,1]; % Coeficientes de um polinômio de 2a ordem

printf('Coeficientes de um polinômio, p(s): \n'), disp(p)
disp(' ')
q=[1,4]; % Coeficientes de um polinômio de 1a ordem
printf('Coeficientes de um polinômio, q(s): \n'), disp(q)
disp(' ')
n=conv(p,q); % multiplica os polinômios p e q

printf('Coeficientes do polinômio n(s)=p(s)*q(s): \n'), disp(n)
disp(' ')
sp=poly2sym(n);
printf('Representação algébrica do polinômio: \n'), disp(sp)
disp(' ')
==================== RESULTADO =========================
Coeficientes de um polinômio, p(s): 3 2 1
Coeficientes de um polinômio, q(s): 1 4
Coeficientes do polinômio n(s)=p(s)*q(s): 3 14 9 4
Representação algébrica do polinômio:

3 2
3*x + 14*x + 9*x + 4
2.1.3.4 Raízes de polinômios

Se p é um vetor linha contendo os coeficientes de p(s) em ordem decrescente, então
roots(p) é um vetor coluna contendo as raízes do polinômio.
Por outro lado, se r é um vetor coluna contendo as raízes do polinômio, então
poly(r) é um vetor linha contendo os coeficientes do polinômio em ordem decrescente.
Quadro 7 – Operações com polinômios (RaizesPolinomio.m).

clearvars
clc

p=[1,3,0,4]; % Coeficientes de um polinômio de 3a ordem
printf('Coeficientes de um polinômio, p(s): \n'), disp(p)
disp(' ')
r=roots(p); % calcula as raízes do polinômio

printf('Raízes de p(s): \n'), disp(r)
disp(' ')
pol=poly(r); % converte à forma polynomial a partir das raízes

printf('O polinômio cujas raízes sã dadas acima é: \n'), disp(pol)
==================== RESULTADO =========================

Coeficientes de um polinômio, p(s):
1 3 0 4
Raízes de p(s):
-3.35530 + 0.00000i
0.17765 + 1.07730i
0.17765 - 1.07730i
O polinômio cujas raízes são dadas acima é:

1.0000e+00 3.0000e+00 -8.8818e-16 4.0000e+00

3 TRANSFORMADAS DE LAPLACE
3.1 Transformada de Laplace

A Transformada de Laplace é uma ferramenta bastante útil para o entendimento dos
conceitos e para a aplicação da teoria de controle de processos, pois permite o
desenvolvimento de representações dinâmicas bastante simples dos processos. Além disso,
a Transformada de Laplace apresenta as seguintes características:
1. É a notação padrão para o estudo da teoria de controle clássico de processos;
2. Converte equações diferenciais ordinárias em equações algébricas, facilitando a sua
resolução;
3. É adequada para a representação de sistemas e análise em diagrama de blocos;
4. É fundamental para a representação de processos na forma de funções de transferência;
5. Permite a análise de estabilidade de sistemas de controles lineares através da resposta
no domínio da frequência
6. É uma técnica adequada para a predição da resposta transiente para diferentes entradas
e para o projeto de sistemas de controle.
Quadro 8 – Transformadas de Laplace (TransfLaplace.m).

clearvars
clc
% laplace: Transformada de Laplace "simbólica"

% ilaplace: Tansformada inversa de Laplace "simbólica"
% Definindo uma função no domínio do tempo: f(t) = e(-at)

f=sym('exp(-2*t)');
disp('Função no domínio do tempo:')
disp(f)
disp(' ')
disp('Transformada de Laplace de f(t):')

F=laplace(f);
disp(F)
disp(' ')
disp('Transformada Inversa de Laplace de F(s):')

f=ilaplace(F);
disp(f)
==================== RESULTADO =========================

Função no domínio do tempo:
-2*t
e
Transformada de Laplace de f(t):

1
-----
s + 2
Transformada Inversa de Laplace de F(s):

-2*t
e
3.2 Transformada Inversa de Laplace – Método das Frações Parciais

A função do Octave empregada para realizar a expansão em frações parciais (Método
de Heaviside) é a residue.
Esta função tem como entradas os polinômios do numerador e denominador da
função de transferência, N(s) e D(s), respectivamente e como saídas os parâmetros das
funções parciais:
N (s) N
cn I
= +  ki s I −i
D (s)
(3)
( s − pn )
en
n =1 i =1
em que, cn são os coeficientes das frações parciais; pn são as raízes ou pólos de D(s); en é a
multiplicidade das raízes ou pólos de D(s) e ki são os termos constantes da expansão.
3.2.1 O Polinômio D(s) Possui Raízes Reais e Distintas

Considere o exemplo da inversão da função de transferência descrita nas Notas de
Aula “Cap3_1-TransformadasLaplace.pdf”, página 13.
N (s) s2 − s − 6
Y (s) = = (4)
D ( s ) s 3 − 2s 2 − s + 2
Quadro 9 – Transformadas de Inversa Laplace (FracParciaisCaso1.m).

clearvars
clc
disp('Definindo uma Função de Transferência, G(s)=N(s)/D(s)')

% N(s) = s^2 - s - 6
% D(s) = s^3 - 2*s^2 - s + 2
N=[1 -1 -6];
D=[1 -2 -1 2];
FT=tf(N,D)
disp(' ')
[c,p,k,e]=residue(N,D);
printf('Coeficientes das frações parciais (c_n): \n'), disp(c)
disp(' ')
printf('Raízes ou pólos de D(s) (p_n): \n'), disp(p)
disp(' ')
printf('Multiplicidade das raízes de D(s) (e_n): \n'), disp(e)
disp(' ')
printf('Termos constantes da expansão (k_i): \n'), disp(k)
==================== RESULTADO =========================

Transfer function 'FT' from input 'u1' to output ...
s^2 - s - 6
y1: -------------------
s^3 - 2 s^2 - s + 2
Continuous-time model.
Coeficientes das frações parciais (c_n):

-1.33333
3.00000
-0.66667
Raízes ou pólos de D(s) (p_n):

2.00000
1.00000
-1.00000
Multiplicidade das raízes de D(s) (e_n):

1
1
1
Termos constantes da expansão (k_i):

[](0x0)

3.2.2 O Polinômio D(s) Possui Raízes Complexas
N (s) 3
Y (s) = =
D (s) s ( s 2 + 2s + 5 )
(5)

clearvars
clc

% N(s) = 3
% D(s) = s(s^2+2*s+5)
N=3;
D=conv([1 0],[1 2 5]);
FT=tf(N,D)
disp(' ')
disp(' ')
disp(' ')
disp(' ')
==================== RESULTADO =========================

Transfer function 'FT' from input 'u1' to output ...
3
y1: -----------------
s^3 + 2 s^2 + 5 s

-0.30000 + 0.15000i
-0.30000 - 0.15000i
0.60000 + 0.00000i

-1 + 2i
-1 - 2i
0 + 0i

1
1
1

[](0x0)
3.2.3 O Polinômio D(s) Possui Raízes Reais e Iguais

N (s) 2
Y (s) = =
D (s)
(6)
s ( s + 1)
3

clearvars
clc

% N(s) = 2
% D(s) = ((s+1)^3)s
N=2;
D=conv(conv(conv([1 1],[1 1]),[1 1]),[1 0]);
FT=tf(N,D)
disp(' ')
disp(' ')
disp(' ')
disp(' ')
==================== RESULTADO =========================

㾨Transfer function 'FT' from input 'u1' to output ...
2
y1: -----------------------
s^4 + 3 s^3 + 3 s^2 + s

-2.0000
-2.0000
-2.0000
2.0000

-1.00000
-1.00000
-1.00000
0.00000

1
2
3
1

[](0x0)

4 FUNÇÕES DE TRANSFERÊNCIA
4.1 Introdução
Uma Função de Transferência (FT) é uma equação algébrica que representa a
relação dinâmica entre uma entrada e uma saída do processo, representado por seu modelo
matemático. Os modelos na forma de função de transferência usam as transformadas de
Laplace. Estas transformadas são muito usadas em controle de processos, já que permitem
o desenvolvimento de representações dinâmicas bastante simples de processos químicos.
Elas transformam equações diferenciais lineares ou linearizadas em equações algébricas,
com as quais é muito mais fácil trabalhar, permitem uma análise rápida da dinâmica do
processo e fornecem uma relação direta entre as entradas e saídas do processo. Dessa
forma, uma função de transferência caracteriza as relações de entrada-saída de sistemas e
processos que podem ser descritos por equações diferenciais lineares ou linearizadas.
A função de transferência de um sistema linear, G(s), é definida como a relação entre
a transformada de Laplace do sinal de saída, Y’(s), e a transformada de Laplace do sinal de
entrada, F’(s), ambas definidas em termos de variáveis desvio e com condições iniciais
nulas, ou seja:
Y ' (s )
G(s ) = (7)
F ' (s )
onde Y’(s) é a transformada de Laplace da saída e U’(s) é a transformada de Laplace da
entrada.
Em geral, a função de transferência G(s) é a razão de dois polinômios:
N (s ) bm s m + bm−1s m−1 +  + b1s + b0

G(s ) = = (8)
D(s ) an s n + an−1s n−1 +  + a1s + a0
4.2 Trabalhando com Funções de Transferência

4.2.1 Representações de uma função de transferência
As funções de transferência podem ser representadas de diferentes formas no Octave,
como segue:
Quadro 12 – Formas de representar uma função de transferência (RepresentacoesFT.m).

% Disciplina Controle de Processos - IT359
% Prof. Dr. Luiz Augusto C. Meleiro (meleiro@ufrrj.br) - DEQ/IT/UFRRJ
clearvars
clc
disp('Representação na forma de Função de Transferência, a partir de N(s) e D(s):')

N=[6 0 -12];
D=[1 1 -4 -4];
G=tf(N,D) % Cria a Função de Transferência G(s)
disp(' ')
disp('Representação na forma zeros, pólos e razão b_m/a_n:')

[zeros,polos,r]=tf2zp(N,D);
printf('Pólos da FT (p_i): \n'), disp(polos)
disp(' ')
printf('Zeros da FT (z_j): \n'), disp(zeros)

disp(' ')
printf('Razão b_m/a_n da FT: \n'), disp(r)
disp(' ')
disp('Representação na forma de N(s) e D(s):')

[N,D]=zp2tf(zeros,polos,r)
disp('Escreve a FT a partir de zeros, pólos e razão b_m/a_n da FT:')

disp('Representação na forma de N(s) e D(s):')
z=[];
p=[0,-1,-2,-3];
r=4;
G2=zpk(z,p,r)
disp(' ')
disp('Forma Equivalente:')
N=4;
D=[1,6,11,6,0];
G2=tf(N,D)
==================== RESULTADO =========================

Representação na forma de Função de Transferência, a partir de N(s) e D(s):
Transfer function 'G' from input 'u1' to output ...
6 s^2 - 12
y1: -------------------
s^3 + s^2 - 4 s - 4
Representação na forma zeros, pólos e razão b_m/a_n:

Pólos da FT (p_i):
2.00000
-2.00000
-1.00000
Zeros da FT (z_j):
-1.4142
1.4142
Razão b_m/a_n da FT:

6
Representação na forma de N(s) e D(s):

N =
6.0000e+00 1.3323e-15 -1.2000e+01
D =
1.0000 1.0000 -4.0000 -4.0000
Escreve a FT a partir de zeros, pólos e razão b_m/a_n da FT:

Representação na forma de N(s) e D(s):
Transfer function 'G2' from input 'u1' to output ...
4
y1: --------------------------
s^4 + 6 s^3 + 11 s^2 + 6 s
Forma Equivalente:
4
y1: --------------------------
s^4 + 6 s^3 + 11 s^2 + 6 s

4.2.2 Cálculo dos pólos, zeros e ganho estacionário
Quadro 13 – Pólos, zeros e ganho estacionário de uma função de transferência
(PolosZerosGanhoFT.m).
clearvars
clc
% Criando a Função de Transferência:

N=[6 0 -12];
D=[1 1 -4 -4];
G=tf(N,D) % Cria a Função de Transferência G(s)
disp(' ')
% Calcula zeros, pólos e razão b_m/a_n da FT:')

[zeros,polos,r]=tf2zp(N,D);
disp(' ')
disp(' ')
printf('Razão b_m/a_n da FT: \n'), disp(r)
disp(' ')
% Calcula o Ganho Estacionário de G(s):

K = dcgain(G);
printf('Ganho Estacionário (K): \n'), disp(K)
disp(' ')
disp('------ Alternativamente ---------')

% Calcula os pólos de G(s):
polos=pole(G);
disp(' ')
% Calcula os pólos de G(s):

polos=roots(D);
disp(' ')
% Calcula os zeros de G(s):')

zeros=roots(N);
disp(' ')
==================== RESULTADO =========================

Transfer function 'G' from input 'u1' to output ...
6 s^2 - 12
y1: -------------------
s^3 + s^2 - 4 s - 4
Pólos da FT (p_i):
2.00000
-2.00000
-1.00000
Zeros da FT (z_j):
-1.4142
1.4142
Razão b_m/a_n da FT:

6
Ganho Estacionário (K):

3
------ Alternativamente ---------

Pólos da FT (p_i):
2.00000
-2.00000

-1.00000
Pólos da FT (p_i):
2.00000
-2.00000
-1.00000
Zeros da FT (z_j):
-1.4142
1.4142
4.2.3 Operações com funções de transferência

Quadro 14 – Adição e multiplicação de funções de transferência (OperacoesComFT.m).
clearvars
clc
disp('Criando a Função de Transferência G1(s)')

N1=1;
D1=[1 1];
G1=tf(N1,D1)
disp(' ')
disp('---------------')
disp('Criando a Função de Transferência G2(s)')

N2=2;
D2=[1 2];
G2=tf(N2,D2)
disp(' ')
disp('---------------')
disp('Adição de duas Funções de Transferência no Matlab: G1(s)+G2(s)')

G3=G1+G2
disp(' ')
disp('---------------')
disp('Multiplicação de duas Funções de Transferência no Matlab: G1(s)*G2(s)')

G4=G1*G2
==================== RESULTADO =========================
Criando a Função de Transferência G1(s)
1
y1: -----
s + 1
---------------
Criando a Função de Transferência G2(s)
2
y1: -----
s + 2
---------------
Adição de duas Funções de Transferência no Matlab: G1(s)+G2(s)
3 s + 4
y1: -------------
s^2 + 3 s + 2

---------------
Multiplicação de duas Funções de Transferência no Matlab: G1(s)*G2(s)
2
y1: -------------
s^2 + 3 s + 2

5 COMPORTAMENTO DINÂMICO EM MALHA ABERTA
O estudo do comportamento dinâmico em malha aberta – ou seja, sem a presença

de controladores – consiste na simulação de um processo para avaliar a sua resposta a
partir de diferentes tipos de entradas. As entradas mais comumente empregadas nesse
estudo são do tipo degrau, pulso, impulso e rampa, além das entradas periódicas,
tipicamente do tipo senoidal. Contudo, a combinação de duas ou mais entradas, assim
como a avaliação da resposta de um processo a outros tipos de entradas além dessas
também fazem parte do estudo do comportamento dinâmico de processos.
A avaliação das respostas de diferentes tipos de processos fornece conhecimento
essencial para o projeto adequado de controladores e a obtenção de respostas estáveis em
malha fechada.
5.1 Respostas Dinâmicas de Processos de 1ª Ordem

Um sistema de primeira ordem é aquele cuja saída y(t) é modelada por uma equação
diferencial de primeira ordem. Então, no caso de um sistema linear ou linearizado, temos:
dy(t )
a1 + a0 y (t ) = bf (t ) (9)
dt
onde f(t) é a entrada do sistema. Se a0  0, então a equação acima pode ser escrita como:
a1 dy(t )
+ y (t ) = f (t )
b
a0 dt a0
(10)
Definindo  p = a1 e K p = b , obtém-se:
a0 a0
dy(t )
p + y (t ) = K p f (t ) (11)
dt
A constante p é conhecida como a constante de tempo do processo (e tem unidade

de tempo) e Kp é chamado de ganho estacionário do processo.
Reescrevendo a equação anterior em termos de variáveis desvio, obtém-se:
dy(t )
p + y(t ) = K p f (t ) (12)
dt
Aplicando a Transformada de Laplace na EDO linear (ou linearizada), chega-se a:
 p sY (s ) + Y (s ) = K p F (s )  Y (s )( p s + 1) = K p F (s ) (13)
Logo, a Função de Transferência de um processo de primeira ordem é:
Y (s ) Kp
G(s ) = =
F (s )  p s + 1
(14)

O comportamento dinâmico de sistemas de 1ª ordem (e de ordem superior) pode ser
estudado a partir de sua função de transferência. Apresentam-se a seguir as respostas no
tempo de sistemas de 1ª ordem frente a alguns tipos de perturbação na variável de entrada,
F’(s):
5.1.1 Resposta de processos de 1ª ordem ao degrau

Se um sistema de 1ª ordem sofre uma perturbação degrau de magnitude M em sua
entrada, ou seja, F’(s) = M/s, a sua resposta, Y’(s), pode ser explicitada da forma:
Kp
Y (s ) =
M
(15)
 ps +1 s
A resposta ao degrau deste sistema é obtida a partir do cômputo da transformada

inversa da equação acima e é dada por:
  − t 
y(t ) = K p M 1 − exp   (16)
 
  p 
A resposta ao degrau de um sistema de 1ª ordem pode ser obtida no Octave de

acordo com o código descrito no Quadro 15:
Quadro 15 – Resposta ao degrau de um sistema de 1ª ordem (RespDegrauSist1aOrdem.m).

% Prof. Luiz Augusto C. Meleiro - meleiro@ufrrj.br - DEQ/IT/UFRRJ
% IT 359 - Controle de Processos - 2020
% Resposta ao degrau de um sistema de 1a ordem
% USO DA FUNÇÃO "step"
clear all
clc
close all % Fecha todas as figuras abertas
Kp=1; % Ganho estacionário do processo de 1a ordem

taup=5; % Constante de tempo do processo de 1a ordem
N=Kp; % Numerador da função de transferência

D=[taup 1]; % Denominador da função de transferência
G=tf(N,D); % Obtendo a função de transferência
% ----------------------------------------------------------------
% Aplicando um pulso UNITÁRIO
[y,t]=step(G);
figure
plot(t,y,'LineWidth',2)
grid
title('Resposta de um Processo de 1â Ordem a um Degrau Unitário')
xlabel('t')
ylabel('y^,(t)')
print -djpg degrau1_sist1.jpg % Salvando a figura no formato png
% ----------------------------------------------------------------
% Aplicando um degrau de magnitude M ao processo
M=5; % Magnitude do degrau
[y2,t2]=step(M*G); % Aplicando um degrau unitário ao processo
figure
plot(t2,y2,'r','LineWidth',2)
grid
title('Resposta de um Processo de 1â Ordem a um Degrau de Magnitude M')
xlabel('t')
ylabel('y^,(t)')

print -djpg degrau5_sist1.jpg
==================== RESULTADO =========================
Os resultados são apresentados na forma gráfica na Figura 1 e na Figura 2.
Figura 1. Resposta de um processo de Figura 2. Resposta de um processo de

1ª ordem a um degrau unitário. 1ª ordem a um degrau de magnitude M.
A função step, por padrão, traça a resposta com o tempo necessário para o processo
atingir o estado estacionário, o que corresponde a aproximadamente cinco constantes de
tempo para sistemas de 1ª ordem. No entanto, é possível obter a resposta ao degrau (ou a
qualquer outra entrada), definindo o tempo da simulação arbitrariamente por meio de um
parâmetro extra na chamada da função. Um exemplo dessa aplicação segue no Quadro 16.
Quadro 16 – Resposta ao degrau de um sistema de 1ª ordem especificando o tempo de

resposta (RespDegrauSist1aOrdem_TempoExtra.m).
% USO DA FUNÇÃO "step"
clear all
clc


% Aplicando um degrau com tempo especificado pelo usuário

ti=0; % Tempo inicial da simulação
tf=50; % Tempo final da simulação
h=0.1; % Incremento no vetor de tempo
t=ti:h:tf; % Vetor do tempo de simulação

[y3,t3]=step(M*G,t); % Aplicando um degrau unitário ao processo
figure
subplot(2,1,1)
plot(t3,y3,'b','LineWidth',2)
grid
xlabel('t')
ylabel('y^,(t)')
print -djpg degrau50_sist1.jpg
==================== RESULTADO =========================
Os resultados são apresentados na forma gráfica na Figura 3.

Figura 3. Resposta de um processo de 1ª ordem a um degrau de magnitude M.
5.1.2 Resposta de processos de 1ª ordem ao impulso

Um impulso é caracterizado pela adição de certa quantidade de massa ou energia ao
sistema em um tempo muito curto, Δt → 0. Matematicamente o impulso é definido pela
função delta de Dirac, δ(t):
 0, t  0

f (t ) =  (t ) =  , t = 0 (17)
 0, t  0

Para um impulso de magnitude B, tem-se:
f (t ) =  (t ) = B  L (t ) = F (s ) = B (18)
Assim, se um sistema de 1ª ordem sofre uma perturbação do tipo impulso de

magnitude B em sua entrada, a sua resposta no domínio de Laplace, Y’(s), é:
Kp
Y (s ) = B (19)
 ps + 1
A resposta ao impulso deste sistema é obtida a partir do cômputo da transformada

K pB  −t 
y(t ) = exp  (20)
p  
 p
A resposta ao impulso de um sistema de 1ª ordem pode ser obtida no Octave de

Quadro 17 – Resposta ao impulso de um sistema de 1ª ordem

(RespImpulsoSist1aOrdem.m).
% USO DA FUNÇÃO "impulse"
clear all
clc

taup=0.5; % Constante de tempo do processo de 1a ordem

G=tf(N,D) % Obtendo a função de transferência
% ----------------------------------------------------------------
% Aplicando um impulso UNITÁRIO
[y,t]=impulse(G); % Aplicando um impulso unitário ao processo
figure
grid
title('Resposta de um Processo de 1â Ordem a um Impulso Unitário','fontsize',14)
xlabel('t','fontsize',14)
ylabel('y^,(t)','fontsize',14)
print -djpg impulso1_sist1.jpg % Salvando a figura no formato png
% ----------------------------------------------------------------
% Aplicando um impulso de magnitude B ao processo
B=5; % Magnitude do impulso
[y2,t2]=impulse(B*G);
figure
grid
title('Resposta de um Processo de 1â Ordem a um Impulso de Magnitude B')
xlabel('t')
ylabel('y^,(t)')
print -djpg impulso5_sist1.jpg
==================== RESULTADO =========================

1ª ordem a um impulso unitário. 1ª ordem a um impulso de magnitude B.
5.1.3 Resposta de processos de 1ª ordem ao pulso

Na prática, a perturbação do tipo impulso é infactível e a melhor aproximação
possível para esta perturbação é a aplicação de um pulso. A função pulso de magnitude P e
duração tw é descrita matematicamente pela equação abaixo.
 0, t0

f (t ) =  P, 0  t  t w  L f (t ) = F (s ) = 1 − exp(− tw s )
P
(21)
 0, s
 t  tw

Assim, se um sistema de 1ª ordem sofre uma perturbação do tipo pulso de magnitude
P e duração tw em sua entrada, a sua resposta no domínio de Laplace é:
Kp
Y (s ) =
P
1 − exp(− tw s ) (22)
 ps +1 s
A resposta ao pulso deste sistema é obtida a partir do cômputo da transformada

  t   −t   − t 
y(t ) = KpP exp  w  exp   − exp   (23)
     
   p    p   p 
Embora não haja uma função nativa no Octave para simular uma entrada do tipo
pulso, é possível usar a função lsim para simular a resposta de modelos lineares (LTI,
Linear Time Invariant) a praticamente qualquer tipo de entrada arbitrária.
A resposta ao pulso de um sistema de 1ª ordem foi obtida no Octave por meio dessa
função (lsim) e o código descrito no Quadro 18:
Quadro 18 – Resposta ao pulso de um sistema de 1ª ordem (RespPulsoSist1aOrdem.m).

% Resposta ao pulso de um sistema de 1a ordem
% ****************************************************************
% USO DA FUNÇÃO "lsim" para definir outros tipos de perturbação
% ****************************************************************
clear all
clc
close all


% Definindo a perturbação PULSO:

P=1; % Magnitude do pulso
tw=2; % Duração do Pulso
t0=1; % Início do Pulso
twf=tw+t0; % Fim do Pulso
u=zeros(size(t)); % Vetor de entrada de mesmo tamanho do tempo de simulação
u(t0/h:twf/h)=P; % Período de duração do Pulso
y=lsim(G,u,t); % Simulação da resposta ao pulso
figure
subplot(2,1,1)
stairs(t,u,'r','LineWidth',2);
legend('Perturbação do tipo Pulso')
ylabel('u^,(t)','fontsize',14)
subplot(2,1,2)
plot(t,y,'LineWidth',2);
grid
legend('Resposta de um Processo de 1â Ordem')

print -djpg P3tw5_sist1.jpg % Salvando a figura no formato png
figure
stairs(t,u,'r','LineWidth',2);
hold
plot(t,y,'b','LineWidth',2);
grid
legend('Perturbação do tipo Pulso','Resposta de um Processo de 1â Ordem')
ylabel('u^,(t) e y^,(t)','fontsize',14)
print -djpg P3tw5_sist1b.jpg % Salvando a figura no formato png
==================== RESULTADO =========================


1ª ordem a um pulso (P = 1, tw = 2). 1ª ordem a um pulso (P = 3, tw = 4).
5.1.4 Resposta de processos de 1ª ordem à rampa

A aproximação matemática deste tipo de perturbação nas variáveis de entrada é feita
por meio da função rampa, definida da seguinte forma:
0 t  0
f (t ) =  (24)
at t  0
cuja transformada de Laplace é:
F (s ) =
a
(25)
s2
Assim, a sua resposta no domínio de Laplace pode ser explicitada da forma:
Kp K p a p2 K p a p K p a
Y (s ) =  Y (s ) =
a
− + 2 (26)
 ps + 1 s2  ps + 1 s s
A resposta deste sistema no domínio do tempo a uma perturbação do tipo rampa é

obtida a partir do cômputo da transformada inversa da equação acima e é dada por:

 −t  
y(t ) = K P a p exp   − 1 + K P at (27)
 
   p  
Para valores elevados de tempo (t >> τp), a equação acima pode ser aproximada por:
y(t )  K P a (t −  p ) (28)
A resposta à rampa de um sistema de 1ª ordem pode ser obtida no Octave de acordo

com o código descrito no Quadro 19:
Quadro 19 – Resposta ao à rampa de um sistema de 1ª ordem

(RespRampaSist1aOrdem.m).
% Resposta à rampa de um sistema de 1a ordem
% ****************************************************************
% ****************************************************************
clear all
clc
close all


% Definindo a perturbação rampa.

t0=1; % Início da rampa
tr=30; % Fim da rampa
a=0.5; % Inclinação da rampa
u(t0/h:tr/h)=a*t(t0/h:tr/h)-a*t(t0/h); % Período de duração da rampa
u(tr/h:length(t))=u(tr/h);
y=lsim(G,u,t); % Simulação da resposta ao pulso
figure
stairs(t,u,'b--','LineWidth',2)
hold
plot(t,y,'r','LineWidth',2);
grid
title('Resposta de um Processo de 1â Ordem a uma Rampa','fontsize',14)
legend('u(t) = at','y^,(t)')
print -djpg rampa_sist1.jpg % Salvando a figura no formato png
==================== RESULTADO =========================


Figura 8. Resposta de um processo de 1ª ordem à rampa (u’(t) = 0,5t).
5.1.5 Resposta de processos de 1ª ordem a perturbações periódicas

Uma perturbação do tipo seno com amplitude A e frequência angular 
(radianos/tempo) é definida da seguinte forma:
f (t ) = Asen (t ) (29)
A transformada de Laplace desta função é:
A
F ( s) = (30)
s + 2
2
e a sua resposta no domínio de Laplace pode ser explicitada da forma:
 K p  A 
Y (s ) =  
  s + 1  s 2 +  2  (31)
 p 
A resposta deste sistema no domínio do tempo, após um tempo suficientemente

longo é dada por:
KpA
y(t ) = y = sen(t +  ) (32)
t →  p2 2 + 1
ou
y (t ) = y = Aˆ sen(t +  ) (33)
t →
onde  = tg −1 (− p ) ( é o arco cuja tangente é -p) e Â é a amplitude da saída.
A resposta ao seno de um sistema de 1ª ordem pode ser obtida no Octave de acordo

Quadro 20 – Resposta ao seno de um sistema de 1ª ordem (RespSenoSist1aOrdem.m).

% Resposta ao seno de um sistema de 1a ordem
% ****************************************************************

% ****************************************************************
clear all
clc
close all


% Definindo a perturbação senoidal.

u=sin(t); % Vetor de entrada
y=lsim(G,u,t); % Simulação da resposta ao seno
figure
plot(t,u,'b--',t,y,'r','LineWidth',2);
grid
title('Resposta de um Processo de 1â Ordem a uma Perturbação Periódica','fontsize',14)
legend('u(t) = seno(t)','y^,(t)')
print -djpg seno_sist1.jpg % Salvando a figura no formato png
figure
subplot(2,1,1)
plot(t,u,'b--',t,y,'r','LineWidth',2);
grid
title('Resposta de um Processo de 1â Ordem a uma Perturbação Periódica','fontsize',14)
legend('u(t) = seno(t)','y^,(t)')
print -djpg seno_sist1b.jpg % Salvando a figura no formato png
==================== RESULTADO =========================

Figura 9. Resposta de um processo de 1ª ordem ao seno.
5.2 Respostas Dinâmicas de Processos de 2ª Ordem

Um sistema de segunda ordem é aquele cuja saída, y(t), é modelada por uma equação
diferencial de segunda ordem. No caso de um sistema linear ou linearizado, temos:
d 2 y(t ) dy(t )
a2 2
+ a1 + a0 y(t ) = bf (t ) (34)
dt dt
Reescrevendo a equação acima da forma padrão de sistemas de segunda ordem:

d 2 y(t ) dy(t )
2 + 2 + y(t ) = K p f (t ) (35)
dt 2 dt
a2 a b
onde  = , 2 = 1 e K p = .
2
a0 a0 a0
A função de transferência típica de sistemas de 2ª ordem é dada por:
Y ( s) K
G(s) = = 2 2 p (36)
F ( s)  s + 2s + 1
5.2.1 Resposta ao Degrau
A resposta ao degrau de um sistema de 2ª ordem pode ser obtida no Octave de

Quadro 21 – Resposta ao degrau de um sistema de 2ª ordem (RespDegrauSist2aOrdem.m).

clear all
clc
close all
% Sistema 1
D=[1 0.4 1]; % Denominador da função de transferência
% ----------------------------------------------------------------
[y,t]=step(M*G);
figure
grid
title('Resposta de um Processo de 2â Ordem a um Degrau Unitário','fontsize',14)
print -djpg degrau_sist2a.jpg % Salvando a figura no formato png

% ----------------------------------------------------------------
[y2,t2]=step(M*G,t);
figure
plot(t2,y2,'LineWidth',2)
grid
title('Resposta de um Processo de 2â Ordem a um Degrau M','fontsize',14)
print -djpg degrauM_sist2a.jpg % Salvando a figura no formato png

==================== RESULTADO =========================

2ª ordem a um degrau unitário. 2ª ordem a um degrau de magnitude M.
Os processos de 2ª ordem também podem ser definidos em função de seus

parâmetros, Kp, ξ e τ. O código para simular esses sistemas é descrito no Quadro 22:
Quadro 22 – Resposta ao degrau de um sistema de 2ª ordem

(RespDegrauSist2aOrdemFormaPadrao.m).
clear all
close all
clc
% Sistema 1
tau1=1;
csi1=2;
D=[tau1^2 2*csi1*tau1 1]; % Denominador da função de transferência
G1=tf(N,D); % Obtendo a função de transferência
% Sistema 2
tau2=1;
csi2=1;
% Sistema 3
tau3=1;
csi3=0.2;

tfim=30; % Tempo final da simulação
t=ti:h:tfim; % Vetor do tempo de simulação
[y1,t]=step(G1,t); % Aplicando um impulso unitário ao processo

figure

plot(t,y1,'b','LineWidth',2)
grid
hold
plot(t,y2,'r','LineWidth',2)
plot(t,y3,'g','LineWidth',2)
title('Resposta de Sistemas de 2â Ordem a um Degrau Unitário (K_p = 1)','fontsize',14)
legend('\xi = 2','\xi = 1','\xi = 0,2')
print -djpg degrau_sists2a_csi.jpg % Salvando a figura no formato png

figure
title('Resposta de Sistemas de 2â Ordem a um Degrau Unitário','fontsize',14)
subplot(3,1,1)
legend('\xi = 2')
grid
subplot(3,1,2)
legend('\xi = 1')
grid
subplot(3,1,3)
legend('\xi = 0,2')
grid
print -djpg degrau_sists2a_csib.jpg % Salvando a figura no formato png
==================== RESULTADO =========================
Figura 12. Respostas ao degrau de um processo de 2ª ordem em função de ξ.
5.2.1.1 Processos multicapacitativos

Os sistemas de 2ª ordem também podem surgir a partir de processos
multicapacitativos, que são sistemas formados por dois processos de 1ª ordem ligados em
série, através dos quais escoa massa ou energia. Um exemplo usual de tal sistema são dois
tanques de nível operando em série, onde se aplica a propriedade multiplicativa das
funções de transferência. Tais processos de segunda ordem apresentam a seguinte função
de transferência:

Y ( s) K p2
G( s) = =
F ( s) ( p1s + 1)( p 2 s + 1)
(37)
A sua equivalência com a equação anterior é obtida igualando-se as duas equações

características e equacionando os coeficientes dos termos em s:
 2 s 2 + 2s + 1 = ( p1s + 1)( p 2 s + 1) , logo,  2 =  p1 p 2 , 2 =  p1 +  p 2 e

 p1 +  p 2
=
2  p1 p 2
Os processos multicapacitativos de 2ª ordem também podem ser simulados no

Octave por meio do código descrito no Quadro 23:
Quadro 23 – Resposta ao degrau de um sistema de 2ª ordem multicapacitativo

(RespDegrauSist2aOrdemMulticapacitativom.m).
clear all
close all
clc
% Sistema 1
Kp1=1; % Ganho estacionário do processo de 1a ordem
taup1=0.5; % Constante de tempo do processo de 1a ordem
N1=Kp1;
D1=[taup1 1];
G1=tf(N1,D1)

taup2=1; % Constante de tempo do processo de 1a ordem
N2=Kp2;
D2=[taup2 1];
G2=tf(N2,D2)
G=G1*G2 % Função de transferência de 2a ordem (processo multicapacitativo)
% Alternativamente:
##D=conv([taup1 1],[taup2 1]); % Denominador da função de transferência
##G1=tf(N,D) % Obtendo a função de transferência

[y1,t1]=step(G1,t); % Aplicando um impulso unitário ao processo

[y2,t2]=step(G2,t); % Aplicando um impulso unitário ao processo
[y,t]=step(G,t); % Aplicando um impulso unitário ao processo
figure
subplot(2,1,1)
plot(t1,y1,'b','LineWidth',2)
grid
hold
plot(t,y,'g','LineWidth',2)
title('Resposta ao Degrau de um Sistema Multicapacitativo de 2â Ordem Sem
Interação','fontsize',14)
legend('Sitema de 1â Ordem 1 (\tau_p = 0,5)','Sitema de 1â Ordem 2 (\tau_p = 1)','Sitema
de 2â Ordem 2 (G1*G2)')

print -djpg degrau_sist_multicap.jpg
==================== RESULTADO =========================

Os resultados são apresentados na forma gráfica na Figura 13, na qual o processo de
2ª ordem é formado pela multiplicação das FT dos dois sistemas de 1ª ordem.
Figura 13. Respostas ao degrau de um processo de 2ª ordem multicapacitativo.
5.2.2 Resposta ao Impulso

A resposta ao impulso de um processo de 2ª ordem pode ser obtida no Octave de
Quadro 24 – Resposta ao impulso de um processo de 2ª ordem

(RespImpulsoSist2aOrdem.m).
% USO DA FUNÇÃO "impulse"
clear all
close all
clc
% Sistema 1
tau1=1;
csi1=2;
% Sistema 2
tau2=1;
csi2=1;
% Sistema 3
tau3=1;
csi3=0.2;


[y1,t]=impulse(G1,t); % Aplicando um impulso unitário ao processo
figure
grid
hold
title('Resposta de Sistemas de 2â Ordem a um Degrau Unitário (K_p = 1)','fontsize',14)
legend('\xi = 2','\xi = 1','\xi = 0,2')
print -djpg impulso_sists2a_csi.jpg % Salvando a figura no formato png

figure
title('Resposta de Sistemas de 2â Ordem a um Degrau Unitário','fontsize',14)
subplot(3,1,1)
legend('\xi = 2')
grid
subplot(3,1,2)
legend('\xi = 1')
grid
subplot(3,1,3)
legend('\xi = 0,2')
grid
print -djpg impulso_sists2a_csib.jpg % Salvando a figura no formato png
==================== RESULTADO =========================

Figura 14. Resposta de um processo de 2ª ordem a um impulso unitário.
5.2.3 Resposta ao Pulso

A resposta ao pulso de um processo de 2ª ordem pode ser obtida no Octave de acordo
Quadro 25 – Resposta ao pulso de um processo de 2ª ordem (RespPulsoSist2aOrdem.m).

%
clear all
close all
clc


P=1; % Magnitude do pulso
tw=2; % Duração do Pulso
t0=1; % Início do Pulso
twf=tw+t0; % Fim do Pulso
u(t0/h:twf/h)=P; % Período de duração do Pulso
##y=lsim(G,u,t); % Simulação da resposta ao pulso
% Sistema 1
D=[1 0.4 1]; % Denominador da função de transferência
G1=tf(N,D) % Obtendo a função de transferência
% Sistema 2
D=conv([taup1 1],[taup2 1]); % Denominador da função de transferência
y1=lsim(G1,u,t); % Simulação da resposta ao pulso

y2=lsim(G2,u,t); % Simulação da resposta ao pulso
figure
subplot(2,1,1)
stairs(t,u,'g','LineWidth',2);
legend('Perturbação do tipo Pulso')
ylabel('u^,(t)','fontsize',14)
subplot(2,1,2)
plot(t,y1,t,y2,'r','LineWidth',2);
grid
legend('Resposta de Sistemas de 2â Ordem')
print -djpg P1tw2_sist2.jpg % Salvando a figura no formato png
figure
title('Resposta de Processos de 2â Ordem ao Pulso','fontsize',14)
stairs(t,u,'g','LineWidth',2);
hold
plot(t,y1,'b',t,y2,'r','LineWidth',2);
grid
legend('Perturbação','Resposta do Processo 1','Resposta do Processo 2')
print -djpg P1tw2_sist2b.jpg % Salvando a figura no formato png
==================== RESULTADO =========================


Figura 15. Resposta de um processo de 2ª ordem a um pulso unitário.
5.3 Respostas Dinâmicas de Processos Mais Complexos

Alguns processos exibem comportamento distintos daqueles cujos modelos
matemáticos são descritos por EDOs de 1ª ou 2ª ordem típicos, ou seja, há processos
multicapacitativos que apresentam interação, processos com tempo morto, resposta
inversa, etc.
O comportamento dinâmico de alguns desses processos será ilustrado a seguir com
auxílio do Octave.
5.3.1 Processos Com Dinâmica no Numerador

Uma função de transferência com zeros significa que seu numerador é um polinômio em
s, N(s). Processos com esta propriedade são conhecidos pela dinâmica no numerador
(numerator dynamics), tendo em vista que este polinômio é responsável por imprimir certas
características à resposta global do processo. Contudo, a presença zeros na função de
transferência (modelo do processo) raramente influencia a estabilidade do processo.
As respostas ao degrau de três processos de 2ª ordem ilustrando o efeito qualitativo
dos zeros sobre suas dinâmicas podem ser obtidas no Octave de acordo com o código
descrito no Quadro 26:
Quadro 26 – Resposta ao degrau de processos de 2ª ordem

(RespDegrauSist2aOrdemComZeros.m).
%
clear all
close all
clc


N1=Kp1; % Numerador da função de transferência
D1=[1 0.4 1]; % Denominador da função de transferência
G1=tf(N1,D1) % Obtendo a função de transferência
[y1,t1]=step(G1,t);

Kp2=[1,1]; % Ganho estacionário do processo de 2a ordem
[y2,t2]=step(G2,t);
Kp3=[-1,1]; % Ganho estacionário do processo de 2a ordem

[y3,t3]=step(G3,t);
figure
subplot(2,1,1)
plot(t1,y1,'b:','LineWidth',2)
hold
plot(t2,y2,'r--','LineWidth',2)
plot(t3,y3,'g-.','LineWidth',3)
grid
legend('Processo de 2â Ordem','Processo de 2â Ordem com Zero Negativo',...
'Processo de 2â Ordem com Zero Positivo', "location", "southeast")
print -djpg degrau_sists2aZeros.jpg % Salvando a figura no formato png
==================== RESULTADO =========================

Figura 16 – Processos de 2ª ordem com dinâmica no numerador.
5.3.1.1 Processos com Resposta Inversa

Processos com resposta inversa apresentam zeros positivos em suas funções de
transferência. O principal efeito dos zeros positivos é inverter, inicialmente, a direção da
resposta do processo. Este comportamento é chamado de resposta inversa ou resposta de
fase não mínima.
As respostas ao degrau de dois processos de 2ª ordem com resposta inversa podem
ser obtidas no Octave de acordo com o código descrito no Quadro 27:
Quadro 27 – Resposta (RespDegrauSit2aOrdemRespInversa.m).

%
clear all
close all
clc
% ----- Sistemas com fator de amortecimento > 1 ----

% Função de transferência sem zeros:
num=[1];
den=[10 7 1];
G=tf(num,den)

% Presença de Zeros Positivos
num=[-3 1];
den=[10 7 1];
Gzp=tf(num,den)
% ----- Sistemas com fator de amortecimento < 1 ----

% Função de transferência sem zeros:
N=[1];
tau3=1;
csi3=0.2;
% Presença de Zeros Positivos

N=[-3 1];
tau3=1;
csi3=0.2;
Gzp2=tf(N,D) % Obtendo a função de transferência

[g1,t]=step(G,t);
figure
plot(t,g1,'r','LineWidth',2);
grid
hold
[gzp1,t]=step(Gzp,t);
plot(t,gzp1,'b--','LineWidth',2);
legend('Processo de 2â Ordem','Processo de 2â Ordem com Zeros Positivos',"location",
"southeast")
title('Resposta de um Processo de 2â Ordem com \xi > 1','fontsize',14)
print -djpg degrau_respinversa1.jpg % Salvando a figura no formato png
[g1,t]=step(G2,t);
figure
plot(t,g1,'r','LineWidth',2);
grid
hold
[gzp1,t]=step(Gzp2,t);
plot(t,gzp1,'b--','LineWidth',2);
legend('Processo de 2â Ordem','Processo de 2â Ordem com Zeros Positivos')
title('Resposta de um Processo de 2â Ordem com \xi < 1','fontsize',14)
print -djpg degrau_respinversa2.jpg % Salvando a figura no formato png
==================== RESULTADO =========================
Figura 17 – Processos de 2ª ordem com resposta inversa (zero positivo).

5.3.2 Processo Integrador
Um exemplo típico deste tipo de processo é o tanque de nível com vazão de saída
mantida constante ilustrado na Figura 18.
Figura 18 – Tanque de nível com vazão de saída constante.
O modelo matemático desse processo é dado por:
dh(t )
A = qi (t ) − q (38)
dt
que em variáveis desvio fica:
dh(t )
A = qi(t ) (39)
dt
cuja função de transferência é:
H (s ) 1
=
Qi(s ) As
(40)
A função de transferência de um sistema do tipo integrador apresenta um pólo na

origem (s = 0) e, portanto, está no limite da estabilidade. Se este sistema sofrer uma
perturbação qualquer, digamos, um degrau de magnitude M em sua entrada, sua saída é
claramente instável:
h(t ) =
M
t (41)
A
A resposta ao degrau de um processo desse processo pode ser obtida no Octave de

Quadro 28 – Resposta (RespDegrauProcessoIntegrador.m).

%
clear all
close all

clc


% ----------------------------------------------------------------
[y,t]=step(M*G);
figure
plot(t,y,'b','LineWidth',2)
grid
xlabel('t')
ylabel('y^,(t)')
print -djpg degrau_integrador.jpg
==================== RESULTADO =========================

Figura 19 – Resposta ao degrau de um processo do tipo integrador.
5.3.3 Processos com Tempo Morto

Muitos sistemas dinâmicos reais apresentam atraso na informação do valor atual de
alguma variável de processo, geralmente a variável controlada. Este atraso é conhecido por
tempo morto (dead time), atraso de transporte (lag) ou simplesmente atraso.
Um exemplo típico é o escoamento de um fluido com temperatura T (oC) através de
uma tubulação muito longa, de comprimento L (m) e área da seção transversal A (m2). Se o
fluido, escoando com vazão volumétrica F (m3/min), sofrer uma perturbação na
temperatura na entrada da tubulação, esta perturbação, T1 (oC), somente será percebida no
final da tubulação após algum tempo, o chamado tempo de atraso, θ (min). Neste caso, o
tempo de atraso é dado por θ = L A/F e a temperatura no final da tubulação é descrita por:
T1 (t ) = T (t −  ) (42)
A transformada de Laplace de uma função deslocada no tempo (com tempo morto) é:
T1(s ) = T (s ) e − S (43)

O modelo de processo mais comum no estudo de controle é o modelo de 1ª ordem
com tempo morto, que escrito em variáveis desvio tem a forma:
dy(t )
p + y(t ) = K p f (t −  ) (44)
dt
e sua transformada de Laplace é:
Y (s ) K p e
− S
= (45)
F (s )  p s + 1
De modo equivalente, a função de transferência de um processo de 2ª ordem com

tempo morto tem a forma:
Y ( s) K e− S
= 2 2 p (46)
F ( s)  s + 2 s + 1
A resposta ao degrau de um processo de 1ª ordem com tempo morto pode ser obtida
no Octave de acordo com o código descrito no Quadro 29:
Quadro 29 – Resposta ao degrau de um processo de 1ª ordem com tempo morto

(RespDegrauSist1aOrdemTempoMorto.m).
%
clear all
close all
clc
td=3; % Tempo morto

Pade=tf([-td/2,1],[td/2,1]) % Aproximação de Padé para o tempo morto
t=0:0.1:50;

G1=tf(1,[taup 1]) % Processo de 1a ordem
G2=G1*Pade % Processo de 1a ordem com tempo morto
figure
y1=step(G1,t); % Processo de 1a ordem
y2=step(G2,t); % Processo de 1a ordem com tempo morto
hold
plot(t,y2,'r','LineWidth',2);
legend('Processo de 1â Ordem','Processo de 1â Ordem com tempo morto',"location",
"southeast")
grid
title('Resposta de um Processo de 1â Ordem com Tempo Morto a um Degrau
Unitário','fontsize',14)
print -djpg degrau_tempomorto1.jpg % Salvando a figura no formato png
==================== RESULTADO =========================


Figura 20 – Respostas ao degrau de processos de 1ª e 2ª ordens com tempo morto.

6 PROJETO E ANÁLISE DE CONTROLADORES FEEDBACK
Considere o diagrama de blocos em malha fechada ilustrado na Figura 21, que

representa um sistema de controle feedback genérico.
Figura 21: Diagrama de blocos de um sistema de controle feedback (Seborg et al., 2011).
Nessa representação, considera-se explicitamente a conversão do valor do set-point

da variável controlada em sinal de corrente, tipicamente mA. Essa conversão é necessária
em implementações digitais do sistema de controle porque o sinal do erro enviado para o
controlador digital deve estar na unidade adequada (mA).
Deve-se observar que a função de transferência do sensor, Gm, já realiza essa
conversão de unidades por meio do seu ganho, Km, ou seja, converte o valor medido da
variável controlada para sinal de corrente, Ym ( s ) =  mA .
Dessa forma, a equação para o sinal de erro fica:
E ( s ) = Ysp ( s ) − Ym ( s ) (47)
em que Ysp ( s ) denota o valor interno do set-point expresso na forma equivalente a um sinal
de corrente elétrica, conforme descrito na equação abaixo:
Ysp ( s ) = K mYsp ( s ) (48)
Portanto, a função de transferência em malha fechada para o sistema de controle

feedback pode ser reescrita da forma:
K mGC ( s ) GF ( s ) GP ( s ) GD ( s )
Y ( s) = Ysp ( s ) + D ( s ) (49)
1 + GC ( s ) GF ( s ) GP ( s ) GM ( s ) 1 + GC ( s ) GF ( s ) GP ( s ) GM ( s )
6.1 Exemplos de Aplicação de Controladores Feedback

Para ilustrar a simulação da resposta em malha fechada de um sistema genérico qualquer,
considere que suas respectivas funções de transferência sejam representadas por:
• Controlador PID:
 1     s2 +  I s + 1 
GC ( s ) = KC 1 + +  D s  = KC  I D  (50)
 Is   Is 
• Atuador (válvula) com dinâmica de 1ª ordem:

KF
GF ( s ) = (51)
 F s +1
• Processo de 1ª ordem:
KP
GP ( s ) = (52)
 Ps +1
• Sensor com dinâmica de 1ª ordem:

Km
GM ( s ) = (53)
 M s +1
• Perturbação com dinâmica de 1ª ordem:

KL
GD ( s ) = (54)
 Ls +1
Os parâmetros utilizados nessa simulação são descritos na Tabela 1 e os códigos no

Octave para os problemas de controle servo e regulador são apresentados no Quadro 30 e
no Quadro 31, respectivamente. As respostas em malha fechada a perturbações no set-point
e na carga podem ser vistas na Figura 22.
Tabela 1. Parâmetros utilizados na simulação de um sistema de controle feedback genérico.

KC = 5,0 τI = 2,0 τD = 0,35
KF = 0,6 τF = 0,2 KP = 1 τP = 4
KM = 3,0 τM = 0,1 KL = 0,8 τL = 2
Quadro 30 – Código no Octave para problemas de controle servo

(ControleFeedback_ProbServo.m).
%
clear all
close all
clc
pkg load control

pkg load signal
% =============================================
% Parâmetros do Sistema
% Controlador
Kc=5;
taui=2;
taud=0.35;
Gc=tf(Kc*[taui*taud,taui,1],[taui,0])
% Atuador
Kf=0.6;
tauf=0.2;

Gf=tf(Kf,[tauf,1])
% Processo
Kp=1;
taup=4;
Gp=tf(Kp,[taup,1])
% Sensor
Km=3;
taum=0.1;
Gm=tf(Km,[taum,1])
Kl=0.8;
taul=2;
Gd=tf(Kl,[taul,1])
% =============================================
% Controlador Feedback: Problema Regulador
D=1; % Magnitude do degrau na carga
Nr=D*Gd; % Numerador do Problema Regulador
Dr=1+Gc*Gf*Gp*Gm; % Denominador do Problema Regulador
P=Nr/Dr; % Controlador Regulador
% =============================================
% Simulação em malha fechada:
[y,t]=step(P,t);
figure
grid
title('Controle Feedback: Problema Regulador','fontsize',14)
xlabel('Tempo','fontsize',14)
==================== RESULTADO =========================

Quadro 31 – Código no Octave para problemas de controle regulador

(ControleFeedback_ProbRegulador.m).
%
clear all
close all
clc
pkg load control

pkg load signal
% =============================================
% Parâmetros do Sistema
% Controlador
Kc=5;
taui=2;
taud=0.35;
Gc=tf(Kc*[taui*taud,taui,1],[taui,0])
% Atuador
Kf=0.6;
tauf=0.2;
Gf=tf(Kf,[tauf,1])
% Processo
Kp=1;
taup=4;

Gp=tf(Kp,[taup,1])
% Sensor
Km=3;
taum=0.1;
Gm=tf(Km,[taum,1])
% =============================================
% Controlador Feedback: Problema Servo
M=1; % Magnitude do degrau no set-point
Ns=Km*Gc*Gf*Gp; % Numerador do Problema Servo
Ds=1+Gc*Gf*Gp*Gm; % Denominador do Problema Servo
P=M*Ns/Ds; % Controlador Servo
% =============================================
% Simulação em malha fechada:
[y,t]=step(P,t);
figure
grid
title('Controle Feedback: Problema Servo','fontsize',14)
xlabel('Tempo','fontsize',14)
==================== RESULTADO =========================

(a) (b)
Figura 22 – Respostas em malha fechada de um processo de 1ª ordem a perturbações no
set-point (a) e na carga (b).

7 PROJETO E ANÁLISE DE CONTROLE EM CASCATA

8 PROJETO E ANÁLISE DE CONTROLADORES FEEDFORWARD

9 REFERÊNCIAS BIBLIOGRÁFICAS
BEQUETTE, B.W. Process Control: Modeling, Design, and Simulation. Prentice Hall,
2002.
BEQUETTE, B.W. Process Dynamics: Modeling, Analysis and Simulation. Prentice Hall,
1998.
LUYBEN, W. L. Process Modeling, Simulation and Control for Chemical Engineers – 2nd
Ed. McGraw-Hill, 1990.
MELEIRO, L. A. C. Notas de aula da disciplina IT359, disponibilizadas no Quiosque.
OGUNNAIKE, B. A. and RAY; W. H. Process Dynamics, Modeling and Control. Oxford
University Press, 1994.
SEBORG, D. E.; EDGAR, T. F. and MELLICHAMP, D. A. Process Dynamics and
Control. John Wiley & Sons, 1989.
SOUZA JR., M. B. Sem Problemas – Cem Problemas de Controle de Processos. Apostila
UFRRJ, 1994.
SOUZA JR., M. B.; HENRIQUES, A. W. S. 100 Respostas Para “Sem Problemas”.
Apostila UFRRJ, 1995.
SOUZA JR., M. B.; TRICA, D. J. Introdução a Modelagem e Dinâmica para Controle de
Processos. PUBLIT Soluções Editoriais, 2013.
STEPHANOPOULOS, G. Chemical Process Control: An Introduction to Theory and
Practice. Prentice-Hall, 1984.


Controle de Processos Com Octave

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Controle de Processos Com Octave

Enviado por

Direitos autorais:

Formatos disponíveis

Controle de Processos – IT359

Prof. Dr. Luiz Augusto C. Meleiro

UNIVERSIDADE FEDERAL RURAL DO RIO DE JANEIRO

CONTROLE DE PROCESSOS QUÍMICOS

Prof. Dr. Luiz Augusto da Cruz Meleiro

1 NOTAS SOBRE O OCTAVE 7

1.1 Instalação dos Pacotes: A versão atual (6.1.0 - Nov-2020) 7

1.2 Atualização da lista de Pacotes 7

1.3 Instalação de Pacotes Adicionais 7

1.4 Habilitação dos Pacotes 8

1.5 Funções Específicas de Cada Pacote 8

2.1 Trabalhando com Álgebra Simbólica 9

3.1 Transformada de Laplace 13

3.2 Transformada Inversa de Laplace – Método das Frações Parciais 13

4.2 Trabalhando com Funções de Transferência 17

Controle de Processos com Gnu-Octave

5 COMPORTAMENTO DINÂMICO EM MALHA ABERTA 22

5.1 Respostas Dinâmicas de Processos de 1ª Ordem 22

5.2 Respostas Dinâmicas de Processos de 2ª Ordem 31

5.3 Respostas Dinâmicas de Processos Mais Complexos 39

6 PROJETO E ANÁLISE DE CONTROLADORES FEEDBACK 46

6.1 Exemplos de Aplicação de Controladores Feedback 46

7 PROJETO E ANÁLISE DE CONTROLE EM CASCATA 50

8 PROJETO E ANÁLISE DE CONTROLADORES FEEDFORWARD 51

Controle de Processos com Gnu-Octave

Controle de Processos com Gnu-Octave

Controle de Processos com Gnu-Octave

Controle de Processos com Gnu-Octave

Controle de Processos com Gnu-Octave

1.1 Instalação dos Pacotes: A versão atual (6.1.0 - Nov-2020)

>> pkg list

1.2 Atualização da lista de Pacotes

>> pkg update

1.3 Instalação de Pacotes Adicionais

>> pkg install -forge nome do pacote

A lista com os pacotes está disponível em: https://octave.sourceforge.io/packages.php

1.3.1 Instalando Pacotes Adicionais

Controle de Processos com Gnu-Octave

>> pkg install -forge signal

1.3.1.2 Instalando o pacote de processamento simbólico

>> pkg install symbolic-win-py-bundle-2.9.0.tar.gz

1.4 Habilitação dos Pacotes

>> pkg load nome do pacote

Por exemplo, para carregar os pacotes necessários para a disciplina de controle de

>> pkg load control

1.5 Funções Específicas de Cada Pacote

▪ pkg control: https://octave.sourceforge.io/control/overview.html

Controle de Processos com Gnu-Octave

2.1 Trabalhando com Álgebra Simbólica

2.1.1 Cálculo analítico da integral de uma função

Quadro 1 – Processamento simbólico (AlgebraSimbolica.m).

syms x; % Definine a variável "x" como simbólica

f=cos(2*x); % define a função a ser integrada

==================== RESULTADO =========================

Quadro 2 – Cálculo de integral simbólica (CalculoIntegral.m).

int_f=int(f,t); % Avalia a integral da função

==================== RESULTADO =========================

2.1.2 Cálculo analítico da derivada de uma função

Quadro 3 – Cálculo de derivada simbólica (CalculoDerivada.m).

syms x; % Definine a variável "x" como simbólica

printf('A função f(x) a ser derivada é: \n'), disp(f)

Controle de Processos com Gnu-Octave

==================== RESULTADO =========================