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

/*=====================================* * Configuration and execution methods * *=====================================*/static void mdlInitializeSizes(SimStruct *S){#ifdef DEBUG	debug("mdlInitializeSizes entered./n");#endif    ssSetNumSFcnParams(S, NPAR);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {		mdlCheckParameters(S);        if (ssGetErrorStatus(S) != NULL) return;    }    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 1)) return;    ssSetInputPortWidth(S, 0, NI);    ssSetInputPortDirectFeedThrough(S, 0, 1);    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, 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);#ifdef DEBUG	debug("mdlInitializeSizes left./n");#endif} /* mdlInitializeSizes */

static void mdlInitializeSizes(SimStruct *S){  uint_T i;  ssSetNumSFcnParams(S, NUMBER_OF_PARAMS);#if defined(MATLAB_MEX_FILE)  if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) {    mdlCheckParameters(S);    if (ssGetErrorStatus(S) != NULL) {      return;    }  } else {    return;  }#endif  for (i = 0; i < NUMBER_OF_PARAMS; i++) {    ssSetSFcnParamNotTunable(S, i);  }  ssSetNumInputPorts(S, 0);  ssSetNumOutputPorts(S, 1);  ssSetOutputPortWidth(S, 0, 1);  ssSetNumContStates(S, 0);  ssSetNumDiscStates(S, 0);  ssSetNumSampleTimes(S, 1);  ssSetNumPWork(S,1);  ssSetNumIWork(S,1);  ssSetNumRWork(S,2);}

static void mdlInitializeSizes(SimStruct *S) {	bool dataPort;	ssSetNumSFcnParams(S,3);	if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {		return; /* Parameter mismatch will be reported by Simulink */	}	dataPort = PARAM(2)[0];	if (dataPort) {		if (!ssSetNumInputPorts(S,2)) return;		ssSetInputPortWidth(S,1,DYNAMICALLY_SIZED);		ssSetInputPortDirectFeedThrough(S,1,1);	} else {		if (!ssSetNumInputPorts(S,1)) return;	}	ssSetInputPortWidth(S,0,1);	ssSetInputPortDirectFeedThrough(S,0,1);	ssSetNumContStates(S,0);	ssSetNumDiscStates(S,0);	if (!ssSetNumOutputPorts(S,0)) return;	ssSetInputPortDataType(S, 0, DYNAMICALLY_TYPED);	ssSetNumSampleTimes(S,1);	ssSetNumRWork(S,1);	ssSetNumIWork(S,1);	ssSetNumPWork(S,2);	ssSetNumModes(S,0);	ssSetNumNonsampledZCs(S,0);	ssSetOptions(S,0);}

/* Function: mdlInitializeSizes =============================================== * Abstract: *    The sizes information is used by Simulink to determine the S-function *    block's characteristics (number of inputs, outputs, states, etc.). */static void mdlInitializeSizes(SimStruct *S) {        ssSetNumSFcnParams(S, 0);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        /* Return if number of expected != number of actual parameters */        return;    }    //  printf("URG: 111/n");    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);        if (!ssSetNumInputPorts(S, 0)) return;        if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, 682);    ssSetOutputPortDataType(S, 0, SS_INT16);        ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);            /* Specify the sim state compliance to be same as a built-in block */    //  ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE);        ssSetOptions(S, 0);        printf("URG: Inicializando driver URG-04LX.../n");}

/* Function: mdlInitializeSizes =============================================== * Abstract: *   Setup sizes of the various vectors. */static void mdlInitializeSizes(SimStruct *S){    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));}

static void mdlInitializeSizes(SimStruct *S){    ssSetNumSFcnParams(S, N_PARAMS);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        /* Return if number of expected != number of actual parameters */        return;    }    ssSetNumContStates(S, N_STATES);    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 1)) return;    ssSetInputPortWidth(S, 0, N_INPUTS);    ssSetInputPortDirectFeedThrough(S, 0, 1);    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, N_OUTPUTS);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    ssSetOptions(S, 0);}

/* Function: mdlInitializeSizes =============================================== * Abstract: *    The sizes information is used by Simulink to determine the S-function *    block's characteristics (number of inputs, outputs, states, etc.). */static void mdlInitializeSizes(SimStruct *S){    /* See sfuntmpl_doc.c for more details on the macros below */    ssSetNumSFcnParams(S, NUM_PARAMS);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S))    {      mdlCheckParameters(S);      if (ssGetErrorStatus(S) != NULL)        /* Return if number of expected != number of actual parameters */        return;    }    else      return;    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    ssSetNumInputPorts(S, 0);    ssSetNumOutputPorts(S, 0);    ssSetNumSampleTimes(S, 1);    ssSetSFcnParamTunable(S, 0, 0);    ssSetSFcnParamTunable(S, 1, 0);    ssSetSFcnParamTunable(S, 2, 0);    ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_CAN_BE_CALLED_CONDITIONALLY);}

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, 7);        ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 2);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    }

 static void mdlSetWorkWidths(SimStruct *S) {     int_T nq = 0;     if( mxGetNumberOfElements(paramQuaternionIndex) == 2 )     {         nq = intval(mxGetPr(paramQuaternionIndex)[1]) - intval(mxGetPr(paramQuaternionIndex)[0]) + 1;         nq = nq / 4;     }     ssSetNumContStates(S, 0);     ssSetNumDiscStates(S, 0);     ssSetNumRWork(S, 0);     ssSetNumIWork(S, 1);     ssSetNumPWork(S, 1);     ssSetNumDWork(S, (nq > 0 ? 3 : 2));     ssSetDWorkWidth(S, 0, ssGetInputPortWidth(S, 0));     ssSetDWorkWidth(S, 1, ssGetInputPortWidth(S, 0));     ssSetDWorkDataType(S, 0, SS_DOUBLE);     ssSetDWorkDataType(S, 1, SS_DOUBLE);     if( nq )     {         ssSetDWorkWidth(S, 2, ssGetInputPortWidth(S, 0));         ssSetDWorkDataType(S, 2, SS_DOUBLE);     }     ssSetNumModes(S, 0); }

static void mdlInitializeSizes(SimStruct *S) {    ssSetNumContStates(    S, 0);   /* number of continuous states           */    ssSetNumDiscStates(    S, 0);   /* number of discrete states             */#ifdef CO_DEBUG    printf("co_udp_receiver :: in mdlInitializeSizes/n");#endif    /* CO changes ... */    ssSetNumInputPorts(S, 0);   /* number of inputs                      */    /*ssSetInputPortWidth( S, 0, DYNAMICALLY_SIZED);*/    ssSetNumOutputPorts( S, 2);   /* number of outputs , all in one vector         */    //ssSetOutputPortMatrixDimensions(S, 0, TRAJ_NUM_POINTS,TRAJ_NUM_COLUMNS);    ssSetOutputPortWidth(S, 0, 7*SEGMENTNUMBER); // length of data    ssSetOutputPortWidth(S, 1, 1); // status output    /*ssSetInputPortDirectFeedThrough(S, 0, 1);    direct feedthrough flag               */    /*ssSetInputPortDirectFeedThrough(S, 1, 1); */  /* direct feedthrough flag               */    ssSetNumSampleTimes(   S, 0);   /* number of sample times                */    ssSetNumSFcnParams(    S, 2);   /* number of input arguments             */    ssSetNumRWork(         S, 0);   /* number of real work vector elements   */    ssSetNumIWork(         S, 0);   /* number of integer work vector elements*/    ssSetNumPWork(         S, 1);   /* number of pointer work vector elements*/#ifdef CO_DEBUG    printf("co_udp_receiver :: mdlInitializeSizes/n");#endif}

static void mdlInitializeSizes(SimStruct *S) {    int_T msgType;    int_T initValLen;    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;    msgType = (int_T)*mxGetPr(ssGetSFcnParam(S,0));    switch (msgType) {    case SUBSCRIBER_TWIST_STAMPED:    case PUBLISHER_POINT_STAMPED:        if (!ssSetNumOutputPorts(S,2)) return;        ssSetOutputPortWidth(S,1,2);        break;    default:        if (!ssSetNumOutputPorts(S,1)) return;    }    switch (msgType) {    case SUBSCRIBER_FLOAT64:    case SUBSCRIBER_INT32:    case SUBSCRIBER_BOOL:    case SUBSCRIBER_TIME:        ssSetOutputPortWidth(S,0,1);        break;    case SUBSCRIBER_FLOAT64ARRAY:        ssSetOutputPortWidth(S,0,DYNAMICALLY_SIZED);        break;    case SUBSCRIBER_TWIST:    case SUBSCRIBER_TWIST_STAMPED:        ssSetOutputPortWidth(S,0,6);        break;    case PUBLISHER_POINT:    case PUBLISHER_POINT_STAMPED:    case PUBLISHER_POSE2D:        ssSetOutputPortWidth(S,0,3);        break;    default:        ssSetErrorStatus(S, "Unknown message type!");        return;    }    initValLen = mxGetNumberOfElements(ssGetSFcnParam(S,2));    if (initValLen > 1) {        ssSetOutputPortWidth(S,0,initValLen);    }    ssSetNumSampleTimes(S,1);    ssSetNumRWork(S,0);    ssSetNumIWork(S,1);    ssSetNumPWork(S,2);    ssSetNumModes(S,0);    ssSetNumNonsampledZCs(S,0);    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;    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 mdlInitializeSizes(SimStruct *S){  ssSetNumSFcnParams(S, 0);  /* Number of expected parameters */  if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {    return;  }  ssSetNumContStates(S, 2);  ssSetNumDiscStates(S, 0);  if (!ssSetNumInputPorts(S, 0)) return;  if (!ssSetNumOutputPorts(S, 1)) return;  ssSetOutputPortWidth(S, 0, 2);  ssSetNumSampleTimes(S, 1);  ssSetNumRWork(S, 0);  ssSetNumIWork(S, 0);  ssSetNumPWork(S, 0);  ssSetNumModes(S, 0);  ssSetNumNonsampledZCs(S, 1);  ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE);  ssSetOptions(S, 0);}

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

/* Function: mdlInitializeSizes =============================================== * Abstract: *   Setup sizes of the various vectors. */static void mdlInitializeSizes(SimStruct *S){    DECL_AND_INIT_DIMSINFO(outputDimsInfo);    ssSetNumSFcnParams(S, NPARAMS);     if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {	 return; /* Parameter mismatch will be reported by Simulink */     }    ssSetNumContStates(S, NUM_CONT_STATES);    ssSetNumDiscStates(S, NUM_DISC_STATES);    if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;    if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;    /* Output Port 0 */    ssSetOutputPortWidth(S, 0, OUTPUT_0_WIDTH);    ssSetOutputPortDataType(S, 0, SS_SINGLE);    ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);    /* Output Port 1 */    ssSetOutputPortWidth(S, 1, OUTPUT_1_WIDTH);    ssSetOutputPortDataType(S, 1, SS_SINGLE);    ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX);    /* Output Port 2 */    ssSetOutputPortWidth(S, 2, OUTPUT_2_WIDTH);    ssSetOutputPortDataType(S, 2, SS_SINGLE);    ssSetOutputPortComplexSignal(S, 2, OUTPUT_2_COMPLEX);    /* Output Port 3 */    ssSetOutputPortWidth(S, 3, OUTPUT_3_WIDTH);    ssSetOutputPortDataType(S, 3, SS_SINGLE);    ssSetOutputPortComplexSignal(S, 3, OUTPUT_3_COMPLEX);    /* Output Port 4 */    ssSetOutputPortWidth(S, 4, OUTPUT_4_WIDTH);    ssSetOutputPortDataType(S, 4, SS_SINGLE);    ssSetOutputPortComplexSignal(S, 4, OUTPUT_4_COMPLEX);    /* Output Port 5 */    ssSetOutputPortWidth(S, 5, OUTPUT_5_WIDTH);    ssSetOutputPortDataType(S, 5, SS_SINGLE);    ssSetOutputPortComplexSignal(S, 5, OUTPUT_5_COMPLEX);    /* Output Port 6 */    ssSetOutputPortWidth(S, 6, OUTPUT_6_WIDTH);    ssSetOutputPortDataType(S, 6, SS_SINGLE);    ssSetOutputPortComplexSignal(S, 6, OUTPUT_6_COMPLEX);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    ssSetSimulinkVersionGeneratedIn(S, "8.6");    /* Take care when specifying exception free code - see sfuntmpl_doc.c */    ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE |                     SS_OPTION_USE_TLC_WITH_ACCELERATOR | 		     SS_OPTION_WORKS_WITH_CODE_REUSE));}

/* Function: mdlInitializeSizes =============================================== * Abstract: *    The sizes information is used by Simulink to determine the S-function *    block's characteristics (number of inputs, outputs, states, etc.). */static void mdlInitializeSizes(SimStruct *S){    /* See sfuntmpl.doc for more details on the macros below */    ssSetNumSFcnParams(S, 0);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        /* Return if number of expected != number of actual parameters */        return;    }    ssSetNumContStates(S, 1);  /* how many continuous states? */    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 1)) return;    ssSetInputPortWidth(S, 0, 1);    /*     * Set direct feedthrough flag (1=yes, 0=no).     * A port has direct feedthrough if the input is used in either     * the mdlOutputs or mdlGetTimeOfNextVarHit functions.     * See matlabroot/simulink/src/sfuntmpl_directfeed.txt.     */    ssSetInputPortDirectFeedThrough(S, 0, 1);    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, 1);    ssSetNumSampleTimes(S, 1);    /*      * If your Fortran code uses REAL for the state, input, and/or output      * datatypes, use these DWorks as work areas to downcast continuous      * states from double to REAL before calling your code.  You could     * also put the work vectors in hard-coded local (stack) variables.     *     * For fixed step code, keep a copy of the variables  to be output      * in a DWork vector so the mdlOutputs() function can provide output      * data when needed. You can use as many DWork vectors as you like      * for both input and output (or hard-code local variables).     */    if(!ssSetNumDWork(   S, 3)) return;    ssSetDWorkWidth(     S, 0, ssGetOutputPortWidth(S,0));    ssSetDWorkDataType(  S, 0, SS_SINGLE); /* use SS_DOUBLE if needed */    ssSetDWorkWidth(     S, 1, ssGetInputPortWidth(S,0));    ssSetDWorkDataType(  S, 1, SS_SINGLE);    ssSetDWorkWidth(     S, 2, ssGetNumContStates(S));    ssSetDWorkDataType(  S, 2, SS_SINGLE);    ssSetNumNonsampledZCs(S, 0);    /* Specify the sim state compliance to be same as a built-in block */    /* see sfun_simstate.c for example of other possible settings */    ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE);    ssSetOptions(S, 0);}

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){        char host[] = "localhost";	int port = 9002;        trigger = 0;    /* See sfuntmpl_doc.c for more details on the macros below */    ssSetNumSFcnParams(S, 1);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        /* Return if number of expected != number of actual parameters */        return;    }    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    /* This functions receives no inputs, but it could use inputs instead of hard-coded parameters (e.g. port and host) */    if (!ssSetNumInputPorts(S, 0)) return;    /*ssSetInputPortWidth(S, 0, 1);*/    /*ssSetInputPortRequiredContiguous(S, 0, true); /direct input signal access*/    /*     * Set direct feedthrough flag (1=yes, 0=no).     * A port has direct feedthrough if the input is used in either     * the mdlOutputs or mdlGetTimeOfNextVarHit functions.     * See matlabroot/simulink/src/sfuntmpl_directfeed.txt.     */    /*ssSetInputPortDirectFeedThrough(S, 0, 1);*/    if (!ssSetNumOutputPorts(S, 2)) return;    ssSetOutputPortWidth(S, 0, PAYLOAD_LEN/2);     ssSetOutputPortDataType(S, 0, SS_UINT16);    ssSetOutputPortWidth(S, 1, 1);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE);            /* Connect to the SerialForwarder server using functions linked in sfsource.o */    fd = open_sf_source(host, port);            if (fd < 0){            ssSetErrorStatus(S,"SerialForwarder not running in the specified host and port");            return;        }}

static void mdlInitializeSizes(SimStruct *S) {  ssSetNumSFcnParams(S, 2);  ssSetNumContStates(S, 0);  ssSetNumDiscStates(S, 0);  ssSetNumInputPorts(S, 0);  ssSetNumOutputPorts(S, 0);  ssSetNumSampleTimes(S, 1);  ssSetNumPWork(S, 1);  // start time}

/* Function: mdlInitializeSizes =============================================== * Abstract: *   Setup sizes of the various vectors. */static void mdlInitializeSizes(SimStruct *S){    DECL_AND_INIT_DIMSINFO(outputDimsInfo);    ssSetNumSFcnParams(S, NPARAMS);     if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {	 return; /* Parameter mismatch will be reported by Simulink */     }    ssSetNumContStates(S, NUM_CONT_STATES);    ssSetNumDiscStates(S, NUM_DISC_STATES);    if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;    if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;    /* Output Port 0 */    outputDimsInfo.width = OUTPUT_0_WIDTH;    ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo);    ssSetOutputPortMatrixDimensions( S ,0, OUTPUT_0_WIDTH, OUTPUT_DIMS_0_COL);    ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED);    ssSetOutputPortDataType(S, 0, SS_UINT8);    ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);    /* Output Port 1 */    outputDimsInfo.width = OUTPUT_1_WIDTH;    ssSetOutputPortDimensionInfo(S, 1, &outputDimsInfo);    ssSetOutputPortMatrixDimensions( S ,1, OUTPUT_1_WIDTH, OUTPUT_DIMS_1_COL);    ssSetOutputPortFrameData(S, 1, OUT_1_FRAME_BASED);    ssSetOutputPortDataType(S, 1, SS_UINT8);    ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX);    /* Output Port 2 */    outputDimsInfo.width = OUTPUT_2_WIDTH;    ssSetOutputPortDimensionInfo(S, 2, &outputDimsInfo);    ssSetOutputPortMatrixDimensions( S ,2, OUTPUT_2_WIDTH, OUTPUT_DIMS_2_COL);    ssSetOutputPortFrameData(S, 2, OUT_2_FRAME_BASED);    ssSetOutputPortDataType(S, 2, SS_UINT8);    ssSetOutputPortComplexSignal(S, 2, OUTPUT_2_COMPLEX);    /* Output Port 3 */    outputDimsInfo.width = OUTPUT_3_WIDTH;    ssSetOutputPortDimensionInfo(S, 3, &outputDimsInfo);    ssSetOutputPortMatrixDimensions( S ,3, OUTPUT_3_WIDTH, OUTPUT_DIMS_3_COL);    ssSetOutputPortFrameData(S, 3, OUT_3_FRAME_BASED);    ssSetOutputPortDataType(S, 3, SS_UINT16);    ssSetOutputPortComplexSignal(S, 3, OUTPUT_3_COMPLEX);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    /* Take care when specifying exception free code - see sfuntmpl_doc.c */    ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE |		     SS_OPTION_WORKS_WITH_CODE_REUSE));}

static void mdlInitializeSizes(SimStruct *S){    const real_T  *P1  = mxGetData(PARAM_DEF3(S));    const real_T  *P2  = mxGetData(PARAM_DEF2(S));    DECL_AND_INIT_DIMSINFO(outputDimsInfo);    ssSetNumSFcnParams(S, NPARAMS);  /* Number of expected parameters */      #if defined(MATLAB_MEX_FILE)	if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) {	  if (ssGetErrorStatus(S) != NULL) {	    return;	  }	 } else {	   return; /* Parameter mismatch will be reported by Simulink */	 }      #endif    ssSetNumContStates(S, NUM_CONT_STATES);    ssSetNumDiscStates(S, NUM_DISC_STATES);    if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;    if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;    /* Output Port 0 */    outputDimsInfo.width = *P1;             ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo);    ssSetOutputPortMatrixDimensions( S ,0, *P1, *P2);    ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED);    ssSetOutputPortDataType(S, 0, SS_UINT8);    ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);    /* Output Port 1 */    outputDimsInfo.width = *P1;    ssSetOutputPortDimensionInfo(S, 1, &outputDimsInfo);    ssSetOutputPortMatrixDimensions( S ,1, *P1, *P2);    ssSetOutputPortFrameData(S, 1, OUT_1_FRAME_BASED);    ssSetOutputPortDataType(S, 1, SS_UINT8);    ssSetOutputPortComplexSignal(S, 1, OUTPUT_1_COMPLEX);    /* Output Port 2 */    outputDimsInfo.width = *P1;    ssSetOutputPortDimensionInfo(S, 2, &outputDimsInfo);    ssSetOutputPortMatrixDimensions( S ,2, *P1, *P2);    ssSetOutputPortFrameData(S, 2, OUT_2_FRAME_BASED);    ssSetOutputPortDataType(S, 2, SS_UINT8);    ssSetOutputPortComplexSignal(S, 2, OUTPUT_2_COMPLEX);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    /* Take care when specifying exception free code - see sfuntmpl_doc.c */    ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE |		     SS_OPTION_WORKS_WITH_CODE_REUSE));}

/* Function: mdlInitializeSizes =============================================== * Abstract: *    The sizes information is used by Simulink to determine the S-function *    block's characteristics (number of inputs, outputs, states, etc.). */static void mdlInitializeSizes(SimStruct *S) {	/* 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);}

/* 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    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, 4)) return;    const int_T nDofs = *((mxChar*)mxGetData(ssGetSFcnParam(S, 4)));    ssSetOutputPortMatrixDimensions(S, 0, nDofs, nRobots); // position    ssSetOutputPortMatrixDimensions(S, 1, nDofs, nRobots); // velocity    ssSetOutputPortMatrixDimensions(S, 2, nDofs, nRobots); // effort    ssSetOutputPortMatrixDimensions(S, 3, 1, nRobots); // SentTime in s;    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 2); // nRobots, nDofs    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);}

static void mdlInitializeSizes(SimStruct *S){  const mxArray *arg;  ssSetNumSFcnParams(S, 3);  /* Number of expected parameters */  if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {    return; /* Parameter mismatch will be reported by Simulink */  }    if (!ssSetNumInputPorts(S, 0)) return;  if (!ssSetNumOutputPorts(S, 7)) return;  RMsys *rmsys = new RMsys;  rmsys->trigger = 0.0;  arg = ssGetSFcnParam(S, 0);  if (mxIsDoubleScalar(arg)) {    rmsys->networkNbr  = (int)*mxGetPr(arg);  }  arg = ssGetSFcnParam(S, 1);  if (mxIsDoubleScalar(arg)) {    rmsys->receiver  = (int)*mxGetPr(arg);  }  arg = ssGetSFcnParam(S, 2);  if (mxIsDoubleScalar(arg)) {    rmsys->outdim  = (int)*mxGetPr(arg);  }  /* Output Ports */  ssSetOutputPortWidth(S, 0, rmsys->outdim);  // data  ssSetOutputPortWidth(S, 1, 1);              // receiver  ssSetOutputPortWidth(S, 2, 1);              // length  ssSetOutputPortWidth(S, 3, 1);              // prio  ssSetOutputPortWidth(S, 4, 1);              // time stamp  ssSetOutputPortWidth(S, 5, 1);              // signal power (wireless only)  ssSetOutputPortWidth(S, 6, 1);              // message id  ssSetNumContStates(S, 0);  ssSetNumDiscStates(S, 0);    ssSetNumSampleTimes(S, 1);      ssSetNumRWork(S, 0);  ssSetNumIWork(S, 0);  ssSetNumPWork(S, 0);   ssSetNumModes(S, 0);  ssSetNumNonsampledZCs(S, 0);  ssSetUserData(S, rmsys);    ssSetOptions(S, SS_OPTION_CALL_TERMINATE_ON_EXIT); }

static void mdlInitializeSizes(SimStruct *S){  ssSetNumSFcnParams(S, 2);  ssSetNumContStates(S, 0);  ssSetNumDiscStates(S, 0);  ssSetNumInputPorts(S, 0);  ssSetNumOutputPorts(S, 0);  ssSetNumSampleTimes(S, 1);  ssSetNumDWork(S, 1);  // wall t0  ssSetDWorkWidth(S, 0, 1);  ssSetDWorkDataType(S, 0, SS_DOUBLE);}

/* * mdlInitializeSizes - initialize the sizes array */static void mdlInitializeSizes(SimStruct *S){    ssSetNumContStates(    S, 21);  /* number of continuous states           */    ssSetNumDiscStates(    S, 0);   /* number of discrete states             */    ssSetNumInputs(        S, 21);  /* number of inputs                      */    ssSetNumOutputs(       S, 21);  /* number of outputs                     */    ssSetDirectFeedThrough(S, 0);   /* direct feedthrough flag               */    ssSetNumSampleTimes(   S, 1);   /* number of sample times                */    ssSetNumSFcnParams(    S, 3);   /* number of input arguments             */    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*/}