ابتدا میتوانید یک ویدیو از این مطلب ببینید.
پروژهای که انجام خواهد شد، یک شبیهسازی است ، که با استفاده از توابع هیستریزیسینک که در خود سایت مذکور موجود است اشاره شده است.
و به‌اصطلاح سیتیای که پیادهسازی شده است ، از قسمتهای مختلفی که یک ولتاژ است تشکیل‌شده است
که وارد یک به‌اصطلاح فلاکس اولیه میشود و بعد از آن وارد یک سیستم پریمینینت میشود.
خود این فلاکس پریمینینت شده که در یک گِین ضرب میشود، وارد یک اینترنالینگ-لوپ یا لوپ داخلی میشود.
که خود این براساس گِینی که وارد میشود،
یک تقسیم بر فلاکس بیس است و زمانی که دیده و دقت داده می شود به این توابعی که برای این سیستم نوشته شده است
نشان داده می شود که از قسمتهای مختلفی تشکیل‌شده که یک خود فلاکس وارد شده است.
برنامه نوشته شدهدر پیوست است
که به صورت یک تابع میان و آن را تعریف میکنند و بعد از آن وارد یک به‌اصطلاح سویچ می آید
که حالا هر کدام از این سویچها که آی یا تی آر هست می آید و وارد سویچ میشود و با استفاده از این تی آر میاد مقایسه میشود
که کدام یکی از این ها بعنوان جریان خروجی بیاید و از سی تیِ ما خارج بشود. این شمایلی هست
که برای یک سیستم دیستربیوشن نت ورک یا شبکه توزیع آمده در نظر گرفته شده که حالا از یک به‌اصطلاح منبع ولتاژ آمده و آن در نظر گرفته شده است.
که حالا این منبع ولتاژ ما برابر 84 ولت هست و بعد از آن می اید وارد سی تیِ ما میشه که قبل از اینکه وارد سی تی بشود، جریان اندازهگیری میشود بعنوان آی1
به وُرک اسپیس یا محل اصطلاح این قسمت می اید و قرار میگیرد
، در ورک اسپیس و بعد از ان که وارد به‌اصطلاح سی تی شدند،
یک سری به‌اصطلاح مقاومت و خازن قرار داده شده است
که معادل شبکه هست و ولتاژ را در این قسمت اندازهگیری میکنند
که هم ولتاژ آر ام اس اندازهگیری میشود،
همه اینها وارد اُسکوپ میشوند و در نهایت برای هسیتریزیس اندازهگیری شدند،
به حالت گرافِ ایکس وای می آید و آن را اندازهگیری میکنند که حالا اگر شبیهسازیای که انجام داده شود و پلی شود، میبینید که گرافِ هسیتریزیس شروع به رسم کردن می کند
و بعد از آن که ولتاژ و به‌اصطلاح جریان بصورت آر ام اس نشان داده می شود اندازهگیری میشود..
حالا در قسمتهای مختلف ما باید شبیهسازیهای مختلفی انجام داده شود، و طبق خواستة مسئله. بطور مثال این جریان، جریان نامیِ نام دارد.
که از اینجا اخذ میشود و بصورت جریان نامی از اینجا خارج میشود،
درصورتیکه علاوه بر اینکه جریان نامی گرفته می شود ، باید 200 برابر جریان نامی رو از سی تی گذرانده شود.
که
با هم به‌اصطلاح دستکاری کردنِ بار میتوان این عمل رو انجام داد
و هم با استفاده از دستکاری کردن به‌اصطلاح خود منبع میتوان به این قسمت دست پیدا کرد
و همچنین میتوان برای یک درصد، اینکار را انجام داد و با افزودن به‌اصطلاح خروجیِ بار میتوان این کار را انجام دهد
که حالا هر کدام از اینها ممکن است.
پیوست برنامه نوشته دشه برای توابع متلبی
#define S_FUNCTION_NAME ftshysteresis
#define S_FUNCTION_LEVEL 2
#include “simstruc.h”
#include <math.h>
#define NPARAMS 21
#define NINPUTS 1
#define NOUTPUTS 3
/ * تعریف پارامترهای ارسال شده به تابع S * /
#define param_ht_sgn_ini (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 0)))) /*HT.sgn_ini*/
#define param_ht_Tr_ini (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 1)))) /*HT.Tr_ini*/
#define param_ht_I_inv_ini (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 2)))) /*HT.I_inv_ini*/
#define param_ht_F_inv_ini (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 3)))) /*HT.F_inv_ini*/
#define param_ht_Fs (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 4)))) /*HT.Fs*/
#define param_ht_Dk_ini (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 5)))) /*HT.Dk_ini*/
#define param_ht_Db_ini (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 6)))) /*HT.Db_ini*/
#define param_ht_dmax_ini (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 7)))) /*HT.dmax_ini*/
#define param_ht_Is (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 8)))) /*HT.Is*/
#define param_ht_a (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 9)))) /*HT.a*/
#define param_ht_b (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 10)))) /*HT.b*/
#define param_ht_c (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 11)))) /*HT.c*/
#define param_ht_e (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 12)))) /*HT.e*/
#define param_ht_alpha (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 13)))) /*HT.alpha*/
#define param_ht_Fj (( دو برابر *) mxGetPr ((ssGetSFcnParam (S، 14)))) / * HT.Fj param_ht_Jmax دو * /
#define param_ht_Mj (( دو برابر *) mxGetPr ((ssGetSFcnParam (S، 15)))) / * HT.Mj param_ht_Jmax دو * /
#define param_ht_Bj (( دو برابر *) mxGetPr ((ssGetSFcnParam (S، 16)))) / * HT.Bj param_ht_Jmax دو * /
#define param_ht_delFj (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 17)))) / * HT.delFj int * /
#define param_ht_Jmax (( int ) * mxGetPr ((ssGetSFcnParam (S، 18)))) /*HT.Jmax*/
#define param_tolerances (( دو برابر *) mxGetPr ((ssGetSFcnParam (S، 19)))) / * Tolerances * /
#define param_Ts (( دو برابر ) * mxGetPr ((ssGetSFcnParam (S، 20)))) / * Ts * /
#define NUM_D_WORKS 15
#define MLOOPS 200
#define MAX_STRING 10
تایپد ساختار {
دو برابر Sgn؛
int Tr؛ / * index de la trajectoire * /
دو برابر I_inv [MLOOPS]؛
دو برابر F_inv [MLOOPS]؛
دو برابر I_old؛
دو برابر F_old؛
دو برابر Dk [MLOOPS]؛
دوبلین Db [MLOOPS]؛
دو برابر dmax [MLOOPS]؛
دو برابر dmin [MLOOPS]؛
دو برابر dp_2؛
دو برابر P؛
دو ب
دوبار Fa_dp2؛
دوبار Fb_dp2؛
} M_struct_t؛
بدون امضا int ftshysteresisBlockId = 0؛
/ * رونویسی از روش fix.m: دور به سمت صفر * /
ثابت int ( دو برابر x)
{
بازگشت (( int ) x)؛
}
/ * Fonction determinant leant de magnetisation vs le flux (de la courbe
* صعود به سطح اضافی)، خط درون یابی.
* Le flux doit respectter: -Fs <= flux <= Fs.
*
* X = Flux *** تجارتی -Fs و Fs inclusion ***
* XT = Vecteur: Flux (شاخص) ou coordonnee du segment indice.
* DFXT = Vecteur: pente ou [delta courant / delta flux] (indice) دو بخش
* شاخص
* BFXT = Vecteur: نقطه تقاطع دو بخش از دیترویت به منزل.
* DELXT = تعادل ثابت جریان جوش
* NF = Numbre de points ou elements du vecteur.
* /
double i_f ( double X، double * XT، double * DFXT، double * BFXT، double DELXT، int NF)
{
int j؛
j = ثابت ((X-XT [0]) / DELXT)؛ / * سرگردان * /
اگر (j <= 0)
{
ج = 0؛
}
چیز دیگری اگر (j> NF – 2)
{
j = NF – 2؛
}
بازگشت (BFXT [j] + DFXT [j] * X)؛
}
/ * تابع که آزمون اگر عدد NAN باشد یا نه * /
کاراکتر IsNumber ( دو برابر )
{ / * این به نظر می رسد که همیشه باید درست باشد
/ اما اگر x یک NaN باشد، اشتباه است. * /
بازگشت (x == x)؛
}
void computeCurrent (SimStruct * S، int size، double * pSys، M_struct_t * pM)
{ / * computeCurrent به پارامترهای HT و Tolerances * /
real_T * x؛
دو F؛ / * شارژ * /
دو برابر TOL_F، TOL_I؛
دو DELTA_FLUX، TOLERANCE_VARIATION، DELTA_FLUX_INVERSION، d، Ie؛
دو برابر TOLERANCE_VARIATION_INV؛
int Tr؛ / * index de la trajectoire partant de 1 provenant des parameters du bloc * /
int index_Tr؛ / * index de la trajectoire partant de 0 * /
DELTA_F دوبل DELTA_I؛
دو برابر I = 0.0؛
int dp_1، DLim، TEST1؛
InputRealPtrsType uPtrs = ssGetInputPortRealSignalPtrs (S، 0)؛
/ * استخراج M از بلوک: * /
x = (real_T *) ssGetDWork (S، 0)؛
pM-> sgn = x [0]؛
x = (real_T *) ssGetDWork (S، 1)؛
pM-> Tr = ( int ) x [0]؛
x = (real_T *) ssGetDWork (S، 2)؛
memcpy (pM-> I_inv، x، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 3)؛
memcpy (pM-> F_inv، x، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 4)؛
pM-> I_old = x [0]؛
x = (real_T *) ssGetDWork (S، 5)؛
pM-> F_old = x [0]؛
x = (real_T *) ssGetDWork (S، 6)؛
memcpy (pM-> Dk، x، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 7)؛
memcpy (pM-> Db، x، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 8)؛
memcpy (pM-> dmax، x، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 9)؛
memcpy (pM-> dmin، x، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 10)؛
pM-> dp_2 = x [0]؛ / * drapeau delta flux petit * /
x = (real_T *) ssGetDWork (S، 11)؛
pM-> P = x [0]؛ / * Pente de la droite reliant deux points d’inversion. * /
x = (real_T *) ssGetDWork (S، 12)؛
pM-> B = x [0]؛ / * Droite: I = PF + B. * /
x = (real_T *) ssGetDWork (S، 13)؛
pM-> Fa_dp2 = x [0]؛ / * Coordonnee du dernier point d inversion (rev1.b) * /
x = (real_T *) ssGetDWork (S، 14)؛
pM-> Fb_dp2 = x [0]؛ / * Coordonnee de l’avant dernier point d’inversion (rev1.b) * /
/ * l’entree est le flux: * /
F = * uPtrs [0]؛
Tr = pM-> Tr؛
index_Tr = Tr-1؛ / * index commencant 0 * /
TEST1 = 0؛ / * Si 1: aucune limitation du flux. * /
TOL_F = param_tolerances [0]؛ / * HT.Fs / 1e5؛٪ Seuil de detection de boucle interne (en pu ou en SI؟) * /
TOL_I = param_tolerances [1]؛ / * HT.Ic / 1e2؛٪ tolerance dans le delta I entre deux points d’inversion * /
/ * ———————————-
انحراف تشخیص d ‘une
———————————- * /
DELTA_FLUX = F – pM-> F_old؛
TOLERANCE_VARIATION = TOL_F؛
TOLERANCE_VARIATION_INV = TOL_F * 0.1؛
/ * شناسایی مواردی را که منحصرا مرتکب می شوند (حالت ضروری در حالت مداوم) (rev.2) * /
اگر (((DELTA_FLUX> + TOLERANCE_VARIATION_INV) && (pM-> sgn == -1)) ||
(DELTA_FLUX <-TOLERANCE_VARIATION_INV) && (pM-> sgn == 1)))) && ssIsMajorTimeStep (S))
{ / * معکوس کردن FLUX.
———————————-
بازخوانی پارامترهای دایره المعارف مجرمانه
———————————-
Etablissement du senecondire de la nouvelle trajectoire. * /
pM-> sgn = -pM-> sgn؛
/ * حافظه ضریب تبدیل دایرهای.
سی دی در حالت demesure و zonation de saturation در دسترس است
rev1.b dp_2 = 0؛ ٪ reset du drapeau delta flux petit
* /
اگر ((fabs (F)> param_ht_Fs) || (fabs (F) <= param_ht_Fs && fabs (pM-> F_old)> param_ht_Fs))
{
index_Tr = 0؛ / * در نوبت به نوبۀ خود،
pM-> I_inv [index_Tr] = -param_ht_Is * pM-> sgn؛ / * Memorisation des coordonnees du point * /
pM-> F_inv [index_Tr] = -param_ht_Fs * pM-> sgn؛ / * d’inversion. * /
}
چیز دیگری اگر (index_Tr == 0)
{ / * Si بر روی صفحه نمایش اصلی * /
index_Tr ++؛ / * Numerotation de la nouvelle trajectoire. * /
pM-> I_inv [index_Tr] = pM-> I_old؛ / * Memorisation des coordonnees du point * /
pM-> F_inv [index_Tr] = pM-> F_old؛ / * d’inversion. * /
pM-> dmax [index_Tr] = pM-> F_inv [index_Tr] – (-pM-> sgn * (param_ht_a * atan ((param_ht_b * (- pM-> sgn) * pM-> I_inv [index_Tr]) + param_ht_c) – (pM-> sgn * param_ht_alpha * pM-> I_inv [index_Tr]) + param_ht_e))؛
pM-> dmin [index_Tr] = 0؛ / * نکته نهایی خودرویی که در اختیار شما قرار گرفته است. * /
/ * اجتناب از تقسیم صفر: * /
اگر ((pM-> F_inv [index_Tr] – pM-> sgn * param_ht_Fs) == 0)
{
pM-> Dk [index_Tr] = 1e6؛ / * مقدار پیش فرض ساختگی .. بهتر از NaN یا مقدار Inf است … * /
}
چیز دیگری
{
pM-> Dk [index_Tr] = pM-> dmax [index_Tr] / (pM-> F_inv [index_Tr] – pM-> sgn * param_ht_Fs)؛
}
pM-> Db [index_Tr] = pM-> dmax [index_Tr] – (pM-> Dk [index_Tr] * pM-> F_inv [index_Tr])؛ / * Db = da F = 0. * /
}
چیز دیگری
{ / * TEST de boucle interne * /
اگر ((fabs (pM-> F_old – pM-> F_inv [index_Tr-1]) <TOLERANCE_VARIATION))
{
dp_1 = 1؛
index_Tr -؛
}
چیز دیگری
{
dp_1 = 0؛
index_Tr ++؛
/ * Verification de la limite maximale pour Tr (200 internets boucles) * /
اگر (index_Tr> = MLOOPS)
{
/ * test PB: * /
index_Tr = MLOOPS – 1؛
ssSetErrorStatus (S، “حداکثر تعداد حلقه های داخلی رسیده است” )؛
بازگشت؛
}
}
/ * Memorisation des coordonnees du point d inversion * /
pM-> I_inv [index_Tr] = pM-> I_old؛
pM-> F_inv [index_Tr] = pM-> F_old؛
اگر (dp_1 == 0) / * depass la تحمل (nouvelle boucle interne) * /
{
/ * max = d au point d inversion * /
pM-> dmax [index_Tr] = pM-> F_inv [index_Tr] – (-pM-> sgn * (param_ht_a * atan ((param_ht_b * (- pM-> sgn) * pM-> I_inv [index_Tr]) + param_ht_c)
– (pM-> sgn * param_ht_alpha * pM-> I_inv [index_Tr]) + param_ht_e))؛
pM-> dmin [index_Tr] = pM-> F_inv [index_Tr-1] – (-pM-> sgn * (param_ht_a * atan ((param_ht_b * (- pM-> sgn) * pM-> I_inv [index_Tr-1] ) + param_ht_c)
– (pM-> sgn * param_ht_alpha * pM-> I_inv [index_Tr-1]) + param_ht_e))؛
/ * اجتناب از تقسیم صفر: * /
اگر ((pM-> F_inv [index_Tr-1] – pM-> F_inv [index_Tr]) == 0)
{
pM-> Dk [index_Tr] = 1e6؛ / * مقدار پیش فرض ummy .. بهتر است از NaN یا مقدار Inf … * /
}
چیز دیگری
{
pM-> Dk [index_Tr] = (pM-> dmin [index_Tr] – pM-> dmax [index_Tr]) / (pM-> F_inv [index_Tr-1] – pM-> F_inv [index_Tr])؛
}
pM-> Db [index_Tr] = pM-> dmax [index_Tr] – (pM-> Dk [index_Tr] * pM-> F_inv [index_Tr])؛ / * Db = da F = 0. * /
}
}
/ * (REV) تأییدیه de variation de flux tres petite (synonyme d’une boucle interne infime) et donc: * /
/ * بر روی Calcule une droite entre les deux points d’inversions * /
/ * test sur la variation du Flux * /
اگر (index_Tr> 0)
{
/ * شاخص توجه توجه به قوانین و مقررات: * /
DELTA_F = pM-> F_inv [index_Tr] -pM-> F_inv [index_Tr-1]؛
DELTA_I = pM-> I_inv [index_Tr] -pM-> I_inv [index_Tr-1]؛
/ * test sur la variation du courant rev1.n * /
اگر ((fabs (DELTA_I) <TOL_I) && (pM-> dp_2 == 0)) / * rev1.b * /
{
/ * variation de courant tres petite و n’est pas deja dans une boucle minimue، donc: * /
/ * بر روی calcule une droite entre les deux points d inversion * /
/ * I = P * Flux + B؛ * /
pM-> P = DELTA_I / DELTA_F؛
/ * توجه: ايميل را وارد نماييد که در آن نباشد
(Cf “Detection d’une inversion” plus haut) * /
pM-> B = pM-> I_inv [index_Tr] – pM-> P * pM-> F_inv [index_Tr]؛
/ * Memorisation des 2 derniers points d’inversions (extremees de la boucle minime) * /
pM-> Fb_dp2 = pM-> F_inv [index_Tr-1]؛ / * rev1.b * /
pM-> Fa_dp2 = pM-> F_inv [index_Tr]؛ / * rev1.b * /
/ * activation du drapeau delta flux petit * /
pM-> dp_2 = 1؛
}
}
}
چیز دیگری
{ / * FLUX ادامه در همان جهت! * /
/ * Faire la detection d’un depassement * /
اگر (index_Tr> 1)
{ / * Si بر روی n’est pas sere une trajectoire dont le point * /
/ * de depensement le le de point saturation * /
DELTA_FLUX_INVERSION = F – pM-> F_inv [index_Tr – 1]؛
/ * Detection de depassement، revenir sur la trajectoire de la boucle emboitante (connue).
در صورت عدم رعایت ضوابط و مقررات مربوطه (ضروری در حالت مداوم) (نسخه 2) * /
اگر ((((DELTA_FLUX_INVERSION> + TOLERANCE_VARIATION) && (pM-> sgn == 1)) ||
((DELTA_FLUX_INVERSION <-TOLERANCE_VARIATION) && (pM-> sgn == -1)))) && ssIsMajorTimeStep (S))
{
index_Tr = index_Tr – 2؛
/ * تست را برای تسویه حساب شما انجام دهید (dp_2) (rev1.b) * /
اگر ((F> pM-> Fa_dp2) && (F> pM-> Fb_dp2)) || ((F <pM-> Fa_dp2) && (F <pM-> Fb_dp2))) / * rev1.b * /
{
pM-> dp_2 = 0؛ / * reset du drapeau delta flux petit (rev 1) * /
}
}
}
/ * بر روی زمین قرارگرفته و از آنجا که میزان اشباع در مجاورت نور جدید است
تشخیص se fait lors du pas majeur * /
اگر ((fabs (F) -param_ht_Fs> + TOLERANCE_VARIATION) && ssIsMajorTimeStep (S))
{
index_Tr = 0؛
}
}
DLim = 0؛ / * خوب دزیمر لو دایپو * /
/ * محاسبه جریان خروجی به عنوان عملکرد شار ورودی: * /
اگر (F> param_ht_Fs)
{ / * ما به منطقه اشباع مثبت وارد می شویم * /
من = param_ht_Is؛ / * نیازی به ارزیابی این نیست، زیرا از خارج از عملکرد محاسبه می شود. * /
/ * بود: I = interp1 (HT.Fj_sat، HT.Ij_sat، F)؛ * /
}
چیز دیگری اگر (F <-param_ht_Fs)
{ / * ما وارد منطقه اشباع منفی می شویم * /
I = -param_ht_Is؛ / * نیازی به ارزیابی این نیست، از آنجا که * /
/ * محاسبه خارج از عملکرد. * /
/ * بود: I = -interp1 (HT.Fj_sat، HT.Ij_sat، F)؛ * /
}
چیز دیگری اگر (index_Tr == 0) / * Boucle principale * /
{
I = pM-> sgn * i_f (pM-> sgn * F، param_ht_Fj، param_ht_Mj، param_ht_Bj، param_ht_delFj، param_ht_Jmax)؛
}
چیز دیگری اگر (index_Tr> 0)
{ / * Boucle interne * /
/ * * * * * * * * * *
اگر (pM-> dp_2)
{
I = pM-> P * F + pM-> B؛
}
چیز دیگری
{ / * calcul de I tra tract. * /
d = (pM-> Dk [index_Tr] * F) + pM-> Db [index_Tr]؛ / * Distance de l’extrados * /
اگر (! IsNumber (d))
{
/ * به نظر می رسد d می تواند NaN زمانی که Dk (Tr) و / یا Db (Tr) = inf * /
/ * این وضعیت زمانی رخ می دهد که (F_inv (Tr-1) – F_inv (Tr)) = 0 در طول * /
/ * ارزیابی Dk .. بنابراین اجازه می دهد امتحان کنید این پچ برای جلوگیری از خطا: * /
d = 0؛
}
I = pM-> sgn * i_f (pM-> sgn * (Fd)، param_ht_Fj، param_ht_Mj، param_ht_Bj، param_ht_delFj، param_ht_Jmax)؛
/ * محدودیتی که من نیاز دارم، afin qu’il demeure dans le * /
/ * چرخه اصلی. * /
Ie = -pM-> sgn * i_f (-pM-> sgn * F، param_ht_Fj، param_ht_Mj، param_ht_Bj، param_ht_delFj، param_ht_Jmax)؛
اگر (((I <Ie) && (pM-> sgn == 1)) || ((I> Ie) && (pM-> sgn == – 1))) && ~ TEST1)
{
I = Ie؛
DLim = 1؛
}
}
}
/ * خروجی های Sfunction بروز رسانی. * /
pSys [0] = I؛
pSys [1] = index_Tr +1؛
اگر (index_Tr == 0)
{
pSys [2] = pM-> sgn؛
}
چیز دیگری
{
pSys [2] = 0؛
}
/ * به روز رسانی اتاق سهام M: * /
pM-> Tr = index_Tr +1؛
pM-> I_old = I؛
pM-> F_old = F؛
}
void SaveMinDwork (SimStruct * S، M_struct_t * pM)
{
real_T * x؛
x = (real_T *) ssGetDWork (S، 0)؛
x [0] = pM-> sgn؛
x = (real_T *) ssGetDWork (S، 1)؛
x [0] = pM-> Tr؛
x = (real_T *) ssGetDWork (S، 2)؛
memcpy (x، pM-> I_inv، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 3)؛
memcpy (x، pM-> F_inv، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 4)؛
x [0] = pM-> I_old؛
x = (real_T *) ssGetDWork (S، 5)؛
x [0] = pM-> F_old؛
x = (real_T *) ssGetDWork (S، 6)؛
memcpy (x، pM-> Dk، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 7)؛
memcpy (x، pM-> Db، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 8)؛
memcpy (x، pM-> dmax، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 9)؛
memcpy (x، pM-> dmin، MLOOPS * sizeof (real_T))؛
x = (real_T *) ssGetDWork (S، 10)؛
x [0] = pM-> dp_2؛
x = (real_T *) ssGetDWork (S، 11)؛
x [0] = pM-> P؛
x = (real_T *) ssGetDWork (S، 12)؛
x [0] = pM-> B؛
x = (real_T *) ssGetDWork (S، 13)؛
x [0] = pM-> Fa_dp2؛
x = (real_T *) ssGetDWork (S، 14)؛
x [0] = pM-> Fb_dp2؛
}
استاتیک void mdlInitializeSizes (SimStruct * S)
{
کاراکتر * id [NUM_D_WORKS]؛
char * tq [NUM_D_WORKS]؛
من int ؛
بدون امضا int MAX_BLOCK_ID = 10000؛
int_T DworkSize [NUM_D_WORKS] = {1،1، MLOOPS، MLOOPS، 1،1، MLOOPS، MLOOPS، MLOOPS، MLOOPS، 1،1،1،1،1}؛
const char * DworkName [NUM_D_WORKS] = { “sgn” ، “Tr” ، “I_inv” ، “F_inv” ، “I_old” ، “xF_old” ، “Dk” ، “Db” ، “dmax” ، “dmin” ، ” dp_2 ” ، ” P ” ، ” B ” ، ” Fa_dp2 ” ، ” Fb_dp2 ” }؛
/ * increment blocksId برای نام Dwork مختلف برای چند تابع hysteresis S-function * /
اگر (ftshysteresisBlockId> = MAX_BLOCK_ID)
{
ftshysteresisBlockId = 0؛
}
چیز دیگری
{
ftshysteresisBlockId ++؛
}
برای (i = 0؛ i <NPARAMS؛ i ++)
{
ssSetSFcnParamTunable (S، I، SS_PRM_NOT_TUNABLE)؛
}
ssSetNumSFcnParams (S، NPARAMS)؛ / * تعداد پارامترهای مورد انتظار * /
برای (i = 0؛ i <NPARAMS؛ i ++)
{
ssSetSFcnParamTunable (S، I، SS_PRM_NOT_TUNABLE)؛
}
ssSetNumContStates (S، 0)؛
ssSetNumDiscStates (S، NINPUTS)؛
اگر (! ssSetNumInputPorts (S، NINPUTS)) بازگشت ؛
برای (i = 0؛ i <NINPUTS؛ i ++)
{
ssSetInputPortWidth (S، I، 1)؛
ssSetInputPortDirectFeedThrough (S، I، 1)؛
}
اگر (! ssSetNumOutputPorts (S، NOUTPUTS)) بازگشت ؛
برای (i = 0؛ i <NOUTPUTS؛ i ++)
{
ssSetOutputPortWidth (S، I، 1)؛
}
ssSetNumSampleTimes (S، 1)؛
( void ) ssSetNumDWork (S، NUM_D_WORKS)؛
ssSetNumRWork (S، 0)؛
ssSetNumIWork (S، 0)؛
ssSetNumPWork (S، 0)؛
ssSetNumModes (S، 0)؛
ssSetNumNonsampledZCs (S، 0)؛
برای (i = 0؛ i <NUM_D_WORKS؛ i ++)
{
ssSetDWorkWidth (S، I، DworkSize [i])؛
ssSetDWorkDataType (S، I، SS_DOUBLE)؛
/* مشخص کننده؛ هر تنظیم قدیمی و به روز رسانی * /
id [i] = ssGetDWorkRTWIdentifier (S، I)؛
اگر (id [i]! = NULL) {
رایگان (id [i])؛
}
id [i] = malloc (80)؛
sprintf (id [i]، “٪ s٪ d” ، DworkName [i]، ftshysteresisBlockId)؛
ssSetDWorkRTWIdentifier (S، I، ID [i])؛
/ * نوع امتیاز هر تنظیم قدیمی و به روز رسانی * /
tq [i] = ssGetDWorkRTWTypeQualifier (S، i)؛
اگر (tq [i]! = NULL) {
رایگان (tq [i])؛
}
tq [i] = malloc (80)؛
/ * strcpy (tq [i]، “fatule”)؛ * /
strcpy (tq [i]، “” )؛
ssSetDWorkRTWTypeQualifier (S، I، tq [i])؛
/ * کلاس ذخیره سازی * /
ssSetDWorkRTWStorageClass (S، I، SS_RTW_STORAGE_EXPORTED_GLOBAL)؛
/ * مشخص کنید که عناصر یک نوع داده کار بردار واقعی هستند * /
ssSetDWorkComplexSignal (S، I، COMPLEX_NO)؛ / * تنظیم به ‘واقعی’ * /
ssSetDWorkUsageType (S، I، SS_DWORK_USED_AS_DWORK)؛
}
/ * در هنگام خروج به حافظه آزاد برای پروکسی های RTW dwork خاتمه می دهد
ssSetOptions (S،
SS_OPTION_WORKS_WITH_CODE_REUSE |
SS_OPTION_EXCEPTION_FREE_CODE |
SS_OPTION_CALL_TERMINATE_ON_EXIT |
SS_OPTION_USE_TLC_WITH_ACCELERATOR)؛ * /
/ * آزمون P.Brunelle: 18-May-2010 * /
ssSetOptions (S،
SS_OPTION_EXCEPTION_FREE_CODE |
SS_OPTION_CALL_TERMINATE_ON_EXIT)؛
ssSetSimStateCompliance (S، USE_CUSTOM_SIM_STATE)؛
ssSupportsMultipleExecInstances (S، درست)؛
}
/ * تابع: mdlInitializeSampleTimes =========================================
* چکیده:
* یک نمونه زمان، و آن را به عنوان چهارم S پارامتر عملکرد منتقل می شود
* /
استاتیک void mdlInitializeSampleTimes (SimStruct * S)
{
ssSetSampleTime (S، 0، param_Ts)؛ / * Ts پارامتر 22 است * /
ssSetOffsetTime (S، 0، 0.0)؛
ssSetModelReferenceSampleTimeDefaultInheritance (S)؛
}
#define MDL_INITIALIZE_CONDITIONS
/ * تابع: mdlInitializeConditions ========================================
* چکیده:
* هر دو حالت مداوم را به صفر برسانید
* /
استاتیک void mdlInitializeConditions (SimStruct * S)
{
real_T * x؛
من int ؛
/ *
* dworks را ابتدایی کنید
* /
x = (real_T *) ssGetDWork (S، 0)؛
x [0] = param_ht_sgn_ini؛
x = (real_T *) ssGetDWork (S، 1)؛
x [0] = param_ht_Tr_ini؛
x = (real_T *) ssGetDWork (S، 2)؛
برای (i = 0؛ i <MLOOPS؛ i ++)
{
x [i] = param_ht_I_inv_ini؛
}
x = (real_T *) ssGetDWork (S، 3)؛
برای (i = 0؛ i <MLOOPS؛ i ++)
{
x [i] = param_ht_F_inv_ini؛
}
x = (real_T *) ssGetDWork (S، 4)؛
x [0] = 0؛
x = (real_T *) ssGetDWork (S، 5)؛
x [0] = -param_ht_Fs * param_ht_sgn_ini؛
x = (real_T *) ssGetDWork (S، 6)؛
برای (i = 0؛ i <MLOOPS؛ i ++)
{
x [i] = param_ht_Dk_ini؛
}
x = (real_T *) ssGetDWork (S، 7)؛
برای (i = 0؛ i <MLOOPS؛ i ++)
{
x [i] = param_ht_Db_ini؛
}
x = (real_T *) ssGetDWork (S، 8)؛
برای (i = 0؛ i <MLOOPS؛ i ++)
{
x [i] = param_ht_dmax_ini؛
}
x = (real_T *) ssGetDWork (S، 9)؛
memset (x، 0، MLOOPS)؛
x = (real_T *) ssGetDWork (S، 10)؛
x [0] = 0؛
x = (real_T *) ssGetDWork (S، 11)؛
x [0] = 0؛
x = (real_T *) ssGetDWork (S، 12)؛
x [0] = 0؛
x = (real_T *) ssGetDWork (S، 13)؛
x [0] = 0؛
x = (real_T *) ssGetDWork (S، 14)؛
x [0] = 0؛
}
/ * تابع: mdlOutputs ============================================= ==========
* چکیده:
* y = x
* /
استاتیک void mdlOutputs (SimStruct * S، int_T tid)
{
real_T * y = ssGetOutputPortRealSignal (S، 0)؛
pSys دوگانه [3]؛
M_struct_t M؛
دو برابر Ts = param_Ts؛
real_T * x = (real_T *) ssGetDWork (S، 4)؛
computeCurrent (S، MLOOPS، pSys، & M)؛
اگر (ssIsMajorTimeStep (S))
SaveMinDwork (S، & M)؛
y [0] = pSys [0]؛ /* جاری*/
y [1] = pSys [1]؛ / * Tr کنترل * /
y [2] = pSys [2]؛ / * دلتا F * /
}
#define MDL_UPDATE
/ * تابع: mdlUpdate ============================================= ===========
* چکیده:
* این تابع یک بار برای هر گام بزرگ یکپارچه نامیده می شود.
* حالت های گسسته به طور معمول در اینجا به روز می شود، اما این تابع مفید است
* برای انجام هر گونه وظیفهای که فقط باید یک بار در هر یکپارچه انجام شود
* گام.
* /
استاتیک void mdlUpdate (SimStruct * S، int_T tid)
{
/ * دو pSys [3]؛ * /
/ * M_struct_t M؛ * /
/ * نکته: در صورت لزوم، یک مأموریتی را در اختیار شما قرار می دهد. mdlOutputs lors des pas majeurs (rev.2) * /
}
/ * توابع مورد نیاز برای پشتیبانی SimStates
* /
static const char * fieldsNames [] = {
“SGN”،
“TR”،
“I_INV” ،
“F_INV” ،
“I_OLD”،
“F_OLD”،
“DK”،
“DB”،
“DMAX”،
“DMIN”،
“DP_2″،
“P”،
“B”،
“FA_DP2” ،
“FB_DP2″،
}؛
شخص توایع هوشمند nFields = SIZEOF (نام فیلدها) / SIZEOF (و const char *).
/ * تعریف کنید تا نشان دهد که این تابع S دارای روش mdlG [S] etSimState است * /
#if تعریف شده (MATLAB_MEX_FILE)
#define MDL_SIM_STATE
static mxArray * mdlGetSimState (SimStruct * S)
{
real_T * sgn = (real_T *) ssGetDWork (S، 0)؛
real_T * Tr = (real_T *) ssGetDWork (S، 1)؛
real_T * I_inv = (real_T *) ssGetDWork (S، 2)؛
real_T * F_inv = (real_T *) ssGetDWork (S، 3)؛
real_T * I_old = (real_T *) ssGetDWork (S، 4)؛
real_T * F_old = (real_T *) ssGetDWork (S، 5)؛
real_T * Dk = (real_T *) ssGetDWork (S، 6)؛
real_T * Db = (real_T *) ssGetDWork (S، 7)؛
real_T * dmax = (real_T *) ssGetDWork (S، 8)؛
real_T * dmin = (real_T *) ssGetDWork (S، 9)؛
real_T * dp_2 = (real_T *) ssGetDWork (S، 10)؛
real_T * P = (real_T *) ssGetDWork (S، 11)؛
real_T * B = (real_T *) ssGetDWork (S، 12)؛
real_T * Fa_dp2 = (real_T *) ssGetDWork (S، 13)؛
real_T * Fb_dp2 = (real_T *) ssGetDWork (S، 14)؛
/ * ایجاد یک ساختار MATLAB برای نگهداری داده های زمان اجرا * /
mxArray * simSnap = mxCreateStructMatrix (1، 1، nFields، fieldNames)؛
{
mxArray * msgn = mxCreateDoubleMatrix (1، 1، mxREAL)؛
memcpy (mxGetPr (msgn)، sgn، sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 0، msgn)؛
}
{
mxArray * mTr = mxCreateDoubleMatrix (1، 1، mxREAL)؛
memcpy (mxGetPr (mTr)، Tr، sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 1، mTr)؛
}
{
mxArray * mI_inv = mxCreateDoubleMatrix (1، MLOOPS، mxREAL)؛
memcpy (mxGetPr (mI_inv)، I_inv، MLOOPS * sizeof (واقعی_T))؛
mxSetFieldByNumber (simSnap، 0، 2، mI_inv)؛
}
{
mxArray * mF_inv = mxCreateDoubleMatrix (1، MLOOPS، mxREAL)؛
memcpy (mxGetPr (mF_inv)، F_inv، MLOOPS * sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 3، mF_inv)؛
}
{
mxArray * mI_old = mxCreateDoubleMatrix (1، 1، mxREAL)؛
memcpy (mxGetPr (mI_old)، I_old، sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 4، mI_old)؛
}
{
mxArray * mF_old = mxCreateDoubleMatrix (1، 1، mxREAL)؛
memcpy (mxGetPr (mF_old)، F_old، sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 5، mF_old)؛
}
{
mxArray * mDk = mxCreateDoubleMatrix (1، MLOOPS، mxREAL)؛
memcpy (mxGetPr (mDk)، Dk، MLOOPS * sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 6، mDk)؛
}
{
mxArray * mDb = mxCreateDoubleMatrix (1، MLOOPS، mxREAL)؛
memcpy (mxGetPr (mDb)، Db، MLOOPS * sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 7، mDb)؛
}
{
mxArray * mdmax = mxCreateDoubleMatrix (1، MLOOPS، mxREAL)؛
memcpy (mxGetPr (mdmax)، dmax، MLOOPS * sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 8، mdmax)؛
}
{
mxArray * mdmin = mxCreateDoubleMatrix (1، MLOOPS، mxREAL)؛
memcpy (mxGetPr (mdmin)، dmin، MLOOPS * sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 9، mdmin)؛
}
{
mxArray * mdp_2 = mxCreateDoubleMatrix (1، 1، mxREAL)؛
memcpy (mxGetPr (mdp_2)، dp_2، sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 10، mdp_2)؛
}
{
mxArray * mP = mxCreateDoubleMatrix (1، 1، mxREAL)؛
memcpy (mxGetPr (mP)، P، sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 11، mP)؛
}
{
mxArray * mB = mxCreateDoubleMatrix (1، 1، mxREAL)؛
memcpy (mxGetPr (mB)، B، sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 12، mB)؛
}
{
mxArray * mFa_dp2 = mxCreateDoubleMatrix (1، 1، mxREAL)؛
memcpy (mxGetPr (mFa_dp2)، Fa_dp2، sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 13، mFa_dp2)؛
}
{
mxArray * mFb_dp2 = mxCreateDoubleMatrix (1، 1، mxREAL)؛
memcpy (mxGetPr (mFb_dp2)، Fb_dp2، sizeof (real_T))؛
mxSetFieldByNumber (simSnap، 0، 14، mFb_dp2)؛
}
بازگشت simSnap؛
}
/ * تابع: mdlSetSimState ============================================= =======
* چکیده:
* ساختار MATLAB را برداشته و آنرا به RunTimeData بازگردانید
* ساختار
* /
استاتیک void mdlSetSimState (SimStruct * S، const mxArray * simSnap)
{
real_T * sgn = (real_T *) ssGetDWork (S، 0)؛
real_T * Tr = (real_T *) ssGetDWork (S، 1)؛
real_T * I_inv = (real_T *) ssGetDWork (S، 2)؛
real_T * F_inv = (real_T *) ssGetDWork (S، 3)؛
real_T * I_old = (real_T *) ssGetDWork (S، 4)؛
real_T * F_old = (real_T *) ssGetDWork (S، 5)؛
real_T * Dk = (real_T *) ssGetDWork (S، 6)؛
real_T * Db = (real_T *) ssGetDWork (S، 7)؛
real_T * dmax = (real_T *) ssGetDWork (S، 8)؛
real_T * dmin = (real_T *) ssGetDWork (S، 9)؛
real_T * dp_2 = (real_T *) ssGetDWork (S، 10)؛
real_T * P = (real_T *) ssGetDWork (S، 11)؛
real_T * B = (real_T *) ssGetDWork (S، 12)؛
real_T * Fa_dp2 = (real_T *) ssGetDWork (S، 13)؛
real_T * Fb_dp2 = (real_T *) ssGetDWork (S، 14)؛
{
const mxArray * msgn = mxGetField (simSnap، 0، fieldNames [0])؛
memcpy (sgn، mxGetPr (msgn)، sizeof (real_T))؛
}
{
const mxArray * mTr = mxGetField (simSnap، 0، fieldNames [1])؛
memcpy (Tr، mxGetPr (mTr)، sizeof (real_T))؛
}
{
const mxArray * mI_inv = mxGetField (simSnap، 0، fieldNames [2])؛
memcpy (I_inv، mxGetPr (mI_inv)، MLOOPS * sizeof (real_T))؛
}
{
const mxArray * mF_inv = mxGetField (simSnap، 0، fieldNames [3])؛
memcpy (F_inv، mxGetPr (mF_inv)، MLOOPS * sizeof (real_T))؛
}
{
const mxArray * mI_old = mxGetField (simSnap، 0، fieldNames [4])؛
memcpy (I_old، mxGetPr (mI_old)، sizeof (real_T))؛
}
{
const mxArray * mF_old = mxGetField (simSnap، 0، fieldNames [5])؛
memcpy (F_old، mxGetPr (mF_old)، sizeof (real_T))؛
}
{
const mxArray * mDk = mxGetField (simSnap، 0، fieldNames [6])؛
memcpy (Dk، mxGetPr (mDk)، MLOOPS * sizeof (واقعی_T))؛
}
{
const mxArray * mDb = mxGetField (simSnap، 0، fieldNames [7])؛
memcpy (Db، mxGetPr (mDb)، MLOOPS * sizeof (real_T))؛
}
{
const mxArray * mdmax = mxGetField (simSnap، 0، fieldNames [8])؛
memcpy (dmax، mxGetPr (mdmax)، MLOOPS * sizeof (real_T))؛
}
{
const mxArray * mdmin = mxGetField (simSnap، 0، fieldNames [9])؛
memcpy (dmin، mxGetPr (mdmin)، MLOOPS * sizeof (real_T))؛
}
{
const mxArray * mdp_2 = mxGetField (simSnap، 0، fieldNames [10])؛
memcpy (dp_2، mxGetPr (mdp_2)، sizeof (real_T))؛
}
{
const mxArray * mP = mxGetField (simSnap، 0، fieldNames [11])؛
memcpy (P، mxGetPr (mP)، sizeof (real_T))؛
}
{
const mxArray * mB = mxGetField (simSnap، 0، fieldNames [12])؛
memcpy (B، mxGetPr (mB)، sizeof (real_T))؛
}
{
const mxArray * mFa_dp2 = mxGetField (simSnap، 0، fieldNames [13])؛
memcpy (Fa_dp2، mxGetPr (mFa_dp2)، sizeof (real_T))؛
}
{
const mxArray * mFb_dp2 = mxGetField (simSnap، 0، fieldNames [14])؛
memcpy (Fb_dp2، mxGetPr (mFb_dp2)، sizeof (real_T))؛
}
}
#endif
/ * تابع: mdlTerminate ============================================= ========
* چکیده:
* بدون خاتمه مورد نیاز است، اما ما ملزم به داشتن این روال است.
* /
استاتیک void mdlTerminate (SimStruct * S)
{
کاراکتر * id؛
char * tq؛
من int ؛
برای (i = 0؛ i <1؛ i ++)
{
/* مشخص کننده؛ هر تنظیم قدیمی و به روز رسانی * /
id = ssGetDWorkRTWIdentifier (S، I)؛
اگر (id = NULL) {
رایگان (id)؛
}
ssSetDWorkRTWIdentifier (S، I، NULL)؛
/ * نوع امتیاز هر تنظیم قدیمی و به روز رسانی * /
tq = ssGetDWorkRTWTypeQualifier (S، I)؛
اگر (tq = NULL) {
رایگان (tq)؛
}
ssSetDWorkRTWTypeQualifier (S، I، NULL)؛
}
}
#ifdef MATLAB_MEX_FILE / * آیا این فایل به عنوان یک فایل MEX کامپایل شده است؟ * /
#include “simulink.c” / * مکانیسم رابط فایل MEX * /
#else
#include “cg_sfun.h” / * تابع ثبت نام نسل کد * /
#endif
