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); }