Programowanie Systemów Sterowania

Programowanie Systemów Sterowania Dr inż. Dariusz Bismor Gliwice, 2007

S-funkcje System-functions reprezentacja bloku Simulinka w języku programowania S-funkcje stanowią wygodny mechanizm poszerzający możliwości Simulinka Zastosowanie s-funkcji obejmuje: tworzenie nowych bloków funkcyjnych tworzenie bloków sterowników urządzeń wykorzystywanie istniejącego kodu w C, C++, Fortranie, Adzie opis systemu jako układu równań przyspieszanie czasu symulacji dodawanie animacji do symulacji

Jak działają S-funkcje? Blok w Simulinku: wejście u stany x wyjście y y = fo( t, x, u) x& = c fd ( t, x, u) xd k + 1 = fu ( t, x, x = x d + x c, u ) równanie wyjścia równanie różniczkowe równanie różnicowe

Jak działają S-funkcje? Fazy symulacji: Inicjalizacja Obliczenie czasu następnej próbki Pętla symulacji Obliczenie wyjść Aktualizacja stanów dyskretnych Obliczenie pochodnych Obliczenie wyjść Obliczenie pochodnych Lokalizacja przejść przez zero Całkowanie

Jak działają S-funkcje? Metody wywołania S-funkcji: Inicjalizacja: utworzenie struktury SimStruct ustawienie ilości i wymiarów wejść i wyjść ustawienie okresu próbkowania dla bloku przydzielenie pamięci dla stanów i tablicy sizes

Jak działają S-funkcje? Metody wywołania S-funkcji (c.d): Obliczenie następnego kroku próbkowania (dla bloków ze zmiennym próbkowaniem) Obliczenie wyjść Aktualizacja stanów dyskretnych Całkowanie równań ciągłych (z małym krokiem całkowania) Zakończenie symulacji

S-funkcja jako M-file Składnia i parametry funkcji: [sys, x0, str, ts] = funkcja(t, x, u, flaga, p1, p2,...) Zwracana Warunki Nieużywane, Wektor wartość początkowe czasów [] Nazwa próbkowania Bieżący funkcji Wektor Metoda czas stanu wejść Parametry wywołania wywołania Metody wywołania: flaga = 0 - inicjalizacja flaga = 1 - całkowanie równań ciągłych flaga = 2 - obliczanie równań dyskretnych flaga = 3 - obliczenie wyjść s-funkcji flaga = 4 - obliczenie czasu następnej próbki flaga = 9 - zakończenie symulacji

S-funkcja jako M-file Przykładowa s-funkcja wzmacniacz: function [sys, x0, str, ts] = pomnoz(t, x, u, flaga, p1) switch flaga, case 0 [sys, x0, str, ts] = inicjalizacja; case 3 sys = oblicz_wyjscie(t, x, u, p1 ); case {1, 2, 4, 9} sys = []; otherwise error([ Nieobsługiwana flaga, num2str(flaga)]); end

S-funkcja jako M-file Przykładowa s-funkcja wzmacniacz: function [sys, x0, str, ts] = inicjalizacja mysizes = simsizes; mysizes.numcontstates = 0; mysizes.numdiscstates = 0; mysizes.numinputs = 1; mysizes.numoutputs = 1; mysizes.dirfeedthrough = 1; mysizes.numsampletimes = 1; sys = simsizes(mysizes) x0 = []; str = []; ts = [-1, 0] %Dziedziczony czas próbkowania

S-funkcja jako M-file Przykładowa s-funkcja wzmacniacz: function sys = oblicz_wyjscie(t, x, u, mnoznik) sys = mnoznik.*u;

S-funkcja dla obiektów ciągłych function [sys,x0,str,ts] = csfunc(t,x,u,flag) % Macierze modelu układu ciągłego w postaci równań stanu: A=[-0.09-0.01; 1 0]; B=[ 1-7; 0-2]; C=[ 0 2; 1-5]; D=[-3 0; 1 0]; % Obsługa flagi. switch flag, case 0 % Initializacja [sys,x0,str,ts]=mdlinitializesizes(a,b,c,d); case 1 % Obliczenie pochodnych sys = mdlderivatives(t,x,u,a,b,c,d); case 3 % Obliczenie wyjść sys = mdloutputs(t,x,u,a,b,c,d); case { 2, 4, 9 } % Nieużywane flagi sys = []; otherwise % Obsługa błędów error(['unhandled flag = ',num2str(flag)]); end

S-funkcja dla obiektów ciągłych function [sys,x0,str,ts] = mdlinitializesizes(a,b,c,d) sizes = simsizes; sizes.numcontstates = 2; sizes.numdiscstates = 0; sizes.numoutputs = 2; sizes.numinputs = 2; sizes.dirfeedthrough = 1; % Ponieważ macierz D niezerowa sizes.numsampletimes = 1; sys = simsizes(sizes); % Zerowe warunki początkowe. x0 = zeros(2,1); str = []; % Inicjalizacja macierzy czasów próbkowania bloku [tp, off] % Dla układu ciągłego należy użyć wartości tp=0 i off=0 ts = [0 0];

S-funkcja dla obiektów ciągłych function sys = mdlderivatives(t,x,u,a,b,c,d) % sys = A*x + B*u; function sys = mdloutputs(t,x,u,a,b,c,d) % sys = C*x + D*u;

S-funkcja dla obiektów dyskretnych function [sys,x0,str,ts] = dsfunc(t,x,u,flag) % Macierze modelu układu dyskretnego w postaci równań stanu A=[ 1.3839 0.5097; 1.0000 0]; B=[ 2.5559 0; 0 4.2382]; C=[ 0 2.0761; 0 7.7891]; D=[ 0.8141 2.9334; 1.2426 0]; switch flag, case 0 % Initializacja sys = mdlinitializesizes(a,b,c,d); case 2 % Aktualizacja stanów dyskretnych sys = mdlupdate(t,x,u,a,b,c,d); case 3 % Obliczanie wyjść sys = mdloutputs(t,x,u,a,b,c,d); case {1, 4, 9} % Nieużywane flagi sys = []; otherwise % Obsługa błędów error(['unhandled flag = ',num2str(flag)]); end

S-funkcja dla obiektów dyskretnych function [sys,x0,str,ts] = mdlinitializesizes(a,b,c,d) sizes = simsizes; sizes.numcontstates = 0; sizes.numdiscstates = 2; sizes.numoutputs = 2; sizes.numinputs = 2; sizes.dirfeedthrough = 1; sizes.numsampletimes = 1; sys = simsizes(sizes); % Ponieważ macierz D niezerowa x0 = ones(2,1); str = []; ts = [1 0]; % Zerowe warunki macierzowe. % Okres próbkowania: [tp, off]

S-funkcja dla obiektów dyskretnych function sys = mdlupdates(t,x,u,a,b,c,d) % sys = A*x + B*u; function sys = mdloutputs(t,x,u,a,b,c,d) % sys = C*x + D*u;

S-funkcja dla obiektów mieszanych function [sys,x0,str,ts] = mixedm(t,x,u,flag) % Element całkujący (1/s) połączony szeregowo z opóźnieniem jednostkowym (1/z). % Okres próbkowania i offset dla części dyskretnej: dperiod = 1; doffset = 0; switch flag, case 0 % Initializacja [sys,x0,str,ts] = mdlinitializesizes(dperiod,doffset); case 1 % Obliczanie pochodnych sys = mdlderivatives(t,x,u); case 2 % Aktualizacja stanów dyskretnych sys = mdlupdate(t,x,u,dperiod,doffset); case 3 % Obliczanie wyjść sys = mdloutputs(t,x,u,doffset,dperiod); case {4, 9} % Nieużywane flagi sys = []; otherwise % Obsługa błędów error(['unhandled flag = ',num2str(flag)]); end

S-funkcja dla obiektów mieszanych function [sys,x0,str,ts] = mdlinitializesizes(dperiod,doffset) sizes = simsizes; sizes.numcontstates = 1; sizes.numdiscstates = 1; sizes.numoutputs = 1; sizes.numinputs = 1; sizes.dirfeedthrough = 0; sizes.numsampletimes = 2; sys = simsizes(sizes); x0 = ones(2,1); str = []; ts = [0, 0; dperiod, doffset]; % DWA czasy próbkowania

S-funkcja dla obiektów mieszanych function sys = mdlderivatives(t,x,u) sys = u; function sys = mdlupdate(t,x,u,dperiod,doffset) % Funkcja aktualizująca stany dyskretne. Poniższy kod sprawdza, czy czas % "t" jest wielokrotnością dyskretnego okresu próbkowania, z dokładnością 1e-8. % Jeżeli tak jest, bieżąca wartość stanu ciągłego (x(1)) jest zwracana jako nowa % wartość stanu dyskretnego if abs(round((t-doffset)/dperiod)-(t-doffset)/dperiod) < 1e-8 sys = x(1); % Wielokrotność dyskr. okresu próbkowania % Przepisanie stanu ciągłego x(1) do stanu dyskretnego else end sys = []; % Czas "t" nie jest wielokrotnością okresu próbkowania % Zwracana pusta macierz symbolizuje brak zmian % stanu dyskretnego

S-funkcja dla obiektów mieszanych function sys = mdloutputs(t,x,u,doffset,dperiod) % Funkcja aktualizująca wyjście. Poniższy kod sprawdza, czy czas % "t" jest wielokrotnością dyskretnego okresu próbkowania, z dokładnością 1e-8 % (mdloutputs jest także wywoływana w małym kroku symulacji) % Jeżeli tak jest, bieżąca wartość stanu dyskretnego (x(2)) jest przepisywana na % wyjście. W przeciwnym przypadku zwraca się pustą macierz symbolizującą % brak zmian na wyjściu. if abs(round((t-doffset)/dperiod)-(t-doffset)/dperiod) < 1e-8 sys = x(2); else sys = []; end

S-funkcja ze zmiennym okresem próbkowania function [sys,x0,str,ts] = vsfunc(t,x,u,flag) % Przykład s-funkcji ze zmiennym czasem próbkowania. Realizowana funkcja to zmienne % opóźnienie - opóźnienie sygnału na pierwszym wejściu zależy od wartości sygnału na % drugim wejściu: dt = u(2); y(t+dt) = u(t) % switch flag, case 0 [sys,x0,str,ts] = mdlinitializesizes; % Inicjalizacja case 2 sys = mdlupdate(t,x,u); % Aktualiz. stanów dyskretnych case 3 sys = mdloutputs(t,x,u); % Obliczanie wyjść case 4 sys = mdlgettimeofnextvarhit(t,x,u); % Obliczanie czasu nast. próbki case { 1, 9 } sys = []; % Pozostałe flagi otherwise error(['unhandled flag = ',num2str(flag)]); % Ewentualny błąd end

S-funkcja ze zmiennym okresem próbkowania function [sys,x0,str,ts] = mdlinitializesizes % sizes = simsizes; sizes.numcontstates = 0; sizes.numdiscstates = 1; sizes.numoutputs = 1; sizes.numinputs = 2; sizes.dirfeedthrough = 1; % flag=4 - wymaganie bezpośredniego sprzężenia sizes.numsampletimes = 1; % wejścia z wyjściem sys = simsizes(sizes); x0 = [0]; str = []; ts = [ 2 0]; % Zerowe warunki początkowe % Zwracana macierz pusta (niewykorzystywany parametr) % Kod dla zmiennego czasu próbkowania

S-funkcja ze zmiennym okresem próbkowania function sys = mdlupdate(t,x,u) % Funkcja do aktualizacji stanów dyskretnych sys = u(1); function sys = mdloutputs(t,x,u) % Funkcja do aktualizacji wyjść sys = x(1); function sys = mdlgettimeofnextvarhit(t,x,u) % Funkcja obliczająca czas następnego próbkowania bloku % Uwaga! Jest to czas bezwzględny, a nie przyrost czasu sys = t + u(2);

Wersja 2 interfejsu s-funkcji Obecnie istnieje druga wersja interfejsu dla s-funkcji pisanych w języku Matlaba Wersja ta nie posiada ograniczeń wersji pierwszej, jak jedno wejście i jedno wyjście bloku Zapis kodu s-funkcji w wersji 2 interfejsu jest bardzo podobny do kodu w języku C Kod s-funkcji w wersji 2 interfejsu traci podstawową zaletę s-funkcji w wersji pierwszej - prostotę

S-funkcje w języku C Najprostszym sposobem zapisania kodu s-funkcji w języku C jest wykorzystanie dostarczanego z Simulinkiem "kreatora" s- funkcji S-funkcję można także zapisać samodzielnie i skompilować przy użyciu dostarczonego skryptu "mex" Trzecim sposobem jest wykorzystanie narzędzi do dziedziczenia kodu Każdy ze sposobów wymaga posiadania zewnętrznych kompilatorów

S-funkcje w języku C Interakcja "silnika" Simulinka z s-funkcją napisaną w języku C polega na wywoływaniu odpowiednich funkcji na każdym z etapów symulacji Funkcje te nazywa się metodami odpowiadają one funkcjom pomocniczym dla poszczególnych faz symulacji Liczba metod, za pomocą których można sterować przebiegiem wykonania bloku, jest znacznie większa od faz symulacji s-funkcji w języku Matlaba Każda s-funkcja musi co najmniej implementować metody dla fazy inicjalizacji rozmiarów, inicjalizacji czasów próbkowania, obliczania wyjść i zakończenia symulacji

Wywołania metod dla języka C mdlinitializesizes mdlcheckparameters Silnik Simulinka mdlsetinputportframedata mdlsetinputportwidth/mdlsetoutputportwidth mdlsetinputportdimensioninfo/mdlsetoutputportdimensioninfo mdlsetinputportsampletime/mdlsetoutputportsampletime mdlinitializesampletime

Wywołania metod dla języka C mdlsetinputportdatatype/mdlsetoutputportdatatype mdlsetdefaultportdatatypes Silnik Simulinka mdlsetinputportcomplexsignal/mdlsetoutputportcomplexsignal mdlsetdefaultportcomplexsignal mdlsetworkwidths mdlstart mdlinitializeconditions mdlcheckparameters mdlprocessparameters mdloutputs

Wywołania metod dla języka C Duży krok symulacji mdlprocessparameters mdlgettimeofnextvarhit mdlinitializeconditions mdloutputs mdlupdate

Wywołania metod dla języka C mdlderivatives Całkowanie mdlcheckparameters Mały krok symulacji mdloutputs mdlderivatives mdloutputs Detekcja przejść przez 0 mdlzerocrossings mdlterminate

Struktura SimStruct Wszystkie metody przyjmują jako parametr wskaźnik do struktury typu SimStruct Struktura ta przechowuje informacje konfiguracyjne bloku Struktura SimStruct jest zdefiniowana w pliku nagłówkowym "simstruct.h" znajdującym się w podkatalogu simulink/include głównego katalogu Matlaba Plik "simstruct.h" zawiera także szereg makr do manipulacji strukturą SimStruct makra te należy traktować jako interfejs struktury Obecnie struktura zawiera 17 składowych takich, jak nazwa bloku, ścieżka do pliku bloku, stan błędu bloku czy wskaźniki do podsystemów bloku

S-funkcje w języku C #define S_FUNCTION_NAME nazwa_funkcji #define S_FUNCTION_LEVEL 2 #include simstruc.h static void mdlinitializesizes(simstruct *S){} static void mdlinitializesampletime(simstruct *S){} static void mdloutputs(simstruct *S, int_t tid){} static void mdlterminate(simstruct *S){} /* Kod dodatkowych funkcji */ #ifdef MATLAB_MEX_FILE #include "simulink.c" /* interfejs dla plików MEX */ #else #include "cg_sfun.h" /* Funkcje dla generacji kodu */ #endif

S-funkcja w języku C - przykład #define S_FUNCTION_NAME cpomnoz #define S_FUNCTION_LEVEL 2 #include "simstruc.h" /* Definicja dla łatwiejszego dostępu do parametru s-funkcji */ #define PARAM1(S) ssgetsfcnparam(s,0) /* Poniższe umożliwia wyłączenie kontroli poprawności zakresu parametru - w tym celu należy zmienić na #undef */ #define MDL_CHECK_PARAMETERS

S-funkcja w języku C - przykład #if defined(mdl_check_parameters) && defined(matlab_mex_file) static void mdlcheckparameters( SimStruct *S ){ /* Sprawdzenie, czy parametr jest skalarny (wzmocnienie) */ if (mxgetnumberofelements(param1(s))!= 1) { ssseterrorstatus(s,"parametr tej S-funkcji ma być skalarem!"); return; } /* Wymuszenie dodatniego wzmocnienia */ if (mxgetpr(param1(s))[0] < 0) { ssseterrorstatus(s, "Parametr tej S-funkcji ma być nieujemny!"); return; } } #endif /* MDL_CHECK_PARAMETERS */

S-funkcja w języku C - przykład static void mdlinitializesizes( SimStruct *S ){ sssetnumsfcnparams(s, 1); if (ssgetnumsfcnparams(s) == ssgetsfcnparamscount(s)) { mdlcheckparameters(s); if( ssgeterrorstatus(s)!= NULL ){ return; /* Simulink ostrzeże o problemie z parametrami */ } } else { return; } if (!sssetnuminputports(s, 1) ) return; sssetinputportwidth( S, 0, DYNAMICALLY_SIZED ); sssetinputportdirectfeedthrough( S, 0, 1 );

S-funkcja w języku C - przykład if (!sssetnumoutputports(s,1)) return; sssetoutputportwidth( S, 0, DYNAMICALLY_SIZED ); sssetnumsampletimes( S, 1); /* Poniższą opcję włącza się po upewnieniu się, że kod nie generuje sytuacji wyjątkowych w rozumieniu Matlaba */ /* sssetoptions(s, SS_OPTION_EXCEPTION_FREE_CODE); */ } static void mdlinitializesampletimes( SimStruct *S ){ } sssetsampletime( S, 0, INHERITED_SAMPLE_TIME ); sssetoffsettime( S, 0, 0.0 );

S-funkcja w języku C - przykład static void mdloutputs(simstruct *S, int_t tid){ int_t i; real_t *mnoznik = mxgetpr( PARAM1(S) ); InputRealPtrsType uptrs = ssgetinputportrealsignalptrs(s,0); real_t *y = ssgetoutputportrealsignal(s,0); int_t width = ssgetoutputportwidth(s,0); } for (i=0; i<width; i++) { *y++ = (*mnoznik) *(*uptrs[i]); } static void mdlterminate(simstruct *S){}

S-funkcja w języku C - przykład #ifdef MATLAB_MEX_FILE #include simulink.c #else #include cg_sfun.h #endif

Zmienne bloku Simulinka Wejścia zewnętrzne (porty) Blok wejściowowyjściowy Wyjścia zewnętrzne (porty) Jednym z zadań metody mdlinitializesizes jest ustawienie rozmiarów Blok funkcyjny Masa wszystkich zmiennych wykorzystywanych przed dany w Simulinku blok Simulinka Stany Parametry Dodatkowe zmienne wektorowe

Tworzenie wejść bloku Składnia: boolean_t sssetnuminputports( SimStruct *S, int_t ile); gdzie: S -wskaźnik do struktury SimSizes, ile - żądana liczba wejść bloku. Zazwyczaj: if(!sssetnuminputports(s, ile) ) return;

Wejścia bloku Po zdefiniowaniu liczby wejść dla każdego wejścia należy określić: wymiar wejścia lub dynamiczny dobór wymiaru, właściwość rozciągania wielkości skalarnych (sssetoption), czy port uczestniczy bezpośrednio w obliczaniu wyjścia lub następnego okresu próbkowania za pomocą makra sssetinputportdirectfeedthrough typ danych portu, jeśli jest to inny typ niż domyślny (double) typ numeryki portu, jeśli port ma przyjmować dane zespolone

Wejścia bloku - rozmiar Dla portu jednowymiarowego o długości Dlugosc: void sssetinputportvectordimension( SimStruct *S, int_t NumPortu, int_t Dlugosc); (lub sssetinputportwidth()) Dla portu, którego sygnałem jest macierz o rozm. M x N: void sssetinputportmatrixdimensions( SimStruct *S, int_t NumPortu, int_t M, int_t N ); W innym przypadku: void sssetinputportdimensioninfo( SimStruct *S, int_t NumPortu, DimsInfo_T *dimsi );

Wejścia bloku - rozmiar dynamiczny Używany w przypadku, gdy rozmiar portu ma zależeć od rozmiaru sygnału podłączonego do portu Można wyróżnić trzy przypadki: jeśli port ma akceptować sygnały dowolnych rozmiarów, należy użyć funkcji: sssetinputportdimensioninfo( S, NumPortu, DYNAMIC_DIMENSION); jeśli port ma akceptować jedynie wektory, lecz o dowolnym rozmiarze, należy użyć funkcji: sssetinputportwidth( S, NumPortu, DYNAMICALLY_SIZED); jeśli port ma akceptować macierz, lecz ilość jej wierszy lub kolumn ma być dowolna, należy użyć funkcji sssetinputportmatrixdimensions( S, NumPortu, M, N ); gdzie M i/lub N może być zapisane jako DYNAMICALLY_SIZED

Wejścia bloku - rozmiar dynamiczny Należy zapewnić obsługę metody mdlsetinputportdimensioninfo(), która dostosowuje rozmiar portu do sygnału do niego dołączonego Można także zapewnić obsługę metody mdlsetdefaultportdimensioninfo(), która dobiera rozmiar portu, gdy nie można określić rozmiaru dołączonego do niego sygnału (np. niepodłączony port)

Wejścia bloku właściwość "rozszerzania" Przykład: blok sumatora z jednym sygnałem wektorowym a drugim skalarnym Ułatwienie: ustawienie, w mdlinitializesizes(), opcji SS_OPTION_ALLOW_INPUT_SCALAR_EXPANSION S-funkcja musi definiować wejścia jako DYNAMICALLY_SIZED S-funkcja nie może implementować żadnej z metod mdlsetinputportwidth(), mdlsetoutputportwidth(), mdlsetinputportdimesioninfo(), mdlsetoutputportdimensioninfo(), mdlsetdefaultportdimensioninfo()

Wejścia bloku - bezpośredni wpływ na wyjście Funkcja: sssetinputportdirectfeedthrough( SimStruct *S, int_t NumPortu, int_t Flaga); umożliwia powiadomienie Simulinka, że sygnał z danego portu jest wykorzystywany w metodach mdloutput lub mdlgettimeofnextvarhit (wartość Flaga = 1)

Wejścia bloku - typ danych Funkcja: sssetinputportdatatype( SimStruct S, int_t NumPortu, DTypeID Id ); umożliwia określenie innego niż domyślny typu danych akceptowanych przez port Określenie typu jako DYNAMICALLY_TYPED umożliwia dobór typu na podstawie typu sygnału podłączonego do portu Wówczas powinno się zdefiniować metody mdlsetinputportdatatype() i mdlsetdefaultportdatatypes()

Wejścia bloku - dane zespolone Funkcja: sssetinputportcomplexsignal( SimStruct S, int_t NumPortu, CSignal_T sig ); umożliwia dobór numeryki portu (rzeczywista lub zespolona) Zmienna sig może przyjmować wartości: COMPLEX_NO dla danych rzeczywistych, COMPLEX_YES dla danych zespolonych i COMPLEX_INHERITED dla typu danych zależnego od typu sygnału podłączonego do portu

Wejścia bloku - dane zespolone W przypadku użycia typu COMPLEX_INHERITED należy zdefiniować metody mdlsetinputportcomplexsignal() i ewentualnie mdlsetdefaultportcomplexsignal()

Dostęp do wejść przez wskaźniki W ogólnym przypadku przestrzeń wejściowo-wyjściowa bloku nie jest ciągła:

Dostęp do wejść przez wskaźniki Składnia: InputRealPtrsType uptrs = ssgetinputportrealsignalptrs( S, portindex); gdzie: portindex - numer wejścia układu, począwszy od 0, S -wskaźnik do struktury SimSizes, uptrs - tablica wskaźników do sygnałów wejściowych. Odwołanie do konkretnego elementu: u1 = *uptrs[ NrElementu ]; uptrs to wskaźnik do tablicy!

Dostęp do wejść przez wskaźniki - przykład Wejście1 Wejście2 Blok funkcyjny Dostęp do elementów Wejścia1: InputRealPtrsType wskwe1 = ssgetinputportrealsignalptrs( S, 0 ); Dostęp do elementów Wejścia2: InputRealPtrsType wskwe2 = ssgetinputportrealsignalptrs( S, 1 ); Rozmiar tablicy Wejścia1: int_t rozmwe1 = ssgetinputportwidth( S, 0 );

Testowanie poprawności obsługi wejść Wiele błędów programowych dotyczących obsługi wejść nie ujawnia się, gdy do wejścia podłączony jest sygnał skalarny Dlatego zaleca się testowanie poprawności obsługi wejść według następującego schematu:

Dostęp do wejść przestrzeni ciągłej Wymuszenie ciągłości przestrzeni wejściowej w metodzie mdlinitializesizes(): gdzie: void sssetinputportrequiredcontiguous( S, portindex, flaga ) portindex - numer wejścia układu, począwszy od 0, S -wskaźnik do struktury SimSizes, flaga - równa TRUE gdy wymagamy ciągłości. Odwołanie do wejścia: const real_t *u = ssgetinputportrealsignal( S, portindex); Odwołanie do konkretnego elementu: u1 = u[0]; Wymuszenie ciągłości wpływa na efektywność!

Tworzenie wyjść bloku Składnia: boolean_t sssetnumoutputports( SimStruct *S, int_t ile); gdzie: S -wskaźnik do struktury SimSizes, ile - żądana liczba wyjść bloku. Zazwyczaj: if(!sssetnumoutputports(s, ile) ) return;

Wyjścia bloku Po określeniu liczby wyjść dla każdego portu wyjściowego należy określić: wymiar wyjścia lub dynamiczny dobór wymiaru za pomocą funkcji sssetoutputportdimensioninfo(), sssetoutputportmatrixdimensions(), sssetoutputportvectordimensions(), sssetoutputportwidth(); w przypadku wyjść z dynamicznym rozmiarem należy zdefiniować metody mdlsetoutputportdimensioninfo() i ewentualnie mdlsetdefaultportdimensioninfo()

Wyjścia bloku typ danych portu za pomocą funkcji sssetoutputportdatatype(); jeśli typ jest zależny od połączeń bloku (DYNAMICALLY_TYPED), powinno się zdefiniować metodę mdlsetoutputportdatatype() i ewentualnie mdlsetdefaultportdatatypes() typ numeryki portu za pomocą funkcji sssetoutputportcomplexsignal(); jeśli typ jest zależny od połączeń bloku (COMPLEX_INHERITED), to należy zdefiniować metodę mdlsetoutputportcomplexsignal() i ewentualnie mdlsetdefaultportcomplexsignal()

Dostęp do wyjść przez wskaźniki Składnia: gdzie: real_t *y = ssgetoutputportrealsignal( S, portindex); portindex - numer wyjścia układu, począwszy od 0, S -wskaźnik do struktury SimSizes, y -wskaźnik do sygnałów wyjściowych. Odwołanie do konkretnego elementu: y[0] = 0; Zazwyczaj rozmiar portu wyjściowego jest powiązany z rozmiarem portu wejściowego Istnieją także makra ssgetoutputportnumdimensions() i ssgetoutputportdimensions() umożliwiające odczyt rozmiaru wyjścia

Przykład kodu Poniższy kod przepisuje dane z portu wejściowego o numerze NrPortuWe do portu wyjściowego o numerze NrPortuWy int_t PozWektora; int_t RozmiarWe = ssgetinputportwidth( S, NrPortuWe ); InputRealPtrsType WskWe = ssgetinputportrealsignalptrs( S, NrPortuWe ); real_t *y = ssgetoutputportsignal( S, NrPortuWy ); for ( PozWektora=0; PozWektora < RozmiarWe; PozWektora++ ) { y[ PozWektora ] = *WskWe[ PozWektora ]; }

Tworzenie stanów bloku Składnia: gdzie: sssetnumcontstates( SimStruct *S, int_t ile); sssetnumdiscstates( SimStruct *S, int_t ile); S ile -wskaźnik do struktury SimSizes, - żądana liczba stanów bloku (lub DYNAMICALLY_SIZED) Jeżeli w metodzie mdlinitializesizes() użyto DYNAMICALLY_SIZED, makra należy jeszcze raz wywołać w metodzie mdlsetworkwidths()!

Inicjalizacja stanów bloku W metodzie mdlinitializeconditions() lub mdlstart(): real_t *x0 = ssgetcontstates(s); int_t lx = ssgetnumcontstates(s); for(; lx > 0; lx--){ *x0++ = 0.0; } Jest to jedyne miejsce, gdzie stany zmienia się "ręcznie"!

Uaktualnianie stanów bloku Stany ciągłe uaktualnia się w metodzie mdlderivatives() Programista powinien obliczyć wektor pochodnych (na podstawie prawej strony równania stanu) i zapisać w miejscu wskazywanym przez wynik wywołania: real_t *dx = ssgetdx(s); Stany dyskretne uaktualnia się w metodzie mdlupdate() Dostęp do bieżącego wektora stanów dyskretnym można uzyskać dzięki wywołaniu: real_t *x = ssgetdiscstates(s); Zazwyczaj aktualizacja stanów wymaga alokacji dodatkowego wektora buforowego

Parametry okna dialogowego Należy zdecydować, w jakim porządku parametry będą wpisywane W metodzie mdlinitializesizes() należy wywołać makro sssetnumsfcnparams() w celu ustawienia ilości obsługiwanych parametrów Ustawioną liczbę parametrów zwraca makro: int_t ssgetnumsfcnparams(simstruct* S); Aktualną liczbę parametrów zwraca makro: int_t ssgetnumsfcnparamscount(simstruct *S); Jeżeli programuje się metodę mdlcheckparams(), należy ją wywołać z metody mdlinitializesizes() Dostęp do parametrów następuje przez makro const mxarray *ssgetsfcnparams( S, index )

Parametry okna dialogowego Tablica Matlaba mxarray może przechowywać dana różnych typów W celu sprawdzenia typu danych w tablicy należy wywołać: DTypeID ssgetdtypeidfrommxarray(const mxarray *m); Inne funkcje przydatne do sprawdzania typu to mxiscomplex(), mxischar(), mxisstruct()

Parametry okna dialogowego Wartość Typ danych Matlaba Typ danych C SS_DOUBLE mxdouble_class real_t SS_SINGLE mxsingle_class real32_t SS_INT8 mxint8_class int8_t SS_UINT8 mxuint8_class uint8_t SS_INT16 mxint16_class int16_t SS_UINT16 mxuint16_class uint16_t SS_INT32 mxint32_class int32_t SS_UINT32 mxuint32_class uint32_t SS_BOOLEAN mxuint8_class boolean_t INVALID_DTYPE_ID

Parametry dostrajalne......to parametry, które można zmieniać podczas symulacji Dla każdego z parametrów dostrajalnych należy wywołać makro void sssetfcnparamtunable( SimStruct *S, int_t Param, int_t Mode ) gdzie: S Param Mode -wskaźnik do struktury SimSizes, - numer parametru, - SS_PRM_TUNABLE (dostrajalny), SS_PRM_NOT_TUNABLE (nie dostrajalny), SS_PRM_SIM_ONLY_TUNABLE (dostrajalny w symul.) Uwaga! Po wykryciu zmiany parametru Simulink wywoła metodę mdlcheckparameters() Metoda mdlprocessparameters() pozwoli przeprowadzić konieczne po dostrojeniu parametru zmiany

Parametry wykonania (run-time) Stanowią wewnętrzną reprezentację parametrów dialogowych Każdy parametr wykonania może odpowiadać jednemu lub większej liczbie parametrów dialogowych Parametry wykonania mogą się różnić od parametrów dialogowych nie tylko wartością, ale i typem Typowe zastosowania: przeliczania, potencjalnie wielu, parametrów dialogowych na jeden parametr konfiguracyjny konwersji skali bądź typu w połączeniu z RTW

Parametry wykonania (run-time) Aby zarejestrować parametr wykonania dla każdego parametru dialogowego, należy w metodzie mdlsetworkwidths wykonać: void ssregalltunableparamsasruntimeparams( S, names) gdzie: S names -wskaźnik do struktury SimSizes, - wskaźnik do tablicy nazw parametrów dla RTW (const char_t *names[]) Simulink rozróżnia jedynie pierwsze cztery znaki każdej nazwy (muszą być niepowtarzalne)!

Parametry wykonania (run-time) Aby zarejestrować pojedynczy parametr wykonania lub kilka takich parametrów należy, w metodzie mdlsetworkwidths() wykonać: sssetnumruntimeparams( SimStruct *S, int_t num) gdzie: S -wskaźnik do struktury SimSizes, num - liczba parametrów wykonania Dalsze czynności zależą od typu relacji pomiędzy parametrem wykonania a parametrem dialogowym

Parametry wykonania (run-time) Aby powiązać parametr wykonania z jednym i tylko jednym parametrem dialogowym, należy wykonać: void ssregdlgparamasruntimeparam(simstruct *S, int_t nrd, int_t nrw, const char_t *nazwa, DTypeId nazwat); gdzie: S nrd nrw nazwa wskaźnik do struktury SimStruct bloku, numer parametru dialogowego numer parametru wykonania symboliczna nazwa parametru wykonania nazwat nazwa typu parametru wykonania Parametry mogą różnić się typem!

Parametry wykonania (run-time) Aby powiązać parametr wykonania z kilkoma parametrami dialogowymi, należy wykonać: void sssetruntimeparaminfo(simstruct *S, int_t nrw, ssparamrec *info); gdzie: S nrw info Parametry mogą różnić się typem! wskaźnik do struktury SimStruct bloku, numer parametru wykonania struktura określająca powiązania pomiędzy parametrami

Parametry wykonania (run-time) Aby uaktualnić parametry wykonania należy, w metodzie mdlprocessparametres(), wywołać jedną z funkcji: ssupdatealltunableparamsasruntimeparams(simstruct *S) dla uaktualnienia wszystkich parametrów, ssupdateruntimeparamdata( SimStruct *S, int_t nrw, void *dana); dla uaktualnienia pojedynczego parametru, utworzonego przez wywołanie ssregdlgparamasruntimeparam() ("dana" to wskaźnik do nowej wartości parametru), ssupdatedlgparamasruntimeparam(simstruct *S, int_t nrw) dla uaktualnienia parametru utworzonego przez wywołanie sssetruntimeparaminfo().

Parametry wykonania (run-time) Aby posłużyć się wartością parametru wykonania należy wywołać makro: ssparamrec * ssgetruntimeparaminfo(simstruct *S, int_t nrw); którego drugim argumentem jest numer żądanego parametru wykonania. Zwrócona przez makro struktura posiada pole "data", którego jest wskaźnikiem do żądanej wartości parametru wykonania. Wskaźnik ten należy wcześniej skonwertować do żądanego typu, np.: real_t par1 = *( (real_t *)((ssgetruntimeparaminfo(s,0)->data));

Czasy próbkowania Czas próbkowania ustalany jest zazwyczaj w metodzie mdlinitializesizes, najczęściej jako jeden dla całego bloku funkcyjnego (tzw. block-based sample times) W takim rozwiązaniu należy wywołać funkcję void sssetnumsampletimes( SimStruct *S, int_t Num); gdzie: S - wskaźnik do struktury SimStruct bloku Num - ilość czasów próbkowania, > 0 Simulink wywoła wtedy metodę mdlinitializesampletimes, w której czasy próbkowania powinny zostać ustawione

Czasy próbkowania Czasy próbkowania wpisuje się jako pary [czas_próbkowania, offset] za pomocą funkcji: sssetsampletime( SimStruct *S, st_index, time_t Czas ); sssetoffsettime( SimStruct *S, st_index, time_t Offset ); gdzie: S st_index - wskaźnik do struktury SimStruct bloku, - indeks pary, dla której dokonuje się zmian, począwszy od 0, Czas, Offset - czas i offset dla danej pary

Czasy próbkowania Możliwe są następujące kombinacje: [CONTINUOUS_SAMPLE_TIME, 0.0] - funkcja ciągła, która dokonuje zmian w małych krokach symulacji, [CONTINUOUS_SAMPLE_TIME, FIXED_IN_MINOR_STEP_OFFSET] - funkcja ciągła, która nie dokonuje zmian wyjść w małym kroku symulacji, [Tp, To ] - funkcja dyskretna, z określonym okresem próbkowania, Tp > 0 oraz 0 To Tp, [VARIABLE_SAMPLE_TIME, 0.0] - funkcja, której czas próbkowania jest zmienny; funkcja taka powinna zdefiniować metodę mdlgettimeofnexvarhit(),

Czasy próbkowania [INHERITED_SAMPLE_TIME, 0.0] - funkcja, której czas próbkowania zależy od sygnału podłączonego do bloku [INHERITED_SAMPLE_TIME, FIXED_IN_MINOR_STEP_OFFSET] - funkcja, której czas próbkowania zależy od sygnału podłączonego do bloku, lecz funkcja nie zmienia swoich wartości wyjściowych podczas małego kroku symulacji Dla sprawdzenia, czy bieżąca chwila jest chwilą dyskretnego próbkowania, bądź chwilą pracy małej pętli symulacji, należy wykorzystać makra: ssissamplehit( SimStructure *S, st_index, tid ); ssiscontinuoustask( SimStructure *S, st_index, tid );

Czasy próbkowania Można także używać innych czasów próbkowania dla różnych portów - wówczas należy w metodzie mdlinitializesizes() wykonać funkcję sssetnumsampletimes(s, PORT_BASED_SAMPLE_TIMES), a następnie: sssetinputportsampletime( S, NumPortu, Czas1 ); sssetinputportoffsettime( S, NumPortu, Offset1 ); sssetoutputportsampletime( S, NumPortu, Czas2 ); sssetoutputportoffsettime( S, NumPortu, Offset2 ); S-funkcja wykorzystująca indywidualne czasy próbkowania nie powinna wywoływać makr sssetsampletime() i sssetoffsettime() Możliwe jest także dziedziczenie czasu próbkowania, bądź użycie "stałego" czasu próbkowania dla portu

Czasy próbkowania S-funkcja, która posiada choć jeden port, który dziedziczy czas próbkowania, powinna zdefiniować metody mdlsetinputportsampletime() jeżeli jest to port wejściowy, bądź mdlsetoutputportsampletime() jeżeli jest to port wyjściowy, bądź obydwie te metody Metody te mogą posłużyć się makrami: real_t ssgetinputportsampletime(simstruct *S, int_t nr) real_t ssgetinputportoffsettime (SimStruct *S, int_t nr) real_t ssgetoutputportsampletime(simstruct *S, int_t nr) real_t ssgetoutputportoffsettime(simstruct *S, int_t nr) w celu odczytania aktualnego czasu próbkowania

Czasy próbkowania Przez "stały" czas próbkowania (ang. constant sample time) dokumentacja Simulinka rozumie sytuację, gdy wartość wejścia lub wyjścia s-funkcji nie ulega zmianie w trakcie symulacji Aby zezwolić na wykorzystanie "stałego" czasu próbkowania, należy w metodzie mdlinitializesizes() ustawić opcję SS_OPTION_ALLOW_CONSTANT_PORT_SAMPLE_TIME "Stały" czas próbkowania uzyskuje się przez ustawienie czasu próbkowania portu równego nieskończoności, i offsetu równego zero, np.: sssetinputportsampletime(s, 0, mxgetinf() ); sssetinputportoffsettime(s, 0, 0);

Czasy próbkowania Jeżeli portem, dla którego ustala się "stały" czas próbkowania, jest port wyjściowy, należy w metodzie mdloutput() sprawdzać, czy drugi parametr jej wywołania jest równy symbolicznej wartości CONSTANT_TID Jeżeli tak jest, należy ustawić wartość portu o "stałym" czasie próbkowania

Czasy próbkowania Funkcja o zmiennym czasie próbkowania powinna implementować metodę mdlgettimeofnextvarhit() W metodzie tej należy wywołać makro: sssettnext(simstruct *S, time_t tnext); Drugim parametrem powyższego makra jest bezwzględny czas symulacji, w którym powinno nastąpić następne przetwarzanie metod bloku Bieżącą chwilę symulacji można określić za pomocą makra: time_t ssgett(simstruct *S) Jeżeli metoda mdlgettimeofnextvarhit() korzysta z wartości któregoś z wejść, należy dla tego wejścia ustawić cechę bezpośredniego przejścia sygnału przez blok

Wektory robocze Zmienne, których wartości mają być przechowywane pomiędzy kolejnymi wywołaniami, można zadeklarować jako statyczne zmienne języka C Wadą takiego rozwiązania jest nadpisywanie tych zmiennych przez kolejne instancje danego bloku Wektory robocze Simulinka są pozbawione tej wady - mogą one przechowywać zmienne typu integer, real, wskaźnik i typu ogólnego

Wektory robocze Do ustawiania rozmiarów wektorów roboczych służą następujące makra, wywoływane w mdlinitializesizes(): sssetnumcontstates - rozmiar wektorów stanów ciągłych sssetnumdiscstates - rozmiar wektorów stanów dyskretnych sssetnumdwork - rozmiar wektorów roboczych typu ogólnego sssetnumrwork - rozmiar wektorów roboczych typu real sssetnumiwork - rozmiar wektorów roboczych typu integer sssetnumpwork - rozmiar wektorów roboczych typu wskaźnikowego sssetnummodes - rozmiar wektora trybów sssetnumnonsampledzcs - ilość stanów, dla których wyznaczane są chwile przejść przez zero

Wektory robocze Makra te są dwuparametrowe drugim parametrem jest żądana liczba wektorów roboczych danego typu Drugi parametr może przyjmować następujące wielkości: zero (domyślna wielkość), wartość całkowita dodatnia, DYNAMICALLY_SIZED dla wielkości zależnej od wielkości wyjścia bloku (dobór automatyczny). Można zdefiniować metodę mdlsetworkwidths, w której dobiera się rozmiary wektorów roboczych, a w której znane są już rozmiary wejść i wyjść

Wektory robocze W przypadku wektorów typu ogólnego należy dookreślić typ i rodzaj każdego pola wektora przez wywołania: void sssetdworkdatatype(simstruct *S, int_t pos, DTypeID typ); void sssetdworkwidth(simstruct *S, int_t pos, int_t rozm) void sssetdworkcomplexsignal(simstruct *S, int_t pos, Csignal_T flaga); gdzie flata = COMPLEX_YES lub COMPLEX_NO

Wektory robocze W dowolnej z metod możliwe jest odczytanie rozmiaru każdego z wektorów roboczych przez wywołania makr: int_t ssgetnumdwork(simstruct *S); int_t ssgetnumiwork(simstruct *S); int_t ssgetnumpwork(simstruct *S); int_t ssgetnumrwork(simstruct *S); Dostęp do wektorów zmiennych roboczych uzyskuje się za pomocą wywołań: void* ssgetdwork(simstruct *S, int_t pozycja); int_t* ssgetiwork(simstruct *S); void** ssgetpwork(simstruct *S); real_t* ssgetrwork(simstruct *S);

Raportowanie błędów Do zgłaszania Simulinkowi błędów, np. błędnie wpisanych parametrów, używa się funkcji: void ssseterrorstatus( SimStruct *S, const char_t *msg ); gdzie: S - wskaźnik do struktury SimStruct, msg - wskaźnik do łańcucha z opisem błędu. Łańcuch z opisem błędu powinien być na stałe w pamięci (static), nie może to być zmienna lokalna! Do wyświetlenia okna dialogowego z ostrzeżeniem służy makro: void sswarning( SimStruct *S, const char_t *msg );

Raportowanie błędów Do wyświetlenia dowolnego komunikatu w głównym oknie Matlaba służy makro: int_t ssprintf(const char_t *msg,... ); Wartością zwracaną jest liczba poprawnie wyświetlonych bajtów, lub zero w przypadku błędu

Raportowanie błędów Wyjątki w dokumentacji Simulinka są rozumiane jako "długie skoki" (ang. long jumps) Wystąpienie tak rozumianych wyjątków jest możliwe przy wywołaniu wszystkich funkcji, których nazwy rozpoczynają się od "mex" Również funkcje o nazwach rozpoczynających się od "mx" nie dają gwarancji braku wyjątków Nigdy nie powodują wystąpienia wyjątku te z funkcji o nazwach rozpoczynających się od "mx", które zwracają wskaźnik lub rozmiar, np. mxgetpr(), mxgetdata(), msgetm(), mxgetnumberofelements() Obsługa wyjątków pociąga za sobą niebagatelny koszt czasowy

Raportowanie błędów W celu wyłączenia obsługi błędów można wykorzystać makro: sssetoptions( S, SS_OPTION_EXCEPTION_FREE_CODE ) W przypadku błędów funkcja z włączoną powyższą opcją może spowodować niezdefiniowane zachowanie Simulinka (zwykle zawieszenie) Opcja SS_OPTION_RUNTIME_EXCEPTION_FREE_CODE sygnalizuje, że wyjątków nie powoduje kod najczęściej wykonywanych metod mdlgettimeofnextvarhit(), mdlupdate(), mdlderivatives() i mdloutputs()

S-funkcje w C++ Mechanizm Simulinka zakłada sposób wywołań s-funkcji właściwy dla języka C W celu wykorzystania w Simulinku kodu z języka C++ należy wszystkie wywołania metod Simulinka objąć dyrektywą <extern C >: #ifdef cplusplus extern C { #endif... #ifdef cplusplus } #endif

S-funkcje w C++ Przechowywanie obiektów języka C++ pomiędzy wywołaniami metod Simulinka wymaga wykorzystania wskaźnikowych wektorów roboczych. Sposób postępowania jest następujący: 1. static void mdlinitializesizes( SimStruct *S ){... sssetnumpwork( S, 1 ); //Utworzenie wektora wsk. } 2. static void mdlstart( SimStruct *S, int_t tid ){ ssgetpwork(s)[ 0 ] = (void *) new Obiekt; }

S-funkcje w C++ 3. Aby odwołać się do obiektu, należy odczytać wskaźnik: void mdloutputs( SimStruc *S, int_t tid){ Obiekt *Ob1 = (Obiekt *) ssgetpwork(s)[ 0 ]; real_t *y = ssgetoutputportrealsignal( S, 0 ); y[ 0 ] = Obiekt->wyjscie(); } 4. Na koniec symulacji należy obiekt skasować: void mdlterminate( SimStruct *S ){ Obiekt *Ob1 = (Obiekt *) ssgetpwork(s)[ 0 ]; delete Ob1; }

S-funkcje w C++ Przykład: wzmacniacz w języku C++