INTRODUÇÃO AO (MATLAB E) SIMULINK
Curso prático introdutório através de exemplos.
Parte I -Generalidades
Irineu Alfredo Ronconi Junior
Fundação Escola Técnica Liberato Salzano Vieira da Cunha
Institut für Regelungstechnik (IfR) –TU Braunschweig
1.- Introdução:
A presente apostila parte do pressuposto que o interessado está já de posse do Programa Matlab, bem como do Simulink que o acompanha. O mesmo está pronto para o uso no computador.
A apostila tem como objetivo ser um manual básico introdutório ao Simulink, principalmente em aplicações de controle de máquinas elétricas assíncronas de indução. Portanto à parte a que se refere ao Matlab,na parte I, serve apenas como um pequeno manual de comandos essenciais que também serão usados no Simulink. Isto é apresentado de forma rápida, tentando imitar um “guia de referência”. Na parte II da apostila são descritos exemplos de blocos desenvolvidos no Simulink para circuitos elétricos em geral, eletrônicos, maquina CC, e finalmente para máquinas ca.
Para os exemplos mais relevantes acompanham os programas em “.m”.
2.- Coisas básicas do Matlab
2.1- Socorro – Help
Quando o Matlab é aberto a tela é semelhante à mostrada abaixo. Nela estão assinalados:
Command Window, Workspace e Currente Directory.
Na janela de comando (Command Window) você pode executar comandos do Matlab, como por exemplo, o comando help. Ele funciona da seguinte forma: help nome da função. Como resultado vem um esclarecimento da mesma se a mesma existe. Por exemplo:
>> help sin SIN Sine.
SIN(X) is the sine of the elements of X. Overloaded methods
Foi pedido um help sobre a função seno (sin, sempre em notação ou o nome em inglês). Se a função não existe o resultado será como o seguinte:
>> help coisa coisa.m not found.
Em caso de precisar ajuda, tente antes de qualquer coisa, as diversas formas de ajuda (help) já inseridas no Matlab.
Entre outras coisas, no command window você pode executar expressões de todos os tipos, fazer cálculos diretos, programas (não é o local apropriado), digitar comando para plotar gráficos, etc. É também ai que vem todas as observações feitas pelo Matlab quando os programas são rodados (relatórios de erros, avisos, etc...).
Na janela, espaço de trabalho (Workspace), é colocado todos os valores de varáveis e variáveis em uso. Pode ser também armazenado ai, dados que você manda de uma simulação no Simulink. Pode ter dados ai para algum bloco do Simulink ler. São fornecidos o tipo de variável, tamanho e etc.
O diretório corrente (current directory), é colocado os programas realizados para serem procurados por outros programas em andamento, ou por blocos do Simulink.
2.2 – Programando no Matlab
Os programas no Matlab são desenvolvidos em um editor próprio: clique em File e então novo (new) m file. Os programas do Matlab são gravados como.m . Você pode também escrever seus programas em C++, Fortran ou em ASCII.
Um outro tipo de arquivos.m são as funções. Muitas vezes fazemos longos programas e os mesmos chamam funções que foram desenvolvidas. É como se fosse uma sub-rotina. Estas funções são construídas obedecendo ao seguinte formato:
function[ argumentos de saída] = nome da função(argumentos de entrada) Por exemplo:
function[mag, phase] = mybode(num, den, w) 2.3. – Variáveis
As variáveis podem conter até 31 caracteres. São sensíveis ao formato maiúscula minúscula. Devem começar por uma letra, e não é permitida acentuação ou letras que não pertençam ao alfabeto inglês.
Podem ser locais, neste caso simplesmente a variável é digitada, ou globais. Neste caso a mesma deve ser declarada global. Quando uma variável é global ela pode ser utilizada por diversas funções ao mesmo tempo. Para se declarar uma variável global, basta no início do programa escrever:
global R,S,T
As variáveis R,S,T (maiúsculas) são globais, isto é podem ser usadas por diferentes funções de um programa em questão.
Algumas variáveis do próprio Matlab são apresentadas a seguir:
Variável Valor/significado
ans Variável padrão para dar os resultados de uma operação
pi Número pi (π = 3,1415...)
eps Menor número que somado a um, resulta em um número de ponto flutuante maior do que 1.
flops Contador do número de operações de ponto flutuante
i (também j) Unidade imaginária
i
=
j
=
−
1
nargin Número de argumentos de entrada de uma função
nargout Número de argumentos de saída de uma função
realmin Menor número real positivo utilizável
realmax Maior número real positivo utilizável
Para apagar variáveis basta digitar clear nome da variável ou clear all, para apagar todas as variáveis ou clear cl* para apagar todas as variáveis que comecem com cl.
2.4. – Os formatos de saída
Comando Matlab exemplo observações
format short 50.833 5 dígitos
format long 50.83333333333334 16 dígitos
format short e 5.0833e+01 5 dígitos + expoente
format long e 5.083333333333334 16 dígitos + expoente
format short g 50.833 O melhor entre format short e
format short e
format hex 40496aaaaaaaaaab Hexadecimal
format + + Positivo, negativo ou zero.
format rat 306/6 Aproximação racional
Para apresentação os dados de saída podem ser impressos, ou expostos na tela com o comando fprintf. A forma mais simples é:
fprintf(codigo,dados, ...)
Código Formato
%e Formato científico com minúscula
%E Formato científico com maiúscula
%f Formato decimal
%s String de caracteres
%u Inteiro
%i “Segue o tipo” já usado
%x Hexadecimal com minúsculas
%X Hexadecimal com maiúsculas
Normalmente em combinação com fprintf é usado algum dos caracteres de controle a seguir:
Caractere de controle Efeito
\n Nova linha
\r Começo da linha
\b Espaço para trás (back space)
\t Tabulador (tab)
\g Nova página
\\ Reduz para trás (back slash)
\b Sino, som (bell)
Exemplos:
%7.3f significa um número com sete dígitos e três casas após a vírgula. Isto é colocado na posição da primeira tabulação (\n)
B)Tabela para logaritmos naturais de 10, 20, 40, 60, 80. >> x =[ 10; 20; 40; 60; 80];
>> y = [x, log(x)];
>> fprintf('\n Numero Log Natural\n'); Numero Log Natural
>> fprintf('%4i\t %8.3f\n', y') 10 2.303
20 2.996 40 3.689 60 4.094 80 4.382
Neste caso temos Número na primeira tabulação e Log Natural na seguinte. O primeiro é um número de até quatro dígitos e o segundo após uma tabulação é de oito dígitos com três casas após a vírgula decimal (f).
Com o comando input poderemos ler variáveis que são digitadas. A forma geral é:
Variável = input(‘valor a ser introduzido’)
Por exemplo um pedido do tipo: “Entre com o raio do círculo em metros “ poderia ser escrito como um comando Matlab da seguinte forma:
R = input(‘Entre com o raio em metros: ’)
O Matlab contém muitas funções matemáticas prontas para o uso. Para sabermos o comando correto basta usar o help no próprio Command Window. Para isso devemos digitar: help ops, para sabermos os principais operadores ( soma, divisão, multiplicação, etc...) e help elfun para que seja listadas as funções matemáticas elementares. A seguir uma “amostra”:
help ops
Operators and special characters.
Arithmetic operators.
plus - Plus + uplus - Unary plus + minus - Minus - uminus - Unary minus - mtimes - Matrix multiply * times - Array multiply .* mpower - Matrix power ^ power - Array power .^ mldivide - Backslash or left matrix divide \ mrdivide - Slash or right matrix divide / ldivide - Left array divide .\ rdivide - Right array divide ./
help elfun
Elementary math functions.
sin - Sine.
sinh - Hyperbolic sine. asin - Inverse sine.
asinh - Inverse hyperbolic sine. cos - Cosine.
cosh - Hyperbolic cosine. acos - Inverse cosine.
acosh - Inverse hyperbolic cosine. tan - Tangent.
tanh - Hyperbolic tangent. atan - Inverse tangent.
atan2 - Four quadrant inverse tangent. atanh - Inverse hyperbolic tangent. Exponential.
exp - Exponential. log - Natural logarithm.
log10 - Common (base 10) logarithm.
log2 - Base 2 logarithm and dissect floating point number. pow2 - Base 2 power and scale floating point number. realpow - Power that will error out on complex result. reallog - Natural logarithm of real number.
realsqrt - Square root of number greater than or equal to zero. sqrt - Square root.
2.5 – Strings, como escrever no Matlab
Uma seqüência de caracteres entre aspas pode se tornar uma “string” ou uma variável de texto. Por exemplo:
C = ‘boa’
Resulta em:
C = boa
Se digitarmos:
Cs = [C, ‘sorte’]
O resultado será:
Cs =
boa sorte
2.6 – Operações com vetores
O Matlab é um programa feito especialmente para se trabalhar com matrizes. Como matrizes podem representar vetores, as operações entre matrizes podem, e muitas vezes são, chamadas de operações com vetores. Alguns fazem uma pequena distinção, chamam de vetores a matriz com uma única linha ou uma única coluna, e matriz quando possui m linha e n colunas. O termo geral, no Matlab é array. Na verdade, podemos considerar tudo como arranjos de m x n, e cuidar para diferenciar uma operação algébrica simplesmente de uma
>> x = [2; 4; 6] x =
2 4 6
É a forma descrever uma matriz coluna. Usa-se “ ; “ .
Já a equivalente matriz linha pode ser escrita das seguintes formas: >> x=[2 4 6]
x =
2 4 6 >> x=[2, 4, 6] x =
2 4 6
Neste caso é utilizado espaços ou vírgulas. >> y = [ tan(pi/4) sqrt(9) -5]
y =
1.0000 3.0000 -5.0000
Para transformar uma matriz linha em coluna ou vice versa usamos o símbolo do apóstrofo: >> y = [ tan(pi/4) sqrt(9) -5]
y =
1.0000 3.0000 -5.0000 >> z = y'
z = 1.0000 3.0000 -5.0000
Como já observamos anteriormente é necessário atenção quando se quer realizar operações aritméticas com matrizes. Por exemplo, quando multiplicamos duas matrizes, poderemos queres uma multiplicação de elemento por elemento ou simplesmente o resultado de uma multiplicação matricial. Operação diferente implica em comandos diferentes;
Observe a seqüência a seguir: >> x = [2 4 6];
2 4 6 >> y = x' y = 2 4 6 >> p = 5*x p =
10 20 30 >> p = 5*y p = 10 20 30 >> z = x*y z = 56 >> w = x.*y
??? Error using ==> .*
Matrix dimensions must agree. >> pot = x.*x
pot =
4 16 36
Observe que só podemos multiplicar matrizes se o número de linhas da primeira é igual ao número de colunas da segunda. Para isso usamos: * . Porém se quisermos multiplicar elemento a elemento, usamos.* .Neste caso a matriz deve ter o mesmo formato de linhas e colunas. Quando isso não ocorre vem uma mensagem de erro como o mostrado.
Normalmente o ponto antes do símbolo da operação significa que a mesma é uma operação de elemento por elemento, uma operação escalar.
Para se obter matriz de zeros: >> Z = zeros(1,4) Z =
0 0 0 0 0 0 0 0 0 0 0 0 Matriz de uns:
>> Uns = ones(1,4) Uns =
1 1 1 1 >> Uns34 = ones(3,4) Uns34 =
1 1 1 1 1 1 1 1 1 1 1 1 Matriz identidade:
>> Ident34 = eye(3,4) Ident34 =
1 0 0 0 0 1 0 0 0 0 1 0
Uma matriz linha, de 1 a 8 incrementada de 1 em 1: linha = [1:8]
linha =
1 2 3 4 5 6 7 8
Uma matriz linha de 0 a 2π, incrementada de π/3: >> angulos = [0:pi/3:2*pi]
angulos =
0 1.0472 2.0944 3.1416 4.1888 5.2360 6.2832 Uma matriz de 5 a 1 decrementada de 1 em 1:
>> decremento = [5:-1:1] decremento =
5 4 3 2 1
Como já sabemos vírgulas ou simplesmente espaços dispõem os elementos da matriz em linha, formando as diversas colunas. O ponto e vírgula fazem com que sejam criadas “novas” linhas. Deste modo geramos uma matriz m x m do tamanho que quisermos.
Então, seja a matriz A:
>> A= [6 1 2; -1 8 3; 2 4 9] A =
6 1 2 -1 8 3 2 4 9
Se quisermos retirar o elemento 8 da matriz, basta digitar : >> ele8 = A(2,2)
ele8 = 8
Se quisermos os elementos da terceira linha: >> ele3li = A(3,:)
ele3li = 2 4 9
Se quisermos todos os elementos da segunda coluna: >> ele2co = A(:,2)
ele2co = 1 8 4
Se as matrizes são de mesma dimensão, todas as operações matemáticas elementares (soma, subtração, divisão produto, quaisquer que sejam eles, etc são permitidos). Caso contrário, valem as regras da álgebra linear, mais a sintaxe do Matlab. Duas matrizes A e B podem ter seu produto se o número de linhas de uma for igual ao número de colunas da outra. Para divisão temos duas situações, importantes, a saber: A\B é equivalente a A-1.B e A/B é equivalente a A.B-1, onde o expoente -1 denota a inversa. Portanto:
Matlab Álgebra
A\B A-1.B
A/B A.B-1
A.\B Divisão elemento a elemento(A/B) A./B Divisão elemento a elemento(B/A)
Sejam as matrizes A e B: A =
2 4 9 B =
1 2 3 2 2 2 4 5 10 Então:
>> div1= A./B div1 =
6.0000 0.5000 0.6667 -0.5000 4.0000 1.5000 0.5000 0.8000 0.9000 >> div2 = A.\B
div2 =
0.1667 2.0000 1.5000 -2.0000 0.2500 0.6667 2.0000 1.2500 1.1111 >> div3 = A/B
div3 =
-6.5000 3.2500 1.5000 12.5000 0.2500 -3.5000 1.2500 -1.1250 0.7500 >> div4 = A\B
div4 =
0.0179 0.1582 0.1433 0.1045 0.0896 -0.1642 0.3940 0.4806 1.1522
A inversa de uma matriz se obtém usando o comando inv.
Exemplo: Calcular os vetores x1, x2 e x3, do sistema A.X = B, abaixo:
−
−
=
−
−
−
−
−
16
32
10
16
6
4
12
10
2
10
2
4
3 2 1x
x
x
A solução do sistema será: X = B.A-1, portanto podemos determinar a inversa de A e então multiplicar por B ou simplesmente fazer A\B. Então:
>> C = inv(A); >> X = C*B X =
2 4 1
>> X = A\B X =
2.0000 4.0000 1.0000
Lembre-se sempre que, dadas duas matrizes A e B, A = ma x na e B = mb x nb só será possível
o produto matricial se ma = nb .
2.8 – Autovalores
Se A é uma matriz n x n os “p” λ que satisfazem a condição Ax =λx são os autovalores de A. No Matlab eles são calculados usando o comando eig(A).
Por exemplo, seja a nossa já conhecida matriz A: A =
4 -2 -10 2 10 -12 -4 -6 16
Para termos os autovalores, basta digitar eig (A). O resultado é uma matriz coluna como mostra a seguir:
> eig(A) ans = 23.4088 0.2703 6.3208
Porém podemos também expressar os resultados de acordo com a definição: Ax =λx. >> [X,lambda]=eig(A)
X =
-0.2882 -0.9317 -0.7844 -0.6621 -0.1902 0.6174 0.6918 -0.3095 0.0586
23.4088 0 0 0 0.2703 0 0 0 6.3208 2.9 – Números Complexos
No Matlab i e j são os símbolos utilizados para a unidade imaginária. As principais operações são sintetizadas na tabela a seguir:
Operação Descrição
Z = a+bi ou Z = a+ bj Forma retangular
real(Z) Fornece a parte real de Z
imag(Z) Fornece aparte imaginária de Z
abs(Z) Determina o valor absoluto de Z
angle(Z) Calcula a fase de Z
conj(Z) Determina o conjugado de Z
Z = M*exp(j*θ) Converte para a forma retangular
2.10 – Raízes de polinômios e polinômios característicos
No Matlab podemos representar um polinômio por uma matriz linha, onde o primeiro elemento é o de mais alto grau do polinômio e o último o coeficiente de grau zero.
Por exemplo:
15
75
,
14
75
,
67
25
,
61
25
,
31
9
)
(
s
=
s
6+
s
5+
s
4+
s
3+
s
2+
s
+
p
, um polinômio.Então, no Matlab
p
=
[
1
9
31
.
25
61
.
25
67
.
75
14
.
75
15
]
Para se determinar as raízes, usa-se o comando roots(p), então:>> p = [1 9 31.25 61.25 67.75 14.75 15]; >> r = roots(p)
r =
-4.0000 -3.0000 -1.0000 + 2.0000i -1.0000 - 2.0000i 0.0000 + 0.5000i 0.0000 - 0.5000i
Exemplo : As raízes de um polinômio são: -1, -2, -3±j4. Determinar a equação polinomial correspondente. Neste caso usaremos o comando poly.
>> r= [-1 -2 -3+4*j -3-4*j]; >> p = poly(r)
p =
1 9 45 87 50
2.11 – Produto e divisão de polinômios
O produto de polinômios é obtido pela convolução de seus coeficientes e o quociente pela “desconvolução”. O Matlab fornece para isso os comandos conv(A,B) e deconv (A,B), onde A e B são matrizes que contém os coeficientes dos polinômios em questão.
Por exemplo, dados os polinômios
A
=
s
4+
9
s
3+
37
s
2+
81
s
+
52
eB
=
s
2+
4
s
+
13
, achar A.B e A/B.>> A = [1 9 37 81 52]; >> B = [1 4 13]; >> AvezB=conv(A,B) AvezB =
1 13 86 346 857 1261 676 >> AdivB = deconv(A,B)
AdivB = 1 5 4
Ou ainda podemos, já saber as raízes do polinômio: >> [AdivB,raizes] = deconv(A,B)
AdivB = 1 5 4
raizes =
0 0 0 0 0
2.12 – Ajustando uma função polinomial a um conjunto de pontos
Dado um conjunto de pontos (x,y) pode-se tentar ajustar a estes pontos a uma função polinomial, da seguinte forma:
n d
d
c
x
c
x
c
x
p
(
)
=
1+
2 −1+
...
+
, o grau da equação então é d e n, os coeficientes serão n = d+1. O comando Matlab será o polyfit(x, y, d).Exemplo: Dados os pontos x,y, encontrar uma equação de grau 3 que se ajuste aos mesmos.
x 0 1 2 4 6 10
y 1 7 23 109 307 1231
>> x = [0 1 2 4 6 10];
>> y = [1 7 23 109 307 1231]; >> c =polyfit(x,y,3)
c =
logo a equação será :
p
(
x
)
=
x
3+
2
x
2+
3
x
+
1
.2.13 – Avaliando valores fornecidos por um polinômio em função de valores atribuídos a variável
Seja, por exemplo o polinômio dado a seguir:
y
=
x
3+
2
x
2+
3
x
+
1
, e desejamos saber qual é o valor de y para os pontos de 0 a 4 incrementados de um em um. O comando a ser utilizado aqui é o polyval(c,x), onde c é a matriz dos coeficientes do polinômio acima.>> c= [1 2 3 1]; >> x=0:1:4;
>> y = polyval(c,x) y =
1 7 23 55 109
2.14 – Expansão em frações parciais
A expansão de um polinômio fracionário em frações parciais é muito importante em controle, pois através desta expansão, simplificamos as parcelas de tal forma que fica mais fácil o cálculo da transformada inversa de Lapalace. O comando Matlab é dado por
[r,p,k]=residue[P,Q]. Então seja o polinômio fracionário a seguir:
0 1 1 1 0 1 1 1
...
...
)
(
)
(
q
s
q
s
q
s
q
p
s
p
s
p
s
p
s
Q
s
P
n n n n m m m m+
+
+
+
+
+
+
+
=
− − − −Então, r é resíduo, p são os pólos e k a razão entre os polinômios., P e Q são os vetores(matriz linha) formado pelos coeficientes de P(s) e Q(s).
Exemplo: Expandir em frações parciais.
4
4
1
9
2
)
(
2 3 3+
+
+
+
+
=
s
s
s
s
s
s
F
>> p=[2 0 9 1]; >> q=[1 1 4 4];
>> [r,p,k]=residue(p,q) r =
0.0000 - 0.2500i 0.0000 + 0.2500i -2.0000
p =
-0.0000 + 2.0000i -0.0000 - 2.0000i -1.0000
2
Isto significa que a expressão anterior pode ser escrita da seguinte forma:
4
1
1
2
2
2
25
,
0
2
25
,
0
1
2
2
)
(
2+
+
+
−
+
=
−
−
+
+
+
+
−
+
=
s
s
j
s
j
j
s
j
s
s
F
Também é permitida operação inversa. Isto é o comando [Q,P] = residue(r,p,k) converte a expansão parcial no polinômio original.
Lembre-se sempre do help do Matlab. Para uma exposição mais completa de funções tecle
help matfun no command window.
3 – Gráficos
Há uma grande variedade de possibilidades de gráficos a serem plotados no Matlab. Aqui são apresentados os mais comuns e menos pesados. Lembrando novamente, caso se queira algo mais sofisticado é recomendado o uso do help do Matlab.
O comando para plotar (em duas dimensões) gráficos é sempre plot( variáveis e características que podem ser adicionadas).Os gráficos poderão ser logarítmicos, retangulares, semi log, polar, etc. Muitas vezes vamos plotar várias curvas no mesmo gráfico, precisaremos diferenciar. Isto pode ser conseguido de acordo com a tabela a seguir:
Especificação de cor Tipo de traçado da curva
cor comando estilo comando
preto k sólido Nada
azul b vazado --
cian c Dois pontos :
verde g Vazado com ponto -.
mangenta m ponto .
vermelho r círculo o
branco w Com x X
estrela *
A seguir é dado um exemplo de como plotar várias curvas no mesmo gráfico diferenciando –as.
Plot(x1, y1, ‘r’, x2, y2, ‘+b’, x3, y3, ‘--‘)
Neste caso teremos três curvas (1, 2 e 3). A primeira normal, porém com cor vermelha. A segunda feita por símbolos + com cor azul e a terceira vazada “--“.
Uma outra maneira de se colocar várias curvas no mesmo gráfico é usando o comando line.
Então para o mesmo caso acima teríamos que escrever:
line(x2, y2, ‘+b’) line(x3, y3, ‘—‘)
Gráficos devem conter título e anotações, bem como, muitas vezes, é necessário que apareça a grade para melhor visualizar valores do mesmo. Isso se consegue com os comandos a seguir:
Comando Efeito
grid Coloca a grade no corpo do gráfico
xlabel(‘identificação do eixo x’) Permite que você escreva algo no eixo x
ylabel(‘identificação do eixo y’) Permite que você escreva algo no eixo y
title(‘título do gráfico’) Coloca o título do gráfico no corpo do mesmo
text(x-coordenada,y-coordenada,’texto’) Coloca um texto na posição x,y
figure Abre uma janela de figura
Exemplos:
faz com que na posição x= 3,5 e y= 1,5 seja escrito, no corpo do gráfico, o texto voltagem. O mesmo poderia ser feito usando o comando gtext(‘texto’). Neste caso, após o gráfico ser plotado, você pode ajustar com o mouse a posição do texto sobre o gráfico. Tem ainda o
legend(linetype1, string1, linetype2, string2,....), permitindo que se coloque legendas com diferentes tipos de escrita. O comando legend off remove as mesmas do gráfico. Embora o Matlab providencie a escala automática dos gráficos, a mesma poderá ser feita manualmente usando o comando axis([x min. x max. Y min. Y max.]). Por exemplo: axis([-1- 40 –50 50]). Para voltar a forma automática baste teclar axis ou axis(‘auto’).
Sugere-se uma olhada nos seguintes helps: help graphics, help plotxy.
Os gráficos gerados no Matlab pode ser salvos, impressos, editados, copiados, exportados, e etc. Por exemplo, seja a função :
>> x=0:1:4;
>> y1= x.^3+2*x.^2+3*x+1; >> plot(y1,x)
Gera o gráfico da figura apresentada a seguir. Nela o menu de file está aberto, propositadamente para que você observe as possibilidades de formas de arquivar o mesmos.
No menu edit, temos a opção de copiar (Copy Figur) o gráfico para o clipboard. Neste caso ele será apresentado da seguinte forma:
Exemplo: Gerar um gráfico, com escalas lineares para as seguintes variáveis expostas na tabela abaixo:
x 0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
y 10 10 16 24 30 38 52 68 82 96 123
Digitamos o seguinte:
>> x=[0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0]; >> y=[10 10 16 24 30 38 52 68 82 96 123]; >> plot(x,y), grid
>> xlabel('x'), ylabel('y'), title('Um exemplo de grafico com o uso de alguns comandos expostos')
>> O resultado será:
Exemplo: Desenvolva um polinômio de grau 2 que se ajuste aos dados da tabela do exemplo anterior. Então a seqüência de comandos deverá ter a seguinte forma:
>> x=[0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0]; >> y=[10 10 16 24 30 38 52 68 82 96 123]; >> plot(x,y), grid
>> xlabel('x'), ylabel('y'), title('Um exemplo de grafico com o uso de alguns comandos expostos')
>> x=[0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0]; >> y=[10 10 16 24 30 38 52 68 82 96 123]; >> p = polyfit(x,y,2); % calcula o polinomio que se ajusta e ele e de segunda ordem >> yc=polyval(p,x); % calcula os pontos "y" gerados pelos valores de x da tabela >> plot(x, y, 'x', x, yc)% plota as duas curvas no mesmo grafico a primeira com "xs" >> xlabel('x'), ylabel('y'), grid
E o gráfico fica, então:
Observe que o “ 4 “ é a posição onde é colocada a caixa. Porém se você quiser mudar, basta clicar o botão direito, fixar sobre a caixa e arrasta-la para o lugar que achar adequado.
Exemplo: Plotar o gráfico da função abaixo, no intervalo de 0 a 3 segundos. Encontrar os valores de tempo e de y para os valores máximos. Identificar bem o gráfico.
)
2
8
sin(
1
+
2−
π
=
e
−t
y
t>> t = 0:.005:3;
>> c = 1 + exp(-2*t).*sin(8*t-pi/2); % lembrar que para multiplicar elementos usamos .* >> [cp,k] = max(c) % cp e o maximo valor de c no interlavo k
cp = 1.4702
k = 73
>> tp=t(k) % o tempo correspondente no intervalo k tp =
0.3600
>> plot(t,c), xlabel('t em segundos'), ylabel('c'), grid >> title('Seno amortecido')
E o gráfico plotado se apresenta da seguinte forma:
Uma forma interativa de se achar os pontos no gráfico é fazer o uso do comando [x,y]=ginput. No caso teremos: [tp, cp] = ginput.
Neste caso aparecerá no gráfico uma “mira” formada por retas cruzadas em 90 graus:
Exemplo: Plotar na mesma janela as quatro funções dadas abaixo. Adotar para o intervalo de variação de ωt de 0 até 3π em passos de 0,005.
1- a esquerda superior plotar
v
=
120
sin
ω
t
e)
4
sin(
100
ω
−
π
=
t
i
em função de ωt;2- na direita superior plotar
p
=
vi
;3- na esquerda inferior, dado Fm = 3, plotar
f
a=
F
msin
ω
t
,f
b=
F
m=
sin(
ω
t
−
2
π
/
3
)
e
f
c=
F
m=
sin(
ω
t
−
4
π
/
3
)
, todos em função de ωt;4- para
f
R=
3
F
m, construir um círculo de raio fR na parte inferior direita.>> subplot(2,2,1), plot(wt, v, wt, i); %o grafico ficou dividido em 4 partes [2,2], esta e a primeira
>> title(' Tensao & corrente'), xlabel('wt em radianos'); >> subplot(2,2,2), plot(wt,p);
>> title('Potencia'), xlabel('wt em radianos') >> Fm=3.0;
>> fa=Fm*sin(wt); %Forca magnetomotriz >> fb=Fm*sin(wt-2*pi/3); fc=Fm*sin(wt-4*pi/3); >> subplot(2,2,3), plot(wt,fa,wt,fb,wt,fc)
>> title('Fmm trifasica'), xlabel('wt em radianos') >> fR=3/2*Fm;
>> subplot(2,2,4), plot(-fR*cos(wt), fR*sin(wt)) >> title('Fmm rotorica')
E os gráficos:
3.1 – Laços e declarações lógicas:
O programa Matlab fornece comandos para desenvolver laços e declarações lógicas. Alguns deles são os comandos: for, while e if. O comando ou declaração for instrui o computador a executar as operações subseqüentes até o comando end por um determinado número de vezes. A expressão pode ser uma matriz. A seguir é dado um exemplo de laço:
A declaração while que comandos sejam repetidos tantas vezes quanto seja necessário de acordo com outras instruções lógicas. Os comandos if, else, e elseif permitem executar comando de forma condicional. Matlab tem, entre outros, seis operadores de relação, quatro de operações lógicas, que são definidos na seguinte tabela:
Operador de relação Operador lógico
== Igual & E
~= Diferente | Ou
< Menor que ~ Complemento (negação) <= Menor ou igual que xor Ou exclusivo
> Maior que
>= Maior ou igual que
Matlab é um programa que utiliza uma linguagem interpretada e operações como multiplicação de matrizes são realizadas de forma mais rápida que operações como incrementar um índice, e uso de laços são muitas vezes ineficientes. Desde que as variáveis no Matlab são arranjos ou matrizes tente usar mais operações vetoriais ao invés de laços. Os laços devem ser usados preferencialmente em operações de controle. Alguns exemplos de uso de laços são demonstrados nos exemplos seguintes.
Exemplo:
Um sinal retangular pode ser representado como uma soma de termos de senos e cossenos, para isso é usado a Série de Fourier:
∑
∞==
+
+
+
=
1 0 0 0 0sin
1
4
...
5
sin
5
1
3
sin
3
1
sin
4
)
(
nt
n
n
t
t
t
t
x
ω
π
ω
ω
ω
π
, n ímpar e inteiroA seguinte seqüência de comandos no Matlab desenvolve uma operação em laço que gera uma soma de termos para valores ímpares e inteiros fornecidos a mesma.
n= input(' numero impar ')%pede um numero pelo teclado, ele deve ser impar w_0t = 0:.01:2*pi; % faz omega vezes t (angulo) variar de 0 ate dois pi em passos de 0,01. Gera um vetor com 628 valores
x = 0 ; for k= 1:2:n;
x = x + 1/k*sin(k*w_0t);
end % faz um laco, onde o k varia de 1 ate n que foi fornecido pelo teclado. A soma para x e feita n vezes
x = 4/pi*x;
plot( w_0t,x), xlabel ('\w_0t') % plota os graficos e coloca os labels (descricao)
text (3.5, .7, ['Soma de ', num2str((n+1)/2),' senos']) % vai ser colocado o texto soma de -resutado de (n+1)/2
%convertido em texto na posicao 3.5, .7 No espaço do “Workspace” teremos a pergunta:
Using Toolbox Path Cache. Type "help toolbox_path_cache" for more info.
To get started, select "MATLAB Help" from the Help menu.
numero impar 121 n =
Foi fornecido o número ímpar 121 e então o resultado gráfico é plotado.
Exemplo:
Uma função de transferência ou função de rede é expressa por:
0 1 1 1 0 1 1 1
...
...
)
(
b
s
b
s
b
s
b
a
s
a
s
a
s
a
s
F
n n n n n n n n+
+
+
+
+
+
+
+
=
− − − −Escrever no Matlab uma função denominada “mybode” para analisar a magnitude e o ângulo de fase da função para
s
=
j
ω
onde 0 < ω < ∞ .Fazer com que o programa avalie a magnitude e o ângulo de fase da função:
s
s
s
s
s
F
1000
110
)
1
(
1000
)
(
3 2+
+
+
=
usar para Omega valores em uma escala logarítmica entre: 0,1 ≤ω≤ 1000.
Neste caso a ação é feita em duas partes. A primeira é criar um programa geral que calcula a magnitude e o ângulo de fase de uma função de transferência numérica. Isto é quando é rodado o “script” onde os dados da função de transferência estão, é chamada a função geral que calcula a magnitude e a fase.
Então, a função geral é desenvolvida pelo seguinte programa:
function[mag, phase]= mybode(num,den,w); % cria uma nova funcao ela fornece a magnitude e a fase desde que sejam dados
% o numerador, o denominador e % omega
m = length(num); n=length(den); % faz a variavel m ser igual ao valor do comprimento do numerador
% e n do denominado. No caso m= 2 e n= 4
N = num(m), D = den(n); % Diz que a variavel N tem o valor da posicao assumida por m no num
% m= 2, logo num=[ 1000 1000], entao N inicialmente % e igual a 1000
N = N+num(m-k)*s.^k % Monta o numerador da funcao de transferencia, se k=1 N= 1000+1000*jw.^1
end
for k= 1:n-1
D= D+den(n-k)*s.^k %Monta o denomindador, se k=1 D= 1+1000*jw %Para k=2, D= (1+1000*jw)+110*jw^2 , k=3
%D=(1+1000*jw)+110*jw*s^2+1*jw^3 OBS: lembrar que w %varia em escala log.
end
H= N./D; % faz a divisao arranjos pela direita de N por D mag=abs(H); % calcula o modulo do resultado acima phase=angle(H)*180/pi; %transforma graus em radianos
A função de transferência é escrita da seguinte forma (observe que na terceira linha é chamada a função geral):
num= [1000 1000];, den=[ 1 110 1000 1];
w=logspace(-1,3); % faz w variar em escala logaritmica
[mag, phase]=mybode(num, den,w); % chama a funcao para calcular a magnitude e fase subplot(2,1,1), semilogx(w,mag), grid % Plota os graficos
xlabel('\omega'), ylabel('Magnitude') subplot(2,1,2), semilogx(w, phase), grid xlabel('\omega'), ylabel('\angulo, grau')
Quando este trecho do programa é rodado ele chama o programa principal e o resultado é o gráfico a seguir:
Exemplo:
Um outro exemplo do uso de laços é a solução numérica de equações diferenciais. O método de Euler é o mais simples e o menos acurado método. Considere a equação diferencial de primeira ordem de um sistema de uma dimensão:
c
x
a
dt
dx
que pode ser reescrita da seguinte forma:
x
a
a
a
c
dt
dx
1 0 1−
=
Se no tempo inicial t0 o valor de x(t0) é dado (conhecido), os valores seguintes de x podem ser
determinados por:
t
dt
dx
x
x
k x kk+1
=
+
∆
Aplicando o algoritmo acima sucessivamente poderemos achar valores de x(t) considerando uma quantidade razoável de pontos entre o estado inicial (t0,x0) e o estado final (tf,xf). O método
de Euler assume que a derivada é constante em todo o intervalo ∆t . Uma melhoria pode ser obtida calculando a derivada se calcula a derivada no início e no final do intervalo e então o valor médio entre eles. Este algoritmo é conhecido como Método modificado de Euler, e é dado por:
t
dt
dx
dt
dx
x
x
p k k x x k c k∆
+
+
=
+ +2
1 1Usando o algoritmo acima encontrar a solução numérica para a equação diferencial a seguir, considerando que t = 15 segundos em passos de 0,01 segundos.
t
t
x
dt
t
dx
π
8
sin
10
)
(
2
)
(
4
+
=
é dado que x0 = 1.O programa desenvolvido (e comentado) é:
a1=4; a0=2; % define as constantes da equacao
x0=1; t0=0; % tempo inicial, valor dos passos a serem feitos Dt=0.01; tf=15; % tempo final
t=[]; x=[]; % Cria duas matrizes vazias que sera preenchida com valores de t e x np=(tf-t0)/Dt; % determina o numero de passos no caso 1500
t(1)=t0; x(1)=x0; % atribui a t e x os seus valores iniciais for k=1:np
c=10*sin(8*pi*t(k)); % componente em seno em t(0)=0;t(1501)=2,89 t(k+1)=t(k)+Dt; % incrementa t, t(1)=0,01; em t(1500)=15,00
Dx1=c/a1 - a0/a1*x(k); % cal. a inc. da curva tangente(derivada)... x(k+1) = x(k)+Dx1*Dt;
Dx2=c/a1 - a0/a1*x(k+1);
Dxavg=(Dx1+Dx2)/2; % calcula a media
x(k+1)=x(k)+Dxavg*Dt; % calcula o incremento em x end
plot(t,x), grid
O resultado, após rodar o mesmo é mostrado no gráfico a seguir:
Exemplo:
Considere um sistema de n equações a n variáveis:
n n n n n
c
x
x
x
f
c
x
x
x
f
c
x
x
x
f
=
=
=
)
,...,
,
(
...
...
...
)
,...,
,
(
)
,...,
,
(
2 1 2 2 1 2 1 2 1 1O método mais usado para resolver sistemas não lineares de equações algébricas é o Método Newton Raphson. O Método consiste em sucessivas aproximações baseadas em um valor inicial estimado através da expansão das equações utilizando a série de Taylor:
[ ]
( ) 1 ( ) )1
(k k k k
C
J
X
X
+=
+
−∆
Onde
J
(k)é uma matriz onde os elementos são as derivadas parciais deF
(k) e∆
C
(k) é:) ( )
(k k
F
C
C
=
−
∆
Iniciando com os seguintes valores, x1 = 1, x2 = 1, e x3 = 1, resolver o seguinte sistema de
equações utilizando o método Newton Raphson.
6
3
3
11
3 2 3 1 1 3 2 2 2 1 2 3 2 2 2 1=
+
−
=
−
+
=
+
−
x
x
x
x
x
x
x
x
x
x
x
x
+
−
−
−
+
−
=
2 1 3 3 2 1 2 3 2 11
3
2
2
2
2
x
x
x
x
x
x
x
x
x
x
J
Obs.: A matriz Jacobiana se calcula da seguinte forma:
∂
∂
∂
∂
∂
∂
∂
∂
∂
∂
∂
∂
∂
∂
∂
∂
∂
∂
=
n n n n n nx
f
x
f
x
f
x
f
x
f
x
f
x
f
x
f
x
f
J
....
....
....
....
....
....
....
2 1 2 2 2 1 2 1 2 1 1 1Um programa em Matlab usando laços para resolver o sistema de equações pode ser dado por:
Dx=[10;10;10];% fixa valores iniciais para Dx. Estes valores são altos x=[1;1;1]; %Estima valores para as variaveis (solucao)
C=[11;3;6];
iter=0; % cria um contador para verificar o numero de interacoes
while max(abs(Dx))>=.0001 & iter <10; % Testa a convergencia inicialmente estipulado iter=iter + 1 % cria um contador de interacoes ate atingir o estipulado
F=[x(1)^2-x(2)^2+x(3)^2 % Calcula F x(1)*x(2)+x(2)^2-3*x(3)
x(1)-x(1)*x(3)+x(2)*x(3)]; DC=C-F % Faz a diferenca
J=[2*x(1) -2*x(2) 2*x(3) % calcula a matriz jacobiana x(2) x(1)+x(2)^2 -3
1-x(3) x(3) -x(1)+x(2)] Dx=J\DC
x=x+Dx % aproxima os valores de x (solucao) de acordo as interacoes end
A seguir o resultado para três interações, sendo uma inicial e outra a final: >> iter = 1 DC = 10 4 5 J =
1 2 -3 0 1 0
Dx = 6 5 4
x = 7 6 5 iter = 5
DC = -0.2465 -5.3369 0.0238
J =
5.1438 -6.8304 8.0736 3.4152 14.2356 -3.0000 -3.0368 4.0368 0.8433
Dx = -0.3929 -0.2852 -0.0215
x = 2.1790 3.1300 4.0153 iter = 10
-0.0000 -0.0032 0.0000
J =
4.0007 -6.0005 8.0000 3.0003 11.0020 -3.0000 -3.0000 4.0000 0.9999
Dx = 1.0e-003 * -0.2964 -0.2183 -0.0157 x = 2.0001 3.0001 4.0000
4. - Diagramas de Simulação:
Equações diferenciais representando uma malha podem ser escritas da seguinte forma:
)
(
)
(
)
(
)
(
)
(
)
(
t
Du
t
Cx
t
y
t
Bu
t
Ax
t
x
+
=
+
=
•Este sistema de equações diferenciais de primeira ordem é conhecido como Equações de Estado de um sistema, e x é o vetor de estado. Uma das vantagens desta representação é que fica mais fácil desenvolver soluções computacionais tanto para formas analógicas quanto digitais dos sistemas que elas representam.
Além do mais este método pode ser estendido para equações não lineares. Equações de estado podem ser obtidas diretamente através das equações diferenciais (de ordem n) ou diretamente do modelo de sistema identificando as variáveis de estado que são apropriadas à solução do mesmo.
Para ilustrar como se seleciona um conjunto de variáveis de estado, consideremos um modelo representado por uma equação diferencial linear de ordem n.
)
(
...
1 01 1
1
a
y
u
t
dt
dy
a
dt
y
d
a
dt
y
d
n n n n n=
+
+
+
+
−− −onde y(t) é a saída do sistema e u(t) é a entrada. Um modelo de estados para este sistema não é único e depende da escolha do conjunto de variáveis. Um conjunto útil de variáveis de estado, chamado de variáveis de fase, é definido como:
1 3
2
1
,
,
,...,
− • • •
=
=
=
=
n ny
x
y
x
y
x
y
x
1
+ •
=
x
kx
, para k = 1, 2, ...,n-1, e então podemos resolver os termosn n
dt
y
d
associando y a x da seguinte forma:
)
(
...
..
...
1 2 1 1 0 1 3 2 2 1t
u
x
a
x
a
x
a
x
x
x
x
x
x
x
n n n n n+
−
−
−
−
=
=
=
=
− • • − • •Em forma matricial:
)
(
1
0
.
.
.
0
0
.
.
.
...
1
...
0
0
0
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
0
1
...
0
0
0
...
0
1
0
.
.
.
1 2 1 1 2 1 0 1 2 1t
u
x
x
x
x
a
a
a
a
x
x
x
x
n n n nn
+
−
−
−
−
=
− − • • − • •a saída será dada pela equação:
[
]
x
y
=
1
0
0
...
0
O Matlab já tem funções prontas (arquivos. m) para resolver diferentes tipos de sistemas de equações diferenciais. Isto é, em vez de usarmos uma resolução própria coma a anterior usando a Matriz Jacobiana, usamos uma solução de acordo com o descrito teórico acima. O Matlab faz isso de diferentes maneiras, como mostram os exemplos a seguir;
a) Equação do oscilador de Van de Pol:
0
)
1
(
2 2 2=
+
−
−
x
dt
dx
x
dt
x
d
µ
, de acordo com o descrito acima pode ser reescrita da seguinteforma:
x
y
1=
edt
dx
y
2=
então 2(
1
y
12)
y
1dt
dy
−
−
=
µ
Fazemos uma função chamada “vdpoliri” que, que descreve a equação acima, e é dada a seguir:
function yprime=vdpoliri(t,y); mu=2;
yprime=[y(2)
No Matlab as derivadas são dadas por um vetor coluna, chamado yprime, neste caso salvamos a mesma e então rodamos o seguinte programinha:
intt=[0 30]; O tempo varia de 0 a 30 segundos, são as interações >> yo=[1;0]; As condições iniciais são 1 e zero
>> ode45('vdpoliri',intt,yo);
Então qual processo vai fazer a derivada (ode45) de quem, em quantas interações e em que condições iniciais.
O resultado é dado pelo gráfico a seguir:
b) Repetimos agora o calculo da equação:
x
t
t
dt
t
dx
π
8
sin
10
)
(
2
)
(
4
+
=
Então:
y
1=
x
edt
dx
y
2=
ou4
y
2+
2
y
1=
10
sin
8
π
t
Fazemos uma função, por exemplo: ”vdseniri1” e gravamos a mesma: function yprime=vdseniri(t,y);
a=4;b=2; yprime=[y(2)
10./a*sin(8*pi*t)-2./a*y(1)];
A seguir setamos os parâmetros, como o número de interações, condições iniciais, conforme a seguir e “calculamos” a equação diferencial:
intt=[0 150]; >> yo=[0;1];
O resultado é o exposto no gráfico a seguir.
4.1 - Exemplos de modelos matemáticos de sistemas
4.1.1 – Sistema massa mola
Como se sabe o sistema é descrito com a seguinte equação diferencial:
)
(
2 2
t
f
Kx
dt
dx
B
dt
x
d
M
+
+
=
que pode ser reagrupada da forma já apresentada anteriormente:
]
)
(
[
1
1 2 2
2 1
kx
Bx
t
f
M
dt
dx
x
dt
dx
−
−
=
Utilizamos os mesmo valores para resolver agora o exemplo apenas usando comandos. Primeiramente criamos uma função chamada mechsys, e gravamos a mesma no diretório em uso (o Matlab precisa achá-la quando a mesma é chamada).
function xdot = mechsys(t,x); F=25;
M =1; B =5; K = 25;
xdot = [x(2) ; 1/M*( F-B*x(2)-K*x(1))];
e então rodamos um programa para que forneça a resposta ao nosso problema. Isto pode ser feito, entre outras maneiras, como o seguinte programinha:
tspan = [0 ,3];% define o intervalo de tempo a ser usado na eq. diferencial x0 = [0, 0]; % define as condicoes iniciais
[t,x] = ode23('mechsys', tspan, x0);%chama a funcao mechsys, analisa a mesma de 0 a 3s nas cond. inic. 0 e 0
subplot(2,1,1), plot(t,x);
title('Tempo de resposta de um sistema mecanico translacional') xlabel('Tempo em segundos')
text(2,1.2, 'movimento') text(2,.2,'velocidade') d=x(:,1); v=x(:,2); subplot(2,1,2), plot(d,v)
title('velocidade versus movimento') xlabel('movimento')
4.1.2 – Sistema não linear – O Pêndulo
A maioria dos sistemas físicos é não linear. Um caso clássico de exemplo é dado pela oscilação de um pêndulo. Sabemos que neste caso o sistema é não linear, por isso o mesmo é limitado a um determinado intervalo onde se pode considerá-lo linear. Neste caso temos um senóide (função não linear) que é amortecido, isto é a oscilação dura um certo intervalo de tempo. Para sistemas não lineares não se pode aplicar o princípio da superposição. No entanto, limitando-se os intervalos de simulação podemos usar ode23 e ode 45 para resolver com boa precisão estes casos.
Considere o pêndulo esquematizado abaixo:
θ
Se
P
=
mg
, L o comprimento em metros, B o amortecimento em kg/m/s, m a massa em kg e θ o ângulo inicial de lançamento do pêndulo com a vertical, teremos:•
−
−
=
P
θ
Bl
θ
F
Tsin
e da Lei de Newton sabemos que:•
=
mL
θ
F
T , combinando as equações:0
sin
=
+
+
•• •
θ
θ
θ
BL
P
mL
, fazendox
1=
θ
e•
=
θ
2x
(variáveis de estado), poderemos escrever:1 2
2
sin
x
mL
P
x
m
B
x
•=
−
−
, da qual desenvolvemos o programa a seguir com o nome de pendulo.m.function xdot = pendulo (t,x); %cria uma funcao dependente do tempo e da posicao global g m P L B
xdot = [x(2) ; -B/m*x(2)-P/(m*L)*sin(x(1))];
e também o programa para rodar a simulação do pêndulo(pendulo1.m): global g m P L B
g= input ('De o valor da aceleracao da gravidade em m/s2: ');
m= input ('Entre com o valor da massa do pendulo em quilogramas: '); P=m*g; % calcula o peso
L= input('Entre com o valor do comprimento do pendulo em metros: '); B= input('Entre com o coef de atrito -entre 0 e 0.02, no ar- : ');
tf= input('A simulacao termina em (s): '); xi= input('A condicao de x em ti eh: '); xf= input('A condicao final de x em tf eh: '); tspan= [ti,tf];
x0= [xi,xf];
[t,x] = ode23('pendulo', tspan, x0); subplot(2,1,1), plot(t,x)
title('Resposta no tempo para o pendulo rigido') xlabel('Tempo em segundos')
text(3.2,3.1, 'Velocidade'), text(3.2,1.2, 'Angulo em radianos') th= x(:,1); w= x(:,2);
subplot(2,1,2), plot (th,w) title ('Plano de fase do pendulo')
xlabel('Posicao em radianos'), ylabel('Velocidade angular')
O leitor pode observar que as variáveis devem ser informadas através do teclado, e que existem, neste caso, variáveis globais, pois as mesmas são usadas em pendulo.m e pendulo1.m ao mesmo tempo.
As variáveis são informadas no espaço do Command Window, como é mostrado a seguir: De o valor da aceleracao da gravidade em m/s2: 9.8
Entre com o valor da massa do pendulo em quilogramas: .8 Entre com o valor do comprimento do pendulo em metros: 1 Entre com o coef de atrito -entre 0 e 0.02, no ar- : 0.02
Alguns aspectos importantes do programa a serem observados estão na figura a seguir:
Se o leitor deseja visualizar as variáveis, deve proceder como mostrado na figura a seguir, indo da esquerda para a direita.
Clique em Workspace (selecione), e com o botão direito clique sobre x a opção open. Deve-se visualizar então:
5 – Introdução ao Simulink
biblioteca já existente, modificados ou criados novos blocos que poderão integrar essa biblioteca.
As principais características são:
- Simulação interativa ao “vivo” é apresentada;
- Uma vasta biblioteca para a criação de sistemas lineares, não lineares, discretos ou híbridos;
- Possibilidade de criar-se hierarquias de forma ilimitada;
- Operações escalares ou vetoriais entre grandezas (ou blocos) são permitidas;
- Possibilidade de criação de novos blocos ou novas bibliotecas;
- Usos de blocos especiais como, por exemplo, de DSP’s da Texas ou Motorola.
5.1 – Parâmetros de simulação
Os parâmetros de simulação você ajusta clicando em “Simulation” e então ”Simulation parameters”. Este uma vez clicada fará aparecer, entre outros: Solver, Workspace I/O e Diagnostics.
No “Solver” você vai ajustar:
- O tempo de simulação, inicialmente ajustado para 0.0 à partida e 10.0 segundos o tempo final;
- O tipo de processo para resolver equações diferenciais a ser usado, inicialmente ajustados em ode45, variable-steep;
- Opções de saída (Aoutput Options) que é ajustada para “Refine output”. Em Workspace I/O você deve ajustar:
- Carregando (Load from Workspace) informações do espaço de trabalho, que poderão ser comandos do Matlab, uma matriz, etc;
- Salvando saídas para o espaço de trabalho(Save to worspace). Neste caso você pode especificar as saídas para serem salvas no espaço de trabalho.
Em Diagnostics você pode:
- Ajustar o nível das mensagens de avisos que o Matlab pode fornecer.
Para parar uma simulação você pode escolher Stop no menu ou usar as teclas Ctrl-T do teclado.
Para criar os sistemas de blocos, você deve abrir o Simulink Library Browser, clicando no ícone apropriado, e então File -> Novo modelo (New Model). Escolher os blocos de interesse, ou digitando no espaço find, o bloco de interesse (por exemplo: scope, para osciloscópio, ou
sum para um somador, int para o integrador, e assim por diante). Achando mesmo você pode simplesmente usar a técnica do “clicar e arrastar” para o espaço onde você vai construir seu modelo.
O exemplo a seguir demonstra isso.
Exemplo: Transformação de graus Celsius em Fahrenheit:
Na verdade o que se quer é um “sistema” que resolva a seguinte equação:
32
5
9
+
=
CF
T
T
Para isso são necessários os seguintes blocos:
- um bloco de rampa(ramp), onde estará a faixa de variação da temperatura;
- um bloco de constante (32);
- um bloco de ganho (gain), pois Tc é multiplicada por 9/5 que é um “ganho”; - um bloco soma 9 (sum);
O conjunto todo é mostrado a seguir:
Tem como resultado final o gráfico a seguir (todo o ambiente é mostrado):
Exemplo: - Resolver a equação diferencial (já resolvida de outra forma):
t
t
x
dt
t
dx
π
8
sin
10
)
(
2
)
(
4
+
=
Temos uma fonte que é o bloco do seno, onde os valores foram ajustados (clica-se rapidamente duas vezes sobre o bloco) em amplitude = 10 e freqüência = 2*pi. Temos um bloco que é um integrador. Antes dele vem uma derivada que é amplificada(gain) em 4 vezes e depois, pela integração temos o sinal simplesmente que terá um ganho 2. Este será visto no osciloscópio. O bloco do somador ajusta a igualdade entre os sinais. O integrador é setado para iniciar em um (como no exemplo anterior). O resultado no osciloscópio é mostrado a seguir:
5.2 Uma pequena tabela de métodos de integração e resolução de equações diferenciais
Métodos de integração
linsin Método para resolver equações lineares dinâmicas. Calcula a derivada e a saída a cada passo de saída.
rk23 Método de Runge Kutta de terceira ordem. Utilizado para resolver equações de sistemas não lineares descontínuos. É recomendada para sistemas mistos, contínuos e descontínuos, mas não para sistemas numéricos “pesados”( de difícil resolução). O método toma três passos internos [0,1/2,1] entre os pontos de saída.
rk45 Método de Runge Kutta de quinta ordem, com características similares ao rk23, exceto que ele toma seis passos internos entre os pontos de saída.
particularmente eficiente quando se manipula sistemas que tem resposta “suave” e não são numericamente pesados.
adams Também é um método com correção preditiva que usa um número variável de passos entre os pontos de saída.. Também é eficiente para manipulação de sistemas que dão uma saída suave e são
numericamente não muito pesados.
euler É um método de passo fixo. Ele calcula a derivada a cada ponto de saída.
Resolução de equações diferenciais
ode45 Método Dormand-Price(4,5), que por sua vez se baseia no método um passo de Runge Kutta. Este é o primeiro método a ser sempre tentado.
ode23 Método Bogacki Shampine(2,3), também baseado no método de Runge Kutta de um passo. Ele pode ser mais eficiente que o ode45 para tolerâncias mais amplas.
ode113 Método de múltiplos passos. Ë recomendado para avaliação de funções que consomem tempo e que as tolerâncias são pequenas.
ode15s Método multi passos, para resolver sistemas de ordem variável baseado em fórmulas de sucessivas diferenciações.
ode23s Método de passo fixo de segunda ordem
ode5, ode4, ode3, ode2 e ode1
São “solvers” de passo fixo, onde o usuário deve atribuir o valor de passos para a diferenciação (integração) numérica. Nos métodos anteriores, pode-se também atribuir os valores dos passos, porém existe a opção automático.
Tolerância(tolerance) É a quantidade permitida de erro relativo a cada passo. Normalmente fixa entre 1e-3 a 1e-6. Recomenda-se iniciar com 1e-3 e então, se necessário, ajustar.
Passo
mínimo(minimum step size)
É usado na partida/repartida(start/restart) da integração/diferenciação de um processamento(run) e depois de uma descontinuidade. É o mínimo intervalo permitido entre uma integração e outra. Pode-se entender como entre variáveis y=f(x), o quanto vale ∆x, sabendo se que o mesmo deve tender a zero.
Passo máximo (maximum step size)
É o limite máximo no tamanho do passo para dar a saída (gráfica) uma aparência suave. Para métodos de passos variáveis o ajuste do mesmo não afeta a precisão, porém pode ter efeitos na
apresentação da saída.
Exemplo:
Construir um bloco que simule as equações diferenciais, que representa um sistema massa/mola:
]
)
(
[
1
1 2 2
2 1
kx
Bx
t
f
M
dt
dx
x
dt
dx
−
−
=
=
onde M= 1kg , B = 5N/m/s, K= 25N/m e f(t) = 25µ(t).
Apenas na fonte step o tempo de passo (step time) deve ser diminuído, ficando próximo de zero, caso contrário a onda será deformada no inicio. Os demais não são necessários alterar, a menos que você deseja uma forma de onda mais suave no osciloscópio. Você pode então fazer testes, mundano a ode, os tempos, os passos, etc e observar o que é alterado.
O resultado deverá ter a seguinte forma na saída do osciloscópio. Aqui adaptado para ser “colado” no word, e não mais visto como aparece normalmente no osciloscópio.
Como foi feito isto? Para desenvolver documentos (como este), simplesmente copiar as figuras do osciloscópio não é uma forma adequada, pois no momento da impressão gera entre outros desconfortos o excesso de gasto de tinta. Então o que se faz é incluir dois blocos chamados To Workspace, como mostra o esquema a seguir:
Isto faz com que os mesmos dados que são enviados ao osciloscópio, também sejam enviados aos Workspace do Matlab. Os blocos necessitam de um nome (saída 01 e 02) e o
