static void mdlInitializeSampleTimes(SimStruct *S)
{
real_T Tsim = mxGetScalar(ssGetSFcnParam(S, 0));
ssSetSampleTime(S, 0, Tsim); //DISCRETE_SAMPLE_TIME);
ssSetOffsetTime(S, 0, 0.0);
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* S-function is comprised of only continuous sample time elements
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
/* fixed sample time passed from options */
ssSetSampleTime(S, 0, TS(S));
ssSetOffsetTime(S, 0, 0.0);
ssSetModelReferenceSampleTimeDefaultInheritance(S);
}
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, *mxGetPr(paramSampleTime));
ssSetOffsetTime(S, 0, 0.0);
ssSetCallSystemOutput(S,0); /* call on first element */
ssSetModelReferenceSampleTimeDefaultInheritance(S);
}
static void mdlInitializeSampleTimes(SimStruct *S)
{
debugPrintf("'%s': mdlInitializeSampleTimes\n", S->path);
ssSetSampleTime(S, 0, CONTINUOUS_SAMPLE_TIME);
ssSetOffsetTime(S, 0, FIXED_IN_MINOR_STEP_OFFSET);
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* S-function is comprised of only continuous sample time elements
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, CONTINUOUS_SAMPLE_TIME);
ssSetOffsetTime(S, 0, 0.0);
ssSetModelReferenceSampleTimeDefaultInheritance(S);
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* This function is used to specify the sample time(s) for your
* S-function. You must register the same number of sample times as
* specified in ssSetNumSampleTimes.
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
int idx;
// Just set this to avoid Simulink whinging
ssSetSampleTime(S, 0, mxGetInf());
ssSetOffsetTime(S, 0, 0.0);
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
/* Register one pair for each sample time */
ssSetSampleTime(S, 0, INHERITED_SAMPLE_TIME);
ssSetOffsetTime(S, 0, 0.0);
ssSetModelReferenceSampleTimeDefaultInheritance(S);
} /* end mdlInitializeSampleTimes */
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* This function is used to specify the sample time(s) for your
* S-function. You must register the same number of sample times as
* specified in ssSetNumSampleTimes.
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
/*
Set the sample time to continuous
*/
ssSetSampleTime(S, 0, CONTINUOUS_SAMPLE_TIME);
ssSetOffsetTime(S, 0, 0.0);
}
// Function: mdlInitializeSampleTimes =========================================
// Abstract:
// This function is used to specify the sample time(s) for your
// S-function. You must register the same number of sample times as
// specified in ssSetNumSampleTimes.
static void mdlInitializeSampleTimes(SimStruct *S)
{
// The sampling time of this SFunction must be inherited so that the Soft Real Time sblock can be used.
ssSetSampleTime(S, 0, INHERITED_SAMPLE_TIME);
// ssSetSampleTime(S, 0, 10.0);
ssSetOffsetTime(S, 0, 0.0);
ssSetModelReferenceSampleTimeDefaultInheritance(S);
}
/* Function to initialize sample times. */
static void mdlInitializeSampleTimes(SimStruct *S)
{
/* task periods */
ssSetSampleTime(S, 0, 0.06);
/* task offsets */
ssSetOffsetTime(S, 0, 0.0);
}
static void mdlInitializeSampleTimes(SimStruct *S){
double n;
ssSetSampleTime(S, 0, mxGetPr(SAMPLE_TIME_ARG)[SAMP_TIME_IND]);
ssSetOffsetTime(S, 0, 0.0);
n = mxGetPr(SAMPLE_TIME_ARG)[SAMP_TIME_IND];
#ifdef __linux
thread_usleep = (int)((n*1E6)/2.0);
#endif
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* Specify the sample time
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
const double Ts = mxGetScalar(TS(S));
ssSetSampleTime(S, 0, Ts);
ssSetOffsetTime(S, 0, 0.0);
/* todo: Is this required?
ssSetModelReferenceSampleTimeDefaultInheritance(S);
*/
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* This function is used to specify the sample time(s) for your
* S-function. You must register the same number of sample times as
* specified in ssSetNumSampleTimes.
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
int idx;
// Just set this to avoid Simulink whinging
ssSetSampleTime(S, 0, INHERITED_SAMPLE_TIME);
ssSetOffsetTime(S, 0, 0.0);
/* Outport 0 is a function call trigger */
ssSetCallSystemOutput(S,0);
}
/* Function: mdlInitializeSampleTimes =====================================
* Abstract:
* This function is used to specify the sample time(s) for your
* S-function. You must register the same number of sample times as
* specified in ssSetNumSampleTimes.
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, (real_T)1);
ssSetOffsetTime(S, 0, (real_T)0);
#if defined(ssSetModelReferenceSampleTimeDisallowInheritance)
ssSetModelReferenceSampleTimeDisallowInheritance(S);
#endif
}
/* Function: mdlInitializeSampleTimes =====================================
* Abstract:
* This function is used to specify the sample time(s) for your
* S-function. You must register the same number of sample times as
* specified in ssSetNumSampleTimes.
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, INHERITED_SAMPLE_TIME);
ssSetOffsetTime(S, 0, FIXED_IN_MINOR_STEP_OFFSET);
#if defined(ssSetModelReferenceSampleTimeDefaultInheritance)
ssSetModelReferenceSampleTimeDefaultInheritance(S);
#endif
}
static void mdlInitializeSampleTimes(SimStruct *S)
{
real_T sampling;
#ifdef DEBUG
debug("mdlInitializeSampleTimes entered.\n");
#endif
sampling = SAMPLING_PARAM_DATA(S)/60;
ssSetSampleTime(S, 0, sampling);
ssSetOffsetTime(S, 0, 0.0);
#ifdef DEBUG
debug("mdlInitializeSampleTimes left.\n");
#endif
} /* mdlInitializeSampleTimes */
/* Function to initialize sample times */
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, SAMPLE_TIME);
ssSetOffsetTime(S, 0, 0);
#ifndef MATLAB_MEX_FILE
#ifdef __WATCOMC__
LoadDLLStatus = LoadFTD2XXLibrary( );
if(LoadDLLStatus != 0 ) return;
#endif /* __WATCOMC__ */
NoOfDetectedUSBDevices = USBOpen( );
CommandRead_TCrane( &RTDACUSBBuffer );
#endif
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* Specifiy that we have a continuous sample time.
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
real_T time;
// get sample time from parameters
time = SAMPLE_TIME(S);
if (time == -1)
{
ssSetSampleTime(S, 0, INHERITED_SAMPLE_TIME);
ssSetModelReferenceSampleTimeDefaultInheritance(S);
}
else
ssSetSampleTime(S, 0, time);
ssSetOffsetTime(S, 0, 0.0);
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* This function is used to specify the sample time(s) for your
* S-function. You must register the same number of sample times as
* specified in ssSetNumSampleTimes.
*/
static void mdlInitializeSampleTimes(SimStruct *S) {
mxArray *array_ptr;
double sampleTime;
// printf("URG: 2222\n");
// Leemos el sample time definido por el usuario
array_ptr = mexGetVariable("caller", "SampleTime");
if (array_ptr == NULL ){
printf("URG: No se encontro la variable SampleTime. Se usará 0.5\n");
sampleTime = 0.5;
}
else
{
sampleTime=*((double*)(mxGetData(array_ptr)));
printf("URG: Usando variable SampleTime con valor = %f\n", sampleTime);
}
//sampleTime = *sampleTimeTmp;
/* Destroy array */
mxDestroyArray(array_ptr);
ssSetSampleTime(S, 0, sampleTime);
ssSetOffsetTime(S, 0, 0.0);
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* Specifiy that we inherit our sample time from the driving block.
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
InputRealPtrsType uPtrs = ssGetInputPortRealSignalPtrs(S,0);
mxArray *array_ptr;
double stTmp;
// Leemos el sample time definido por el usuario
array_ptr = mexGetVariable("caller", "SampleTime");
if (array_ptr == NULL ){
mexPrintf("No se encontro la variable SampleTime. Se usará 0.001\n");
stTmp = 0.001;
}
else
{
stTmp=*((double*)(mxGetData(array_ptr)));
mexPrintf("Usando variable SampleTime con valor = %f\n", sampleTime);
}
sampleTime = stTmp;
/* Destroy array */
mxDestroyArray(array_ptr);
ssSetSampleTime(S, 0, sampleTime);
ssSetOffsetTime(S, 0, 0.0);
}
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, CONTINUOUS_SAMPLE_TIME);
ssSetOffsetTime(S, 0, 0.0);
}
/* Model initialize function */
void xpcosc_initialize(boolean_T firstTime)
{
(void)firstTime;
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)xpcosc_rtM, 0,
sizeof(rtModel_xpcosc));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&xpcosc_rtM->solverInfo,
&xpcosc_rtM->Timing.simTimeStep);
rtsiSetTPtr(&xpcosc_rtM->solverInfo, &rtmGetTPtr(xpcosc_rtM));
rtsiSetStepSizePtr(&xpcosc_rtM->solverInfo, &xpcosc_rtM->Timing.stepSize0);
rtsiSetdXPtr(&xpcosc_rtM->solverInfo, &xpcosc_rtM->ModelData.derivs);
rtsiSetContStatesPtr(&xpcosc_rtM->solverInfo,
&xpcosc_rtM->ModelData.contStates);
rtsiSetNumContStatesPtr(&xpcosc_rtM->solverInfo,
&xpcosc_rtM->Sizes.numContStates);
rtsiSetErrorStatusPtr(&xpcosc_rtM->solverInfo, (&rtmGetErrorStatus
(xpcosc_rtM)));
rtsiSetRTModelPtr(&xpcosc_rtM->solverInfo, xpcosc_rtM);
}
rtsiSetSimTimeStep(&xpcosc_rtM->solverInfo, MAJOR_TIME_STEP);
xpcosc_rtM->ModelData.intgData.y = xpcosc_rtM->ModelData.odeY;
xpcosc_rtM->ModelData.intgData.f[0] = xpcosc_rtM->ModelData.odeF[0];
xpcosc_rtM->ModelData.intgData.f[1] = xpcosc_rtM->ModelData.odeF[1];
xpcosc_rtM->ModelData.intgData.f[2] = xpcosc_rtM->ModelData.odeF[2];
xpcosc_rtM->ModelData.intgData.f[3] = xpcosc_rtM->ModelData.odeF[3];
xpcosc_rtM->ModelData.contStates = ((real_T *) &xpcosc_X);
rtsiSetSolverData(&xpcosc_rtM->solverInfo, (void *)
&xpcosc_rtM->ModelData.intgData);
rtsiSetSolverName(&xpcosc_rtM->solverInfo,"ode4");
xpcosc_rtM->solverInfoPtr = (&xpcosc_rtM->solverInfo);
/* Initialize timing info */
{
int_T *mdlTsMap = xpcosc_rtM->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
xpcosc_rtM->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
xpcosc_rtM->Timing.sampleTimes = (&xpcosc_rtM->Timing.sampleTimesArray[0]);
xpcosc_rtM->Timing.offsetTimes = (&xpcosc_rtM->Timing.offsetTimesArray[0]);
/* task periods */
xpcosc_rtM->Timing.sampleTimes[0] = (0.0);
xpcosc_rtM->Timing.sampleTimes[1] = (0.001);
/* task offsets */
xpcosc_rtM->Timing.offsetTimes[0] = (0.0);
xpcosc_rtM->Timing.offsetTimes[1] = (0.0);
}
rtmSetTPtr(xpcosc_rtM, &xpcosc_rtM->Timing.tArray[0]);
{
int_T *mdlSampleHits = xpcosc_rtM->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
xpcosc_rtM->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(xpcosc_rtM, 0.2);
xpcosc_rtM->Timing.stepSize0 = 0.001;
xpcosc_rtM->Timing.stepSize1 = 0.001;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
xpcosc_rtM->rtwLogInfo = &rt_DataLoggingInfo;
}
/* Setup for data logging */
{
/*
* Set pointers to the data and signal info each state
*/
{
static int_T rt_LoggedStateWidths[] = {
1,
1
};
static int_T rt_LoggedStateNumDimensions[] = {
1,
1
};
static int_T rt_LoggedStateDimensions[] = {
1,
1
};
static boolean_T rt_LoggedStateIsVarDims[] = {
0,
0
};
static BuiltInDTypeId rt_LoggedStateDataTypeIds[] = {
SS_DOUBLE,
SS_DOUBLE
};
static int_T rt_LoggedStateComplexSignals[] = {
0,
0
};
static const char_T *rt_LoggedStateLabels[] = {
"CSTATE",
"CSTATE"
};
static const char_T *rt_LoggedStateBlockNames[] = {
"xpcosc/Integrator1",
"xpcosc/Integrator"
};
static const char_T *rt_LoggedStateNames[] = {
"",
""
};
static boolean_T rt_LoggedStateCrossMdlRef[] = {
0,
0
};
static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 },
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 }
};
static RTWLogSignalInfo rt_LoggedStateSignalInfo = {
2,
rt_LoggedStateWidths,
rt_LoggedStateNumDimensions,
rt_LoggedStateDimensions,
rt_LoggedStateIsVarDims,
(NULL),
rt_LoggedStateDataTypeIds,
rt_LoggedStateComplexSignals,
(NULL),
{ rt_LoggedStateLabels },
(NULL),
(NULL),
(NULL),
{ rt_LoggedStateBlockNames },
{ rt_LoggedStateNames },
rt_LoggedStateCrossMdlRef,
rt_RTWLogDataTypeConvert
};
static void * rt_LoggedStateSignalPtrs[2];
rtliSetLogXSignalPtrs(xpcosc_rtM->rtwLogInfo, (LogSignalPtrsType)
rt_LoggedStateSignalPtrs);
rtliSetLogXSignalInfo(xpcosc_rtM->rtwLogInfo, &rt_LoggedStateSignalInfo);
rt_LoggedStateSignalPtrs[0] = (void*)&xpcosc_X.Integrator1_CSTATE;
rt_LoggedStateSignalPtrs[1] = (void*)&xpcosc_X.Integrator_CSTATE;
}
rtliSetLogT(xpcosc_rtM->rtwLogInfo, "tout");
rtliSetLogX(xpcosc_rtM->rtwLogInfo, "xout");
rtliSetLogXFinal(xpcosc_rtM->rtwLogInfo, "");
rtliSetSigLog(xpcosc_rtM->rtwLogInfo, "");
rtliSetLogVarNameModifier(xpcosc_rtM->rtwLogInfo, "rt_");
rtliSetLogFormat(xpcosc_rtM->rtwLogInfo, 0);
rtliSetLogMaxRows(xpcosc_rtM->rtwLogInfo, 0);
rtliSetLogDecimation(xpcosc_rtM->rtwLogInfo, 1);
/*
* Set pointers to the data and signal info for each output
*/
{
static void * rt_LoggedOutputSignalPtrs[] = {
&xpcosc_Y.Outport[0]
};
rtliSetLogYSignalPtrs(xpcosc_rtM->rtwLogInfo, ((LogSignalPtrsType)
rt_LoggedOutputSignalPtrs));
}
{
static int_T rt_LoggedOutputWidths[] = {
2
};
static int_T rt_LoggedOutputNumDimensions[] = {
1
};
static int_T rt_LoggedOutputDimensions[] = {
2
};
static boolean_T rt_LoggedOutputIsVarDims[] = {
0
};
static int_T* rt_LoggedCurrentSignalDimensions[] = {
(NULL)
};
static BuiltInDTypeId rt_LoggedOutputDataTypeIds[] = {
SS_DOUBLE
};
static int_T rt_LoggedOutputComplexSignals[] = {
0
};
static const char_T *rt_LoggedOutputLabels[] = {
"" };
static const char_T *rt_LoggedOutputBlockNames[] = {
"xpcosc/Outport" };
static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 }
};
static RTWLogSignalInfo rt_LoggedOutputSignalInfo[] = {
{
1,
rt_LoggedOutputWidths,
rt_LoggedOutputNumDimensions,
rt_LoggedOutputDimensions,
rt_LoggedOutputIsVarDims,
rt_LoggedCurrentSignalDimensions,
rt_LoggedOutputDataTypeIds,
rt_LoggedOutputComplexSignals,
(NULL),
{ rt_LoggedOutputLabels },
(NULL),
(NULL),
(NULL),
{ rt_LoggedOutputBlockNames },
{ (NULL) },
(NULL),
rt_RTWLogDataTypeConvert
}
};
rtliSetLogYSignalInfo(xpcosc_rtM->rtwLogInfo, rt_LoggedOutputSignalInfo);
/* set currSigDims field */
rt_LoggedCurrentSignalDimensions[0] = &rt_LoggedOutputWidths[0];
}
rtliSetLogY(xpcosc_rtM->rtwLogInfo, "yout");
}
/* external mode info */
xpcosc_rtM->Sizes.checksums[0] = (1235351435U);
xpcosc_rtM->Sizes.checksums[1] = (4143988505U);
xpcosc_rtM->Sizes.checksums[2] = (362576123U);
xpcosc_rtM->Sizes.checksums[3] = (1068881914U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[1];
xpcosc_rtM->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(xpcosc_rtM->extModeInfo,
&xpcosc_rtM->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(xpcosc_rtM->extModeInfo, xpcosc_rtM->Sizes.checksums);
rteiSetTPtr(xpcosc_rtM->extModeInfo, rtmGetTPtr(xpcosc_rtM));
}
xpcosc_rtM->solverInfoPtr = (&xpcosc_rtM->solverInfo);
xpcosc_rtM->Timing.stepSize = (0.001);
rtsiSetFixedStepSize(&xpcosc_rtM->solverInfo, 0.001);
rtsiSetSolverMode(&xpcosc_rtM->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
xpcosc_rtM->ModelData.blockIO = ((void *) &xpcosc_B);
{
xpcosc_B.Integrator1 = 0.0;
xpcosc_B.PCI6221AD = 0.0;
xpcosc_B.RateTransition1 = 0.0;
xpcosc_B.SignalGenerator = 0.0;
xpcosc_B.RateTransition = 0.0;
xpcosc_B.Gain = 0.0;
xpcosc_B.Integrator = 0.0;
xpcosc_B.Gain1 = 0.0;
xpcosc_B.Gain2 = 0.0;
xpcosc_B.Sum = 0.0;
}
/* parameters */
xpcosc_rtM->ModelData.defaultParam = ((real_T *)&xpcosc_P);
/* states (continuous) */
{
real_T *x = (real_T *) &xpcosc_X;
xpcosc_rtM->ModelData.contStates = (x);
(void) memset((void *)&xpcosc_X, 0,
sizeof(ContinuousStates_xpcosc));
}
/* states (dwork) */
xpcosc_rtM->Work.dwork = ((void *) &xpcosc_DWork);
(void) memset((void *)&xpcosc_DWork, 0,
sizeof(D_Work_xpcosc));
xpcosc_DWork.PCI6713DA_RWORK = 0.0;
/* external outputs */
xpcosc_rtM->ModelData.outputs = (&xpcosc_Y);
xpcosc_Y.Outport[0] = 0.0;
xpcosc_Y.Outport[1] = 0.0;
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
xpcosc_rtM->SpecialInfo.mappingInfo = (&dtInfo);
xpcosc_rtM->SpecialInfo.xpcData = ((void*) &dtInfo);
dtInfo.numDataTypes = 14;
dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
dtInfo.dataTypeNames = &rtDataTypeNames[0];
/* Block I/O transition table */
dtInfo.B = &rtBTransTable;
/* Parameters transition table */
dtInfo.P = &rtPTransTable;
}
/* Initialize DataMapInfo substructure containing ModelMap for C API */
xpcosc_InitializeDataMapInfo(xpcosc_rtM);
/* child S-Function registration */
{
RTWSfcnInfo *sfcnInfo = &xpcosc_rtM->NonInlinedSFcns.sfcnInfo;
xpcosc_rtM->sfcnInfo = (sfcnInfo);
rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(xpcosc_rtM)));
rtssSetNumRootSampTimesPtr(sfcnInfo, &xpcosc_rtM->Sizes.numSampTimes);
xpcosc_rtM->NonInlinedSFcns.taskTimePtrs[0] = &(rtmGetTPtr(xpcosc_rtM)[0]);
xpcosc_rtM->NonInlinedSFcns.taskTimePtrs[1] = &(rtmGetTPtr(xpcosc_rtM)[1]);
rtssSetTPtrPtr(sfcnInfo,xpcosc_rtM->NonInlinedSFcns.taskTimePtrs);
rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(xpcosc_rtM));
rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(xpcosc_rtM));
rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(xpcosc_rtM));
rtssSetStepSizePtr(sfcnInfo, &xpcosc_rtM->Timing.stepSize);
rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(xpcosc_rtM));
rtssSetDerivCacheNeedsResetPtr(sfcnInfo,
&xpcosc_rtM->ModelData.derivCacheNeedsReset);
rtssSetZCCacheNeedsResetPtr(sfcnInfo,
&xpcosc_rtM->ModelData.zCCacheNeedsReset);
rtssSetBlkStateChangePtr(sfcnInfo, &xpcosc_rtM->ModelData.blkStateChange);
rtssSetSampleHitsPtr(sfcnInfo, &xpcosc_rtM->Timing.sampleHits);
rtssSetPerTaskSampleHitsPtr(sfcnInfo, &xpcosc_rtM->Timing.perTaskSampleHits);
rtssSetSimModePtr(sfcnInfo, &xpcosc_rtM->simMode);
rtssSetSolverInfoPtr(sfcnInfo, &xpcosc_rtM->solverInfoPtr);
}
xpcosc_rtM->Sizes.numSFcns = (2);
/* register each child */
{
(void) memset((void *)&xpcosc_rtM->NonInlinedSFcns.childSFunctions[0], 0,
2*sizeof(SimStruct));
xpcosc_rtM->childSfunctions =
(&xpcosc_rtM->NonInlinedSFcns.childSFunctionPtrs[0]);
xpcosc_rtM->childSfunctions[0] =
(&xpcosc_rtM->NonInlinedSFcns.childSFunctions[0]);
xpcosc_rtM->childSfunctions[1] =
(&xpcosc_rtM->NonInlinedSFcns.childSFunctions[1]);
/* Level2 S-Function Block: xpcosc/<Root>/PCI-6221 AD (adnipcim) */
{
SimStruct *rts = xpcosc_rtM->childSfunctions[0];
/* timing info */
time_T *sfcnPeriod = xpcosc_rtM->NonInlinedSFcns.Sfcn0.sfcnPeriod;
time_T *sfcnOffset = xpcosc_rtM->NonInlinedSFcns.Sfcn0.sfcnOffset;
int_T *sfcnTsMap = xpcosc_rtM->NonInlinedSFcns.Sfcn0.sfcnTsMap;
(void) memset((void*)sfcnPeriod, 0,
sizeof(time_T)*1);
(void) memset((void*)sfcnOffset, 0,
sizeof(time_T)*1);
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
/* Set up the mdlInfo pointer */
{
ssSetBlkInfo2Ptr(rts, &xpcosc_rtM->NonInlinedSFcns.blkInfo2[0]);
}
ssSetRTWSfcnInfo(rts, xpcosc_rtM->sfcnInfo);
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &xpcosc_rtM->NonInlinedSFcns.methods2[0]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &xpcosc_rtM->NonInlinedSFcns.methods3[0]);
}
/* Allocate memory for states auxilliary information */
{
ssSetStatesInfo2(rts, &xpcosc_rtM->NonInlinedSFcns.statesInfo2[0]);
}
/* outputs */
{
ssSetPortInfoForOutputs(rts,
&xpcosc_rtM->NonInlinedSFcns.Sfcn0.outputPortInfo[0]);
_ssSetNumOutputPorts(rts, 1);
/* port 0 */
{
_ssSetOutputPortNumDimensions(rts, 0, 1);
ssSetOutputPortWidth(rts, 0, 1);
ssSetOutputPortSignal(rts, 0, ((real_T *) &xpcosc_B.PCI6221AD));
}
}
/* path info */
ssSetModelName(rts, "PCI-6221 AD");
ssSetPath(rts, "xpcosc/PCI-6221 AD");
ssSetRTModel(rts,xpcosc_rtM);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* parameters */
{
mxArray **sfcnParams = (mxArray **)
&xpcosc_rtM->NonInlinedSFcns.Sfcn0.params;
ssSetSFcnParamsCount(rts, 7);
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
ssSetSFcnParam(rts, 0, (mxArray*)xpcosc_P.PCI6221AD_P1_Size);
ssSetSFcnParam(rts, 1, (mxArray*)xpcosc_P.PCI6221AD_P2_Size);
ssSetSFcnParam(rts, 2, (mxArray*)xpcosc_P.PCI6221AD_P3_Size);
ssSetSFcnParam(rts, 3, (mxArray*)xpcosc_P.PCI6221AD_P4_Size);
ssSetSFcnParam(rts, 4, (mxArray*)xpcosc_P.PCI6221AD_P5_Size);
ssSetSFcnParam(rts, 5, (mxArray*)xpcosc_P.PCI6221AD_P6_Size);
ssSetSFcnParam(rts, 6, (mxArray*)xpcosc_P.PCI6221AD_P7_Size);
}
/* work vectors */
ssSetIWork(rts, (int_T *) &xpcosc_DWork.PCI6221AD_IWORK[0]);
ssSetPWork(rts, (void **) &xpcosc_DWork.PCI6221AD_PWORK);
{
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
&xpcosc_rtM->NonInlinedSFcns.Sfcn0.dWork;
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
&xpcosc_rtM->NonInlinedSFcns.Sfcn0.dWorkAux;
ssSetSFcnDWork(rts, dWorkRecord);
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
_ssSetNumDWork(rts, 2);
/* IWORK */
ssSetDWorkWidth(rts, 0, 41);
ssSetDWorkDataType(rts, 0,SS_INTEGER);
ssSetDWorkComplexSignal(rts, 0, 0);
ssSetDWork(rts, 0, &xpcosc_DWork.PCI6221AD_IWORK[0]);
/* PWORK */
ssSetDWorkWidth(rts, 1, 1);
ssSetDWorkDataType(rts, 1,SS_POINTER);
ssSetDWorkComplexSignal(rts, 1, 0);
ssSetDWork(rts, 1, &xpcosc_DWork.PCI6221AD_PWORK);
}
/* registration */
adnipcim(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.001);
ssSetOffsetTime(rts, 0, 0.0);
sfcnTsMap[0] = 1;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetOutputPortConnected(rts, 0, 1);
_ssSetOutputPortBeingMerged(rts, 0, 0);
/* Update the BufferDstPort flags for each input port */
}
/* Level2 S-Function Block: xpcosc/<Root>/PCI-6713 DA (danipci671x) */
{
SimStruct *rts = xpcosc_rtM->childSfunctions[1];
/* timing info */
time_T *sfcnPeriod = xpcosc_rtM->NonInlinedSFcns.Sfcn1.sfcnPeriod;
time_T *sfcnOffset = xpcosc_rtM->NonInlinedSFcns.Sfcn1.sfcnOffset;
int_T *sfcnTsMap = xpcosc_rtM->NonInlinedSFcns.Sfcn1.sfcnTsMap;
(void) memset((void*)sfcnPeriod, 0,
sizeof(time_T)*1);
(void) memset((void*)sfcnOffset, 0,
sizeof(time_T)*1);
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
/* Set up the mdlInfo pointer */
{
ssSetBlkInfo2Ptr(rts, &xpcosc_rtM->NonInlinedSFcns.blkInfo2[1]);
}
ssSetRTWSfcnInfo(rts, xpcosc_rtM->sfcnInfo);
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &xpcosc_rtM->NonInlinedSFcns.methods2[1]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &xpcosc_rtM->NonInlinedSFcns.methods3[1]);
}
/* Allocate memory for states auxilliary information */
{
ssSetStatesInfo2(rts, &xpcosc_rtM->NonInlinedSFcns.statesInfo2[1]);
}
/* inputs */
{
_ssSetNumInputPorts(rts, 1);
ssSetPortInfoForInputs(rts,
&xpcosc_rtM->NonInlinedSFcns.Sfcn1.inputPortInfo[0]);
/* port 0 */
{
real_T const **sfcnUPtrs = (real_T const **)
&xpcosc_rtM->NonInlinedSFcns.Sfcn1.UPtrs0;
sfcnUPtrs[0] = &xpcosc_B.RateTransition;
ssSetInputPortSignalPtrs(rts, 0, (InputPtrsType)&sfcnUPtrs[0]);
_ssSetInputPortNumDimensions(rts, 0, 1);
ssSetInputPortWidth(rts, 0, 1);
}
}
/* path info */
ssSetModelName(rts, "PCI-6713 DA");
ssSetPath(rts, "xpcosc/PCI-6713 DA");
ssSetRTModel(rts,xpcosc_rtM);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* parameters */
{
mxArray **sfcnParams = (mxArray **)
&xpcosc_rtM->NonInlinedSFcns.Sfcn1.params;
ssSetSFcnParamsCount(rts, 6);
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
ssSetSFcnParam(rts, 0, (mxArray*)xpcosc_P.PCI6713DA_P1_Size);
ssSetSFcnParam(rts, 1, (mxArray*)xpcosc_P.PCI6713DA_P2_Size);
ssSetSFcnParam(rts, 2, (mxArray*)xpcosc_P.PCI6713DA_P3_Size);
ssSetSFcnParam(rts, 3, (mxArray*)xpcosc_P.PCI6713DA_P4_Size);
ssSetSFcnParam(rts, 4, (mxArray*)xpcosc_P.PCI6713DA_P5_Size);
ssSetSFcnParam(rts, 5, (mxArray*)xpcosc_P.PCI6713DA_P6_Size);
}
/* work vectors */
ssSetRWork(rts, (real_T *) &xpcosc_DWork.PCI6713DA_RWORK);
ssSetIWork(rts, (int_T *) &xpcosc_DWork.PCI6713DA_IWORK[0]);
{
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
&xpcosc_rtM->NonInlinedSFcns.Sfcn1.dWork;
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
&xpcosc_rtM->NonInlinedSFcns.Sfcn1.dWorkAux;
ssSetSFcnDWork(rts, dWorkRecord);
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
_ssSetNumDWork(rts, 2);
/* RWORK */
ssSetDWorkWidth(rts, 0, 1);
ssSetDWorkDataType(rts, 0,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 0, 0);
ssSetDWork(rts, 0, &xpcosc_DWork.PCI6713DA_RWORK);
/* IWORK */
ssSetDWorkWidth(rts, 1, 2);
ssSetDWorkDataType(rts, 1,SS_INTEGER);
ssSetDWorkComplexSignal(rts, 1, 0);
ssSetDWork(rts, 1, &xpcosc_DWork.PCI6713DA_IWORK[0]);
}
/* registration */
danipci671x(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.001);
ssSetOffsetTime(rts, 0, 0.0);
sfcnTsMap[0] = 1;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetInputPortConnected(rts, 0, 1);
/* Update the BufferDstPort flags for each input port */
ssSetInputPortBufferDstPort(rts, 0, -1);
}
}
}
static void mdlInitializeSampleTimes(SimStruct *S) {
real_T sampleTime = PARAM(3)[0];
ssSetSampleTime(S,0,sampleTime);
ssSetOffsetTime(S,0,0.0);
}
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, INHERITED_SAMPLE_TIME);
ssSetOffsetTime(S, 0, 0.0);
}
/* Registration function */
RT_MODEL_DI_model_T *DI_model(void)
{
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)DI_model_M, 0,
sizeof(RT_MODEL_DI_model_T));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&DI_model_M->solverInfo,
&DI_model_M->Timing.simTimeStep);
rtsiSetTPtr(&DI_model_M->solverInfo, &rtmGetTPtr(DI_model_M));
rtsiSetStepSizePtr(&DI_model_M->solverInfo, &DI_model_M->Timing.stepSize0);
rtsiSetErrorStatusPtr(&DI_model_M->solverInfo, (&rtmGetErrorStatus
(DI_model_M)));
rtsiSetRTModelPtr(&DI_model_M->solverInfo, DI_model_M);
}
rtsiSetSimTimeStep(&DI_model_M->solverInfo, MAJOR_TIME_STEP);
rtsiSetSolverName(&DI_model_M->solverInfo,"FixedStepDiscrete");
DI_model_M->solverInfoPtr = (&DI_model_M->solverInfo);
/* Initialize timing info */
{
int_T *mdlTsMap = DI_model_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
DI_model_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
DI_model_M->Timing.sampleTimes = (&DI_model_M->Timing.sampleTimesArray[0]);
DI_model_M->Timing.offsetTimes = (&DI_model_M->Timing.offsetTimesArray[0]);
/* task periods */
DI_model_M->Timing.sampleTimes[0] = (0.0);
DI_model_M->Timing.sampleTimes[1] = (0.01);
/* task offsets */
DI_model_M->Timing.offsetTimes[0] = (0.0);
DI_model_M->Timing.offsetTimes[1] = (0.0);
}
rtmSetTPtr(DI_model_M, &DI_model_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = DI_model_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
DI_model_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(DI_model_M, 30.0);
DI_model_M->Timing.stepSize0 = 0.01;
DI_model_M->Timing.stepSize1 = 0.01;
/* External mode info */
DI_model_M->Sizes.checksums[0] = (943881189U);
DI_model_M->Sizes.checksums[1] = (2376373844U);
DI_model_M->Sizes.checksums[2] = (1356612486U);
DI_model_M->Sizes.checksums[3] = (687118842U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[1];
DI_model_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(DI_model_M->extModeInfo,
&DI_model_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(DI_model_M->extModeInfo, DI_model_M->Sizes.checksums);
rteiSetTPtr(DI_model_M->extModeInfo, rtmGetTPtr(DI_model_M));
}
DI_model_M->solverInfoPtr = (&DI_model_M->solverInfo);
DI_model_M->Timing.stepSize = (0.01);
rtsiSetFixedStepSize(&DI_model_M->solverInfo, 0.01);
rtsiSetSolverMode(&DI_model_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
DI_model_M->SpecialInfo.mappingInfo = (&dtInfo);
dtInfo.numDataTypes = 14;
dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
dtInfo.dataTypeNames = &rtDataTypeNames[0];
}
/* child S-Function registration */
{
RTWSfcnInfo *sfcnInfo = &DI_model_M->NonInlinedSFcns.sfcnInfo;
DI_model_M->sfcnInfo = (sfcnInfo);
rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(DI_model_M)));
rtssSetNumRootSampTimesPtr(sfcnInfo, &DI_model_M->Sizes.numSampTimes);
DI_model_M->NonInlinedSFcns.taskTimePtrs[0] = &(rtmGetTPtr(DI_model_M)[0]);
DI_model_M->NonInlinedSFcns.taskTimePtrs[1] = &(rtmGetTPtr(DI_model_M)[1]);
rtssSetTPtrPtr(sfcnInfo,DI_model_M->NonInlinedSFcns.taskTimePtrs);
rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(DI_model_M));
rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(DI_model_M));
rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(DI_model_M));
rtssSetStepSizePtr(sfcnInfo, &DI_model_M->Timing.stepSize);
rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(DI_model_M));
rtssSetDerivCacheNeedsResetPtr(sfcnInfo,
&DI_model_M->ModelData.derivCacheNeedsReset);
rtssSetZCCacheNeedsResetPtr(sfcnInfo,
&DI_model_M->ModelData.zCCacheNeedsReset);
rtssSetBlkStateChangePtr(sfcnInfo, &DI_model_M->ModelData.blkStateChange);
rtssSetSampleHitsPtr(sfcnInfo, &DI_model_M->Timing.sampleHits);
rtssSetPerTaskSampleHitsPtr(sfcnInfo, &DI_model_M->Timing.perTaskSampleHits);
rtssSetSimModePtr(sfcnInfo, &DI_model_M->simMode);
rtssSetSolverInfoPtr(sfcnInfo, &DI_model_M->solverInfoPtr);
}
DI_model_M->Sizes.numSFcns = (1);
/* register each child */
{
(void) memset((void *)&DI_model_M->NonInlinedSFcns.childSFunctions[0], 0,
1*sizeof(SimStruct));
DI_model_M->childSfunctions =
(&DI_model_M->NonInlinedSFcns.childSFunctionPtrs[0]);
DI_model_M->childSfunctions[0] =
(&DI_model_M->NonInlinedSFcns.childSFunctions[0]);
/* Level2 S-Function Block: DI_model/<Root>/S-Function (DI_v1) */
{
SimStruct *rts = DI_model_M->childSfunctions[0];
/* timing info */
time_T *sfcnPeriod = DI_model_M->NonInlinedSFcns.Sfcn0.sfcnPeriod;
time_T *sfcnOffset = DI_model_M->NonInlinedSFcns.Sfcn0.sfcnOffset;
int_T *sfcnTsMap = DI_model_M->NonInlinedSFcns.Sfcn0.sfcnTsMap;
(void) memset((void*)sfcnPeriod, 0,
sizeof(time_T)*1);
(void) memset((void*)sfcnOffset, 0,
sizeof(time_T)*1);
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
/* Set up the mdlInfo pointer */
{
ssSetBlkInfo2Ptr(rts, &DI_model_M->NonInlinedSFcns.blkInfo2[0]);
}
ssSetRTWSfcnInfo(rts, DI_model_M->sfcnInfo);
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &DI_model_M->NonInlinedSFcns.methods2[0]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &DI_model_M->NonInlinedSFcns.methods3[0]);
}
/* Allocate memory for states auxilliary information */
{
ssSetStatesInfo2(rts, &DI_model_M->NonInlinedSFcns.statesInfo2[0]);
}
/* inputs */
{
_ssSetNumInputPorts(rts, 1);
ssSetPortInfoForInputs(rts,
&DI_model_M->NonInlinedSFcns.Sfcn0.inputPortInfo[0]);
/* port 0 */
{
ssSetInputPortRequiredContiguous(rts, 0, 1);
ssSetInputPortSignal(rts, 0, (real_T*)&DI_model_RGND);
_ssSetInputPortNumDimensions(rts, 0, 1);
ssSetInputPortWidth(rts, 0, 1);
}
}
/* path info */
ssSetModelName(rts, "S-Function");
ssSetPath(rts, "DI_model/S-Function");
ssSetRTModel(rts,DI_model_M);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* registration */
DI_v1(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.0);
ssSetOffsetTime(rts, 0, 0.0);
sfcnTsMap[0] = 0;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetInputPortConnected(rts, 0, 0);
/* Update the BufferDstPort flags for each input port */
ssSetInputPortBufferDstPort(rts, 0, -1);
}
}
/* Initialize Sizes */
DI_model_M->Sizes.numContStates = (0);/* Number of continuous states */
DI_model_M->Sizes.numY = (0); /* Number of model outputs */
DI_model_M->Sizes.numU = (0); /* Number of model inputs */
DI_model_M->Sizes.sysDirFeedThru = (0);/* The model is not direct feedthrough */
DI_model_M->Sizes.numSampTimes = (2);/* Number of sample times */
DI_model_M->Sizes.numBlocks = (1); /* Number of blocks */
return DI_model_M;
}
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, INHERITED_SAMPLE_TIME);
ssSetOffsetTime(S, 0, FIXED_IN_MINOR_STEP_OFFSET);
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* This function is used to specify the sample time(s) for your
* S-function. You must register the same number of sample times as
* specified in ssSetNumSampleTimes.
*/
static void mdlInitializeSampleTimes(SimStruct *S) {
ssSetSampleTime(S, 0, mxGetScalar(ssGetSFcnParam(S, 0)));
ssSetOffsetTime(S, 0, 0.0);
ssSetModelReferenceSampleTimeDefaultInheritance(S);
}
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, mxGetPr(SAMP_TIME_ARG)[SAMP_TIME_IND]);
ssSetOffsetTime(S, 0, 0.0);
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* This function is used to specify the sample time(s) for your
* S-function. You must register the same number of sample times as
* specified in ssSetNumSampleTimes.
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, B(S,"SampleTime"));
ssSetOffsetTime(S, 0, FIXED_IN_MINOR_STEP_OFFSET); //);
}
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, *mxGetPr(paramSampleTime));
ssSetOffsetTime(S, 0, 0.0);
ssSetModelReferenceSampleTimeDefaultInheritance(S);
}