static void mdlInitializeSizes(SimStruct *S) { int i; ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } for (i = 0; i < NPARAMS; i++) ssSetSFcnParamTunable(S, i, 0); ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 2)) return; ssSetInputPortWidth(S, 0, 7); ssSetInputPortRequiredContiguous(S, 0, true); ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortWidth(S, 1, DYNAMICALLY_SIZED); ssSetInputPortRequiredContiguous(S, 1, true); ssSetInputPortDirectFeedThrough(S, 1, 1); if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 12); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 5); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); }
/* 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) { /* See sfuntmpl_doc.c for more details on the macros below */ ssSetNumSFcnParams(S, 1); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 3)) return; ssSetInputPortWidth(S, 0, 1); ssSetInputPortWidth(S, 1, 1); ssSetInputPortWidth(S, 2, 1); ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/ ssSetInputPortRequiredContiguous(S, 1, true); /*direct input signal access*/ ssSetInputPortRequiredContiguous(S, 2, true); /*direct input signal access*/ /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. * See matlabroot/simulink/src/sfuntmpl_directfeed.txt. */ ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortDirectFeedThrough(S, 1, 1); ssSetInputPortDirectFeedThrough(S, 2, 1); if (!ssSetNumOutputPorts(S, 5)) return; ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortWidth(S, 1, 1); ssSetOutputPortWidth(S, 2, 1); ssSetOutputPortWidth(S, 3, 1); ssSetOutputPortWidth(S, 4, 1); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { 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 */ inputDimsInfo.width = INPUT_0_WIDTH; ssSetInputPortDimensionInfo(S, 0, &inputDimsInfo); ssSetInputPortMatrixDimensions( S , 0, INPUT_0_WIDTH, INPUT_DIMS_0_COL); ssSetInputPortFrameData(S, 0, IN_0_FRAME_BASED); ssSetInputPortDataType(S, 0, SS_SINGLE); ssSetInputPortComplexSignal(S, 0, INPUT_0_COMPLEX); ssSetInputPortDirectFeedThrough(S, 0, INPUT_0_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/ /*Input Port 1 */ inputDimsInfo.width = INPUT_1_WIDTH; ssSetInputPortDimensionInfo(S, 1, &inputDimsInfo); ssSetInputPortMatrixDimensions( S , 1, INPUT_1_WIDTH, INPUT_DIMS_1_COL); ssSetInputPortFrameData(S, 1, IN_1_FRAME_BASED); ssSetInputPortDataType(S, 1, SS_INT32); ssSetInputPortComplexSignal(S, 1, INPUT_1_COMPLEX); ssSetInputPortDirectFeedThrough(S, 1, INPUT_1_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 1, 1); /*direct input signal access*/ if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return; 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) { int i; ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } for (i = 0; i < NPARAMS; i++) ssSetSFcnParamTunable(S, i, 0); ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 3); ssSetInputPortRequiredContiguous(S, 0, true); ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 1); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_USE_TLC_WITH_ACCELERATOR); }
static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 4); /* B,x0,U,P Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) return; else { if (CheckPar(S)) return; } ssSetNumContStates(S, (int) B(S,"CStates")); ssSetNumDiscStates(S, (int) B(S,"DStates")); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, (int) (U(S,"Number")*B(S,"WaterIn")+B(S,"Setpoints"))); ssSetInputPortDirectFeedThrough(S, 0, (int) B(S,"Direct")); ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/ if (!ssSetNumOutputPorts(S,1)) return; ssSetOutputPortWidth(S, 0, (int) (U(S,"Number")*B(S,"WaterOut")+B(S,"Measurements")) ); 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); }
static void set_input_port (SimStruct *S, int_T num, DTypeId type) { ssSetInputPortWidth (S, num, 1); ssSetInputPortDataType (S, num, type); ssSetInputPortComplexSignal (S, num, COMPLEX_NO); ssSetInputPortDirectFeedThrough (S, num, 1); ssSetInputPortRequiredContiguous (S, num, 1); /*direct input signal access*/ }
static void mdlInitializeSizes(SimStruct *S) { int i,nChannels; static char msg[256]; ssSetNumSFcnParams(S, NUMBER_OF_ARGS); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ sprintf(msg,"Wrong Number of input arguments passed.\n%d arguments are expected\n",NUMBER_OF_ARGS); ssSetErrorStatus(S,msg); return; } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetNumInputPorts(S, 0);//there is no input //if (!ssSetNumInputPorts(S, 1)) return; nChannels=(uint_T)mxGetN(CHANNEL_ARG); //if (!ssSetNumOutputPorts(S, 1)) return; ssSetNumOutputPorts(S,nChannels);//set number of outputs ports for(i=0;i<nChannels;i++) { ssSetOutputPortWidth(S, i, 1);//set width of each port to 1 } ssSetInputPortWidth(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/ /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. */ ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetNumSampleTimes(S, 1);//set number of sample time to 1,which means all input ports share same Ts ssSetNumRWork(S, NO_R_WORKS);//number of float in work vector ssSetNumIWork(S, NO_I_WORKS);//number of int in work vector ssSetNumPWork(S, 0);//number of pointer in work vector ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0);//no need for pass-zero check ssSetSFcnParamNotTunable(S,0); ssSetSFcnParamNotTunable(S,1); ssSetSFcnParamNotTunable(S,2); ssSetSFcnParamNotTunable(S,3); ssSetSFcnParamNotTunable(S,4); ssSetOptions(S,SS_OPTION_EXCEPTION_FREE_CODE|SS_OPTION_PLACE_ASAP); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { 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); 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. */ if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 2); ssSetInputPortDataType(S,0,DYNAMICALLY_TYPED); ssSetInputPortDirectFeedThrough(S,0,1); ssSetInputPortRequiredContiguous(S,0,1); ssSetInputPortReusable(S,0,1); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetOptions(S, 0); ssFxpSetU32BitRegionCompliant(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) { ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/ ssSetInputPortDirectFeedThrough(S, 0, 0); if (!ssSetNumOutputPorts(S, 2)) return; ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortWidth(S, 1, 1); ssSetNumSampleTimes(S, 1); /* * Create a DWork data structure. */ { int dtId; /* * Use caution to avoid name conflicts when registering the * data type name. The suggested naming convention is to use * a common prefix based on your Blockset's name for each data type * registered by S-functions in your blocks set. If the S-function * is not part of a blockset, then use your company's name as a prefix. * The data type name is limited to 31 characters. */ dtId = ssRegisterDataType(S, "ExampleCounterStateStruct"); if (dtId == INVALID_DTYPE_ID ) return; /* Register the size of the udt */ if (!ssSetDataTypeSize(S, dtId, sizeof(CounterStateStruct))) return; ssSetNumDWork(S,1); ssSetDWorkDataType(S, 0, dtId); ssSetDWorkWidth(S, 0, 1); ssSetDWorkName(S, 0, "CSStruct"); /*optional name, less than 16 chars*/ } /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_RUNTIME_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { /* See sfuntmpl_doc.c for more details on the macros below */ ssSetNumSFcnParams(S, 2); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink. */ } #endif ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 2)) return; ssSetInputPortMatrixDimensions(S, 0, DYNAMICALLY_SIZED, DYNAMICALLY_SIZED); // triangles ssSetInputPortDataType(S, 0, SS_UINT32); ssSetInputPortMatrixDimensions(S, 1, DYNAMICALLY_SIZED, DYNAMICALLY_SIZED); // vertices for (int_T i = 0; i < ssGetNumInputPorts(S); ++i) { /*direct input signal access*/ ssSetInputPortRequiredContiguous(S, i, true); /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. * See matlabroot/simulink/src/sfuntmpl_directfeed.txt. */ ssSetInputPortDirectFeedThrough(S, i, 1); } if (!ssSetNumOutputPorts(S, 0)) return; ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 2); //GenericPub and frame id ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
static void mdlInitializeSizes(SimStruct *S) { if (!ssSetNumInputPorts(S, 2)) return; ssSetInputPortWidth(S, 0, NUM_STATES); // x0 ssSetInputPortWidth(S, 1, 1); // reference ssSetInputPortDirectFeedThrough(S, 0, true); ssSetInputPortRequiredContiguous(S, 0, true); ssSetInputPortDirectFeedThrough(S, 1, true); ssSetInputPortRequiredContiguous(S, 1, true); ssSetNumPWork(S, 6); if (!ssSetNumOutputPorts(S, 4)) return; ssSetOutputPortWidth(S, 0, NUM_CONTROLS); ssSetOutputPortWidth(S, 1, NUM_STATES); ssSetOutputPortWidth(S, 2, 1); ssSetOutputPortWidth(S, 3, 1); ssSetNumSampleTimes(S, 1); }
static void setInputPorts(SimStruct * S){ if (P_ID == -1){ ssSetNumInputPorts(S,2); ssSetInputPortDataType(S,1,SS_UINT32); ssSetInputPortWidth(S,1,1); ssSetInputPortDirectFeedThrough(S,1,true); }else{ ssSetNumInputPorts(S,1); } ssSetInputPortRequiredContiguous(S,0,true); ssSetInputPortDataType(S,0,DYNAMICALLY_TYPED); ssSetInputPortDirectFeedThrough(S,0,true); ssSetInputPortWidth(S,0,DYNAMICALLY_SIZED); }
/* 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) { /* setup the right number of parameters: distance, coelevation */ ssSetNumSFcnParams(S,0); if(ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)){ /* sfunction is initialised with the wrong number of parameters */ return; } /* set number of continnuert and discrete states. */ ssSetNumContStates(S, 0); /*zero continuert states*/ ssSetNumDiscStates(S, 0); /*zero discrete states*/ /* specify the number of inputs to 1 (|R_sc(I)| and coelecation) */ if (!ssSetNumInputPorts(S, 1)) return; /*wrong number of inputs*/ ssSetInputPortWidth(S, 0, 3); 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); /* check if the output is setup right: gravitional potential of earth zonal harmonics. */ if (!ssSetNumOutputPorts(S, 1)) return; /*no output set*/ ssSetOutputPortWidth(S, 0, 3); ssSetNumSampleTimes(S, 1); }
/* 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)); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; /* Parameter mismatch will be reported by Simulink */ } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, 1); ssSetInputPortDataType(S, 0, DYNAMICALLY_TYPED ); ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/ if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 1); ssSetOutputPortDataType(S, 0, DYNAMICALLY_TYPED); ssSetOutputPortComplexSignal(S, 0, COMPLEX_NO); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME | SS_OPTION_NONVOLATILE | SS_OPTION_WORKS_WITH_CODE_REUSE)); ssSupportsMultipleExecInstances(S, true); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 1); // Number of expected parameters if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; // Parameter mismatch will be reported by Simulink } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 1); // Usado para actualizar las entradas if (!ssSetNumInputPorts(S,1)) return; ssSetInputPortWidth( S, 0, NENTRADAS ); ssSetInputPortRequiredContiguous( S, 0, 1 ); //for( k=0; k<NENTRADAS; k++ ) //{ // ssSetInputPortWidth(S,k,1); // ssSetInputPortDirectFeedThrough(S,k,1); // Existen llamadas de la entrada en la funcion mdlOutputs // ssSetInputPortRequiredContiguous(S,k,1); // sacado del ejemplo (?) //} if (!ssSetNumOutputPorts(S,1)) return; ssSetOutputPortWidth( S, 0, NSALIDAS ); //for( k=0; k<NSALIDAS; k++ ) //{ // ssSetOutputPortWidth(S, k, 1); //} ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); // reserve element in the float vector ssSetNumIWork(S, 0); // reserve element in the int vector ssSetNumPWork(S, 1); // reserve element in the pointers vector ssSetNumModes(S, 0); // to store a C++ object ssSetNumNonsampledZCs(S, 0); // number of states for which a block detects zero crossings ssSetOptions(S, 0); // set the simulation options that this block implements }
/* Function: mdlInitializeSizes =============================================== * Abstract: * The sizes information is used by Simulink to determine the S-function * block's characteristics (number of inputs, outputs, states, etc.). */ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, NUM_PARAMS); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) return; } else{ return; /* Simulink will report a parameter mismatch error */ } #endif ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); if (!ssSetNumInputPorts(S, 1)) return; ssSetInputPortWidth(S, 0, mxGetScalar(NUMREG(S))); ssSetInputPortDirectFeedThrough(S, 0, 1); /* this is s static fcn: y = f(u) */ ssSetInputPortRequiredContiguous(S, 0, 1); /* there is only one scalar output */ if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortWidth(S, 0, 1); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE); /* Preemptively clear user data pointer so we don't try to free it */ ssSetUserData(S, NULL); }
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) { ssSetNumSFcnParams(S, NUMBER_OF_ARGS); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { /* Return if number of expected != number of actual parameters */ return; } ssSetNumContStates(S, 0); ssSetNumDiscStates(S, 0); if (!ssSetNumInputPorts(S, 0)) return; // ssSetInputPortWidth(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/ /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. */ ssSetInputPortDirectFeedThrough(S, 0, 1); if (!ssSetNumOutputPorts(S, 0)) return; // ssSetOutputPortWidth(S, 0, 1); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, NO_I_WORKS); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, 0); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * 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: * 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)); }
/* 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); }
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) { /* See sfuntmpl_doc.c for more details on the macros below */ char host[] = "localhost"; int port = 9002; fd = open_sf_source(host, port); 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, 10)) return; ssSetInputPortWidth(S, 0, 1); ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/ ssSetInputPortWidth(S, 1, 1); ssSetInputPortRequiredContiguous(S, 1, true); /*direct input signal access*/ ssSetInputPortWidth(S, 2, 1); ssSetInputPortRequiredContiguous(S, 2, true); /*direct input signal access*/ ssSetInputPortWidth(S, 3, 1); ssSetInputPortRequiredContiguous(S, 3, true); /*direct input signal access*/ ssSetInputPortWidth(S, 4, 1); ssSetInputPortRequiredContiguous(S, 4, true); /*direct input signal access*/ ssSetInputPortWidth(S, 5, 1); ssSetInputPortRequiredContiguous(S, 5, true); /*direct input signal access*/ ssSetInputPortWidth(S, 6, 1); ssSetInputPortRequiredContiguous(S, 6, true); /*direct input signal access*/ ssSetInputPortWidth(S, 7, 1); ssSetInputPortRequiredContiguous(S, 7, true); /*direct input signal access*/ ssSetInputPortWidth(S, 8, 1); ssSetInputPortRequiredContiguous(S, 8, true); /*direct input signal access*/ ssSetInputPortWidth(S, 9, 1); ssSetInputPortRequiredContiguous(S, 9, true); /*direct input signal access*/ /* * Set direct feedthrough flag (1=yes, 0=no). * A port has direct feedthrough if the input is used in either * the mdlOutputs or mdlGetTimeOfNextVarHit functions. * See matlabroot/simulink/src/sfuntmpl_directfeed.txt. */ ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortDirectFeedThrough(S, 1, 1); ssSetInputPortDirectFeedThrough(S, 2, 1); ssSetInputPortDirectFeedThrough(S, 3, 1); ssSetInputPortDirectFeedThrough(S, 4, 1); ssSetInputPortDirectFeedThrough(S, 5, 1); ssSetInputPortDirectFeedThrough(S, 6, 1); ssSetInputPortDirectFeedThrough(S, 7, 1); ssSetInputPortDirectFeedThrough(S, 8, 1); ssSetInputPortDirectFeedThrough(S, 9, 1); if (!ssSetNumOutputPorts(S, 0)) return; /*ssSetOutputPortWidth(S, 0, 1);*/ ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE); }
/* Registration function */ RT_MODEL_DI_model_T *DI_model(void) { /* Registration code */ /* initialize non-finites */ rt_InitInfAndNaN(sizeof(real_T)); /* initialize real-time model */ (void) memset((void *)DI_model_M, 0, sizeof(RT_MODEL_DI_model_T)); { /* Setup solver object */ rtsiSetSimTimeStepPtr(&DI_model_M->solverInfo, &DI_model_M->Timing.simTimeStep); rtsiSetTPtr(&DI_model_M->solverInfo, &rtmGetTPtr(DI_model_M)); rtsiSetStepSizePtr(&DI_model_M->solverInfo, &DI_model_M->Timing.stepSize0); rtsiSetErrorStatusPtr(&DI_model_M->solverInfo, (&rtmGetErrorStatus (DI_model_M))); rtsiSetRTModelPtr(&DI_model_M->solverInfo, DI_model_M); } rtsiSetSimTimeStep(&DI_model_M->solverInfo, MAJOR_TIME_STEP); rtsiSetSolverName(&DI_model_M->solverInfo,"FixedStepDiscrete"); DI_model_M->solverInfoPtr = (&DI_model_M->solverInfo); /* Initialize timing info */ { int_T *mdlTsMap = DI_model_M->Timing.sampleTimeTaskIDArray; mdlTsMap[0] = 0; mdlTsMap[1] = 1; DI_model_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]); DI_model_M->Timing.sampleTimes = (&DI_model_M->Timing.sampleTimesArray[0]); DI_model_M->Timing.offsetTimes = (&DI_model_M->Timing.offsetTimesArray[0]); /* task periods */ DI_model_M->Timing.sampleTimes[0] = (0.0); DI_model_M->Timing.sampleTimes[1] = (0.01); /* task offsets */ DI_model_M->Timing.offsetTimes[0] = (0.0); DI_model_M->Timing.offsetTimes[1] = (0.0); } rtmSetTPtr(DI_model_M, &DI_model_M->Timing.tArray[0]); { int_T *mdlSampleHits = DI_model_M->Timing.sampleHitArray; mdlSampleHits[0] = 1; mdlSampleHits[1] = 1; DI_model_M->Timing.sampleHits = (&mdlSampleHits[0]); } rtmSetTFinal(DI_model_M, 30.0); DI_model_M->Timing.stepSize0 = 0.01; DI_model_M->Timing.stepSize1 = 0.01; /* External mode info */ DI_model_M->Sizes.checksums[0] = (943881189U); DI_model_M->Sizes.checksums[1] = (2376373844U); DI_model_M->Sizes.checksums[2] = (1356612486U); DI_model_M->Sizes.checksums[3] = (687118842U); { static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE; static RTWExtModeInfo rt_ExtModeInfo; static const sysRanDType *systemRan[1]; DI_model_M->extModeInfo = (&rt_ExtModeInfo); rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan); systemRan[0] = &rtAlwaysEnabled; rteiSetModelMappingInfoPtr(DI_model_M->extModeInfo, &DI_model_M->SpecialInfo.mappingInfo); rteiSetChecksumsPtr(DI_model_M->extModeInfo, DI_model_M->Sizes.checksums); rteiSetTPtr(DI_model_M->extModeInfo, rtmGetTPtr(DI_model_M)); } DI_model_M->solverInfoPtr = (&DI_model_M->solverInfo); DI_model_M->Timing.stepSize = (0.01); rtsiSetFixedStepSize(&DI_model_M->solverInfo, 0.01); rtsiSetSolverMode(&DI_model_M->solverInfo, SOLVER_MODE_SINGLETASKING); /* data type transition information */ { static DataTypeTransInfo dtInfo; (void) memset((char_T *) &dtInfo, 0, sizeof(dtInfo)); DI_model_M->SpecialInfo.mappingInfo = (&dtInfo); dtInfo.numDataTypes = 14; dtInfo.dataTypeSizes = &rtDataTypeSizes[0]; dtInfo.dataTypeNames = &rtDataTypeNames[0]; } /* child S-Function registration */ { RTWSfcnInfo *sfcnInfo = &DI_model_M->NonInlinedSFcns.sfcnInfo; DI_model_M->sfcnInfo = (sfcnInfo); rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(DI_model_M))); rtssSetNumRootSampTimesPtr(sfcnInfo, &DI_model_M->Sizes.numSampTimes); DI_model_M->NonInlinedSFcns.taskTimePtrs[0] = &(rtmGetTPtr(DI_model_M)[0]); DI_model_M->NonInlinedSFcns.taskTimePtrs[1] = &(rtmGetTPtr(DI_model_M)[1]); rtssSetTPtrPtr(sfcnInfo,DI_model_M->NonInlinedSFcns.taskTimePtrs); rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(DI_model_M)); rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(DI_model_M)); rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(DI_model_M)); rtssSetStepSizePtr(sfcnInfo, &DI_model_M->Timing.stepSize); rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(DI_model_M)); rtssSetDerivCacheNeedsResetPtr(sfcnInfo, &DI_model_M->ModelData.derivCacheNeedsReset); rtssSetZCCacheNeedsResetPtr(sfcnInfo, &DI_model_M->ModelData.zCCacheNeedsReset); rtssSetBlkStateChangePtr(sfcnInfo, &DI_model_M->ModelData.blkStateChange); rtssSetSampleHitsPtr(sfcnInfo, &DI_model_M->Timing.sampleHits); rtssSetPerTaskSampleHitsPtr(sfcnInfo, &DI_model_M->Timing.perTaskSampleHits); rtssSetSimModePtr(sfcnInfo, &DI_model_M->simMode); rtssSetSolverInfoPtr(sfcnInfo, &DI_model_M->solverInfoPtr); } DI_model_M->Sizes.numSFcns = (1); /* register each child */ { (void) memset((void *)&DI_model_M->NonInlinedSFcns.childSFunctions[0], 0, 1*sizeof(SimStruct)); DI_model_M->childSfunctions = (&DI_model_M->NonInlinedSFcns.childSFunctionPtrs[0]); DI_model_M->childSfunctions[0] = (&DI_model_M->NonInlinedSFcns.childSFunctions[0]); /* Level2 S-Function Block: DI_model/<Root>/S-Function (DI_v1) */ { SimStruct *rts = DI_model_M->childSfunctions[0]; /* timing info */ time_T *sfcnPeriod = DI_model_M->NonInlinedSFcns.Sfcn0.sfcnPeriod; time_T *sfcnOffset = DI_model_M->NonInlinedSFcns.Sfcn0.sfcnOffset; int_T *sfcnTsMap = DI_model_M->NonInlinedSFcns.Sfcn0.sfcnTsMap; (void) memset((void*)sfcnPeriod, 0, sizeof(time_T)*1); (void) memset((void*)sfcnOffset, 0, sizeof(time_T)*1); ssSetSampleTimePtr(rts, &sfcnPeriod[0]); ssSetOffsetTimePtr(rts, &sfcnOffset[0]); ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap); /* Set up the mdlInfo pointer */ { ssSetBlkInfo2Ptr(rts, &DI_model_M->NonInlinedSFcns.blkInfo2[0]); } ssSetRTWSfcnInfo(rts, DI_model_M->sfcnInfo); /* Allocate memory of model methods 2 */ { ssSetModelMethods2(rts, &DI_model_M->NonInlinedSFcns.methods2[0]); } /* Allocate memory of model methods 3 */ { ssSetModelMethods3(rts, &DI_model_M->NonInlinedSFcns.methods3[0]); } /* Allocate memory for states auxilliary information */ { ssSetStatesInfo2(rts, &DI_model_M->NonInlinedSFcns.statesInfo2[0]); } /* inputs */ { _ssSetNumInputPorts(rts, 1); ssSetPortInfoForInputs(rts, &DI_model_M->NonInlinedSFcns.Sfcn0.inputPortInfo[0]); /* port 0 */ { ssSetInputPortRequiredContiguous(rts, 0, 1); ssSetInputPortSignal(rts, 0, (real_T*)&DI_model_RGND); _ssSetInputPortNumDimensions(rts, 0, 1); ssSetInputPortWidth(rts, 0, 1); } } /* path info */ ssSetModelName(rts, "S-Function"); ssSetPath(rts, "DI_model/S-Function"); ssSetRTModel(rts,DI_model_M); ssSetParentSS(rts, (NULL)); ssSetRootSS(rts, rts); ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2); /* registration */ DI_v1(rts); sfcnInitializeSizes(rts); sfcnInitializeSampleTimes(rts); /* adjust sample time */ ssSetSampleTime(rts, 0, 0.0); ssSetOffsetTime(rts, 0, 0.0); sfcnTsMap[0] = 0; /* set compiled values of dynamic vector attributes */ ssSetNumNonsampledZCs(rts, 0); /* Update connectivity flags for each port */ _ssSetInputPortConnected(rts, 0, 0); /* Update the BufferDstPort flags for each input port */ ssSetInputPortBufferDstPort(rts, 0, -1); } } /* Initialize Sizes */ DI_model_M->Sizes.numContStates = (0);/* Number of continuous states */ DI_model_M->Sizes.numY = (0); /* Number of model outputs */ DI_model_M->Sizes.numU = (0); /* Number of model inputs */ DI_model_M->Sizes.sysDirFeedThru = (0);/* The model is not direct feedthrough */ DI_model_M->Sizes.numSampTimes = (2);/* Number of sample times */ DI_model_M->Sizes.numBlocks = (1); /* Number of blocks */ return DI_model_M; }
/* Function: mdlInitializeSizes =============================================== * Abstract: * Setup sizes of the various vectors. */ static void mdlInitializeSizes(SimStruct *S) { DECL_AND_INIT_DIMSINFO(inputDimsInfo); DECL_AND_INIT_DIMSINFO(outputDimsInfo); ssSetNumSFcnParams(S, NPARAMS); /* Number of expected parameters */ #if defined(MATLAB_MEX_FILE) if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) { mdlCheckParameters(S); if (ssGetErrorStatus(S) != NULL) { return; } } else { return; /* Parameter mismatch will be reported by Simulink */ } #endif ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetNumContStates(S, NUM_CONT_STATES); ssSetNumDiscStates(S, NUM_DISC_STATES); if (!ssSetNumInputPorts(S, NUM_INPUTS)) return; /*Input Port 0 */ ssSetInputPortWidth(S, 0, INPUT_0_WIDTH); /* */ ssSetInputPortDataType(S, 0, SS_DOUBLE); ssSetInputPortComplexSignal(S, 0, INPUT_0_COMPLEX); ssSetInputPortDirectFeedThrough(S, 0, INPUT_0_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/ /*Input Port 1 */ ssSetInputPortWidth(S, 1, INPUT_1_WIDTH); /* */ ssSetInputPortDataType(S, 1, SS_DOUBLE); ssSetInputPortComplexSignal(S, 1, INPUT_1_COMPLEX); ssSetInputPortDirectFeedThrough(S, 1, INPUT_1_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 1, 1); /*direct input signal access*/ /*Input Port 2 */ ssSetInputPortWidth(S, 2, INPUT_2_WIDTH); /* */ ssSetInputPortDataType(S, 2, SS_DOUBLE); ssSetInputPortComplexSignal(S, 2, INPUT_2_COMPLEX); ssSetInputPortDirectFeedThrough(S, 2, INPUT_2_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 2, 1); /*direct input signal access*/ /*Input Port 3 */ ssSetInputPortWidth(S, 3, INPUT_3_WIDTH); /* */ ssSetInputPortDataType(S, 3, SS_DOUBLE); ssSetInputPortComplexSignal(S, 3, INPUT_3_COMPLEX); ssSetInputPortDirectFeedThrough(S, 3, INPUT_3_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 3, 1); /*direct input signal access*/ /*Input Port 4 */ ssSetInputPortWidth(S, 4, INPUT_4_WIDTH); /* */ ssSetInputPortDataType(S, 4, SS_DOUBLE); ssSetInputPortComplexSignal(S, 4, INPUT_4_COMPLEX); ssSetInputPortDirectFeedThrough(S, 4, INPUT_4_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 4, 1); /*direct input signal access*/ if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return; /* Output Port 0 */ ssSetOutputPortWidth(S, 0, OUTPUT_0_WIDTH); ssSetOutputPortDataType(S, 0, SS_DOUBLE); ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_WORKS_WITH_CODE_REUSE)); }
/* Function: mdlInitializeSizes =============================================== * Abstract: * 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 */ inputDimsInfo.width = INPUT_0_WIDTH; ssSetInputPortDimensionInfo(S, 0, &inputDimsInfo); ssSetInputPortMatrixDimensions( S , 0, INPUT_0_WIDTH, INPUT_DIMS_0_COL); 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*/ /*Input Port 1 */ inputDimsInfo.width = INPUT_1_WIDTH; ssSetInputPortDimensionInfo(S, 1, &inputDimsInfo); ssSetInputPortMatrixDimensions( S , 1, INPUT_1_WIDTH, INPUT_DIMS_1_COL); ssSetInputPortFrameData(S, 1, IN_1_FRAME_BASED); 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 */ inputDimsInfo.width = INPUT_2_WIDTH; ssSetInputPortDimensionInfo(S, 2, &inputDimsInfo); ssSetInputPortMatrixDimensions( S , 2, INPUT_2_WIDTH, INPUT_DIMS_2_COL); ssSetInputPortFrameData(S, 2, IN_2_FRAME_BASED); 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 */ inputDimsInfo.width = INPUT_3_WIDTH; ssSetInputPortDimensionInfo(S, 3, &inputDimsInfo); ssSetInputPortMatrixDimensions( S , 3, INPUT_3_WIDTH, INPUT_DIMS_3_COL); ssSetInputPortFrameData(S, 3, IN_3_FRAME_BASED); 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 */ inputDimsInfo.width = INPUT_4_WIDTH; ssSetInputPortDimensionInfo(S, 4, &inputDimsInfo); ssSetInputPortMatrixDimensions( S , 4, INPUT_4_WIDTH, INPUT_DIMS_4_COL); ssSetInputPortFrameData(S, 4, IN_4_FRAME_BASED); 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*/ /*Input Port 6 */ ssSetInputPortWidth(S, 6, INPUT_6_WIDTH); /* */ ssSetInputPortDataType(S, 6, SS_DOUBLE); ssSetInputPortComplexSignal(S, 6, INPUT_6_COMPLEX); ssSetInputPortDirectFeedThrough(S, 6, INPUT_6_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 6, 1); /*direct input signal access*/ /*Input Port 7 */ inputDimsInfo.width = INPUT_7_WIDTH; ssSetInputPortDimensionInfo(S, 7, &inputDimsInfo); ssSetInputPortMatrixDimensions( S ,7, INPUT_7_WIDTH, INPUT_DIMS_7_COL); ssSetInputPortFrameData(S, 7, IN_7_FRAME_BASED); ssSetInputPortDataType(S, 7, SS_DOUBLE); ssSetInputPortComplexSignal(S, 7, INPUT_7_COMPLEX); ssSetInputPortDirectFeedThrough(S, 7, INPUT_7_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 7, 1); /*direct input signal access*/ /*Input Port 8 */ inputDimsInfo.width = INPUT_8_WIDTH; ssSetInputPortDimensionInfo(S, 8, &inputDimsInfo); ssSetInputPortMatrixDimensions( S ,8, INPUT_8_WIDTH, INPUT_DIMS_8_COL); ssSetInputPortFrameData(S, 8, IN_8_FRAME_BASED); ssSetInputPortDataType(S, 8, SS_DOUBLE); ssSetInputPortComplexSignal(S, 8, INPUT_8_COMPLEX); ssSetInputPortDirectFeedThrough(S, 8, INPUT_8_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 8, 1); /*direct input signal access*/ /*Input Port 9 */ inputDimsInfo.width = INPUT_9_WIDTH; ssSetInputPortDimensionInfo(S, 9, &inputDimsInfo); ssSetInputPortMatrixDimensions( S ,9, INPUT_9_WIDTH, INPUT_DIMS_9_COL); ssSetInputPortFrameData(S, 9, IN_9_FRAME_BASED); ssSetInputPortDataType(S, 9, SS_DOUBLE); ssSetInputPortComplexSignal(S, 9, INPUT_9_COMPLEX); ssSetInputPortDirectFeedThrough(S, 9, INPUT_9_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 9, 1); /*direct input signal access*/ /*Input Port 10 */ inputDimsInfo.width = INPUT_10_WIDTH; ssSetInputPortDimensionInfo(S, 10, &inputDimsInfo); ssSetInputPortMatrixDimensions( S ,10, INPUT_10_WIDTH, INPUT_DIMS_10_COL); ssSetInputPortFrameData(S, 10, IN_10_FRAME_BASED); ssSetInputPortDataType(S, 10, SS_UINT8); ssSetInputPortComplexSignal(S, 10, INPUT_10_COMPLEX); ssSetInputPortDirectFeedThrough(S, 10, INPUT_10_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 10, 1); /*direct input signal access*/ /*Input Port 11 */ inputDimsInfo.width = INPUT_11_WIDTH; ssSetInputPortDimensionInfo(S, 11, &inputDimsInfo); ssSetInputPortMatrixDimensions( S ,11, INPUT_11_WIDTH, INPUT_DIMS_11_COL); ssSetInputPortFrameData(S, 11, IN_11_FRAME_BASED); ssSetInputPortDataType(S, 11, SS_UINT8); ssSetInputPortComplexSignal(S, 11, INPUT_11_COMPLEX); ssSetInputPortDirectFeedThrough(S, 11, INPUT_11_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 11, 1); /*direct input signal access*/ /*Input Port 12 */ inputDimsInfo.width = INPUT_12_WIDTH; ssSetInputPortDimensionInfo(S, 12, &inputDimsInfo); ssSetInputPortMatrixDimensions( S ,12, INPUT_12_WIDTH, INPUT_DIMS_12_COL); ssSetInputPortFrameData(S, 12, IN_12_FRAME_BASED); ssSetInputPortDataType(S, 12, SS_UINT8); ssSetInputPortComplexSignal(S, 12, INPUT_12_COMPLEX); ssSetInputPortDirectFeedThrough(S, 12, INPUT_12_FEEDTHROUGH); ssSetInputPortRequiredContiguous(S, 12, 1); /*direct input signal access*/ if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return; 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)); }
/* Model initialize function */ void testSHM_initialize(boolean_T firstTime) { (void)firstTime; /* Registration code */ /* initialize non-finites */ rt_InitInfAndNaN(sizeof(real_T)); /* initialize real-time model */ (void) memset((void *)testSHM_M,0, sizeof(RT_MODEL_testSHM)); rtsiSetSolverName(&testSHM_M->solverInfo,"FixedStepDiscrete"); testSHM_M->solverInfoPtr = (&testSHM_M->solverInfo); /* Initialize timing info */ { int_T *mdlTsMap = testSHM_M->Timing.sampleTimeTaskIDArray; mdlTsMap[0] = 0; testSHM_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]); testSHM_M->Timing.sampleTimes = (&testSHM_M->Timing.sampleTimesArray[0]); testSHM_M->Timing.offsetTimes = (&testSHM_M->Timing.offsetTimesArray[0]); /* task periods */ testSHM_M->Timing.sampleTimes[0] = (0.001); /* task offsets */ testSHM_M->Timing.offsetTimes[0] = (0.0); } rtmSetTPtr(testSHM_M, &testSHM_M->Timing.tArray[0]); { int_T *mdlSampleHits = testSHM_M->Timing.sampleHitArray; mdlSampleHits[0] = 1; testSHM_M->Timing.sampleHits = (&mdlSampleHits[0]); } rtmSetTFinal(testSHM_M, 10.0); testSHM_M->Timing.stepSize0 = 0.001; /* Setup for data logging */ { static RTWLogInfo rt_DataLoggingInfo; testSHM_M->rtwLogInfo = &rt_DataLoggingInfo; rtliSetLogXSignalInfo(testSHM_M->rtwLogInfo, (NULL)); rtliSetLogXSignalPtrs(testSHM_M->rtwLogInfo, (NULL)); rtliSetLogT(testSHM_M->rtwLogInfo, "tout"); rtliSetLogX(testSHM_M->rtwLogInfo, ""); rtliSetLogXFinal(testSHM_M->rtwLogInfo, ""); rtliSetSigLog(testSHM_M->rtwLogInfo, ""); rtliSetLogVarNameModifier(testSHM_M->rtwLogInfo, "rt_"); rtliSetLogFormat(testSHM_M->rtwLogInfo, 0); rtliSetLogMaxRows(testSHM_M->rtwLogInfo, 1000); rtliSetLogDecimation(testSHM_M->rtwLogInfo, 1); rtliSetLogY(testSHM_M->rtwLogInfo, ""); rtliSetLogYSignalInfo(testSHM_M->rtwLogInfo, (NULL)); rtliSetLogYSignalPtrs(testSHM_M->rtwLogInfo, (NULL)); } testSHM_M->solverInfoPtr = (&testSHM_M->solverInfo); testSHM_M->Timing.stepSize = (0.001); rtsiSetFixedStepSize(&testSHM_M->solverInfo, 0.001); rtsiSetSolverMode(&testSHM_M->solverInfo, SOLVER_MODE_SINGLETASKING); /* block I/O */ testSHM_M->ModelData.blockIO = ((void *) &testSHM_B); (void) memset(((void *) &testSHM_B),0, sizeof(BlockIO_testSHM)); /* parameters */ testSHM_M->ModelData.defaultParam = ((real_T *) &testSHM_P); /* states (dwork) */ testSHM_M->Work.dwork = ((void *) &testSHM_DWork); (void) memset((void *)&testSHM_DWork, 0, sizeof(D_Work_testSHM)); /* C API for Parameter Tuning and/or Signal Monitoring */ { static ModelMappingInfo mapInfo; (void) memset((char_T *) &mapInfo,0, sizeof(mapInfo)); /* block signal monitoring map */ mapInfo.Signals.blockIOSignals = &rtBIOSignals[0]; mapInfo.Signals.numBlockIOSignals = 2; /* parameter tuning maps */ mapInfo.Parameters.blockTuning = &rtBlockTuning[0]; mapInfo.Parameters.variableTuning = &rtVariableTuning[0]; mapInfo.Parameters.parametersMap = rtParametersMap; mapInfo.Parameters.dimensionsMap = rtDimensionsMap; mapInfo.Parameters.numBlockTuning = 4; mapInfo.Parameters.numVariableTuning = 0; testSHM_M->SpecialInfo.mappingInfo = (&mapInfo); } /* child S-Function registration */ { RTWSfcnInfo *sfcnInfo = &testSHM_M->NonInlinedSFcns.sfcnInfo; testSHM_M->sfcnInfo = (sfcnInfo); rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(testSHM_M))); rtssSetNumRootSampTimesPtr(sfcnInfo, &testSHM_M->Sizes.numSampTimes); rtssSetTPtrPtr(sfcnInfo, &rtmGetTPtr(testSHM_M)); rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(testSHM_M)); rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(testSHM_M)); rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(testSHM_M)); rtssSetStepSizePtr(sfcnInfo, &testSHM_M->Timing.stepSize); rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(testSHM_M)); rtssSetDerivCacheNeedsResetPtr(sfcnInfo, &testSHM_M->ModelData.derivCacheNeedsReset); rtssSetZCCacheNeedsResetPtr(sfcnInfo, &testSHM_M->ModelData.zCCacheNeedsReset); rtssSetBlkStateChangePtr(sfcnInfo, &testSHM_M->ModelData.blkStateChange); rtssSetSampleHitsPtr(sfcnInfo, &testSHM_M->Timing.sampleHits); rtssSetPerTaskSampleHitsPtr(sfcnInfo, &testSHM_M->Timing.perTaskSampleHits); rtssSetSimModePtr(sfcnInfo, &testSHM_M->simMode); rtssSetSolverInfoPtr(sfcnInfo, &testSHM_M->solverInfoPtr); } testSHM_M->Sizes.numSFcns = (2); /* register each child */ { (void) memset((void *)&testSHM_M->NonInlinedSFcns.childSFunctions[0],0, 2*sizeof(SimStruct)); testSHM_M->childSfunctions = (&testSHM_M-> NonInlinedSFcns.childSFunctionPtrs[0]); testSHM_M->childSfunctions[0] = (&testSHM_M-> NonInlinedSFcns.childSFunctions[0]); testSHM_M->childSfunctions[1] = (&testSHM_M-> NonInlinedSFcns.childSFunctions[1]); /* Level2 S-Function Block: testSHM/<Root>/S-Function (sSHM) */ { SimStruct *rts = testSHM_M->childSfunctions[0]; /* timing info */ time_T *sfcnPeriod = testSHM_M->NonInlinedSFcns.Sfcn0.sfcnPeriod; time_T *sfcnOffset = testSHM_M->NonInlinedSFcns.Sfcn0.sfcnOffset; int_T *sfcnTsMap = testSHM_M->NonInlinedSFcns.Sfcn0.sfcnTsMap; (void) memset((void*)sfcnPeriod,0, sizeof(time_T)*1); (void) memset((void*)sfcnOffset,0, sizeof(time_T)*1); ssSetSampleTimePtr(rts, &sfcnPeriod[0]); ssSetOffsetTimePtr(rts, &sfcnOffset[0]); ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap); /* Set up the mdlInfo pointer */ { ssSetBlkInfo2Ptr(rts, &testSHM_M->NonInlinedSFcns.blkInfo2[0]); ssSetRTWSfcnInfo(rts, testSHM_M->sfcnInfo); } /* Allocate memory of model methods 2 */ { ssSetModelMethods2(rts, &testSHM_M->NonInlinedSFcns.methods2[0]); } /* Allocate memory of model methods 3 */ { ssSetModelMethods3(rts, &testSHM_M->NonInlinedSFcns.methods3[0]); } /* inputs */ { _ssSetNumInputPorts(rts, 1); ssSetPortInfoForInputs(rts, &testSHM_M->NonInlinedSFcns.Sfcn0.inputPortInfo[0]); /* port 0 */ { ssSetInputPortRequiredContiguous(rts, 0, 1); ssSetInputPortSignal(rts, 0, testSHM_B.TmpHiddenBufferAtSFunctionInpor); _ssSetInputPortNumDimensions(rts, 0, 1); ssSetInputPortWidth(rts, 0, 3); } } /* outputs */ { ssSetPortInfoForOutputs(rts, &testSHM_M->NonInlinedSFcns.Sfcn0.outputPortInfo[0]); _ssSetNumOutputPorts(rts, 1); /* port 0 */ { _ssSetOutputPortNumDimensions(rts, 0, 1); ssSetOutputPortWidth(rts, 0, 3); ssSetOutputPortSignal(rts, 0, ((real_T *) testSHM_B.SFunction)); } } /* path info */ ssSetModelName(rts, "S-Function"); ssSetPath(rts, "testSHM/S-Function"); ssSetRTModel(rts,testSHM_M); ssSetParentSS(rts, (NULL)); ssSetRootSS(rts, rts); ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2); /* work vectors */ { struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) &testSHM_M->NonInlinedSFcns.Sfcn0.dWork; struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *) &testSHM_M->NonInlinedSFcns.Sfcn0.dWorkAux; ssSetSFcnDWork(rts, dWorkRecord); ssSetSFcnDWorkAux(rts, dWorkAuxRecord); _ssSetNumDWork(rts, 2); /* DWORK1 */ ssSetDWorkWidth(rts, 0, 1); ssSetDWorkDataType(rts, 0,SS_POINTER); ssSetDWorkComplexSignal(rts, 0, 0); ssSetDWork(rts, 0, &testSHM_DWork.SFunction_DWORK1); /* DWORK2 */ ssSetDWorkWidth(rts, 1, 1); ssSetDWorkDataType(rts, 1,SS_POINTER); ssSetDWorkComplexSignal(rts, 1, 0); ssSetDWork(rts, 1, &testSHM_DWork.SFunction_DWORK2); } /* registration */ sSHM(rts); sfcnInitializeSizes(rts); sfcnInitializeSampleTimes(rts); /* adjust sample time */ ssSetSampleTime(rts, 0, 0.001); ssSetOffsetTime(rts, 0, 0.0); sfcnTsMap[0] = 0; /* set compiled values of dynamic vector attributes */ ssSetNumNonsampledZCs(rts, 0); /* Update connectivity flags for each port */ _ssSetInputPortConnected(rts, 0, 1); _ssSetOutputPortConnected(rts, 0, 1); _ssSetOutputPortBeingMerged(rts, 0, 0); /* Update the BufferDstPort flags for each input port */ ssSetInputPortBufferDstPort(rts, 0, -1); } /* Level2 S-Function Block: testSHM/<Root>/RTAI_SCOPE (sfun_rtai_scope) */ { SimStruct *rts = testSHM_M->childSfunctions[1]; /* timing info */ time_T *sfcnPeriod = testSHM_M->NonInlinedSFcns.Sfcn1.sfcnPeriod; time_T *sfcnOffset = testSHM_M->NonInlinedSFcns.Sfcn1.sfcnOffset; int_T *sfcnTsMap = testSHM_M->NonInlinedSFcns.Sfcn1.sfcnTsMap; (void) memset((void*)sfcnPeriod,0, sizeof(time_T)*1); (void) memset((void*)sfcnOffset,0, sizeof(time_T)*1); ssSetSampleTimePtr(rts, &sfcnPeriod[0]); ssSetOffsetTimePtr(rts, &sfcnOffset[0]); ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap); /* Set up the mdlInfo pointer */ { ssSetBlkInfo2Ptr(rts, &testSHM_M->NonInlinedSFcns.blkInfo2[1]); ssSetRTWSfcnInfo(rts, testSHM_M->sfcnInfo); } /* Allocate memory of model methods 2 */ { ssSetModelMethods2(rts, &testSHM_M->NonInlinedSFcns.methods2[1]); } /* Allocate memory of model methods 3 */ { ssSetModelMethods3(rts, &testSHM_M->NonInlinedSFcns.methods3[1]); } /* inputs */ { _ssSetNumInputPorts(rts, 3); ssSetPortInfoForInputs(rts, &testSHM_M->NonInlinedSFcns.Sfcn1.inputPortInfo[0]); /* port 0 */ { real_T const **sfcnUPtrs = (real_T const **) &testSHM_M->NonInlinedSFcns.Sfcn1.UPtrs0; sfcnUPtrs[0] = &testSHM_B.SFunction[0]; ssSetInputPortSignalPtrs(rts, 0, (InputPtrsType)&sfcnUPtrs[0]); _ssSetInputPortNumDimensions(rts, 0, 1); ssSetInputPortWidth(rts, 0, 1); } /* port 1 */ { real_T const **sfcnUPtrs = (real_T const **) &testSHM_M->NonInlinedSFcns.Sfcn1.UPtrs1; sfcnUPtrs[0] = &testSHM_B.SFunction[1]; ssSetInputPortSignalPtrs(rts, 1, (InputPtrsType)&sfcnUPtrs[0]); _ssSetInputPortNumDimensions(rts, 1, 1); ssSetInputPortWidth(rts, 1, 1); } /* port 2 */ { real_T const **sfcnUPtrs = (real_T const **) &testSHM_M->NonInlinedSFcns.Sfcn1.UPtrs2; sfcnUPtrs[0] = &testSHM_B.SFunction[2]; ssSetInputPortSignalPtrs(rts, 2, (InputPtrsType)&sfcnUPtrs[0]); _ssSetInputPortNumDimensions(rts, 2, 1); ssSetInputPortWidth(rts, 2, 1); } } /* path info */ ssSetModelName(rts, "RTAI_SCOPE"); ssSetPath(rts, "testSHM/RTAI_SCOPE"); ssSetRTModel(rts,testSHM_M); ssSetParentSS(rts, (NULL)); ssSetRootSS(rts, rts); ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2); /* parameters */ { mxArray **sfcnParams = (mxArray **) &testSHM_M->NonInlinedSFcns.Sfcn1.params; ssSetSFcnParamsCount(rts, 2); ssSetSFcnParamsPtr(rts, &sfcnParams[0]); ssSetSFcnParam(rts, 0, (mxArray*)&testSHM_P.RTAI_SCOPE_P1_Size[0]); ssSetSFcnParam(rts, 1, (mxArray*)&testSHM_P.RTAI_SCOPE_P2_Size[0]); } /* work vectors */ ssSetPWork(rts, (void **) &testSHM_DWork.RTAI_SCOPE_PWORK); { struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) &testSHM_M->NonInlinedSFcns.Sfcn1.dWork; struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *) &testSHM_M->NonInlinedSFcns.Sfcn1.dWorkAux; ssSetSFcnDWork(rts, dWorkRecord); ssSetSFcnDWorkAux(rts, dWorkAuxRecord); _ssSetNumDWork(rts, 1); /* PWORK */ ssSetDWorkWidth(rts, 0, 1); ssSetDWorkDataType(rts, 0,SS_POINTER); ssSetDWorkComplexSignal(rts, 0, 0); ssSetDWork(rts, 0, &testSHM_DWork.RTAI_SCOPE_PWORK); } /* registration */ sfun_rtai_scope(rts); sfcnInitializeSizes(rts); sfcnInitializeSampleTimes(rts); /* adjust sample time */ ssSetSampleTime(rts, 0, 0.001); ssSetOffsetTime(rts, 0, 0.0); sfcnTsMap[0] = 0; /* set compiled values of dynamic vector attributes */ ssSetNumNonsampledZCs(rts, 0); /* Update connectivity flags for each port */ _ssSetInputPortConnected(rts, 0, 1); _ssSetInputPortConnected(rts, 1, 1); _ssSetInputPortConnected(rts, 2, 1); /* Update the BufferDstPort flags for each input port */ ssSetInputPortBufferDstPort(rts, 0, -1); ssSetInputPortBufferDstPort(rts, 1, -1); ssSetInputPortBufferDstPort(rts, 2, -1); } } }
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 ) ; }