/* 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 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);
real_T *Humidity = (real_T *)ssGetOutputPortRealSignal(S,0);
const int_T p_width0 = mxGetNumberOfElements(PARAM_DEF0(S));
const int_T p_width1 = mxGetNumberOfElements(PARAM_DEF1(S));
const int8_T *interruptNum = (const int8_T *)mxGetData(PARAM_DEF0(S));
const real_T *sampleTime = (const real_T *)mxGetData(PARAM_DEF1(S));
HH10D_Update_wrapper(Humidity, xD, interruptNum, p_width0, sampleTime, p_width1);
}
/* Function: mdlOutputs =======================================================
*
*/
static void mdlOutputs(SimStruct *S, int_T tid)
{
const real32_T *float_in = (const real32_T*) ssGetInputPortSignal(S,0);
uint32_T *fixed_out = (uint32_T *)ssGetOutputPortRealSignal(S,0);
const int_T p_width0 = mxGetNumberOfElements(PARAM_DEF0(S));
const int_T p_width1 = mxGetNumberOfElements(PARAM_DEF1(S));
const uint32_T *bitwidth = mxGetData(PARAM_DEF0(S));
const uint32_T *fp_position = mxGetData(PARAM_DEF1(S));
SDFPToFixed_Outputs_wrapper(float_in, fixed_out, bitwidth, p_width0, fp_position, p_width1);
}
/* 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 *micros = (const real_T*) ssGetInputPortSignal(S,0);
const int_T p_width0 = mxGetNumberOfElements(PARAM_DEF0(S));
const int_T p_width1 = mxGetNumberOfElements(PARAM_DEF1(S));
const real_T *S_T = (const real_T *)mxGetData(PARAM_DEF0(S));
const real_T *PIN = (const real_T *)mxGetData(PARAM_DEF1(S));
hitec_Update_wrapper(micros, xD, S_T, p_width0, PIN, p_width1);
}
/* 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);
real_T *Temp = (real_T *)ssGetOutputPortRealSignal(S,0);
const int_T p_width0 = mxGetNumberOfElements(PARAM_DEF0(S));
const int_T p_width1 = mxGetNumberOfElements(PARAM_DEF1(S));
const int8_T *i2cAddress = (const int8_T *)mxGetData(PARAM_DEF0(S));
const real_T *sampleTime = (const real_T *)mxGetData(PARAM_DEF1(S));
Tmp102_Update_wrapper(Temp, xD, i2cAddress, p_width0, sampleTime, p_width1);
}
/* Function: mdlOutputs =======================================================
*
*/
static void mdlOutputs(SimStruct *S, int_T tid)
{
const real_T *u0 = (const real_T*) ssGetInputPortSignal(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 int32_T *baud = (const int32_T *)mxGetData(PARAM_DEF0(S));
const int32_T *uart = (const int32_T *)mxGetData(PARAM_DEF1(S));
const real_T *SampleTime = (const real_T *)mxGetData(PARAM_DEF2(S));
}
/* Function: mdlOutputs =======================================================
*
*/
static void mdlOutputs(SimStruct *S, int_T tid)
{
uint8_T *y0 = (uint8_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 real_T *baud = (const real_T *)mxGetData(PARAM_DEF0(S));
const real_T *uart = (const real_T *)mxGetData(PARAM_DEF1(S));
const real_T *SampleTime = (const real_T *)mxGetData(PARAM_DEF2(S));
y0[0] = 0;
}
/* Function: mdlOutputs =======================================================
*
*/
static void mdlOutputs(SimStruct *S, int_T tid)
{
const real_T *pCyl = (const real_T*) ssGetInputPortSignal(S,0);
const real_T *tempCyl = (const real_T*) ssGetInputPortSignal(S,1);
const real_T *vCyl = (const real_T*) ssGetInputPortSignal(S,2);
const real_T *omega = (const real_T*) ssGetInputPortSignal(S,3);
const real_T *tempWall = (const real_T*) ssGetInputPortSignal(S,4);
real_T *dQ = (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 real_T *stroke = (const real_T *)mxGetData(PARAM_DEF0(S));
const real_T *B = (const real_T *)mxGetData(PARAM_DEF1(S));
const real_T *cAlpha = (const real_T *)mxGetData(PARAM_DEF2(S));
const real_T *nCyl = (const real_T *)mxGetData(PARAM_DEF3(S));
EngCylHeatTransfer_Outputs_wrapper(pCyl, tempCyl, vCyl, omega, tempWall, dQ, stroke, p_width0, B, p_width1, cAlpha, p_width2, nCyl, p_width3);
}
/* Function: mdlOutputs =======================================================
*
*/
static void mdlOutputs(SimStruct *S, int_T tid)
{
const uint32_T *in0 = (const uint32_T*) ssGetInputPortSignal(S,0);
const uint32_T *in1 = (const uint32_T*) ssGetInputPortSignal(S,1);
const uint32_T *in2 = (const uint32_T*) ssGetInputPortSignal(S,2);
const uint32_T *in3 = (const uint32_T*) ssGetInputPortSignal(S,3);
uint32_T *adder_out = (uint32_T *)ssGetOutputPortRealSignal(S,0);
uint32_T *DBG_in01 = (uint32_T *)ssGetOutputPortRealSignal(S,1);
uint32_T *DBG_in012 = (uint32_T *)ssGetOutputPortRealSignal(S,2);
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 uint32_T *in_bitwidth = (const uint32_T *)mxGetData(PARAM_DEF0(S));
const uint32_T *in_fp_position = (const uint32_T *)mxGetData(PARAM_DEF1(S));
const uint32_T *out_bitwidth = (const uint32_T *)mxGetData(PARAM_DEF2(S));
const uint32_T *out_fp_position = (const uint32_T *)mxGetData(PARAM_DEF3(S));
SDFPAdder4_Outputs_wrapper(in0, in1, in2, in3, adder_out, DBG_in01, DBG_in012, in_bitwidth, p_width0, in_fp_position, p_width1, out_bitwidth, p_width2, out_fp_position, p_width3);
}
static void mdlStart(SimStruct *S)
{
const real_T *pp1 = mxGetData(PARAM_DEF0(S));
const real_T *pp2 = mxGetData(PARAM_DEF1(S));
int P2=*pp2;
if(P2!=0)
ssSetOutputPortWidth(S, 0,P2);
int connected=0,accCon,portno;
struct sockaddr_in serv_addr;
char* P1=(char*)mxGetPr(ssGetSFcnParam(S,0));
char* last;
int num=mxGetNumberOfElements(ssGetSFcnParam(S,0));
int count;
char *port;
char porttemp[20];
/*Determine Port Number*/
portno =*pp1;
const int_T y_width = ssGetOutputPortWidth(S,0);
int yes=1;int i;
accCon = socket(AF_INET, SOCK_STREAM, 0);
if (accCon < 0)
error("ERROR opening socket");
bzero((char *) &serv_addr, sizeof(serv_addr));
setsockopt(accCon,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);
if (bind(accCon, (struct sockaddr *) &serv_addr,
sizeof(serv_addr)) < 0)
error("ERROR on binding");
fcntl(accCon, F_SETFL, O_NONBLOCK);
last = malloc( y_width);
for(i=0;i<y_width;i++)
last[i]=128;
ssSetIWorkValue(S, 0, connected);
ssSetIWorkValue(S, 1, accCon);
/*ssSetPWorkValue(S, 2, (void*) &cli_addr);*/
ssSetPWorkValue(S, 1, (void*) last);
}
/* 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 *FComb = (const real_T*) ssGetInputPortSignal(S,7);
const real_T *phi = (const real_T*) ssGetInputPortSignal(S,8);
const real_T *combState = (const real_T*) ssGetInputPortSignal(S,9);
real_T *p = (real_T *)ssGetOutputPortRealSignal(S,0);
real_T *Tu = (real_T *)ssGetOutputPortRealSignal(S,1);
real_T *Fu = (real_T *)ssGetOutputPortRealSignal(S,2);
real_T *Vu = (real_T *)ssGetOutputPortRealSignal(S,3);
real_T *Tb = (real_T *)ssGetOutputPortRealSignal(S,4);
real_T *Fb = (real_T *)ssGetOutputPortRealSignal(S,5);
real_T *Vb = (real_T *)ssGetOutputPortRealSignal(S,6);
const real_T *xC = ssGetContStates(S);
real_T *p_prev = (real_T*) ssGetDWork(S,0);
real_T *Tu_prev = (real_T*) ssGetDWork(S,1);
real_T *Fu_prev = (real_T*) ssGetDWork(S,2);
real_T *Ru_prev = (real_T*) ssGetDWork(S,3);
real_T *uu_prev = (real_T*) ssGetDWork(S,4);
real_T *Cvu_prev = (real_T*) ssGetDWork(S,5);
real_T *Tb_prev = (real_T*) ssGetDWork(S,6);
real_T *Fb_prev = (real_T*) ssGetDWork(S,7);
real_T *Rb_prev = (real_T*) ssGetDWork(S,8);
real_T *ub_prev = (real_T*) ssGetDWork(S,9);
real_T *Cvb_prev = (real_T*) ssGetDWork(S,10);
real_T *mCyl_prev = (real_T*) ssGetDWork(S,11);
real_T *mbCyl_prev = (real_T*) ssGetDWork(S,12);
real_T *VCyl_prev = (real_T*) ssGetDWork(S,13);
real_T *mu_prev = (real_T*) ssGetDWork(S,14);
real_T *mub_prev = (real_T*) ssGetDWork(S,15);
real_T *Vu_prev = (real_T*) ssGetDWork(S,16);
real_T *QCyl_prev = (real_T*) ssGetDWork(S,17);
real_T *HCyl_prev = (real_T*) ssGetDWork(S,18);
real_T *WCyl_prev = (real_T*) ssGetDWork(S,19);
real_T *mfb_prev = (real_T*) ssGetDWork(S,20);
real_T *mMix_prev = (real_T*) ssGetDWork(S,21);
real_T *mb0 = (real_T*) ssGetDWork(S,22);
real_T *ResetMix = (real_T*) ssGetDWork(S,23);
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_width9 = mxGetNumberOfElements(PARAM_DEF9(S));
const real_T *fs = (const real_T *)mxGetData(PARAM_DEF0(S));
const real_T *DPhiMix = (const real_T *)mxGetData(PARAM_DEF1(S));
const real_T *phiMix0 = (const real_T *)mxGetData(PARAM_DEF2(S));
const real_T *alpha = (const real_T *)mxGetData(PARAM_DEF3(S));
const real_T *hn = (const real_T *)mxGetData(PARAM_DEF4(S));
const real_T *nStroke = (const real_T *)mxGetData(PARAM_DEF9(S));
ThdynCVNV2Zone_Update_wrapper(phi,FComb,combState,p,Tu,Fu,Vu,Tb,Fb,Vb,
xC,p_prev,Tu_prev,Fu_prev,Ru_prev,uu_prev,Cvu_prev,
Tb_prev,Fb_prev,Rb_prev,ub_prev,Cvb_prev,
mCyl_prev,mbCyl_prev,VCyl_prev,QCyl_prev,HCyl_prev,WCyl_prev,
mu_prev,mub_prev,Vu_prev,mfb_prev,
mMix_prev,mb0,ResetMix,
fs,p_width0,DPhiMix,p_width1,phiMix0,p_width2,
alpha,p_width3,hn,p_width4,nStroke,p_width9);
}
