diff --git a/Model_Task.c b/Model_Task.c
index 1fa92f1..b8749fc 100644
--- a/Model_Task.c
+++ b/Model_Task.c
@@ -6,12 +6,16 @@
 #include <CmsisRtosThreadUtils.h>
 #include "Model_actuator.h"
 
+#define LOG_SIGN "Model"
+#define LOGGER env->logger
+
 void ModelTask_Init(
-        tModelTask *env
+        tModelTask *env,
+        tLoggerInterface *logger
 ) {
     Model_actuator_initialize();
     env->access = osMutexNew(NULL);
-
+    env->logger = logger;
     InitThreadAtrStatic(&env->thread.attr, "ModelTask", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
     env->thread.id = 0;
 }
@@ -21,6 +25,8 @@ static bool setActuatorBusy(tModelTask *env) {
     for (uint8_t i = 0; i < 9; ++i) {
         if (rtY.Out1.COM[i] != 0) {
 
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "DETECT COMMAND")
+
             env->triggerCommand = true;
 
             for (uint8_t j = 0; j < 9; ++j) {
@@ -38,11 +44,14 @@ static bool setActuatorBusy(tModelTask *env) {
 static _Noreturn void ModelTask_Thread(tModelTask *env) {
     for (;;) {
         if (osMutexAcquire(env->access, 1000) == osOK) {
+
+            LoggerFormatInfo(LOGGER, LOG_SIGN, "in_Busy_Ch0 = %d in_Act_Stall_Slave_Ch0 = %d", rtU.in_Busy_Ch0, rtU.in_Act_Stall_Slave_Ch0[7])
+
             Model_actuator_step();
             setActuatorBusy(env);
             osMutexRelease(env->access);
         }
-        SystemDelayMs(100);
+        SystemDelayMs(250);
     }
 }
 
diff --git a/Model_Task.h b/Model_Task.h
index 10ed477..d9e4d12 100644
--- a/Model_Task.h
+++ b/Model_Task.h
@@ -7,11 +7,14 @@
 
 #include <cmsis_os.h>
 #include "stdbool.h"
+#include "LoggerInterface.h"
 
 typedef struct {
 
     osMutexId_t access;
 
+    tLoggerInterface *logger;
+
     bool triggerCommand;
     uint8_t numCommand[9];
 
@@ -23,8 +26,10 @@ typedef struct {
     } thread;
 } tModelTask;
 
-void ModelTask_Init(tModelTask *env);
+void ModelTask_Init(tModelTask *env, tLoggerInterface *logger);
+
 void ModelTask_StartThread(tModelTask *env);
+
 void ModelTask_StopThread(tModelTask *env);
 
 #endif //HVAC_M7_MODEL_TASK_H
diff --git a/Model_actuator.c b/Model_actuator.c
index 9d82b6f..532ca7f 100644
--- a/Model_actuator.c
+++ b/Model_actuator.c
@@ -3,9 +3,9 @@
  *
  * Code generated for Simulink model 'Model_actuator'.
  *
- * Model version                  : 1.543
+ * Model version                  : 1.552
  * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
- * C/C++ source code generated on : Fri Dec 19 18:00:02 2025
+ * C/C++ source code generated on : Wed Dec 24 11:40:12 2025
  *
  * Target selection: ert.tlc
  * Embedded hardware selection: ARM Compatible->ARM Cortex-M
@@ -18,6 +18,7 @@
 #include "Model_actuator.h"
 #include <stdint.h>
 #include "Model_actuator_private.h"
+#include <stdbool.h>
 #include "Model_actuator_types.h"
 
 /* Exported block states */
@@ -41,12 +42,12 @@ RT_MODEL *const rtM = &rtM_;
 
 /*
  * Output and update for action system:
- *    '<S12>/If Action Subsystem3'
  *    '<S10>/If Action Subsystem3'
  *    '<S9>/If Action Subsystem3'
- *    '<S2>/If Action Subsystem3'
- *    '<S6>/If Action Subsystem3'
  *    '<S8>/If Action Subsystem3'
+ *    '<S2>/If Action Subsystem3'
+ *    '<S5>/If Action Subsystem3'
+ *    '<S7>/If Action Subsystem3'
  *    '<S1>/If Action Subsystem3'
  */
 void IfActionSubsystem3(int8_t rtu_stepIn, int8_t *rty_step, uint8_t
@@ -54,149 +55,103 @@ void IfActionSubsystem3(int8_t rtu_stepIn, int8_t *rty_step, uint8_t
 {
   int32_t i;
 
-  /* DataStoreWrite: '<S38>/Data Store Write3' */
+  /* DataStoreWrite: '<S40>/Data Store Write3' */
   for (i = 0; i < 9; i++) {
     rtd_com_loc[i] = 0U;
   }
 
-  /* End of DataStoreWrite: '<S38>/Data Store Write3' */
+  /* End of DataStoreWrite: '<S40>/Data Store Write3' */
 
-  /* SignalConversion generated from: '<S38>/stepIn' */
+  /* SignalConversion generated from: '<S40>/stepIn' */
   *rty_step = rtu_stepIn;
 }
 
+/*
+ * Output and update for atomic system:
+ *    '<S2>/MAX POSITION'
+ *    '<S1>/MAX POSITION'
+ */
+void MAXPOSITION(const int16_t rtu_step[9], int16_t rty_y[9])
+{
+  int32_t i;
+
+  /* :  y = step; */
+  for (i = 0; i < 9; i++) {
+    rty_y[i] = rtu_step[i];
+  }
+
+  /* :  fprintf('SIMULINK POSITION '); */
+  printf("SIMULINK POSITION ");
+  fflush(stdout);
+
+  /* :  for i = 1:numel(step) */
+  for (i = 0; i < 9; i++) {
+    /* :  fprintf('%d ', int16(step(i))); */
+    printf("%d ", rtu_step[i]);
+    fflush(stdout);
+  }
+
+  /* :  fprintf('\n'); */
+  printf("\n");
+  fflush(stdout);
+}
+
+/*
+ * Output and update for atomic system:
+ *    '<S2>/MAX POSITION1'
+ *    '<S1>/MAX POSITION1'
+ */
+void MAXPOSITION1(const int8_t rtu_step[9], int8_t rty_y[9])
+{
+  int32_t i;
+
+  /* :  y = step; */
+  for (i = 0; i < 9; i++) {
+    rty_y[i] = rtu_step[i];
+  }
+
+  /* :  fprintf('SIMULINK Stall_Slave '); */
+  printf("SIMULINK Stall_Slave ");
+  fflush(stdout);
+
+  /* :  for i = 1:numel(step) */
+  for (i = 0; i < 9; i++) {
+    /* :  fprintf('%d ', int16(step(i))); */
+    printf("%d ", (int16_t)rtu_step[i]);
+    fflush(stdout);
+  }
+
+  /* :  fprintf('\n'); */
+  printf("\n");
+  fflush(stdout);
+}
+
 /* Model step function */
 void Model_actuator_step(void)
 {
   int32_t i;
-  uint16_t tmp;
-  int8_t rtb_Switch;
+  int16_t rtb_y_ff[9];
+  int8_t rtb_y_b[9];
+  bool rtb_RelationalOperator_j[9];
+  bool tmp;
+  bool tmp_0;
 
   /* 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;
+  if (rtDW.stepSig < 1) {
+    /* Switch: '<Root>/Switch' incorporates:
+     *  Constant: '<Root>/Constant1'
+     */
+    rtDW.UnitDelay_DSTATE = 1;
   }
 
   /* End of Switch: '<Root>/Switch' */
 
   /* SwitchCase: '<Root>/Switch Case' */
-  switch (rtb_Switch) {
+  switch (rtDW.UnitDelay_DSTATE) {
    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] = 1U;
-      }
-
-      /* 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' */
-      IfActionSubsystem3(rtb_Switch, &rtB.Merge, rtDW.com_loc);
-
-      /* 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: '<S25>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S25>/Data Store Write' */
-        rtDW.pos_loc[i] = 6000U;
-
-        /* DataStoreWrite: '<S25>/Data Store Write1' */
-        rtDW.com_loc[i] = 2U;
-      }
-
-      /* Merge: '<Root>/Merge' incorporates:
-       *  Constant: '<S25>/Constant'
-       *  Merge: '<S7>/Merge'
-       *  Sum: '<S25>/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: '<S26>/Action Port'
-       */
-      /* DataStoreWrite: '<S26>/Data Store Write3' */
-      for (i = 0; i < 9; i++) {
-        rtDW.com_loc[i] = 0U;
-      }
-
-      /* End of DataStoreWrite: '<S26>/Data Store Write3' */
-
-      /* Merge: '<Root>/Merge' incorporates:
-       *  Merge: '<S7>/Merge'
-       *  SignalConversion generated from: '<S26>/stepIn1'
-       */
-      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:
@@ -205,47 +160,106 @@ void Model_actuator_step(void)
      */
     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'
+       *  ActionPort: '<S39>/Action Port'
        */
       for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S34>/Data Store Write' */
-        rtDW.mode_loc[i] = 0U;
+        /* DataStoreWrite: '<S39>/Data Store Write2' */
+        rtDW.mode_loc[i] = 2U;
 
-        /* DataStoreWrite: '<S34>/Data Store Write2' */
+        /* DataStoreWrite: '<S39>/Data Store Write3' */
         rtDW.com_loc[i] = 1U;
       }
 
       /* Merge: '<Root>/Merge' incorporates:
-       *  Constant: '<S34>/Constant'
+       *  Constant: '<S39>/Constant'
        *  Merge: '<S10>/Merge'
-       *  Sum: '<S34>/step inc'
+       *  SignalConversion generated from: '<S39>/step'
+       *  Sum: '<S39>/step inc'
        */
-      rtB.Merge = (int8_t)(rtb_Switch + 1);
+      rtB.Merge = (int8_t)(rtDW.UnitDelay_DSTATE + 1);
+
+      /* MATLAB Function: '<S39>/stop mode' */
+      /* :  y = step; */
+      /* :  fprintf('SIMULINK Stop Mode\n'); */
+      printf("SIMULINK Stop Mode\n");
+      fflush(stdout);
 
       /* End of Outputs for SubSystem: '<S10>/If Action Subsystem2' */
     } else {
       /* Outputs for IfAction SubSystem: '<S10>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S35>/Action Port'
+       *  ActionPort: '<S40>/Action Port'
        */
       /* Merge: '<Root>/Merge' */
-      IfActionSubsystem3(rtb_Switch, &rtB.Merge, rtDW.com_loc);
+      IfActionSubsystem3(rtDW.UnitDelay_DSTATE, &rtB.Merge, rtDW.com_loc);
 
       /* 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' */
+    /* End of Outputs for SubSystem: '<Root>/Stop Mode' */
     break;
 
-   case 4:
-    /* Outputs for IfAction SubSystem: '<Root>/Move to position Min' incorporates:
+   case 2:
+    /* Outputs for IfAction SubSystem: '<Root>/Initial CPOS Min' incorporates:
+     *  ActionPort: '<S6>/Action Port'
+     */
+    /* If: '<S6>/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: '<S6>/If Action Subsystem' incorporates:
+       *  ActionPort: '<S27>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S27>/Data Store Write' */
+        rtDW.pos_loc[i] = 6000U;
+
+        /* DataStoreWrite: '<S27>/Data Store Write1' */
+        rtDW.com_loc[i] = 2U;
+      }
+
+      /* MATLAB Function: '<S27>/Initial CPOS Min' */
+      /* :  y = step; */
+      /* :  fprintf('SIMULINK Initial CPOS Min - 6000\n'); */
+      printf("SIMULINK Initial CPOS Min - 6000\n");
+      fflush(stdout);
+
+      /* Merge: '<Root>/Merge' incorporates:
+       *  Constant: '<S27>/Constant'
+       *  Merge: '<S6>/Merge'
+       *  SignalConversion generated from: '<S27>/step'
+       *  Sum: '<S27>/step inc'
+       */
+      rtB.Merge = (int8_t)(rtDW.UnitDelay_DSTATE + 1);
+
+      /* End of Outputs for SubSystem: '<S6>/If Action Subsystem' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S6>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S28>/Action Port'
+       */
+      /* DataStoreWrite: '<S28>/Data Store Write3' */
+      for (i = 0; i < 9; i++) {
+        rtDW.com_loc[i] = 0U;
+      }
+
+      /* End of DataStoreWrite: '<S28>/Data Store Write3' */
+
+      /* Merge: '<Root>/Merge' incorporates:
+       *  Merge: '<S6>/Merge'
+       *  SignalConversion generated from: '<S28>/stepIn1'
+       */
+      rtB.Merge = rtDW.UnitDelay_DSTATE;
+
+      /* End of Outputs for SubSystem: '<S6>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S6>/If' */
+    /* End of Outputs for SubSystem: '<Root>/Initial CPOS Min' */
+    break;
+
+   case 3:
+    /* Outputs for IfAction SubSystem: '<Root>/Normal Mode' incorporates:
      *  ActionPort: '<S9>/Action Port'
      */
     /* If: '<S9>/If1' incorporates:
@@ -254,170 +268,45 @@ void Model_actuator_step(void)
      */
     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'
+       *  ActionPort: '<S36>/Action Port'
        */
       for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S31>/Data Store Write1' */
-        rtDW.stall_set_loc[i] = 1U;
+        /* DataStoreWrite: '<S36>/Data Store Write' */
+        rtDW.mode_loc[i] = 0U;
 
-        /* DataStoreWrite: '<S31>/Data Store Write3' incorporates:
-         *  Constant: '<S31>/Constant2'
-         */
-        rtDW.lnoise_set_loc[i] = 0U;
-
-        /* DataStoreWrite: '<S31>/Data Store Write2' */
-        rtDW.com_loc[i] = 3U;
-
-        /* DataStoreWrite: '<S31>/Data Store Write4' incorporates:
-         *  Constant: '<S31>/Constant4'
-         */
-        rtDW.autos_set_loc[i] = 0U;
-
-        /* DataStoreWrite: '<S31>/Data Store Write5' incorporates:
-         *  Constant: '<S31>/Constant5'
-         */
-        rtDW.speed_set_loc[i] = 0U;
-
-        /* DataStoreWrite: '<S31>/Data Store Write6' incorporates:
-         *  Constant: '<S31>/Constant6'
-         */
-        rtDW.coils_stop_set_loc[i] = 0U;
-
-        /* DataStoreWrite: '<S31>/Data Store Write' */
-        rtDW.pos_loc[i] = 0U;
+        /* DataStoreWrite: '<S36>/Data Store Write2' */
+        rtDW.com_loc[i] = 1U;
       }
 
+      /* MATLAB Function: '<S36>/Normal Mode' */
+      /* :  y = step; */
+      /* :  fprintf('SIMULINK Normal Mode\n'); */
+      printf("SIMULINK Normal Mode\n");
+      fflush(stdout);
+
       /* Merge: '<Root>/Merge' incorporates:
-       *  Constant: '<S31>/Constant'
-       *  Merge: '<S9>/Merge'
-       *  Sum: '<S31>/step inc'
+       *  Constant: '<S36>/Constant'
+       *  SignalConversion generated from: '<S36>/step'
+       *  Sum: '<S36>/step inc'
        */
-      rtB.Merge = (int8_t)(rtb_Switch + 1);
+      rtB.Merge = (int8_t)(rtDW.UnitDelay_DSTATE + 1);
 
       /* End of Outputs for SubSystem: '<S9>/If Action Subsystem2' */
     } else {
       /* Outputs for IfAction SubSystem: '<S9>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S32>/Action Port'
+       *  ActionPort: '<S37>/Action Port'
        */
-      /* Merge: '<Root>/Merge' */
-      IfActionSubsystem3(rtb_Switch, &rtB.Merge, rtDW.com_loc);
+      IfActionSubsystem3(rtDW.UnitDelay_DSTATE, &rtB.Merge, rtDW.com_loc);
 
       /* 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' */
+    /* End of Outputs for SubSystem: '<Root>/Normal Mode' */
     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: '<S18>/Action Port'
-       */
-      /* DataStoreWrite: '<S18>/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: '<S18>/Data Store Write1' */
-
-      /* Merge: '<Root>/Merge' incorporates:
-       *  Constant: '<S18>/Constant'
-       *  Merge: '<S2>/Merge'
-       *  Sum: '<S18>/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: '<S19>/Action Port'
-       */
-      /* Merge: '<Root>/Merge' */
-      IfActionSubsystem3(rtb_Switch, &rtB.Merge, rtDW.com_loc);
-
-      /* 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: '<S22>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S22>/Data Store Write' */
-        rtDW.pos_loc[i] = 0U;
-
-        /* DataStoreWrite: '<S22>/Data Store Write1' */
-        rtDW.com_loc[i] = 2U;
-      }
-
-      /* Merge: '<Root>/Merge' incorporates:
-       *  Constant: '<S22>/Constant'
-       *  Merge: '<S6>/Merge'
-       *  Sum: '<S22>/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: '<S23>/Action Port'
-       */
-      /* Merge: '<Root>/Merge' */
-      IfActionSubsystem3(rtb_Switch, &rtB.Merge, rtDW.com_loc);
-
-      /* 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:
+   case 4:
+    /* Outputs for IfAction SubSystem: '<Root>/Move to position Min' incorporates:
      *  ActionPort: '<S8>/Action Port'
      */
     /* If: '<S8>/If1' incorporates:
@@ -426,65 +315,292 @@ void Model_actuator_step(void)
      */
     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'
+       *  ActionPort: '<S33>/Action Port'
        */
       for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S28>/Data Store Write1' */
+        /* DataStoreWrite: '<S33>/Data Store Write1' */
         rtDW.stall_set_loc[i] = 1U;
 
-        /* DataStoreWrite: '<S28>/Data Store Write3' incorporates:
-         *  Constant: '<S28>/Constant2'
+        /* DataStoreWrite: '<S33>/Data Store Write3' incorporates:
+         *  Constant: '<S33>/Constant2'
          */
         rtDW.lnoise_set_loc[i] = 0U;
 
-        /* DataStoreWrite: '<S28>/Data Store Write2' */
+        /* DataStoreWrite: '<S33>/Data Store Write2' */
         rtDW.com_loc[i] = 3U;
 
-        /* DataStoreWrite: '<S28>/Data Store Write4' incorporates:
-         *  Constant: '<S28>/Constant4'
+        /* DataStoreWrite: '<S33>/Data Store Write4' incorporates:
+         *  Constant: '<S33>/Constant4'
          */
         rtDW.autos_set_loc[i] = 0U;
 
-        /* DataStoreWrite: '<S28>/Data Store Write5' incorporates:
-         *  Constant: '<S28>/Constant5'
+        /* DataStoreWrite: '<S33>/Data Store Write5' incorporates:
+         *  Constant: '<S33>/Constant5'
          */
         rtDW.speed_set_loc[i] = 0U;
 
-        /* DataStoreWrite: '<S28>/Data Store Write6' incorporates:
-         *  Constant: '<S28>/Constant6'
+        /* DataStoreWrite: '<S33>/Data Store Write6' incorporates:
+         *  Constant: '<S33>/Constant6'
          */
         rtDW.coils_stop_set_loc[i] = 0U;
 
-        /* DataStoreWrite: '<S28>/Data Store Write' */
-        rtDW.pos_loc[i] = 6000U;
+        /* DataStoreWrite: '<S33>/Data Store Write' */
+        rtDW.pos_loc[i] = 1U;
       }
 
+      /* MATLAB Function: '<S33>/Move to position Min' */
+      /* :  y = step; */
+      /* :  fprintf('SIMULINK Move to position Min - 1\n'); */
+      printf("SIMULINK Move to position Min - 1\n");
+      fflush(stdout);
+
       /* Merge: '<Root>/Merge' incorporates:
-       *  Constant: '<S28>/Constant'
-       *  Merge: '<S8>/Merge'
-       *  Sum: '<S28>/step inc'
+       *  Constant: '<S33>/Constant'
+       *  SignalConversion generated from: '<S33>/step'
+       *  Sum: '<S33>/step inc'
        */
-      rtB.Merge = (int8_t)(rtb_Switch + 1);
+      rtB.Merge = (int8_t)(rtDW.UnitDelay_DSTATE + 1);
 
       /* End of Outputs for SubSystem: '<S8>/If Action Subsystem2' */
     } else {
       /* Outputs for IfAction SubSystem: '<S8>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S29>/Action Port'
+       *  ActionPort: '<S34>/Action Port'
        */
-      /* Merge: '<Root>/Merge' */
-      IfActionSubsystem3(rtb_Switch, &rtB.Merge, rtDW.com_loc);
+      IfActionSubsystem3(rtDW.UnitDelay_DSTATE, &rtB.Merge, rtDW.com_loc);
 
       /* End of Outputs for SubSystem: '<S8>/If Action Subsystem3' */
     }
 
     /* End of If: '<S8>/If1' */
+    /* End of Outputs for SubSystem: '<Root>/Move to position Min' */
+    break;
 
-    /* MATLAB Function: '<S8>/Move to position Max' */
-    /* :  y = step; */
-    /* :  fprintf('Move to position Max\n'); */
-    printf("Move to position Max\n");
-    fflush(stdout);
+   case 5:
+    /* Outputs for IfAction SubSystem: '<Root>/Check Stall Min' incorporates:
+     *  ActionPort: '<S2>/Action Port'
+     */
+    /* RelationalOperator: '<S2>/Relational Operator1' incorporates:
+     *  DataStoreWrite: '<Root>/Data Store Write4'
+     *  Inport: '<Root>/in_Act_Stall_Slave_Ch0'
+     */
+    for (i = 0; i < 9; i++) {
+      rtb_RelationalOperator_j[i] = (rtU.in_Act_Stall_Slave_Ch0[i] == 1);
+    }
 
+    /* End of RelationalOperator: '<S2>/Relational Operator1' */
+
+    /* Logic: '<S2>/Logical Operator2' */
+    tmp = rtb_RelationalOperator_j[0];
+    for (i = 0; i < 8; i++) {
+      tmp = (tmp || rtb_RelationalOperator_j[i + 1]);
+    }
+
+    /* RelationalOperator: '<S2>/Relational Operator' incorporates:
+     *  DataStoreWrite: '<Root>/Data Store Write1'
+     *  Inport: '<Root>/in_CPOS_ALL_Ch0'
+     */
+    for (i = 0; i < 9; i++) {
+      rtb_RelationalOperator_j[i] = (rtU.in_CPOS_ALL_Ch0[i] == 1);
+    }
+
+    /* End of RelationalOperator: '<S2>/Relational Operator' */
+
+    /* Logic: '<S2>/Logical Operator1' */
+    tmp_0 = rtb_RelationalOperator_j[0];
+    for (i = 0; i < 8; i++) {
+      tmp_0 = (tmp_0 || rtb_RelationalOperator_j[i + 1]);
+    }
+
+    /* If: '<S2>/If2' incorporates:
+     *  DataTypeConversion: '<S2>/Data Type Conversion'
+     *  DataTypeConversion: '<S2>/Data Type Conversion1'
+     *  Inport: '<Root>/in_Busy_Ch0'
+     *  Inport: '<Root>/in_Error_Connect_Ch0'
+     *  Logic: '<S2>/Logical Operator'
+     *  Logic: '<S2>/Logical Operator1'
+     *  Logic: '<S2>/Logical Operator2'
+     */
+    if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0) && (tmp ||
+         tmp_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'
+       *  Sum: '<S17>/step inc'
+       */
+      rtB.Merge = (int8_t)(rtDW.UnitDelay_DSTATE + 1);
+
+      /* MATLAB Function: '<S17>/MIN POSITION' incorporates:
+       *  DataStoreWrite: '<Root>/Data Store Write1'
+       *  Inport: '<Root>/in_CPOS_ALL_Ch0'
+       */
+      /* :  y = step; */
+      /* :  fprintf('SIMULINK Min_position_Ch0 '); */
+      printf("SIMULINK Min_position_Ch0 ");
+      fflush(stdout);
+
+      /* :  for i = 1:numel(step) */
+      for (i = 0; i < 9; i++) {
+        /* :  fprintf('%d ', int16(step(i))); */
+        printf("%d ", rtU.in_CPOS_ALL_Ch0[i]);
+        fflush(stdout);
+      }
+
+      /* :  fprintf('\n'); */
+      printf("\n");
+      fflush(stdout);
+
+      /* End of MATLAB Function: '<S17>/MIN POSITION' */
+      /* End of Outputs for SubSystem: '<S2>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S2>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S18>/Action Port'
+       */
+      IfActionSubsystem3(rtDW.UnitDelay_DSTATE, &rtB.Merge, rtDW.com_loc);
+
+      /* End of Outputs for SubSystem: '<S2>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S2>/If2' */
+
+    /* MATLAB Function: '<S2>/MAX POSITION' incorporates:
+     *  Inport: '<Root>/in_CPOS_ALL_Ch0'
+     */
+    MAXPOSITION(rtU.in_CPOS_ALL_Ch0, rtb_y_ff);
+
+    /* MATLAB Function: '<S2>/MAX POSITION1' incorporates:
+     *  Inport: '<Root>/in_Act_Stall_Slave_Ch0'
+     */
+    MAXPOSITION1(rtU.in_Act_Stall_Slave_Ch0, rtb_y_b);
+
+    /* End of Outputs for SubSystem: '<Root>/Check Stall Min' */
+    break;
+
+   case 6:
+    /* Outputs for IfAction SubSystem: '<Root>/Initial CPOS Max' incorporates:
+     *  ActionPort: '<S5>/Action Port'
+     */
+    /* If: '<S5>/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: '<S5>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S24>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S24>/Data Store Write' */
+        rtDW.pos_loc[i] = 1U;
+
+        /* DataStoreWrite: '<S24>/Data Store Write1' */
+        rtDW.com_loc[i] = 2U;
+      }
+
+      /* MATLAB Function: '<S24>/Initial CPOS Max' */
+      /* :  y = step; */
+      /* :  fprintf('SIMULINK Initial CPOS Max - 1\n'); */
+      printf("SIMULINK Initial CPOS Max - 1\n");
+      fflush(stdout);
+
+      /* Merge: '<Root>/Merge' incorporates:
+       *  Constant: '<S24>/Constant'
+       *  SignalConversion generated from: '<S24>/step'
+       *  Sum: '<S24>/step inc'
+       */
+      rtB.Merge = (int8_t)(rtDW.UnitDelay_DSTATE + 1);
+
+      /* End of Outputs for SubSystem: '<S5>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S5>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S25>/Action Port'
+       */
+      IfActionSubsystem3(rtDW.UnitDelay_DSTATE, &rtB.Merge, rtDW.com_loc);
+
+      /* End of Outputs for SubSystem: '<S5>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S5>/If1' */
+    /* End of Outputs for SubSystem: '<Root>/Initial CPOS Max' */
+    break;
+
+   case 7:
+    /* Outputs for IfAction SubSystem: '<Root>/Move to position Max' incorporates:
+     *  ActionPort: '<S7>/Action Port'
+     */
+    /* If: '<S7>/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: '<S7>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S30>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S30>/Data Store Write1' */
+        rtDW.stall_set_loc[i] = 1U;
+
+        /* DataStoreWrite: '<S30>/Data Store Write3' incorporates:
+         *  Constant: '<S30>/Constant2'
+         */
+        rtDW.lnoise_set_loc[i] = 0U;
+
+        /* DataStoreWrite: '<S30>/Data Store Write2' */
+        rtDW.com_loc[i] = 3U;
+
+        /* DataStoreWrite: '<S30>/Data Store Write4' incorporates:
+         *  Constant: '<S30>/Constant4'
+         */
+        rtDW.autos_set_loc[i] = 0U;
+
+        /* DataStoreWrite: '<S30>/Data Store Write5' incorporates:
+         *  Constant: '<S30>/Constant5'
+         */
+        rtDW.speed_set_loc[i] = 0U;
+
+        /* DataStoreWrite: '<S30>/Data Store Write6' incorporates:
+         *  Constant: '<S30>/Constant6'
+         */
+        rtDW.coils_stop_set_loc[i] = 0U;
+
+        /* DataStoreWrite: '<S30>/Data Store Write' */
+        rtDW.pos_loc[i] = 6000U;
+      }
+
+      /* MATLAB Function: '<S30>/Move to position Max' */
+      /* :  y = step; */
+      /* :  fprintf('SIMULINK Move to position Max - 6000\n'); */
+      printf("SIMULINK Move to position Max - 6000\n");
+      fflush(stdout);
+
+      /* Merge: '<Root>/Merge' incorporates:
+       *  Constant: '<S30>/Constant'
+       *  SignalConversion generated from: '<S30>/step'
+       *  Sum: '<S30>/step inc'
+       */
+      rtB.Merge = (int8_t)(rtDW.UnitDelay_DSTATE + 1);
+
+      /* End of Outputs for SubSystem: '<S7>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S7>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S31>/Action Port'
+       */
+      IfActionSubsystem3(rtDW.UnitDelay_DSTATE, &rtB.Merge, rtDW.com_loc);
+
+      /* End of Outputs for SubSystem: '<S7>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S7>/If1' */
     /* End of Outputs for SubSystem: '<Root>/Move to position Max' */
     break;
 
@@ -492,15 +608,53 @@ void Model_actuator_step(void)
     /* Outputs for IfAction SubSystem: '<Root>/Check Stall Max' incorporates:
      *  ActionPort: '<S1>/Action Port'
      */
-    /* If: '<S1>/If1' incorporates:
+    /* RelationalOperator: '<S1>/Relational Operator1' incorporates:
+     *  DataStoreWrite: '<Root>/Data Store Write4'
+     *  Inport: '<Root>/in_Act_Stall_Slave_Ch0'
+     */
+    for (i = 0; i < 9; i++) {
+      rtb_RelationalOperator_j[i] = (rtU.in_Act_Stall_Slave_Ch0[i] == 1);
+    }
+
+    /* End of RelationalOperator: '<S1>/Relational Operator1' */
+
+    /* Logic: '<S1>/Logical Operator2' */
+    tmp = rtb_RelationalOperator_j[0];
+    for (i = 0; i < 8; i++) {
+      tmp = (tmp || rtb_RelationalOperator_j[i + 1]);
+    }
+
+    /* RelationalOperator: '<S1>/Relational Operator' incorporates:
+     *  DataStoreWrite: '<Root>/Data Store Write1'
+     *  Inport: '<Root>/in_CPOS_ALL_Ch0'
+     */
+    for (i = 0; i < 9; i++) {
+      rtb_RelationalOperator_j[i] = (rtU.in_CPOS_ALL_Ch0[i] == 6000);
+    }
+
+    /* End of RelationalOperator: '<S1>/Relational Operator' */
+
+    /* Logic: '<S1>/Logical Operator1' */
+    tmp_0 = rtb_RelationalOperator_j[0];
+    for (i = 0; i < 8; i++) {
+      tmp_0 = (tmp_0 || rtb_RelationalOperator_j[i + 1]);
+    }
+
+    /* If: '<S1>/If2' incorporates:
+     *  DataTypeConversion: '<S1>/Data Type Conversion'
+     *  DataTypeConversion: '<S1>/Data Type Conversion1'
      *  Inport: '<Root>/in_Busy_Ch0'
      *  Inport: '<Root>/in_Error_Connect_Ch0'
+     *  Logic: '<S1>/Logical Operator'
+     *  Logic: '<S1>/Logical Operator1'
+     *  Logic: '<S1>/Logical Operator2'
      */
-    if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) {
+    if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0) && (tmp ||
+         tmp_0)) {
       /* Outputs for IfAction SubSystem: '<S1>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S15>/Action Port'
+       *  ActionPort: '<S12>/Action Port'
        */
-      /* DataStoreWrite: '<S15>/Data Store Write1' incorporates:
+      /* DataStoreWrite: '<S12>/Data Store Write1' incorporates:
        *  DataStoreWrite: '<Root>/Data Store Write1'
        *  Inport: '<Root>/in_CPOS_ALL_Ch0'
        */
@@ -508,71 +662,89 @@ void Model_actuator_step(void)
         rtDW.Max_position_Ch0[i] = rtU.in_CPOS_ALL_Ch0[i];
       }
 
-      /* End of DataStoreWrite: '<S15>/Data Store Write1' */
+      /* End of DataStoreWrite: '<S12>/Data Store Write1' */
 
       /* Merge: '<Root>/Merge' incorporates:
-       *  Constant: '<S15>/Constant'
-       *  Merge: '<S1>/Merge'
-       *  Sum: '<S15>/step inc'
+       *  Constant: '<S12>/Constant'
+       *  Sum: '<S12>/step inc'
        */
-      rtB.Merge = (int8_t)(rtb_Switch + 1);
+      rtB.Merge = (int8_t)(rtDW.UnitDelay_DSTATE + 1);
 
+      /* MATLAB Function: '<S12>/MIN POSITION' incorporates:
+       *  DataStoreWrite: '<Root>/Data Store Write1'
+       *  Inport: '<Root>/in_CPOS_ALL_Ch0'
+       */
+      /* :  y = step; */
+      /* :  fprintf('SIMULINK Max_position_Ch0 '); */
+      printf("SIMULINK Max_position_Ch0 ");
+      fflush(stdout);
+
+      /* :  for i = 1:numel(step) */
+      for (i = 0; i < 9; i++) {
+        /* :  fprintf('%d ', int16(step(i))); */
+        printf("%d ", rtU.in_CPOS_ALL_Ch0[i]);
+        fflush(stdout);
+      }
+
+      /* :  fprintf('\n'); */
+      printf("\n");
+      fflush(stdout);
+
+      /* End of MATLAB Function: '<S12>/MIN POSITION' */
       /* End of Outputs for SubSystem: '<S1>/If Action Subsystem2' */
     } else {
       /* Outputs for IfAction SubSystem: '<S1>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S16>/Action Port'
+       *  ActionPort: '<S13>/Action Port'
        */
-      /* Merge: '<Root>/Merge' */
-      IfActionSubsystem3(rtb_Switch, &rtB.Merge, rtDW.com_loc);
+      IfActionSubsystem3(rtDW.UnitDelay_DSTATE, &rtB.Merge, rtDW.com_loc);
 
       /* End of Outputs for SubSystem: '<S1>/If Action Subsystem3' */
     }
 
-    /* End of If: '<S1>/If1' */
+    /* End of If: '<S1>/If2' */
 
-    /* MATLAB Function: '<S1>/Check Stall Max' */
-    /* :  y = step; */
-    /* :  fprintf('Check Stall Max\n'); */
-    printf("Check Stall Max\n");
-    fflush(stdout);
+    /* MATLAB Function: '<S1>/MAX POSITION' incorporates:
+     *  Inport: '<Root>/in_CPOS_ALL_Ch0'
+     */
+    MAXPOSITION(rtU.in_CPOS_ALL_Ch0, rtb_y_ff);
+
+    /* MATLAB Function: '<S1>/MAX POSITION1' incorporates:
+     *  Inport: '<Root>/in_Act_Stall_Slave_Ch0'
+     */
+    MAXPOSITION1(rtU.in_Act_Stall_Slave_Ch0, rtb_y_b);
 
     /* End of Outputs for SubSystem: '<Root>/Check Stall Max' */
     break;
 
    case 9:
     /* Outputs for IfAction SubSystem: '<Root>/Homing' incorporates:
-     *  ActionPort: '<S4>/Action Port'
+     *  ActionPort: '<S3>/Action Port'
      */
-    /* DataStoreWrite: '<S4>/Data Store Write3' */
+    /* DataStoreWrite: '<S3>/Data Store Write3' */
     for (i = 0; i < 9; i++) {
       rtDW.com_loc[i] = 0U;
     }
 
-    /* End of DataStoreWrite: '<S4>/Data Store Write3' */
+    /* End of DataStoreWrite: '<S3>/Data Store Write3' */
 
     /* Merge: '<Root>/Merge' incorporates:
-     *  Constant: '<S4>/Constant2'
-     *  SignalConversion generated from: '<S4>/step'
+     *  Constant: '<S3>/Constant2'
+     *  SignalConversion generated from: '<S3>/step'
      */
     rtB.Merge = 1;
 
-    /* MATLAB Function: '<S4>/MAX POSITION' incorporates:
-     *  DataStoreRead: '<S4>/Data Store Read2'
+    /* MATLAB Function: '<S3>/MAX POSITION' incorporates:
+     *  DataStoreRead: '<S3>/Data Store Read2'
      */
     /* :  y = step; */
-    /* :  fprintf('MAX POSITION '); */
-    printf("MAX POSITION ");
+    /* :  fprintf('SIMULINK MAX POSITION '); */
+    printf("SIMULINK 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);
+      printf("%d ", rtDW.Max_position_Ch0[i]);
       fflush(stdout);
     }
 
@@ -580,25 +752,20 @@ void Model_actuator_step(void)
     printf("\n");
     fflush(stdout);
 
-    /* End of MATLAB Function: '<S4>/MAX POSITION' */
+    /* End of MATLAB Function: '<S3>/MAX POSITION' */
 
-    /* MATLAB Function: '<S4>/MIN POSITION' incorporates:
-     *  DataStoreRead: '<S4>/Data Store Read3'
+    /* MATLAB Function: '<S3>/MIN POSITION' incorporates:
+     *  DataStoreRead: '<S3>/Data Store Read3'
      */
     /* :  y = step; */
-    /* :  fprintf('MIN POSITION '); */
-    printf("MIN POSITION ");
+    /* :  fprintf('SIMULINK MIN POSITION '); */
+    printf("SIMULINK 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);
+      printf("%d ", rtDW.Min_position_Ch0[i]);
       fflush(stdout);
     }
 
@@ -606,18 +773,18 @@ void Model_actuator_step(void)
     printf("\n");
     fflush(stdout);
 
-    /* End of MATLAB Function: '<S4>/MIN POSITION' */
+    /* End of MATLAB Function: '<S3>/MIN POSITION' */
     /* End of Outputs for SubSystem: '<Root>/Homing' */
     break;
 
    case 0:
     /* Outputs for IfAction SubSystem: '<Root>/Homing1' incorporates:
-     *  ActionPort: '<S5>/Action Port'
+     *  ActionPort: '<S4>/Action Port'
      */
     /* Merge: '<Root>/Merge' incorporates:
-     *  SignalConversion generated from: '<S5>/stepIn'
+     *  SignalConversion generated from: '<S4>/stepIn'
      */
-    rtB.Merge = rtb_Switch;
+    rtB.Merge = rtDW.UnitDelay_DSTATE;
 
     /* End of Outputs for SubSystem: '<Root>/Homing1' */
     break;
@@ -630,17 +797,17 @@ void Model_actuator_step(void)
    */
   rtDW.stepSig = 1;
 
-  /* BusCreator: '<S13>/Bus Creator' incorporates:
-   *  DataStoreRead: '<S13>/Data Store Read1'
-   *  DataStoreRead: '<S13>/Data Store Read2'
-   *  DataStoreRead: '<S13>/Data Store Read3'
-   *  DataStoreRead: '<S13>/Data Store Read4'
-   *  DataStoreRead: '<S13>/Data Store Read5'
-   *  DataStoreRead: '<S13>/Data Store Read6'
-   *  DataStoreRead: '<S13>/Data Store Read7'
-   *  DataStoreRead: '<S13>/Data Store Read8'
-   *  DataStoreRead: '<S13>/Data Store Read9'
-   *  DataStoreWrite: '<S13>/Data Store Write'
+  /* BusCreator: '<S11>/Bus Creator' incorporates:
+   *  DataStoreRead: '<S11>/Data Store Read1'
+   *  DataStoreRead: '<S11>/Data Store Read2'
+   *  DataStoreRead: '<S11>/Data Store Read3'
+   *  DataStoreRead: '<S11>/Data Store Read4'
+   *  DataStoreRead: '<S11>/Data Store Read5'
+   *  DataStoreRead: '<S11>/Data Store Read6'
+   *  DataStoreRead: '<S11>/Data Store Read7'
+   *  DataStoreRead: '<S11>/Data Store Read8'
+   *  DataStoreRead: '<S11>/Data Store Read9'
+   *  DataStoreWrite: '<S11>/Data Store Write'
    */
   for (i = 0; i < 9; i++) {
     controllerData.POS[i] = rtDW.pos_loc[i];
@@ -654,28 +821,16 @@ void Model_actuator_step(void)
     controllerData.Coils_Stop_SET[i] = rtDW.coils_stop_set_loc[i];
   }
 
-  /* End of BusCreator: '<S13>/Bus Creator' */
+  /* End of BusCreator: '<S11>/Bus Creator' */
 
   /* Outport: '<Root>/Out1' incorporates:
    *  DataStoreRead: '<Root>/Data Store Read10'
    */
   rtY.Out1 = controllerData;
 
-  /* MATLAB Function: '<Root>/Finish case' incorporates:
+  /* Update for Switch: '<Root>/Switch' 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;
 }
 
diff --git a/Model_actuator.h b/Model_actuator.h
index 61d9a75..df98196 100644
--- a/Model_actuator.h
+++ b/Model_actuator.h
@@ -3,9 +3,9 @@
  *
  * Code generated for Simulink model 'Model_actuator'.
  *
- * Model version                  : 1.542
+ * Model version                  : 1.550
  * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
- * C/C++ source code generated on : Fri Dec 19 17:44:01 2025
+ * C/C++ source code generated on : Tue Dec 23 15:12:50 2025
  *
  * Target selection: ert.tlc
  * Embedded hardware selection: ARM Compatible->ARM Cortex-M
@@ -45,8 +45,8 @@ typedef struct {
 
 /* Block states (default storage) for system '<Root>' */
 typedef struct {
-  uint16_t Min_position_Ch0[9];        /* '<Root>/Data Store Memory12' */
-  uint16_t Max_position_Ch0[9];        /* '<Root>/Data Store Memory13' */
+  int16_t Min_position_Ch0[9];         /* '<Root>/Data Store Memory12' */
+  int16_t Max_position_Ch0[9];         /* '<Root>/Data Store Memory13' */
   uint16_t pos_loc[9];                 /* '<Root>/Data Store Memory4' */
   int8_t UnitDelay_DSTATE;             /* '<Root>/Unit Delay' */
   int8_t stepSig;                      /* '<Root>/Data Store Memory' */
@@ -62,18 +62,18 @@ typedef struct {
 
 /* External inputs (root inport signals with default storage) */
 typedef struct {
-  uint16_t in_CPOS_ALL_Ch0[9];         /* '<Root>/in_CPOS_ALL_Ch0' */
-  uint8_t in_Act_Emrf_Slave_Ch0[9];    /* '<Root>/in_Act_Emrf_Slave_Ch0' */
-  uint8_t in_Mode_Slave_Ch0[9];        /* '<Root>/in_Mode_Slave_Ch0' */
-  uint8_t in_Act_Err1_Supply_Ch0[9];   /* '<Root>/in_Act_Err1_Supply_Ch0' */
-  uint8_t in_Act_Err2_Communication_Ch0[9];
+  int16_t in_CPOS_ALL_Ch0[9];          /* '<Root>/in_CPOS_ALL_Ch0' */
+  int8_t in_Act_Emrf_Slave_Ch0[9];     /* '<Root>/in_Act_Emrf_Slave_Ch0' */
+  int8_t in_Mode_Slave_Ch0[9];         /* '<Root>/in_Mode_Slave_Ch0' */
+  int8_t in_Act_Err1_Supply_Ch0[9];    /* '<Root>/in_Act_Err1_Supply_Ch0' */
+  int8_t in_Act_Err2_Communication_Ch0[9];
                                     /* '<Root>/in_Act_Err2_Communication_Ch0' */
-  uint8_t in_Act_Err3_Temperature_Ch0[9];
+  int8_t in_Act_Err3_Temperature_Ch0[9];
                                       /* '<Root>/in_Act_Err3_Temperature_Ch0' */
-  uint8_t in_Act_Err4_Permanent_Electrical_Ch0[9];
+  int8_t in_Act_Err4_Permanent_Electrical_Ch0[9];
                              /* '<Root>/in_Act_Err4_Permanent_Electrical_Ch0' */
-  uint8_t in_Act_Stall_Slave_Ch0[9];   /* '<Root>/in_Act_Stall_Slave_Ch0' */
-  uint8_t in_Act_Reset_Ch0[9];         /* '<Root>/in_Act_Reset_Ch0' */
+  int8_t in_Act_Stall_Slave_Ch0[9];    /* '<Root>/in_Act_Stall_Slave_Ch0' */
+  int8_t in_Act_Reset_Ch0[9];          /* '<Root>/in_Act_Reset_Ch0' */
   uint8_t in_Busy_Ch0;                 /* '<Root>/in_Busy_Ch0' */
   uint8_t in_Error_Connect_Ch0;        /* '<Root>/in_Error_Connect_Ch0' */
 } ExtU;
diff --git a/Model_actuator_private.h b/Model_actuator_private.h
index 8f5ba10..487fecc 100644
--- a/Model_actuator_private.h
+++ b/Model_actuator_private.h
@@ -3,9 +3,9 @@
  *
  * Code generated for Simulink model 'Model_actuator'.
  *
- * Model version                  : 1.542
+ * Model version                  : 1.550
  * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
- * C/C++ source code generated on : Fri Dec 19 17:44:01 2025
+ * C/C++ source code generated on : Tue Dec 23 15:12:50 2025
  *
  * Target selection: ert.tlc
  * Embedded hardware selection: ARM Compatible->ARM Cortex-M
@@ -24,10 +24,6 @@
 
 extern void IfActionSubsystem3(int8_t rtu_stepIn, int8_t *rty_step, uint8_t
   rtd_com_loc[9]);
-extern 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]);
 
 #endif                                 /* Model_actuator_private_h_ */
 
diff --git a/Model_actuator_types.h b/Model_actuator_types.h
index 3773767..bbd4855 100644
--- a/Model_actuator_types.h
+++ b/Model_actuator_types.h
@@ -3,9 +3,9 @@
  *
  * Code generated for Simulink model 'Model_actuator'.
  *
- * Model version                  : 1.542
+ * Model version                  : 1.550
  * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
- * C/C++ source code generated on : Fri Dec 19 17:44:01 2025
+ * C/C++ source code generated on : Tue Dec 23 15:12:50 2025
  *
  * Target selection: ert.tlc
  * Embedded hardware selection: ARM Compatible->ARM Cortex-M