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:
* 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)
{
// loop counter
int idx;
ssSetNumSFcnParams(S, P_NPARMS); /* Number of expected parameters */
// No parameters will be tunable
for(idx=0; idx<P_NPARMS; idx++){
ssSetSFcnParamNotTunable(S,idx);
}
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
/* Return if number of expected != number of actual parameters */
return;
}
// Setup all the CAN datatypes
CAN_Common_MdlInitSizes(S);
// Extended frame
int_T canExDT = ssGetDataTypeId(S,SL_CAN_EXTENDED_FRAME_DTYPE_NAME );
// Standard frame
int_T canStDT = ssGetDataTypeId(S,SL_CAN_STANDARD_FRAME_DTYPE_NAME );
// Setup input port
ssSetNumInputPorts(S,1);
ssSetInputPortWidth(S,0,1);
ssSetInputPortDirectFeedThrough(S,0,true);
ssSetInputPortDataType(S,0,DYNAMICALLY_TYPED);
// Setup output ports
ssSetNumOutputPorts(S,4);
ssSetOutputPortWidth(S,0,1); /* ID */
ssSetOutputPortDataType(S,0, SS_DOUBLE);
ssSetOutputPortWidth(S,1,1); /* Length */
ssSetOutputPortDataType(S,1, SS_DOUBLE);
ssSetOutputPortWidth(S,2,1); /* Type */
ssSetOutputPortDataType(S,2, SS_DOUBLE);
ssSetOutputPortWidth(S,3,1); /* Data */
ssSetOutputPortDataType(S,3, SS_DOUBLE);
ssSetNumContStates(S, 0);
ssSetNumDiscStates(S, 0);
ssSetNumSampleTimes(S, 1);
ssSetNumRWork(S, 0);
ssSetNumIWork(S, 0);
ssSetNumPWork(S, 0);
ssSetNumModes(S, 0);
ssSetNumNonsampledZCs(S, 0);
/* use generated code in Accelerator Mode */
ssSetOptions(S, SS_OPTION_USE_TLC_WITH_ACCELERATOR);
}
static void mdlInitializeSizes(SimStruct *S)
{
uint_T i;
ssSetNumSFcnParams(S, NUMBER_OF_PARAMS);
#if defined(MATLAB_MEX_FILE)
if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) {
mdlCheckParameters(S);
if (ssGetErrorStatus(S) != NULL) {
return;
}
} else {
return;
}
#endif
for (i = 0; i < NUMBER_OF_PARAMS; i++) {
ssSetSFcnParamNotTunable(S, i);
}
ssSetNumInputPorts(S, 0);
ssSetNumOutputPorts(S, 1);
ssSetOutputPortWidth(S, 0, 1);
ssSetNumContStates(S, 0);
ssSetNumDiscStates(S, 0);
ssSetNumSampleTimes(S, 1);
ssSetNumPWork(S,1);
ssSetNumIWork(S,1);
ssSetNumRWork(S,2);
}
/* 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 idx;
int_T canExDT; // Extended extended frame
int_T canStDT; // Standard frame
/* See sfuntmpl_doc.c for more details on the macros below */
ssSetNumSFcnParams(S, P_NPARMS); /* Number of expected parameters */
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
/* Return if number of expected != number of actual parameters */
return;
}
// No parameters will be tunable
for(idx=0; idx<P_NPARMS; idx++){
ssSetSFcnParamNotTunable(S,idx);
}
// Setup all the CAN datatypes
CAN_Common_MdlInitSizes(S);
canExDT = ssGetDataTypeId(S,SL_CAN_EXTENDED_FRAME_DTYPE_NAME );
canStDT = ssGetDataTypeId(S,SL_CAN_STANDARD_FRAME_DTYPE_NAME );
// One vectorized output port may contain several CAN
// messages, one frame per signal element
ssSetNumOutputPorts(S,1);
ssSetOutputPortWidth(S,0,1);
if( P_TYPE == CAN_MESSAGE_STANDARD){
ssSetOutputPortDataType(S,0,canStDT);
}else if ( P_TYPE == CAN_MESSAGE_EXTENDED ){
ssSetOutputPortDataType(S,0,canExDT);
}
// Multiple input ports. Each input port represents
// a CAN data frame. These will be vectorized
// uint8 inputs. The width corressponds to the
// number of data bytes in the frame
setInputPorts(S);
ssSetNumContStates(S, 0);
ssSetNumDiscStates(S, 0);
ssSetNumSampleTimes(S, 1);
ssSetNumRWork(S, 0);
ssSetNumIWork(S, 0);
ssSetNumPWork(S, 0);
ssSetNumModes(S, 0);
ssSetNumNonsampledZCs(S, 0);
/* use generated code in Accelerator Mode */
ssSetOptions(S, SS_OPTION_USE_TLC_WITH_ACCELERATOR);
}
static void mdlInitializeSizes(SimStruct *S)
{
uint_T i;
ssSetNumSFcnParams(S, NUMBER_OF_PARAMS);
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
return;
}
for (i = 0; i < NUMBER_OF_PARAMS; i++) {
ssSetSFcnParamNotTunable(S, i);
}
ssSetNumInputPorts(S, 1);
ssSetNumOutputPorts(S, 0);
ssSetInputPortWidth(S, 0, 1);
ssSetInputPortDirectFeedThrough(S, 0, 1);
ssSetNumContStates(S, 0);
ssSetNumDiscStates(S, 0);
ssSetNumSampleTimes(S, 1);
ssSetNumPWork(S, 1);
}
/* 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 idx;
/* See sfuntmpl_doc.c for more details on the macros below */
ssSetNumSFcnParams(S, P_NPARMS); /* Number of expected parameters */
// No parameters will be tunable
for(idx=0; idx<P_NPARMS; idx++){
ssSetSFcnParamNotTunable(S,idx);
}
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
/* Return if number of expected != number of actual parameters */
return;
}
ssSetNumInputPorts(S,0);
ssSetNumOutputPorts(S,2);
ssSetOutputPortWidth(S,0,1);
ssSetOutputPortWidth(S,1,8);
ssSetOutputPortDataType(S,1,SS_UINT8);
ssSetNumContStates(S, 0);
ssSetNumDiscStates(S, 0);
ssSetNumSampleTimes(S, 1);
ssSetNumRWork(S, 0);
ssSetNumIWork(S, 0);
ssSetNumPWork(S, 0);
ssSetNumModes(S, 0);
ssSetNumNonsampledZCs(S, 0);
ssSetOptions(S, 0);
}
/* 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 */
/* mdlInitializeSizes() */
static void mdlInitializeSizes(SimStruct *S) {
// A counting variable
int idx;
// The number of output ports required
int nOP = 0;
// The current output port
int cOP = 0;
/* Register the custom CAN data types */
CAN_Common_MdlInitSizes(S);
ssSetNumSFcnParams(S,NUM_PARAMS); /* Number of expected parameters */
#if defined (MATLAB_MEX_FILE)
if(ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
return; /* Simulink will report a mismatch error */
}
#endif /* MATLAB_MEX_FILE */
// No parameters will be tunable
for(idx=0; idx<NUM_PARAMS; idx++){
ssSetSFcnParamNotTunable(S,idx);
}
ssSetNumInputPorts (S,1);
ssSetInputPortWidth (S,0,1);
ssSetInputPortDirectFeedThrough (S,0,1);
ssSetInputPortDataType (S,0,DYNAMICALLY_TYPED);
nOP += P_SHOW_ID;
nOP += P_SHOW_LENGTH;
nOP += P_SHOW_DATA;
ssSetNumOutputPorts(S,nOP);
// Set the current output port to zero
cOP = 0;
if(P_SHOW_DATA){
ssSetOutputPortDataType(S,cOP,DYNAMICALLY_TYPED);
ssSetOutputPortWidth(S,cOP++,DYNAMICALLY_SIZED);
}
if(P_SHOW_ID){
ssSetOutputPortDataType (S,cOP,SS_UINT32);
ssSetOutputPortWidth(S,cOP++,1);
}
if(P_SHOW_LENGTH){
ssSetOutputPortDataType (S,cOP,SS_UINT32);
ssSetOutputPortWidth(S,cOP++,1);
}
ssSetNumSampleTimes (S,1);
/* use generated code in Accelerator Mode */
ssSetOptions (S,SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR);
}
