static void mdlSetInputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo) { boolean_T isNotVector = ((dimsInfo->numDims == 2 ) && (dimsInfo->dims[0] > 1 && dimsInfo->dims[1] > 1)) ; if(isNotVector){ ssSetErrorStatus(S, "The block only accepts vector signals. " "It does not accept a [mxn] matrix signal " "where m > 1 and n > 1."); }else{ int otherPort = (port == 0) ? 1 : 0; if(!ssSetInputPortDimensionInfo(S, port, dimsInfo)) return; /* * If other port width is unknown, set the other port width. * Note1: we cannot update other port dimension info. * Note2: For simplicity, this block cannot accept partial dimension, * however, it may partially set other port dimension info. */ if(ssGetInputPortWidth(S, otherPort) == DYNAMICALLY_SIZED && ssGetInputPortWidth(S, port) != DYNAMICALLY_SIZED){ DECL_AND_INIT_DIMSINFO(dimsInfo); dimsInfo.width = ssGetInputPortWidth (S, port); dimsInfo.numDims = ssGetInputPortNumDimensions(S, otherPort); dimsInfo.dims = ssGetInputPortDimensions (S, otherPort); if(!ssSetInputPortDimensionInfo(S, otherPort, &dimsInfo)) return; } } }
static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, NUM_PARAMS); if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) return; /* Inputs: */ if (!ssSetNumInputPorts(S, 2)) return; ssSetInputPortDataType(S, 0, DYNAMICALLY_TYPED); ssSetInputPortDataType(S, 1, DYNAMICALLY_TYPED); if(!ssSetInputPortDimensionInfo(S, 0, DYNAMIC_DIMENSION)) return; if(!ssSetInputPortDimensionInfo(S, 1, DYNAMIC_DIMENSION)) return; ssSetInputPortFrameData(S, 0, FRAME_INHERITED); ssSetInputPortFrameData(S, 1, FRAME_INHERITED); ssSetInputPortComplexSignal(S, 0, COMPLEX_INHERITED); ssSetInputPortComplexSignal(S, 1, COMPLEX_INHERITED); ssSetInputPortDirectFeedThrough(S, 0, 1); ssSetInputPortDirectFeedThrough(S, 1, 1); ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL); ssSetInputPortOverWritable(S, 0, 1); ssSetInputPortOverWritable(S, 1, 1); /* Outputs: */ if (!ssSetNumOutputPorts(S, 1)) return; ssSetOutputPortDataType(S, 0, DYNAMICALLY_TYPED); if(!ssSetOutputPortVectorDimension(S, 0, 1)) return; ssSetOutputPortFrameData(S, 0, FRAME_NO); ssSetOutputPortComplexSignal(S, 0, COMPLEX_INHERITED); ssSetOutputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL); ssSetNumSampleTimes(S, 1); /* specify the sim state compliance to be same as a built-in block */ ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE); ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_CAN_BE_CALLED_CONDITIONALLY | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_NONVOLATILE); }
/* Function: 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*/ if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return; ssSetOutputPortWidth(S, 0, OUTPUT_0_WIDTH); ssSetOutputPortDataType(S, 0, SS_INT32); ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX); ssSetNumSampleTimes(S, 1); ssSetNumRWork(S, 0); ssSetNumIWork(S, 0); ssSetNumPWork(S, 0); ssSetNumModes(S, 0); ssSetNumNonsampledZCs(S, 0); /* Take care when specifying exception free code - see sfuntmpl_doc.c */ ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_WORKS_WITH_CODE_REUSE)); }
static void mdlSetOutputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo) { # ifdef DEBUG printf(" co_udp_receiver :: Now in mdlSetOutputPortDimensionInfo.\n"); # endif /* * If the block has scalar parameter, the output dimensions are unknown. * Set the input and output port to have the same dimensions. */ if(!ssSetOutputPortDimensionInfo(S, port, dimsInfo)) return; /* The block only accepts 2-D signals. Check number of dimensions. */ if(dimsInfo->numDims != 1) { ssSetErrorStatus(S, "Invalid output port dimensions. The output signal " "must be a vector signal."); return; } else { /* Set the input port dimensions */ if(!ssSetInputPortDimensionInfo(S, port, dimsInfo)) return; } }
static void mdlSetInputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo) { //TODO: for now accept the proposed size. //If we want to change the behaviour we have to implement some callbacks ssSetInputPortDimensionInfo(S, port, dimsInfo); }
void mdlSetOutputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo) { if (port == 0) { ssSetOutputPortDimensionInfo(S, port,dimsInfo); ssSetInputPortDimensionInfo(S, port,dimsInfo); } } /* end mdlSetOutputPortDimensionInfo */
/* Function: mdlSetInputPortDimensionInfo ================================= * Abstract: * This method is called with the candidate dimensions for an input port * with unknown dimensions. If the proposed dimensions are acceptable, the * method should go ahead and set the actual port dimensions. * If they are unacceptable an error should be generated via * ssSetErrorStatus. * Note that any other input or output ports whose dimensions are * implicitly defined by virtue of knowing the dimensions of the given * port can also have their dimensions set. * */ static void mdlSetInputPortDimensionInfo(SimStruct *S, int_T portIndex, const DimsInfo_T *dimsInfo) { /* /* Set input port dimension */ if(!ssSetInputPortDimensionInfo(S, portIndex, dimsInfo)) return; }
void mdlSetInputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo) /* ========================================================================*/ { if (dimsInfo->numDims >= 2 && dimsInfo->dims[1] > 1) ssSetErrorStatus(S, "Wrong port dimensions") else if (BUFFER_SIZE / BYTES_PER_SAMPLE % dimsInfo->dims[0]) ssSetErrorStatus(S, "Frame size must be a power of two (<= 2^18)") else ssSetInputPortDimensionInfo(S, port, dimsInfo); }
void mdlSetInputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo) { if (port == 0) { /* Set the size for all dynamic ports using dimsInfo */ ssSetInputPortDimensionInfo(S, port,dimsInfo); ssSetOutputPortDimensionInfo(S, port, dimsInfo); } else { return; } } /*mdlSetInputPortDimensionInfo */
static void mdlSetInputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo) { if (dimsInfo->numDims != 2 || dimsInfo->dims[0] != 3) { std::stringstream ss; ss << "Input port " << port << " should be a 3xN matrix."; ssSetErrorStatus(S, ss.str().c_str()); return; } if (!ssSetInputPortDimensionInfo(S, port, dimsInfo)) return; }
/* 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: mdlSetInputPortDimensionInfo ==================================== */ static void mdlSetInputPortDimensionInfo(SimStruct *S, int_T portIndex, const DimsInfo_T *dimsInfo) { int outPortWidth = 0; if(!ssSetInputPortDimensionInfo(S, portIndex, dimsInfo)) return; outPortWidth = ssGetOutputPortWidth( S, 0 ); if ( outPortWidth == DYNAMICALLY_SIZED ) { if(!ssSetOutputPortDimensionInfo(S, 0, dimsInfo)) return; } else if ( outPortWidth != dimsInfo->width ) { ssSetErrorStatus(S,"Input port width not compatible with output port width."); } } /* mdlSetInputPortDimensionInfo */
/* Function: mdlInitializeSizes =========================================*/ static void mdlInitializeSizes(SimStruct *S) { ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; } /* Register the number and type of states the S-Function uses */ ssSetNumContStates( S, 0); /* number of continuous states */ ssSetNumDiscStates( S, 0); /* number of discrete states */ ssAllowSignalsWithMoreThan2D(S); /* * Configure the input ports. First set the number of input ports. */ if (!ssSetNumInputPorts(S, 1)) return; if(!ssSetInputPortDimensionInfo(S, 0, DYNAMIC_DIMENSION)) return; ssSetInputPortDataType(S, 0, DYNAMICALLY_TYPED); ssSetInputPortDirectFeedThrough(S, 0, 1); /* * Configure the output ports. First set the number of output ports. */ if (!ssSetNumOutputPorts(S, 1)) return; if(!ssSetOutputPortDimensionInfo(S,0,DYNAMIC_DIMENSION)) return; ssSetOutputPortDataType(S, 0, DYNAMICALLY_TYPED); ssSetNumSampleTimes(S, PORT_BASED_SAMPLE_TIMES); ssSetInputPortSampleTime(S, 0, INHERITED_SAMPLE_TIME); ssSetOutputPortSampleTime(S, 0, INHERITED_SAMPLE_TIME); /* * Set size of the work vectors. */ ssSetNumRWork( S, 0); /* number of real work vector elements */ ssSetNumIWork( S, 0); /* number of integer work vector elements*/ ssSetNumPWork( S, 0); /* number of pointer work vector elements*/ ssSetNumModes( S, 0); /* number of mode work vector elements */ ssSetNumNonsampledZCs( S, 0); /* number of non-sampled zero crossings */ ssSetOptions(S, 0); /* general options (SS_OPTION_xx) */ } /* end mdlInitializeSizes */
void mdlSetDefaultPortDimensionInfo(SimStruct *S) { DECL_AND_INIT_DIMSINFO(dimsInfo); /* Either 2nd input or 2nd output should be already known */ if (ssGetOutputPortWidth(S, 0) != DYNAMICALLY_SIZED) { /* It is the output that is known, get the dimensions first */ dimsInfo.width = ssGetOutputPortWidth(S, 0); dimsInfo.numDims = ssGetOutputPortNumDimensions(S, 0); dimsInfo.dims = ssGetOutputPortDimensions(S, 0); /*set second input, first output if unknown */ if (ssGetInputPortWidth(S, 0) == DYNAMICALLY_SIZED) { if(!ssSetInputPortDimensionInfo(S, 0, &dimsInfo)) return; } return; } else { if (ssGetInputPortWidth(S, 0) != DYNAMICALLY_SIZED) { /* It is the input that is known, get the dimensions */ dimsInfo.width = ssGetInputPortWidth(S, 0); dimsInfo.numDims = ssGetInputPortNumDimensions(S, 0); dimsInfo.dims = ssGetInputPortDimensions(S, 0); /*set first and second output if unknown */ if (ssGetOutputPortWidth(S, 0) == DYNAMICALLY_SIZED) { if(!ssSetOutputPortDimensionInfo(S, 0, &dimsInfo)) return; } return; } else { /* Default everything to a scalar signal */ ssSetOutputPortVectorDimension(S, 0, 1); ssSetInputPortVectorDimension(S, 0, 1); return; } } } /* end mdlSetDefaultPortDimensionInfo */
static void mdlSetDefaultPortDimensionInfo(SimStruct *S) { DECL_AND_INIT_DIMSINFO(portDimsInfo); int_T dims[2] = { INPUT_0_WIDTH, 1 }; bool frameIn = ssGetInputPortFrameData(S, 0) == FRAME_YES; /* Neither the input nor the output ports have been set */ portDimsInfo.width = INPUT_0_WIDTH; portDimsInfo.numDims = frameIn ? 2 : 1; portDimsInfo.dims = frameIn ? dims : &portDimsInfo.width; if (ssGetInputPortNumDimensions(S, 0) == (-1)) { ssSetInputPortDimensionInfo(S, 0, &portDimsInfo); } portDimsInfo.width = OUTPUT_0_WIDTH; dims[0] = OUTPUT_0_WIDTH; dims[1] = 1; portDimsInfo.dims = frameIn ? dims : &portDimsInfo.width; if (ssGetOutputPortNumDimensions(S, 0) == (-1)) { ssSetOutputPortDimensionInfo(S, 0, &portDimsInfo); } return; }
static void mdlSetInputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo) { int_T uNumDims = dimsInfo->numDims; int_T uWidth = dimsInfo->width; int_T *uDims = dimsInfo->dims; boolean_T isOk = true; /* Set input port dimension */ if(!ssSetInputPortDimensionInfo(S, port, dimsInfo)) return; /* * The block only accepts 2-D signals. Check number of dimensions. * If the parameter and the input signal are non-scalar, their dimensions * must be the same. */ #ifdef XXX if (port==0) { isOk = ((uNumDims == 1) && (uDims[0]==24)) ; if(!isOk) { printf("%d, %d, \n", uNumDims, uDims[0]); /*ssSetErrorStatus(S, "Invalid input port dimensions. The input must be " "a 24 vector."); return;*/ } else { /* Set the output port dimensions */ /*ssSetOutputPortWidth(S, 0, uDims[0]);*/ } } #endif }
static void mdlSetInputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo) { if(!ssSetInputPortDimensionInfo(S, port, dimsInfo)) return; }
/* 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)); }
/* 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 nOutputPorts = 1; /* number of output ports */ int_T needsInput = 1; /* direct feed through */ int_T inputPortIdx = 0; int_T outputPortIdx = 0; ssSetNumSFcnParams(S, 0); /* Number of expected parameters */ if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) { return; } if (ssGetErrorStatus(S) != NULL) return; /* Register the number and type of states the S-Function uses */ ssSetNumContStates( S, 0); /* number of continuous states */ ssSetNumDiscStates( S, 0); /* number of discrete states */ /* * Configure the input ports. First set the number of input ports. */ if (!ssSetNumInputPorts(S, nInputPorts)) return; if(!ssSetInputPortDimensionInfo(S, inputPortIdx, DYNAMIC_DIMENSION)) return; ssSetInputPortWidth(S, inputPortIdx, DYNAMICALLY_SIZED); ssSetInputPortRequiredContiguous(S, inputPortIdx, TRUE); /*direct input signal access*/ ssSetInputPortDataType(S, inputPortIdx,DYNAMICALLY_TYPED); ssSetInputPortDirectFeedThrough(S, inputPortIdx,TRUE); ssSetInputPortOverWritable(S, inputPortIdx, FALSE); ssSetInputPortReusable(S, inputPortIdx,TRUE); ssSetInputPortComplexSignal( S, inputPortIdx, COMPLEX_INHERITED); /* * Configure the output ports. First set the number of output ports. */ if (!ssSetNumOutputPorts(S, nOutputPorts)) return; if(!ssSetOutputPortDimensionInfo(S,outputPortIdx,DYNAMIC_DIMENSION)) return; ssSetOutputPortWidth(S, outputPortIdx, DYNAMICALLY_SIZED); /* register data type */ ssSetOutputPortDataType( S, outputPortIdx, DYNAMICALLY_TYPED ); ssSetOutputPortReusable( S, outputPortIdx, TRUE); ssSetOutputPortComplexSignal(S, outputPortIdx, COMPLEX_INHERITED ); ssSetNumSampleTimes( S, 1); /* number of sample times */ /* * Set size of the work vectors. */ ssSetNumRWork( S, 0); /* number of real work vector elements */ ssSetNumIWork( S, 0); /* number of integer work vector elements*/ ssSetNumPWork( S, 0); /* number of pointer work vector elements*/ ssSetNumModes( S, 0); /* number of mode work vector elements */ ssSetNumNonsampledZCs( S, 0); /* number of nonsampled zero crossings */ ssSetOptions( S, 0); /* general options (SS_OPTION_xx) */ ssFxpSetU32BitRegionCompliant(S, 1); } /* end mdlInitializeSizes */