void ) { } static void mdlOutputs ( SimStruct * S , int_T tid ) { real_T
jzxguy1xyo ; ZCEventType zcEvent ; boolean_T is1galx1wr ; real_T iden3vpls2 ;
real_T kewj0jjgdw ; real_T c3hti1p3uf ; int8_T rtPrevAction ; int8_T rtAction
; nmsgyp54ig * _rtB ; bbqvqz25ov * _rtP ; n2g2llwf21 * _rtX ; aa2ep02qn5 *
_rtZCE ; pklu3vjy1t * _rtDW ; _rtDW = ( ( pklu3vjy1t * ) ssGetRootDWork ( S )
) ; _rtZCE = ( ( aa2ep02qn5 * ) _ssGetPrevZCSigState ( S ) ) ; _rtX = ( (
n2g2llwf21 * ) ssGetContStates ( S ) ) ; _rtP = ( ( bbqvqz25ov * )
ssGetModelRtp ( S ) ) ; _rtB = ( ( nmsgyp54ig * ) _ssGetModelBlockIO ( S ) )
; if ( ssIsSampleHit ( S , 4 , 0 ) ) { _rtB -> jbbkv4upvi = _rtDW ->
idaicj53o4 ; } if ( ssIsSampleHit ( S , 1 , 0 ) ) { is1galx1wr = ( _rtB ->
jbbkv4upvi != c22ngqieus ( S ) -> pactsh03am ) ; } jzxguy1xyo = ssGetT ( S )
; if ( ssIsSampleHit ( S , 1 , 0 ) ) { _rtB -> oojsaunz11 = _rtP -> P_5 ;
_rtB -> fmra2cutsa = _rtP -> P_6 ; } _rtB -> fs1ofsmvy2 = muDoubleScalarRem (
jzxguy1xyo + _rtB -> oojsaunz11 , _rtB -> fmra2cutsa ) * _rtP -> P_7 ; _rtB
-> kdd430tca4 = ( ( 2.0 * _rtB -> fs1ofsmvy2 - 1.0 ) + 1.0 ) * 0.5 ; if (
ssIsSampleHit ( S , 1 , 0 ) ) { if ( ssIsMajorTimeStep ( S ) ) { _rtDW ->
fiaf5yjt4n = ( _rtB -> jbbkv4upvi >= _rtB -> kdd430tca4 ) ; } _rtB ->
bonoh3t2uf = ( is1galx1wr && _rtDW -> fiaf5yjt4n ) ; } _rtB -> puvw0myvhu [ 0
] = _rtB -> bonoh3t2uf ; _rtB -> puvw0myvhu [ 1 ] = 0.0 ; _rtB -> puvw0myvhu
[ 2 ] = 0.0 ; _rtDW -> lhiprm3wjz [ 0 ] = ! ( _rtB -> puvw0myvhu [ 0 ] ==
_rtDW -> lhiprm3wjz [ 1 ] ) ; _rtDW -> lhiprm3wjz [ 1 ] = _rtB -> puvw0myvhu
[ 0 ] ; _rtB -> puvw0myvhu [ 3 ] = _rtDW -> lhiprm3wjz [ 0 ] ; if (
ssIsSampleHit ( S , 2 , 0 ) ) { ssCallAccelRunBlock ( S , 9 , 15 ,
SS_CALL_MDL_OUTPUTS ) ; ssCallAccelRunBlock ( S , 9 , 16 ,
SS_CALL_MDL_OUTPUTS ) ; } if ( ssIsSampleHit ( S , 4 , 0 ) ) { _rtB ->
ni0skqgprw = _rtB -> mgrpxotnda [ 2 ] ; } if ( ssIsSampleHit ( S , 2 , 0 ) )
{ ssCallAccelRunBlock ( S , 9 , 20 , SS_CALL_MDL_OUTPUTS ) ; } if (
ssIsSampleHit ( S , 1 , 0 ) ) { zcEvent = rt_ZCFcn ( ANY_ZERO_CROSSING , &
_rtZCE -> mpe2yble25 , ( _rtB -> fs1ofsmvy2 - _rtP -> P_11 ) ) ; if ( _rtDW
-> oosqu0tl1h == 0 ) { if ( zcEvent != NO_ZCEVENT ) { _rtB -> dgvfzxjzqp = !
( _rtB -> dgvfzxjzqp != 0.0 ) ; _rtDW -> oosqu0tl1h = 1 ; } else if ( _rtB ->
dgvfzxjzqp == 1.0 ) { if ( _rtB -> fs1ofsmvy2 != _rtP -> P_11 ) { _rtB ->
dgvfzxjzqp = 0.0 ; } } else { if ( _rtB -> fs1ofsmvy2 == _rtP -> P_11 ) {
_rtB -> dgvfzxjzqp = 1.0 ; } } } else { if ( _rtB -> fs1ofsmvy2 != _rtP ->
P_11 ) { _rtB -> dgvfzxjzqp = 0.0 ; } _rtDW -> oosqu0tl1h = 0 ; } } if (
ssIsSampleHit ( S , 2 , 0 ) ) { ssCallAccelRunBlock ( S , 9 , 23 ,
SS_CALL_MDL_OUTPUTS ) ; ssCallAccelRunBlock ( S , 9 , 33 ,
SS_CALL_MDL_OUTPUTS ) ; iden3vpls2 = _rtP -> P_13 * _rtB -> mgrpxotnda [ 8 ]
; } if ( ssIsSampleHit ( S , 4 , 0 ) ) { _rtB -> gp5orjzg5t = _rtB ->
mgrpxotnda [ 2 ] ; } if ( ssIsSampleHit ( S , 2 , 0 ) ) { kewj0jjgdw = (
iden3vpls2 - _rtB -> gp5orjzg5t ) * _rtB -> nzunlww04y ; } if ( ssIsSampleHit
( S , 4 , 0 ) ) { _rtB -> jw2hkpsksy = _rtB -> gp5orjzg5t * _rtB ->
dvca5kgoqr ; _rtB -> elobzetbdp = _rtB -> mgrpxotnda [ 8 ] ; } if (
ssIsSampleHit ( S , 2 , 0 ) ) { c3hti1p3uf = ( kewj0jjgdw + _rtB ->
jw2hkpsksy ) - _rtB -> elobzetbdp ; if ( ssIsSampleHit ( S , 4 , 0 ) ) { _rtB
-> bc5lqmbcwx = _rtB -> mgrpxotnda [ 9 ] ; } } if ( ssIsSampleHit ( S , 4 , 0
) ) { _rtB -> bpiny53cki = _rtB -> elobzetbdp + _rtB -> bc5lqmbcwx ; } if (
ssIsSampleHit ( S , 2 , 0 ) ) { iden3vpls2 = c3hti1p3uf / _rtB -> bpiny53cki
+ _rtB -> idha0n310x ; if ( iden3vpls2 > _rtP -> P_16 ) { _rtB -> ccrq35nhp3
= _rtP -> P_16 ; } else if ( iden3vpls2 < _rtP -> P_17 ) { _rtB -> ccrq35nhp3
= _rtP -> P_17 ; } else { _rtB -> ccrq35nhp3 = iden3vpls2 ; } } if (
ssIsSampleHit ( S , 4 , 0 ) ) { _rtB -> pvzuuxenvc = _rtB -> ccrq35nhp3 ; }
if ( ssIsSampleHit ( S , 2 , 0 ) ) { _rtB -> ii04l1a0ic = ( _rtB ->
mgrpxotnda [ 9 ] + _rtB -> mgrpxotnda [ 8 ] ) - _rtB -> mgrpxotnda [ 6 ] ;
ssCallAccelRunBlock ( S , 9 , 51 , SS_CALL_MDL_OUTPUTS ) ; rtPrevAction =
_rtDW -> dcumqbbyun ; if ( ssIsMajorTimeStep ( S ) ) { if ( _rtB ->
mgrpxotnda [ 9 ] < 90.199999999999989 ) { rtAction = 0 ; } else { rtAction =
1 ; } _rtDW -> dcumqbbyun = rtAction ; } else { rtAction = _rtDW ->
dcumqbbyun ; } if ( rtPrevAction != rtAction ) { switch ( rtPrevAction ) {
case 0 : ssSetSolverNeedsReset ( S ) ; break ; case 1 : ssSetSolverNeedsReset
( S ) ; break ; case 2 : ssSetSolverNeedsReset ( S ) ; break ; } } switch (
rtAction ) { case 0 : if ( rtAction != rtPrevAction ) { if ( ssGetTaskTime (
S , 2 ) != ssGetTStart ( S ) ) { ssSetSolverNeedsReset ( S ) ; } } _rtB ->
kx5rgsvmx3 = _rtP -> P_0 * _rtB -> mgrpxotnda [ 8 ] ; if ( ssIsMajorTimeStep
( S ) ) { srUpdateBC ( _rtDW -> o5k0zwtbn4 ) ; } break ; case 1 : if (
rtAction != rtPrevAction ) { if ( ssGetTaskTime ( S , 2 ) != ssGetTStart ( S
) ) { ssSetSolverNeedsReset ( S ) ; } } _rtB -> kx5rgsvmx3 = _rtP -> P_1 ; if
( ssIsMajorTimeStep ( S ) ) { srUpdateBC ( _rtDW -> ihoovge3z4 ) ; } break ;
case 2 : if ( rtAction != rtPrevAction ) { if ( ssGetTaskTime ( S , 2 ) !=
ssGetTStart ( S ) ) { ssSetSolverNeedsReset ( S ) ; } } _rtB -> pvzuuxenvc =
_rtP -> P_2 ; if ( ssIsMajorTimeStep ( S ) ) { srUpdateBC ( _rtDW ->
gunoszsdaf ) ; } break ; } } bemu4fk2sq ( S , _rtB -> kwjevd5eqt , 0.0 , &
_rtB -> bemu4fk2sq4 , & _rtDW -> bemu4fk2sq4 , ( mvw1gbh0c1 * ) & _rtP ->
bemu4fk2sq4 , & ( ( npjij2cecc * ) ssGetContStateDisabled ( S ) ) ->
bemu4fk2sq4 ) ; cqabclhqip ( S , _rtB -> donhz1jhkq , 0.0 , & _rtB ->
cqabclhqip4 , & _rtDW -> cqabclhqip4 , ( nneyi35s1a * ) & _rtP -> cqabclhqip4
, & _rtX -> cqabclhqip4 , & ( ( npjij2cecc * ) ssGetContStateDisabled ( S ) )
-> cqabclhqip4 ) ; bemu4fk2sq ( S , _rtB -> jwapqatga5 , 0.0 , & _rtB ->
n1qdzssqu3 , & _rtDW -> n1qdzssqu3 , ( mvw1gbh0c1 * ) & _rtP -> n1qdzssqu3 ,
& ( ( npjij2cecc * ) ssGetContStateDisabled ( S ) ) -> n1qdzssqu3 ) ;
cqabclhqip ( S , _rtB -> p5ierutvgv , 0.0 , & _rtB -> nfugx5ih43 , & _rtDW ->
nfugx5ih43 , ( nneyi35s1a * ) & _rtP -> nfugx5ih43 , & _rtX -> nfugx5ih43 , &
( ( npjij2cecc * ) ssGetContStateDisabled ( S ) ) -> nfugx5ih43 ) ;
UNUSED_PARAMETER ( tid ) ; } static void mdlOutputsTID5 ( SimStruct * S ,
/* Model output function */
void motor_io_position_output(void)
{
real_T temp;
ZCEventType zcEvent;
real_T u1;
real_T u2;
if (rtmIsMajorTimeStep(motor_io_position_M)) {
/* set solver stop time */
if (!(motor_io_position_M->Timing.clockTick0+1)) {
rtsiSetSolverStopTime(&motor_io_position_M->solverInfo,
((motor_io_position_M->Timing.clockTickH0 + 1) *
motor_io_position_M->Timing.stepSize0 * 4294967296.0));
} else {
rtsiSetSolverStopTime(&motor_io_position_M->solverInfo,
((motor_io_position_M->Timing.clockTick0 + 1) *
motor_io_position_M->Timing.stepSize0 +
motor_io_position_M->Timing.clockTickH0 *
motor_io_position_M->Timing.stepSize0 * 4294967296.0));
}
} /* end MajorTimeStep */
/* Update absolute time of base rate at minor time step */
if (rtmIsMinorTimeStep(motor_io_position_M)) {
motor_io_position_M->Timing.t[0] = rtsiGetT(&motor_io_position_M->solverInfo);
}
if (rtmIsMajorTimeStep(motor_io_position_M)) {
/* S-Function (rti_commonblock): '<S13>/S-Function1' */
/* This comment workarounds a code generation problem */
/* Gain: '<S5>/fi1_scaling' */
motor_io_position_B.fi1_scaling = motor_io_position_P.fi1_scaling_Gain *
motor_io_position_B.SFunction1;
/* DiscreteTransferFcn: '<Root>/Gfbreal' */
temp = motor_io_position_B.fi1_scaling;
temp -= motor_io_position_P.Gfbreal_DenCoef[1] *
motor_io_position_DW.Gfbreal_states[0];
temp -= motor_io_position_P.Gfbreal_DenCoef[2] *
motor_io_position_DW.Gfbreal_states[1];
temp /= motor_io_position_P.Gfbreal_DenCoef[0];
motor_io_position_DW.Gfbreal_tmp = temp;
temp = motor_io_position_P.Gfbreal_NumCoef[0] *
motor_io_position_DW.Gfbreal_tmp;
temp += motor_io_position_P.Gfbreal_NumCoef[1] *
motor_io_position_DW.Gfbreal_states[0];
temp += motor_io_position_P.Gfbreal_NumCoef[2] *
motor_io_position_DW.Gfbreal_states[1];
motor_io_position_B.Gfbreal = temp;
}
/* SignalGenerator: '<Root>/SinGenerator' */
motor_io_position_B.SinGenerator = sin
(motor_io_position_P.SinGenerator_Frequency * motor_io_position_M->Timing.t
[0]) * motor_io_position_P.SinGenerator_Amplitude;
/* SignalGenerator: '<Root>/SquareGenerator' */
temp = motor_io_position_P.SquareGenerator_Frequency *
motor_io_position_M->Timing.t[0];
if (temp - floor(temp) >= 0.5) {
motor_io_position_B.SquareGenerator =
motor_io_position_P.SquareGenerator_Amplitude;
} else {
motor_io_position_B.SquareGenerator =
-motor_io_position_P.SquareGenerator_Amplitude;
}
/* End of SignalGenerator: '<Root>/SquareGenerator' */
/* Switch: '<Root>/Switch' incorporates:
* Constant: '<Root>/SignalSelector[0Square,1Sine]'
*/
if (motor_io_position_P.SignalSelector0Square1Sine_Valu != 0.0) {
motor_io_position_B.ref = motor_io_position_B.SinGenerator;
} else {
motor_io_position_B.ref = motor_io_position_B.SquareGenerator;
}
/* End of Switch: '<Root>/Switch' */
if (rtmIsMajorTimeStep(motor_io_position_M)) {
/* DiscreteTransferFcn: '<Root>/Gffreal' */
temp = motor_io_position_B.ref;
temp -= motor_io_position_P.Gffreal_DenCoef[1] *
motor_io_position_DW.Gffreal_states[0];
temp -= motor_io_position_P.Gffreal_DenCoef[2] *
motor_io_position_DW.Gffreal_states[1];
temp /= motor_io_position_P.Gffreal_DenCoef[0];
motor_io_position_DW.Gffreal_tmp = temp;
temp = motor_io_position_P.Gffreal_NumCoef[0] *
motor_io_position_DW.Gffreal_tmp;
temp += motor_io_position_P.Gffreal_NumCoef[1] *
motor_io_position_DW.Gffreal_states[0];
temp += motor_io_position_P.Gffreal_NumCoef[2] *
motor_io_position_DW.Gffreal_states[1];
motor_io_position_B.Gffreal = temp;
/* Sum: '<Root>/Sum' */
motor_io_position_B.Sum = motor_io_position_B.Gffreal -
motor_io_position_B.Gfbreal;
/* Gain: '<Root>/Gain' */
motor_io_position_B.Gain = motor_io_position_P.Gain_Gain *
motor_io_position_B.Sum;
/* Saturate: '<S2>/Saturation' */
temp = motor_io_position_B.Gain;
u1 = motor_io_position_P.Saturation_LowerSat;
u2 = motor_io_position_P.Saturation_UpperSat;
if (temp > u2) {
motor_io_position_B.Volt = u2;
} else if (temp < u1) {
motor_io_position_B.Volt = u1;
} else {
motor_io_position_B.Volt = temp;
}
/* End of Saturate: '<S2>/Saturation' */
/* Gain: '<S2>/pwm_skalning' */
motor_io_position_B.pwm_skalning = motor_io_position_P.pwm_skalning_Gain *
motor_io_position_B.Volt;
/* Sum: '<S2>/Sum' incorporates:
* Constant: '<S2>/pwm_offstet'
*/
motor_io_position_B.Sum_f = motor_io_position_B.pwm_skalning +
motor_io_position_P.pwm_offstet_Value;
/* S-Function (rti_commonblock): '<S9>/S-Function1' */
/* This comment workarounds a code generation problem */
/* dSPACE I/O Board DS1104 #1 Unit:PWM Group:PWM */
ds1104_slave_dsp_pwm_duty_write(0, rti_slv1104_fcn_index[6],
motor_io_position_B.Sum_f);
/* S-Function (rti_commonblock): '<S9>/S-Function2' */
/* This comment workarounds a code generation problem */
/* S-Function (rti_commonblock): '<S9>/S-Function3' */
/* This comment workarounds a code generation problem */
/* S-Function (rti_commonblock): '<S9>/S-Function4' */
/* This comment workarounds a code generation problem */
/* DataTypeConversion: '<S2>/Data Type Conversion' incorporates:
* Constant: '<S2>/Enable[1_Off, 0_On]'
*/
motor_io_position_B.DataTypeConversion =
(motor_io_position_P.Enable1_Off0_On_Value != 0.0);
/* S-Function (rti_commonblock): '<S8>/S-Function1' */
/* This comment workarounds a code generation problem */
/* dSPACE I/O Board DS1104 #1 Unit:BIT_IO Group:BIT_OUT */
if (motor_io_position_B.DataTypeConversion > 0) {
ds1104_bit_io_set(DS1104_DIO0);
} else {
ds1104_bit_io_clear(DS1104_DIO0);
}
/* DiscreteTransferFcn: '<Root>/Gff' */
temp = motor_io_position_B.ref;
temp -= motor_io_position_P.Gff_DenCoef[1] *
motor_io_position_DW.Gff_states[0];
temp -= motor_io_position_P.Gff_DenCoef[2] *
motor_io_position_DW.Gff_states[1];
temp /= motor_io_position_P.Gff_DenCoef[0];
motor_io_position_DW.Gff_tmp = temp;
temp = motor_io_position_P.Gff_NumCoef[0] * motor_io_position_DW.Gff_tmp;
temp += motor_io_position_P.Gff_NumCoef[1] *
motor_io_position_DW.Gff_states[0];
temp += motor_io_position_P.Gff_NumCoef[2] *
motor_io_position_DW.Gff_states[1];
motor_io_position_B.Gff = temp;
}
/* Integrator: '<S1>/Integrator1' */
motor_io_position_B.Integrator1 = motor_io_position_X.Integrator1_CSTATE;
/* Quantizer: '<S4>/Quantizer' */
temp = motor_io_position_B.Integrator1;
motor_io_position_B.Quantizer = rt_roundd_snf(temp / motor_io_position_P.quant)
* motor_io_position_P.quant;
if (rtmIsMajorTimeStep(motor_io_position_M)) {
/* ZeroOrderHold: '<S4>/Zero-Order Hold' */
motor_io_position_B.ZeroOrderHold = motor_io_position_B.Quantizer;
/* DiscreteTransferFcn: '<Root>/Gfb' */
temp = motor_io_position_B.ZeroOrderHold;
temp -= motor_io_position_P.Gfb_DenCoef[1] *
motor_io_position_DW.Gfb_states[0];
temp -= motor_io_position_P.Gfb_DenCoef[2] *
motor_io_position_DW.Gfb_states[1];
temp /= motor_io_position_P.Gfb_DenCoef[0];
motor_io_position_DW.Gfb_tmp = temp;
temp = motor_io_position_P.Gfb_NumCoef[0] * motor_io_position_DW.Gfb_tmp;
temp += motor_io_position_P.Gfb_NumCoef[1] *
motor_io_position_DW.Gfb_states[0];
temp += motor_io_position_P.Gfb_NumCoef[2] *
motor_io_position_DW.Gfb_states[1];
motor_io_position_B.Gfb = temp;
/* Sum: '<Root>/Sum1' */
motor_io_position_B.Sum1 = motor_io_position_B.Gff - motor_io_position_B.Gfb;
/* Saturate: '<Root>/Saturation' */
temp = motor_io_position_B.Sum1;
u1 = motor_io_position_P.Saturation_LowerSat_c;
u2 = motor_io_position_P.Saturation_UpperSat_p;
if (temp > u2) {
motor_io_position_B.Saturation = u2;
} else if (temp < u1) {
motor_io_position_B.Saturation = u1;
} else {
motor_io_position_B.Saturation = temp;
}
/* End of Saturate: '<Root>/Saturation' */
}
/* Integrator: '<S1>/Integrator' */
motor_io_position_B.Integrator = motor_io_position_X.Integrator_CSTATE;
/* Gain: '<S1>/Gain1' */
motor_io_position_B.Gain1 = motor_io_position_P.Gain1_Gain *
motor_io_position_B.Integrator;
/* Sum: '<S1>/Add' */
motor_io_position_B.Add = motor_io_position_B.Saturation -
motor_io_position_B.Gain1;
/* Gain: '<S1>/k//R ' */
motor_io_position_B.kR = motor_io_position_P.kR_Gain * motor_io_position_B.Add;
/* Saturate: '<S6>/Saturate to Fc' */
temp = motor_io_position_B.kR;
u1 = motor_io_position_P.SaturatetoFc_LowerSat;
u2 = motor_io_position_P.F_c;
if (temp > u2) {
motor_io_position_B.Stickslipregion = u2;
} else if (temp < u1) {
motor_io_position_B.Stickslipregion = u1;
} else {
motor_io_position_B.Stickslipregion = temp;
}
/* End of Saturate: '<S6>/Saturate to Fc' */
/* Abs: '<S6>/Abs' */
motor_io_position_B.Abs = fabs(motor_io_position_B.Integrator);
/* RelationalOperator: '<S7>/Compare' incorporates:
* Constant: '<S7>/Constant'
*/
motor_io_position_B.Compare = (motor_io_position_B.Abs <=
motor_io_position_P.Constant_Value);
/* Gain: '<S6>/Vicous friction' */
motor_io_position_B.Vicousfriction = motor_io_position_P.Vicousfriction_Gain *
motor_io_position_B.Integrator;
/* Signum: '<S6>/Sign' */
temp = motor_io_position_B.Integrator;
if (temp < 0.0) {
motor_io_position_B.Sign = -1.0;
} else if (temp > 0.0) {
motor_io_position_B.Sign = 1.0;
} else if (temp == 0.0) {
motor_io_position_B.Sign = 0.0;
} else {
motor_io_position_B.Sign = temp;
}
/* End of Signum: '<S6>/Sign' */
/* Product: '<S6>/Product' incorporates:
* Constant: '<S6>/F_c'
*/
motor_io_position_B.Product = motor_io_position_P.F_c *
motor_io_position_B.Sign;
/* Sum: '<S6>/Add' */
motor_io_position_B.Viscousregion = motor_io_position_B.Vicousfriction +
motor_io_position_B.Product;
/* Switch: '<S6>/Switch' */
if (motor_io_position_B.Compare) {
motor_io_position_B.Friction = motor_io_position_B.Stickslipregion;
} else {
motor_io_position_B.Friction = motor_io_position_B.Viscousregion;
}
/* End of Switch: '<S6>/Switch' */
/* Sum: '<S1>/Add1' */
motor_io_position_B.Add1 = motor_io_position_B.kR -
motor_io_position_B.Friction;
if (rtmIsMajorTimeStep(motor_io_position_M)) {
/* Gain: '<S1>/Gain2' incorporates:
* Constant: '<S1>/Load inertia'
*/
motor_io_position_B.Gain2 = motor_io_position_P.Gain2_Gain *
motor_io_position_P.J1;
/* Sum: '<S1>/Add2' incorporates:
* Constant: '<S1>/Motor inertia'
*/
motor_io_position_B.Add2 = motor_io_position_B.Gain2 +
motor_io_position_P.Motorinertia_Value;
}
/* Product: '<S1>/Inertias 1//J' */
motor_io_position_B.Inertias1J = 1.0 / motor_io_position_B.Add2 *
motor_io_position_B.Add1;
if (rtmIsMajorTimeStep(motor_io_position_M)) {
}
/* Switch: '<S6>/Switch1' incorporates:
* Constant: '<S6>/Constant1'
* Constant: '<S6>/F_c'
*/
if (motor_io_position_B.Integrator > motor_io_position_P.Switch1_Threshold) {
motor_io_position_B.Switch1 = motor_io_position_P.F_c;
} else {
motor_io_position_B.Switch1 = motor_io_position_P.Constant1_Value;
}
/* End of Switch: '<S6>/Switch1' */
if (rtmIsMajorTimeStep(motor_io_position_M)) {
/* S-Function (rti_commonblock): '<S13>/S-Function2' */
/* This comment workarounds a code generation problem */
/* Gain: '<S5>/w1_scaling' */
motor_io_position_B.w1_scaling = motor_io_position_P.w1_scaling_Gain *
motor_io_position_B.SFunction2;
/* Outputs for Triggered SubSystem: '<S5>/DS1104ENC_SET_POS_C1' incorporates:
* TriggerPort: '<S15>/Trigger'
*/
if (rtmIsMajorTimeStep(motor_io_position_M)) {
/* Constant: '<S5>/Reset enc' */
zcEvent = rt_ZCFcn(RISING_ZERO_CROSSING,
&motor_io_position_PrevZCX.DS1104ENC_SET_POS_C1_Trig_ZCE,
(motor_io_position_P.Resetenc_Value));
if (zcEvent != NO_ZCEVENT) {
/* S-Function (rti_commonblock): '<S15>/S-Function1' */
/* This comment workarounds a code generation problem */
/* dSPACE I/O Board DS1104 Unit:ENC_SET */
ds1104_inc_position_write(1, 0, DS1104_INC_LINE_SUBDIV_4);
}
}
/* End of Outputs for SubSystem: '<S5>/DS1104ENC_SET_POS_C1' */
/* S-Function (rti_commonblock): '<S14>/S-Function1' */
/* This comment workarounds a code generation problem */
/* S-Function (rti_commonblock): '<S14>/S-Function2' */
/* This comment workarounds a code generation problem */
}
}
/* Model output function */
void motor_io_output(void)
{
ZCEventType zcEvent;
real_T u0;
real_T u1;
real_T u2;
if (rtmIsMajorTimeStep(motor_io_M)) {
/* set solver stop time */
if (!(motor_io_M->Timing.clockTick0+1)) {
rtsiSetSolverStopTime(&motor_io_M->solverInfo,
((motor_io_M->Timing.clockTickH0 + 1) *
motor_io_M->Timing.stepSize0 * 4294967296.0));
} else {
rtsiSetSolverStopTime(&motor_io_M->solverInfo,
((motor_io_M->Timing.clockTick0 + 1) *
motor_io_M->Timing.stepSize0 + motor_io_M->Timing.clockTickH0 *
motor_io_M->Timing.stepSize0 * 4294967296.0));
}
} /* end MajorTimeStep */
/* Update absolute time of base rate at minor time step */
if (rtmIsMinorTimeStep(motor_io_M)) {
motor_io_M->Timing.t[0] = rtsiGetT(&motor_io_M->solverInfo);
}
if (rtmIsMajorTimeStep(motor_io_M)) {
/* S-Function (rti_commonblock): '<S14>/S-Function1' */
/* This comment workarounds a code generation problem */
/* Gain: '<S6>/fi1_scaling' */
motor_io_B.fi1_scaling = motor_io_P.fi1_scaling_Gain * motor_io_B.SFunction1;
/* MATLAB Function: '<Root>/Traject_and_Model_function 1' incorporates:
* Constant: '<Root>/RS'
* Constant: '<Root>/Reset enc'
*/
mot_Traject_and_Model_function1(motor_io_P.Resetenc_Value,
motor_io_P.RS_Value, motor_io_B.fi1_scaling,
&motor_io_B.sf_Traject_and_Model_function1,
&motor_io_DW.sf_Traject_and_Model_function1);
/* Gain: '<Root>/Gain' */
motor_io_B.Gain = motor_io_P.Gain_Gain *
motor_io_B.sf_Traject_and_Model_function1.volt;
/* Saturate: '<S2>/Saturation' */
u0 = motor_io_B.Gain;
u1 = motor_io_P.Saturation_LowerSat;
u2 = motor_io_P.Saturation_UpperSat;
if (u0 > u2) {
motor_io_B.Volt = u2;
} else if (u0 < u1) {
motor_io_B.Volt = u1;
} else {
motor_io_B.Volt = u0;
}
/* End of Saturate: '<S2>/Saturation' */
/* Gain: '<S2>/pwm_skalning' */
motor_io_B.pwm_skalning = motor_io_P.pwm_skalning_Gain * motor_io_B.Volt;
/* Sum: '<S2>/Sum' incorporates:
* Constant: '<S2>/pwm_offstet'
*/
motor_io_B.Sum = motor_io_B.pwm_skalning + motor_io_P.pwm_offstet_Value;
/* S-Function (rti_commonblock): '<S10>/S-Function1' */
/* This comment workarounds a code generation problem */
/* dSPACE I/O Board DS1104 #1 Unit:PWM Group:PWM */
ds1104_slave_dsp_pwm_duty_write(0, rti_slv1104_fcn_index[6], motor_io_B.Sum);
/* S-Function (rti_commonblock): '<S10>/S-Function2' */
/* This comment workarounds a code generation problem */
/* S-Function (rti_commonblock): '<S10>/S-Function3' */
/* This comment workarounds a code generation problem */
/* S-Function (rti_commonblock): '<S10>/S-Function4' */
/* This comment workarounds a code generation problem */
/* DataTypeConversion: '<S2>/Data Type Conversion' incorporates:
* Constant: '<S2>/Enable[1_Off, 0_On]'
*/
motor_io_B.DataTypeConversion = (motor_io_P.Enable1_Off0_On_Value != 0.0);
/* S-Function (rti_commonblock): '<S9>/S-Function1' */
/* This comment workarounds a code generation problem */
/* dSPACE I/O Board DS1104 #1 Unit:BIT_IO Group:BIT_OUT */
if (motor_io_B.DataTypeConversion > 0) {
ds1104_bit_io_set(DS1104_DIO0);
} else {
ds1104_bit_io_clear(DS1104_DIO0);
}
}
/* Integrator: '<S1>/Integrator1' */
motor_io_B.Integrator1 = motor_io_X.Integrator1_CSTATE;
if (rtmIsMajorTimeStep(motor_io_M)) {
/* MATLAB Function: '<Root>/Traject_and_Model_function 3' incorporates:
* Constant: '<Root>/RS'
* Constant: '<Root>/Reset enc'
*/
mot_Traject_and_Model_function1(motor_io_P.Resetenc_Value,
motor_io_P.RS_Value, motor_io_B.Integrator1,
&motor_io_B.sf_Traject_and_Model_function3,
&motor_io_DW.sf_Traject_and_Model_function3);
}
/* Integrator: '<S1>/Integrator' */
motor_io_B.Integrator = motor_io_X.Integrator_CSTATE;
/* Gain: '<S1>/Gain1' */
motor_io_B.Gain1 = motor_io_P.Gain1_Gain * motor_io_B.Integrator;
/* Sum: '<S1>/Add' */
motor_io_B.Add = motor_io_B.sf_Traject_and_Model_function3.volt -
motor_io_B.Gain1;
/* Gain: '<S1>/k//R ' */
motor_io_B.kR = motor_io_P.kR_Gain * motor_io_B.Add;
/* Saturate: '<S7>/Saturate to Fc' */
u0 = motor_io_B.kR;
u1 = motor_io_P.SaturatetoFc_LowerSat;
u2 = motor_io_P.F_c_upper;
if (u0 > u2) {
motor_io_B.Stickslipregion = u2;
} else if (u0 < u1) {
motor_io_B.Stickslipregion = u1;
} else {
motor_io_B.Stickslipregion = u0;
}
/* End of Saturate: '<S7>/Saturate to Fc' */
/* Abs: '<S7>/Abs' */
motor_io_B.Abs = fabs(motor_io_B.Integrator);
/* RelationalOperator: '<S8>/Compare' incorporates:
* Constant: '<S8>/Constant'
*/
motor_io_B.Compare = (motor_io_B.Abs <= motor_io_P.Constant_Value);
/* Gain: '<S7>/Vicous friction' */
motor_io_B.Vicousfriction = motor_io_P.Vicousfriction_Gain *
motor_io_B.Integrator;
/* Signum: '<S7>/Sign' */
u0 = motor_io_B.Integrator;
if (u0 < 0.0) {
motor_io_B.Sign = -1.0;
} else if (u0 > 0.0) {
motor_io_B.Sign = 1.0;
} else if (u0 == 0.0) {
motor_io_B.Sign = 0.0;
} else {
motor_io_B.Sign = u0;
}
/* End of Signum: '<S7>/Sign' */
/* Product: '<S7>/Product' incorporates:
* Constant: '<S7>/F_c'
*/
motor_io_B.Product = motor_io_P.F_c * motor_io_B.Sign;
/* Sum: '<S7>/Add' */
motor_io_B.Viscousregion = motor_io_B.Vicousfriction + motor_io_B.Product;
/* Switch: '<S7>/Switch' */
if (motor_io_B.Compare) {
motor_io_B.Friction = motor_io_B.Stickslipregion;
} else {
motor_io_B.Friction = motor_io_B.Viscousregion;
}
/* End of Switch: '<S7>/Switch' */
/* Sum: '<S1>/Add1' */
motor_io_B.Add1 = motor_io_B.kR - motor_io_B.Friction;
if (rtmIsMajorTimeStep(motor_io_M)) {
/* Gain: '<S1>/Gain2' incorporates:
* Constant: '<S1>/Load inertia'
*/
motor_io_B.Gain2 = motor_io_P.Gain2_Gain * motor_io_P.J1;
/* Sum: '<S1>/Add2' incorporates:
* Constant: '<S1>/Motor inertia'
*/
motor_io_B.Add2 = motor_io_B.Gain2 + motor_io_P.Motorinertia_Value;
}
/* Product: '<S1>/Inertias 1//J' */
motor_io_B.Inertias1J = 1.0 / motor_io_B.Add2 * motor_io_B.Add1;
if (rtmIsMajorTimeStep(motor_io_M)) {
/* S-Function (rti_commonblock): '<S14>/S-Function2' */
/* This comment workarounds a code generation problem */
/* Gain: '<S6>/w1_scaling' */
motor_io_B.w1_scaling = motor_io_P.w1_scaling_Gain * motor_io_B.SFunction2;
/* Outputs for Triggered SubSystem: '<S6>/DS1104ENC_SET_POS_C1' incorporates:
* TriggerPort: '<S16>/Trigger'
*/
if (rtmIsMajorTimeStep(motor_io_M)) {
/* Constant: '<S6>/Reset enc' */
zcEvent = rt_ZCFcn(RISING_ZERO_CROSSING,
&motor_io_PrevZCX.DS1104ENC_SET_POS_C1_Trig_ZCE,
(motor_io_P.Resetenc_Value_k));
if (zcEvent != NO_ZCEVENT) {
/* S-Function (rti_commonblock): '<S16>/S-Function1' */
/* This comment workarounds a code generation problem */
/* dSPACE I/O Board DS1104 Unit:ENC_SET */
ds1104_inc_position_write(1, 0, DS1104_INC_LINE_SUBDIV_4);
}
}
/* End of Outputs for SubSystem: '<S6>/DS1104ENC_SET_POS_C1' */
/* S-Function (rti_commonblock): '<S15>/S-Function1' */
/* This comment workarounds a code generation problem */
/* S-Function (rti_commonblock): '<S15>/S-Function2' */
/* This comment workarounds a code generation problem */
}
/* SignalGenerator: '<Root>/SinGenerator' */
motor_io_B.SinGenerator = sin(motor_io_P.SinGenerator_Frequency *
motor_io_M->Timing.t[0]) * motor_io_P.SinGenerator_Amplitude;
/* SignalGenerator: '<Root>/SquareGenerator' */
u0 = motor_io_P.SquareGenerator_Frequency * motor_io_M->Timing.t[0];
if (u0 - floor(u0) >= 0.5) {
motor_io_B.SquareGenerator = motor_io_P.SquareGenerator_Amplitude;
} else {
motor_io_B.SquareGenerator = -motor_io_P.SquareGenerator_Amplitude;
}
/* End of SignalGenerator: '<Root>/SquareGenerator' */
/* Switch: '<Root>/Switch' incorporates:
* Constant: '<Root>/SignalSelector[0Square,1Sine]'
*/
if (motor_io_P.SignalSelector0Square1Sine_Valu != 0.0) {
motor_io_B.Switch = motor_io_B.SinGenerator;
} else {
motor_io_B.Switch = motor_io_B.SquareGenerator;
}
/* End of Switch: '<Root>/Switch' */
}
