Sei sulla pagina 1di 48

Introduzione al Simulink

 SIMULINK uno strumento software per la


modellizzazione, la simulazione e lanalisi dei
sistemi dinamici.
 supporta sistemi lineari e non lineari, modellizzati
a tempo continuo, tempo discreto.
 utilizza una interfaccia grafica che consente di
costruire i modelli come dei diagrammi a blocchi.
 vantaggio: non richiede la formulazione di
equazioni differenziali, ne la conoscenza di un
linguaggio particolare.
Matlab Simulink & S-Function

pag. 1

Introduzione al Simulink
 Una volta definito il modello questo pu essere
immediatamente simulato (senza compilazione).
 La simulazione di modelli Simulink richiede
lintegrazione numerica di equazioni differenziali
ordinarie (ODE)
 abbiamo solutori a passo variabile e solutori a
passo fisso.
 Solutori a passo variabile sono gli stessi di Matlab
ode45, ode23,ode113, ode15s, ode23s, ode23t,
ode23tb, che permetto di risolvere anche problemi
stiff.
Matlab Simulink & S-Function

pag. 2

I blocchi pi usati: Sources


 constant: ingresso costante

1
Constant

 signal generator: generatore definibile dallutente

S ignal
G e n e ra to r

 step: gradino
Step

 sine wave: generatore sinusoidale


Sine Wave

 clock: generatore del segnale temporale del sistema


 from workspace: ingresso dati dal workspace

Clock

simin
From
Workspace

 band limited white noise: rumore bianco


Matlab Simulink & S-Function

Uniform Random
Number

pag. 3

I blocchi pi usati: Sinks


 scope: visualizzatore grafico
Floating
Scope

 xy graph: visualizzatore grafico (in funzione dei 2 ingressi)


XY Graph

 display: visualizzatore numerico


Display

 to file: salva i dati su file


 to workspace: salva i dati nel workspace

untitled.mat

 stop simulation: interrompe la simulazione

To File

simout
To Workspace

Matlab Simulink & S-Function

pag. 4

Sinks

Matlab Simulink & S-Function

pag. 5

Sources & Sinks

Matlab Simulink & S-Function

pag. 6

I blocchi pi usati: Math Operations & User Defined


Function

















abs valore assoluto


trigonometric function funzioni trigonometriche
math function implementa funzioni matematiche varie
rounding function implementa funzioni di approssimazione
minmax massimo e minimo
product prodotto
logiacl operator operatori logici
sign segno
saturation saturazione
transport delay ritardo
variable transport delay ritardo variabile
hit crossing segnala i passaggi per lo 0
fcn implementa una funzione (sintassi C)
MATLAB fcn richiama una funzione Matlab
S-function richiama una S-function
switch interruttore

 manual switch interruttore manuale


Matlab Simulink & S-Function

pag. 7

I blocchi pi usati: Math Operation


 gain: guadagno
 sum: somma/sottrazione
 integrator: integratore
 transfer function: funzione di trasferimento
 derivative: derivata
 dot product: prodotto fra vettori
 matrix gain: guadagno matriciale
 sider gain: guadagno modificabile dallutente durante la
simulazione
Matlab Simulink & S-Function

pag. 8

I blocchi pi usati: Connections & Port and


Subsystem
 in: input port
 out: output port
 mux: combina i segnali in ingresso
 demux: scompone il segnale in ingresso
 enable: input di abilitazione di un sistema
 subsystem: definizione di un sottosistema definito
aggregando un insieme di blocchi
 selector: permette di selezionare particolari segnali in
ingresso
 width: dimensione segnale in ingresso
Matlab Simulink & S-Function

pag. 9

Simulation Parameters menu

metodo di integrazione

controllo della precisione

Matlab Simulink & S-Function

pag. 10

Scelta parametri di integrazione


 Tolleranza relativa: Rappresenta l'errore percentuale di ogni
stato.
 Tolleranza assoluta: Rappresenta l'errore assoluto del valore
di uno stato quando questo si avvicina allo zero.
 Passo di integrazione massimo: Controlla il valore massimo
del passo di integrazione del metodo di integrazione scelto.
t stop t start
Il valore di default dato dalla formula
h =
max

50

 Passo di integrazione iniziale: Viene impostato dal sistema


analizzando le derivate al primo passo di integrazione. Il
valore impostato solo un valore consigliato che viene
ridotto in caso di necessit dal sistema se l'errore non
soddisfacente
Matlab Simulink & S-Function

pag. 11

Avviare Simulink
Nella finestra di comando di MATLAB (command window), nel
prompt >> , digitare simulink e premere Enter

Oppure cliccare sullapposita icona

Matlab Simulink & S-Function

pag. 12

Creare un nuovo modello


 Cliccare licona nuovo
modello nellangolo in
alto a sinistra per aprire
un nuovo file Simulink

 Selezionare licona
Simulink per ottenere gli
elementi del modello

Matlab Simulink & S-Function

pag. 13

Workspace

Libreria degli elementi Il modello verr creato in questa finestra

Matlab Simulink & S-Function

pag. 14

Un semplice esempio
 Costruire un modello Simulink
che risolve lequazione
differenziale
x = 3 sin (2t )
 Condizione iniziale x(0)=-1
 Si inizia delineando lo schema a
blocchi di questo modello
matematico
 Lingresso la funzione di
forzamento: 3sin(2t)
 Luscita la soluzione
dellequazione differenziale: x(t)
 Si pu iniziare a comporre lo
schema Simulink
Matlab Simulink & S-Function

pag. 15

Selezionare il blocco dingresso

Matlab Simulink & S-Function

pag. 16

Selezionare il blocco operativo

Matlab Simulink & S-Function

pag. 17

Selezionare il blocco duscita

Matlab Simulink & S-Function

pag. 18

Collegare i blocchi con i segnali


 Posizionare il puntatore
sulla porta di uscita ( > )
del blocco SineWave
 Trascinare luscita del
blocco
SineWaveallingresso del
blocco Integrator
 Trascinare luscita del
blocco Integrator
allingresso del blocco
Scope

Matlab Simulink & S-Function

pag. 19

Selezionare i parametri di simulazione


 Doppio click sul
blocco SineWave
per settare:
amplitude= 3
frequency= 2
 Questo produrr
lingresso
desiderato 3sin(2t)

Matlab Simulink & S-Function

pag. 20

Selezionare i parametri di simulazione

 Doppio clik sul


blocco Integratorper
settare la condizione
iniziale = -1
 Questo setta la IC
x(0) = -1

Matlab Simulink & S-Function

pag. 21

Risultati della simulazione


 Nella finestra del modello,
dal men a tendina
Simulation, selezionare
Start osservare
luscitax(t)nella finestra
Scope
 Per verificare che
landamento ottenuto
rappresenti la soluzione
cercata, si risolve lequazione
analiticamente:
 Il risultato analitico che
coincide esattamente con il
grafico (il risultato della
simulazione)

Matlab Simulink & S-Function

1 3
x(t ) = cos(2t )
2 2
pag. 22

Definizione S-Functon
S-Function
 una descrizione, mediante linguaggio di
programmazione, di un sistema dinamico.
 Il codice pu essere scritto in Matlab o C.
 Le S-Function scritte in C sono compilate come MEX-file
(Memory Executable) utilizzando il comando mex
allinterno della Command Window.
 La forma di una S-Function molto generale e pu
descrivere sistemi continui e discreti
 Tutti i modelli Simulink a blocchi possano essere descritti
come S-Function

Matlab Simulink & S-Function

pag. 23

S-Function genera una DLL


 Dopo la compilazione della S-Function il codice
generato contenuto in una libreria dinamica o DLL
(Dynamic Link Library).
 La DLL viene invocata dal Matlab in modo dinamico
(cerca nel path); una volta effettuato, il collegamento
diventa stabile (la DLL risulta in permanente
utilizzazione da parte del Matlab) per cui la DLL non
pi cancellabile (da Explorer) o modificabile (da un
programma esterno a Matlab) finch dal Matlab non
viene eseguita l'istruzione "clear mex" o viene
ricompilata di nuovo tramite l'istruzione "mex".
 Se esistono due S-Function una scritta in C e una scritta
come m-file viene eseguita sempre la prima.
Matlab Simulink & S-Function

pag. 24

Quando utilizzare una S-Function

 Aggiungere blocchi di utilit al Simulink.


 Velocizzare notevolmente la simulazione integrando
codice C .
 Una stessa S-function pu essere utilizzata in pi punti
della stessa simulazione, modificando solamente i
parametri con cui la S-function viene invocata.
 Descrivere un sistema come una sequenza di istruzioni.

Matlab Simulink & S-Function

pag. 25

Matlab & Simulink

Simulazione di un sistema dinamico

Matlab Simulink & S-Function

pag. 26

Simulazione in ambiente Matlab/Simulink


 Anche se il modello pu essere definito interamente
nellambiente Simulink, questa scelta fornisce una
soluzione molto limitata e rigida
 E preferibile dividere il modello fra i due ambienti
 Nel codice Matlab di lancio si definiscono
 i valori dei parametri
 i valori delle condizioni iniziali
 i parametri della simulazione (tempo finale, precisione, etc.)

 Nello schema simulink si definisce il modello


 come schema a blocchi
 come S-function
 scritta in codice Matlab
 scritta in codice C e compilata come C-MEX ottenendo una DLL
Matlab Simulink & S-Function

pag. 27

Simulazione di un sistema dinamico


Modulodidilancio
lancio
Modulo
MATLAB
MATLAB

ModulodidiSimulazione
Simulazione
Modulo
SIMULINK
SIMULINK

ModelloSIMULINK
SIMULINK
Modello
blocchi
aablocchi

Definisce i parametri del modello e della simulazione.


Specifica il modello e le modalit di simulazione.

Esegue la simulazione con i parametri


ed il modello definito da Matlab
Contiene i motori di integrazione

Blocco
BloccoS-function
S-function

definizione del modello


in linguaggio Matlab
Matlab Simulink & S-Function

E necessario un
compilatore C per
generare la DLL

definizione del modello


in linguaggio C/C++
pag. 28

Modulo Simulink a blocchi: la cinetica di Monod


dS
1 max S
Dinamica del substrato:
=
X
dt
Y Ks + S
dX max S
=
X Kd X
Dinamica della biomassa:
Ks + S
dt

Mmax/(1+Ks/u[1])
Monod kinetics

-1/Y
Product

Yield

Kd
decay

Matlab Simulink & S-Function

Sum1

1
s
Integrale di S

S
To Workspace

1
s
Integrale di X

X
To Workspace1

pag. 29

Valutazione della soluzione a blocchi


 Vantaggi:
 Comprensione immediata del modello
 Possibilit di cablare modelli di qualsiasi
complessit
 Svantaggi:
 in molti casi la scrittura di codice sequenziale pi
immediata
 difficolt di lettura e correzione se il modello
complesso
 lentezza di esecuzione
 Alternativa: riunire tutte le equazioni di modello in
ununica S-function

Matlab Simulink & S-Function

pag. 30

Comunicazione fra modulo Matlab e Simulink


globalPPIC
IC%Ks
%KsMu
MuYYKd
KdDDSX0
SX0Smo
SmoXmo
Xmo
global
Mu=0.5;Ks=150;Y=0.5;Kd=0.015;
Mu=0.5;Ks=150;Y=0.5;Kd=0.015;
Smo=10;Xmo=5;
Smo=10;Xmo=5;
IC=[SmoXmo];
Xmo];
IC=[Smo
chiamata al simulatore
P=[MuKs
KsYYKd];
Kd];
P=[Mu
tfin=150;
tfin=150;
[t,x,y]=sim('SmonS',tfin);
[t,x,y]=sim('SmonS',tfin);

Modulo MATLAB
(Programma di lancio)

SmonS
function [sys, x0] = Monod_Kinetics(t,x,u,flag)
global P IC
Signal
Mu=P(1);
Generator
Ks=P(2);
Y=P(3);
Kd=P(4);
%Assegnazione delle condizioni iniziali
Smo=IC(1);
Xmo=IC(2);
% Definizione delle equazioni del modello
...........................................
if abs(flag) == 1,
dx(1)=-(1/Y)*Mu*x(1)*x(2)/(Ks+x(1));
dx(2)=Mu*x(1)*x(2)/(Ks+x(1))-Kd*x(2);
sys = dx;
end
...........................................

Matlab Simulink & S-Function

Monod_Kinetics

Xout

S-Function

Modulo SIMULINK
(Esegue la simulazione)
Modulo S-Function
in linguaggio Matlab
(Definisce il modello)
pag. 31

Definizione del modello in Linguaggio C


SmonS
SMonod
#define MDL_DERIVATIVES
/* Function: mdlDerivatives
Signal
* calcolo del sistema differenziale non lineare
Generator
*/
static void mdlDerivatives(SimStruct *S)
{
real_T
*dx = ssGetdX(S);
real_T
*x = ssGetContStates(S);
InputRealPtrsType uPtrs = ssGetInputPortRealSignalPtrs(S,0);
real_T
*Par = mxGetPr(P_param(S));
real_T Mu=Par[0];
real_T Ks=Par[1];
real_T Y=Par[2];
real_T Kd=Par[3];
/* stato del sistema
* x(0) substrato
* x(1) biomassa
*/
/* velocit di reazione */
dx[0]=(-1/Y)*Mu*x[0]*x[1]/(Ks+x[0]);
dx[1]=Mu*x[0]*x[1]/(Ks+x[0])-Kd*x[1];
}

Matlab Simulink & S-Function

Xout

S-Function

La rimanente
parte della
struttura in C
rimane
praticamente
invariata

pag. 32

Parametri della S-function


 Nel caso di S-function scritta
in linguaggio Matlab, non
sono necessari parametri di
chiamata
 I parametri del modello e
le condizioni iniziali sono
passati direttamente
attraverso la
dichiarazione global

 Nel caso di S-function che fa


riferimento ad una DLL, i
parametri e le condizioni
iniziali devono essere passati
da riga di comando, usando i
nomi di vettori definiti nel
programma di lancio
Matlab Simulink & S-Function

pag. 33

Corpo della S-function in Matlab (1)


function [sys, x0] = Monod_Kinetics(t,x,u,flag)
%SFUNCONT An example S-function for continuous systems.
%
This M-file is designed to be used as a template for other
%
S-functions.

La S-function ha una struttura a


flag: a seconda del valore assunto
dal flag, essa esegue compiti diversi

% Uncomment the following two lines to show how the flags are called.
% dispString=['flag = ' num2str(flag) ' at time = ' num2str(t)];
% disp(dispString)
Si dichiarano globali i parametri e
global P IC
le condizioni iniziali
Mu=P(1);
Ks=P(2);
Definizione dei parametri e delle
Y =P(3);
Kd =P(4);
condizioni iniziali
Smo=IC(1);
Xmo=IC(2);
if abs(flag) == 1,
flag = 1 corrisponde alla
dx(1)=-(1/Y)*Mu*x(1)*x(2)/(Ks+x(1));
risoluzione delle equazioni
dx(2)=Mu*x(1)*x(2)/(Ks+x(1))-Kd*x(2);
differenziali
sys = dx;
end
if flag == 3,
% If FLAG==3, then SIMULINK wants to know what the next output is. flag = 3 corrisponde al calcolo
% **** In this template system, y gets the current state x ****
delluscita a partire dallo stato
% (SYS =) Y = X
sys = x;
end

Matlab Simulink & S-Function

pag. 34

Corpo della S-function in Matlab (2)


if flag == 0,
% This part takes care of all initialization; it is used only once.
% The sizes vector is six elements long, and it looks like this:
sizes(1) = 2; % number of continuous states
Definizione della struttura del
sizes(2) = 0; % number of discrete states
sistema: numero di ingressi, stati,
sizes(3) = 2; % number of system outputs
uscite
sizes(4) = 1; % number of system inputs
sizes(5) = 0; % number of discontinuous roots; unused
feature, set to zero
sizes(6) = 0;
% Set the initial conditions on the states Assegnazione delle condizioni
x0 = [Smo Xmo];
iniziali provenienti dal programma
sys = sizes';
di lancio Matlab
end
if flag==2 |flag==4
Se non ci sono stati discreti il flag
% Flags not considered here are treated as unimportant.
2 e 4 non vanno settati
% Notice that since there are no discrete states in this system,
% there is no need to deal with FLAG==2 or FLAG==4.
% Output is set to [].
sys = [];
end

% if abs(flag) == ...

Matlab Simulink & S-Function

pag. 35

Il blocco S-function
Ogni C-MEX S-function deve avere la seguente forma :
#define S_FUNCTION_NAME nome_della_sfunction
#define S_FUNCTION_LEVEL 2
#include simstruc.h
static void mdlInitializeSizes(SimStruct *S)
{
}
< routines di calcolo >
static void mdlTerminate(SimStruct *S)
{
}
#ifdef MATLAB_MEX_FILE
#include simulink.c
#else
#include cg_sfun.h
#endif

Matlab Simulink & S-Function

si definisce il numero di stati,


di ingressi, di uscite e di
parametri

Dedinizione delle operazioni


che l S-Function deve fare
prima di essere terminata

pag. 36

Struttura
Start

mdlInitializeSizes
mdlInitializeSampleTimes

mdlOutputs

mdlTerminate
Matlab Simulink & S-Function

pag. 37

mdlInitializeSizes
 mdlInitializeSizes la prima routine che Simulink
chiama quando interagisce con una S-function; in
seguito Simulink agisce chiamando altre routines ( tutte
le funzioni utilizzate da Simulink per eseguire la
simulazione iniziano con mdl ed hanno come
argomento la struttura SimStruct )fino al
raggiungimento della routine mdlTerminate che viene
chiamata da Simulink quando la simulazione
terminata
 La funzione mdlInitializeSizes viene chiamata da
Simulink quando viene disegnato il blocco S-function
per la prima volta ed utilizzata per determinare il
numero di ingressi e di uscite da associare al blocco
stesso.
Matlab Simulink & S-Function

pag. 38

mdlInitializeSampleTimes, mdlOutputs, mdlTerminate

 La funzione mdlInitializeSampleTimes viene chiamata


da Simulink in fase di esecuzione per valutare il tempo
di campionamento dellintero sistema di simulazione.
 La funzione mdlOutputs viene eseguita in simulazione
ogni volta che Simulink ha necessit di aggiornare le
uscite del blocco S-function;
 La funzione mdlTerminate viene eseguita alla fine della
simulazione; in qualche caso vuota se non si devono
eseguire operazioni particolari, come ad esempio la
chiusura di un file che stato utilizzato durante tutta la
simulazione

Matlab Simulink & S-Function

pag. 39

Riassumendo la Simstruc.h
 Ogni S-function contiene ingressi, uscite, parametri, stati, condizioni
iniziali e parametri di esecuzione come il tempo di campionamento.
 Tutti questi dati vengono salvati in una struttura a cui Simulink attinge
ogni volta che, durante lelaborazione, viene richiesto una qualche dato.
 Laccesso a tali dati avviene attraverso opportune macro, presenti nella
libreria Simstruc.h, che operano per mezzo di puntatori ed accedono
direttamente alla struttura di dati.
 Ogni modifica dei dati viene salvata immediatamente allinterno della
SimStruct; ci comporta che, oltre ad una maggiore velocit ed un
notevole risparmio di memoria, ogni errore commesso nellaccesso ai
dati risulta essere irreversibile e comporta il blocco del programma. Per
questo motivo laccesso ai dati contenuti nella struttura deve avvenire solo
per mezzo delle apposite macro (la lista completa di tutte le macro
presente in The C MEX S-function SimStruct), ed il cui uso deve essere
ben controllato.
 La struttura dei dati SimStruct viene generata da Simulink eseguendo
particolari funzioni mdl;

Matlab Simulink & S-Function

pag. 40

Macro
 Le principali macro sono :
 ssSetNumSFcnParams (S,n): rilascia lo spazio allinterno della struttura
SimStruct S per n parametri;
 ssSetNumContState(S,n) : rilascia lo spazio allinterno della struttura
SimStruct S per n stati continui;
 ssSetNumDiscState(S,n) : rilascia lo spazio allinterno della struttura
SimStruct S per n stati discreti;
 ssSetNumInputPorts (S,n) : rilascia lo spazio allinterno della struttura
SimStruct S per n porte di ingresso;
 ssSetInputPortWidth (S,n,nc) : rilascia lo spazio allinterno della struttura
SimStruct S per un vettore di nc componenti legato alla porta di ingresso n;
 ssSetInputPortDirectFeedThrough (S,n,0 o 1) : informa Simulink che
lingresso n della struttura S viene utilizzato (valore 1) o non viene utilizzato
(0) per valutare luscita del blocco;
 ssSetNumOutputPorts (S,n) : rilascia lo spazio allinterno della struttura
SimStruct S per n porte di uscita;
 ssSetOutputPortWidth (S,n,nc) : rilascia lo spazio allinterno della struttura
SimStruct S per un vettore di nc componenti legato alla porta di uscita n;
 ssSetNumSampleTimes (S,n) : rilascia lo spazio allinterno della struttura
SimStruct S per n diversi passi di campionamento;
Matlab Simulink & S-Function

pag. 41

Gestione dei Parametri


 Ogni S-function pu ricevere dei parametri dallesterno;
Ma bisogna determinare lordine in cui i parametri
vengono specificati nel dialog box del blocco S-function.
 Nella funzione mdlInitializeSizes occorre usare la macro
ssSetNumSFcnParams(S,n) per riservare spazio allinterno
della SimStruct per i parametri; con S si indica la
SimStruct e con n il numero di parametri che la struttura
deve contenere.
 Si pu accedere ai parametri utilizzando la macro
ssSetSFcnParam (S,n); dove con S si indica la struttura in
cui sono memorizzati i dati e con n si indica la posizione
che il particolare parametro occupa nella dialog box.
 Quando la simulazione viene fatta girare, Simulink legge i
parametri dalla dialog box e li pone in un array allinterno
della struttura, larray mantiene lo stesso ordine che i dati
avevano nella dialog box.
Matlab Simulink & S-Function

pag. 42

Gestione Parametri
 Per esempio se vogliamo usare quattro parametri : A,B,C e D
occorre inserire nella funzione mdlInitializeSizes la riga
ssSetNumSFcnParams(S,4);
 Per utilizzare i parametri si useranno le seguenti macro :
A=ssGetSFcnParam(S,0)
B=ssGetSFcnParam(S,1)
C=ssGetSFcnParam(S,2)
D=ssGetSFcnParam(S,3)
 Le macro restituiscono un puntatore che contiene lindirizzo
del dato di interesse quindi si possono usare anche dei vettori
di parametri, facendo attenzione ad eseguire la giusta
indicizzazione del puntatore.
Matlab Simulink & S-Function

pag. 43

Gestione degli Stati


 Le informazioni relative agli stati vengono inserite allinterno della
SimStruct in due passi successivi:
1. Allinterno della funzione mdlInitializeSizes vengono descritti il
tipo e il numero degli stati che compongono il sistema
2. Allinterno della funzione mdlInitializeConditions vengono
assegnate le condizioni iniziali necessarie allintegrazione del
modello.
Lassegnazione delle condizioni iniziali richiede lutilizzo di una
apposita macro per accedere allarea di memoria della struttura
SimStruct in cui sono salvati i dati relativi allo stato.
Simulink prevede due differenti macro per accedere allo stato a
seconda che sia continuo (ssGetContStates(S)) o discreto
(ssGetDiscStates(S)), ed entrambe restituiscono un puntatore.

Matlab Simulink & S-Function

pag. 44

Stato Continuo
 Nel caso di stato continuo Simulink mette a disposizione la
funzione mdlDerivateves allinterno della quale lutente deve
scrivere il codice necessario a calcolare la derivata dello stato;
tipicamente il corpo di una equazione differenziale.
 Allinterno di questa funzione , normalmente, necessario accedere
a molte informazioni contenute allinterno della SimStruct come
ad esempio lo stato, gli ingressi e larea di memoria della struttura
dove devono essere salvate le derivate una volta calcolate.
 Per accedere a queste aree delle SimStruct si devono utilizzare
apposite macro :
 ssGetdX(S) : permette di accedere allarea di memoria contenente
le derivate;
 ssGetContStates(S) : permette di accedere allarea di memoria
contenente lo stato;
 ssGetInputPortRealSignalPtrs(S,n) : permette di accedere
allingresso n del blocco S-function.
Matlab Simulink & S-Function

pag. 45

Corpo della S-function in C (1)


/* File
: SMonod.c
*/
#define S_FUNCTION_NAME SMonod
#define S_FUNCTION_LEVEL 2
#include "simstruc.h"
#define U(element) (*uPtrs[element]) /* Puntatore all'ingresso Port0*/
#define P_param(S) ssGetSFcnParam(S,0)
#define IO_param(S) ssGetSFcnParam(S,1)
#define NumeroParametri 2 /*numero totale di parametri */
#define NumeroStati 2
/*numero di stati continui */
#define NumeroUscite 2
/*====================*
* S-function methods *
*====================*/
/* Function: mdlInitializeSizes ===============================================
* inizializzazione:* si definisce il numero di stati, di ingressi, di uscite e di parametri
*/
static void mdlInitializeSizes(SimStruct *S)
{
ssSetNumSFcnParams(S, NumeroParametri); /* Numero di parametri attesi*/
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
return; /* Parameter mismatch will be reported by Simulink */
}
ssSetNumContStates(S, NumeroStati);
ssSetNumDiscStates(S, 0);
if (!ssSetNumInputPorts(S, 1)) return;
ssSetInputPortWidth(S, 0, 1); /* Ingresso scalare */
ssSetInputPortDirectFeedThrough(S, 0, 1);
if (!ssSetNumOutputPorts(S, 1)) return;
ssSetOutputPortWidth(S, 0, NumeroUscite);
ssSetNumSampleTimes(S, 1);
ssSetNumRWork(S, 0);
ssSetNumIWork(S, 0);
ssSetNumPWork(S, 0);
ssSetNumModes(S, 0);
ssSetNumNonsampledZCs(S, 0);
/* Take care when specifying exception free code - see sfuntmpl.doc */
ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE);
}

Matlab Simulink & S-Function

pag. 46

Corpo della S-function in C (2)


#define MDL_DERIVATIVES
/* Function: mdlDerivatives =================================================
* calcolo del sistema differenziale non lineare*/
static void mdlDerivatives(SimStruct *S)
{
real_T
*dx
= ssGetdX(S);
real_T
*x
= ssGetContStates(S);
InputRealPtrsType uPtrs = ssGetInputPortRealSignalPtrs(S,0);
real_T
real_T Mu=Par[0];
real_T Ks=Par[1];
real_T Y=Par[2];
real_T Kd=Par[3];
real_T D=Par[4];
/* stato del sistema
* x(0) substrato
* x(1) biomassa
*/
/* velocit di reazione */

*Par

= mxGetPr(P_param(S));

dx[0]=(-1/Y)*Mu*x[0]*x[1]/(Ks+x[0])+D*U(0);
dx[1]=Mu*x[0]*x[1]/(Ks+x[0])-Kd*x[1];
}
/* Function: mdlTerminate =====================================================
* eventuale blocco da eseguire alla chiusura della S function
*/
static void mdlTerminate(SimStruct *S)
{
}
#ifdef MATLAB_MEX_FILE
/* Is this file being compiled as a MEX-file? */
#include "simulink.c"
/* MEX-file interface mechanism */
#else
#include "cg_sfun.h"
/* Code generation registration function */
#endif

Matlab Simulink & S-Function

pag. 47

Confronto fra i tempi di esecuzione


Modello di Monod
35

30

Tempo di simulazione:
15000 min

25

Tempi di esecuzione:

Conc. (mg/l)

Substrato
Biomassa

Con S-function in Matlab:


1.0150 s

20

15

10

0
0

5000

10000
tempo (min)

15000

Con S-function in C:
0.0940 s
In questo caso il
guadagno di circa 10,
ma per sistemi complessi
si pu superare un fattore
100

Le uscite delle simulazioni sono identiche


Matlab Simulink & S-Function

pag. 48