/* 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);
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
return; /* Parameter mismatch will be reported by Simulink */
}
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_UINT8);
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_UINT8);
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_UINT8);
ssSetInputPortComplexSignal(S, 2, INPUT_2_COMPLEX);
ssSetInputPortDirectFeedThrough(S, 2, INPUT_2_FEEDTHROUGH);
ssSetInputPortRequiredContiguous(S, 2, 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);
/* Output Port 1 */
ssSetOutputPortWidth(S, 1, OUTPUT_1_WIDTH);
ssSetOutputPortDataType(S, 1, SS_DOUBLE);
ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX);
ssSetNumSampleTimes(S, 1);
ssSetNumRWork(S, 0);
ssSetNumIWork(S, 0);
ssSetNumPWork(S, 0);
ssSetNumModes(S, 0);
ssSetNumNonsampledZCs(S, 0);
ssSetSimulinkVersionGeneratedIn(S, "8.4");
/* 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)
{
// 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);
}
/* 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);
}
/* Function: mdlInitializeSizes ===============================================
* Abstract:
* Setup sizes of the various vectors.
*/
static void mdlInitializeSizes(SimStruct *S)
{
DECL_AND_INIT_DIMSINFO(outputDimsInfo);
ssSetNumSFcnParams(S, NPARAMS);
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
return; /* Parameter mismatch will be reported by Simulink */
}
ssSetNumContStates(S, NUM_CONT_STATES);
ssSetNumDiscStates(S, NUM_DISC_STATES);
if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;
if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;
/* Output Port 0 */
outputDimsInfo.width = OUTPUT_0_WIDTH;
ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,0, OUTPUT_0_WIDTH, OUTPUT_DIMS_0_COL);
ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED);
ssSetOutputPortDataType(S, 0, SS_UINT8);
ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);
/* Output Port 1 */
outputDimsInfo.width = OUTPUT_1_WIDTH;
ssSetOutputPortDimensionInfo(S, 1, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,1, OUTPUT_1_WIDTH, OUTPUT_DIMS_1_COL);
ssSetOutputPortFrameData(S, 1, OUT_1_FRAME_BASED);
ssSetOutputPortDataType(S, 1, SS_UINT8);
ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX);
/* Output Port 2 */
outputDimsInfo.width = OUTPUT_2_WIDTH;
ssSetOutputPortDimensionInfo(S, 2, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,2, OUTPUT_2_WIDTH, OUTPUT_DIMS_2_COL);
ssSetOutputPortFrameData(S, 2, OUT_2_FRAME_BASED);
ssSetOutputPortDataType(S, 2, SS_UINT8);
ssSetOutputPortComplexSignal(S, 2, OUTPUT_2_COMPLEX);
/* Output Port 3 */
outputDimsInfo.width = OUTPUT_3_WIDTH;
ssSetOutputPortDimensionInfo(S, 3, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,3, OUTPUT_3_WIDTH, OUTPUT_DIMS_3_COL);
ssSetOutputPortFrameData(S, 3, OUT_3_FRAME_BASED);
ssSetOutputPortDataType(S, 3, SS_UINT16);
ssSetOutputPortComplexSignal(S, 3, OUTPUT_3_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_WORKS_WITH_CODE_REUSE));
}
static void mdlInitializeSizes(SimStruct *S)
{
const real_T *P1 = mxGetData(PARAM_DEF3(S));
const real_T *P2 = mxGetData(PARAM_DEF2(S));
DECL_AND_INIT_DIMSINFO(outputDimsInfo);
ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */
#if defined(MATLAB_MEX_FILE)
if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) {
if (ssGetErrorStatus(S) != NULL) {
return;
}
} else {
return; /* Parameter mismatch will be reported by Simulink */
}
#endif
ssSetNumContStates(S, NUM_CONT_STATES);
ssSetNumDiscStates(S, NUM_DISC_STATES);
if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;
if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;
/* Output Port 0 */
outputDimsInfo.width = *P1;
ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,0, *P1, *P2);
ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED);
ssSetOutputPortDataType(S, 0, SS_UINT8);
ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);
/* Output Port 1 */
outputDimsInfo.width = *P1;
ssSetOutputPortDimensionInfo(S, 1, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,1, *P1, *P2);
ssSetOutputPortFrameData(S, 1, OUT_1_FRAME_BASED);
ssSetOutputPortDataType(S, 1, SS_UINT8);
ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX);
/* Output Port 2 */
outputDimsInfo.width = *P1;
ssSetOutputPortDimensionInfo(S, 2, &outputDimsInfo);
ssSetOutputPortMatrixDimensions( S ,2, *P1, *P2);
ssSetOutputPortFrameData(S, 2, OUT_2_FRAME_BASED);
ssSetOutputPortDataType(S, 2, SS_UINT8);
ssSetOutputPortComplexSignal(S, 2, OUTPUT_2_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_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)
{
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)
{
DECL_AND_INIT_DIMSINFO(outputDimsInfo);
ssSetNumSFcnParams(S, NPARAMS);
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
return; /* Parameter mismatch will be reported by Simulink */
}
ssSetNumContStates(S, NUM_CONT_STATES);
ssSetNumDiscStates(S, NUM_DISC_STATES);
if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;
if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;
ssSetOutputPortWidth(S, 0, OUTPUT_0_WIDTH);
ssSetOutputPortDataType(S, 0, SS_INT32);
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_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) {
ssSetNumSFcnParams(S, 0); /* Number of expected parameters */
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
/* Return if number of expected != number of actual parameters */
return;
}
// printf("URG: 111\n");
ssSetNumContStates(S, 0);
ssSetNumDiscStates(S, 0);
if (!ssSetNumInputPorts(S, 0)) return;
if (!ssSetNumOutputPorts(S, 1)) return;
ssSetOutputPortWidth(S, 0, 682);
ssSetOutputPortDataType(S, 0, SS_INT16);
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);
printf("URG: Inicializando driver URG-04LX...\n");
}
/* 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);
}
/* 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)
{
char host[] = "localhost";
int port = 9002;
trigger = 0;
/* 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);
/* This functions receives no inputs, but it could use inputs instead of hard-coded parameters (e.g. port and host) */
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, 2)) return;
ssSetOutputPortWidth(S, 0, PAYLOAD_LEN/2);
ssSetOutputPortDataType(S, 0, SS_UINT16);
ssSetOutputPortWidth(S, 1, 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);
/* Connect to the SerialForwarder server using functions linked in sfsource.o */
fd = open_sf_source(host, port);
if (fd < 0){
ssSetErrorStatus(S,"SerialForwarder not running in the specified host and port");
return;
}
}
/* Function: mdlInitializeSizes ===============================================
* Abstract:
* Setup sizes of the various vectors.
*/
static void mdlInitializeSizes(SimStruct *S)
{
DECL_AND_INIT_DIMSINFO(outputDimsInfo);
ssSetNumSFcnParams(S, NPARAMS);
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
return; /* Parameter mismatch will be reported by Simulink */
}
ssSetNumContStates(S, NUM_CONT_STATES);
ssSetNumDiscStates(S, NUM_DISC_STATES);
if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;
if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;
/* Output Port 0 */
ssSetOutputPortWidth(S, 0, OUTPUT_0_WIDTH);
ssSetOutputPortDataType(S, 0, SS_SINGLE);
ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);
/* Output Port 1 */
ssSetOutputPortWidth(S, 1, OUTPUT_1_WIDTH);
ssSetOutputPortDataType(S, 1, SS_SINGLE);
ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX);
/* Output Port 2 */
ssSetOutputPortWidth(S, 2, OUTPUT_2_WIDTH);
ssSetOutputPortDataType(S, 2, SS_SINGLE);
ssSetOutputPortComplexSignal(S, 2, OUTPUT_2_COMPLEX);
/* Output Port 3 */
ssSetOutputPortWidth(S, 3, OUTPUT_3_WIDTH);
ssSetOutputPortDataType(S, 3, SS_SINGLE);
ssSetOutputPortComplexSignal(S, 3, OUTPUT_3_COMPLEX);
/* Output Port 4 */
ssSetOutputPortWidth(S, 4, OUTPUT_4_WIDTH);
ssSetOutputPortDataType(S, 4, SS_SINGLE);
ssSetOutputPortComplexSignal(S, 4, OUTPUT_4_COMPLEX);
/* Output Port 5 */
ssSetOutputPortWidth(S, 5, OUTPUT_5_WIDTH);
ssSetOutputPortDataType(S, 5, SS_SINGLE);
ssSetOutputPortComplexSignal(S, 5, OUTPUT_5_COMPLEX);
/* Output Port 6 */
ssSetOutputPortWidth(S, 6, OUTPUT_6_WIDTH);
ssSetOutputPortDataType(S, 6, SS_SINGLE);
ssSetOutputPortComplexSignal(S, 6, OUTPUT_6_COMPLEX);
ssSetNumSampleTimes(S, 1);
ssSetNumRWork(S, 0);
ssSetNumIWork(S, 0);
ssSetNumPWork(S, 0);
ssSetNumModes(S, 0);
ssSetNumNonsampledZCs(S, 0);
ssSetSimulinkVersionGeneratedIn(S, "8.6");
/* 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));
}
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: mdlSetOutputPortDataType ========================================
*/
static void mdlSetOutputPortDataType(SimStruct *S,int portIndex,DTypeId dType)
{
if ( ssGetDataTypeIsFxpFltApiCompat( S, dType ) == 0)
{
ssSetErrorStatus(S,"Unrecognized data type.");
}
else
{
ssSetOutputPortDataType( S, 0, dType );
}
} /* mdlSetOutputPortDataType */
// 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);
}
static void mdlInitializeSizes(SimStruct *S)
{
int_T status; // for new type definition
DTypeId COM_HANDLE_id; // for new type definition
HANDLE handle_aux; // for new type definition
//====================================================== new type definition
COM_HANDLE_id = ssRegisterDataType(S, "COM_HANDLE");
if(COM_HANDLE_id == INVALID_DTYPE_ID) return;
status = ssSetDataTypeSize(S, COM_HANDLE_id, sizeof(handle_aux));
if(status == 0) return;
status = ssSetDataTypeZero(S, COM_HANDLE_id, &handle_aux);
if(status == 0) return;
//=============================================================== parameters
ssSetNumSFcnParams(S, 2); // 2 parameters:
// - COM port
// - baudrate
//Parameter mismatch will be reported by Simulink
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S))
return;
//=================================================================== inputs
if (!ssSetNumInputPorts(S, 0)) return; // 0 inputs
//================================================================== outputs
if (!ssSetNumOutputPorts(S, 1)) return; // 1 outputs:
// - COM handle
////////////////////////////// com handle //////////////////////////////
ssSetOutputPortWidth(S,0,1); // input 1 width
ssSetOutputPortDataType(S, 0, COM_HANDLE_id); // input 1 datatype
//============================================================= sample times
ssSetNumSampleTimes( S, 1); // number of sample times
//============================================================= work vectors
ssSetNumRWork(S, 0); // 0 real work vector elements
ssSetNumIWork(S, 0); // 0 work vector elements
ssSetNumPWork(S, 1); // 1 pwork vector elements:
// - COM handle
ssSetNumModes(S, 0); // 0 mode work vector elements
ssSetNumNonsampledZCs(S, 0); // 0 nonsampled zero crossings
}
static void SetPortDataType(SimStruct *S, DTypeId dataTypeId )
{
switch (dataTypeId) {
case SS_DOUBLE:
case SS_SINGLE:
ssSetInputPortDataType( S, 0, dataTypeId);
ssSetInputPortDataType( S, 1, dataTypeId);
ssSetOutputPortDataType(S, 0, dataTypeId);
break;
default:
ssSetErrorStatus(S, "Dot product supports double and single"
" datatypes only");
}
}
/* 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);
}
static void mdlSetDefaultPortDataTypes(SimStruct *S) {
int_T canStDT = ssGetDataTypeId(S,SL_CAN_STANDARD_FRAME_DTYPE_NAME );
int dataPort;
if ( ssGetInputPortDataType(S,0) == DYNAMICALLY_TYPED ){
ssSetInputPortDataType( S, 0, canStDT );
}
if (P_SHOW_DATA ){
dataPort = 0;
if ( ssGetOutputPortDataType(S,dataPort)==DYNAMICALLY_TYPED){
ssSetOutputPortDataType(S,dataPort,SS_UINT8);
}
}
} /* mdlSetDefaultPortDataTypes */
/* 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
ssSetNumContStates(S, NUM_CONT_STATES);
ssSetNumDiscStates(S, NUM_DISC_STATES);
if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;
inputDimsInfo.width = INPUT_0_WIDTH;
ssSetInputPortDimensionInfo(S, 0, &inputDimsInfo);
ssSetInputPortFrameData(S, 0, IN_0_FRAME_BASED);
ssSetInputPortDataType(S, 0, SS_UINT32);
ssSetInputPortComplexSignal(S, 0, INPUT_0_COMPLEX);
ssSetInputPortDirectFeedThrough(S, 0, INPUT_0_FEEDTHROUGH);
ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/
if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;
outputDimsInfo.width = OUTPUT_0_WIDTH;
ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo);
ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED);
ssSetOutputPortDataType(S, 0, SS_DOUBLE);
ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);
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_WORKS_WITH_CODE_REUSE));
}
static void mdlSetOutputPortDataType(SimStruct *S, int port, DTypeId dType)
{
int portWidth;
// set up the data-port data type
if (P_SHOW_DATA) {
// data port is port 0
if (port == 0) {
portWidth = ssGetOutputPortWidth(S,port);
if (isAcceptableOutputDataType(S,dType,portWidth)){
ssSetOutputPortDataType(S,port,dType);
}else{
ssSetErrorStatus(S,"Incompatible DataType or Size specified");
}
}
}
}
static void mdlInitializeSizes(SimStruct *S)
{
DECL_AND_INIT_DIMSINFO(inputDimsInfo);
DECL_AND_INIT_DIMSINFO(outputDimsInfo);
ssSetNumSFcnParams(S, NPARAMS);
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
return; /* Parameter mismatch will be reported by Simulink */
}
ssSetNumContStates(S, NUM_CONT_STATES);
ssSetNumDiscStates(S, NUM_DISC_STATES);
if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;
inputDimsInfo.width = INPUT_0_WIDTH;
ssSetInputPortDimensionInfo(S, 0, &inputDimsInfo);
ssSetInputPortFrameData(S, 0, IN_0_FRAME_BASED);
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*/
if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;
outputDimsInfo.width =OUTPUT_0_WIDTH;
ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo);
ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED);
ssSetOutputPortDataType(S, 0, SS_DOUBLE);
ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);
ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);
ssSetNumSampleTimes(S, 1);
ssSetNumRWork(S, 0);
ssSetNumIWork(S, 0);
ssSetNumPWork(S, 0);
ssSetNumModes(S, 0);
ssSetNumNonsampledZCs(S, 0);
/*ssSetOutputPortWidth(S,0,atoi(temp));*/
/* 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
| SS_OPTION_ALLOW_PARTIAL_DIMENSIONS_CALL));
}
/* Function: mdlInitializeSizes =========================================*/
static void mdlInitializeSizes(SimStruct *S)
{
ssSetNumSFcnParams(S, 0); /* Number of expected parameters */
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
return;
}
/* Register the number and type of states the S-Function uses */
ssSetNumContStates( S, 0); /* number of continuous states */
ssSetNumDiscStates( S, 0); /* number of discrete states */
ssAllowSignalsWithMoreThan2D(S);
/*
* Configure the input ports. First set the number of input ports.
*/
if (!ssSetNumInputPorts(S, 1)) return;
if(!ssSetInputPortDimensionInfo(S, 0, DYNAMIC_DIMENSION)) return;
ssSetInputPortDataType(S, 0, DYNAMICALLY_TYPED);
ssSetInputPortDirectFeedThrough(S, 0, 1);
/*
* Configure the output ports. First set the number of output ports.
*/
if (!ssSetNumOutputPorts(S, 1)) return;
if(!ssSetOutputPortDimensionInfo(S,0,DYNAMIC_DIMENSION)) return;
ssSetOutputPortDataType(S, 0, DYNAMICALLY_TYPED);
ssSetNumSampleTimes(S, PORT_BASED_SAMPLE_TIMES);
ssSetInputPortSampleTime(S, 0, INHERITED_SAMPLE_TIME);
ssSetOutputPortSampleTime(S, 0, INHERITED_SAMPLE_TIME);
/*
* Set size of the work vectors.
*/
ssSetNumRWork( S, 0); /* number of real work vector elements */
ssSetNumIWork( S, 0); /* number of integer work vector elements*/
ssSetNumPWork( S, 0); /* number of pointer work vector elements*/
ssSetNumModes( S, 0); /* number of mode work vector elements */
ssSetNumNonsampledZCs( S, 0); /* number of non-sampled zero crossings */
ssSetOptions(S, 0); /* general options (SS_OPTION_xx) */
} /* end mdlInitializeSizes */
/* 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 (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.
* See matlabroot/simulink/src/sfuntmpl_directfeed.txt.
*/
//ssSetInputPortDirectFeedThrough(S, 0, 1);
if (!ssSetNumOutputPorts(S, 3)) return;
ssSetOutputPortWidth(S, 0, CONSTANT_AXES_SIZE); // axes
ssSetOutputPortWidth(S, 1, CONSTANT_BUTTONS_SIZE); // buttons
ssSetOutputPortDataType(S, 1, SS_INT32);
ssSetOutputPortWidth(S, 2, 1); // time
ssSetNumSampleTimes(S, 1);
ssSetNumRWork(S, 0);
ssSetNumIWork(S, 0);
ssSetNumPWork(S, 2); //AsyncSpinner, GenericSub
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, 0); /* 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, 1)) return;
ssSetInputPortWidth(S, 0, 1);
ssSetInputPortDataType(S, 0, SS_UINT32);
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, 1)) return;
ssSetOutputPortWidth(S, 0, 1);
ssSetOutputPortDataType(S, 0, SS_UINT32);
ssSetNumSampleTimes(S, 1);
ssSetNumRWork(S, 1);
ssSetNumIWork(S, 1);
//ssSetNumPWork(S, 0);
//ssSetNumModes(S, 0);
//ssSetNumNonsampledZCs(S, 0);
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)
{
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);
}
static void mdlInitializeSizes(SimStruct * S) {
ssSetNumSFcnParams(S, NUMBER_OF_ARGS);
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
sprintf(msg, "Wrong number of input arguments passed.\n"
"%d arguments are expected\n", NUMBER_OF_ARGS);
ssSetErrorStatus(S, msg);
return;
}
if ( mxGetM(NO_BYTES_ARG)!=1 | mxGetN(NO_BYTES_ARG)!=1 ) {
sprintf(msg,"Output port width argument must be a scalar\n");
ssSetErrorStatus(S,msg);
return;
}
ssSetNumContStates(S, 0);
ssSetNumDiscStates(S, 0);
ssSetNumOutputPorts(S, 2);
ssSetOutputPortWidth(S, 0, PORT_WIDTH);
ssSetOutputPortDataType(S, 0, SS_UINT8);
ssSetOutputPortWidth(S, 1, 1); /* received flag */
ssSetNumInputPorts(S, 0);
ssSetNumSampleTimes(S, 1);
ssSetNumRWork(S, NO_R_WORKS);
ssSetNumIWork(S, NO_I_WORKS);
ssSetNumPWork(S, NO_P_WORKS);
ssSetNumModes(S, 0);
ssSetNumNonsampledZCs(S, 0);
ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_PLACE_ASAP);
}
/* 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:
* Setup sizes of the various vectors.
*/
static void mdlInitializeSizes(SimStruct *S)
{
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
ssSetNumContStates(S, NUM_CONT_STATES);
ssSetNumDiscStates(S, NUM_DISC_STATES);
if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;
if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;
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));
}
static void mdlSetDefaultPortDataTypes(SimStruct *S)
{
ssSetInputPortDataType( S, 0, SS_DOUBLE);
ssSetOutputPortDataType(S, 0, SS_DOUBLE);
}
static void mdlSetOutputPortDataType(SimStruct *S, int port, DTypeId dType)
{
ssSetOutputPortDataType(S, 0, dType);
}
