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