/* Output and update for referenced model: 'motor_hr' */
void motor_hr(const real_T *rtu_enable, const real_T *rtu_power, const real_T
*rtu_direction)
{
real_T rtu_enable_0;
uint8_T rtu_enable_1;
/* Switch: '<Root>/Switch' incorporates:
* Constant: '<Root>/Constant2'
*/
if (*rtu_enable > motor_hr_P.Switch_Threshold) {
rtu_enable_0 = *rtu_direction;
} else {
rtu_enable_0 = motor_hr_P.Constant2_Value;
}
/* End of Switch: '<Root>/Switch' */
/* DataTypeConversion: '<S1>/Data Type Conversion' */
if (rtu_enable_0 < 256.0) {
if (rtu_enable_0 >= 0.0) {
rtu_enable_1 = (uint8_T)rtu_enable_0;
} else {
rtu_enable_1 = 0U;
}
} else {
rtu_enable_1 = MAX_uint8_T;
}
/* End of DataTypeConversion: '<S1>/Data Type Conversion' */
/* S-Function (arduinodigitaloutput_sfcn): '<S1>/Digital Output' */
MW_digitalWrite(motor_hr_P.DigitalOutput_pinNumber, rtu_enable_1);
/* Switch: '<Root>/Switch1' incorporates:
* Constant: '<Root>/Constant3'
*/
if (*rtu_enable > motor_hr_P.Switch1_Threshold) {
rtu_enable_0 = *rtu_power;
} else {
rtu_enable_0 = motor_hr_P.Constant3_Value;
}
/* End of Switch: '<Root>/Switch1' */
/* DataTypeConversion: '<S2>/Data Type Conversion' */
if (rtu_enable_0 < 256.0) {
if (rtu_enable_0 >= 0.0) {
rtu_enable_1 = (uint8_T)rtu_enable_0;
} else {
rtu_enable_1 = 0U;
}
} else {
rtu_enable_1 = MAX_uint8_T;
}
/* End of DataTypeConversion: '<S2>/Data Type Conversion' */
/* S-Function (arduinoanalogoutput_sfcn): '<S2>/PWM' */
MW_analogWrite(motor_hr_P.PWM_pinNumber, rtu_enable_1);
}
/* Model output function */
void ArduinoFirstTry_output(void)
{
real_T rtb_PulseGenerator;
uint8_T rtb_PulseGenerator_0;
/* DiscretePulseGenerator: '<Root>/Pulse Generator' */
rtb_PulseGenerator = (ArduinoFirstTry_DW.clockTickCounter <
ArduinoFirstTry_P.PulseGenerator_Duty) &&
(ArduinoFirstTry_DW.clockTickCounter >= 0L) ?
ArduinoFirstTry_P.PulseGenerator_Amp : 0.0;
if (ArduinoFirstTry_DW.clockTickCounter >=
ArduinoFirstTry_P.PulseGenerator_Period - 1.0) {
ArduinoFirstTry_DW.clockTickCounter = 0L;
} else {
ArduinoFirstTry_DW.clockTickCounter++;
}
/* End of DiscretePulseGenerator: '<Root>/Pulse Generator' */
/* DataTypeConversion: '<S1>/Data Type Conversion' */
if (rtb_PulseGenerator < 256.0) {
if (rtb_PulseGenerator >= 0.0) {
rtb_PulseGenerator_0 = (uint8_T)rtb_PulseGenerator;
} else {
rtb_PulseGenerator_0 = 0U;
}
} else {
rtb_PulseGenerator_0 = MAX_uint8_T;
}
/* End of DataTypeConversion: '<S1>/Data Type Conversion' */
/* S-Function (arduinodigitaloutput_sfcn): '<S1>/Digital Output' */
MW_digitalWrite(ArduinoFirstTry_P.DigitalOutput_pinNumber,
rtb_PulseGenerator_0);
}
/* Model step function */
void motor_hr_step(void)
{
real_T tmp;
uint8_T tmp_0;
/* Switch: '<Root>/Switch' incorporates:
* Constant: '<Root>/Constant2'
* Inport: '<Root>/direction'
* Inport: '<Root>/enable'
*/
if (motor_hr_U.enable > motor_hr_P.Switch_Threshold) {
tmp = motor_hr_U.direction;
} else {
tmp = motor_hr_P.Constant2_Value;
}
/* End of Switch: '<Root>/Switch' */
/* DataTypeConversion: '<S1>/Data Type Conversion' */
if (tmp < 256.0) {
if (tmp >= 0.0) {
tmp_0 = (uint8_T)tmp;
} else {
tmp_0 = 0U;
}
} else {
tmp_0 = MAX_uint8_T;
}
/* End of DataTypeConversion: '<S1>/Data Type Conversion' */
/* S-Function (arduinodigitaloutput_sfcn): '<S1>/Digital Output' */
MW_digitalWrite(motor_hr_P.DigitalOutput_pinNumber, tmp_0);
/* Switch: '<Root>/Switch1' incorporates:
* Constant: '<Root>/Constant3'
* Inport: '<Root>/enable'
* Inport: '<Root>/power'
*/
if (motor_hr_U.enable > motor_hr_P.Switch1_Threshold) {
tmp = motor_hr_U.power;
} else {
tmp = motor_hr_P.Constant3_Value;
}
/* End of Switch: '<Root>/Switch1' */
/* DataTypeConversion: '<S2>/Data Type Conversion' */
if (tmp < 256.0) {
if (tmp >= 0.0) {
tmp_0 = (uint8_T)tmp;
} else {
tmp_0 = 0U;
}
} else {
tmp_0 = MAX_uint8_T;
}
/* End of DataTypeConversion: '<S2>/Data Type Conversion' */
/* S-Function (arduinoanalogoutput_sfcn): '<S2>/PWM' */
MW_analogWrite(motor_hr_P.PWM_pinNumber, tmp_0);
/* External mode */
rtExtModeUploadCheckTrigger(1);
{ /* Sample time: [20.0s, 0.0s] */
rtExtModeUpload(0, motor_hr_M->Timing.taskTime0);
}
/* signal main to stop simulation */
{ /* Sample time: [20.0s, 0.0s] */
if ((rtmGetTFinal(motor_hr_M)!=-1) &&
!((rtmGetTFinal(motor_hr_M)-motor_hr_M->Timing.taskTime0) >
motor_hr_M->Timing.taskTime0 * (DBL_EPSILON))) {
rtmSetErrorStatus(motor_hr_M, "Simulation finished");
}
if (rtmGetStopRequested(motor_hr_M)) {
rtmSetErrorStatus(motor_hr_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.
*/
motor_hr_M->Timing.taskTime0 =
(++motor_hr_M->Timing.clockTick0) * motor_hr_M->Timing.stepSize0;
}
/*
* Output and update for atomic system:
* '<S1>/hl'
* '<S1>/vl'
*/
void motor_test_hierarchies_hl(real_T rtu_enable, real_T rtu_power, real_T
rtu_direction, B_hl_motor_test_hierarchies_T *localB,
P_hl_motor_test_hierarchies_T *localP)
{
real_T rtu_enable_0;
uint8_T rtu_enable_1;
/* Switch: '<S4>/Switch' incorporates:
* Constant: '<S4>/Constant2'
*/
if (rtu_enable > localP->Switch_Threshold) {
rtu_enable_0 = rtu_direction;
} else {
rtu_enable_0 = localP->Constant2_Value;
}
/* End of Switch: '<S4>/Switch' */
/* DataTypeConversion: '<S8>/Data Type Conversion' */
if (rtu_enable_0 < 256.0) {
if (rtu_enable_0 >= 0.0) {
rtu_enable_1 = (uint8_T)rtu_enable_0;
} else {
rtu_enable_1 = 0U;
}
} else {
rtu_enable_1 = MAX_uint8_T;
}
/* End of DataTypeConversion: '<S8>/Data Type Conversion' */
/* S-Function (arduinodigitaloutput_sfcn): '<S8>/Digital Output' */
MW_digitalWrite(localP->DigitalOutput_pinNumber, rtu_enable_1);
/* Switch: '<S4>/Switch1' incorporates:
* Constant: '<S4>/Constant3'
* DataTypeConversion: '<S9>/Data Type Conversion'
*/
if (rtu_enable > localP->Switch1_Threshold) {
/* DataTypeConversion: '<S9>/Data Type Conversion' */
if (rtu_power < 256.0) {
if (rtu_power >= 0.0) {
localB->DataTypeConversion = (uint8_T)rtu_power;
} else {
localB->DataTypeConversion = 0U;
}
} else {
localB->DataTypeConversion = MAX_uint8_T;
}
} else if (localP->Constant3_Value < 256.0) {
/* DataTypeConversion: '<S9>/Data Type Conversion' incorporates:
* Constant: '<S4>/Constant3'
*/
if (localP->Constant3_Value >= 0.0) {
localB->DataTypeConversion = (uint8_T)localP->Constant3_Value;
} else {
localB->DataTypeConversion = 0U;
}
} else {
/* DataTypeConversion: '<S9>/Data Type Conversion' */
localB->DataTypeConversion = MAX_uint8_T;
}
/* End of Switch: '<S4>/Switch1' */
/* S-Function (arduinoanalogoutput_sfcn): '<S9>/PWM' */
MW_analogWrite(localP->PWM_pinNumber, localB->DataTypeConversion);
}
/* Model step function */
void motor_test_hierarchies_step(void)
{
/* local block i/o variables */
real_T rtb_FromWs;
real_T tmp;
uint8_T tmp_0;
/* Constant: '<Root>/enable' */
motor_test_hierarchies_B.enable = motor_test_hierarchies_P.enable_Value;
/* FromWorkspace: '<S3>/FromWs' */
{
real_T *pDataValues = (real_T *)
motor_test_hierarchies_DW.FromWs_PWORK.DataPtr;
real_T *pTimeValues = (real_T *)
motor_test_hierarchies_DW.FromWs_PWORK.TimePtr;
int_T currTimeIndex = motor_test_hierarchies_DW.FromWs_IWORK.PrevIndex;
real_T t = motor_test_hierarchies_M->Timing.t[0];
/* Get index */
if (t <= pTimeValues[0]) {
currTimeIndex = 0;
} else if (t >= pTimeValues[9]) {
currTimeIndex = 8;
} else {
if (t < pTimeValues[currTimeIndex]) {
while (t < pTimeValues[currTimeIndex]) {
currTimeIndex--;
}
} else {
while (t >= pTimeValues[currTimeIndex + 1]) {
currTimeIndex++;
}
}
}
motor_test_hierarchies_DW.FromWs_IWORK.PrevIndex = currTimeIndex;
/* Post output */
{
real_T t1 = pTimeValues[currTimeIndex];
real_T t2 = pTimeValues[currTimeIndex + 1];
if (t1 == t2) {
if (t < t1) {
rtb_FromWs = pDataValues[currTimeIndex];
} else {
rtb_FromWs = pDataValues[currTimeIndex + 1];
}
} else {
real_T f1 = (t2 - t) / (t2 - t1);
real_T f2 = 1.0 - f1;
real_T d1;
real_T d2;
int_T TimeIndex= currTimeIndex;
d1 = pDataValues[TimeIndex];
d2 = pDataValues[TimeIndex + 1];
rtb_FromWs = (real_T) rtInterpolate(d1, d2, f1, f2);
pDataValues += 10;
}
}
}
/* Outputs for Atomic SubSystem: '<S1>/hl' */
/* Constant: '<Root>/direction' */
motor_test_hierarchies_hl(motor_test_hierarchies_B.enable, rtb_FromWs,
motor_test_hierarchies_P.direction_Value, &motor_test_hierarchies_B.hl,
(P_hl_motor_test_hierarchies_T *)&motor_test_hierarchies_P.hl);
/* End of Outputs for SubSystem: '<S1>/hl' */
/* Outputs for Atomic SubSystem: '<S1>/hr' */
/* Switch: '<S5>/Switch' incorporates:
* Constant: '<Root>/direction'
* Constant: '<S5>/Constant2'
*/
if (motor_test_hierarchies_B.enable >
motor_test_hierarchies_P.Switch_Threshold) {
tmp = motor_test_hierarchies_P.direction_Value;
} else {
tmp = motor_test_hierarchies_P.Constant2_Value;
}
/* End of Switch: '<S5>/Switch' */
/* DataTypeConversion: '<S10>/Data Type Conversion' */
if (tmp < 256.0) {
if (tmp >= 0.0) {
tmp_0 = (uint8_T)tmp;
} else {
tmp_0 = 0U;
}
} else {
tmp_0 = MAX_uint8_T;
}
/* End of DataTypeConversion: '<S10>/Data Type Conversion' */
/* S-Function (arduinodigitaloutput_sfcn): '<S10>/Digital Output' */
MW_digitalWrite(motor_test_hierarchies_P.DigitalOutput_pinNumber, tmp_0);
/* Switch: '<S5>/Switch1' incorporates:
* Constant: '<S5>/Constant3'
* DataTypeConversion: '<S11>/Data Type Conversion'
*/
if (motor_test_hierarchies_B.enable >
motor_test_hierarchies_P.Switch1_Threshold) {
/* DataTypeConversion: '<S11>/Data Type Conversion' */
if (rtb_FromWs < 256.0) {
if (rtb_FromWs >= 0.0) {
motor_test_hierarchies_B.DataTypeConversion_b = (uint8_T)rtb_FromWs;
} else {
motor_test_hierarchies_B.DataTypeConversion_b = 0U;
}
} else {
motor_test_hierarchies_B.DataTypeConversion_b = MAX_uint8_T;
}
} else if (motor_test_hierarchies_P.Constant3_Value < 256.0) {
/* DataTypeConversion: '<S11>/Data Type Conversion' incorporates:
* Constant: '<S5>/Constant3'
*/
if (motor_test_hierarchies_P.Constant3_Value >= 0.0) {
motor_test_hierarchies_B.DataTypeConversion_b = (uint8_T)
motor_test_hierarchies_P.Constant3_Value;
} else {
motor_test_hierarchies_B.DataTypeConversion_b = 0U;
}
} else {
/* DataTypeConversion: '<S11>/Data Type Conversion' */
motor_test_hierarchies_B.DataTypeConversion_b = MAX_uint8_T;
}
/* End of Switch: '<S5>/Switch1' */
/* S-Function (arduinoanalogoutput_sfcn): '<S11>/PWM' */
MW_analogWrite(motor_test_hierarchies_P.PWM_pinNumber,
motor_test_hierarchies_B.DataTypeConversion_b);
/* Outputs for Atomic SubSystem: '<S1>/vl' */
/* Constant: '<Root>/direction' */
motor_test_hierarchies_hl(motor_test_hierarchies_B.enable, rtb_FromWs,
motor_test_hierarchies_P.direction_Value, &motor_test_hierarchies_B.vl,
(P_hl_motor_test_hierarchies_T *)&motor_test_hierarchies_P.vl);
/* End of Outputs for SubSystem: '<S1>/vl' */
/* Outputs for Atomic SubSystem: '<S1>/vr' */
/* Switch: '<S7>/Switch' incorporates:
* Constant: '<Root>/direction'
* Constant: '<S7>/Constant2'
*/
if (motor_test_hierarchies_B.enable >
motor_test_hierarchies_P.Switch_Threshold_k) {
tmp = motor_test_hierarchies_P.direction_Value;
} else {
tmp = motor_test_hierarchies_P.Constant2_Value_n;
}
/* End of Switch: '<S7>/Switch' */
/* DataTypeConversion: '<S14>/Data Type Conversion' */
if (tmp < 256.0) {
if (tmp >= 0.0) {
tmp_0 = (uint8_T)tmp;
} else {
tmp_0 = 0U;
}
} else {
tmp_0 = MAX_uint8_T;
}
/* End of DataTypeConversion: '<S14>/Data Type Conversion' */
/* S-Function (arduinodigitaloutput_sfcn): '<S14>/Digital Output' */
MW_digitalWrite(motor_test_hierarchies_P.DigitalOutput_pinNumber_a, tmp_0);
/* Switch: '<S7>/Switch1' incorporates:
* Constant: '<S7>/Constant3'
* DataTypeConversion: '<S15>/Data Type Conversion'
*/
if (motor_test_hierarchies_B.enable >
motor_test_hierarchies_P.Switch1_Threshold_o) {
/* DataTypeConversion: '<S15>/Data Type Conversion' */
if (rtb_FromWs < 256.0) {
if (rtb_FromWs >= 0.0) {
motor_test_hierarchies_B.DataTypeConversion = (uint8_T)rtb_FromWs;
} else {
motor_test_hierarchies_B.DataTypeConversion = 0U;
}
} else {
motor_test_hierarchies_B.DataTypeConversion = MAX_uint8_T;
}
} else if (motor_test_hierarchies_P.Constant3_Value_f < 256.0) {
/* DataTypeConversion: '<S15>/Data Type Conversion' incorporates:
* Constant: '<S7>/Constant3'
*/
if (motor_test_hierarchies_P.Constant3_Value_f >= 0.0) {
motor_test_hierarchies_B.DataTypeConversion = (uint8_T)
motor_test_hierarchies_P.Constant3_Value_f;
} else {
motor_test_hierarchies_B.DataTypeConversion = 0U;
}
} else {
/* DataTypeConversion: '<S15>/Data Type Conversion' */
motor_test_hierarchies_B.DataTypeConversion = MAX_uint8_T;
}
/* End of Switch: '<S7>/Switch1' */
/* S-Function (arduinoanalogoutput_sfcn): '<S15>/PWM' */
MW_analogWrite(motor_test_hierarchies_P.PWM_pinNumber_n,
motor_test_hierarchies_B.DataTypeConversion);
/* External mode */
rtExtModeUploadCheckTrigger(2);
{ /* Sample time: [0.0s, 0.0s] */
rtExtModeUpload(0, motor_test_hierarchies_M->Timing.t[0]);
}
{ /* Sample time: [1.0s, 0.0s] */
rtExtModeUpload(1, ((motor_test_hierarchies_M->Timing.clockTick1) ));
}
/* signal main to stop simulation */
{ /* Sample time: [0.0s, 0.0s] */
if ((rtmGetTFinal(motor_test_hierarchies_M)!=-1) &&
!((rtmGetTFinal(motor_test_hierarchies_M)-
motor_test_hierarchies_M->Timing.t[0]) >
motor_test_hierarchies_M->Timing.t[0] * (DBL_EPSILON))) {
rtmSetErrorStatus(motor_test_hierarchies_M, "Simulation finished");
}
if (rtmGetStopRequested(motor_test_hierarchies_M)) {
rtmSetErrorStatus(motor_test_hierarchies_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.
*/
motor_test_hierarchies_M->Timing.t[0] =
(++motor_test_hierarchies_M->Timing.clockTick0) *
motor_test_hierarchies_M->Timing.stepSize0;
{
/* Update absolute timer for sample time: [1.0s, 0.0s] */
/* The "clockTick1" counts the number of times the code of this task has
* been executed. The resolution of this integer timer is 1.0, which is the step size
* of the task. Size of "clockTick1" ensures timer will not overflow during the
* application lifespan selected.
*/
motor_test_hierarchies_M->Timing.clockTick1++;
}
}
