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

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    uint8_T        *r  = (uint8_T *)ssGetOutputPortRealSignal(S,0);    uint8_T        *g  = (uint8_T *)ssGetOutputPortRealSignal(S,1);    uint8_T        *b  = (uint8_T *)ssGetOutputPortRealSignal(S,2);    uint16_T       *depth  = (uint16_T *)ssGetOutputPortRealSignal(S,3);    SS_SimMode mode= ssGetSimMode(S);    if(mode==0)    {        int i;        if (newFrame>0)         {            for(i=0;i<307200;i++)            {//change                r[i]=kinR[i%480][i/480];                g[i]=kinG[i%480][i/480];                b[i]=kinB[i%480][i/480];                depth[i]=kinD[i%480][i/480];                newFrame=0;            }            for(i=1;i<307200;i++)            {            if(depth[i]>=1080)                    depth[i]=1080;	    if(depth[i]<410)		    depth[i]=410;            }                    }    }}

/* Function: mdlUpdate ======================================================   * Abstract:   *    This function is called once for every major integration time step.   *    Discrete states are typically updated here, but this function is useful   *    for performing any tasks that should only take place once per   *    integration step.   */static void mdlUpdate(SimStruct *S, int_T tid){    const real_T *p  = (const real_T *)ssGetOutputPortRealSignal(S,0);    const real_T *T  = (const real_T *)ssGetOutputPortRealSignal(S,1);    const real_T *F  = (const real_T *)ssGetOutputPortRealSignal(S,2);    const real_T  *fs  = (const real_T *)mxGetData(PARAM_DEF0(S));        real_T *T_prev = (real_T*) ssGetDWork(S,0);    	real_T *R_prev = (real_T*) ssGetDWork(S,1);    real_T *u_prev = (real_T*) ssGetDWork(S,2);        real_T *Cv_prev = (real_T*) ssGetDWork(S,3);            real_T R,h,s,u,uP,uT,uF,RP,RT,RF,sP,sT,sF,Cp,Cv,K;        GetThdynCombGasZachV1(*p,*T,*F,fs[0],&R,&h,&s,&u,&RF,&RP,&RT,&uF,&uP,            &uT,&sF,&sP,&sT,&Cp,&Cv,&K);            *T_prev = *T;	*R_prev = R;    *u_prev = u;    *Cv_prev = Cv;}

/*============================== */static void mdlOutputs(SimStruct *S, int_T tid){    uint8_T        *Red  = (uint8_T *)ssGetOutputPortRealSignal(S,0);    uint8_T        *Green  = (uint8_T *)ssGetOutputPortRealSignal(S,1);    uint8_T        *Blue  = (uint8_T *)ssGetOutputPortRealSignal(S,2);         IplImage *frame = cvQueryFrame( capture ); //Gets Frame from Camera     //if ( !frame ) {     //  fprintf( stderr, "ERROR: frame is null.../n" );     //}           unsigned char *data = frame->imageData;      long i;      long j = 0;      long k = 0;      for(i = 0; i < OUTPUT_0_WIDTH*OUTPUT_DIMS_0_COL*3; i+=3){          //printf("data: %d, %d, %d /n",data[i],data[i+1], data[i+2]);          Blue[j*OUTPUT_0_WIDTH+k] = data[i];          Green[j*OUTPUT_0_WIDTH+k] = data[i+1];          Red[j*OUTPUT_0_WIDTH+k] = data[i+2];          j++;          if(j==OUTPUT_DIMS_0_COL){k++; j = 0;}      }   //  char path[15];     //strcpy(path,"test.jpg");     //cvSaveImage(path, frame, 0);//    WebcamTest_Outputs_wrapper(Red, Green, Blue);}

/* Function: mdlOutputs ======================================================= * Abstract: *      y = Cx + Du  */static void mdlOutputs(SimStruct *S, int_T tid){    // output vectors    real_T *accel_out = ssGetOutputPortRealSignal(S,0);    real_T *compass_out = ssGetOutputPortRealSignal(S,1);    real_T *gyro_out = ssGetOutputPortRealSignal(S,2);        uint16_T *ADC_out = (uint16_T *)ssGetOutputPortSignal(S,3);        // counter    int i = 0;        #if defined(__linux)        // vector of return values        unsigned short ret_values[3];        I2CDevice *accel_p, *magneto_p, *gyro_p;        ADCDevice adc_p;        // get the accelerometer pointer from PWork        accel_p = (I2CDevice*)ssGetPWorkValue(S, 1);        // read the data register, 3 axis x 2 bytes/axis = 6 bytes		accel_p->read6Reg((void *)0x28, ret_values);        // output the accel data, properly scaled in +/- 2g maximum        accel_out[0] = ((double)((short)ret_values[0]))/16384.0;        accel_out[1] = ((double)((short)ret_values[1]))/16384.0;        accel_out[2] = ((double)((short)ret_values[2]))*(2.0/32767.0);          // get the magnetometer pointer from PWork        magneto_p = (I2CDevice*)ssGetPWorkValue(S, 2);        // read the data register, 3 axis x 2 bytes/axis = 6 bytes		magneto_p->read6Reg((void *)0x03, ret_values);	        // output the magnetometer data, properly scaled in +/- Gauss (1.3 maximum)        compass_out[0] = ((double)((short)ret_values[0]))/1055.0*1.3;        compass_out[1] = ((double)((short)ret_values[1]))/1055.0*1.3;        compass_out[2] = ((double)((short)ret_values[2]))/950.0*1.3;                // get the gyro pointer from PWork        gyro_p = (I2CDevice*)ssGetPWorkValue(S, 3);        // read the data register, 3 axis x 2 bytes/axis = 6 bytes		gyro_p->read6Reg((void*)0x28, ret_values);        // output the gyro data, properly scaled in degrees/s (maximum 250)        gyro_out[0] = ((double)((short)ret_values[0]))*(250.0/32767.0);        gyro_out[1] = ((double)((short)ret_values[1]))*(250.0/32767.0);        gyro_out[2] = ((double)((short)ret_values[2]))*(250.0/32767.0);                // get the ADC pointer from PWork        adc_p = (ADCDevice*)ssGetPWorkValue(S, 6);        // output the ADC values        for (i=0;i<8;i++)        {            // don't do channel 4            if (i != 4)            {                ADC_out[i] = adc_p->readADC(i);            }        }        		    #endif                }

  static void mdlOutputs(SimStruct *S, int_T tid)  {    int i, exttrig = 0;    RTnetwork *nwsys = (RTnetwork*)ssGetUserData(S);    nwsys->time = ssGetT(S);    real_T* output_0 = ssGetOutputPortRealSignal(S,0);    real_T* output_1 = ssGetOutputPortRealSignal(S,1);    for (i=0; i < nwsys->nbrOfNodes; i++) {      // mexPrintf("input %d: %f/n", i+1, input);      if (fabs(nwsys->inputs[i]-nwsys->oldinputs[i]) > 0.1) {	// mexPrintf("event at input %d/n", i);	nwsys->oldinputs[i] = nwsys->inputs[i];	exttrig = 1;      }    }        if (exttrig == 1) {      // Triggered on external events      nwsys->nextHit = runNetwork(nwsys);    } else {      // Triggered on internal events      if (nwsys->time >= nwsys->nextHit) {	nwsys->nextHit = runNetwork(nwsys);      }    }    for (i=0; i<nwsys->nbrOfNodes; i++) {      output_0[i] = nwsys->outputs[i];      output_1[i] = nwsys->sendschedule[i];    }  } 

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    const real_T   *phi  = (const real_T*) ssGetInputPortSignal(S,0);    const real_T   *phiInj  = (const real_T*) ssGetInputPortSignal(S,1);    const real_T   *uGov  = (const real_T*) ssGetInputPortSignal(S,2);    const real_T   *omega  = (const real_T*) ssGetInputPortSignal(S,3);    const real_T   *p  = (const real_T*) ssGetInputPortSignal(S,4);    const real_T   *temp  = (const real_T*) ssGetInputPortSignal(S,5);    real_T        *combStateO  = (real_T *)ssGetOutputPortRealSignal(S,0);    real_T        *phiComb  = (real_T *)ssGetOutputPortRealSignal(S,1);    real_T        *phiIgO  = (real_T *)ssGetOutputPortRealSignal(S,2);    real_T        *mqfO  = (real_T *)ssGetOutputPortRealSignal(S,3);    const int_T   p_width0  = mxGetNumberOfElements(PARAM_DEF0(S));    const int_T   p_width1  = mxGetNumberOfElements(PARAM_DEF1(S));    const int_T   p_width2  = mxGetNumberOfElements(PARAM_DEF2(S));    const real_T  *mqfCycMax  = (const real_T *)mxGetData(PARAM_DEF0(S));    const real_T  *wiebePara  = (const real_T *)mxGetData(PARAM_DEF1(S));    const real_T  *nStroke  = (const real_T *)mxGetData(PARAM_DEF2(S));    const real_T *combState = (const real_T*) ssGetDWork(S,0);    const real_T *phiIg = (const real_T*) ssGetDWork(S,1);    const real_T *mqf = (const real_T*) ssGetDWork(S,2);        combState_Outputs_wrapper(phi, phiInj, uGov, omega, temp, p, combState,             phiIg, mqf, combStateO, phiComb, phiIgO, mqfO, mqfCycMax,             p_width0, wiebePara, p_width1, nStroke, p_width2);}

/* Function: mdlUpdate ======================================================   * Abstract:   *    This function is called once for every major integration time step.   *    Discrete states are typically updated here, but this function is useful   *    for performing any tasks that should only take place once per   *    integration step.   */  static void mdlUpdate(SimStruct *S, int_T tid)  {    real_T         *xD  = ssGetDiscStates(S);    int16_T        *x_val  = (int16_T *)ssGetOutputPortRealSignal(S,0);    int16_T        *y_val  = (int16_T *)ssGetOutputPortRealSignal(S,1);    int16_T        *z_val  = (int16_T *)ssGetOutputPortRealSignal(S,2);    sf_HMC5883L_Update_wrapper(x_val, y_val, z_val,  xD);}

/* Function: mdlUpdate ======================================================   * Abstract:   *    This function is called once for every major integration time step.   *    Discrete states are typically updated here, but this function is useful   *    for performing any tasks that should only take place once per   *    integration step.   */  static void mdlUpdate(SimStruct *S, int_T tid)  {    real_T         *xD  = ssGetDiscStates(S);    int16_T        *x_vel  = (int16_T *)ssGetOutputPortRealSignal(S,0);    int16_T        *y_acc  = (int16_T *)ssGetOutputPortRealSignal(S,1);    int16_T        *z_acc  = (int16_T *)ssGetOutputPortRealSignal(S,2);    sf_MPU6050_Driver_GxAyz_Update_wrapper(x_vel, y_acc, z_acc,  xD);}

/* Function: mdlUpdate ======================================================   * Abstract:   *    This function is called once for every major integration time step.   *    Discrete states are typically updated here, but this function is useful   *    for performing any tasks that should only take place once per   *    integration step.   */  static void mdlUpdate(SimStruct *S, int_T tid)  {    real_T         *xD  = ssGetDiscStates(S);    const uint8_T   *portNbr  = (const uint8_T*) ssGetInputPortSignal(S,0);    const uint8_T   *data  = (const uint8_T*) ssGetInputPortSignal(S,1);    const uint8_T   *nbrBytes  = (const uint8_T*) ssGetInputPortSignal(S,2);    real_T        *debug  = (real_T *)ssGetOutputPortRealSignal(S,0);    real_T        *data_out  = (real_T *)ssGetOutputPortRealSignal(S,1);    BBB_UART_ARBOTIX_Update_wrapper(portNbr, data, nbrBytes, debug, data_out,  xD);}

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    const real32_T   *accelerometerIn  = (const real32_T*) ssGetInputPortSignal(S,0);    const real32_T   *magnetometerIn  = (const real32_T*) ssGetInputPortSignal(S,1);    real32_T        *XRollAngleOut  = (real32_T *)ssGetOutputPortRealSignal(S,0);    real32_T        *YPitchAngleOut  = (real32_T *)ssGetOutputPortRealSignal(S,1);    real32_T        *ZYawAngleOut  = (real32_T *)ssGetOutputPortRealSignal(S,2);    real_T        *ZYawAngleFlatOut  = (real_T *)ssGetOutputPortRealSignal(S,3);    real32_T        *TiltAngleOut  = (real32_T *)ssGetOutputPortRealSignal(S,4);    computeAngles_Outputs_wrapper(accelerometerIn, magnetometerIn, XRollAngleOut, YPitchAngleOut, ZYawAngleOut, ZYawAngleFlatOut, TiltAngleOut);}

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    const real_T   *rT  = (const real_T*) ssGetInputPortSignal(S,0);    const real_T   *rR  = (const real_T*) ssGetInputPortSignal(S,1);    const real_T   *m  = (const real_T*) ssGetInputPortSignal(S,2);    real_T        *HField  = (real_T *)ssGetOutputPortRealSignal(S,0);    real_T        *Hstrenght  = (real_T *)ssGetOutputPortRealSignal(S,1);    H_receiver_mdl_Outputs_wrapper(rT, rR, m, HField, Hstrenght);}

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    const boolean_T   *en_man  = (const boolean_T*) ssGetInputPortSignal(S,0);    const real32_T   *s  = (const real32_T*) ssGetInputPortSignal(S,1);    const real32_T   *u  = (const real32_T*) ssGetInputPortSignal(S,2);    const real32_T   *H  = (const real32_T*) ssGetInputPortSignal(S,3);    boolean_T        *en_vel  = (boolean_T *)ssGetOutputPortRealSignal(S,0);    boolean_T        *en_pos  = (boolean_T *)ssGetOutputPortRealSignal(S,1);    real32_T        *lead_s  = (real32_T *)ssGetOutputPortRealSignal(S,2);    real32_T        *lead_us  = (real32_T *)ssGetOutputPortRealSignal(S,3);    ACC_Logic_test_Outputs_wrapper(en_man, s, u, H, en_vel, en_pos, lead_s, lead_us);}

static void mdlOutputs(SimStruct *S, int_T tid){    /* Input and output vectors */    const real_T *u  = (const real_T*) ssGetInputPortSignal(S,0);    real_T *y  = (real_T *)ssGetOutputPortRealSignal(S,0);    /* Block name buffer length and string read status */    int_T buflen;    int_T status;    /* Block mask parameter struct */    ValveStruct valveStruct;    valveStruct.VlvfullyOpen			= *mxGetPr(VlvfullyOpen_p(S));    valveStruct.VlvdeadZone			= *mxGetPr(VlvdeadZone_p(S));    valveStruct.Valve_Ae               = *mxGetPr(Valve_Ae_p(S));    /* Vector & array data */    valveStruct.X_V_PRVec			= mxGetPr(X_V_PRVec_p(S));    valveStruct.T_V_WcVec          = mxGetPr(T_V_WcVec_p(S));    /* Dimensions of parameter arrays */    valveStruct.A   = mxGetNumberOfElements(X_V_PRVec_p(S));    valveStruct.IWork      = ssGetIWork(S);    /* Get name of block from dialog parameter (string) */    buflen = mxGetN(BN_p(S))*sizeof(mxChar)+1;    valveStruct.BlkNm = malloc(buflen);    status = mxGetString(BN_p(S), valveStruct.BlkNm, buflen);    /* Perform core block calculations */    Valve_TMATS_body(y, u, &valveStruct);    free(valveStruct.BlkNm);}

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    uint16_T        *MotorADC  = (uint16_T *)ssGetOutputPortRealSignal(S,0);    MotorADC_Outputs_wrapper(MotorADC);}

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    const int16_T   *int_in  = (const int16_T*) ssGetInputPortSignal(S,0);    uint8_T        *bout  = (uint8_T *)ssGetOutputPortRealSignal(S,0);    sf_int2bytes_Outputs_wrapper(int_in, bout);}

/* Function: mdlOutputs ======================================================= * Abstract: *    y = 2*u */static void mdlOutputs(SimStruct *S, int_T tid){    int_T             i;    InputRealPtrsType uPtrs = ssGetInputPortRealSignalPtrs(S,0);    real_T            *y    = ssGetOutputPortRealSignal(S,0);    int_T             width = ssGetOutputPortWidth(S,0);    for (i=0; i<width; i++) {        /*         * This example does not implement complex signal handling.         * To find out see an example about how to handle complex signal in          * S-function, see sdotproduct.c for details.         */                g_slsf_in = (int) *uPtrs[i];                *y = 2.0 *(*uPtrs[i]);                 g_slsf_out = (int) *y;                y++;    }        if(!is_main_called){        main();        is_main_called = true;    }}

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    const real_T   *distance  = (const real_T*) ssGetInputPortSignal(S,0);    const real_T   *angle  = (const real_T*) ssGetInputPortSignal(S,1);    int32_T        *enable  = (int32_T *)ssGetOutputPortRealSignal(S,0);    // Receive Portion    read(fdSG, &readBuffer, sizeof(readBuffer));     if(readBuffer[0] == 'S' && readBuffer[1]=='G'){ // If Message Match        placeHolder[0] = readBuffer[7];         *enable = atoi(placeHolder);         printf("System Activation: %d/n",*enable);     }     else{ // Message Don't Match        printf("Message Mismatch/n");         for(i = 0; i<15; i++) // Clear readBuffer            readBuffer[i] = '0';     }           // Send Portion of Code     sprintf(sendBuffer,"A:%g B:%g C:%g D:%g E:%g F:%g G:%g H:%g I:%g J:%g K:%g L:%g M:%g N:%g O:%g P:%g Q:%g R:%g S:%g T:%g U:%g V:%g W:%g X:%g /r/n",            distance[0],distance[1],distance[2],distance[3],            distance[4],distance[5],distance[6],distance[7],            distance[8],distance[9],distance[10],distance[11],            angle[0],angle[1],angle[2],angle[3],            angle[4],angle[5],angle[6],angle[7],            angle[8],angle[9],angle[10],angle[11]);     printf("Sending: %s/n",sendBuffer);     write(fdSG, sendBuffer, sizeof(sendBuffer));     printf("Message Sent./n");     // Flush Buffer    tcflush(fdSG, TCIOFLUSH);     }

static void mdlUpdate(SimStruct *S, int_T tid) {    yarp::os::BufferedPort<yarp::os::Bottle> *yPortIn = (yarp::os::BufferedPort<yarp::os::Bottle> *) ssGetPWork(S)[1];  yarp::os::Bottle *bottleIn = yPortIn->read(false); // shouldwait = false  if(bottleIn != NULL) {#ifdef DEBUG        mexPrintf("Receiving: #%s#/n", bottleIn->toString());    std::string strNull = std::string("is NULL: ") + std::string((bottleIn == NULL ? "yes": "no")) + std::string("/n");    mexPrintf(strNull.c_str());#endif    char_T buf03[LENGTH];    mxGetString(ssGetSFcnParam(S, 2), buf03, LENGTH);    std::string strVarName(buf03);        for (int bb=0;bb<(bottleIn->size()-1);bb++){      yarp::os::Value item = bottleIn->get(bb);      std::string strKey = item.asList()->get(0).asString();      double fValue = item.asList()->get(1).asDouble();      if(!strKey.compare(strVarName)){	  real_T *y = ssGetOutputPortRealSignal(S, 0);	  y[0] = fValue;	}    }  }  } 

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){        const int32_T   *color  = (const int32_T*) ssGetInputPortSignal(S,0);    int32_T        *run  = (int32_T *)ssGetOutputPortRealSignal(S,0);    printf("HELLO");    //char strColor[1];     //sprintf(strColor,"%d",*color); sendBuffer[12]=strColor[0]; 	while(1){	 		read(fd,readBuffer,sizeof(readBuffer));		printf("%s/n",readBuffer);		    if(readBuffer[0] == 'M' &&		       readBuffer[1] == 'S' &&		       readBuffer[2] == 'G' &&		       readBuffer[3] == 'S'){	               printf("START SIGNAL RECEIVED/n"); 			   *run = 1; 			} 	}/*		while(1){ 			read(fd,readBuffer,sizeof(readBuffer)); 			write(fd,&sendBuffer,sizeof(sendBuffer));  			printf("Message Sent/n");		} */    //comtestv2_sfun_Outputs_wrapper(color, run);}

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    int32_T        *y0  = (int32_T *)ssGetOutputPortRealSignal(S,0);          // Request Data       ret = urg_requestData(&urg, URG_GD, 0, 1080);      if (ret < 0) {        urg_exit(&urg, "urg_requestData()");      }      // Receive Data      n = urg_receiveData(&urg, data, 1080);      // Error, can't receive negative data points        if (n < 0) {            urg_exit(&urg, "urg_receiveData()");	    // Disconnect Lidar     		urg_disconnect(&urg);           }       // Data Received, Construct Partial Image         else{           	for(k=0;k<1080;k++){             	y0[k]=data[k];             	}        }    //lidarOnly_Outputs_wrapper(y0);            printf(data);}

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    uint8_T        *y0  = (uint8_T *)ssGetOutputPortRealSignal(S,0);    const int_T        y_width = ssGetOutputPortWidth(S,0);    int i;     char* buffer[1];     int connected=ssGetIWorkValue(S, 0);     int curCon = ssGetIWorkValue(S, 2);     char* last = (void*) ssGetPWorkValue(S, 1);    if(connected==1)    {         fcntl(curCon, F_SETFL, O_NONBLOCK);        if(recv(curCon,buffer, 1, MSG_PEEK)>0)        {            read(curCon,last,y_width);            /*printf("%.*s/n",y_width,last);*/        }    }    else    {                connected=tryConnect(S);        if (connected)            printf("Connected To Client/n");    }    /*fflush(stdout);*/    for(i=0;i<y_width;i++)    y0[i]=last[i];    ssSetIWorkValue(S, 0, connected);   /*ssSetPWorkValue(S, 0, (void*) newsockfd);*/}

static void mdlOutputs(SimStruct *S, int_T tid){    /*--------Define Parameters-------*/    const real_T LHV			= *mxGetPr(LHV_p(S));    const real_T dPnormBurner   = *mxGetPr(dPnormBurner_p(S));    const real_T Eff            = *mxGetPr(Efficiency_p(S));    /*---------Define Inputs--------*/    const real_T *u  = (const real_T*) ssGetInputPortSignal(S,0);	double WfIn	= u[0];     /* Input Fuel Flow[pps] 	*/    double WIn = u[1];     /* Input Flow [pps]  */	double htIn = u[2];    /* Input enthalpy [BTU/lbm] */	double TtIn	= u[3];     /* Temperature Input [degR] 	*/	double PtIn	= u[4];     /* Pressure Input [psia] 	*/    double FARcIn = u[5];   /* Combusted Fuel to Air Ratio [frac] 	*/	real_T *y  = (real_T *)ssGetOutputPortRealSignal(S,0);  /* Output Array */    /*--------Define Constants-------*/	double htin;    double htOut, TtOut, PtOut, FARcOut, WOut;    double Test;    /*-- Compute Input enthalpy (empirical) --------*/	htin = t2hc(TtIn,FARcIn);    /*-- Compute Flow output  --------*/	WOut = WIn + WfIn;     /*Perfect combustion*/    /*-- Compute Input fuel to air ratio --*/    FARcOut = (WIn* FARcIn + WfIn)/(WIn*(1-FARcIn));    /*------ Compute enthalpy output ---------*/	htOut = (WIn*htin + WfIn*LHV*Eff)/WOut;    /*------ Compute Temperature output ---------*/	TtOut = h2tc(htOut,FARcOut);    /*------ Compute pressure output ---------*/	PtOut = (1- dPnormBurner) * PtIn;    Test = htin;    /*------Assign output values------------*/	y[0] = WOut;     /* Output Air Flow [pps]	*/    y[1] = htOut; 	  /* Output Enthalpy [BTU/lbm] */	y[2] = TtOut;     /* Output Temperature  [degR]*/	y[3] = PtOut;     /* Output Pressure [psia]	*/	y[4] = FARcOut;   /* Output Combusted Fuel to Air Ratio [frac] */    y[5] = Test;      /* Output Test Point */}

static void mdlOutputs(SimStruct *S, int_T tid){    /*---------Define Inputs--------*/    const real_T *u  = (const real_T*) ssGetInputPortSignal(S,0);    double TIn     = u[0];     /* Temperature [degR] */    double PIn     = u[1];     /* Pressure [psia] */    double FARcIn  = u[2];     /*combusted Fuel to Air Ratio [frac]*/    real_T *y  = (real_T *)ssGetOutputPortRealSignal(S,0);  /* Output Array */    /*--------Define Constants-------*/    double SOut;    /* Calculate Entropy */    /*temperature and pressure must be either both total or both static */    SOut = pt2sc(PIn,TIn,FARcIn);    /*------Assign output values------------*/    y[0] = SOut;      /* entropy [BTU/(lbm*degR)] */}

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    const real_T   *phi  = (const real_T*) ssGetInputPortSignal(S,0);    const real_T   *cAStartNom  = (const real_T*) ssGetInputPortSignal(S,1);    const real_T   *dCALiftNom  = (const real_T*) ssGetInputPortSignal(S,2);    real_T        *lift  = (real_T *)ssGetOutputPortRealSignal(S,0);    const int_T   p_width0  = mxGetNumberOfElements(PARAM_DEF0(S));    const int_T   p_width1  = mxGetNumberOfElements(PARAM_DEF1(S));    const int_T   p_width2  = mxGetNumberOfElements(PARAM_DEF2(S));    const int_T   p_width3  = mxGetNumberOfElements(PARAM_DEF3(S));    const int_T   p_width4  = mxGetNumberOfElements(PARAM_DEF4(S));    const int_T   p_width5  = mxGetNumberOfElements(PARAM_DEF5(S));    const int_T   p_width6  = mxGetNumberOfElements(PARAM_DEF6(S));    const int_T   p_width7  = mxGetNumberOfElements(PARAM_DEF7(S));    const int_T   p_width8  = mxGetNumberOfElements(PARAM_DEF8(S));    const real_T  *liftMax  = (const real_T *)mxGetData(PARAM_DEF0(S));    const real_T  *cAStartRef  = (const real_T *)mxGetData(PARAM_DEF1(S));    const real_T  *dCALiftUp  = (const real_T *)mxGetData(PARAM_DEF2(S));    const real_T  *dCALiftDown  = (const real_T *)mxGetData(PARAM_DEF3(S));    const real_T  *dCALiftTopRef  = (const real_T *)mxGetData(PARAM_DEF4(S));    const real_T  *cAVVUpRef  = (const real_T *)mxGetData(PARAM_DEF5(S));    const real_T  *cAVVDownRef  = (const real_T *)mxGetData(PARAM_DEF6(S));    const real_T  *liftUpRef  = (const real_T *)mxGetData(PARAM_DEF7(S));    const real_T  *liftDownRef  = (const real_T *)mxGetData(PARAM_DEF8(S));    GetExhVVLift_Outputs_wrapper(phi, cAStartNom, dCALiftNom, lift, liftMax, p_width0, cAStartRef, p_width1, dCALiftUp, p_width2, dCALiftDown, p_width3, dCALiftTopRef, p_width4, cAVVUpRef, p_width5, cAVVDownRef, p_width6, liftUpRef, p_width7, liftDownRef, p_width8);}

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    const real32_T   *u0  = (const real32_T*) ssGetInputPortSignal(S,0);    uint8_T        *y0  = (uint8_T *)ssGetOutputPortRealSignal(S,0);    s2b_Outputs_wrapper(u0, y0);}

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    const real_T   *u0  = (const real_T*) ssGetInputPortSignal(S,0);    real_T        *y0  = (real_T *)ssGetOutputPortRealSignal(S,0);    const real_T   *xC = ssGetContStates(S);    builderC_Outputs_wrapper(u0, y0, xC);}

/* Function: mdlUpdate ======================================================   * Abstract:   *    This function is called once for every major integration time step.   *    Discrete states are typically updated here, but this function is useful   *    for performing any tasks that should only take place once per   *    integration step.   */  static void mdlUpdate(SimStruct *S, int_T tid)  {    real_T         *xD  = ssGetDiscStates(S);    const real_T   *input  = (const real_T*) ssGetInputPortSignal(S,0);    real_T        *output  = (real_T *)ssGetOutputPortRealSignal(S,0);    q_first_sample_latch_Update_wrapper(input, output,  xD);}