Introduzione a Scilab

Contenuto 

Introduzione a Scilab 

Fabio Checconi 

7 novembre 2004 


Introduzione a Scilab

Contenuto 

Contenuto 

1 Il linguaggio 

Tipi fondamentali 

Aggregati 

2 Sistemi lineari 

3 Equazioni differenziali 

4 Simulazione 

Risposte temporali 

Scicos 

5 Programmazione 



Contenuto 

Contenuto 



Aggregati 



4 Simulazione 


Scicos 




Contenuto 

Contenuto 



Aggregati 



4 Simulazione 


Scicos 




Contenuto 

Contenuto 



Aggregati 



4 Simulazione 


Scicos 




Contenuto 

Contenuto 



Aggregati 



4 Simulazione 


Scicos 




Contenuto 

Cos’è Scilab 

Scilab è un’alternativa a MATLAB a sorgenti aperte, 

sviluppata dall’INRIA e liberamente scaricabile da Internet. 

Offre un linguaggio simile a quello di MATLAB e numerose 

routine dedicate ai problemi di controllo. 




Il linguaggio 

Sistemi lineari 

Equazioni differenziali 

Simulazione 

Programmazione 


Aggregati 

I tipi fondamentali manipolati da Scilab sono: 

scalari 

booleani 

stringhe 

polinomi 




Il linguaggio 



Simulazione 



Aggregati 


scalari 

booleani 

stringhe 

polinomi 




Il linguaggio 



Simulazione 



Aggregati 


scalari 

booleani 

stringhe 

polinomi 




Il linguaggio 



Simulazione 



Aggregati 


scalari 

booleani 

stringhe 

polinomi 



Polinomi 

Il linguaggio 



Simulazione 



Aggregati 

La funzione poly(r,’x’) crea un polinomio nella variabile x 

che ha gli elementi del vettore r come radici. 

Per introdurre p(x) = x 2 − 3x + 2 = (x − 1)(x − 2) si può 

usare: 

-->p=poly([1 2],’x’); 

oppure, più comodamente, 

-->x=poly(0,’x’); 

-->p=x^2-3*x+2; 



Il linguaggio 



Simulazione 


Polinomi: secondo esempio 


Aggregati 

Si può usare il monomio x della slide precedente per creare 

una funzione razionale fratta. Ad esempio se si vuole 

si può scrivere 

f (x) = 

x − 1 

x 3 + 3x 2 − 2x + 2 

-->f=(x-1)/(x^3+3*x^2-2*x+2); 



Aggregati 

Il linguaggio 



Simulazione 



Aggregati 

È possibile aggregare oggetti appartenenti ai tipi fondamentali 

in matrici oppure in liste. 

Quindi a differenza di MATLAB la matrice non è un tipo 

fondamentale; si possono creare matrici di scalari, di booleani, 

di stringhe e di polinomi. 



Liste 

Il linguaggio 



Simulazione 



Aggregati 

Una lista è un vettore di oggetti di tipo eventualmente non 

omogeneo. Possono far parte delle liste anche oggetti di tipo 

aggregato. 

-->l=list([1 2 3],’testo’,[1 2;3 4]); 

crea una lista contenente un vettore, una stringa ed una 

matrice. 

Per accedere un elemento della lista si usa la stessa notazione 

usata per gli elementi di un vettore: 

-->s=l(2); 



Liste con tipo 

Il linguaggio 



Simulazione 



Aggregati 

Una lista con tipo è una lista i cui elementi sono indirizzati 

tramite un nome specificato al momento della creazione, con 

la funzione tlist. 

-->tl=tlist([’tipolista’ ’primo’ ’secondo’], 

[1 2 3],’testo’); 

crea una lista di tipo ’tipolista’ avente per elementi un 

vettore ed una stringa. 

Si può accedere, per esempio, alla stringa con la notazione 

-->tl(’secondo’); 



Il linguaggio 



Simulazione 


Sistemi lineari a tempo continuo 

Un sistema lineare stazionario a tempo continuo del tipo 

ẋ = Ax + Bu 

y = Cx + Du 

x(0) = x 0 

è rappresentato da una lista con tipo creata con la funzione 

syslin (i parametri D ed x0 sono facoltativi): 

-->sl=syslin(’c’,A,B,C,D,x0); 



Il linguaggio 



Simulazione 


Sistemi lineari a tempo discreto 

Un sistema lineare stazionario a tempo discreto del tipo 

x(k + 1) = Ax(k) + Bu(k) 

y(k) = Cx(k) + Du(k) 

x(0) = x 0 

si rappresenta nel solito modo, specificando che è a tempo 

discreto con il primo parametro ’d’ 

-->sl=syslin(’d’,A,B,C,D,x0); 



Il linguaggio 



Simulazione 


Funzioni di trasferimento 

La funzione syslin può essere usata anche per descrivere un 

sistema nel dominio delle variabili s o z, specificando come 

parametro una funzione (o una matrice) di trasferimento: 

-->sl=syslin(dom,H); 

con dom=’c’ per un sistema a tempo continuo e dom=’d’ per 

un sistema a tempo discreto. 



Il linguaggio 



Simulazione 


Cambiamento di rappresentazione 

Per passare dalla rappresentazione di un sistema sl nello 

spazio degli stati alla matrice di trasferimento si può usare la 

funzione ss2tf(sl). 

Per il passaggio inverso si usa tf2ss(sl). 

Si può notare che avere i polinomi come tipi predefiniti 

permette di ottenere la matrice di trasferimento dalla relazione 

G(s) = C(sI − A) −1 B: 

-->G=C*inv(s*eye()-A)*B; 



Il linguaggio 



Simulazione 


Definizione di una funzione 

Una funzione si può definire in linea con deff(). Per esempio 

f (t) = 3t + sin(2πt) si definisce come: 

-->deff(’[x]=f(t)’,’x=3*t+sin(2*%pi*t)’); 

Il primo argomento dichiara il nome della funzione e i 

parametri in ingresso ed uscita, mentre il secondo è il corpo 

vero e proprio. 



Integrazione 

Il linguaggio 



Simulazione 


Un’equazione differenziale del tipo 

dy 

dt 

= f (t, y) 

y(0) = y 0 

si risolve con ode(y0,t0,t,f), in cui y0 è il vettore delle 

condizioni iniziali, t0 l’istante iniziale, t un vettore con i tempi 

per cui si vogliono le soluzioni ed f è la funzione di t ed y da 

integrare. 



Esempio 

Il linguaggio 



Simulazione 


Per avere i valori di y(t) soluzione di 

dy 

dt 

= 3t + sin(2πt) 

y(0) = 0 

per t = 1, 2, . . . , 10 si può scrivere: 

-->deff(’x=f(t,y)’,’x=3*t+sin(2*%pi*t)’); 

-->y=ode(0,0,1:10,f); 



Il linguaggio 



Simulazione 


Esempio: risposta di un sistema lineare 

Data la rappresentazione nello spazio degli stati di un sistema 

SISO sl si vuole risolvere 

dx 

dt 

= Ax + Bu 

Rispetto al caso precedente f è funzione di x ma anche di u: 

invece di specificare f come funzione si specifica come lista di 

funzioni. La prima è quella da integrare e può chiamare le 

successive. 



Il linguaggio 



Simulazione 


Esempio (continua) 

Per estrarre A, B, C e D da sl si scrive: 

-->[A,B,C,D]=abcd(sl); 

Si definiscono u e la funzione da integrare e si crea la lista: 

-->deff(’x=u(t)’,’if t < 0 then x=0; else x=1; end’); 

-->deff(’x=sist(t,y,u)’,’x=A*y+B*u(t)’); 

-->l=list(sist,u); 



Il linguaggio 



Simulazione 



Si può risolvere l’equazione, richiedendo il vettore degli stati 

per t = 0, . . . , 20 e calcolare le uscite corrispondenti: 

-->x=ode(sl(’x0’),0,0:20,l); 

-->y=C*x+D; 



Il linguaggio 



Simulazione 



Scicos 

Risposta di un sistema a tempo continuo 

Per avere la risposta temporale ad un ingresso u agli istanti 

contenuti nel vettore t del sistema sl si usa la funzione csim: 

-->y=csim(u,t,sl); 

u può essere una funzione, un vettore contenente gli ingressi ai 

tempi in t, la stringa ’step’ per la risposta al gradino oppure 

’impuls’ per la risposta impulsiva. 



Il linguaggio 



Simulazione 



Scicos 

Risposta di un sistema a tempo discreto 

Per i sistemi a tempo discreto si usa flts: 

-->y=flts(u,sl); 

u è il vettore degli ingressi. 



Il linguaggio 



Simulazione 


Disegnare un grafico 


Scicos 

La funzione plot2d([x],y) disegna in un grafico i valori di y 

in corrispondenza di quelli di x. x è opzionale, sia x che y 

devono essere vettori colonna. 

Per esempio per disegnare f (t) = sin(2πt) per 0 ≤ t ≤ 1 

spaziando i campioni di 0.01 si usa: 

-->t=0:.01:1; 

-->f=sin(2*%pi*t); 

-->plot2d(t’,f’); 



Il linguaggio 



Simulazione 


Risposta in frequenza 


Scicos 

La risposta in frequenza di un sistema sl si può disegnare 

usando la funzione bode: 

-->bode(sl); 



Scicos 

Il linguaggio 



Simulazione 



Scicos 

Scilab offre un toolbox analogo al Simulink di MATLAB per 

creare modelli di sistemi complessi e per simularli. Per 

richiamarlo si usa il comando scicos. 

L’interfaccia è la stessa di Simulink, ma i modelli creati non 

sono compatibili. 



Il linguaggio 



Simulazione 



È possibile estendere le funzionalità dell’ambiente di Scilab 

definendo nuove funzioni (come in parte si è già visto) in un 

linguaggio che offre costrutti simili a quelli di MATLAB. 

Nonostante gli M-file non siano completamente compatibili 

con la sintassi di Scilab si possono importare con 

mfile2sci(path). 

A differenza di MATLAB bisogna caricare in modo esplicito i 

file che contengono funzioni, con getf(path). 



Il linguaggio 



Simulazione 


Esempio: algoritmo di Leverrier 

Si vuole calcolare (zI − A) −1 con A, I ∈ R N mediante 

l’algoritmo di Leverrier: 

Inizializzazione: 

Ricorsione: 

Verifica: 

a 0 = 1 

M 1 = I . 

a k = − 1 k tr (AM k) , con k = 1, . . . , N 

M k+1 = a k I + AM k , con k = 1, . . . , N − 1. 

AM N + a N I = 0. (1) 



Il linguaggio 



Simulazione 



function [P,err]=leverr(A) 

z=poly(0,’z’); 

M=eye(A); 

N=M;D=1; 

for k=1:size(A,1)-1 

a=-trace(A*M)/k; 

M=A*M+a*eye(); 

N=N*z+M; 

D=D*z+a; 

end 

a=-trace(A*M)/k; 



Il linguaggio 



Simulazione 


Esempio: usare la funzione 

Prima di usare la funzione bisogna salvarla in un file esterno, 

per esempio lev.sci e caricarla con: 

-->getf(’lev.sci’); 

A questo punto si può chiamare con: 

-->x=leverr(A); 



Riferimenti 

Riferimenti 

Download e documentazione: scilabsoft.inria.fr

Introduzione a Scilab

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?