/* 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 */ /* Register xref_bus datatype for Input port 0 */ #if defined(MATLAB_MEX_FILE) if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { DTypeId dataTypeIdReg; ssRegisterTypeFromNamedObject(S, "xref_bus", &dataTypeIdReg); if(dataTypeIdReg == INVALID_DTYPE_ID) return; ssSetInputPortDataType(S,0, dataTypeIdReg); } #endif ssSetInputPortWidth(S, 0, INPUT_0_WIDTH); ssSetInputPortComplexSignal(S, 0, INPUT_0_COMPLEX); ssSetInputPortDirectFeedThrough(S, 0, INPUT_0_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/ ssSetBusInputAsStruct(S, 0,IN_0_BUS_BASED); ssSetInputPortBusMode(S, 0, SL_BUS_MODE); /*Input Port 1 */ /* Register x_bus datatype for Input port 1 */ #if defined(MATLAB_MEX_FILE) if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { DTypeId dataTypeIdReg; ssRegisterTypeFromNamedObject(S, "x_bus", &dataTypeIdReg); if(dataTypeIdReg == INVALID_DTYPE_ID) return; ssSetInputPortDataType(S,1, dataTypeIdReg); } #endif ssSetInputPortWidth(S, 1, INPUT_1_WIDTH); ssSetInputPortComplexSignal(S, 1, INPUT_1_COMPLEX); ssSetInputPortDirectFeedThrough(S, 1, INPUT_1_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 1, 1); /*direct input signal access*/ ssSetBusInputAsStruct(S, 1,IN_1_BUS_BASED); ssSetInputPortBusMode(S, 1, SL_BUS_MODE); if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return; /* Register u_bus datatype for Output port 0 */ #if defined(MATLAB_MEX_FILE) if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { DTypeId dataTypeIdReg; ssRegisterTypeFromNamedObject(S, "u_bus", &dataTypeIdReg); if(dataTypeIdReg == INVALID_DTYPE_ID) return; ssSetOutputPortDataType(S,0, dataTypeIdReg); } #endif ssSetBusOutputObjectName(S, 0, (void *) "u_bus"); ssSetOutputPortWidth(S, 0, OUTPUT_0_WIDTH); ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX); ssSetBusOutputAsStruct(S, 0,OUT_0_BUS_BASED); ssSetOutputPortBusMode(S, 0, SL_BUS_MODE); if (ssRTWGenIsCodeGen(S)) { isSimulationTarget = GetRTWEnvironmentMode(S); if (isSimulationTarget==-1) { ssSetErrorStatus(S, " Unable to determine a valid code generation environment mode"); return; } isSimulationTarget |= ssRTWGenIsModelReferenceSimTarget(S); } /* Set the number of dworks */ if (!isDWorkPresent) { if (!ssSetNumDWork(S, 0)) return; } else { if (!ssSetNumDWork(S, 3)) return; } if (isDWorkPresent) { /* * Configure the dwork 0 (u0."BUS") */ #if defined(MATLAB_MEX_FILE) if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { DTypeId dataTypeIdReg; ssRegisterTypeFromNamedObject(S, "xref_bus", &dataTypeIdReg); if (dataTypeIdReg == INVALID_DTYPE_ID) return; ssSetDWorkDataType(S, 0, dataTypeIdReg); } #endif ssSetDWorkUsageType(S, 0, SS_DWORK_USED_AS_DWORK); ssSetDWorkName(S, 0, "u0BUS"); ssSetDWorkWidth(S, 0, DYNAMICALLY_SIZED); ssSetDWorkComplexSignal(S, 0, COMPLEX_NO); /* * Configure the dwork 1 (u1."BUS") */ #if defined(MATLAB_MEX_FILE) if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { DTypeId dataTypeIdReg; ssRegisterTypeFromNamedObject(S, "x_bus", &dataTypeIdReg); if (dataTypeIdReg == INVALID_DTYPE_ID) return; ssSetDWorkDataType(S, 1, dataTypeIdReg); } #endif ssSetDWorkUsageType(S, 1, SS_DWORK_USED_AS_DWORK); ssSetDWorkName(S, 1, "u1BUS"); ssSetDWorkWidth(S, 1, DYNAMICALLY_SIZED); ssSetDWorkComplexSignal(S, 1, COMPLEX_NO); /* * Configure the dwork 2 (y0BUS) */ #if defined(MATLAB_MEX_FILE) if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { DTypeId dataTypeIdReg; ssRegisterTypeFromNamedObject(S, "u_bus", &dataTypeIdReg); if (dataTypeIdReg == INVALID_DTYPE_ID) return; ssSetDWorkDataType(S, 2, dataTypeIdReg); } #endif ssSetDWorkUsageType(S, 2, SS_DWORK_USED_AS_DWORK); ssSetDWorkName(S, 2, "y0BUS"); ssSetDWorkWidth(S, 2, DYNAMICALLY_SIZED); ssSetDWorkComplexSignal(S, 2, COMPLEX_NO); } 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 mdlSetWorkWidths(SimStruct *S) { int_T nq = 0; if( mxGetNumberOfElements(paramQuaternionIndex) == 2 ) { nq = intval(mxGetPr(paramQuaternionIndex)[1]) - intval(mxGetPr(paramQuaternionIndex)[0]) + 1; nq = nq / 4; } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetNumRWork(S, 0); ssSetNumIWork(S, 1); ssSetNumPWork(S, 1); ssSetNumDWork(S, (nq > 0 ? 3 : 2)); ssSetDWorkWidth(S, 0, ssGetInputPortWidth(S, 0)); ssSetDWorkWidth(S, 1, ssGetInputPortWidth(S, 0)); ssSetDWorkDataType(S, 0, SS_DOUBLE); ssSetDWorkDataType(S, 1, SS_DOUBLE); if( nq ) { ssSetDWorkWidth(S, 2, ssGetInputPortWidth(S, 0)); ssSetDWorkDataType(S, 2, SS_DOUBLE); } ssSetNumModes(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); }
/* 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, 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) { ssSetNumSFcnParams(S, 2); ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetNumInputPorts(S, 0); ssSetNumOutputPorts(S, 0); ssSetNumSampleTimes(S, 1); ssSetNumDWork(S, 1); // wall t0 ssSetDWorkWidth(S, 0, 1); ssSetDWorkDataType(S, 0, SS_DOUBLE); }
static void mdlSetWorkWidths_c3_MPC_framework(SimStruct *S) { if(sim_mode_is_rtw_gen(S)) { int_T chartIsInlinable = (int_T)sf_is_chart_inlinable("MPC_framework",3); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop("MPC_framework",3,"gatewayCannotBeInlinedMultipleTimes")); if(chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 2, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 3, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 4, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 5, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 6, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 7, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,"MPC_framework",3,8); sf_mark_chart_reusable_outputs(S,"MPC_framework",3,3); } if (!sf_is_chart_instance_optimized_out("MPC_framework",3)) { int dtId; char *chartInstanceTypedefName = sf_chart_instance_typedef_name("MPC_framework",3); dtId = ssRegisterDataType(S, chartInstanceTypedefName); if (dtId == INVALID_DTYPE_ID ) return; /* Register the size of the udt */ if (!ssSetDataTypeSize(S, dtId, 8)) return; if(!ssSetNumDWork(S,1)) return; ssSetDWorkDataType(S, 0, dtId); ssSetDWorkWidth(S, 0, 1); ssSetDWorkName(S, 0, "ChartInstance"); /*optional name, less than 16 chars*/ sf_set_rtw_identifier(S); } ssSetHasSubFunctions(S,!(chartIsInlinable)); ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); } ssSetChecksum0(S,(1607393255U)); ssSetChecksum1(S,(1677787762U)); ssSetChecksum2(S,(2097080131U)); ssSetChecksum3(S,(3166642993U)); ssSetExplicitFCSSCtrl(S,1); }
static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 5); /* Number of expected parameters */ #ifndef TRES_SIMULINK_DISABLE_MASK_PROTECTION // Perform mask params validity check // TODO very basic error check (to be improved). const mxArray *mxMsdVarName = ssGetSFcnParam(S,MSG_DESCR_VARNAME); if ((mxGetM(mxMsdVarName) != 1) || (mxGetN(mxMsdVarName) == 0)) { ssSetErrorStatus(S, "The message-set description variable cannot be empty"); return; } const mxArray *mxNdVarName = ssGetSFcnParam(S,NTWK_DESCR_VARNAME); if ((mxGetM(mxNdVarName) != 1) || (mxGetN(mxNdVarName) == 0)) { ssSetErrorStatus(S, "The network description variable cannot be empty (you must specify at least the network topology!)"); return; } const mxArray *mxAddLibsPath = ssGetSFcnParam(S,OTHER_DEPS); if ((mxGetM(mxAddLibsPath) != 1) || (mxGetN(mxAddLibsPath) == 0)) { ssSetErrorStatus(S, "The Additional Libraries (see the Simulator tab) field cannot be empty"); return; } #endif ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); // Set the number of input ports to 0 if (!ssSetNumInputPorts(S, 0)) return; // Set the output port to have a dynamic dimension if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, DYNAMICALLY_SIZED); ssSetNumSampleTimes(S, 1); ssSetNumDWork(S, 1); // store the `New pending activations available' flag ssSetDWorkWidth(S, 0, 1); ssSetDWorkDataType(S, 0, SS_BOOLEAN); ssSetNumPWork(S, 1); // store the tres::Network ssSetNumRWork(S, 1); // store the time_resolution ssSetNumNonsampledZCs(S, 1); // next hit }
static void mdlSetWorkWidths_c2_object_tracker_intensity(SimStruct *S) { if(sim_mode_is_rtw_gen(S)) { int_T chartIsInlinable = (int_T)sf_is_chart_inlinable("object_tracker_intensity",2); ssSetStateflowIsInlinable(S,chartIsInlinable); ssSetEnableFcnIsTrivial(S,1); ssSetDisableFcnIsTrivial(S,1); ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop("object_tracker_intensity",2,"gatewayCannotBeInlinedMultipleTimes")); if(chartIsInlinable) { ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 2, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 3, SS_REUSABLE_AND_LOCAL); sf_mark_chart_expressionable_inputs(S,"object_tracker_intensity",2,4); sf_mark_chart_reusable_outputs(S,"object_tracker_intensity",2,3); } if (!sf_is_chart_instance_optimized_out("object_tracker_intensity",2)) { int dtId; char *chartInstanceTypedefName = sf_chart_instance_typedef_name("object_tracker_intensity",2); dtId = ssRegisterDataType(S, chartInstanceTypedefName); if (dtId == INVALID_DTYPE_ID ) return; /* Register the size of the udt */ if (!ssSetDataTypeSize(S, dtId, 8)) return; if(!ssSetNumDWork(S,1)) return; ssSetDWorkDataType(S, 0, dtId); ssSetDWorkWidth(S, 0, 1); ssSetDWorkName(S, 0, "ChartInstance"); /*optional name, less than 16 chars*/ sf_set_rtw_identifier(S); } ssSetHasSubFunctions(S,!(chartIsInlinable)); ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE); } ssSetChecksum0(S,(1312153194U)); ssSetChecksum1(S,(1014398065U)); ssSetChecksum2(S,(1024726701U)); ssSetChecksum3(S,(2475745997U)); ssSetExplicitFCSSCtrl(S,1); }
static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 3); ssSetInputPortRequiredContiguous(S, 0, true); ssSetInputPortDirectFeedThrough(S, 0, 0); //ssSetInputPortDataType(S,0,SS_DOUBLE); if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 3); ssSetNumSampleTimes(S, 1); ssSetNumDWork(S, 2); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); //Pointer SHM_IN ssSetDWorkWidth(S, DVECSHMIN, 1); ssSetDWorkDataType(S, DVECSHMIN, SS_POINTER); //Pointer SHM_OUT ssSetDWorkWidth(S, DVECSHMOUT, 1); ssSetDWorkDataType(S, DVECSHMOUT, SS_POINTER); 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) { /* Number of expected parameters */ ssSetNumSFcnParams(S, 0); /* * Set the number of pworks. */ ssSetNumPWork(S, 0); /* * Set the number of dworks. */ if (!ssSetNumDWork(S, 0)) return; /* * Set the number of input ports. */ if (!ssSetNumInputPorts(S, 1)) return; /* * Configure the input port 1 */ ssSetInputPortDataType(S, 0, SS_INT32); ssSetInputPortWidth(S, 0, 1); ssSetInputPortComplexSignal(S, 0, COMPLEX_NO); ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortAcceptExprInRTW(S, 0, 1); ssSetInputPortOverWritable(S, 0, 1); ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortRequiredContiguous(S, 0, 1); /* * Set the number of output ports. */ if (!ssSetNumOutputPorts(S, 1)) return; /* * Configure the output port 1 */ ssSetOutputPortDataType(S, 0, SS_INT32); ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortComplexSignal(S, 0, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 0, 1); /* * Register reserved identifiers to avoid name conflict */ if (ssRTWGenIsCodeGen(S)) { /* * Register reserved identifier for StartFcnSpec */ ssRegMdlInfo(S, (char*)"createAdder", MDL_INFO_ID_RESERVED, 0, 0, (void*) ssGetPath(S)); /* * Register reserved identifier for OutputFcnSpec */ ssRegMdlInfo(S, (char*)"adderOutput", MDL_INFO_ID_RESERVED, 0, 0, (void*) ssGetPath(S)); /* * Register reserved identifier for TerminateFcnSpec */ ssRegMdlInfo(S, (char*)"deleteAdder", MDL_INFO_ID_RESERVED, 0, 0, (void*) ssGetPath(S)); /* * Register reserved identifier for wrappers */ if (ssRTWGenIsModelReferenceSimTarget(S)) { /* * Register reserved identifier for StartFcnSpec for SimulationTarget */ ssRegMdlInfo(S, (char*)"sldemo_sfun_adder_cpp_wrapper_start", MDL_INFO_ID_RESERVED, 0, 0, (void*) ssGetPath(S)); /* * Register reserved identifier for OutputFcnSpec for SimulationTarget */ ssRegMdlInfo(S, (char*)"sldemo_sfun_adder_cpp_wrapper_output", MDL_INFO_ID_RESERVED, 0, 0, (void*) ssGetPath(S)); /* * Register reserved identifier for TerminateFcnSpec for SimulationTarget */ ssRegMdlInfo(S, (char*)"sldemo_sfun_adder_cpp_wrapper_terminate", MDL_INFO_ID_RESERVED, 0, 0, (void*) ssGetPath(S)); } } /* * This S-function can be used in referenced model simulating in normal mode. */ ssSetModelReferenceNormalModeSupport(S, MDL_START_AND_MDL_PROCESS_PARAMS_OK); /* * Set the number of sample time. */ ssSetNumSampleTimes(S, 1); /* * All options have the form SS_OPTION_<name> and are documented in * matlabroot/simulink/include/simstruc.h. The options should be * bitwise or'd together as in * ssSetOptions(S, (SS_OPTION_name1 | SS_OPTION_name2)) */ ssSetOptions(S, SS_OPTION_CAN_BE_CALLED_CONDITIONALLY | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_SFUNCTION_INLINED_FOR_RTW | SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME); }
/* 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) { 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_DOUBLE); ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX); /* Output Port 1 */ /* Register SL_ROS_SUB_MSG datatype for Output port 1 */ #if defined(MATLAB_MEX_FILE) if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { DTypeId dataTypeIdReg; ssRegisterTypeFromNamedObject(S, "SL_ROS_SUB_MSG", &dataTypeIdReg); if(dataTypeIdReg == INVALID_DTYPE_ID) return; ssSetOutputPortDataType(S,1, dataTypeIdReg); } #endif ssSetBusOutputObjectName(S, 1, (void *) "SL_ROS_SUB_MSG"); ssSetOutputPortWidth(S, 1, OUTPUT_1_WIDTH); ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX); ssSetBusOutputAsStruct(S, 1, OUT_1_BUS_BASED); ssSetOutputPortBusMode(S, 1, SL_BUS_MODE); if (ssRTWGenIsCodeGen(S)) { isSimulationTarget = GetRTWEnvironmentMode(S); if (isSimulationTarget == -1) { ssSetErrorStatus(S, " Unable to determine a valid code generation environment mode"); return; } isSimulationTarget |= ssRTWGenIsModelReferenceSimTarget(S); } /* Set the number of dworks */ if (!isDWorkPresent) { if (!ssSetNumDWork(S, 0)) return; } else { if (!ssSetNumDWork(S, 1)) return; } if (isDWorkPresent) { /* * Configure the dwork 0 (y1BUS) */ #if defined(MATLAB_MEX_FILE) if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { DTypeId dataTypeIdReg; ssRegisterTypeFromNamedObject(S, "SL_ROS_SUB_MSG", &dataTypeIdReg); if (dataTypeIdReg == INVALID_DTYPE_ID) return; ssSetDWorkDataType(S, 0, dataTypeIdReg); } #endif ssSetDWorkUsageType(S, 0, SS_DWORK_USED_AS_DWORK); ssSetDWorkName(S, 0, "y1BUS"); ssSetDWorkWidth(S, 0, DYNAMICALLY_SIZED); ssSetDWorkComplexSignal(S, 0, COMPLEX_NO); } ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetSimulinkVersionGeneratedIn(S, "8.7"); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, 0); }
static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); if (S->mdlInfo->genericFcn != NULL) { _GenericFcn fcn = S->mdlInfo->genericFcn; (fcn)(S, GEN_FCN_CHK_MODELREF_SOLVER_TYPE_EARLY, 2, NULL); } ssSetRTWGeneratedSFcn(S, 2); ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 2)) return; if (!ssSetInputPortVectorDimension(S, 0, 1)) return; ssSetInputPortFrameData(S, 0, FRAME_NO); ssSetInputPortBusMode(S, 0, SL_NON_BUS_MODE) if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { ssSetInputPortDataType(S, 0, SS_DOUBLE); } ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, 1); ssSetInputPortOptimOpts(S, 0, SS_NOT_REUSABLE_AND_GLOBAL); ssSetInputPortOverWritable(S, 0, FALSE); ssSetInputPortSampleTime(S, 0, 0.0); ssSetInputPortOffsetTime(S, 0, 0.0); if (!ssSetInputPortVectorDimension(S, 1, 1)) return; ssSetInputPortFrameData(S, 1, FRAME_NO); ssSetInputPortBusMode(S, 1, SL_NON_BUS_MODE) if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { ssSetInputPortDataType(S, 1, SS_DOUBLE); } ssSetInputPortDirectFeedThrough(S, 1, 1); ssSetInputPortRequiredContiguous(S, 1, 1); ssSetInputPortOptimOpts(S, 1, SS_NOT_REUSABLE_AND_GLOBAL); ssSetInputPortOverWritable(S, 1, FALSE); ssSetInputPortSampleTime(S, 1, 0.0); ssSetInputPortOffsetTime(S, 1, 0.0); if (!ssSetNumOutputPorts(S, 1)) return; if (!ssSetOutputPortVectorDimension(S, 0, 1)) return; ssSetOutputPortFrameData(S, 0, FRAME_NO); ssSetOutputPortBusMode(S, 0, SL_NON_BUS_MODE) if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { ssSetOutputPortDataType(S, 0, SS_DOUBLE); } ssSetOutputPortSampleTime(S, 0, 0.0); ssSetOutputPortOffsetTime(S, 0, 0.0); ssSetOutputPortOkToMerge(S, 0, SS_OK_TO_MERGE); ssSetOutputPortOptimOpts(S, 0, SS_NOT_REUSABLE_AND_GLOBAL); rt_InitInfAndNaN(sizeof(real_T)); { real_T minValue = rtMinusInf; real_T maxValue = rtInf; ssSetModelRefInputSignalDesignMin(S,0,&minValue); ssSetModelRefInputSignalDesignMax(S,0,&maxValue); } { real_T minValue = rtMinusInf; real_T maxValue = rtInf; ssSetModelRefInputSignalDesignMin(S,1,&minValue); ssSetModelRefInputSignalDesignMax(S,1,&maxValue); } { real_T minValue = rtMinusInf; real_T maxValue = rtInf; ssSetModelRefOutputSignalDesignMin(S,0,&minValue); ssSetModelRefOutputSignalDesignMax(S,0,&maxValue); } { static ssRTWStorageType storageClass[3] = { SS_RTW_STORAGE_AUTO, SS_RTW_STORAGE_AUTO, SS_RTW_STORAGE_AUTO }; ssSetModelRefPortRTWStorageClasses(S, storageClass); } ssSetNumSampleTimes(S, PORT_BASED_SAMPLE_TIMES); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumZeroCrossingSignals(S, 0); ssSetOutputPortIsNonContinuous(S, 0, 0); ssSetOutputPortIsFedByBlockWithModesNoZCs(S, 0, 0); ssSetInputPortIsNotDerivPort(S, 0, 1); ssSetInputPortIsNotDerivPort(S, 1, 1); ssSetModelReferenceSampleTimeInheritanceRule(S, DISALLOW_SAMPLE_TIME_INHERITANCE); ssSetOptimizeModelRefInitCode(S, 0); ssSetModelReferenceNormalModeSupport(S, MDL_START_AND_MDL_PROCESS_PARAMS_OK); ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME | SS_OPTION_SUPPORTS_ALIAS_DATA_TYPES | SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_CALL_TERMINATE_ON_EXIT); if (S->mdlInfo->genericFcn != NULL) { ssRegModelRefChildModel(S,1,childModels); } #if SS_SFCN_FOR_SIM if (S->mdlInfo->genericFcn != NULL && ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { mr_vdmultRM_MdlInfoRegFcn(S, "vdmultRM"); } #endif if (!ssSetNumDWork(S, 1)) { return; } #if SS_SFCN_FOR_SIM { int mdlrefDWTypeId; ssRegMdlRefDWorkType(S, &mdlrefDWTypeId); if (mdlrefDWTypeId == INVALID_DTYPE_ID ) return; if (!ssSetDataTypeSize(S, mdlrefDWTypeId, sizeof(rtMdlrefDWork_mr_vdmultRM))) return; ssSetDWorkDataType(S, 0, mdlrefDWTypeId); ssSetDWorkWidth(S, 0, 1); } #endif ssSetNeedAbsoluteTime(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) { /* Number of expected parameters */ ssSetNumSFcnParams(S, 0); /* * Set the number of pworks. */ ssSetNumPWork(S, 0); /* * Set the number of dworks. */ if (!ssSetNumDWork(S, 0)) return; /* * Set the number of input ports. */ if (!ssSetNumInputPorts(S, 0)) return; /* * Set the number of output ports. */ if (!ssSetNumOutputPorts(S, 1)) return; /* * Configure the output port 1 */ ssSetOutputPortDataType(S, 0, SS_SINGLE); ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortComplexSignal(S, 0, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 0, 1); /* * Register reserved identifiers to avoid name conflict */ if (ssRTWGenIsCodeGen(S) || ssGetSimMode(S)==SS_SIMMODE_EXTERNAL) { /* * Register reserved identifier for StartFcnSpec */ ssRegMdlInfo(S, "Magneto_Initialization", MDL_INFO_ID_RESERVED, 0, 0, ssGetPath(S)); /* * Register reserved identifier for OutputFcnSpec */ ssRegMdlInfo(S, "Magneto_Get_X", MDL_INFO_ID_RESERVED, 0, 0, ssGetPath(S)); /* * Register reserved identifier for wrappers */ if (ssRTWGenIsModelReferenceSimTarget(S)) { /* * Register reserved identifier for StartFcnSpec for SimulationTarget */ ssRegMdlInfo(S, "ARDrone_Magneto_X_wrapper_start", MDL_INFO_ID_RESERVED, 0, 0, ssGetPath(S)); /* * Register reserved identifier for OutputFcnSpec for SimulationTarget */ ssRegMdlInfo(S, "ARDrone_Magneto_X_wrapper_output", MDL_INFO_ID_RESERVED, 0, 0, ssGetPath(S)); } } /* * This S-function can be used in referenced model simulating in normal mode. */ ssSetModelReferenceNormalModeSupport(S, MDL_START_AND_MDL_PROCESS_PARAMS_OK); /* * Set the number of sample time. */ ssSetNumSampleTimes(S, 1); /* * All options have the form SS_OPTION_<name> and are documented in * matlabroot/simulink/include/simstruc.h. The options should be * bitwise or'd together as in * ssSetOptions(S, (SS_OPTION_name1 | SS_OPTION_name2)) */ ssSetOptions(S, SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_CAN_BE_CALLED_CONDITIONALLY | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_SFUNCTION_INLINED_FOR_RTW | SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME); }
static void mdlInitializeSizes(SimStruct *S) { int_T param; int_T nports_in = 1; int_T nports_out = 2; int_T idxin_x0 = 0; int_T idxin_params = 0; int_T idxin_reset = 0; int_T idxout_time = 0; 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 for( param=0; param<NPARAMS; param++ ) { ssSetSFcnParamTunable(S,param,false); } ssSetNumSampleTimes(S, 1); ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetNumRWork(S, 0); ssSetNumIWork(S, DYNAMICALLY_SIZED); ssSetNumPWork(S, DYNAMICALLY_SIZED); ssSetNumDWork(S, DYNAMICALLY_SIZED); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); if( intval(mxGetScalar(paramInitialConditionSource)) > 1 ) { idxin_x0 = nports_in++; } if( intval(mxGetScalar(paramSpecificationsSource)) == 3 ) { idxin_params = nports_in++; } if( intval(mxGetScalar(paramExternalReset)) > 1 ) { idxin_reset = nports_in++; } if( intval(mxGetScalar(paramOutputTime)) > 0 ) { idxout_time = nports_out++; } if( !ssSetNumInputPorts(S, nports_in) ) return; if( !ssSetNumOutputPorts(S, nports_out) ) return; ssSetInputPortWidth(S, 0, DYNAMICALLY_SIZED); ssSetInputPortDataType(S, 0, SS_DOUBLE ); ssSetInputPortComplexSignal(S, 0, 0); ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/ ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortWidth(S, 1, DYNAMICALLY_SIZED); ssSetOutputPortDataType(S, 1, SS_DOUBLE); if( idxin_x0 ) { ssSetInputPortWidth(S, idxin_x0, DYNAMICALLY_SIZED); ssSetInputPortDataType(S, idxin_x0, SS_DOUBLE ); ssSetInputPortComplexSignal(S, idxin_x0, 0); ssSetInputPortDirectFeedThrough(S, idxin_x0, 1); ssSetInputPortRequiredContiguous(S, idxin_x0, 1); /*direct input signal access*/ } if( idxin_params ) { ssSetInputPortWidth(S, idxin_params, 2); ssSetInputPortDataType(S, idxin_params, SS_DOUBLE ); ssSetInputPortComplexSignal(S, idxin_params, 0); ssSetInputPortDirectFeedThrough(S, idxin_params, 1); } if( idxin_reset ) { ssSetInputPortWidth(S, idxin_reset, 1); ssSetInputPortDataType(S, idxin_reset, SS_BOOLEAN ); ssSetInputPortComplexSignal(S, idxin_reset, 0); ssSetInputPortDirectFeedThrough(S, idxin_reset, 1); } if( idxout_time ) { ssSetOutputPortWidth(S, idxout_time, 1); ssSetOutputPortDataType(S, idxout_time, SS_DOUBLE); } /* Take care when specifying exception free code - see sfuntmpl_doc.c */ /* ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_CALL_TERMINATE_ON_EXIT ); */ 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, 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, NUM_INPUT)) return; //ssSetInputPortWidth(S, INPUT_PARTICLE, INPUT_PARTICLE_WIDTH); /* SHARED MEMORY */ /* pmd_data */ ssSetInputPortWidth(S, INPUT_PMD_DATA, 2); ssSetInputPortDataType(S, INPUT_PMD_DATA, SS_UINT32); /* POSITION */ ssSetInputPortWidth(S, INPUT_POSITION, 3); //ssSetInputPortDataType(S, INPUT_ALTITUDE, SS_UINT32); /* DCM */ ssSetInputPortWidth(S, INPUT_DCM, 9); /* Walls */ ssSetInputPortWidth(S, INPUT_WALLS, 47*9); /* Measured Velocity */ ssSetInputPortWidth(S, INPUT_MEASURED_VELOCITY, 3); /* general settings for input ports */ int i = 0; for ( i=0; i < NUM_INPUT; 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, NUM_OUTPUT)) return; //ssSetOutputPortMatrixDimensions(S, OUTPUT_UAVENV, OUTPUT_UAVENV_HEIGHT, OUTPUT_UAVENV_WIDTH); // The data type of an output port is double(real_t) by default - and thats perfectly fine here. ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetOptions(S, 0); ssSetNumDWork(S,1); ssSetDWorkWidth(S,0,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_T nInputPorts = 1; /* number of input ports */ int_T dimInputPorts[1] = {6}; /* dimension array of input port sizes */ int_T needsInput[1] = {0}; /* array of direct feedthrough */ int_T nOutputPorts = 4; /* number of output ports */ int_T dimOutputPorts[4] = {3,3,3,8}; /* dimension array of output port sizes */ /* outputs are accel, magnetometer, gyro, ADC (channels 0-3,5-7), channel 4 will always be equal to 0 */ int_T nContStates = 0; /* number of continuous states */ int_T nDiscStates = 0; /* number of discrete states */ /* past pwm outputs */ int_T nDWork = 0; /* size of D (data) work vector */ int_T nRWork = 0; /* size of R (real) work vector */ int_T nIWork = 0; /* size of I (integer) work vector */ int_T nPWork = 7; /* size of P (pointer) work vector */ int_T nMWork = 0; /* size of M (mode) work vector */ int_T nZCWork = 0; /* size of ZC (zero crossings) work vector */ int_T i = 0; /* for loop counter */ ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* * If the the number of expected input parameters is not * equal to the number of parameters entered in the * dialog box, return. Simulink will generate an error * indicating that there is aparameter mismatch. */ return; } else { /* check the parameters to make sure they're valid */ /* only works for simulation */ #if defined(MATLAB_MEX_FILE) mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) return; #endif } /* Set the number of continuous and discrete states */ ssSetNumContStates(S, nContStates); ssSetNumDiscStates(S, nDiscStates); /* * Configure the input ports. First set the number of input * ports. */ if (!ssSetNumInputPorts(S, nInputPorts)) return; /* * Set input port dimensions for each input port index * starting at 0. */ for (i=0; i < nInputPorts; i++) { if(ssSetInputPortVectorDimension(S, i, dimInputPorts[i])==0) return; /* * Set direct feedthrough flag (1=yes, 0=no). */ ssSetInputPortDirectFeedThrough(S, i, needsInput[i]); } /* * Configure the output ports. First set the number of * output ports. */ if (!ssSetNumOutputPorts(S, nOutputPorts)) return; /* * Set output port dimensions for each output port index * starting at 0. */ for (i=0; i < nOutputPorts; i++) { if(ssSetOutputPortVectorDimension(S, i, dimOutputPorts[i])==0) return; } ssSetOutputPortDataType(S,3,SS_UINT16); /* * Set the number of sample times. */ ssSetNumSampleTimes(S, 1); /* * Set size of the work vectors. */ ssSetNumDWork(S, nDWork); /* data vector */ ssSetNumRWork(S, nRWork); /* real vector */ ssSetNumIWork(S, nIWork); /* integer vector */ ssSetNumPWork(S, nPWork); /* pointer vector */ ssSetNumModes(S, nMWork); /* mode vector */ ssSetNumNonsampledZCs(S, nZCWork); /* zero crossings */ ssSetOptions(S, 0); } /* end mdlInitializeSizes */
/* Function to initialize sizes. */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSampleTimes(S, 1); /* Number of sample times */ ssSetNumContStates(S, 0); /* Number of continuous states */ ssSetNumNonsampledZCs(S, 0); /* Number of nonsampled ZCs */ /* Number of output ports */ if (!ssSetNumOutputPorts(S, 1)) return; /* outport number: 0 */ if (!ssSetOutputPortVectorDimension(S, 0, 1)) return; if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { ssSetOutputPortDataType(S, 0, SS_DOUBLE); } ssSetOutputPortSampleTime(S, 0, 0.06); ssSetOutputPortOffsetTime(S, 0, 0.0); ssSetOutputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); /* Number of input ports */ if (!ssSetNumInputPorts(S, 1)) return; /* inport number: 0 */ { if (!ssSetInputPortVectorDimension(S, 0, 1)) return; if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) { ssSetInputPortDataType(S, 0, SS_DOUBLE); } ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortSampleTime(S, 0, 0.06); ssSetInputPortOffsetTime(S, 0, 0.0); ssSetInputPortOverWritable(S, 0, 0); ssSetInputPortOptimOpts(S, 0, SS_NOT_REUSABLE_AND_GLOBAL); } ssSetRTWGeneratedSFcn(S, 1); /* Generated S-function */ /* DWork */ if (!ssSetNumDWork(S, 1)) { return; } /* '<S1>/LinearModel': DSTATE */ ssSetDWorkName(S, 0, "DWORK0"); ssSetDWorkWidth(S, 0, 1); ssSetDWorkUsedAsDState(S, 0, 1); /* Tunable Parameters */ ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { #if defined(MDL_CHECK_PARAMETERS) mdlCheckParameters(S); #endif /* MDL_CHECK_PARAMETERS */ if (ssGetErrorStatus(S) != (NULL) ) { return; } } else { return; /* Parameter mismatch will be reported by Simulink */ } #endif /* MATLAB_MEX_FILE */ /* Options */ ssSetOptions(S, (SS_OPTION_RUNTIME_EXCEPTION_FREE_CODE | SS_OPTION_PORT_SAMPLE_TIMES_ASSIGNED )); #if SS_SFCN_FOR_SIM { ssSupportsMultipleExecInstances(S, false); ssRegisterMsgForNotSupportingMultiExecInst(S, "<diag_root><diag id=\"Simulink:blocks:BlockDoesNotSupportMultiExecInstances\"><arguments><arg type=\"encoded\">SABhAG0AbQBlAHIAcwB0AGUAaQBuAC8ASABhAG0AbQBlAHIAcwB0AGUAaQBuAC0AVwBpAGUAbgBlAHIAIABNAG8AZABlAGwAMQAvAFAAdwBsAGkAbgBlAGEAcgAxAAAA</arg><arg type=\"encoded\">PABfAF8AaQBpAFMAUwBfAF8APgA8AC8AXwBfAGkAaQBTAFMAXwBfAD4AAAA=</arg><arg type=\"encoded\">PABfAF8AaQB0AGUAcgBCAGwAawBfAF8APgA8AC8AXwBfAGkAdABlAHIAQgBsAGsAXwBfAD4AAAA=</arg></arguments></diag>\n</diag_root>"); ssHasStateInsideForEachSS(S, false); } #endif }
/* 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*/ /*Input Port 5 */ ssSetInputPortWidth(S, 5, INPUT_5_WIDTH); /* */ ssSetInputPortDataType(S, 5, SS_DOUBLE); ssSetInputPortComplexSignal(S, 5, INPUT_5_COMPLEX); ssSetInputPortDirectFeedThrough(S, 5, INPUT_5_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 5, 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); /* Output Port 2 */ ssSetOutputPortWidth(S, 2, OUTPUT_2_WIDTH); ssSetOutputPortDataType(S, 2, SS_DOUBLE); ssSetOutputPortComplexSignal(S, 2, OUTPUT_2_COMPLEX); /* Output Port 3 */ ssSetOutputPortWidth(S, 3, OUTPUT_3_WIDTH); ssSetOutputPortDataType(S, 3, SS_DOUBLE); ssSetOutputPortComplexSignal(S, 3, OUTPUT_3_COMPLEX); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /*initialzation of sizes related to DWork Vectors*/ ssSetNumDWork(S,NDWORKS); /*DWork vector 1*/ ssSetDWorkWidth(S, 0, DWORK_0_WIDTH); ssSetDWorkDataType(S, 0, SS_DOUBLE); /*DWork vector 2*/ ssSetDWorkWidth(S, 1, DWORK_1_WIDTH); ssSetDWorkDataType(S, 1, SS_DOUBLE); /*DWork vector 3*/ ssSetDWorkWidth(S, 2, DWORK_2_WIDTH); ssSetDWorkDataType(S, 2, SS_DOUBLE); /* 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) { /* Number of expected parameters */ ssSetNumSFcnParams(S, 0); /* * Set the number of pworks. */ ssSetNumPWork(S, 0); /* * Set the number of dworks. */ if (!ssSetNumDWork(S, 0)) return; /* * Set the number of input ports. */ if (!ssSetNumInputPorts(S, 1)) return; /* * Configure the input port 1 */ ssSetInputPortDataType(S, 0, SS_UINT32); ssSetInputPortWidth(S, 0, 2); ssSetInputPortComplexSignal(S, 0, COMPLEX_NO); ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortAcceptExprInRTW(S, 0, 0); ssSetInputPortOverWritable(S, 0, 0); ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortRequiredContiguous(S, 0, 1); /* * Set the number of output ports. */ if (!ssSetNumOutputPorts(S, 22)) return; /* * Configure the output port 1 */ ssSetOutputPortDataType(S, 0, SS_UINT32); ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortComplexSignal(S, 0, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 0, 0); /* * Configure the output port 2 */ ssSetOutputPortDataType(S, 1, SS_UINT32); ssSetOutputPortWidth(S, 1, 1); ssSetOutputPortComplexSignal(S, 1, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 1, 0); /* * Configure the output port 3 */ ssSetOutputPortDataType(S, 2, SS_UINT32); ssSetOutputPortWidth(S, 2, 1); ssSetOutputPortComplexSignal(S, 2, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 2, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 2, 0); /* * Configure the output port 4 */ ssSetOutputPortDataType(S, 3, SS_UINT32); ssSetOutputPortWidth(S, 3, 1); ssSetOutputPortComplexSignal(S, 3, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 3, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 3, 0); /* * Configure the output port 5 */ ssSetOutputPortDataType(S, 4, SS_DOUBLE); ssSetOutputPortWidth(S, 4, 1); ssSetOutputPortComplexSignal(S, 4, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 4, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 4, 0); /* * Configure the output port 6 */ ssSetOutputPortDataType(S, 5, SS_DOUBLE); ssSetOutputPortWidth(S, 5, 1); ssSetOutputPortComplexSignal(S, 5, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 5, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 5, 0); /* * Configure the output port 7 */ ssSetOutputPortDataType(S, 6, SS_DOUBLE); ssSetOutputPortWidth(S, 6, 1); ssSetOutputPortComplexSignal(S, 6, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 6, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 6, 0); /* * Configure the output port 8 */ ssSetOutputPortDataType(S, 7, SS_DOUBLE); ssSetOutputPortWidth(S, 7, 1); ssSetOutputPortComplexSignal(S, 7, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 7, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 7, 0); /* * Configure the output port 9 */ ssSetOutputPortDataType(S, 8, SS_DOUBLE); ssSetOutputPortWidth(S, 8, 1); ssSetOutputPortComplexSignal(S, 8, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 8, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 8, 0); /* * Configure the output port 10 */ ssSetOutputPortDataType(S, 9, SS_DOUBLE); ssSetOutputPortWidth(S, 9, 1); ssSetOutputPortComplexSignal(S, 9, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 9, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 9, 0); /* * Configure the output port 11 */ ssSetOutputPortDataType(S, 10, SS_DOUBLE); ssSetOutputPortWidth(S, 10, 1); ssSetOutputPortComplexSignal(S, 10, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 10, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 10, 0); /* * Configure the output port 12 */ ssSetOutputPortDataType(S, 11, SS_DOUBLE); ssSetOutputPortWidth(S, 11, 1); ssSetOutputPortComplexSignal(S, 11, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 11, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 11, 0); /* * Configure the output port 13 */ ssSetOutputPortDataType(S, 12, SS_DOUBLE); ssSetOutputPortWidth(S, 12, 1); ssSetOutputPortComplexSignal(S, 12, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 12, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 12, 0); /* * Configure the output port 14 */ ssSetOutputPortDataType(S, 13, SS_DOUBLE); ssSetOutputPortWidth(S, 13, 1); ssSetOutputPortComplexSignal(S, 13, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 13, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 13, 0); /* * Configure the output port 15 */ ssSetOutputPortDataType(S, 14, SS_DOUBLE); ssSetOutputPortWidth(S, 14, 1); ssSetOutputPortComplexSignal(S, 14, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 14, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 14, 0); /* * Configure the output port 16 */ ssSetOutputPortDataType(S, 15, SS_DOUBLE); ssSetOutputPortWidth(S, 15, 1); ssSetOutputPortComplexSignal(S, 15, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 15, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 15, 0); /* * Configure the output port 17 */ ssSetOutputPortDataType(S, 16, SS_DOUBLE); ssSetOutputPortWidth(S, 16, 1); ssSetOutputPortComplexSignal(S, 16, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 16, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 16, 0); /* * Configure the output port 18 */ ssSetOutputPortDataType(S, 17, SS_DOUBLE); ssSetOutputPortWidth(S, 17, 1); ssSetOutputPortComplexSignal(S, 17, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 17, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 17, 0); /* * Configure the output port 19 */ ssSetOutputPortDataType(S, 18, SS_DOUBLE); ssSetOutputPortWidth(S, 18, 1); ssSetOutputPortComplexSignal(S, 18, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 18, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 18, 0); /* * Configure the output port 20 */ ssSetOutputPortDataType(S, 19, SS_DOUBLE); ssSetOutputPortWidth(S, 19, 1); ssSetOutputPortComplexSignal(S, 19, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 19, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 19, 0); /* * Configure the output port 21 */ ssSetOutputPortDataType(S, 20, SS_DOUBLE); ssSetOutputPortWidth(S, 20, 1); ssSetOutputPortComplexSignal(S, 20, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 20, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 20, 0); /* * Configure the output port 22 */ ssSetOutputPortDataType(S, 21, SS_UINT32); ssSetOutputPortWidth(S, 21, 1); ssSetOutputPortComplexSignal(S, 21, COMPLEX_NO); ssSetOutputPortOptimOpts(S, 21, SS_REUSABLE_AND_LOCAL); ssSetOutputPortOutputExprInRTW(S, 21, 0); /* * Register reserved identifiers to avoid name conflict */ if (ssRTWGenIsCodeGen(S)) { /* * Register reserved identifier for StartFcnSpec */ ssRegMdlInfo(S, "openFile", MDL_INFO_ID_RESERVED, 0, 0, ssGetPath(S)); /* * Register reserved identifier for OutputFcnSpec */ ssRegMdlInfo(S, "DrugLibraryReader", MDL_INFO_ID_RESERVED, 0, 0, ssGetPath(S)); /* * Register reserved identifier for TerminateFcnSpec */ ssRegMdlInfo(S, "closeFile", MDL_INFO_ID_RESERVED, 0, 0, ssGetPath(S)); } /* * This S-function can be used in referenced model simulating in normal mode. */ ssSetModelReferenceNormalModeSupport(S, MDL_START_AND_MDL_PROCESS_PARAMS_OK); /* * Set the number of sample time. */ ssSetNumSampleTimes(S, 1); /* * All options have the form SS_OPTION_<name> and are documented in * matlabroot/simulink/include/simstruc.h. The options should be * bitwise or'd together as in * ssSetOptions(S, (SS_OPTION_name1 | SS_OPTION_name2)) */ ssSetOptions(S, SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_CAN_BE_CALLED_CONDITIONALLY | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_SFUNCTION_INLINED_FOR_RTW | SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME); }
return ; } static void mdlInitializeSizes ( SimStruct * S ) { ssSetNumSFcnParams ( S , 0 ) ; ssFxpSetU32BitRegionCompliant ( S , 1 ) ; rt_InitInfAndNaN ( sizeof ( real_T ) ) ; if ( S -> mdlInfo -> genericFcn != ( NULL ) ) { _GenericFcn fcn = S -> mdlInfo -> genericFcn ; real_T lifeSpan = rtInf ; real_T startTime = 0.0 ; real_T stopTime = rtInf ; int_T hwSettings [ 15 ] ; int_T opSettings [ 1 ] ; boolean_T concurrTaskSupport = 0 ; boolean_T hasDiscTs = 1 ; real_T fixedStep = 0.001 ; ( fcn ) ( S , GEN_FCN_CHK_MODELREF_SOLVER_TYPE_EARLY , 2 , ( NULL ) ) ; ( fcn ) ( S , GEN_FCN_MODELREF_RATE_GROUPED , 0 , ( NULL ) ) ; if ( ! ( fcn ) ( S , GEN_FCN_CHK_MODELREF_LIFE_SPAN , - 1 , & lifeSpan ) ) return ; if ( ! ( fcn ) ( S , GEN_FCN_CHK_MODELREF_START_TIME , - 1 , & startTime ) ) return ; if ( ! ( fcn ) ( S , GEN_FCN_CHK_MODELREF_STOP_TIME , - 1 , & stopTime ) ) return ; hwSettings [ 0 ] = 16 ; hwSettings [ 1 ] = 16 ; hwSettings [ 2 ] = 16 ; hwSettings [ 3 ] = 32 ; hwSettings [ 4 ] = 32 ; hwSettings [ 5 ] = 64 ; hwSettings [ 6 ] = 16 ; hwSettings [ 7 ] = 0 ; hwSettings [ 8 ] = 1 ; hwSettings [ 9 ] = 16 ; hwSettings [ 10 ] = 1 ; hwSettings [ 11 ] = 2 ; hwSettings [ 12 ] = 2 ; hwSettings [ 13 ] = 64 ; hwSettings [ 14 ] = 0 ; if ( ! ( fcn ) ( S , GEN_FCN_CHK_MODELREF_HARDWARE_SETTINGS , 15 , hwSettings ) ) return ; opSettings [ 0 ] = 0 ; if ( ! ( fcn ) ( S , GEN_FCN_CHK_MODELREF_OPTIM_SETTINGS , 1 , opSettings ) ) return ; if ( ! ( fcn ) ( S , GEN_FCN_CHK_MODELREF_CONCURRETNT_TASK_SUPPORT , ( int_T ) concurrTaskSupport , ( NULL ) ) ) return ; if ( ! ( fcn ) ( S , GEN_FCN_CHK_MODELREF_SOLVER_TYPE , 0 , & hasDiscTs ) ) return ; if ( ! ( fcn ) ( S , GEN_FCN_CHK_MODELREF_SOLVER_NAME , 0 , ( void * ) "FixedStepDiscrete" ) ) return ; if ( ! ( fcn ) ( S , GEN_FCN_CHK_MODELREF_SOLVER_MODE , SOLVER_MODE_SINGLETASKING , ( NULL ) ) ) return ; if ( ! ( fcn ) ( S , GEN_FCN_CHK_MODELREF_FIXED_STEP , 0 , & fixedStep ) ) return ; ( fcn ) ( S , GEN_FCN_CHK_MODELREF_FRAME_UPGRADE_DIAGNOSTICS , 1 , ( NULL ) ) ; } { static const char * globalVarList [ ] = { "Cntrl_Status" , "DT_PRECISION_HI" , "DT_PRECISION_LO" , "EV_Param" , "Motor_Cmds" , "Power_Lims" , "brake_cmd_table" , "ctrlConst" , "decel_cmd_vec" , "regen_pwr_vec" } ; ssRegModelRefGlobalVarUsage ( S , 10 , ( void * ) globalVarList ) ; } ssSetRTWGeneratedSFcn ( S , 2 ) ; ssSetNumContStates ( S , 0 ) ; ssSetNumDiscStates ( S , 0 ) ; if ( ! ssSetNumInputPorts ( S , 8 ) ) return ; if ( ! ssSetInputPortVectorDimension ( S , 0 , 1 ) ) return ; ssSetInputPortDimensionsMode ( S , 0 , FIXED_DIMS_MODE ) ; ssSetInputPortFrameData ( S , 0 , FRAME_NO ) ; if ( ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { ssSetInputPortDataType ( S , 0 , SS_SINGLE ) ; } ssSetInputPortDirectFeedThrough ( S , 0 , 1 ) ; ssSetInputPortRequiredContiguous ( S , 0 , 1 ) ; ssSetInputPortOptimOpts ( S , 0 , SS_NOT_REUSABLE_AND_LOCAL ) ; ssSetInputPortOverWritable ( S , 0 , FALSE ) ; ssSetInputPortSampleTime ( S , 0 , 0.001 ) ; ssSetInputPortOffsetTime ( S , 0 , 0.0 ) ; if ( ! ssSetInputPortVectorDimension ( S , 1 , 1 ) ) return ; ssSetInputPortDimensionsMode ( S , 1 , FIXED_DIMS_MODE ) ; ssSetInputPortFrameData ( S , 1 , FRAME_NO ) ; if ( ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { ssSetInputPortDataType ( S , 1 , SS_SINGLE ) ; } ssSetInputPortDirectFeedThrough ( S , 1 , 1 ) ; ssSetInputPortRequiredContiguous ( S , 1 , 1 ) ; ssSetInputPortOptimOpts ( S , 1 , SS_NOT_REUSABLE_AND_LOCAL ) ; ssSetInputPortOverWritable ( S , 1 , FALSE ) ; ssSetInputPortSampleTime ( S , 1 , 0.001 ) ; ssSetInputPortOffsetTime ( S , 1 , 0.0 ) ; if ( ! ssSetInputPortVectorDimension ( S , 2 , 1 ) ) return ; ssSetInputPortDimensionsMode ( S , 2 , FIXED_DIMS_MODE ) ; ssSetInputPortFrameData ( S , 2 , FRAME_NO ) ; if ( ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { ssSetInputPortDataType ( S , 2 , SS_SINGLE ) ; } ssSetInputPortDirectFeedThrough ( S , 2 , 0 ) ; ssSetInputPortRequiredContiguous ( S , 2 , 1 ) ; ssSetInputPortOptimOpts ( S , 2 , SS_NOT_REUSABLE_AND_LOCAL ) ; ssSetInputPortOverWritable ( S , 2 , FALSE ) ; ssSetInputPortSampleTime ( S , 2 , 0.001 ) ; ssSetInputPortOffsetTime ( S , 2 , 0.0 ) ; if ( ! ssSetInputPortVectorDimension ( S , 3 , 1 ) ) return ; ssSetInputPortDimensionsMode ( S , 3 , FIXED_DIMS_MODE ) ; ssSetInputPortFrameData ( S , 3 , FRAME_NO ) ; if ( ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { ssSetInputPortDataType ( S , 3 , SS_SINGLE ) ; } ssSetInputPortDirectFeedThrough ( S , 3 , 0 ) ; ssSetInputPortRequiredContiguous ( S , 3 , 1 ) ; ssSetInputPortOptimOpts ( S , 3 , SS_NOT_REUSABLE_AND_LOCAL ) ; ssSetInputPortOverWritable ( S , 3 , FALSE ) ; ssSetInputPortSampleTime ( S , 3 , 0.001 ) ; ssSetInputPortOffsetTime ( S , 3 , 0.0 ) ; if ( ! ssSetInputPortVectorDimension ( S , 4 , 1 ) ) return ; ssSetInputPortDimensionsMode ( S , 4 , FIXED_DIMS_MODE ) ; ssSetInputPortFrameData ( S , 4 , FRAME_NO ) ; if ( ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { ssSetInputPortDataType ( S , 4 , SS_SINGLE ) ; } ssSetInputPortDirectFeedThrough ( S , 4 , 1 ) ; ssSetInputPortRequiredContiguous ( S , 4 , 1 ) ; ssSetInputPortOptimOpts ( S , 4 , SS_NOT_REUSABLE_AND_LOCAL ) ; ssSetInputPortOverWritable ( S , 4 , FALSE ) ; ssSetInputPortSampleTime ( S , 4 , 0.001 ) ; ssSetInputPortOffsetTime ( S , 4 , 0.0 ) ; if ( ! ssSetInputPortVectorDimension ( S , 5 , 1 ) ) return ; ssSetInputPortDimensionsMode ( S , 5 , FIXED_DIMS_MODE ) ; ssSetInputPortFrameData ( S , 5 , FRAME_NO ) ; if ( ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { ssSetInputPortDataType ( S , 5 , SS_SINGLE ) ; } ssSetInputPortDirectFeedThrough ( S , 5 , 1 ) ; ssSetInputPortRequiredContiguous ( S , 5 , 1 ) ; ssSetInputPortOptimOpts ( S , 5 , SS_NOT_REUSABLE_AND_LOCAL ) ; ssSetInputPortOverWritable ( S , 5 , FALSE ) ; ssSetInputPortSampleTime ( S , 5 , 0.001 ) ; ssSetInputPortOffsetTime ( S , 5 , 0.0 ) ; if ( ! ssSetInputPortVectorDimension ( S , 6 , 1 ) ) return ; ssSetInputPortDimensionsMode ( S , 6 , FIXED_DIMS_MODE ) ; ssSetInputPortFrameData ( S , 6 , FRAME_NO ) ; if ( ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { ssSetInputPortDataType ( S , 6 , SS_SINGLE ) ; } ssSetInputPortDirectFeedThrough ( S , 6 , 1 ) ; ssSetInputPortRequiredContiguous ( S , 6 , 1 ) ; ssSetInputPortOptimOpts ( S , 6 , SS_REUSABLE_AND_LOCAL ) ; ssSetInputPortOverWritable ( S , 6 , FALSE ) ; ssSetInputPortSampleTime ( S , 6 , 0.001 ) ; ssSetInputPortOffsetTime ( S , 6 , 0.0 ) ; if ( ! ssSetInputPortVectorDimension ( S , 7 , 1 ) ) return ; ssSetInputPortDimensionsMode ( S , 7 , FIXED_DIMS_MODE ) ; ssSetInputPortFrameData ( S , 7 , FRAME_NO ) ; if ( ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { ssSetInputPortDataType ( S , 7 , SS_SINGLE ) ; } ssSetInputPortDirectFeedThrough ( S , 7 , 1 ) ; ssSetInputPortRequiredContiguous ( S , 7 , 1 ) ; ssSetInputPortOptimOpts ( S , 7 , SS_REUSABLE_AND_LOCAL ) ; ssSetInputPortOverWritable ( S , 7 , FALSE ) ; ssSetInputPortSampleTime ( S , 7 , 0.001 ) ; ssSetInputPortOffsetTime ( S , 7 , 0.0 ) ; if ( ! ssSetNumOutputPorts ( S , 3 ) ) return ; if ( ! ssSetOutputPortVectorDimension ( S , 0 , 1 ) ) return ; ssSetOutputPortDimensionsMode ( S , 0 , FIXED_DIMS_MODE ) ; ssSetOutputPortFrameData ( S , 0 , FRAME_NO ) ; if ( ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { #if defined (MATLAB_MEX_FILE) { DTypeId dataTypeIdReg ; ssRegisterTypeFromNamedObject ( S , "Cntrl_Status" , & dataTypeIdReg ) ; if ( dataTypeIdReg == INVALID_DTYPE_ID ) return ; ssSetOutputPortDataType ( S , 0 , dataTypeIdReg ) ; } #endif } ssSetOutputPortSampleTime ( S , 0 , 0.001 ) ; ssSetOutputPortOffsetTime ( S , 0 , 0.0 ) ; ssSetOutputPortDiscreteValuedOutput ( S , 0 , 0 ) ; ssSetOutputPortOkToMerge ( S , 0 , SS_OK_TO_MERGE ) ; ssSetOutputPortOptimOpts ( S , 0 , SS_NOT_REUSABLE_AND_GLOBAL ) ; if ( ! ssSetOutputPortVectorDimension ( S , 1 , 1 ) ) return ; ssSetOutputPortDimensionsMode ( S , 1 , FIXED_DIMS_MODE ) ; ssSetOutputPortFrameData ( S , 1 , FRAME_NO ) ; if ( ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { #if defined (MATLAB_MEX_FILE) { DTypeId dataTypeIdReg ; ssRegisterTypeFromNamedObject ( S , "Motor_Cmds" , & dataTypeIdReg ) ; if ( dataTypeIdReg == INVALID_DTYPE_ID ) return ; ssSetOutputPortDataType ( S , 1 , dataTypeIdReg ) ; } #endif } ssSetOutputPortSampleTime ( S , 1 , 0.001 ) ; ssSetOutputPortOffsetTime ( S , 1 , 0.0 ) ; ssSetOutputPortDiscreteValuedOutput ( S , 1 , 0 ) ; ssSetOutputPortOkToMerge ( S , 1 , SS_OK_TO_MERGE ) ; ssSetOutputPortOptimOpts ( S , 1 , SS_NOT_REUSABLE_AND_LOCAL ) ; if ( ! ssSetOutputPortVectorDimension ( S , 2 , 1 ) ) return ; ssSetOutputPortDimensionsMode ( S , 2 , FIXED_DIMS_MODE ) ; ssSetOutputPortFrameData ( S , 2 , FRAME_NO ) ; if ( ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { ssSetOutputPortDataType ( S , 2 , SS_SINGLE ) ; } ssSetOutputPortSampleTime ( S , 2 , 0.001 ) ; ssSetOutputPortOffsetTime ( S , 2 , 0.0 ) ; ssSetOutputPortDiscreteValuedOutput ( S , 2 , 0 ) ; ssSetOutputPortOkToMerge ( S , 2 , SS_OK_TO_MERGE ) ; ssSetOutputPortOptimOpts ( S , 2 , SS_NOT_REUSABLE_AND_LOCAL ) ; { real_T minValue = rtMinusInf ; real_T maxValue = rtInf ; ssSetModelRefInputSignalDesignMin ( S , 0 , & minValue ) ; ssSetModelRefInputSignalDesignMax ( S , 0 , & maxValue ) ; } { real_T minValue = rtMinusInf ; real_T maxValue = rtInf ; ssSetModelRefInputSignalDesignMin ( S , 1 , & minValue ) ; ssSetModelRefInputSignalDesignMax ( S , 1 , & maxValue ) ; } { real_T minValue = rtMinusInf ; real_T maxValue = rtInf ; ssSetModelRefInputSignalDesignMin ( S , 2 , & minValue ) ; ssSetModelRefInputSignalDesignMax ( S , 2 , & maxValue ) ; } { real_T minValue = rtMinusInf ; real_T maxValue = rtInf ; ssSetModelRefInputSignalDesignMin ( S , 3 , & minValue ) ; ssSetModelRefInputSignalDesignMax ( S , 3 , & maxValue ) ; } { real_T minValue = rtMinusInf ; real_T maxValue = rtInf ; ssSetModelRefInputSignalDesignMin ( S , 4 , & minValue ) ; ssSetModelRefInputSignalDesignMax ( S , 4 , & maxValue ) ; } { real_T minValue = rtMinusInf ; real_T maxValue = rtInf ; ssSetModelRefInputSignalDesignMin ( S , 5 , & minValue ) ; ssSetModelRefInputSignalDesignMax ( S , 5 , & maxValue ) ; } { real_T minValue = rtMinusInf ; real_T maxValue = rtInf ; ssSetModelRefInputSignalDesignMin ( S , 6 , & minValue ) ; ssSetModelRefInputSignalDesignMax ( S , 6 , & maxValue ) ; } { real_T minValue = rtMinusInf ; real_T maxValue = rtInf ; ssSetModelRefInputSignalDesignMin ( S , 7 , & minValue ) ; ssSetModelRefInputSignalDesignMax ( S , 7 , & maxValue ) ; } { real_T minValue = rtMinusInf ; real_T maxValue = rtInf ; ssSetModelRefOutputSignalDesignMin ( S , 0 , & minValue ) ; ssSetModelRefOutputSignalDesignMax ( S , 0 , & maxValue ) ; } { real_T minValue = rtMinusInf ; real_T maxValue = rtInf ; ssSetModelRefOutputSignalDesignMin ( S , 1 , & minValue ) ; ssSetModelRefOutputSignalDesignMax ( S , 1 , & maxValue ) ; } { real_T minValue = rtMinusInf ; real_T maxValue = rtInf ; ssSetModelRefOutputSignalDesignMin ( S , 2 , & minValue ) ; ssSetModelRefOutputSignalDesignMax ( S , 2 , & maxValue ) ; } { static ssRTWStorageType storageClass [ 11 ] = { SS_RTW_STORAGE_AUTO , SS_RTW_STORAGE_AUTO , SS_RTW_STORAGE_AUTO , SS_RTW_STORAGE_AUTO , SS_RTW_STORAGE_AUTO , SS_RTW_STORAGE_AUTO , SS_RTW_STORAGE_AUTO , SS_RTW_STORAGE_AUTO , SS_RTW_STORAGE_AUTO , SS_RTW_STORAGE_AUTO , SS_RTW_STORAGE_AUTO } ; ssSetModelRefPortRTWStorageClasses ( S , storageClass ) ; } ssSetModelRefSignalLoggingSaveFormat ( S , SS_DATASET_FORMAT ) ; ssSetNumSampleTimes ( S , PORT_BASED_SAMPLE_TIMES ) ; ssSetNumRWork ( S , 0 ) ; ssSetNumIWork ( S , 0 ) ; ssSetNumPWork ( S , 0 ) ; ssSetNumModes ( S , 0 ) ; { int_T zcsIdx = 0 ; } ssSetOutputPortIsNonContinuous ( S , 0 , 0 ) ; ssSetOutputPortIsFedByBlockWithModesNoZCs ( S , 0 , 0 ) ; ssSetOutputPortIsNonContinuous ( S , 1 , 0 ) ; ssSetOutputPortIsFedByBlockWithModesNoZCs ( S , 1 , 0 ) ; ssSetOutputPortIsNonContinuous ( S , 2 , 0 ) ; ssSetOutputPortIsFedByBlockWithModesNoZCs ( S , 2 , 0 ) ; ssSetInputPortIsNotDerivPort ( S , 0 , 1 ) ; ssSetInputPortIsNotDerivPort ( S , 1 , 1 ) ; ssSetInputPortIsNotDerivPort ( S , 2 , 1 ) ; ssSetInputPortIsNotDerivPort ( S , 3 , 1 ) ; ssSetInputPortIsNotDerivPort ( S , 4 , 1 ) ; ssSetInputPortIsNotDerivPort ( S , 5 , 1 ) ; ssSetInputPortIsNotDerivPort ( S , 6 , 1 ) ; ssSetInputPortIsNotDerivPort ( S , 7 , 1 ) ; ssSetModelReferenceSampleTimeInheritanceRule ( S , DISALLOW_SAMPLE_TIME_INHERITANCE ) ; ssSetOptimizeModelRefInitCode ( S , 1 ) ; ssSetAcceptsFcnCallInputs ( S ) ; { static const char * inlinedVars [ ] = { "EV_Param" , "brake_cmd_table" , "ctrlConst" , "decel_cmd_vec" , "regen_pwr_vec" } ; ssSetModelRefInlinedVars ( S , 5 , ( void * ) inlinedVars ) ; } ssSetModelReferenceNormalModeSupport ( S , MDL_START_AND_MDL_PROCESS_PARAMS_OK ) ; ssSupportsMultipleExecInstances ( S , FALSE ) ; ssRegisterMsgForNotSupportingMultiExecInst ( S , "<diag_root><diag id=\"Simulink:blocks:ImplicitIterSS_SigObjExpStorageClassNotSupportedInside\"><arguments><arg type=\"numeric\">1</arg><arg type=\"encoded\">RQBWAF8AUAB3AHIAXwBNAGEAbgBhAGcAZQByAC8AUABvAHcAZQByAF8AQwBvAG4AdAByAG8AbAAvAEUAcgByAG8AcgAgAFMAdQBtAAAA</arg><arg type=\"encoded\">cABvAHcAZQByAF8AZQByAHIAbwByAAAA</arg><arg type=\"encoded\">PABfAF8AaQBpAFMAUwBfAF8APgA8AC8AXwBfAGkAaQBTAFMAXwBfAD4AAAA=</arg><arg type=\"encoded\">PABfAF8AaQB0AGUAcgBCAGwAawBfAF8APgA8AC8AXwBfAGkAdABlAHIAQgBsAGsAXwBfAD4AAAA=</arg></arguments></diag>\n</diag_root>" ) ; ssHasStateInsideForEachSS ( S , FALSE ) ; ssSetModelRefHasParforForEachSS ( S , FALSE ) ; ssSetModelRefHasVariantModelOrSubsystem ( S , FALSE ) ; ssSetNumAsyncTs ( S , 0 ) ; ssSetOptions ( S , SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME | SS_OPTION_SUPPORTS_ALIAS_DATA_TYPES | SS_OPTION_WORKS_WITH_CODE_REUSE ) ; if ( S -> mdlInfo -> genericFcn != ( NULL ) ) { ssRegModelRefChildModel ( S , 1 , childModels ) ; } #if SS_SFCN_FOR_SIM if ( S -> mdlInfo -> genericFcn != ( NULL ) && ssGetSimMode ( S ) != SS_SIMMODE_SIZES_CALL_ONLY ) { int_T retVal = 1 ; mr_EV_Pwr_Manager_MdlInfoRegFcn ( S , "EV_Pwr_Manager" , & retVal ) ; if ( ! retVal ) return ; } #endif ssSetNumDWork ( S , 0 ) ; slmrSetHasNonVirtualConstantTs ( S , true ) ; ssSetNeedAbsoluteTime ( S , 1 ) ; ssSetModelRefHasEnablePort ( 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) { /* Number of expected parameters */ ssSetNumSFcnParams(S, 0); /* * Set the number of pworks. */ ssSetNumPWork(S, 0); /* * Set the number of dworks. */ if (!ssSetNumDWork(S, 0)) return; /* * Set the number of input ports. */ if (!ssSetNumInputPorts(S, 0)) return; /* * Set the number of output ports. */ if (!ssSetNumOutputPorts(S, 0)) return; /* * Register reserved identifiers to avoid name conflict */ if (ssRTWGenIsCodeGen(S) || ssGetSimMode(S)==SS_SIMMODE_EXTERNAL) { /* * Register reserved identifier for StartFcnSpec */ ssRegMdlInfo(S, "Actuator_Initialization", MDL_INFO_ID_RESERVED, 0, 0, ssGetPath(S)); /* * Register reserved identifier for TerminateFcnSpec */ ssRegMdlInfo(S, "Actuator_Stop", MDL_INFO_ID_RESERVED, 0, 0, ssGetPath(S)); } /* * This S-function can be used in referenced model simulating in normal mode. */ ssSetModelReferenceNormalModeSupport(S, MDL_START_AND_MDL_PROCESS_PARAMS_OK); /* * Set the number of sample time. */ ssSetNumSampleTimes(S, 1); /* * All options have the form SS_OPTION_<name> and are documented in * matlabroot/simulink/include/simstruc.h. The options should be * bitwise or'd together as in * ssSetOptions(S, (SS_OPTION_name1 | SS_OPTION_name2)) */ ssSetOptions(S, SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_CAN_BE_CALLED_CONDITIONALLY | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_SFUNCTION_INLINED_FOR_RTW | SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME); ssSetSimulinkVersionGeneratedIn(S, "8.3"); }
/* 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, 9); /* Number of expected parameter vectors*/ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } //ssSetNumContStates(S, 12); ssSetNumDiscStates(S, 12); /* if (!ssSetNumInputPorts(S, 1)) return; */ ssSetNumInputPorts(S, 1); ssSetInputPortWidth(S, 0, 8);//[thr ail el rud mxtr run flap gear] /* 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, 6)) return; ssSetOutputPortWidth(S, 0, 12);//The model has 12 states:[u v w p q r h-sl-ft long lat phi theta psi] /* Flight Controls output [thr-pos-norm left-ail-pos-rad el-pos-rad tvc-pos-rad rud-pos-rad flap-pos-norm right-ail-pos-rad * speedbrake-pos-rad spoiler-pos-rad lef-pos-rad gear-pos-norm Nose-gear-steering-pos-deg gear-unit-WOW] */ ssSetOutputPortWidth(S, 1, 13); /* Propulsion output piston (per engine) [prop-rpm prop-thrust-lbs mixture fuel-flow-gph advance-ratio power-hp pt-lbs_sqft * volumetric-efficiency bsfc-lbs_hphr prop-torque blade-angle prop-pitch] * Propulsion output turbine (per engine) [thrust-lbs n1 n2 fuel-flow-pph fuel-flow-pps pt-lbs_sqft pitch-rad reverser-rad yaw-rad inject-cmd * set-running fuel-dump] */ ssSetOutputPortWidth(S, 2, 48); ssSetOutputPortWidth(S, 3, 11);//Calculated outputs [pilot-Nz alpha alpha-dot beta beta-dot vc-fps vc-kts // Vt-fps vg-fps mach climb-rate] ssSetOutputPortWidth(S, 4, 6);//JSBSim Calculated State derivatives output [u_dot v_dot w_dot p_dot q_dot r_dot] ssSetOutputPortWidth(S, 5, 6);//JSBSim Calculated Aerodynamic forces and monents output [X Y Z L M C] //ssSetNumSampleTimes(S, 1); if(!ssSetNumDWork( S, 7)) return; ssSetDWorkWidth( S, 0, ssGetInputPortWidth(S,0));//Work vector for input port ssSetDWorkDataType( S, 0, SS_DOUBLE); /* use SS_DOUBLE if needed */ ssSetDWorkWidth( S, 1, ssGetNumDiscStates(S));//Work vector for states * may need to add actuator states! ssSetDWorkDataType( S, 1, SS_DOUBLE); ssSetDWorkWidth( S, 2, ssGetOutputPortWidth(S,4)); //Work vector derivatives ssSetDWorkDataType( S, 2, SS_DOUBLE); ssSetDWorkWidth( S, 3, ssGetOutputPortWidth(S,1));//Work vector for flight controls outputs ssSetDWorkDataType( S, 3, SS_DOUBLE); ssSetDWorkWidth( S, 4, ssGetOutputPortWidth(S,2));//Work vector for propulsion outputs ssSetDWorkDataType( S, 4, SS_DOUBLE); ssSetDWorkWidth( S, 5, ssGetOutputPortWidth(S,3));//Work vector for calculated outputs ssSetDWorkDataType( S, 5, SS_DOUBLE); ssSetDWorkWidth( S, 6, ssGetOutputPortWidth(S,5));//Work vector for aerodynamic outputs ssSetDWorkDataType( S, 6, SS_DOUBLE); ssSetNumPWork(S, 1); // reserve element in the pointers vector // to store a C++ object ssSetNumNonsampledZCs(S, 0); ssSetOptions(S, 0); }