/*
 * File: Model_actuator.c
 *
 * Code generated for Simulink model 'Model_actuator'.
 *
 * Model version                  : 1.538
 * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
 * C/C++ source code generated on : Fri Dec 19 14:23:04 2025
 *
 * Target selection: ert.tlc
 * Embedded hardware selection: ARM Compatible->ARM Cortex-M
 * Emulation hardware selection:
 *    Differs from embedded hardware (MATLAB Host)
 * Code generation objectives: Unspecified
 * Validation result: Not run
 */

#include "Model_actuator.h"
#include <stdint.h>
#include "Model_actuator_private.h"
#include "Model_actuator_types.h"

/* Exported block states */
ActuatorCmdBus controllerData;         /* '<Root>/Data Store Memory15' */

/* Block signals (default storage) */
B rtB;

/* Block states (default storage) */
DW rtDW;

/* External inputs (root inport signals with default storage) */
ExtU rtU;

/* External outputs (root outports fed by signals with default storage) */
ExtY rtY;

/* Real-time model */
static RT_MODEL rtM_;
RT_MODEL *const rtM = &rtM_;

/*
 * Output and update for action system:
 *    '<S9>/If Action Subsystem2'
 *    '<S8>/If Action Subsystem2'
 */
void IfActionSubsystem2(int8_t rtu_stepIn, int8_t *rty_step, uint8_t
  rtd_autos_set_loc[9], uint8_t rtd_coils_stop_set_loc[9], uint8_t rtd_com_loc[9],
  uint8_t rtd_lnoise_set_loc[9], uint8_t rtd_speed_set_loc[9], uint8_t
  rtd_stall_set_loc[9])
{
  int32_t i;
  for (i = 0; i < 9; i++) {
    /* DataStoreWrite: '<S31>/Data Store Write1' incorporates:
     *  Constant: '<S31>/Constant1'
     */
    rtd_stall_set_loc[i] = 0U;

    /* DataStoreWrite: '<S31>/Data Store Write3' incorporates:
     *  Constant: '<S31>/Constant2'
     */
    rtd_lnoise_set_loc[i] = 0U;

    /* DataStoreWrite: '<S31>/Data Store Write2' */
    rtd_com_loc[i] = 2U;

    /* DataStoreWrite: '<S31>/Data Store Write4' incorporates:
     *  Constant: '<S31>/Constant4'
     */
    rtd_autos_set_loc[i] = 0U;

    /* DataStoreWrite: '<S31>/Data Store Write5' incorporates:
     *  Constant: '<S31>/Constant5'
     */
    rtd_speed_set_loc[i] = 0U;

    /* DataStoreWrite: '<S31>/Data Store Write6' incorporates:
     *  Constant: '<S31>/Constant6'
     */
    rtd_coils_stop_set_loc[i] = 0U;
  }

  /* Sum: '<S31>/step inc' incorporates:
   *  Constant: '<S31>/Constant'
   */
  *rty_step = (int8_t)(rtu_stepIn + 1);
}

/* Model step function */
void Model_actuator_step(void)
{
  int32_t i;
  uint16_t tmp;
  int8_t rtb_Switch;

  /* BusCreator: '<Root>/Bus Creator' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read1'
   *  DataStoreRead: '<Root>/Data Store Read2'
   *  DataStoreRead: '<Root>/Data Store Read3'
   *  DataStoreRead: '<Root>/Data Store Read4'
   *  DataStoreRead: '<Root>/Data Store Read5'
   *  DataStoreRead: '<Root>/Data Store Read6'
   *  DataStoreRead: '<Root>/Data Store Read7'
   *  DataStoreRead: '<Root>/Data Store Read8'
   *  DataStoreRead: '<Root>/Data Store Read9'
   *  DataStoreWrite: '<Root>/Data Store Write'
   */
  for (i = 0; i < 9; i++) {
    controllerData.POS[i] = rtDW.pos_loc[i];
    controllerData.BUS_ADR[i] = rtDW.busAdr_loc[i];
    controllerData.MODE[i] = rtDW.mode_loc[i];
    controllerData.COM[i] = rtDW.com_loc[i];
    controllerData.Stall_SET[i] = rtDW.stall_set_loc[i];
    controllerData.Lnoise_SET[i] = rtDW.lnoise_set_loc[i];
    controllerData.Autos_SET[i] = rtDW.autos_set_loc[i];
    controllerData.Speed_SET[i] = rtDW.speed_set_loc[i];
    controllerData.Coils_Stop_SET[i] = rtDW.coils_stop_set_loc[i];
  }

  /* End of BusCreator: '<Root>/Bus Creator' */

  /* Switch: '<Root>/Switch' incorporates:
   *  Constant: '<Root>/Constant1'
   *  DataStoreRead: '<Root>/Data Store Read'
   *  UnitDelay: '<Root>/Unit Delay'
   */
  if (rtDW.stepSig >= 1) {
    rtb_Switch = rtDW.UnitDelay_DSTATE;
  } else {
    rtb_Switch = 1;
  }

  /* End of Switch: '<Root>/Switch' */

  /* SwitchCase: '<Root>/Switch Case' */
  switch (rtb_Switch) {
   case 1:
    /* Outputs for IfAction SubSystem: '<Root>/Stop Mode' incorporates:
     *  ActionPort: '<S12>/Action Port'
     */
    /* If: '<S12>/If1' incorporates:
     *  Inport: '<Root>/in_Busy_Ch0'
     *  Inport: '<Root>/in_Error_Connect_Ch0'
     */
    if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S12>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S37>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S37>/Data Store Write2' */
        rtDW.mode_loc[i] = 2U;

        /* DataStoreWrite: '<S37>/Data Store Write3' */
        rtDW.com_loc[i] = 0U;
      }

      /* Merge: '<Root>/Merge' incorporates:
       *  Constant: '<S37>/Constant'
       *  Merge: '<S12>/Merge'
       *  Sum: '<S37>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch + 1);

      /* End of Outputs for SubSystem: '<S12>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S12>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S38>/Action Port'
       */
      /* Merge: '<Root>/Merge' incorporates:
       *  Merge: '<S12>/Merge'
       *  SignalConversion generated from: '<S38>/stepIn'
       */
      rtB.Merge = rtb_Switch;

      /* End of Outputs for SubSystem: '<S12>/If Action Subsystem3' */
    }

    /* End of If: '<S12>/If1' */

    /* MATLAB Function: '<S12>/stop mode' */
    /* :  y = step; */
    /* :  fprintf('Stop Mode\n'); */
    printf("Stop Mode\n");
    fflush(stdout);

    /* End of Outputs for SubSystem: '<Root>/Stop Mode' */
    break;

   case 2:
    /* Outputs for IfAction SubSystem: '<Root>/Initial CPOS Min' incorporates:
     *  ActionPort: '<S7>/Action Port'
     */
    /* If: '<S7>/If' incorporates:
     *  Inport: '<Root>/in_Busy_Ch0'
     *  Inport: '<Root>/in_Error_Connect_Ch0'
     */
    if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S7>/If Action Subsystem' incorporates:
       *  ActionPort: '<S24>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S24>/Data Store Write' */
        rtDW.pos_loc[i] = 6000U;

        /* DataStoreWrite: '<S24>/Data Store Write1' */
        rtDW.com_loc[i] = 1U;
      }

      /* Merge: '<Root>/Merge' incorporates:
       *  Constant: '<S24>/Constant'
       *  Merge: '<S7>/Merge'
       *  Sum: '<S24>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch + 1);

      /* End of Outputs for SubSystem: '<S7>/If Action Subsystem' */
    } else {
      /* Outputs for IfAction SubSystem: '<S7>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S25>/Action Port'
       */
      /* Merge: '<Root>/Merge' incorporates:
       *  Merge: '<S7>/Merge'
       *  SignalConversion generated from: '<S25>/step'
       *  SignalConversion generated from: '<S25>/stepIn1'
       */
      /* :  y = step; */
      /* :  coder.extrinsic('fprintf'); */
      /* :  fprintf('Actuator else: step = %d\n', step); */
      rtB.Merge = rtb_Switch;

      /* End of Outputs for SubSystem: '<S7>/If Action Subsystem3' */
    }

    /* End of If: '<S7>/If' */

    /* MATLAB Function: '<S7>/Initial CPOS Min' */
    /* :  y = step; */
    /* :  fprintf('Initial CPOS Min\n'); */
    printf("Initial CPOS Min\n");
    fflush(stdout);

    /* End of Outputs for SubSystem: '<Root>/Initial CPOS Min' */
    break;

   case 3:
    /* Outputs for IfAction SubSystem: '<Root>/Normal Mode' incorporates:
     *  ActionPort: '<S10>/Action Port'
     */
    /* If: '<S10>/If1' incorporates:
     *  Inport: '<Root>/in_Busy_Ch0'
     *  Inport: '<Root>/in_Error_Connect_Ch0'
     */
    if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S10>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S34>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S34>/Data Store Write' */
        rtDW.mode_loc[i] = 0U;

        /* DataStoreWrite: '<S34>/Data Store Write2' */
        rtDW.com_loc[i] = 0U;
      }

      /* Merge: '<Root>/Merge' incorporates:
       *  Constant: '<S34>/Constant'
       *  Merge: '<S10>/Merge'
       *  Sum: '<S34>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch + 1);

      /* End of Outputs for SubSystem: '<S10>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S10>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S35>/Action Port'
       */
      /* Merge: '<Root>/Merge' incorporates:
       *  Merge: '<S10>/Merge'
       *  SignalConversion generated from: '<S35>/stepIn'
       */
      rtB.Merge = rtb_Switch;

      /* End of Outputs for SubSystem: '<S10>/If Action Subsystem3' */
    }

    /* End of If: '<S10>/If1' */

    /* MATLAB Function: '<S10>/Normal Mode' */
    /* :  y = step; */
    /* :  fprintf('Normal Mode\n'); */
    printf("Normal Mode\n");
    fflush(stdout);

    /* End of Outputs for SubSystem: '<Root>/Normal Mode' */
    break;

   case 4:
    /* Outputs for IfAction SubSystem: '<Root>/Move to position Min' incorporates:
     *  ActionPort: '<S9>/Action Port'
     */
    /* If: '<S9>/If1' incorporates:
     *  Inport: '<Root>/in_Busy_Ch0'
     *  Inport: '<Root>/in_Error_Connect_Ch0'
     */
    if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S9>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S31>/Action Port'
       */
      /* Merge: '<Root>/Merge' */
      IfActionSubsystem2(rtb_Switch, &rtB.Merge, rtDW.autos_set_loc,
                         rtDW.coils_stop_set_loc, rtDW.com_loc,
                         rtDW.lnoise_set_loc, rtDW.speed_set_loc,
                         rtDW.stall_set_loc);

      /* End of Outputs for SubSystem: '<S9>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S9>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S32>/Action Port'
       */
      /* Merge: '<Root>/Merge' incorporates:
       *  Merge: '<S9>/Merge'
       *  SignalConversion generated from: '<S32>/stepIn'
       */
      rtB.Merge = rtb_Switch;

      /* End of Outputs for SubSystem: '<S9>/If Action Subsystem3' */
    }

    /* End of If: '<S9>/If1' */

    /* MATLAB Function: '<S9>/Move to position Min' */
    /* :  y = step; */
    /* :  fprintf('Move to position Min\n'); */
    printf("Move to position Min\n");
    fflush(stdout);

    /* End of Outputs for SubSystem: '<Root>/Move to position Min' */
    break;

   case 5:
    /* Outputs for IfAction SubSystem: '<Root>/Check Stall Min' incorporates:
     *  ActionPort: '<S2>/Action Port'
     */
    /* If: '<S2>/If1' incorporates:
     *  Inport: '<Root>/in_Busy_Ch0'
     *  Inport: '<Root>/in_Error_Connect_Ch0'
     */
    if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S2>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S17>/Action Port'
       */
      /* DataStoreWrite: '<S17>/Data Store Write1' incorporates:
       *  DataStoreWrite: '<Root>/Data Store Write1'
       *  Inport: '<Root>/in_CPOS_ALL_Ch0'
       */
      for (i = 0; i < 9; i++) {
        rtDW.Min_position_Ch0[i] = rtU.in_CPOS_ALL_Ch0[i];
      }

      /* End of DataStoreWrite: '<S17>/Data Store Write1' */

      /* Merge: '<Root>/Merge' incorporates:
       *  Constant: '<S17>/Constant'
       *  Merge: '<S2>/Merge'
       *  Sum: '<S17>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch + 1);

      /* End of Outputs for SubSystem: '<S2>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S2>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S18>/Action Port'
       */
      /* Merge: '<Root>/Merge' incorporates:
       *  Merge: '<S2>/Merge'
       *  SignalConversion generated from: '<S18>/stepIn'
       */
      rtB.Merge = rtb_Switch;

      /* End of Outputs for SubSystem: '<S2>/If Action Subsystem3' */
    }

    /* End of If: '<S2>/If1' */

    /* MATLAB Function: '<S2>/Check Stall Min' */
    /* :  y = step; */
    /* :  fprintf('Check Stall Min\n'); */
    printf("Check Stall Min\n");
    fflush(stdout);

    /* End of Outputs for SubSystem: '<Root>/Check Stall Min' */
    break;

   case 6:
    /* Outputs for IfAction SubSystem: '<Root>/Initial CPOS Max' incorporates:
     *  ActionPort: '<S6>/Action Port'
     */
    /* If: '<S6>/If1' incorporates:
     *  Inport: '<Root>/in_Busy_Ch0'
     *  Inport: '<Root>/in_Error_Connect_Ch0'
     */
    if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S6>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S21>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S21>/Data Store Write' */
        rtDW.pos_loc[i] = 0U;

        /* DataStoreWrite: '<S21>/Data Store Write1' */
        rtDW.com_loc[i] = 1U;
      }

      /* Merge: '<Root>/Merge' incorporates:
       *  Constant: '<S21>/Constant'
       *  Merge: '<S6>/Merge'
       *  Sum: '<S21>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch + 1);

      /* End of Outputs for SubSystem: '<S6>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S6>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S22>/Action Port'
       */
      /* Merge: '<Root>/Merge' incorporates:
       *  Merge: '<S6>/Merge'
       *  SignalConversion generated from: '<S22>/stepIn'
       */
      rtB.Merge = rtb_Switch;

      /* End of Outputs for SubSystem: '<S6>/If Action Subsystem3' */
    }

    /* End of If: '<S6>/If1' */

    /* MATLAB Function: '<S6>/Initial CPOS Max' */
    /* :  y = step; */
    /* :  fprintf('Initial CPOS Max\n'); */
    printf("Initial CPOS Max\n");
    fflush(stdout);

    /* End of Outputs for SubSystem: '<Root>/Initial CPOS Max' */
    break;

   case 7:
    /* Outputs for IfAction SubSystem: '<Root>/Move to position Max' incorporates:
     *  ActionPort: '<S8>/Action Port'
     */
    /* If: '<S8>/If1' incorporates:
     *  Inport: '<Root>/in_Busy_Ch0'
     *  Inport: '<Root>/in_Error_Connect_Ch0'
     */
    if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S8>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S28>/Action Port'
       */
      /* Merge: '<Root>/Merge' */
      IfActionSubsystem2(rtb_Switch, &rtB.Merge, rtDW.autos_set_loc,
                         rtDW.coils_stop_set_loc, rtDW.com_loc,
                         rtDW.lnoise_set_loc, rtDW.speed_set_loc,
                         rtDW.stall_set_loc);

      /* End of Outputs for SubSystem: '<S8>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S8>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S29>/Action Port'
       */
      /* Merge: '<Root>/Merge' incorporates:
       *  Merge: '<S8>/Merge'
       *  SignalConversion generated from: '<S29>/stepIn'
       */
      rtB.Merge = rtb_Switch;

      /* End of Outputs for SubSystem: '<S8>/If Action Subsystem3' */
    }

    /* End of If: '<S8>/If1' */

    /* MATLAB Function: '<S8>/Move to position Max' */
    /* :  y = step; */
    /* :  fprintf('Move to position Max\n'); */
    printf("Move to position Max\n");
    fflush(stdout);

    /* End of Outputs for SubSystem: '<Root>/Move to position Max' */
    break;

   case 8:
    /* Outputs for IfAction SubSystem: '<Root>/Check Stall Max' incorporates:
     *  ActionPort: '<S1>/Action Port'
     */
    /* If: '<S1>/If1' incorporates:
     *  Inport: '<Root>/in_Busy_Ch0'
     *  Inport: '<Root>/in_Error_Connect_Ch0'
     */
    if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S1>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S14>/Action Port'
       */
      /* DataStoreWrite: '<S14>/Data Store Write1' incorporates:
       *  DataStoreWrite: '<Root>/Data Store Write1'
       *  Inport: '<Root>/in_CPOS_ALL_Ch0'
       */
      for (i = 0; i < 9; i++) {
        rtDW.Max_position_Ch0[i] = rtU.in_CPOS_ALL_Ch0[i];
      }

      /* End of DataStoreWrite: '<S14>/Data Store Write1' */

      /* Merge: '<Root>/Merge' incorporates:
       *  Constant: '<S14>/Constant'
       *  Merge: '<S1>/Merge'
       *  Sum: '<S14>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch + 1);

      /* End of Outputs for SubSystem: '<S1>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S1>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S15>/Action Port'
       */
      /* Merge: '<Root>/Merge' incorporates:
       *  Merge: '<S1>/Merge'
       *  SignalConversion generated from: '<S15>/stepIn'
       */
      rtB.Merge = rtb_Switch;

      /* End of Outputs for SubSystem: '<S1>/If Action Subsystem3' */
    }

    /* End of If: '<S1>/If1' */

    /* MATLAB Function: '<S1>/Check Stall Max' */
    /* :  y = step; */
    /* :  fprintf('Check Stall Max\n'); */
    printf("Check Stall Max\n");
    fflush(stdout);

    /* End of Outputs for SubSystem: '<Root>/Check Stall Max' */
    break;

   case 9:
    /* Outputs for IfAction SubSystem: '<Root>/Homing' incorporates:
     *  ActionPort: '<S4>/Action Port'
     */
    /* Merge: '<Root>/Merge' incorporates:
     *  Constant: '<S4>/Constant2'
     *  SignalConversion generated from: '<S4>/step'
     */
    rtB.Merge = 1;

    /* MATLAB Function: '<S4>/MAX POSITION' incorporates:
     *  DataStoreRead: '<S4>/Data Store Read2'
     */
    /* :  y = step; */
    /* :  fprintf('MAX POSITION '); */
    printf("MAX POSITION ");
    fflush(stdout);

    /* :  for i = 1:numel(step) */
    for (i = 0; i < 9; i++) {
      /* :  fprintf('%d ', int16(step(i))); */
      tmp = rtDW.Max_position_Ch0[i];
      if (tmp > 32767) {
        tmp = 32767U;
      }

      printf("%d ", (int16_t)tmp);
      fflush(stdout);
    }

    /* :  fprintf('\n'); */
    printf("\n");
    fflush(stdout);

    /* End of MATLAB Function: '<S4>/MAX POSITION' */

    /* MATLAB Function: '<S4>/MIN POSITION' incorporates:
     *  DataStoreRead: '<S4>/Data Store Read3'
     */
    /* :  y = step; */
    /* :  fprintf('MIN POSITION '); */
    printf("MIN POSITION ");
    fflush(stdout);

    /* :  for i = 1:numel(step) */
    for (i = 0; i < 9; i++) {
      /* :  fprintf('%d ', int16(step(i))); */
      tmp = rtDW.Min_position_Ch0[i];
      if (tmp > 32767) {
        tmp = 32767U;
      }

      printf("%d ", (int16_t)tmp);
      fflush(stdout);
    }

    /* :  fprintf('\n'); */
    printf("\n");
    fflush(stdout);

    /* End of MATLAB Function: '<S4>/MIN POSITION' */
    /* End of Outputs for SubSystem: '<Root>/Homing' */
    break;

   case 0:
    /* Outputs for IfAction SubSystem: '<Root>/Homing1' incorporates:
     *  ActionPort: '<S5>/Action Port'
     */
    /* Merge: '<Root>/Merge' incorporates:
     *  SignalConversion generated from: '<S5>/stepIn'
     */
    rtB.Merge = rtb_Switch;

    /* End of Outputs for SubSystem: '<Root>/Homing1' */
    break;
  }

  /* End of SwitchCase: '<Root>/Switch Case' */

  /* Outport: '<Root>/Out1' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read10'
   */
  rtY.Out1 = controllerData;

  /* DataStoreWrite: '<Root>/Start write stepSig' incorporates:
   *  Constant: '<Root>/Constant1'
   */
  rtDW.stepSig = 1;

  /* MATLAB Function: '<Root>/Finish case' incorporates:
   *  UnitDelay: '<Root>/Unit Delay'
   */
  /* :  y = step; */
  /* :  fprintf('Finish case: step = %d\n', step); */
  printf("Finish case: step = %d\n", rtDW.UnitDelay_DSTATE);
  fflush(stdout);

  /* MATLAB Function: '<Root>/Start case' */
  /* :  y = step; */
  /* :  fprintf('Start case: step = %d\n', step); */
  printf("Start case: step = %d\n", rtb_Switch);
  fflush(stdout);

  /* Update for UnitDelay: '<Root>/Unit Delay' */
  rtDW.UnitDelay_DSTATE = rtB.Merge;
}

/* Model initialize function */
void Model_actuator_initialize(void)
{
  /* (no initialization code required) */
}

/* Model terminate function */
void Model_actuator_terminate(void)
{
  /* (no terminate code required) */
}

/*
 * File trailer for generated code.
 *
 * [EOF]
 */