自学教程：C++ ssSetNumContStates函数代码示例

/* 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, 4);  /* 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    int_T nRobots = mxGetNumberOfElements(ssGetSFcnParam(S,2));    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 0)) return;    //ssSetInputPortWidth(S, 0, 1);    //ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/    /*     * Set direct feedthrough flag (1=yes, 0=no).     * A port has direct feedthrough if the input is used in either     * the mdlOutputs or mdlGetTimeOfNextVarHit functions.     * See matlabroot/simulink/src/sfuntmpl_directfeed.txt.     */    //ssSetInputPortDirectFeedThrough(S, 0, 1);    if (!ssSetNumOutputPorts(S, 2)) return;    ssSetOutputPortMatrixDimensions(S, 0, 4, nRobots); // forces    ssSetOutputPortMatrixDimensions(S, 1, 1, nRobots); // SentTime in s;    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);     ssSetNumIWork(S, 1); // nRobots    ssSetNumPWork(S, nRobots + 1); //nRobots x GenericSub, AsyncSpinner    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(outputDimsInfo);    ssSetNumSFcnParams(S, NPARAMS);     if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {	 return; /* Parameter mismatch will be reported by Simulink */     }    ssSetNumContStates(S, NUM_CONT_STATES);    ssSetNumDiscStates(S, NUM_DISC_STATES);    if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;    if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;    /* Output Port 0 */    outputDimsInfo.width = OUTPUT_0_WIDTH;    ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo);    ssSetOutputPortMatrixDimensions( S ,0, OUTPUT_0_WIDTH, OUTPUT_DIMS_0_COL);    ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED);    ssSetOutputPortDataType(S, 0, SS_UINT8);    ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);    /* Output Port 1 */    outputDimsInfo.width = OUTPUT_1_WIDTH;    ssSetOutputPortDimensionInfo(S, 1, &outputDimsInfo);    ssSetOutputPortMatrixDimensions( S ,1, OUTPUT_1_WIDTH, OUTPUT_DIMS_1_COL);    ssSetOutputPortFrameData(S, 1, OUT_1_FRAME_BASED);    ssSetOutputPortDataType(S, 1, SS_UINT8);    ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX);    /* Output Port 2 */    outputDimsInfo.width = OUTPUT_2_WIDTH;    ssSetOutputPortDimensionInfo(S, 2, &outputDimsInfo);    ssSetOutputPortMatrixDimensions( S ,2, OUTPUT_2_WIDTH, OUTPUT_DIMS_2_COL);    ssSetOutputPortFrameData(S, 2, OUT_2_FRAME_BASED);    ssSetOutputPortDataType(S, 2, SS_UINT8);    ssSetOutputPortComplexSignal(S, 2, OUTPUT_2_COMPLEX);    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){    slDataTypeAccess *dta = ssGetDataTypeAccess(S);    int              udtId;    ssSetNumSFcnParams(S, 0);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        /* Return if number of expected != number of actual parameters */        return;    }    /* Obtain an integer datatype ID for the udt (user-defined type) "Data" */    udtId = ssRegisterDataType(S, "Data");    if ( udtId == INVALID_DTYPE_ID ) return;    /* Register the size of the udt */    if (!ssSetDataTypeSize(S, udtId, sizeof(Data))) return;    /* Register the zero of the udt */    if (!ssSetDataTypeZero(S, udtId, &zero)) return;    /* Set input-port properties */    if (!ssSetNumInputPorts(S, 1)) return;    ssSetInputPortWidth(S, 0, 1);    ssSetInputPortDataType(S, 0, SS_DOUBLE);    ssSetInputPortDirectFeedThrough(S, 0, 1);    /* Set output port properties */    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortDataType(S, 0, udtId);    ssSetOutputPortWidth(S, 0, 1);    /* Set miscellaneous properties */    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    /* specify the sim state compliance to be same as a built-in block */    ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE);    ssSetOptions(S,                 SS_OPTION_WORKS_WITH_CODE_REUSE);}

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

static void mdlInitializeSizes(SimStruct *S){    ssSetNumSFcnParams(S, 5);  /* Number of expected parameters */#ifndef TRES_SIMULINK_DISABLE_MASK_PROTECTION    // Perform mask params validity check    // TODO very basic error check (to be improved).    const mxArray *mxMsdVarName = ssGetSFcnParam(S,MSG_DESCR_VARNAME);    if ((mxGetM(mxMsdVarName) != 1) || (mxGetN(mxMsdVarName) == 0))    {        ssSetErrorStatus(S, "The message-set description variable cannot be empty");        return;    }    const mxArray *mxNdVarName = ssGetSFcnParam(S,NTWK_DESCR_VARNAME);    if ((mxGetM(mxNdVarName) != 1) || (mxGetN(mxNdVarName) == 0))    {        ssSetErrorStatus(S, "The network description variable cannot be empty (you must specify at least the network topology!)");        return;    }    const mxArray *mxAddLibsPath = ssGetSFcnParam(S,OTHER_DEPS);    if ((mxGetM(mxAddLibsPath) != 1) || (mxGetN(mxAddLibsPath) == 0))    {        ssSetErrorStatus(S, "The Additional Libraries (see the Simulator tab) field cannot be empty");        return;    }#endif    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    // Set the number of input ports to 0    if (!ssSetNumInputPorts(S, 0)) return;    // Set the output port to have a dynamic dimension    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, DYNAMICALLY_SIZED);    ssSetNumSampleTimes(S, 1);    ssSetNumDWork(S, 1);  // store the `New pending activations available' flag    ssSetDWorkWidth(S, 0, 1);    ssSetDWorkDataType(S, 0, SS_BOOLEAN);    ssSetNumPWork(S, 1);  // store the tres::Network    ssSetNumRWork(S, 1);  // store the time_resolution    ssSetNumNonsampledZCs(S, 1);    // next hit}

/* 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, 5);  /* 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, 0)) return;	if (!ssSetNumOutputPorts(S, 0)) return;	ssSetNumSampleTimes(S, 1);	ssSetNumRWork(S, 0);	ssSetNumIWork(S, 1); // nWaitTopic	size_t wait_buflen = mxGetN((ssGetSFcnParam(S, 2)))*sizeof(mxChar)+1;	char* wait_name = (char*)mxMalloc(wait_buflen);	mxGetString((ssGetSFcnParam(S, 2)), wait_name, wait_buflen);	char * topic = strtok(wait_name, TOPIC_SEPARATORS);	unsigned int nWaitTopic = 0;	while (topic != NULL){		nWaitTopic++;		topic = strtok(NULL, TOPIC_SEPARATORS);	}	mxFree(wait_name);	ssSetNumPWork(S, 4+nWaitTopic+1); //Start + Stop + Synchronous + Trigger services + wait_topic Subscriber(s) + AsyncSpinner	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){    DECL_AND_INIT_DIMSINFO(inputDimsInfo);    DECL_AND_INIT_DIMSINFO(outputDimsInfo);    ssSetNumSFcnParams(S, NPARAMS);     if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {	 return; /* Parameter mismatch will be reported by Simulink */     }    ssSetNumContStates(S, NUM_CONT_STATES);    ssSetNumDiscStates(S, NUM_DISC_STATES);    if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;    inputDimsInfo.width = INPUT_0_WIDTH;    ssSetInputPortDimensionInfo(S, 0, &inputDimsInfo);    ssSetInputPortFrameData(S, 0, IN_0_FRAME_BASED);    ssSetInputPortDataType(S, 0, SS_DOUBLE);    ssSetInputPortComplexSignal(S, 0, INPUT_0_COMPLEX);    ssSetInputPortDirectFeedThrough(S, 0, INPUT_0_FEEDTHROUGH);    ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/     if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;    outputDimsInfo.width =OUTPUT_0_WIDTH;    ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo);    ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED);    ssSetOutputPortDataType(S, 0, SS_DOUBLE);    ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);    ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    /*ssSetOutputPortWidth(S,0,atoi(temp));*/    /* Take care when specifying exception free code - see sfuntmpl_doc.c */    ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE |                     SS_OPTION_USE_TLC_WITH_ACCELERATOR | 		     SS_OPTION_WORKS_WITH_CODE_REUSE            | SS_OPTION_ALLOW_PARTIAL_DIMENSIONS_CALL));}

/* Function: mdlInitializeSizes =========================================*/static void mdlInitializeSizes(SimStruct *S){    ssSetNumSFcnParams(S, 0);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        return;    }    /* Register the number and type of states the S-Function uses */    ssSetNumContStates(    S, 0);   /* number of continuous states           */    ssSetNumDiscStates(    S, 0);   /* number of discrete states             */    ssAllowSignalsWithMoreThan2D(S);    /*     * Configure the input ports. First set the number of input ports.      */    if (!ssSetNumInputPorts(S, 1)) return;        if(!ssSetInputPortDimensionInfo(S, 0, DYNAMIC_DIMENSION)) return;    ssSetInputPortDataType(S, 0, DYNAMICALLY_TYPED);    ssSetInputPortDirectFeedThrough(S, 0, 1);    /*     * Configure the output ports. First set the number of output ports.     */    if (!ssSetNumOutputPorts(S, 1)) return;    if(!ssSetOutputPortDimensionInfo(S,0,DYNAMIC_DIMENSION)) return;    ssSetOutputPortDataType(S, 0, DYNAMICALLY_TYPED);    ssSetNumSampleTimes(S, PORT_BASED_SAMPLE_TIMES);    ssSetInputPortSampleTime(S, 0, INHERITED_SAMPLE_TIME);    ssSetOutputPortSampleTime(S, 0, INHERITED_SAMPLE_TIME);    /*     * Set size of the work vectors.     */    ssSetNumRWork(         S, 0);   /* number of real work vector elements   */    ssSetNumIWork(         S, 0);   /* number of integer work vector elements*/    ssSetNumPWork(         S, 0);   /* number of pointer work vector elements*/    ssSetNumModes(         S, 0);   /* number of mode work vector elements   */    ssSetNumNonsampledZCs( S, 0);   /* number of non-sampled zero crossings   */    ssSetOptions(S, 0);   /* general options (SS_OPTION_xx)        */} /* end mdlInitializeSizes */

static void mdlInitializeSizes(SimStruct *S) {	ssSetNumSFcnParams(S,5);	if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {		return; /* Parameter mismatch will be reported by Simulink */	}	ssSetNumContStates(S,0);	ssSetNumDiscStates(S,0);	if (!ssSetNumInputPorts(S,0)) return;	if (!ssSetNumOutputPorts(S,0)) return;	ssSetNumSampleTimes(S,1);	ssSetNumRWork(S,0);	ssSetNumIWork(S,0);	ssSetNumPWork(S,0);	ssSetNumModes(S,0);	ssSetNumNonsampledZCs(S,0);	ssSetOptions(S,0);}

static void mdlSetWorkWidths_c1_newtons_cradle(SimStruct *S){  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    mxArray *infoStruct = load_newtons_cradle_optimization_info();    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct,      1);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(),                infoStruct,1,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S,      sf_get_instance_specialization(),infoStruct,1,      "gatewayCannotBeInlinedMultipleTimes"));    sf_update_buildInfo(S,sf_get_instance_specialization(),infoStruct,1);    if (chartIsInlinable) {      sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(),        infoStruct,1,2);    }    {      unsigned int outPortIdx;      for (outPortIdx=1; outPortIdx<=2; ++outPortIdx) {        ssSetOutputPortOptimizeInIR(S, outPortIdx, 1U);      }    }    sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,1);    ssSetHasSubFunctions(S,!(chartIsInlinable));    ssSetCallsOutputInInitFcn(S,1);  } else {  }  ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  ssSetChecksum0(S,(3676614977U));  ssSetChecksum1(S,(2993289601U));  ssSetChecksum2(S,(3118278023U));  ssSetChecksum3(S,(1837160273U));  ssSetNumContStates(S,6);  ssSetExplicitFCSSCtrl(S,1);  ssSupportsMultipleExecInstances(S,1);}

static void mdlInitializeSizes(SimStruct *S){    ssSetNumSFcnParams(S, 1);    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) return;    ssSetNumContStates(S, 6);    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 1)) return;    ssSetInputPortWidth(S, 0, 3);    ssSetInputPortDirectFeedThrough(S, 0, 1);    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, 6);    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);}

/* 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*/    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){    /* See sfuntmpl_doc.c for more details on the macros below */    ssSetNumSFcnParams(S, 2);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        /* Return if number of expected != number of actual parameters */        return;    }    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 0)) return;    //ssSetInputPortWidth(S, 0, 1);    //ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/    /*     * Set direct feedthrough flag (1=yes, 0=no).     * A port has direct feedthrough if the input is used in either     * the mdlOutputs or mdlGetTimeOfNextVarHit functions.     * See matlabroot/simulink/src/sfuntmpl_directfeed.txt.     */    //ssSetInputPortDirectFeedThrough(S, 0, 1);    if (!ssSetNumOutputPorts(S, 3)) return;    ssSetOutputPortWidth(S, 0, CONSTANT_AXES_SIZE); // axes    ssSetOutputPortWidth(S, 1, CONSTANT_BUTTONS_SIZE); // buttons    ssSetOutputPortDataType(S, 1, SS_INT32);    ssSetOutputPortWidth(S, 2, 1); // time    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 2); //AsyncSpinner, GenericSub    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    /* Specify the sim state compliance to be same as a built-in block */    ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE);    ssSetOptions(S, 0);}

/* Function: mdlInitializeSizes =============================================== * Abstract: *   Setup sizes of the various vectors. */static void mdlInitializeSizes(SimStruct *S){    DECL_AND_INIT_DIMSINFO(outputDimsInfo);    ssSetNumSFcnParams(S, NPARAMS);     if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {	 return; /* Parameter mismatch will be reported by Simulink */     }    ssSetNumContStates(S, NUM_CONT_STATES);    ssSetNumDiscStates(S, NUM_DISC_STATES);    if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;    if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;    /* Output Port 0 */    ssSetOutputPortWidth(S, 0, OUTPUT_0_WIDTH);    ssSetOutputPortDataType(S, 0, SS_INT16);    ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);    /* Output Port 1 */    ssSetOutputPortWidth(S, 1, OUTPUT_1_WIDTH);    ssSetOutputPortDataType(S, 1, SS_INT16);    ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX);    /* Output Port 2 */    ssSetOutputPortWidth(S, 2, OUTPUT_2_WIDTH);    ssSetOutputPortDataType(S, 2, SS_INT16);    ssSetOutputPortComplexSignal(S, 2, OUTPUT_2_COMPLEX);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    ssSetSimulinkVersionGeneratedIn(S, "8.3");    /* 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));}

/* * Setup sizes of the various vectors. */static void mdlInitializeSizes (SimStruct *S){	/* Количество параметров. */	ssSetNumSFcnParams (S, 0);	if (ssGetNumSFcnParams (S) != ssGetSFcnParamsCount (S)) {		/* Simulink сообщит о несоответствии параметров */		return;	}	ssSetNumContStates (S, 0);	ssSetNumDiscStates (S, 0);	/*	 * Входы.	 */	if (! ssSetNumInputPorts (S, 4))		return;	set_input_port (S, 0, SS_BOOLEAN);	/* rn0 */	set_input_port (S, 1, SS_BOOLEAN);	/* rn1 */	set_input_port (S, 2, SS_BOOLEAN);	/* rn2 */	set_input_port (S, 3, SS_BOOLEAN);	/* rn3 */	/*	 * Выходы.	 */	if (! ssSetNumOutputPorts (S, 1))		return;	set_output_port (S, 0, SS_BOOLEAN);	/* tx */	ssSetNumSampleTimes (S, 1);	ssSetNumRWork (S, 0);	ssSetNumIWork (S, 0);	ssSetNumPWork (S, 1);	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 |			 SS_OPTION_DISCRETE_VALUED_OUTPUT);}

static void mdlInitializeSizes(SimStruct *S){	uint_T i;		ssSetNumSFcnParams(S, NUMBER_OF_PARAMS);	if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {		return;	}	for (i = 0; i < NUMBER_OF_PARAMS; i++) {		ssSetSFcnParamNotTunable(S, i);	}	ssSetNumInputPorts(S, 1);	ssSetNumOutputPorts(S, 0);	ssSetInputPortWidth(S, 0, 1);	ssSetInputPortDirectFeedThrough(S, 0, 1);	ssSetNumContStates(S, 0);	ssSetNumDiscStates(S, 0);	ssSetNumSampleTimes(S, 1);	ssSetNumPWork(S, 1);}

static void mdlInitializeSizes(SimStruct *S){	int i;#ifndef MATLAB_MEX_FILE#include "time_xpcimport.c"#endif   	ssSetNumSFcnParams(S, 0);	if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {		return; /* Parameter mismatch will be reported by Simulink */	}  ssSetNumContStates(S, 0);  ssSetNumDiscStates(S, 0);  ssSetNumOutputPorts(S, 1);  ssSetOutputPortWidth(S, 0, 8);  ssSetNumInputPorts(S, 0);        }

static void mdlInitializeSizes(SimStruct *S){int_T num_channels;  ssSetNumSFcnParams(S, NUMBER_OF_ARGS);  if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {    return; /* Parameter mismatch will be reported by Simulink */  }  num_channels=(int_T) mxGetPr(CHANNELS_ARG)[CHANNELS_IND];  if (!ssSetNumInputPorts(S, 0)) return;  if (!ssSetNumOutputPorts(S,1)) return;  ssSetOutputPortWidth(S, 0, num_channels);  ssSetNumContStates(S, 0);  ssSetNumDiscStates(S, 0);  ssSetNumSampleTimes(S, 1);  ssSetNumIWork(S,NO_I_WORKS);}

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, 3)) return;    ssSetInputPortWidth(S, 0, 12);    ssSetInputPortRequiredContiguous(S, 0, true);    ssSetInputPortDirectFeedThrough(S, 0, 1);        ssSetInputPortWidth(S, 1, DYNAMICALLY_SIZED);    ssSetInputPortRequiredContiguous(S, 1, true);    ssSetInputPortDirectFeedThrough(S, 1, 1);        ssSetInputPortWidth(S, 2, DYNAMICALLY_SIZED);    ssSetInputPortRequiredContiguous(S, 2, true);    ssSetInputPortDirectFeedThrough(S, 2, 1);        if (!ssSetNumOutputPorts(S, 3)) return;    ssSetOutputPortWidth(S, 0, 27);    ssSetOutputPortWidth(S, 1, DYNAMICALLY_SIZED);    ssSetOutputPortWidth(S, 2, DYNAMICALLY_SIZED);        ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, NUM_IWORK);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(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, 4);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        /* Return if number of expected != number of actual parameters */        return;    }    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 0)) return;    //ssSetInputPortWidth(S, 0, 1);    //ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/    /*     * Set direct feedthrough flag (1=yes, 0=no).     * A port has direct feedthrough if the input is used in either     * the mdlOutputs or mdlGetTimeOfNextVarHit functions.     * See matlabroot/simulink/src/sfuntmpl_directfeed.txt.     */    //ssSetInputPortDirectFeedThrough(S, 0, 1);    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, 1); // port 0 is 1 value (rtTimeDelay)    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 2); // Tsim, simulationTime, showEveryNumSeconds    ssSetNumIWork(S, 1); // CycleCounter    ssSetNumPWork(S, 2); // startTime,lastExecTime    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){    ssSetNumSFcnParams(S, 0);						    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        return; /* Parameter mismatch will be reported by Simulink */    }    /* no states, all computation will be done in output section */    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);        /* one input port: state x(k) + vector of references */    ssSetNumInputPorts(S, 1);         /* one output port: control action */    ssSetNumOutputPorts(S, 1);    /* width of input vector - number of states of the original problem.      * note that tracking includes additional states, here we do not consider them     */    if (MPT_TRACKING>0) {        ssSetInputPortWidth(S, 0, MPT_NXT + MPT_NREF);    } else {        /* dimension extended by one to allow empty reference to be passed */        /*ssSetInputPortWidth(S, 0, MPT_NXT + 1); */        ssSetInputPortWidth(S, 0, MPT_NXT);    }        ssSetInputPortDirectFeedThrough(S, 0, 1);        /* width of output - number of control actions */    ssSetOutputPortWidth(S, 0, MPT_NU);        ssSetNumSampleTimes(S, 1);    /* Take care when specifying exception free code - see sfuntmpl.doc */    ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE);    }

static void mdlInitializeSizes(SimStruct *S){   ssSetNumSFcnParams(S, 1);  /* Number of expected parameters */   if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) return;    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);   if (!ssSetNumInputPorts(S, 0)) return;   if (!ssSetNumOutputPorts(S, 0)) return;      ssSetNumSampleTimes(S, 1);   ssSetNumRWork(S, 1);   ssSetNumIWork(S, 0);   ssSetNumPWork(S, 0);   ssSetNumModes(S, 0);   ssSetNumNonsampledZCs(S, 0);   ssSetOptions(S, 0);}

static void mdlInitializeSizes(SimStruct * S) {        ssSetNumSFcnParams(S, NUMBER_OF_ARGS);    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        sprintf(msg, "Wrong number of input arguments passed./n"        "%d arguments are expected/n", NUMBER_OF_ARGS);        ssSetErrorStatus(S, msg);        return;    }        if ( mxGetM(NO_BYTES_ARG)!=1 | mxGetN(NO_BYTES_ARG)!=1 ) {        sprintf(msg,"Output port width argument must be a scalar/n");        ssSetErrorStatus(S,msg);        return;    }        ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);        ssSetNumOutputPorts(S, 2);    ssSetOutputPortWidth(S, 0, PORT_WIDTH);    ssSetOutputPortDataType(S, 0, SS_UINT8);        ssSetOutputPortWidth(S, 1, 1);      /* received flag */        ssSetNumInputPorts(S, 0);        ssSetNumSampleTimes(S, 1);        ssSetNumRWork(S, NO_R_WORKS);    ssSetNumIWork(S, NO_I_WORKS);    ssSetNumPWork(S, NO_P_WORKS);        ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);        ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_PLACE_ASAP);}

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++) {        if (i != 5)            ssSetSFcnParamTunable(S, i, 1);        else            ssSetSFcnParamTunable(S, i, 0);    }    ssSetOptions(S, SS_OPTION_WORKS_WITH_CODE_REUSE |                     SS_OPTION_USE_TLC_WITH_ACCELERATOR);    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 1)) return;    ssSetInputPortWidth(S, 0, 5);    ssSetInputPortRequiredContiguous(S, 0, true);    ssSetInputPortDirectFeedThrough(S, 0, 1);    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, 2);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, NERRORS);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(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, 3);  /* Number of expected parameters */    // Parameter mismatch will be reported by Simulink  if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) {    mdlCheckParameters(S);    if (ssGetErrorStatus(S) != NULL) {      return;    }  } else {    return; /* Parameter mismatch will be reported by Simulink */  }  ssSetSFcnParamTunable(S, 0, 0);  ssSetNumContStates(S, 0);  ssSetNumDiscStates(S, 0);  if (!ssSetNumInputPorts(S, 0)) return;  //  ssSetInputPortDirectFeedThrough(S, 0, 1);        if (!ssSetNumOutputPorts(S, 1)) return;  ssSetOutputPortWidth(S, 0, DYNAMICALLY_SIZED);    ssSetNumSampleTimes(S, 1);  ssSetNumPWork(S, 2); // reserve element in the pointers vector  ssSetNumModes(S, 0); // to store a C++ object  ssSetNumNonsampledZCs(S, 0);  ssSetSimStateCompliance(S, USE_CUSTOM_SIM_STATE);  ssSetOptions(S, 0);}

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