diff --git a/DUTs/E_SlitSoftLimits.TcDUT b/DUTs/E_SlitSoftLimits.TcDUT
new file mode 100644
index 00000000..c2610442
--- /dev/null
+++ b/DUTs/E_SlitSoftLimits.TcDUT
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<TcPlcObject Version="1.1.0.1">
+  <DUT Name="E_SlitSoftLimits" Id="{5a8c53db-c513-01b1-1e81-1ca22261b4f2}">
+    <Declaration><![CDATA[{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE E_SlitSoftLimits :
+(
+    START := 0,
+    WRITE_GAP_CENTRE_FWD,
+    WRITE_GAP_CENTRE_BWD,
+    WRITE_GAP_SIZE_FWD,
+    FINISH
+    );
+END_TYPE
+]]></Declaration>
+  </DUT>
+</TcPlcObject>
\ No newline at end of file
diff --git a/POUs/Motion/FB_Axis.TcPOU b/POUs/Motion/FB_Axis.TcPOU
index 4689df3d..5955d21b 100644
--- a/POUs/Motion/FB_Axis.TcPOU
+++ b/POUs/Motion/FB_Axis.TcPOU
@@ -638,16 +638,16 @@ IF _stAxis.stControl.eCommand = E_MotionFunctions.eGearInMultiMaster AND _stAxis
     //Transfer gear ratios to FB
     fbGearInMultiMaster.GearRatio1 := _stAxis.stConfig.astMultiMasterAxisLatched[1].fRatio;
     fbGearInMultiMaster.GearRatio2 := _stAxis.stConfig.astMultiMasterAxisLatched[2].fRatio;
-    fbGearInMultiMaster.GearRatio3 := _stAxis.stConfig.astMultiMasterAxisLatched[3].fRatio;
-    fbGearInMultiMaster.GearRatio4 := _stAxis.stConfig.astMultiMasterAxisLatched[4].fRatio;
+//  fbGearInMultiMaster.GearRatio3 := _stAxis.stConfig.astMultiMasterAxisLatched[3].fRatio; (Not in use, commented due to slits code)
+//  fbGearInMultiMaster.GearRatio4 := _stAxis.stConfig.astMultiMasterAxisLatched[4].fRatio; (Not in use, commented due to slits code)
     fbGearInMultiMaster.Enable := TRUE;
 END_IF
 
 fbGearInMultiMaster(Slave := _stAxis.Axis,
     Master1 := GVL.astAxes[_stAxis.stConfig.astMultiMasterAxisLatched[1].nIndex].Axis,
-    Master2 := GVL.astAxes[_stAxis.stConfig.astMultiMasterAxisLatched[2].nIndex].Axis,
-    Master3 := GVL.astAxes[_stAxis.stConfig.astMultiMasterAxisLatched[3].nIndex].Axis,
-    Master4 := GVL.astAxes[_stAxis.stConfig.astMultiMasterAxisLatched[4].nIndex].Axis);
+    Master2 := GVL.astAxes[_stAxis.stConfig.astMultiMasterAxisLatched[2].nIndex].Axis);
+//    Master3 := GVL.astAxes[_stAxis.stConfig.astMultiMasterAxisLatched[3].nIndex].Axis,
+//    Master4 := GVL.astAxes[_stAxis.stConfig.astMultiMasterAxisLatched[4].nIndex].Axis);
 fbGearInMultiMaster.Enable:= FALSE;
 
 IF fbGearInMultiMaster.InGear THEN
diff --git a/POUs/Motion/FB_SlitPair.TcPOU b/POUs/Motion/FB_SlitPair.TcPOU
index adde0016..78c2b4a4 100644
--- a/POUs/Motion/FB_SlitPair.TcPOU
+++ b/POUs/Motion/FB_SlitPair.TcPOU
@@ -1,17 +1,16 @@
 <?xml version="1.0" encoding="utf-8"?>
 <TcPlcObject Version="1.1.0.1">
   <POU Name="FB_SlitPair" Id="{e905bacc-19e9-06c3-04ae-f4fd4f34065e}" SpecialFunc="None">
-    <Declaration><![CDATA[
-FUNCTION_BLOCK FB_SlitPair
+    <Declaration><![CDATA[FUNCTION_BLOCK FB_SlitPair
 VAR_INPUT
     iBladeNegative: UINT; //Axis ID for negatively positioned blade
     iBladePositive: UINT; //Axis ID for positively positioned blade
     iGapSize: UINT; //Axis ID for the size of gap between slit blades
     iGapCentre: UINT; //Axis ID for the centre position of the gap formed by slit blades
-    bEnable: BOOL; //Enable/disable the slit set
-    bReset: BOOL; //Reset the slit set
     fEncoderScaling: LREAL := 10000; //default scaling denominator of 10000
-    bAutoHome: BOOL := FALSE;
+    bAutoHome: BOOL := TRUE; //Blades homing is automatically done if they are not homed
+    bAnticollisionEnable: BOOL := FALSE; //Blades anticollision option, only for when blades are moved independently
+
 END_VAR
 VAR_OUTPUT
     bEnabled: BOOL := FALSE; //Enabled status of function
@@ -22,8 +21,11 @@ VAR
     eSlitPairState: E_SlitPairStates := E_SlitPairStates.INIT; //statemachine index
 
 //Internal statuses for logic
+    bEnable: BOOL; //Enable/disable the slit set
+    bReset: BOOL; //Reset the slit set
     bResetting: BOOL := FALSE; //TRUE if axis going through a reset
     bAxesEnabled: BOOL := FALSE; //TRUE if all axes enabled
+    bSlitsHomed: BOOL := FALSE; //TRUE if all axes Homed after reboot
     bBladesHomed: BOOL:= FALSE; //TRUE if blade axes are calibrated
     bGapHomed: BOOL:= FALSE; //TRUE if virtual axes are calibrated
     bBladesCoupled: BOOL:= FALSE; //TRUE if both blade axes are coupled
@@ -35,16 +37,25 @@ VAR
     fGapCentrePosition: LREAL;
     iGapCentrePosition AT %Q*: UDINT := 0;
     resetCounterTimeout: UINT :=0;
-    mcHomeGapSize: MC_Home;
-    mcHomeGapCentre: MC_Home;
+    eSoftLimitsUpdate: E_SlitSoftLimits := E_SlitSoftLimits.START; //Sequence steps for update of soft limits
+    fbNoMovingRising: R_TRIG;
+    fbInOpRising: R_TRIG;
+    bUpdateSoftLimits: BOOL := FALSE;
+    bHomingRequested: BOOL := FALSE;
+    fbEnableRising: R_TRIG;
+    fbStopRising: R_TRIG;
+    fbDisableRising: R_TRIG;
+    fbDisabledRising: R_TRIG;
+    fbHomingRising: R_TRIG;
 END_VAR
 ]]></Declaration>
     <Implementation>
-      <ST><![CDATA[
-(* NOTES
+      <ST><![CDATA[(* NOTES
 For the virtual axis setup, the encoders need their type changed from "simulation encoder" to "Encoder (Universal)".
 In addition the scale factor needs to be changed to a numerator of 1 and denominator of fEncoderScaling which is 10,000 by default)
 Care needs to be taken with scaling and setup of both real and virtual axes to ensure velocities are not too fast and axes have time to settle before they submit a "complete move"
+Link the virtual encoder inputs to the Gap and Center position calculations iGapSizePosition iGapCentrePosition
+Encoder needs to be set as ABSOLUTE
 *)
 
 //Configure homing routine of virtual axes
@@ -56,15 +67,15 @@ actErrorHandling(); //Error handling subroutine
 actGapLimits(); //Set virtual axis limits to TRUE
 actVirtualAxisPositions(); //Virtual axis encoder position subroutine
 actRunMethods(); //Update statuses
-
-//Mc_Home FBs configured to clear homing signal
-mcHomeGapSize(Axis := astAxes[iGapSize].Axis, HomingMode:=MC_HomingMode.MC_ResetCalibration);
-mcHomeGapCentre(Axis:=astAxes[iGapCentre].Axis, HomingMode:=MC_HomingMode.MC_ResetCalibration);
-mcHomeGapSize.Execute := FALSE;
-mcHomeGapCentre.Execute := FALSE;
+actEnableAxes(); //Enable the axes
+checkSlitsHomed(); //Status of the axes homing
+IF bAnticollisionEnable THEN //Blades anticollision enabled
+    actInterlocking();
+END_IF
 
 CASE eSlitPairState OF
     E_SlitPairStates.INIT:
+        bEnabled := FALSE;
         IF bAxesEnabled AND bEnable THEN
             eSlitPairState := E_SlitPairStates.INIT_CLEAR_GEARING;
         END_IF
@@ -79,24 +90,33 @@ CASE eSlitPairState OF
         END_IF
 
     E_SlitPairStates.CHECK_HOME_STATUS: //If blades are already homed, skip to virtual homing, if blades not homed and autohome enabled then home blades, otherwise wait for blades to be homed
-        IF bBladesHomed THEN
+        IF NOT bSlitsHomed THEN
+            //Perform homing
+            eSlitPairState := E_SlitPairStates.HOME_BLADES;
+        ELSIF bBladesHomed THEN
             eSlitPairState := E_SlitPairStates.HOME_GAP; //Skip to functioning
         ELSIF bAutoHome THEN
             eSlitPairState := E_SlitPairStates.HOME_BLADES; //If autohome enabled, home the blades
         END_IF
 
     E_SlitPairStates.HOME_BLADES: //Initiate homing of blade axes. Homing routine must be pre-configured by user
-        GVL.astAxes[iBladeNegative].stControl.eCommand := E_MotionFunctions.eHome;
-        GVL.astAxes[iBladePositive].stControl.eCommand := E_MotionFunctions.eHome;
-        GVL.astAxes[iBladeNegative].stControl.bExecute := TRUE;
-        GVL.astAxes[iBladePositive].stControl.bExecute := TRUE;
-        bHoming := TRUE;
-        eSlitPairState := E_SlitPairStates.CHECK_BLADE_HOME_COMPLETE;
+        IF (GVL.astAxes[iGapSize].stControl.eCommand = E_MotionFunctions.eHome AND GVL.astAxes[iGapSize].stControl.bExecute) OR
+            (GVL.astAxes[iGapCentre].stControl.eCommand = E_MotionFunctions.eHome AND GVL.astAxes[iGapCentre].stControl.bExecute) OR bHomingRequested THEN
+
+            GVL.astAxes[iBladeNegative].stControl.eCommand := E_MotionFunctions.eHome;
+            GVL.astAxes[iBladePositive].stControl.eCommand := E_MotionFunctions.eHome;
+            GVL.astAxes[iBladeNegative].stControl.bExecute := TRUE;
+            GVL.astAxes[iBladePositive].stControl.bExecute := TRUE;
+            bHoming := TRUE;
+            eSlitPairState := E_SlitPairStates.CHECK_BLADE_HOME_COMPLETE;
+        END_IF
 
     E_SlitPairStates.CHECK_BLADE_HOME_COMPLETE: //Wait for completion of blade homing routines
-        IF bBladesHomed THEN
+        IF bBladesHomed AND NOT GVL.astAxes[iBladeNegative].stStatus.bBusy AND NOT GVL.astAxes[iBladePositive].stStatus.bBusy THEN
             eSlitPairState := E_SlitPairStates.HOME_GAP;
             bHoming := FALSE;
+        ELSIF (GVL.astAxes[iBladeNegative].stStatus.nErrorID > 0) OR (GVL.astAxes[iBladePositive].stStatus.nErrorID >0) THEN
+            eSlitPairState := E_SlitPairStates.ERROR;
         END_IF
 
     E_SlitPairStates.HOME_GAP: //"Home" the virtual axes
@@ -111,8 +131,9 @@ CASE eSlitPairState OF
         eSlitPairState := E_SlitPairStates.CHECK_GAP_HOME_COMPLETE;
 
     E_SlitPairStates.CHECK_GAP_HOME_COMPLETE: //Wait for virtual homing completion
-        IF bGapHomed THEN
+        IF bGapHomed AND NOT GVL.astAxes[iGapSize].stStatus.bBusy AND NOT GVL.astAxes[iGapCentre].stStatus.bBusy THEN
             eSlitPairState := E_SlitPairStates.GEARIN_SLITS;
+            bHomingRequested := FALSE;
         END_IF
 
     E_SlitPairStates.GEARIN_SLITS: //Setup gearing
@@ -122,34 +143,41 @@ CASE eSlitPairState OF
     E_SlitPairStates.CHECK_GEARIN_SLITS_COMPLETE: //Wait for gearing complete
         IF bBladesCoupled THEN
             eSlitPairState := E_SlitPairStates.SLITS_OPERATIONAL;
+        ELSIF NOT GVL.astAxes[iGapSize].stStatus.bEnabled AND NOT GVL.astAxes[iGapCentre].stStatus.bEnabled THEN
+            eSlitPairState := E_SlitPairStates.ERROR_GEAROUT;
         END_IF
 
     E_SlitPairStates.SLITS_OPERATIONAL: //SLITS OPERATIONAL - Monitor for any gear outs and re-gear when no busy blades
         bEnabled := TRUE;
-        IF NOT bBladesCoupled AND NOT GVL.astAxes[iBladeNegative].stStatus.bBusy AND NOT GVL.astAxes[iBladePositive].stStatus.bBusy THEN
+        checkSoftLimits(); //Soft limits are updated when axes are stopped
+        IF (NOT bBladesCoupled OR NOT bEnable) AND NOT GVL.astAxes[iBladeNegative].stStatus.bBusy AND NOT GVL.astAxes[iBladePositive].stStatus.bBusy THEN
+            eSlitPairState := E_SlitPairStates.GEAROUT_BLADES;
+        END_IF
+        IF (GVL.astAxes[iGapSize].stControl.eCommand = E_MotionFunctions.eHome AND GVL.astAxes[iGapSize].stControl.bExecute) OR
+            (GVL.astAxes[iGapCentre].stControl.eCommand = E_MotionFunctions.eHome AND GVL.astAxes[iGapCentre].stControl.bExecute) THEN
             eSlitPairState := E_SlitPairStates.GEAROUT_BLADES;
+            bHomingRequested := TRUE;
         END_IF
 
-    E_SlitPairStates.GEAROUT_BLADES: //Clear amy residual gearing
+    E_SlitPairStates.GEAROUT_BLADES: //Clear any residual gearing
         actClearSlitGearing();
         eSlitPairState := E_SlitPairStates.CHECK_GEAROUT_COMPLETE;
 
     E_SlitPairStates.CHECK_GEAROUT_COMPLETE: //Check gearing cleared
         IF bBladesUncoupled THEN
-            eSlitPairState := E_SlitPairStates.CLEAR_GAP_CALIBRATION; //Back to homing, this ensures the setpoint position of the axis is updated.
-        END_IF
-
-    E_SlitPairStates.CLEAR_GAP_CALIBRATION:
-        mcHomeGapSize.Execute := TRUE;
-        mcHomeGapCentre.Execute := TRUE;
-        IF mcHomeGapSize.Done AND mcHomeGapCentre.Done THEN
-            eSlitPairState := E_SlitPairStates.HOME_GAP; //Back to homing, this ensures the setpoint position of the axis is updated.
+            IF bHomingRequested THEN
+                eSlitPairState := E_SlitPairStates.HOME_BLADES;
+                bEnabled := FALSE;
+            ELSE
+                eSlitPairState := E_SlitPairStates.INIT;
+            END_IF
         END_IF
 
     E_SlitPairStates.ERROR: //ERROR STATE
         resetCounterTimeout := 0;
         bError := TRUE;
         bEnabled := FALSE;
+        actStopAxes();
         IF bReset THEN
             bResetting := TRUE;
             eSlitPairState := E_SlitPairStates.ERROR_GEAROUT;
@@ -186,6 +214,7 @@ CASE eSlitPairState OF
             bResetting := FALSE;
         END_IF
 END_CASE
+
 bReset := FALSE;
 ]]></ST>
     </Implementation>
@@ -196,6 +225,40 @@ GVL.astAxes[iBladeNegative].stControl.eCommand := E_MotionFunctions.eGearOut;
 GVL.astAxes[iBladePositive].stControl.eCommand := E_MotionFunctions.eGearOut;
 GVL.astAxes[iBladeNegative].stControl.bExecute := TRUE;
 GVL.astAxes[iBladePositive].stControl.bExecute := TRUE;
+]]></ST>
+      </Implementation>
+    </Action>
+    <Action Name="actEnableAxes" Id="{1879c38a-aecf-0e8c-2a58-959e274ebc63}">
+      <Implementation>
+        <ST><![CDATA[//Enable all axes when one of the virtual axes is enabled
+fbEnableRising(CLK := GVL.astAxes[iGapSize].stControl.bEnable OR GVL.astAxes[iGapCentre].stControl.bEnable);
+
+IF fbEnableRising.Q THEN
+    GVL.astAxes[iBladePositive].stControl.bEnable := TRUE;
+    GVL.astAxes[iBladeNegative].stControl.bEnable := TRUE;
+    GVL.astAxes[iGapSize].stControl.bEnable := TRUE;
+    GVL.astAxes[iGapCentre].stControl.bEnable := TRUE;
+    bEnable := TRUE;
+END_IF
+
+
+//Disable blade axes when both the virtuals are disabled
+fbDisableRising(CLK := NOT GVL.astAxes[iGapSize].stControl.bEnable OR NOT GVL.astAxes[iGapCentre].stControl.bEnable);
+
+IF fbDisableRising.Q THEN
+    GVL.astAxes[iBladePositive].stControl.bEnable := FALSE;
+    GVL.astAxes[iBladeNegative].stControl.bEnable := FALSE;
+    GVL.astAxes[iGapSize].stControl.bEnable := FALSE;
+    GVL.astAxes[iGapCentre].stControl.bEnable := FALSE;
+END_IF
+
+//Set Enable flag when all axes are enabled
+bEnable := GVL.astAxes[iBladePositive].stStatus.bEnabled AND GVL.astAxes[iBladeNegative].stStatus.bEnabled
+    AND GVL.astAxes[iGapSize].stStatus.bEnabled AND GVL.astAxes[iGapCentre].stStatus.bEnabled;
+
+//Set flag when all axes are disable
+fbDisabledRising(CLK := NOT GVL.astAxes[iBladePositive].stStatus.bEnabled AND GVL.astAxes[iBladeNegative].stStatus.bEnabled
+    AND GVL.astAxes[iGapSize].stStatus.bEnabled AND GVL.astAxes[iGapCentre].stStatus.bEnabled);
 ]]></ST>
       </Implementation>
     </Action>
@@ -206,15 +269,25 @@ IF bResetting THEN //ignore setting in error state if FB going through a reset
     RETURN;
 END_IF
 
+//RESET - Use the reset from the virtual axes in order to reset the slits
+bReset := GVL.astAxes[iGapCentre].stControl.bReset OR GVL.astAxes[iGapSize].stControl.bReset;
+
 IF NOT bError AND bAxisErrorsPresent THEN
     eSlitPairState := E_SlitPairStates.ERROR;
 END_IF
-IF eSlitPairState <> E_SlitPairStates.INIT AND NOT bAxesEnabled THEN
-    eSlitPairState := E_SlitPairStates.ERROR;
-END_IF
-IF (eSlitPairState <> E_SlitPairStates.INIT AND NOT bFunctionInErrorState) AND NOT bEnable THEN
-    eSlitPairState := E_SlitPairStates.ERROR;
+
+//Report error to virtual axes
+IF eSlitPairState = E_SlitPairStates.ERROR THEN
+    GVL.astAxes[iGapCentre].stStatus.bError := TRUE;
+    GVL.astAxes[iGapSize].stStatus.bError := TRUE;
 END_IF
+
+//IF eSlitPairState <> E_SlitPairStates.INIT AND NOT bAxesEnabled THEN
+//    eSlitPairState := E_SlitPairStates.ERROR;
+//END_IF
+//IF (eSlitPairState <> E_SlitPairStates.INIT AND NOT bFunctionInErrorState) AND NOT bEnable THEN
+//    eSlitPairState := E_SlitPairStates.ERROR;
+//END_IF
 IF bEnabled AND NOT bBladesHomed THEN
     eSlitPairState := E_SlitPairStates.ERROR;
 END_IF
@@ -223,11 +296,21 @@ END_IF
     </Action>
     <Action Name="actGapLimits" Id="{def3d604-4e23-0583-39ed-61c5876cfc85}">
       <Implementation>
-        <ST><![CDATA[//Set Virtual axis inputs to TRUE to enable movement
-GVL.astAxes[iGapSize].stInputs.bLimitBwd := TRUE;
-GVL.astAxes[iGapSize].stInputs.bLimitFwd := TRUE;
-GVL.astAxes[iGapCentre].stInputs.bLimitBwd := TRUE;
-GVL.astAxes[iGapCentre].stInputs.bLimitFwd := TRUE;
+        <ST><![CDATA[//Set Virtual axes inputs to TRUE to enable movement
+GVL.astAxes[iGapSize].stInputs.bLimitBwd := GVL.astAxes[iBladeNegative].stInputs.bLimitFwd OR GVL.astAxes[iBladePositive].stInputs.bLimitBwd;
+GVL.astAxes[iGapSize].stInputs.bLimitFwd := GVL.astAxes[iBladeNegative].stInputs.bLimitBwd OR GVL.astAxes[iBladePositive].stInputs.bLimitFwd;
+GVL.astAxes[iGapCentre].stInputs.bLimitBwd := GVL.astAxes[iBladeNegative].stInputs.bLimitFwd OR GVL.astAxes[iBladePositive].stInputs.bLimitBwd;
+GVL.astAxes[iGapCentre].stInputs.bLimitFwd := GVL.astAxes[iBladeNegative].stInputs.bLimitBwd OR GVL.astAxes[iBladePositive].stInputs.bLimitFwd;
+]]></ST>
+      </Implementation>
+    </Action>
+    <Action Name="actInterlocking" Id="{64063538-5b16-04d7-1d46-c493a7cc7a35}">
+      <Implementation>
+        <ST><![CDATA[//Blades interlocking for anticollision purposes
+GVL.astAxes[iBladeNegative].stControl.bInterlockFwd := GVL.astAxes[iBladeNegative].stStatus.fActPosition >= GVL.astAxes[iBladePositive].stStatus.fActPosition
+    OR GVL.astAxes[iBladeNegative].stControl.fPosition >= GVL.astAxes[iBladePositive].stStatus.fActPosition;
+GVL.astAxes[iBladePositive].stControl.bInterlockBwd := GVL.astAxes[iBladePositive].stStatus.fActPosition <= GVL.astAxes[iBladeNegative].stStatus.fActPosition
+    OR GVL.astAxes[iBladePositive].stControl.fPosition <= GVL.astAxes[iBladeNegative].stStatus.fActPosition;
 ]]></ST>
       </Implementation>
     </Action>
@@ -257,12 +340,77 @@ GVL.astAxes[iBladePositive].stConfig.astMultiMasterAxis[2].nIndex := iGapCentre;
 GVL.astAxes[iBladePositive].stConfig.astMultiMasterAxis[2].fRatio := 1;
 GVL.astAxes[iBladeNegative].stControl.bExecute := TRUE;
 GVL.astAxes[iBladePositive].stControl.bExecute := TRUE;
+]]></ST>
+      </Implementation>
+    </Action>
+    <Action Name="actStopAxes" Id="{83b4f1fe-f696-016b-03db-3bcff9089f7d}">
+      <Implementation>
+        <ST><![CDATA[//Stop all axes when in error (Abort movements)
+GVL.astAxes[iBladePositive].stControl.bStop := TRUE;
+GVL.astAxes[iBladeNegative].stControl.bStop := TRUE;
+GVL.astAxes[iGapSize].stControl.bStop := TRUE;
+GVL.astAxes[iGapCentre].stControl.bStop := TRUE;
+]]></ST>
+      </Implementation>
+    </Action>
+    <Action Name="actUpdateSoftLimits" Id="{35e948c5-fa3a-0897-288a-c8995c0599d0}">
+      <Implementation>
+        <ST><![CDATA[//The soft limits of the virtual axes are updated everytime a movement has been accomplished.
+//This is to avoid undesired errors if the user sets a target position which is not allowed
+
+CASE eSoftLimitsUpdate OF
+
+E_SlitSoftLimits.START: //START SEQ
+    eSoftLimitsUpdate := E_SlitSoftLimits.WRITE_GAP_CENTRE_FWD;
+
+E_SlitSoftLimits.WRITE_GAP_CENTRE_FWD: //WRITE GAP CENTRE FWD SOFT LIMIT
+    IF NOT GVL.astAxes[iGapCentre].stStatus.bBusy AND NOT GVL.astAxes[iGapSize].stStatus.bBusy THEN
+        eSoftLimitsUpdate := E_SlitSoftLimits.WRITE_GAP_CENTRE_BWD;
+        GVL.astAxes[iGapCentre].stControl.bExecute := TRUE;
+        GVL.astAxes[iGapCentre].stControl.eCommand := E_MotionFunctions.eWriteParameter;
+        GVL.astAxes[iGapCentre].stConfig.eAxisParameters := E_AxisParameters.SWLimitForward;
+        GVL.astAxes[iGapCentre].stConfig.fWriteAxisParameter := (GVL.astAxes[iBladePositive].stConfig.fMaxSoftPosLimit
+            - GVL.astAxes[iGapSize].stStatus.fActPosition/2);
+    END_IF
+
+E_SlitSoftLimits.WRITE_GAP_CENTRE_BWD: //WRITE GAP CENTRE BWD SOFT LIMIT
+    IF GVL.astAxes[iGapCentre].stStatus.bDone AND NOT GVL.astAxes[iGapCentre].stControl.bExecute THEN
+        eSoftLimitsUpdate := E_SlitSoftLimits.WRITE_GAP_SIZE_FWD;
+        GVL.astAxes[iGapCentre].stControl.bExecute := TRUE;
+        GVL.astAxes[iGapCentre].stControl.eCommand := E_MotionFunctions.eWriteParameter;
+        GVL.astAxes[iGapCentre].stConfig.eAxisParameters := E_AxisParameters.SWLimitBackward;
+        GVL.astAxes[iGapCentre].stConfig.fWriteAxisParameter := (GVL.astAxes[iBladeNegative].stConfig.fMinSoftPosLimit
+            + GVL.astAxes[iGapSize].stStatus.fActPosition/2);
+    END_IF
+
+E_SlitSoftLimits.WRITE_GAP_SIZE_FWD: //WRITE GAP SIZE FWD SOFT LIMIT
+    IF GVL.astAxes[iGapCentre].stStatus.bDone AND NOT GVL.astAxes[iGapCentre].stControl.bExecute THEN
+        eSoftLimitsUpdate := E_SlitSoftLimits.FINISH;
+        GVL.astAxes[iGapSize].stControl.bExecute := TRUE;
+        GVL.astAxes[iGapSize].stControl.eCommand := E_MotionFunctions.eWriteParameter;
+        GVL.astAxes[iGapSize].stConfig.eAxisParameters := E_AxisParameters.SWLimitForward;
+        IF GVL.astAxes[iGapCentre].stStatus.fActPosition >= 0.0 THEN
+            GVL.astAxes[iGapSize].stConfig.fWriteAxisParameter := 2 * ABS(GVL.astAxes[iBladePositive].stConfig.fMaxSoftPosLimit
+                - GVL.astAxes[iGapCentre].stStatus.fActPosition);
+        ELSE
+            GVL.astAxes[iGapSize].stConfig.fWriteAxisParameter := 2 * ABS(GVL.astAxes[iBladeNegative].stConfig.fMinSoftPosLimit
+                - GVL.astAxes[iGapCentre].stStatus.fActPosition);
+        END_IF
+    END_IF
+
+E_SlitSoftLimits.FINISH: //FINISHED WHEN LAST WRITING OF PARAMETERS IS DONE
+    IF GVL.astAxes[iGapSize].stStatus.bDone AND NOT GVL.astAxes[iGapSize].stControl.bExecute THEN
+        eSoftLimitsUpdate := E_SlitSoftLimits.START;
+        bUpdateSoftLimits := FALSE;
+    END_IF
+
+END_CASE
 ]]></ST>
       </Implementation>
     </Action>
     <Action Name="actVirtualAxisPositions" Id="{7f6698b5-ef89-01d2-091a-1167e8f62f6e}">
       <Implementation>
-        <ST><![CDATA[(*Calculate virtual axis positions and convert to UDINT.
+        <ST><![CDATA[(*Calculate virtual axes positions and convert to UDINT.
 Conversion to UDINT is prohibited if it would exceed UDINT max value of 4,294,967,295.
 If this is not done, it can cause overflow when connected to the encoder input and hard-crash the PLC which will only recover with a power cycle.
 To preserve decimal position data of the LREAL (i.e. anything <1mm) it is necessary to scale the value before converting to UDINT.
@@ -406,6 +554,44 @@ END_IF
 IF eSlitPairState = E_SlitPairStates.ERROR_RESET_CHECK THEN
     bOutput := TRUE;
 END_IF
+]]></ST>
+      </Implementation>
+    </Method>
+    <Method Name="checkSlitsHomed" Id="{79b1cda9-2126-0e81-3df4-233ef39e0b6e}">
+      <Declaration><![CDATA[(*Method to check if blade axes are homed/have the calibration flag.
+Only returns TRUE if BOTH blades are homed*)
+METHOD checkSlitsHomed: BOOL
+VAR_OUTPUT
+    bOutput: BOOL := TRUE;
+END_VAR
+]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[fbHomingRising(CLK:=
+    GVL.astAxes[iBladeNegative].stStatus.bHomed
+    AND GVL.astAxes[iBladePositive].stStatus.bHomed
+    AND GVL.astAxes[iGapSize].stStatus.bHomed
+    AND GVL.astAxes[iGapCentre].stStatus.bHomed);
+IF fbHomingRising.Q THEN
+    bOutput := FALSE;
+    bSlitsHomed := TRUE;
+END_IF
+]]></ST>
+      </Implementation>
+    </Method>
+    <Method Name="checkSoftLimits" Id="{7b17dbf3-e1d6-0a6e-1aa4-6cded47f1f4b}">
+      <Declaration><![CDATA[METHOD checkSoftLimits : BOOL
+]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[fbNoMovingRising(CLK := NOT GVL.astAxes[iGapCentre].stStatus.bMoving AND NOT GVL.astAxes[iGapSize].stStatus.bMoving);
+fbInOpRising(CLK := eSlitPairState = E_SlitPairStates.SLITS_OPERATIONAL);
+
+IF fbNoMovingRising.Q OR fbInOpRising.Q THEN
+    bUpdateSoftLimits := TRUE;
+END_IF
+
+IF bUpdateSoftLimits THEN
+    actUpdateSoftLimits();
+END_IF
 ]]></ST>
       </Implementation>
     </Method>