Pentru a activa Simulink Accelerator, se selecteaza Accelerator din meniul Simulation al modelului de executat. Pentru a începe simularea se selecteaza Start din meniul Simulation.
Dupa actionarea butonului de start simulare, Accelerator genereaza cod C si îl compileaza. Accelerator executa apoi urmatoarele operatii:
Plaseaza codul C generat într-un subdirector numit modelname_accel_rtw (modelname este numele modelului)
Plaseaza fisierul MEX compilat în directorul de lucru curent.
Lanseaza în executie modelul compilat
Daca modelul nu se compileaza cel mai probabil comanda mex nu este setata corespunzator. Se poate executa comanda mex -setup din linia de comanda MATLAB pentru a selecta un compilator de C dintr-o lista afisata în timpul configurarii.
Accelerator foloseste tehnologia Real-Time Workshop pentru a genera codul folosit la accelerare executie modelului. Codul generat este utilizabil numai pentru accelerarea executie modelului. Daca se doreste folosirea codului pentru alte scopuri, este necesara utilizarea Real-Time Workshop.
Manevrarea schimbarilor în structura modelului
Dupa ce se foloseste Simulink Accelerator pentru a simula un model, fisierul MEX care contine versiunea compilata a modelului ramâne disponibil pentru utilizare ulterioara. Chiar daca se iese din mediul MATLAB, se poate reutiliza fisierul MEX într-o alta sesiune MATLAB sau Simulink. Daca se modifica structura modelului Simulink original prin adaugarea sau stergerea de blocuri, Accelerator regenereaza automat codul C care supraînscrie fisierul MEX existent. În permanenta fiierul MEX corespunzator va contine versiunea compilata a ultimului model Simulink folosit. Exemple de modificari structurale ale modelului care necesita ca Accelerator sa reia procesul de reconstructie sunt:
Schimbarea metodei de integrare
Adaugarea sau stergerea de blocuri sau conexiuni dintre blocuri
Schimbarea numarului de intrari sau de iesiri din blocuri, chiar daca dsipunem de o conectivitate vectorizata.
Schimbarea numarului de stari din model
Schimbarea functiei din blocul Trigonometric Function
Schimbarea semnelor unui bloc sumator
Adaugarea unui fisier Target Language CompilerTM (TLC) pentru o S-functie inline
Acceleratorul Simulink afiseaza mesaje de atentionare daca se încearca modificari nepermise în model, dar nu opreste simularea modelului. Pentru a face modificari în model se recomanda oprirea simularii, efectuarea modificarilor si apoi restartarea simularii. Modificari simple precum ajustarea unor alte valori pentru blocuri de amplificare nu cauzeaza mesaje de avertizare.
Îmbunatatirea performantelor modului Accelerator
În general, Simulink Accelerator creaza cod optimizat pentru viteza pentru majoritatea blocurilor disponibile în Simulink. Sunt însa situatii în care se mai poate îmbunatati performanta simularii. Aceste cazuri sunt prezentate mai jos.
Simulation Parameters dialog box - Optiunile din panourile Diagnostics si Advanced pot afecta performantele Accelerator-ului. Pentru cresterea performantelor este de dorit:
- dezafectarea Consistency checking si Bounds checking din panoul Diagnostics. Setati Signal storage reuse în panoul Advanced.
Stateflow -- Accelerator este complet compatibil cu Stateflow, dar nu poate îmbunatati performantele portiunilor Stateflow ale modelului. Dezafectati (deselectati) Stateflow debugging si animation pentru a creste performantele modelelor ce include blocuri Stateflow.
S-functii scrise de utilizator -- Accelerator nu poate îmbunatati viteza de simulare a S-functiilor decât daca ele sunt folosite inline folosind Target Language Compiler. Inline se refera la procesul de a crea fisiere TLC care directioneaza Real-Time Workshop pentru a crea cod pentru aceste S-functii. Aceste inline S-functii elimina apelurile repetate si inutile catre interfata program cu aplicatia (API- application program interface) a Simulink.
S-functii furnizate de Simulink sau blocksets - Desi Simulink Accelerator este compatibil cu toate blocurile prevazute de Simulink si blocksets, el nu va îmbunatati viteza de simulare pentru S-functii de tipul fisiere M sau C-MEX care nu dispun de un fisier TLC asociat pentru inline.
Gestionarea unor mari cantitati de date - daca se folosete Workspace I/O, To Workspace, To File, sau blocuri Scope, mari cantitati de date vor încetini functionarea Accelerator. Se poate încerca folosirea decimarii sau limitarii iesirilor la ultimele N puncte.
Modele mari - Atât în mod Accelerator cât si în mod Normal, Simulink poate consuma mult timp pentru initializarea acestor modele de dimensiuni mari. Creterea vitezei acceleratorului este minima daca timpul de simulare (de la startul la terminarea unei singure simulari) este mic.
Blocuri care nu conduc la cresterea vitezei de simulare
Simulink Accelerator creste viteza de simulare numai pentru blocuri din Simulink, Fixed Point, sau DSP blocksets. Mai mult, Accelerator nu poate îmbunatati performanta simularii pentru anumite blocuri din Simulink sau DSP blocksets. Iata lista acestor blocuri
Blocri Simulink
Display
From File
From Workspace
Inport (root level only)
MATLAB Fcn Outport (root level only)
Scope
To File
To Workspace
Transport Delay
Variable Transport Delay
XY Graph
Biquadratic Filter
Convolution
Direct-Form II Transpose Filter
Dyadic Analysis Filter Bank
Dyadic Synthesis Filter Bank
FIR Decimation
FIR Interpolation
FIR Rate Conversion
From Wave Device
From Wave File
Integer Delay
Variable Integer Delay
Matrix Multiply
Matrix To Workspace
Triggered Signal To Workspace
Triggered Signal From Workspace
Time-Varying Direct-Form II Transpose Filter
To Wave File
To Wave Device
Wavelet Analysis
Wavelet Synthesis
Zero Pad
Simularea Rapida (Rapid Simulation)
În Real-Time Workshop, rapid simulation target (rsim) consta într-un set de fisiere tinta (target files) pentru executia pe calculatorul gazda (host) a unor aplicatii, dar nu în timp real (nonreal-time execution). Se poate folosi rsim pentru a genera un set de simulari rapide de sine-statatoare care permit modificarea unor loturi de semnale de intare sau de parametri. Mentionam ca termenul de simulare se refera la faptul ca un program executabil, provenit printr-un proces build, este rulat cu posibilitatea modificarii unor serii de parametri. Modificarea parametrilor (semnale de intrare, parametri de simulare sau parametri ai modelului) se face fara a mai fi nevoie de o recompilare a modelului de referinta din Simulink.
Codul C generat de RTW este optimizat pentru a conferi viteza mare de executie modelelor Simulink ce contin sisteme dinamice hibride. Acestea include si modele care utilizeaza integratoare cu pas variabil sau cu detectia trecerii prin zero. Viteza de executie a codului generat fac din rsim un target ideal pentru modele la care facem o proiectare iterativa laborioasa, cu schimbarea frecventa a parametrilor. Executabilul generat (model.exe), creat folosind rsim target are interfata run-time necesara pentru a citi si scrie date din/în fisierele de date standard cu extensia .MAT. Folosind aceasta interfata, model.exe poate citi noi semnale sau parametri dintr-un fisier de intrare .MAT la începutul simularii si poate scrie rezultatele simularii într-un fisier de date de iesire .MAT.
Având construit un executabil rsim cu ajutorul RTW si a unui compilator corespunzator pe calculatorul gazda, se pot executa oricare dintre combinatiile urmatoare folosind optiuni din linia de comanda. Fara a recompila modelul, tinta rsim permite:
Specificarea a noi fisiere ce furnizeaza semnale de intrare folosindu-ne de blocurile Simulink From File.
Specificarea unui nou fisier care furnizeaza semnale de intrare cu orice tip de data Simulink (double, float, int32, uint32, int16, uint16, int8, uint8, si complex data) folosind blocul From Workspace.
Înlocuirea vectorului parametru al întregii diagrame bloc si rularea simularii.
Specificarea unui nou timp de stop pentru simularea de sine-statatoare.
Specificarea altui nume (altul decât cel implicit, cel al modelului) pentru fisierul în care se salveaza datele de iesire ale modelului.
Specificarea numelui sau numelor fisierelor de date folosite pentru salvarea datelor conectate la blocuri To File.
Optiunile de mai sus se pot rula:
direct din linia de comanda a sistemului de operare folosit (spre exemplu fereastra DOS sub Windows)
folosind simbolul de executie comanda externa (!) din mediul MATLAB.
Folosind facilitatile de mai sus, se pot scrie fisiere script (cu extensia .m) care sa ruleze în secventa un set de simulari care folosesc noi seturi de date. Aceste script-uri pot fi scrise pentru a oferi nume de fisiere unice si pentru parametrii de intrare si pentru semnalele de intare, precum si nume pentru fisierele de iesire pentru întregul model sau pentru blocurile To File.
rsim target poate fi configurat fie pentru a avea acces la toate metodele de integrare disponibile în Simulink (configuratie implicita) fie pentru a folosi metodele de integrare (solvere) cu pas fix incorporate în RTW.
În configuratia implicita, executabilul de sine-statator (model.exe) creat de rsim target se leaga cu modulul de integrare din Simulink (care este o biblioteca distribuita, cu legare dinamica) daca modelul foloseste o metoda de integrare cu pas variabil. Daca se foloseste model.exe cu modulul de integrare din Simulink, se face o verificare a licentei.
Target-ul rapid simulation (rsim) prevede o platforma pe computerul gazda pentru testarea codului generat din diferite modele, pentru acordarea parametrilor sau pentru modificarea diferitelor marimi de intrare în sistem.
Daca se foloseste target-ul Rapid Simulation se poate rula o simulare într-un mod similar cu target-ul GRT furnizat de Real-Time Workshop. Aceasta simulare nu foloseste întreruperi ale timer-ului si din aceasta cauza este un mediu de simulare care nu lucreaza în timp real.
O diferenta majora între GRT si RSIM este aceea ca RSIM permite schimbarea valorilor parametrilor sau a semnalelor de intrare la începutul simularii fara a mai fi nevoie de regenerarea codului sau de recompilare.
O singura constructie a modelului poate fi utilizata pentru a studia efectele unor diferiti parametri sau a unor semnale diferite de intrare asupra marimilor de iesire sau asupra comportamentului sistemului. Argumentele din linia de comanda furnizeaza mecanismul necesar pentru a specifica noi date pentru simulare.
Optiunile liniei de comanda |
Descriere |
|
model -f old.mat=new.mat |
Citeste semnalul de intrare din fisierul new.mat care înlocuieste fisierul original old.mat folosit la crearea executabilului. |
|
model -o newlogfile.mat |
Scrie un MAT-fisier cu numele newlogfile.mat |
|
model -p filename.mat |
Citeste un nou vector (de înlocuire) de parametri din filename.mat |
|
model -s <stoptime> |
Seteaza parametrul de simulare Stop time la valoarea <stoptime> |
|
model -t old.mat=new.mat |
Modelul original salveaza semnalele specificate în fisierul de iesire old.mat. Pentru aceasta rulare se foloseste fisierul de iesire new.mat |
|
model -v |
Ruleaza în mod afisare mesaje |
|
model -h |
Afiseaza un mesaj de help cu optiunile de afisare |
Real-Time Workshop rapid simulation target (rsim) consta într-un set de fisiere tinta pentru executia nonreal-time pe calculatorul gazda.
Se poate folosi rsim target pentru a genera simulari rapide de sine statatoare care sa permita modificarea semnalelor de intrare sau a parametrilor modelului folosind fisiere de date MATLAB MAT-file sau date structurate în spatiul de lucru al MATLAB-ului fara a fi nevoie sa recompilam modelul.
Codul C code generat cu ajutorul Real-Time Workshop este puternic optimizat pentru a furniza executia rapida a modelelor dinamice hibride. Executabilul generat (model.exe) de catre rsim target poseda interfata run-time necesara pentru a scrie sau citi date în/din fisiere standard de date MATLAB MAT-file.
Folosind aceasta interfata, model.exe poate citi noi valori pentru semnalele de intrare sau pentru diversi parametri la începutul simularii si poate scrie apoi rezultatele simularii în fisiere de date care pot fi prelucrate adecvat în MATLAB.
Construind un executabil cu rsim si folosind RTW împreuna cu un compilator de C pe computerul gazda, se pot folosi oricare din combinatiile de mai jos folosind optiuni în liniile de comanda. Fara a recompila modelul rapid simulation target permite ca:
Specificarea de noi fisiere de date care sa furnizeze semnale de intrare pentru blocurile From File
Specificarea unui nou fisier ce furnizeaza semnale de intrare cu orice tip de date acceptat de Simulink (double, float, int32, uint32, int16, uint16, int8, uint8, si complex data) folosind blocul From Workspace.
Înlocuirea vectorului parametrilor din diagrama si reluarea simularii
Specificarea unui alt moment la care se opreste simularea.
Specificarea unui nou nume pentru fisierul de date în care se stocheaza datele de iesire.
Aceste optiuni se pot rula fie direct din linia de comanda a sistemului de operare, fie folosind simbolul (!) de comanda externa de la prompterul liniei de comanda MATLAB.
Se pot scrie foarte simplu fisiere script care sa furnizeze seturi de simulari în care sa putem modifica fie semnalele de intrare fie parametrii modelului.
Rsim target poate fi configurat pentru a avea acces la toate metodele de integrare disponibile în Simulink sau pentru folosirea metodelor de integrare cu pas fix ale RTW.
Exemplul 1: Specificarea unui nou fisier de date tip semnal pentru un bloc From File
Pentru a întelege cum se poate modifica un semnal de intrare pentru un sistem a carui functionare se studiaza, vom considera un exemplu Simulink prin care se studiaza raspunsul la intrare treapta al sistemelor de ordinul 2. Parametrii variabili, care se initializeaza în MATLAB, sunt T (perioada de esantionare), csi (factor de amortizare) si w (pulsatia naturala).
Modelul Simulink, numit ord2rasp.mdl, este de forma:
Sursa semnalului de intrare este blocul From File în care se specifica numele fisierului de date care contine cel putin o matrice care are pe prima linie timpul si pe liniile urmatoare valorile intrarilor considerate. Pentru a putea seta parametrii acestui bloc, se genereaza timpul si intrarea catre sistemul de ordinul 2. Acest lucru se realizeaza simplu cu secventa:
>> input_time=0:.1:10; % timpul de simulare
>> input_data=ones(1,length(input_time)); %semnalul de intrare
>> input=[input_time;input_data]; %matricea de date
>> save input input; %se salveaza matricea input în fisierul input.mat
Se seteaza în Simulation Parameters: Workspace I/O variabilele care se salveaza în spatiul de lucru si care se vor gasi, la finalul simularii, în fisierul ord2rasp.mat
Urmeaza configurarea procesului de constructie (target). Pentru aceasta, se alege din meniul Simulation Parameters, Real-Time Workshop, Target Configuration, Configuration <Browse>, se alege optiunea rsim.tlc.
Se lanseaza apoi procesul de constructie prin simpla apasare a butonului Build. Se atrage atentia ca, în prealabil, se atribuie valori parametrilor T (perioada de esantionare), w (pulsatia) si csi (factorul de amortizare. Se vor afisa urmatoarele mesaje:
### Starting Real-Time Workshop build procedure for model: ord2rasp
### Generating code into build directory: .\ord2rasp_rsim_rtw
### Invoking Target Language Compiler on ord2rasp.rtw
### Loading TMW TLC function libraries
### Initial pass through model to cache user defined code
### Caching model source code
### Creating (RealTime) source file ord2rasp.c
### Creating model header file ord2rasp.h
### Creating model header file ord2rasp_export.h
### Creating parameter file ord2rasp_prm.h
### Creating registration file ord2rasp_reg.h
### Creating data type transition file ord2rasp_dt.c
### TLC code generation complete.
### Creating project marker file: rtw_proj.tmw
### Creating ord2rasp.mk from D:\matlabR12\rtw\c\rsim\rsim_lcc.tmf
### Building ord2rasp: ord2rasp.bat
. . . . . . . . . . . . . . . . . . . .
### Created executable: ord2rasp.exe
### Successful completion of Real-Time Workshop build procedure for model: ord2rasp
Se obtine în final executabilul ord2rasp.exe, care se lanseaza în executie ca o comanda externa
>> !ord2rasp
** starting model 'ord2rasp' **
** created ord2rasp.mat **
Se observa cum în urma executiei programului, se genereaza un fisier tip MAT, cu acelasi nume cu al modelului, în care sunt stocate variabilele setate spre a fi salvate prin optiunea save to workspace. Încarcând datele în spatiul de lucru si plotând rezultatele, obtinem:
>> load ord2rasp
>> plot(rt_tout,rt_yout);
Putem scrie un script file cu numele ord2rasp_rsim.m cu continutul:
input_time=0:.1:10; % timpul de simulare
input_data=ones(1,length(input_time)); %semnalul de intrare treapta
omega=5;
input_data=sin(omega*input_time);
input=[input_time;input_data]; %matricea de date
save new_input input; %se salveaza matricea input în fisierul new_input.mat
!ord2rasp -f input.mat=new_input.mat
load ord2rasp
plot(rt_tout,rt_yout);
Comanda de baza este reprezentata de !ord2rasp -f input.mat=new_input.mat care informeaza executabilul ca s-a schimbat fisierul din care blocul From File culege datele de intrare. În urma rularii programului, sub MATLAB, obtinem:
Ca rezultat se citesc datele din noul fisier si se realizeaza simularea pâna la momentul de timp specificat în pagina Solver a Simulation Parameters dialog box. Cu alte cuvinte, putem genera un semnal de intrare pe un interval de timp mai mare decât timpul de simulare fixat. Simularea se va face numai pe intervalul fixat de parametrii de simulare.
Exemplul 2: Un alt caz interesant este cel al folosirii mai multor semnale de intrare. Sa presupunem modelul:
Se observa cum marimea de intrare în sistemul de ordinul 2 se obtine prin însumarea a doua semnale care se stocheaza împreuna într-o forma matriciala în fisierul input.mat. Crearea sa se face cu secventa:
>> t=0:.1:10;
>> u1=sin(5*t);
>> u2=[zeros(1,60),ones(1,length(t)-60)];
>> mat=[t;u1;u2];
>> save input mat
Matricea va avea 3 linii, din care prima linie este reprezentata de vectorul de timp iar celelalte doua linii sunt reprezentate de cele doua semnale.
Marimea vectorului de iesire din blocul From File depinde de numarul semnalelor stocate în prima matrice care se salveaza în fisierul input.mat. Blocul utilizeaza vectorul timp pentru a genera semnalele de iesire, dar vectorul timp nu se genereaza la iesire. În cazul nostru, în blocul DMUX vor intra doua semnale, anume u1 si u2, deci am folosit un DMUX cu doua iesiri. Mai departe, acestea se însumeaza si se transmit mai departe la intrarea sistemului de ordinul 2.
Acestui model se aplica procesul Build, rezultând, automat, un fisier de iesire cu numele ord2rasp.mat, în care se vor afla marimile bifate în casutele Workspace Out, anume tout si yout.
Mai întâi vom simula sub Simulink modelul, iesirea fiind afisata pe osciloscop, apoi vom lansa în executie executabilul obtinut prin Build.
Dupa cum se observa din optiunile Save options/Format, marimile de iesire Time si Output se vor salva în format Array, prima linie fiind vectorul de timp iar cea de-a doua fiind iesirea. Secventa de comanda va fi:
>> !ord2rasp
** starting model 'ord2rasp' **
** created ord2rasp.mat **
>> load ord2rasp
>> plot(rt_tout,rt_yout)
Prin simulare sub Simulink respectiv prin rulare externa, se obtin urmatoarele rezultate:
Cum rsim nu plaseaza semnalul în codul generat, se reduce lungimea codului generat precum si timpul de compilare. Blocul From File cere ca tipurile de date sa fie de tipul double.
Folosirea blocului From Workspace
Daca este necesar sa folosim alte tipuri de date, se foloseste blocul From Workspace.
Pentru a putea folosi blocul From Workspace, va trebui sa formam o structura de date care este acceptata de workspace data. Aceasta este de forma:
variable.time
variable.signals.values
Daca avem mai mult de un singur semnal, formatul trebuie sa fie:
variable.time
variable.signals(1).values
variable.signals(2).values
În cazul nostru, secventa de creare a structurii input este:
>> input.time=input_time;
>> input.signals.values=input_data';
Este nevoie ca numarul de coloane al fiecarui semnal sa fie egal cu numarul de linii al vectorului (câmpului) time. De aceea s-a transpus vectorul de date.
Modelul se recompileaza si se lanseaza în executie, obtinându-se aceleasi rezultate.
Daca dorim sa folosim doua semnale de intrare, putem avea configuratia din figura de mai jos. Pentru a initia variabilele de intrare, vom genera secventa:
input.time=input_time';
input.signals(1).values=input_data;
input.signals(2).values=[zeros(60,1);ones(61,1)];
Trebuie sa avem grija ca numarul de linii pentru time si substructura signals sa fie acelasi.
Vom seta parametrul Load from workspace cu numele structurii construite mai sus, input, si apoi vom putea începe simularea. Aceasta structura se preteaza numai pentru simulare, nu si pentru generarea unui executabil. Simulink selecteaza automat primul semnal din structura pentru primul port de intrare, s.a.m.d.
Daca se specifica optiunea Save to Workspace, adica se marcheaza una din casutele Time, States, Outputs sau Final States din pagina Workspace I/O a casutei de dialog Simulation Parameters , implicit se salveaza rezultatele în fisierul model.mat.
Se poate specifica un fisier de salvare care sa înlocuiasca pe cel implicit pentru anumite simulari. În cazul nostru, se salveaza sub forma matriciala rt_tout si rt_yout în fisierul ord2rasp.mat în momentul în care se executa comanda !ord2rasp.
!ord2rasp
created ord2rasp.mat
Se poate specifica un nou fisier de iesire prin comanda
>>! ord2rasp -o sim1.mat
În acest caz, se ruleaza setul de parametri furnizati la momentul generarii codului, inclusiv fiecare bloc From File. Se pot combina astfel o mare varietate de fanioane rsim pentru a furniza noi date de intrare, noi parametri si fisiere de iesire pentru simulare.
Este important sa subliniem ca, pentru generarea unui fisier cu intrari modificabile fara reconstructia executabilului este necesara existenta unui fisier-MAT care sa ofere date blocului From File prezent în modelul Simulink. Aceasta este o particularitate fata de aceeasi operatie de constructie sub GRT, care insereaza datele din fisierul-MAT direct în codul C generat care este apoi compilat si legat pentru obtinerea executabilului. Prin contrast, rsim permite furnizarea unor noi date care sa le înlocuiasca pe cele mai vechi la fiecare simulare. Un fisier-MAT care sa contina datele pentru blocurile From File sau From Workspace prezente în model trebuie sa existe în permanenta.
Din momentul în care se modifica valorile unuia sau mai multor parametri în diagrama Simulink activa, se poate extrage un vector de parametri, rtP (Real-Time Parameters) pentru întreg modelul. Vectorul rtP, împreuna cu o suma de verificare (checksum), pot fi apoi salvate într-un fisier-MAT. Acest fisier poate fi citit de catre executabilul rsim de sine-statator provenit din modelul Simulink, permitându-ne înlocuirea unuia sau mai multor parametri pentru a studia efectul acestor modificari asupra comportarii sistemului, precum si modificarea unor semnale de intrare.
Suma de control permite o verificare de siguranta pentru a asigura ca modificarea parametrilor se aplica numai modelelor rsim care au aceeasi structura a modelului. Daca se sterge un bloc sau se adauga unul, noua suma de control nu se va mai potrivi cu cea originala, iar rsim va detecta aceasta incompatibilitate în vectorul parametrilor si va abandona pentru a preveni furnizarea unor rezultate incorecte. În acest caz, când structura modelului este modificata, este necesara regenerarea codului din noul model.
rsim target ne permite modificarea valorii oricarui parametru, inclusiv ai acelora cu asa-numite efecte secundare. Spre exemplu, functia de transfer de ordinul 2 pe care am implementat-o în blocul Transfer Function are doi parametri cu efecte secundare, w si csi, care, la rândul lor, modifica numaratorul si numitorul functiei de transfer, alti parametri ai modelului.
În general RTW evalueaza functiile cu efecte secundare înaintea generarii codului. Codul generat pentru acest exemplu retine o singura intrare locatie de memorie iar dependenta de alti parametri nu mai este vizibila în codul generat.
RSIM target înlatura acest neajuns al manevrarii unor functii cu efecte secundare prin înlocuirea întregii structuri de parametri, rtP, cu una noua în care s-au propagat corespunzator toate modificarile.
Aceasta noua structura trebuie creata prin folosirea functiei rsimgetrtp.m.
Spre exemplu, sa revenim la primul model care simuleaza raspunsul la intrare treapta al sistemului de ordinul 2. Parametrii sistemului se pot schimba si efectul schimbarii se poate vizualiza folosind în mod repetat secventa:
csi = .2;w=15;myrtp = rsimgetrtp('ord2rasp');save myparamfile myrtp;
>> !ord2rasp -p myparamfile.mat
** starting model 'ord2rasp' **
** created ord2rasp.mat **
>> load ord2rasp;plot(rt_tout,rt_yout);
>> csi = .5;w=5;myrtp = rsimgetrtp('ord2rasp');save myparamfile myrtp;
>> !ord2rasp -p myparamfile.mat
** starting model 'ord2rasp' **
** created ord2rasp.mat **
>> load ord2rasp;plot(rt_tout,rt_yout);
Tot ceea ce am realizat mai sus se poate introduce într-un fisier script, denumit rsim_test.m, în care putem introduce comenzile:
T=input('Perioada de esantionare: ');
w=input('Pulsatia naturala sistem: ');
csi=input('Factor amortizare sistem: ');
input_time=0:T:10; % timpul de simulare
input_data=ones(1,length(input_time)); %semnalul de intrare treapta
mat=[input_time;input_data];
save new_input mat
myrtp = rsimgetrtp('ord2rasp');
save myparamfile myrtp;
!ord2rasp -f input.mat=new_input.mat -p myparamfile.mat
load ord2rasp;
plot(rt_tout,rt_yout);
Aceste comenzi nu pot fi incluse într-o functie care sa fie compilata deoarece exista o serie de functii apelate neacceptate în modul MEX.
Daca nu este specificat explicit un moment de stop pentru simulare, simularea va fi executata pâna se atinge valoarea specificata în pagina Solver la momentul generarii codului. Se poate specifica o noua valoare de stop folosind comanda
!rsimtfdemo -s 6.0
În acest caz, simularea va rula pâna se ating cele 6 secunde specificate explicit. În acest moment simularea se opreste si se face logarea cu fisierul de date tip MAT asa cum s-a descris mai sus. In this case, the simulation will run until it reaches 6.0 seconds. At this point it will stop and log the data according to the MAT-file data logging rules as described above.
Daca modelul include blocul From File care contine un vector de timp ca prima linie, sfârsitul simularii va fi dictat de setarea originala din pagina Solver a Simulation Parameters dialog box sau cu ajutorul optiunii -s descrisa mai sus.
Daca totusi timpul de simulare depaseste valoarea finala a timpului din matricea de date atunci semnalul va fi extrapolat pâna la valoarea finala a timpului specificat explicit.
Specificarea unui nou fisier de iesire (New Output Filenames) pentru To File Blocks
Acest lucru se realizeaza asemanator cu specificarea unui nou fisier de intare, si anume cu sintaxa:
!mymodel -t original.mat=replacement.mat
Se specifica deci numele fisierului folosit la momentul generarii codului si a numelui noului fisier de iesire. Prin aceasta metoda se evita supraînscrierea unor date care au fost obtinute la o simulare anterioara.
|
