/* Outputs for root system: '<Root>' */ static void mdlOutputs(SimStruct *S, int_T tid) { BlockIO_Hammerstein *_rtB; _rtB = ((BlockIO_Hammerstein *) ssGetLocalBlockIO(S)); /* DiscreteStateSpace: '<S1>/LinearModel' */ { ((BlockIO_Hammerstein *) ssGetLocalBlockIO(S))->LinearModel = 1.0*((real_T*) ssGetDWork(S, 0))[0]; } /* Level2 S-Function Block: '<S1>/Pwlinear1' (sfunpwlinear) */ { SimStruct *rts = ssGetSFunction(S, 0); sfcnOutputs(rts, 0); if (ssGetErrorStatus(rts) != (NULL)) return; } /* Outport: '<Root>/Out1' */ ((real_T *)ssGetOutputPortSignal(S, 0))[0] = _rtB->Pwlinear1; /* Level2 S-Function Block: '<S1>/Pwlinear' (sfunpwlinear) */ { SimStruct *rts = ssGetSFunction(S, 1); sfcnOutputs(rts, 0); if (ssGetErrorStatus(rts) != (NULL)) return; } /* tid is required for a uniform function interface. * Argument tid is not used in the function. */ UNUSED_PARAMETER(tid); }
/* Model step function */ void Hammerstein_step(void) { /* DiscreteStateSpace: '<S1>/LinearModel' */ { Hammerstein_B.LinearModel = Hammerstein_P.LinearModel_C* Hammerstein_DWork.LinearModel_DSTATE; } /* Level2 S-Function Block: '<S1>/Pwlinear1' (sfunpwlinear) */ { SimStruct *rts = Hammerstein_M->childSfunctions[0]; ssSetOutputPortSignal(rts, 0, &Hammerstein_Y.Out1); sfcnOutputs(rts, 0); } /* Level2 S-Function Block: '<S1>/Pwlinear' (sfunpwlinear) */ { SimStruct *rts = Hammerstein_M->childSfunctions[1]; sfcnOutputs(rts, 0); } /* Update for DiscreteStateSpace: '<S1>/LinearModel' */ { Hammerstein_DWork.LinearModel_DSTATE = Hammerstein_B.Pwlinear + Hammerstein_P.LinearModel_A*Hammerstein_DWork.LinearModel_DSTATE; } /* Matfile logging */ rt_UpdateTXYLogVars(Hammerstein_M->rtwLogInfo, (Hammerstein_M->Timing.t)); /* signal main to stop simulation */ { /* Sample time: [0.06s, 0.0s] */ if ((rtmGetTFinal(Hammerstein_M)!=-1) && !((rtmGetTFinal(Hammerstein_M)-Hammerstein_M->Timing.t[0]) > Hammerstein_M->Timing.t[0] * (DBL_EPSILON))) { rtmSetErrorStatus(Hammerstein_M, "Simulation finished"); } if (rtmGetStopRequested(Hammerstein_M)) { rtmSetErrorStatus(Hammerstein_M, "Simulation finished"); } } /* Update absolute time for base rate */ /* The "clockTick0" counts the number of times the code of this task has * been executed. The absolute time is the multiplication of "clockTick0" * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not * overflow during the application lifespan selected. * Timer of this task consists of two 32 bit unsigned integers. * The two integers represent the low bits Timing.clockTick0 and the high bits * Timing.clockTickH0. When the low bit overflows to 0, the high bits increment. */ if (!(++Hammerstein_M->Timing.clockTick0)) { ++Hammerstein_M->Timing.clockTickH0; } Hammerstein_M->Timing.t[0] = Hammerstein_M->Timing.clockTick0 * Hammerstein_M->Timing.stepSize0 + Hammerstein_M->Timing.clockTickH0 * Hammerstein_M->Timing.stepSize0 * 4294967296.0; }
/* Model output function */ void DI_model_output(void) { /* Level2 S-Function Block: '<Root>/S-Function' (DI_v1) */ { SimStruct *rts = DI_model_M->childSfunctions[0]; sfcnOutputs(rts, 0); } }
/* Model output function */ void AD_model_output(void) { /* Level2 S-Function Block: '<Root>/Get_Parameter ' (AD_v2) */ { SimStruct *rts = AD_model_M->childSfunctions[0]; sfcnOutputs(rts, 0); } }
/* Model output function */ static void testSHM_output(int_T tid) { /* local block i/o variables */ real_T rtb_Gain; /* Level2 S-Function Block: '<Root>/S-Function' (sSHM) */ { SimStruct *rts = testSHM_M->childSfunctions[0]; sfcnOutputs(rts, 0); } /* Level2 S-Function Block: '<Root>/RTAI_SCOPE' (sfun_rtai_scope) */ { SimStruct *rts = testSHM_M->childSfunctions[1]; sfcnOutputs(rts, 0); } /* DigitalClock: '<Root>/Digital Clock' */ rtb_Gain = testSHM_M->Timing.t[0]; /* Gain: '<Root>/Gain' */ rtb_Gain *= testSHM_P.Gain_Gain; /* SignalConversion: '<Root>/TmpHiddenBufferAtS-FunctionInport1' incorporates: * Constant: '<Root>/Bias' * Sum: '<Root>/Sum' * Sum: '<Root>/Sum1' * Trigonometry: '<Root>/Trigonometric Function' * Trigonometry: '<Root>/Trigonometric Function1' */ testSHM_B.TmpHiddenBufferAtSFunctionInpor[0] = rtb_Gain; testSHM_B.TmpHiddenBufferAtSFunctionInpor[1] = sin(rtb_Gain) + testSHM_P.Bias_Value; testSHM_B.TmpHiddenBufferAtSFunctionInpor[2] = cos(rtb_Gain) + testSHM_P.Bias_Value; /* tid is required for a uniform function interface. * Argument tid is not used in the function. */ UNUSED_PARAMETER(tid); }
/* Model output function */ void test_mdl_output(void) { /* Sin: '<Root>/Sine Wave' */ test_mdl_B.SineWave = sin(test_mdl_P.SineWave_Freq * test_mdl_M->Timing.t[0] + test_mdl_P.SineWave_Phase) * test_mdl_P.SineWave_Amp + test_mdl_P.SineWave_Bias; /* Level2 S-Function Block: '<Root>/S-Function' (phy_to_lnr) */ { SimStruct *rts = test_mdl_M->childSfunctions[0]; sfcnOutputs(rts, 0); } }
/* Model output function */ void xpcosc_output(int_T tid) { real_T temp; if (rtmIsMajorTimeStep(xpcosc_rtM)) { /* set solver stop time */ if (!(xpcosc_rtM->Timing.clockTick0+1)) { rtsiSetSolverStopTime(&xpcosc_rtM->solverInfo, ((xpcosc_rtM->Timing.clockTickH0 + 1) * xpcosc_rtM->Timing.stepSize0 * 4294967296.0)); } else { rtsiSetSolverStopTime(&xpcosc_rtM->solverInfo, ((xpcosc_rtM->Timing.clockTick0 + 1) * xpcosc_rtM->Timing.stepSize0 + xpcosc_rtM->Timing.clockTickH0 * xpcosc_rtM->Timing.stepSize0 * 4294967296.0)); } } /* end MajorTimeStep */ /* Update absolute time of base rate at minor time step */ if (rtmIsMinorTimeStep(xpcosc_rtM)) { xpcosc_rtM->Timing.t[0] = rtsiGetT(&xpcosc_rtM->solverInfo); } /* Integrator: '<Root>/Integrator1' */ xpcosc_B.Integrator1 = xpcosc_X.Integrator1_CSTATE; if (rtmIsMajorTimeStep(xpcosc_rtM)) { /* Level2 S-Function Block: '<Root>/PCI-6221 AD' (adnipcim) */ { SimStruct *rts = xpcosc_rtM->childSfunctions[0]; sfcnOutputs(rts, 1); } /* RateTransition: '<Root>/Rate Transition1' */ if (rtmIsMajorTimeStep(xpcosc_rtM)) { xpcosc_B.RateTransition1 = xpcosc_B.PCI6221AD; } /* End of RateTransition: '<Root>/Rate Transition1' */ } /* Outport: '<Root>/Outport' */ xpcosc_Y.Outport[0] = xpcosc_B.Integrator1; xpcosc_Y.Outport[1] = xpcosc_B.RateTransition1; /* SignalGenerator: '<Root>/Signal Generator' */ temp = xpcosc_P.SignalGenerator_Frequency * xpcosc_rtM->Timing.t[0]; if (temp - floor(temp) >= 0.5) { xpcosc_B.SignalGenerator = xpcosc_P.SignalGenerator_Amplitude; } else { xpcosc_B.SignalGenerator = -xpcosc_P.SignalGenerator_Amplitude; } /* End of SignalGenerator: '<Root>/Signal Generator' */ /* RateTransition: '<Root>/Rate Transition' */ if (rtmIsMajorTimeStep(xpcosc_rtM)) { xpcosc_B.RateTransition = xpcosc_B.SignalGenerator; /* Level2 S-Function Block: '<Root>/PCI-6713 DA' (danipci671x) */ { SimStruct *rts = xpcosc_rtM->childSfunctions[1]; sfcnOutputs(rts, 1); } } /* End of RateTransition: '<Root>/Rate Transition' */ /* ok to acquire for <S1>/S-Function */ xpcosc_DWork.SFunction_IWORK.AcquireOK = 1; /* Gain: '<Root>/Gain' */ xpcosc_B.Gain = xpcosc_P.Gain_Gain * xpcosc_B.Integrator1; /* Integrator: '<Root>/Integrator' */ xpcosc_B.Integrator = xpcosc_X.Integrator_CSTATE; /* Gain: '<Root>/Gain1' */ xpcosc_B.Gain1 = xpcosc_P.Gain1_Gain * xpcosc_B.Integrator; /* Gain: '<Root>/Gain2' */ xpcosc_B.Gain2 = xpcosc_P.Gain2_Gain * xpcosc_B.SignalGenerator; /* Sum: '<Root>/Sum' */ xpcosc_B.Sum = (xpcosc_B.Gain2 - xpcosc_B.Gain) - xpcosc_B.Gain1; /* tid is required for a uniform function interface. * Argument tid is not used in the function. */ UNUSED_PARAMETER(tid); }
/* Model output function */ void RA4_student_output(void) { /* Reset subsysRan breadcrumbs */ srClearBC(RA4_student_DW.Controller_SubsysRanBC); /* UnitDelay: '<Root>/Unit Delay2' */ RA4_student_B.UnitDelay2[0] = RA4_student_DW.UnitDelay2_DSTATE[0]; RA4_student_B.UnitDelay2[1] = RA4_student_DW.UnitDelay2_DSTATE[1]; RA4_student_B.UnitDelay2[2] = RA4_student_DW.UnitDelay2_DSTATE[2]; /* UnitDelay: '<Root>/Unit Delay1' */ RA4_student_B.UnitDelay1 = RA4_student_DW.UnitDelay1_DSTATE; /* RTW Generated Level2 S-Function Block: '<S2>/Robot Arm_sfcn' (Robot_sf) */ { SimStruct *rts = RA4_student_M->childSfunctions[1]; sfcnOutputs(rts, 0); } /* Outputs for Enabled SubSystem: '<Root>/Controller' incorporates: * EnablePort: '<S1>/Enable' */ if (RA4_student_B.RobotArm_sfcn_o1 > 0.0) { if (!RA4_student_DW.Controller_MODE) { RA4_student_DW.Controller_MODE = true; } } else { if (RA4_student_DW.Controller_MODE) { RA4_student_DW.Controller_MODE = false; } } if (RA4_student_DW.Controller_MODE) { /* Sum: '<S1>/Sum4' incorporates: * Constant: '<S1>/Feedforward R' * Constant: '<S1>/Reference R' * Gain: '<S3>/Gain' * Sum: '<S1>/Sum2' */ RA4_student_B.Sum4 = (RA4_student_P.ReferenceR_Value - RA4_student_B.RobotArm_sfcn_o2[0]) * RA4_student_P.Gain_Gain + RA4_student_P.FeedforwardR_Value; /* Sum: '<S1>/Sum5' incorporates: * Constant: '<S1>/Feedforward X' * Constant: '<S1>/Reference X' * Gain: '<S4>/Gain' * Sum: '<S1>/Sum1' */ RA4_student_B.Sum5 = (RA4_student_P.ReferenceX_Value - RA4_student_B.RobotArm_sfcn_o2[1]) * RA4_student_P.Gain_Gain_e + RA4_student_P.FeedforwardX_Value; /* Sum: '<S1>/Sum6' incorporates: * Constant: '<S1>/Feedforward Z' * Constant: '<S1>/Reference Z' * Gain: '<S5>/Gain' * Sum: '<S1>/Sum3' */ RA4_student_B.Sum6 = (RA4_student_P.ReferenceZ_Value - RA4_student_B.RobotArm_sfcn_o2[2]) * RA4_student_P.Gain_Gain_l + RA4_student_P.FeedforwardZ_Value; /* Constant: '<S1>/Reference Solenoid' */ RA4_student_B.ReferenceSolenoid = RA4_student_P.ReferenceSolenoid_Value; /* Level2 S-Function Block: '<S6>/S-Function' (sf_rt_scope) */ { SimStruct *rts = RA4_student_M->childSfunctions[0]; sfcnOutputs(rts, 0); } srUpdateBC(RA4_student_DW.Controller_SubsysRanBC); } /* End of Outputs for SubSystem: '<Root>/Controller' */ }
/* Model output function */ void Mechanics_output(int_T tid) { /* Update absolute time of base rate at minor time step */ if (rtmIsMinorTimeStep(Mechanics_M)) { Mechanics_M->Timing.t[0] = rtsiGetT(&Mechanics_M->solverInfo); } if (rtmIsMajorTimeStep(Mechanics_M)) { /* set solver stop time */ rtsiSetSolverStopTime(&Mechanics_M->solverInfo, ((Mechanics_M->Timing.clockTick0+1)* Mechanics_M->Timing.stepSize0)); } /* end MajorTimeStep */ if (rtmIsMajorTimeStep(Mechanics_M) && Mechanics_M->Timing.TaskCounters.TID[1] == 0) { /* Level2 S-Function Block: '<Root>/Arduino' (QueryInstrument) */ { SimStruct *rts = Mechanics_M->childSfunctions[0]; sfcnOutputs(rts, 1); } /* Gain: '<Root>/Gain' */ Mechanics_B.Gain = Mechanics_P.Gain_Gain * Mechanics_B.Arduino; } /* S-Function Block: <S6>/Block#1 */ { _rtMech_PWORK *mechWork = (_rtMech_PWORK *) Mechanics_DWork.Block1_PWORK; mechWork->genSimData.time = Mechanics_M->Timing.t[0]; mechWork->outSimData.majorTimestep = rtmIsMajorTimeStep(Mechanics_M); if (kinematicSfcnOutputMethod(mechWork->mechanism, &(mechWork->genSimData), &(mechWork->outSimData))) { { const ErrorRecord *err = getErrorMsg(); static char_T errorMsg[1024]; sprintf(errorMsg, err->errorMsg, err->blocks[0], err->blocks[1], err->blocks[2], err->blocks[3], err->blocks[4]); rtmSetErrorStatus(Mechanics_M, errorMsg); return; } } } if (rtmIsMajorTimeStep(Mechanics_M) && Mechanics_M->Timing.TaskCounters.TID[1] == 0) { /* Gain: '<S6>/_gravity_conversion' incorporates: * Constant: '<S5>/SOURCE_BLOCK' */ Mechanics_B._gravity_conversion[0] = Mechanics_P._gravity_conversion_Gain * Mechanics_P.SOURCE_BLOCK_Value[0]; Mechanics_B._gravity_conversion[1] = Mechanics_P._gravity_conversion_Gain * Mechanics_P.SOURCE_BLOCK_Value[1]; Mechanics_B._gravity_conversion[2] = Mechanics_P._gravity_conversion_Gain * Mechanics_P.SOURCE_BLOCK_Value[2]; } /* S-Function Block: <S6>/Block#2 */ { _rtMech_PWORK *mechWork = (_rtMech_PWORK *) Mechanics_DWork.Block2_PWORK; mechWork->genSimData.time = Mechanics_M->Timing.t[0]; mechWork->outSimData.majorTimestep = rtmIsMajorTimeStep(Mechanics_M); if (dynamicSfcnOutputMethod(mechWork->mechanism, &(mechWork->genSimData), &(mechWork->outSimData))) { { const ErrorRecord *err = getErrorMsg(); static char_T errorMsg[1024]; sprintf(errorMsg, err->errorMsg, err->blocks[0], err->blocks[1], err->blocks[2], err->blocks[3], err->blocks[4]); rtmSetErrorStatus(Mechanics_M, errorMsg); return; } } } /* S-Function Block: <S6>/Block#3 */ { _rtMech_PWORK *mechWork = (_rtMech_PWORK *) Mechanics_DWork.Block3_PWORK; mechWork->genSimData.time = Mechanics_M->Timing.t[0]; mechWork->outSimData.majorTimestep = rtmIsMajorTimeStep(Mechanics_M); if (eventSfcnOutputMethod(mechWork->mechanism, &(mechWork->genSimData), &(mechWork->outSimData))) { { const ErrorRecord *err = getErrorMsg(); static char_T errorMsg[1024]; sprintf(errorMsg, err->errorMsg, err->blocks[0], err->blocks[1], err->blocks[2], err->blocks[3], err->blocks[4]); rtmSetErrorStatus(Mechanics_M, errorMsg); return; } } } UNUSED_PARAMETER(tid); }