static void mdlInitializeSizes( SimStruct *S ) /* ======================================================================== */ { int_T port; /* set number of expected parameters and check for a mismatch. */ ssSetNumSFcnParams( S, NUM_PARAMS ); #if defined(MATLAB_MEX_FILE) if ( ssGetNumSFcnParams( S ) == ssGetSFcnParamsCount( S ) ) { mdlCheckParameters( S ); if ( ssGetErrorStatus( S ) != NULL ) return; }else { return; } #endif /* sampling */ ssSetNumSampleTimes( S, PORT_BASED_SAMPLE_TIMES ); /* Set number of input ports and tunability */ ssSetSFcnParamTunable( S, DEVICE_INDEX, SS_PRM_NOT_TUNABLE ); /* set the resulting number of ports */ if ( !ssSetNumInputPorts( S, 1 ) ) return; port = 0; { const Frame_T inputsFrames = ( (double) mxGetScalar( ssGetSFcnParam( S, USE_FRAMES ) ) > 0.0) ? FRAME_YES : FRAME_NO; double sample_time = 1 / mxGetScalar( ssGetSFcnParam( S, SAMPLE_RATE ) ); const int_T buf_length = (int_T) (double) mxGetScalar( ssGetSFcnParam( S, FRAME_LENGTH ) ); const time_T period = (time_T) (sample_time * buf_length); ssSetInputPortMatrixDimensions( S, port, buf_length, 1 ); ssSetInputPortComplexSignal( S, port, COMPLEX_YES ); ssSetInputPortDataType( S, port, SS_DOUBLE ); ssSetInputPortFrameData( S, port, inputsFrames ); ssSetInputPortDirectFeedThrough( S, port, 1 ); ssSetInputPortSampleTime( S, port, period ); ssSetInputPortOffsetTime( S, port, 0.0 ); } /* Set number of output ports */ if ( !ssSetNumOutputPorts( S, 0 ) ) return; /* data port properties */ /* Prepare work Vectors */ ssSetNumPWork( S, P_WORK_LENGTH ); ssSetNumIWork( S, I_WORK_LENGTH ); ssSetNumRWork( S, R_WORK_LENGTH ); ssSetNumModes( S, 0 ); ssSetNumNonsampledZCs( S, 0 ); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance( S, USE_DEFAULT_SIM_STATE ); ssSetOptions( S, 0 ); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; /* Parameter mismatch will be reported by Simulink */ } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 2); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 2); ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 2); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE); }
static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; } ssSetNumContStates(S, 2); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 0)) return; if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 2); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 1); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
void mdlInitializeSizes(SimStruct *S) /* ======================================================================== */ { /* parameters */ ssSetNumSFcnParams(S, NUM_PARAMS); #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) return; } else return; #endif ssSetSFcnParamTunable(S, FREQUENCY, SS_PRM_SIM_ONLY_TUNABLE); ssSetSFcnParamTunable(S, BANDWIDTH, SS_PRM_NOT_TUNABLE); ssSetSFcnParamTunable(S, TXVGA_GAIN, SS_PRM_SIM_ONLY_TUNABLE); /* ports */ ssSetNumSampleTimes(S, 1); if (!ssSetNumOutputPorts(S, 0) || !ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, DYNAMICALLY_SIZED); ssSetInputPortComplexSignal(S, 0, COMPLEX_YES); ssSetInputPortDataType(S, 0, SS_INT8); ssSetInputPortDirectFeedThrough(S, 0, true); ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); /* work Vectors */ ssSetNumPWork(S, P_WORK_LENGTH); ssSetNumIWork(S, 0); ssSetNumRWork(S, NUM_PARAMS); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } if (!ssSetNumInputPorts(S, 0)) return; if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortDataType(S, 0, SS_DOUBLE); /* same as clock block */ ssSetOutputPortConstOutputExprInRTW(S, 0, 1); ssSetNumSampleTimes(S, 1); /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_USE_TLC_WITH_ACCELERATOR); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; /* Parameter mismatch will be reported by Simulink */ } if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, DYNAMICALLY_SIZED); ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S,1)) return; ssSetOutputPortWidth(S, 0, DYNAMICALLY_SIZED); ssSetNumSampleTimes(S, 1); /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR); /*main();*/ }
/* Function: mdlInitializeSizes */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 19); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; /* Parameter mismatch will be reported by Simulink */ } ssSetNumContStates(S, 4); /* Number of continuous states*/ if (!ssSetNumInputPorts(S, 3)) return; /*Number of INPUTS*/ ssSetInputPortWidth(S, 0, 1); /* In0.0: I */ ssSetInputPortWidth(S, 1, 1); /* In1.0: x */ ssSetInputPortWidth(S, 2, 1); /* In1.0: dx */ ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortDirectFeedThrough(S, 1, 1); ssSetInputPortDirectFeedThrough(S, 2, 1); if (!ssSetNumOutputPorts(S, 1)) return;/* Number of OUTPUTS */ ssSetOutputPortWidth(S, 0, 1); /* Out0.0: deltaF */ ssSetNumSampleTimes(S, 1); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { /* See sfuntmpl.doc for more details on the macros below */ ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } ssSetNumContStates(S, 1); /* how many continuous states? */ ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 1); /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. * See matlabroot/simulink/src/sfuntmpl_directfeed.txt. */ ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 1); ssSetNumSampleTimes(S, 1); /* * If your Fortran code uses REAL for the state, input, and/or output * datatypes, use these DWorks as work areas to downcast continuous * states from double to REAL before calling your code. You could * also put the work vectors in hard-coded local (stack) variables. * * For fixed step code, keep a copy of the variables to be output * in a DWork vector so the mdlOutputs() function can provide output * data when needed. You can use as many DWork vectors as you like * for both input and output (or hard-code local variables). */ if(!ssSetNumDWork( S, 3)) return; ssSetDWorkWidth( S, 0, ssGetOutputPortWidth(S,0)); ssSetDWorkDataType( S, 0, SS_SINGLE); /* use SS_DOUBLE if needed */ ssSetDWorkWidth( S, 1, ssGetInputPortWidth(S,0)); ssSetDWorkDataType( S, 1, SS_SINGLE); ssSetDWorkWidth( S, 2, ssGetNumContStates(S)); ssSetDWorkDataType( S, 2, SS_SINGLE); ssSetNumNonsampledZCs(S, 0); /* Specify the sim state compliance to be same as a built-in block */ /* see sfun_simstate.c for example of other possible settings */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
static void mdlInitializeSizes(SimStruct *S) { int i,nChannels; static char msg[256]; ssSetNumSFcnParams(S, NUMBER_OF_ARGS); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ sprintf(msg,"Wrong Number of input arguments passed.\n%d arguments are expected\n",NUMBER_OF_ARGS); ssSetErrorStatus(S,msg); return; } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetNumInputPorts(S, 0);//there is no input //if (!ssSetNumInputPorts(S, 1)) return; nChannels=(uint_T)mxGetN(CHANNEL_ARG); //if (!ssSetNumOutputPorts(S, 1)) return; ssSetNumOutputPorts(S,nChannels);//set number of outputs ports for(i=0;i<nChannels;i++) { ssSetOutputPortWidth(S, i, 1);//set width of each port to 1 } ssSetInputPortWidth(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/ /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. */ ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetNumSampleTimes(S, 1);//set number of sample time to 1,which means all input ports share same Ts ssSetNumRWork(S, NO_R_WORKS);//number of float in work vector ssSetNumIWork(S, NO_I_WORKS);//number of int in work vector ssSetNumPWork(S, 0);//number of pointer in work vector ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0);//no need for pass-zero check ssSetSFcnParamNotTunable(S,0); ssSetSFcnParamNotTunable(S,1); ssSetSFcnParamNotTunable(S,2); ssSetSFcnParamNotTunable(S,3); ssSetSFcnParamNotTunable(S,4); ssSetOptions(S,SS_OPTION_EXCEPTION_FREE_CODE|SS_OPTION_PLACE_ASAP); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { slDataTypeAccess *dta = ssGetDataTypeAccess(S); int udtId; ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } /* Obtain an integer datatype ID for the udt (user-defined type) "Data" */ udtId = ssRegisterDataType(S, "Data"); if ( udtId == INVALID_DTYPE_ID ) return; /* Register the size of the udt */ if (!ssSetDataTypeSize(S, udtId, sizeof(Data))) return; /* Register the zero of the udt */ if (!ssSetDataTypeZero(S, udtId, &zero)) return; /* Register the convert-between datatype function defined above */ if (!dtaSetConvertBetweenFcn(dta, ssGetPath(S), udtId, &DataCnvBtw)) return; /* Register the is-positive datatype function defined above*/ if (!dtaSetIsPositiveFcn(dta, ssGetPath(S), udtId, &DataIsPos)) return; /* Set input-port properties */ if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 1); ssSetInputPortDataType(S, 0, SS_DOUBLE); ssSetInputPortDirectFeedThrough(S, 0, 1); /* Set output port properties */ if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortDataType(S, 0, udtId); ssSetOutputPortWidth(S, 0, 1); /* Set miscellaneous properties */ ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME | SS_OPTION_SFUNCTION_INLINED_FOR_RTW); }
static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, NUM_PARAMS); if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) return; /* Inputs: */ if (!ssSetNumInputPorts(S, 2)) return; ssSetInputPortDataType(S, 0, DYNAMICALLY_TYPED); ssSetInputPortDataType(S, 1, DYNAMICALLY_TYPED); if(!ssSetInputPortDimensionInfo(S, 0, DYNAMIC_DIMENSION)) return; if(!ssSetInputPortDimensionInfo(S, 1, DYNAMIC_DIMENSION)) return; ssSetInputPortFrameData(S, 0, FRAME_INHERITED); ssSetInputPortFrameData(S, 1, FRAME_INHERITED); ssSetInputPortComplexSignal(S, 0, COMPLEX_INHERITED); ssSetInputPortComplexSignal(S, 1, COMPLEX_INHERITED); ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortDirectFeedThrough(S, 1, 1); ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); ssSetInputPortOverWritable(S, 0, 1); ssSetInputPortOverWritable(S, 1, 1); /* Outputs: */ if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortDataType(S, 0, DYNAMICALLY_TYPED); if(!ssSetOutputPortVectorDimension(S, 0, 1)) return; ssSetOutputPortFrameData(S, 0, FRAME_NO); ssSetOutputPortComplexSignal(S, 0, COMPLEX_INHERITED); ssSetOutputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetNumSampleTimes(S, 1); /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_CAN_BE_CALLED_CONDITIONALLY | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_NONVOLATILE); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/ ssSetInputPortDirectFeedThrough(S, 0, 0); if (!ssSetNumOutputPorts(S, 2)) return; ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortWidth(S, 1, 1); ssSetNumSampleTimes(S, 1); /* * Create a DWork data structure. */ { int dtId; /* * Use caution to avoid name conflicts when registering the * data type name. The suggested naming convention is to use * a common prefix based on your Blockset's name for each data type * registered by S-functions in your blocks set. If the S-function * is not part of a blockset, then use your company's name as a prefix. * The data type name is limited to 31 characters. */ dtId = ssRegisterDataType(S, "ExampleCounterStateStruct"); if (dtId == INVALID_DTYPE_ID ) return; /* Register the size of the udt */ if (!ssSetDataTypeSize(S, dtId, sizeof(CounterStateStruct))) return; ssSetNumDWork(S,1); ssSetDWorkDataType(S, 0, dtId); ssSetDWorkWidth(S, 0, 1); ssSetDWorkName(S, 0, "CSStruct"); /*optional name, less than 16 chars*/ } /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_RUNTIME_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { /* See sfuntmpl_doc.c for more details on the macros below */ ssSetNumSFcnParams(S, 5); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink. */ } #endif int_T nRobots = mxGetNumberOfElements(ssGetSFcnParam(S,2)); ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 0)) return; //ssSetInputPortWidth(S, 0, 1); //ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/ /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. * See matlabroot/simulink/src/sfuntmpl_directfeed.txt. */ //ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 4)) return; const int_T nDofs = *((mxChar*)mxGetData(ssGetSFcnParam(S, 4))); ssSetOutputPortMatrixDimensions(S, 0, nDofs, nRobots); // position ssSetOutputPortMatrixDimensions(S, 1, nDofs, nRobots); // velocity ssSetOutputPortMatrixDimensions(S, 2, nDofs, nRobots); // effort ssSetOutputPortMatrixDimensions(S, 3, 1, nRobots); // SentTime in s; ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 2); // nRobots, nDofs ssSetNumPWork(S, nRobots + 1); //nRobots x GenericSub, AsyncSpinner ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { /* See sfuntmpl_doc.c for more details on the macros below */ ssSetNumSFcnParams(S, 2); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink. */ } #endif ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 2)) return; ssSetInputPortMatrixDimensions(S, 0, DYNAMICALLY_SIZED, DYNAMICALLY_SIZED); // triangles ssSetInputPortDataType(S, 0, SS_UINT32); ssSetInputPortMatrixDimensions(S, 1, DYNAMICALLY_SIZED, DYNAMICALLY_SIZED); // vertices for (int_T i = 0; i < ssGetNumInputPorts(S); ++i) { /*direct input signal access*/ ssSetInputPortRequiredContiguous(S, i, true); /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. * See matlabroot/simulink/src/sfuntmpl_directfeed.txt. */ ssSetInputPortDirectFeedThrough(S, i, 1); } if (!ssSetNumOutputPorts(S, 0)) return; ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 2); //GenericPub and frame id ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
// Function: mdlInitializeSizes =============================================== // Abstract: // The sizes information is used by Simulink to determine the S-function // block's characteristics (number of inputs, s, states, etc.). static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, NPARAMS); #if defined(MATLAB_MEX_FILE) if(ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)){ mdlCheckParameters(S); if(ssGetErrorStatus(S)!=NULL){ return; } else{ cout<<"All parameters have been checked and passed correctly"<<endl; } } else{ return; // Parameter mismatch reported by Simulink } #endif // Parameter mismatch will be reported by Simulink if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; } // Specify I/O // INPUTS if(!ssSetNumInputPorts(S,0)) return; // OUTPUTS if (!ssSetNumOutputPorts(S,SIZE_READING_PORT)) return; for (int i = 0; i < SIZE_READING_PORT; i++) { ssSetOutputPortWidth (S, i, 1); ssSetOutputPortDataType(S, i, 0); } ssSetNumSampleTimes(S, 1); // Reserve place for C++ object ssSetNumPWork(S, 1); // DWork vectors ssSetNumDWork(S, 1); ssSetDWorkWidth(S, 0, 1); ssSetDWorkDataType(S, 0, SS_DOUBLE); ssSetSimStateCompliance(S, USE_CUSTOM_SIM_STATE); ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_ALLOW_INPUT_SCALAR_EXPANSION | SS_OPTION_USE_TLC_WITH_ACCELERATOR); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink */ } #endif { int iParam = 0; int nParam = ssGetNumSFcnParams(S); for ( iParam = 0; iParam < nParam; iParam++ ) { ssSetSFcnParamTunable( S, iParam, SS_PRM_SIM_ONLY_TUNABLE ); } } ssSetNumContStates(S, NSTATES); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, NINPUTS)) return; ssSetInputPortWidth(S, 0, 1); ssSetInputPortDirectFeedThrough(S, 0, TRUE); ssSetInputPortWidth(S, 1, 1); ssSetInputPortDirectFeedThrough(S, 1, TRUE); ssSetInputPortWidth(S, 2, 1); ssSetInputPortDirectFeedThrough(S, 2, TRUE); if (!ssSetNumOutputPorts(S, NOUTPUTS)) return; //ssSetOutputPortWidth(S, 0, NOUTPUTS); { ssSetOutputPortWidth(S, 0, 1); } ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { /* See sfuntmpl_doc.c for more details on the macros below */ ssSetNumSFcnParams(S, 1); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 3)) return; ssSetInputPortWidth(S, 0, 1); ssSetInputPortWidth(S, 1, 1); ssSetInputPortWidth(S, 2, 1); ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/ ssSetInputPortRequiredContiguous(S, 1, true); /*direct input signal access*/ ssSetInputPortRequiredContiguous(S, 2, true); /*direct input signal access*/ /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. * See matlabroot/simulink/src/sfuntmpl_directfeed.txt. */ ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortDirectFeedThrough(S, 1, 1); ssSetInputPortDirectFeedThrough(S, 2, 1); if (!ssSetNumOutputPorts(S, 5)) return; ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortWidth(S, 1, 1); ssSetOutputPortWidth(S, 2, 1); ssSetOutputPortWidth(S, 3, 1); ssSetOutputPortWidth(S, 4, 1); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { slDataTypeAccess *dta = ssGetDataTypeAccess(S); int udtId; ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } /* Obtain an integer datatype ID for the udt (user-defined type) "Data" */ udtId = ssRegisterDataType(S, "Data"); if ( udtId == INVALID_DTYPE_ID ) return; /* Register the size of the udt */ if (!ssSetDataTypeSize(S, udtId, sizeof(Data))) return; /* Register the zero of the udt */ if (!ssSetDataTypeZero(S, udtId, &zero)) return; /* Set input-port properties */ if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 1); ssSetInputPortDataType(S, 0, SS_DOUBLE); ssSetInputPortDirectFeedThrough(S, 0, 1); /* Set output port properties */ if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortDataType(S, 0, udtId); ssSetOutputPortWidth(S, 0, 1); /* Set miscellaneous properties */ ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { /* See sfuntmpl_doc.c for more details on the macros below */ ssSetNumSFcnParams(S, 5); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink. */ } #endif ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 0)) return; if (!ssSetNumOutputPorts(S, 0)) return; ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 1); // nWaitTopic size_t wait_buflen = mxGetN((ssGetSFcnParam(S, 2)))*sizeof(mxChar)+1; char* wait_name = (char*)mxMalloc(wait_buflen); mxGetString((ssGetSFcnParam(S, 2)), wait_name, wait_buflen); char * topic = strtok(wait_name, TOPIC_SEPARATORS); unsigned int nWaitTopic = 0; while (topic != NULL){ nWaitTopic++; topic = strtok(NULL, TOPIC_SEPARATORS); } mxFree(wait_name); ssSetNumPWork(S, 4+nWaitTopic+1); //Start + Stop + Synchronous + Trigger services + wait_topic Subscriber(s) + AsyncSpinner ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Call mdlCheckParameters to verify that the parameters are okay, * then setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 6)) return; ssSetInputPortWidth (S, 0, DYNAMICALLY_SIZED); ssSetInputPortComplexSignal(S, 0, COMPLEX_INHERITED); ssSetOutputPortWidth (S, 0, DYNAMICALLY_SIZED); ssSetOutputPortComplexSignal(S, 0, COMPLEX_INHERITED); ssSetOutputPortWidth (S, 1, DYNAMICALLY_SIZED); ssSetOutputPortComplexSignal(S, 1, COMPLEX_INHERITED); ssSetOutputPortWidth (S, 2, DYNAMICALLY_SIZED); ssSetOutputPortComplexSignal(S, 2, COMPLEX_INHERITED); ssSetOutputPortWidth (S, 3, DYNAMICALLY_SIZED); ssSetOutputPortComplexSignal(S, 3, COMPLEX_INHERITED); ssSetOutputPortWidth (S, 4, DYNAMICALLY_SIZED); ssSetOutputPortComplexSignal(S, 4, COMPLEX_INHERITED); ssSetOutputPortWidth (S, 5, DYNAMICALLY_SIZED); ssSetOutputPortComplexSignal(S, 5, COMPLEX_INHERITED); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_EXCEPTION_FREE_CODE); }
static void mdlStart_UXvEHHrxIcmXaLthmwvduD(SimStruct *S) { InstanceStruct_UXvEHHrxIcmXaLthmwvduD *moduleInstance = (InstanceStruct_UXvEHHrxIcmXaLthmwvduD *)calloc(1, sizeof (InstanceStruct_UXvEHHrxIcmXaLthmwvduD)); moduleInstance->S = S; cgxertSetRuntimeInstance(S, (void *)moduleInstance); ssSetSimStateCompliance(S, DISALLOW_SIM_STATE); ssSetmdlOutputs(S, mdlOutputs_UXvEHHrxIcmXaLthmwvduD); ssSetmdlInitializeConditions(S, mdlInitialize_UXvEHHrxIcmXaLthmwvduD); ssSetmdlUpdate(S, mdlUpdate_UXvEHHrxIcmXaLthmwvduD); ssSetmdlTerminate(S, mdlTerminate_UXvEHHrxIcmXaLthmwvduD); cgxe_mdl_start(moduleInstance); { uint_T options = ssGetOptions(S); options |= SS_OPTION_RUNTIME_EXCEPTION_FREE_CODE; ssSetOptions(S, options); } }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 3); /* Number of expected parameters */ // Parameter mismatch will be reported by Simulink if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink */ } ssSetSFcnParamTunable(S, 0, 0); ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 0)) return; // ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, DYNAMICALLY_SIZED); ssSetNumSampleTimes(S, 1); ssSetNumPWork(S, 2); // reserve element in the pointers vector ssSetNumModes(S, 0); // to store a C++ object ssSetNumNonsampledZCs(S, 0); ssSetSimStateCompliance(S, USE_CUSTOM_SIM_STATE); ssSetOptions(S, 0); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; /* Parameter mismatch will be reported by Simulink */ } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 1); ssSetInputPortDataType(S, 0, DYNAMICALLY_TYPED ); ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/ if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortDataType(S, 0, DYNAMICALLY_TYPED); ssSetOutputPortComplexSignal(S, 0, COMPLEX_NO); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME | SS_OPTION_NONVOLATILE | SS_OPTION_WORKS_WITH_CODE_REUSE)); ssSupportsMultipleExecInstances(S, true); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, NUM_PARAMS); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) return; } else{ return; /* Simulink will report a parameter mismatch error */ } #endif ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, mxGetScalar(NUMREG(S))); ssSetInputPortDirectFeedThrough(S, 0, 1); /* this is s static fcn: y = f(u) */ ssSetInputPortRequiredContiguous(S, 0, 1); /* there is only one scalar output */ if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 1); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE); /* Preemptively clear user data pointer so we don't try to free it */ ssSetUserData(S, NULL); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, NUMBER_OF_ARGS); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 0)) return; // ssSetInputPortWidth(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/ /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. */ ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 0)) return; // ssSetOutputPortWidth(S, 0, 1); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, NO_I_WORKS); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Call mdlCheckParameters to verify that the parameters are okay, * then setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { int_T intervalSize; ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink */ } #endif { int iParam = 0; int nParam = ssGetNumSFcnParams(S); for ( iParam = 0; iParam < nParam; iParam++ ) { ssSetSFcnParamTunable( S, iParam, SS_PRM_SIM_ONLY_TUNABLE ); } } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 1)) return; /* * If the quantization interval is a vector, set the width * of the input and the output to be the same size as it. * Otherwise, set the widths to be DYNAMICALLY_SIZED. */ intervalSize = (mxGetM(QUANTIZATION_PARAM(S)) * mxGetN(QUANTIZATION_PARAM(S))); if (intervalSize > 1) { ssSetInputPortWidth (S, 0, intervalSize); ssSetOutputPortWidth(S, 0, intervalSize); } else { ssSetInputPortWidth (S, 0, DYNAMICALLY_SIZED); ssSetOutputPortWidth(S, 0, DYNAMICALLY_SIZED); } ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE); }
// Function: mdlInitializeSizes =============================================== // Abstract: // The sizes information is used by Simulink to determine the S-function // block's characteristics (number of inputs, s, states, etc.). static void mdlInitializeSizes(SimStruct *S) { static char errorBuffer[512]; if (ssGetSFcnParamsCount(S) < 1) { sprintf(errorBuffer, "%s", "The block type parameter must be specified"); ssSetErrorStatus(S, errorBuffer); return; } char *classNameStr = mxArrayToString(ssGetSFcnParam(S, 0)); std::string className(classNameStr); mxFree(classNameStr); wbt::Block *block = wbt::Block::instantiateBlockWithClassName(className); //We cannot save data in PWork during the initializeSizes phase ssSetNumPWork(S, 1); if (!block) { sprintf(errorBuffer, "Could not create an object of type %s", className.c_str()); ssSetErrorStatus(S, errorBuffer); return; } ssSetNumSFcnParams(S, 1 + block->numberOfParameters()); ssSetSFcnParamTunable(S, 0, false); for (unsigned i = 1; i < ssGetNumSFcnParams(S); ++i) { bool tunable = false; block->parameterAtIndexIsTunable(i - 1, tunable); ssSetSFcnParamTunable(S, i, tunable); } #if defined(MATLAB_MEX_FILE) if(ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)){ mdlCheckParameters(S); if(ssGetErrorStatus(S)){ return; } } else{ sprintf(errorBuffer, "%s", "Number of parameters different from those defined"); ssSetErrorStatus(S, errorBuffer); return; } #endif wbt::Error error; if (!block->configureSizeAndPorts(S, &error)) { sprintf(errorBuffer, "%s", error.message.substr(0, 511).c_str()); ssSetErrorStatus(S, errorBuffer); return; } ssSetNumSampleTimes(S, 1); ssSetSimStateCompliance(S, USE_CUSTOM_SIM_STATE); //?? ssSetNumDiscStates(S, block->numberOfDiscreteStates()); ssSetNumContStates(S, 0);//block->numberOfContinuousStates()); uint_T options = SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_ALLOW_INPUT_SCALAR_EXPANSION | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_CALL_TERMINATE_ON_EXIT; //also ? //SS_OPTION_RUNTIME_EXCEPTION_FREE_CODE options |= block->additionalBlockOptions(); ssSetOptions(S, options); delete block; }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Call mdlCheckParameters to verify that the parameters are okay, * then setup sizes of the various vectors. * * We specify 2 input and 3 output ports with inherited port based sample * times. */ static void mdlInitializeSizes(SimStruct *S) { int_T i; real_T ts; /* See sfuntmpl_doc.c for more details on the macros below */ /* Set number of expected parameters */ if (ssGetSFcnParamsCount(S) == NKPARAMS || ssGetSFcnParamsCount(S) == NTOTALPARAMS) { ssSetNumSFcnParams(S, ssGetSFcnParamsCount(S)); } else { ssSetNumSFcnParams(S, NKPARAMS); } #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink */ } #endif /* Parameters can't be tuned */ ssSetSFcnParamNotTunable(S,K1_IDX); ssSetSFcnParamNotTunable(S,K2_IDX); ssSetSFcnParamNotTunable(S,K3_IDX); /* Load ts for input and output ports */ if (ssGetNumSFcnParams(S) == NTOTALPARAMS) { ssSetSFcnParamNotTunable(S,OPTIONAL_TS_IDX); ts = mxGetPr(OPTIONAL_TS_PARAM(S))[0]; } else { ts = INHERITED_SAMPLE_TIME; } ssSetNumSampleTimes(S, PORT_BASED_SAMPLE_TIMES); /* Two inputs */ if (!ssSetNumInputPorts(S, NINPUTS)) return; for (i = 0; i < NINPUTS; i++) { ssSetInputPortWidth(S, i, 1); ssSetInputPortDirectFeedThrough(S, i, 1); ssSetInputPortSampleTime(S, i, ts); ssSetInputPortOffsetTime(S, i, 0.0); ssSetInputPortOverWritable(S, i, 0); /* Output is decimated! */ } /* * We are always looking at the enable input in the correct task so we can * optimize away this entry from the block I/O. */ ssSetInputPortOptimOpts(S, ENABLE_IPORT, SS_REUSABLE_AND_LOCAL); /* * We are always looking at the enable input in the correct task so we can * optimize away this entry from the block I/O. */ ssSetInputPortOptimOpts(S, SIGNAL_IPORT, SS_REUSABLE_AND_LOCAL); /* Three outputs */ if (!ssSetNumOutputPorts(S, NOUTPUTS)) return; for (i = 0; i < NOUTPUTS; i++) { ssSetOutputPortWidth(S, i, 1); ssSetOutputPortOptimOpts(S, i, SS_NOT_REUSABLE_AND_GLOBAL); /* Need to be persistent since the since we don't update the outputs at every sample hit for this block */ if (ts == INHERITED_SAMPLE_TIME) { ssSetOutputPortSampleTime(S, i, ts); } else { ssSetOutputPortSampleTime(S, i, ts*mxGetPr(ssGetSFcnParam(S,i))[0]); } ssSetOutputPortOffsetTime(S, i, 0.0); } ssSetNumIWork(S, 1); /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR); } /* end mdlInitializeSizes */
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { DECL_AND_INIT_DIMSINFO(inputDimsInfo); DECL_AND_INIT_DIMSINFO(outputDimsInfo); ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink */ } #endif ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetNumContStates(S, NUM_CONT_STATES); ssSetNumDiscStates(S, NUM_DISC_STATES); if (!ssSetNumInputPorts(S, NUM_INPUTS)) return; /*Input Port 0 */ ssSetInputPortWidth(S, 0, INPUT_0_WIDTH); /* */ ssSetInputPortDataType(S, 0, SS_DOUBLE); ssSetInputPortComplexSignal(S, 0, INPUT_0_COMPLEX); ssSetInputPortDirectFeedThrough(S, 0, INPUT_0_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/ /*Input Port 1 */ ssSetInputPortWidth(S, 1, INPUT_1_WIDTH); /* */ ssSetInputPortDataType(S, 1, SS_DOUBLE); ssSetInputPortComplexSignal(S, 1, INPUT_1_COMPLEX); ssSetInputPortDirectFeedThrough(S, 1, INPUT_1_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 1, 1); /*direct input signal access*/ /*Input Port 2 */ ssSetInputPortWidth(S, 2, INPUT_2_WIDTH); /* */ ssSetInputPortDataType(S, 2, SS_DOUBLE); ssSetInputPortComplexSignal(S, 2, INPUT_2_COMPLEX); ssSetInputPortDirectFeedThrough(S, 2, INPUT_2_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 2, 1); /*direct input signal access*/ /*Input Port 3 */ ssSetInputPortWidth(S, 3, INPUT_3_WIDTH); /* */ ssSetInputPortDataType(S, 3, SS_DOUBLE); ssSetInputPortComplexSignal(S, 3, INPUT_3_COMPLEX); ssSetInputPortDirectFeedThrough(S, 3, INPUT_3_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 3, 1); /*direct input signal access*/ /*Input Port 4 */ ssSetInputPortWidth(S, 4, INPUT_4_WIDTH); /* */ ssSetInputPortDataType(S, 4, SS_DOUBLE); ssSetInputPortComplexSignal(S, 4, INPUT_4_COMPLEX); ssSetInputPortDirectFeedThrough(S, 4, INPUT_4_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 4, 1); /*direct input signal access*/ if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return; /* Output Port 0 */ ssSetOutputPortWidth(S, 0, OUTPUT_0_WIDTH); ssSetOutputPortDataType(S, 0, SS_DOUBLE); ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_WORKS_WITH_CODE_REUSE)); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { int_T npar = ssGetSFcnParamsCount(S); /* options are optional as a third parameter */ if ( npar==2 || npar==3 ) { ssSetNumSFcnParams(S, npar); /* Number of expected parameters */ } else { return; } #ifdef MATLAB_MEX_FILE if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink */ } #endif /* no states because we do not need nothing to remember */ ssSetNumContStates(S, 0); /* the number of continuous states */ ssSetNumDiscStates(S, 0 ); /* the number of discrete states */ /* inputs are M, q*/ if (!ssSetNumInputPorts(S, 2)) return; /* input matrix M to port 0*/ ssSetInputPortWidth(S, 0, NSTATES(S)*NSTATES(S)); ssSetInputPortMatrixDimensions(S, 0, NSTATES(S), NSTATES(S)); ssSetInputPortDirectFeedThrough(S, 0, 1); /* direct feedtrough for port 0*/ /* input vector q to port 1*/ ssSetInputPortWidth(S, 1, NSTATES(S)); ssSetInputPortVectorDimension(S, 1, NSTATES(S)); ssSetInputPortDirectFeedThrough(S, 1, 1); /* direct feedtrough for port 1*/ /* outputs are z, w, basis, exitflag, pivots, time */ if (!ssSetNumOutputPorts(S, 6)) return; ssSetOutputPortWidth(S, 0, NSTATES(S)); /* output z to port 0 */ ssSetOutputPortVectorDimension(S, 0, NSTATES(S)); ssSetOutputPortWidth(S, 1, NSTATES(S)); /* output w to port 1 */ ssSetOutputPortVectorDimension(S, 1, NSTATES(S)); ssSetOutputPortWidth(S, 2, NSTATES(S)); /* basis to port 2 */ ssSetOutputPortVectorDimension(S, 2, NSTATES(S)); ssSetOutputPortWidth(S, 3, 1); /* exitflag to port 3 */ ssSetOutputPortWidth(S, 4, 1); /* pivots to port 4 */ ssSetOutputPortWidth(S, 5, 1); /* computation time to port 5 */ ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 7); /* working vectors Mn, qn, r, c, x, pA, pB */ ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* use PWorks to store values */ ssSetSimStateCompliance(S, HAS_NO_SIM_STATE); ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE ); }