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

/* 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: *   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){    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, 0)) return;    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, 1);    ssSetOutputPortDataType(S, 0, SS_DOUBLE);  /* same as clock block */    ssSetOutputPortConstOutputExprInRTW(S, 0, 1);    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_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;    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));}

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

/* 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, s, states, etc.).static void mdlInitializeSizes(SimStruct *S){    ssSetNumSFcnParams(S, NPARAMS);#if defined(MATLAB_MEX_FILE)    if(ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)){        mdlCheckParameters(S);        if(ssGetErrorStatus(S)!=NULL){            return;        }        else{            cout<<"All parameters have been checked and passed correctly"<<endl;        }    } else{        return; // Parameter mismatch reported by Simulink    }#endif    // Parameter mismatch will be reported by Simulink    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        return;    }    // Specify I/O    // INPUTS    if(!ssSetNumInputPorts(S,0)) return;    // OUTPUTS    if (!ssSetNumOutputPorts(S,SIZE_READING_PORT)) return;    for (int i = 0; i < SIZE_READING_PORT; i++)    {        ssSetOutputPortWidth   (S, i, 1);        ssSetOutputPortDataType(S, i, 0);    }        ssSetNumSampleTimes(S, 1);    // Reserve place for C++ object    ssSetNumPWork(S, 1);    // DWork vectors    ssSetNumDWork(S, 1);    ssSetDWorkWidth(S, 0, 1);    ssSetDWorkDataType(S, 0, SS_DOUBLE);    ssSetSimStateCompliance(S, USE_CUSTOM_SIM_STATE);    ssSetOptions(S,                 SS_OPTION_WORKS_WITH_CODE_REUSE |                 SS_OPTION_EXCEPTION_FREE_CODE |                 SS_OPTION_ALLOW_INPUT_SCALAR_EXPANSION |                 SS_OPTION_USE_TLC_WITH_ACCELERATOR);}

static void mdlInitializeSizes(SimStruct *S){    int_T   status;                                 // for new type definition    DTypeId COM_HANDLE_id;                          // for new type definition    HANDLE  handle_aux;                             // for new type definition//======================================================     new type definition    COM_HANDLE_id = ssRegisterDataType(S, "COM_HANDLE");    if(COM_HANDLE_id == INVALID_DTYPE_ID) return;    status = ssSetDataTypeSize(S, COM_HANDLE_id, sizeof(handle_aux));    if(status == 0) return;    status = ssSetDataTypeZero(S, COM_HANDLE_id, &handle_aux);    if(status == 0) return;//===============================================================     parameters    ssSetNumSFcnParams(S, 2);                           // 2 parameters:                                                        //      - COM port                                                        //      - baudrate    //Parameter mismatch will be reported by Simulink    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S))        return;//===================================================================     inputs   if (!ssSetNumInputPorts(S, 0)) return;               // 0 inputs//==================================================================     outputs    if (!ssSetNumOutputPorts(S, 1)) return;             // 1 outputs:                                                        //      - COM handle//////////////////////////////   com handle   //////////////////////////////    ssSetOutputPortWidth(S,0,1);                        // input 1 width    ssSetOutputPortDataType(S, 0, COM_HANDLE_id);       // input 1 datatype//=============================================================     sample times    ssSetNumSampleTimes(  S, 1);                // number of sample times//=============================================================     work vectors    ssSetNumRWork(S, 0);                        // 0 real work vector elements    ssSetNumIWork(S, 0);                        // 0 work vector elements    ssSetNumPWork(S, 1);                        // 1 pwork vector elements:                                                //      - COM handle    ssSetNumModes(S, 0);                        // 0  mode work vector elements    ssSetNumNonsampledZCs(S, 0);                // 0  nonsampled zero crossings    }

/* 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: *   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){    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 */

/* 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: *    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, 1)) return;    ssSetInputPortWidth(S, 0, 1);    ssSetInputPortDataType(S, 0, SS_UINT32);    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);        ssSetOutputPortDataType(S, 0, SS_UINT32);        ssSetNumSampleTimes(S, 1);        ssSetNumRWork(S, 1);    ssSetNumIWork(S, 1);    //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);}

/* 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: *   Setup sizes of the various vectors. */static void mdlInitializeSizes(SimStruct *S){    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;    if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;    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));}

static void mdlSetDefaultPortDataTypes(SimStruct *S){  ssSetInputPortDataType( S, 0, SS_DOUBLE); ssSetOutputPortDataType(S, 0, SS_DOUBLE);}

static void mdlSetOutputPortDataType(SimStruct *S, int port, DTypeId dType){    ssSetOutputPortDataType(S, 0, dType);}