diff --git a/src/FieldElementSubsystems.Test/Connection/Baseline4R1/PointToInterlockingConnectionTest.cs b/src/FieldElementSubsystems.Test/Connection/Baseline4R1/PointToInterlockingConnectionTest.cs
index f4a0c1f..b159c89 100644
--- a/src/FieldElementSubsystems.Test/Connection/Baseline4R1/PointToInterlockingConnectionTest.cs
+++ b/src/FieldElementSubsystems.Test/Connection/Baseline4R1/PointToInterlockingConnectionTest.cs
@@ -32,7 +32,7 @@ private static Mock<IConnection> CreateDefaultMockConnection()
         {"PointSettings:AllPointMachinesCrucial", "false" },
         {"PointSettings:ObserveAbilityToMove", "true" },
         {"PointSettings:PDIVersion", "1" },
-        {"PointSettings:PDIChecksum", "0x0000" }
+        {"PointSettings:PDIChecksum", "0x00" }
     };
 
     private readonly IConfiguration _configuration = new ConfigurationBuilder()
@@ -44,13 +44,13 @@ public void Test_Connect()
     {
         // Arrange
         var mockConnection = new Mock<IConnection>();
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
 
         // Assert
-        Assert.Equal(connection.CurrentConnection, mockConnection.Object);
+        Assert.Equal(((PointToInterlockingConnection)connection).CurrentConnection, mockConnection.Object);
     }
 
     [Fact]
@@ -62,16 +62,16 @@ public async Task Test_Initialization()
         mockConnection.Setup(x => x.SendAsync(Capture.In(receivedMessages)))
             .Returns(Task.FromResult(0));
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, false, CancellationToken.None);
 
         // Assert
         mockConnection.Verify(v => v.ReceiveAsync(It.IsAny<CancellationToken>()), Times.Exactly(2));
         mockConnection.Verify(v => v.SendAsync(It.IsAny<byte[]>()), Times.Exactly(5));
-        Assert.Equal(new PointPdiVersionCheckMessage("99W1________________", "INTERLOCKING________", PointPdiVersionCheckMessageResultPdiVersionCheck.PDIVersionsFromReceiverAndSenderDoMatch,  1, 2, new byte[] { 0x00, 0x00 }).ToByteArray(), receivedMessages[0]);
+        Assert.Equal(new PointPdiVersionCheckMessage("99W1________________", "INTERLOCKING________", PointPdiVersionCheckMessageResultPdiVersionCheck.PDIVersionsFromReceiverAndSenderDoMatch,  1,1, new byte[] { 0x00 }).ToByteArray(), receivedMessages[0]);
         Assert.Equal(new PointStartInitialisationMessage("99W1________________", "INTERLOCKING________").ToByteArray(), receivedMessages[1]);
         Assert.Equal(new PointPointPositionMessage("99W1________________", "INTERLOCKING________", PointPointPositionMessageReportedPointPosition.PointIsInALeftHandPositionDefinedEndPosition, PointPointPositionMessageReportedDegradedPointPosition.PointIsNotInADegradedPosition).ToByteArray(), receivedMessages[2]);
         Assert.Equal(new PointAbilityToMovePointMessage("99W1________________", "INTERLOCKING________", PointAbilityToMovePointMessageReportedAbilityToMovePointStatus.PointIsAbleToMove).ToByteArray(), receivedMessages[3]);
@@ -89,16 +89,16 @@ public async Task Test_Initialization_Timeout(){
         mockConnection.Setup(x => x.SendAsync(Capture.In(receivedMessages)))
             .Returns(Task.FromResult(0));
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, true, CancellationToken.None);
 
         // Assert
+        // Should not send/receive any more messages after version check as timeout is simulated
         mockConnection.Verify(v => v.ReceiveAsync(It.IsAny<CancellationToken>()), Times.Exactly(1));
         mockConnection.Verify(v => v.SendAsync(It.IsAny<byte[]>()), Times.Exactly(1));
-        Assert.Equal(new PointPdiVersionCheckMessage("99W1________________", "INTERLOCKING________", PointPdiVersionCheckMessageResultPdiVersionCheck.PDIVersionsFromReceiverAndSenderDoMatch,  1, 2, new byte[] { 0x00, 0x00 }).ToByteArray(), receivedMessages[0]);
     }
 
     /// <summary>
@@ -115,10 +115,10 @@ public async Task Test_Initialization_Version_Mismatch(){
         mockConnection.Setup(x => x.SendAsync(Capture.In(receivedMessages)))
             .Returns(Task.FromResult(0));
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, true, CancellationToken.None);
 
         // Assert
@@ -136,10 +136,10 @@ public async Task Test_Send_Position()
         mockConnection.Setup(x => x.SendAsync(Capture.In(args)))
             .Returns(Task.FromResult(0));
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, false, CancellationToken.None);
         foreach (var position in new List<GenericPointPosition>() { GenericPointPosition.Left, GenericPointPosition.Right, GenericPointPosition.UnintendedPosition, GenericPointPosition.NoEndPosition })
         {
@@ -165,10 +165,10 @@ public async Task Test_Receive_Position()
             .ReturnsAsync(new PointMovePointCommand("99W1", "100", PointMovePointCommandCommandedPointPosition.SubsystemElectronicInterlockingRequestsALeftHandPointMoving).ToByteArray())
             .ReturnsAsync(new PointMovePointCommand("99W1", "100", PointMovePointCommandCommandedPointPosition.SubsystemElectronicInterlockingRequestsARightHandPointMoving).ToByteArray());
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, false, CancellationToken.None);
         var position1 = await connection.ReceiveMovePointCommand(CancellationToken.None);
         var position2 = await connection.ReceiveMovePointCommand(CancellationToken.None);
@@ -188,10 +188,10 @@ public async Task Test_TimeoutMessage()
         mockConnection.Setup(x => x.SendAsync(Capture.In(args)))
             .Returns(Task.FromResult(0));
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, false, CancellationToken.None);
         await connection.SendTimeoutMessage();
 
diff --git a/src/FieldElementSubsystems.Test/Connection/Baseline4R2/PointToInterlockingConnectionTest.cs b/src/FieldElementSubsystems.Test/Connection/Baseline4R2/PointToInterlockingConnectionTest.cs
index 3e78eb1..855091e 100644
--- a/src/FieldElementSubsystems.Test/Connection/Baseline4R2/PointToInterlockingConnectionTest.cs
+++ b/src/FieldElementSubsystems.Test/Connection/Baseline4R2/PointToInterlockingConnectionTest.cs
@@ -23,7 +23,7 @@ public class PointToInterlockingConnectionTest
         {"PointSettings:AllPointMachinesCrucial", "false" },
         {"PointSettings:ObserveAbilityToMove", "true" },
         {"PointSettings:PDIVersion", "1" },
-        {"PointSettings:PDIChecksum", "0x0000" }
+        {"PointSettings:PDIChecksum", "0x00" }
     };
 
     private readonly IConfiguration _configuration = new ConfigurationBuilder()
@@ -35,13 +35,13 @@ public void Test_Connect()
     {
         // Arrange
         var mockConnection = new Mock<IConnection>();
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
 
         // Assert
-        Assert.Equal(connection.CurrentConnection, mockConnection.Object);
+        Assert.Equal(((PointToInterlockingConnection)connection).CurrentConnection, mockConnection.Object);
     }
 
     [Fact]
@@ -56,16 +56,15 @@ public async Task Test_Initialization()
         mockConnection.Setup(x => x.SendAsync(Capture.In(receivedMessages)))
             .Returns(Task.FromResult(0));
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, false, CancellationToken.None);
 
-        // Assert
         mockConnection.Verify(v => v.ReceiveAsync(It.IsAny<CancellationToken>()), Times.Exactly(2));
         mockConnection.Verify(v => v.SendAsync(It.IsAny<byte[]>()), Times.Exactly(5));
-        Assert.Equal(new PointPdiVersionCheckMessage("99W1________________", "INTERLOCKING________", PointPdiVersionCheckMessageResultPdiVersionCheck.PDIVersionsFromReceiverAndSenderDoMatch, 1, 2, new byte[] { 0x00, 0x00 }).ToByteArray(), receivedMessages[0]);
+        Assert.Equal(new PointPdiVersionCheckMessage("99W1________________", "INTERLOCKING________", PointPdiVersionCheckMessageResultPdiVersionCheck.PDIVersionsFromReceiverAndSenderDoMatch, 1,1, new byte[] { 0x00 }).ToByteArray(), receivedMessages[0]);
         Assert.Equal(new PointStartInitialisationMessage("99W1________________", "INTERLOCKING________").ToByteArray(), receivedMessages[1]);
         Assert.Equal(new PointPointPositionMessage("99W1________________", "INTERLOCKING________", PointPointPositionMessageReportedPointPosition.PointIsInALeftHandPositionDefinedEndPosition, PointPointPositionMessageReportedDegradedPointPosition.PointIsNotInADegradedPosition).ToByteArray(), receivedMessages[2]);
         Assert.Equal(new PointAbilityToMovePointMessage("99W1________________", "INTERLOCKING________", PointAbilityToMovePointMessageReportedAbilityToMovePointStatus.PointIsAbleToMove).ToByteArray(), receivedMessages[3]);
@@ -83,16 +82,16 @@ public async Task Test_Initialization_Timeout(){
         mockConnection.Setup(x => x.SendAsync(Capture.In(receivedMessages)))
             .Returns(Task.FromResult(0));
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, true, CancellationToken.None);
 
         // Assert
+        // Should not send/receive any more messages after version check as timeout is simulated
         mockConnection.Verify(v => v.ReceiveAsync(It.IsAny<CancellationToken>()), Times.Exactly(1));
         mockConnection.Verify(v => v.SendAsync(It.IsAny<byte[]>()), Times.Exactly(1));
-        Assert.Equal(new PointPdiVersionCheckMessage("99W1________________", "INTERLOCKING________", PointPdiVersionCheckMessageResultPdiVersionCheck.PDIVersionsFromReceiverAndSenderDoMatch,  1, 2, new byte[] { 0x00, 0x00 }).ToByteArray(), receivedMessages[0]);
     }
 
     /// <summary>
@@ -109,10 +108,10 @@ public async Task Test_Initialization_Version_Mismatch(){
         mockConnection.Setup(x => x.SendAsync(Capture.In(receivedMessages)))
             .Returns(Task.FromResult(0));
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, true, CancellationToken.None);
 
         // Assert
@@ -133,10 +132,10 @@ public async Task Test_Send_Position()
         mockConnection.Setup(x => x.SendAsync(Capture.In(args)))
             .Returns(Task.FromResult(0));
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, false, CancellationToken.None);
         await connection.SendPointPosition(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Right, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove));
         await connection.SendPointPosition(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove));
@@ -162,10 +161,10 @@ public async Task Test_Receive_Position()
             .ReturnsAsync(new PointMovePointCommand("99W1", "100", PointMovePointCommandCommandedPointPosition.SubsystemElectronicInterlockingRequestsALeftHandPointMoving).ToByteArray())
             .ReturnsAsync(new PointMovePointCommand("99W1", "100", PointMovePointCommandCommandedPointPosition.SubsystemElectronicInterlockingRequestsARightHandPointMoving).ToByteArray());
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, false, CancellationToken.None);
         var position1 = await connection.ReceiveMovePointCommand(CancellationToken.None);
         var position2 = await connection.ReceiveMovePointCommand(CancellationToken.None);
@@ -188,10 +187,10 @@ public async Task Test_TimeoutMessage()
         mockConnection.Setup(x => x.SendAsync(Capture.In(args)))
             .Returns(Task.FromResult(0));
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), _configuration, CancellationToken.None);
 
         // Act
-        connection.Connect(mockConnection.Object);
+        var connection = builder.Connect(mockConnection.Object);
         await connection.InitializeConnection(new GenericPointState(LastCommandedPointPosition: null, PointPosition: GenericPointPosition.Left, DegradedPointPosition: GenericDegradedPointPosition.NotDegraded, AbilityToMove: GenericAbilityToMove.AbleToMove), true, false, CancellationToken.None);
         await connection.SendTimeoutMessage();
 
diff --git a/src/FieldElementSubsystems.Test/Point/Baseline4R2/CommandingAndReversingTests.cs b/src/FieldElementSubsystems.Test/Point/Baseline4R2/CommandingAndReversingTests.cs
index 3da96c9..403748f 100644
--- a/src/FieldElementSubsystems.Test/Point/Baseline4R2/CommandingAndReversingTests.cs
+++ b/src/FieldElementSubsystems.Test/Point/Baseline4R2/CommandingAndReversingTests.cs
@@ -30,7 +30,7 @@ private static (EulynxLive.Point.Point point, Task pointTask, List<byte[]> recei
             {"PointSettings:InitialDegradedPointPosition", initialPointState.DegradedPointPosition.ToString() },
             {"PointSettings:InitialAbilityToMove", initialPointState.AbilityToMove.ToString() },
             {"PointSettings:PDIVersion", "1" },
-            {"PointSettings:PDIChecksum", "0x0000" }
+            {"PointSettings:PDIChecksum", "0x00" }
         };
 
         var configuration = new ConfigurationBuilder()
@@ -72,11 +72,11 @@ private static (EulynxLive.Point.Point point, Task pointTask, List<byte[]> recei
             .Setup(x => x.Connect(It.IsAny<PointConfiguration>(), It.IsAny<CancellationToken>()))
             .Returns(mockConnection.Object);
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), configuration, CancellationToken.None);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), configuration, CancellationToken.None);
 
         var mockHubContext = new Mock<IHubContext<StatusHub>>();
         mockHubContext.Setup(x => x.Clients.All.SendCoreAsync(It.IsAny<string>(), It.IsAny<object[]>(), It.IsAny<CancellationToken>())).Returns(Task.CompletedTask);
-        var point = new EulynxLive.Point.Point(Mock.Of<ILogger<EulynxLive.Point.Point>>(), configuration, connection, connectionProvider.Object, mockHubContext.Object);
+        var point = new EulynxLive.Point.Point(Mock.Of<ILogger<EulynxLive.Point.Point>>(), configuration, builder, connectionProvider.Object, mockHubContext.Object);
         if (simulateTimeouts) {
             point.EnableTimeoutLeft(true);
             point.EnableTimeoutRight(true);
diff --git a/src/FieldElementSubsystems.Test/Point/Baseline4R2/ReportStatusTests.cs b/src/FieldElementSubsystems.Test/Point/Baseline4R2/ReportStatusTests.cs
index 35677b1..c34e9b5 100644
--- a/src/FieldElementSubsystems.Test/Point/Baseline4R2/ReportStatusTests.cs
+++ b/src/FieldElementSubsystems.Test/Point/Baseline4R2/ReportStatusTests.cs
@@ -30,7 +30,7 @@ private static (EulynxLive.Point.Point point, Task, List<byte[]> receivedBytes)
             {"PointSettings:InitialDegradedPointPosition", initialPointState.DegradedPointPosition.ToString() },
             {"PointSettings:InitialAbilityToMove", initialPointState.AbilityToMove.ToString() },
             {"PointSettings:PDIVersion", "1" },
-            {"PointSettings:PDIChecksum", "0x0000" }
+            {"PointSettings:PDIChecksum", "0x00" }
         };
 
         var configuration = new ConfigurationBuilder()
@@ -58,12 +58,11 @@ private static (EulynxLive.Point.Point point, Task, List<byte[]> receivedBytes)
             .Setup(x => x.Connect(It.IsAny<PointConfiguration>(), It.IsAny<CancellationToken>()))
             .Returns(mockConnection.Object);
 
-        var connection = new PointToInterlockingConnection(Mock.Of<ILogger<PointToInterlockingConnection>>(), configuration, CancellationToken.None);
-        connection.Connect(mockConnection.Object);
+        var builder = new PointToInterlockingConnectionBuilder(Mock.Of<ILogger<PointToInterlockingConnection>>(), configuration, CancellationToken.None);
 
         var mockHubContext = new Mock<IHubContext<StatusHub>>();
         mockHubContext.Setup(x => x.Clients.All.SendCoreAsync(It.IsAny<string>(), It.IsAny<object[]>(), It.IsAny<CancellationToken>())).Returns(Task.CompletedTask);
-        var point = new EulynxLive.Point.Point(Mock.Of<ILogger<EulynxLive.Point.Point>>(), configuration, connection, connectionProvider.Object, mockHubContext.Object);
+        var point = new EulynxLive.Point.Point(Mock.Of<ILogger<EulynxLive.Point.Point>>(), configuration, builder, connectionProvider.Object, mockHubContext.Object);
 
         async Task SimulatePoint()
         {
diff --git a/src/FieldElementSubsystems.Test/Point/PointTest.cs b/src/FieldElementSubsystems.Test/Point/PointTest.cs
index 14fbaf0..4afab1a 100644
--- a/src/FieldElementSubsystems.Test/Point/PointTest.cs
+++ b/src/FieldElementSubsystems.Test/Point/PointTest.cs
@@ -29,7 +29,7 @@ private static (EulynxLive.Point.Point, Func<Task> simulatePoint, Mock<IPointToI
             {"PointSettings:InitialDegradedPointPosition", initialPointState.DegradedPointPosition.ToString() },
             {"PointSettings:InitialAbilityToMove", initialPointState.AbilityToMove.ToString() },
             {"PointSettings:PDIVersion", "1" },
-            {"PointSettings:PDIChecksum", "0x0000" }
+            {"PointSettings:PDIChecksum", "0x00" }
         };
 
         var configuration = new ConfigurationBuilder()
@@ -38,11 +38,11 @@ private static (EulynxLive.Point.Point, Func<Task> simulatePoint, Mock<IPointToI
 
         var cancel = new CancellationTokenSource();
         var config = configuration.GetSection("PointSettings").Get<PointConfiguration>()!;
-        var mockConnection = CreateDefaultMockConnection(config);
+        var (mockConnection, mockConnectionBuilder) = CreateDefaultMockConnection(config);
 
         var mockHubContext = new Mock<IHubContext<StatusHub>>();
         mockHubContext.Setup(x => x.Clients.All.SendCoreAsync(It.IsAny<string>(), It.IsAny<object[]>(), It.IsAny<CancellationToken>())).Returns(Task.CompletedTask);
-        var point = new EulynxLive.Point.Point(Mock.Of<ILogger<EulynxLive.Point.Point>>(), configuration, mockConnection.Object, Mock.Of<IConnectionProvider>(), mockHubContext.Object);
+        var point = new EulynxLive.Point.Point(Mock.Of<ILogger<EulynxLive.Point.Point>>(), configuration, mockConnectionBuilder.Object, Mock.Of<IConnectionProvider>(), mockHubContext.Object);
 
         async Task SimulatePoint()
         {
@@ -56,9 +56,10 @@ async Task SimulatePoint()
         return (point, SimulatePoint, mockConnection, cancel);
     }
 
-    private static Mock<IPointToInterlockingConnection> CreateDefaultMockConnection(PointConfiguration configuration)
+    private static (Mock<IPointToInterlockingConnection>, Mock<IPointToInterlockingConnectionBuilder>) CreateDefaultMockConnection(PointConfiguration configuration)
     {
         var mockConnection = new Mock<IPointToInterlockingConnection>();
+        var mockConnectionBuilder = new Mock<IPointToInterlockingConnectionBuilder>();
         mockConnection.Setup(x => x.Configuration).Returns(() => configuration);
         mockConnection
             .Setup(m => m.SendPointPosition(
@@ -66,13 +67,13 @@ private static Mock<IPointToInterlockingConnection> CreateDefaultMockConnection(
             .Returns(Task.FromResult(0));
         mockConnection
             .Setup(m => m.InitializeConnection(
-                It.IsAny<GenericPointState>(), It.IsAny<bool>(), It.IsAny<bool>(),It.IsAny<CancellationToken>()))
+                It.IsAny<GenericPointState>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<CancellationToken>()))
             .Returns(Task.FromResult(true));
-        mockConnection
+        mockConnectionBuilder
             .Setup(m => m.Connect(
                 It.IsAny<IConnection>()))
             .Returns(mockConnection.Object);
-        return mockConnection;
+        return (mockConnection, mockConnectionBuilder);
     }
 
     private readonly ILogger<EulynxLive.Point.Point> _logger = Mock.Of<ILogger<EulynxLive.Point.Point>>();
@@ -116,7 +117,7 @@ public async Task Test_Reset()
         await pointTask();
 
         // Assert
-        connection.Verify(v => v.InitializeConnection(It.IsAny<GenericPointState>(), It.IsAny<bool>(), It.IsAny<bool>(),It.IsAny<CancellationToken>()), Times.Exactly(2));
+        connection.Verify(v => v.InitializeConnection(It.IsAny<GenericPointState>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<CancellationToken>()), Times.Exactly(2));
     }
 
     [Fact]
diff --git a/src/FieldElementSubsystems.Test/UtilsTest.cs b/src/FieldElementSubsystems.Test/UtilsTest.cs
index 7aa4405..4393437 100644
--- a/src/FieldElementSubsystems.Test/UtilsTest.cs
+++ b/src/FieldElementSubsystems.Test/UtilsTest.cs
@@ -7,13 +7,21 @@ public static void TestHexToByteArray()
     {
         string hexString = "0A0B0C0D0E0F";
         byte[] byteArray = hexString.HexToByteArray();
-        Assert.Equal(byteArray, new byte[] { 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F });
+        Assert.Equal(byteArray, [0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F]);
+    }
+
+    [Fact]
+    public static void TestHexToByteArray0x()
+    {
+        string hexString = "0x0A0B0C0D0E0F";
+        byte[] byteArray = hexString.HexToByteArray();
+        Assert.Equal(byteArray, [0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F]);
     }
 
     [Fact]
     public static void TestHexToByteArrayUneven()
     {
         string hexString = "F";
-        Assert.Throws<ArgumentException>(() => hexString.HexToByteArray());
+        Assert.Throws<ArgumentException>(hexString.HexToByteArray);
     }
 }
diff --git a/src/FieldElementSubsystems/Connections/EulynxBaseline4R1/PointToInterlockingConnection.cs b/src/FieldElementSubsystems/Connections/EulynxBaseline4R1/PointToInterlockingConnection.cs
index 7051e59..8382c6b 100644
--- a/src/FieldElementSubsystems/Connections/EulynxBaseline4R1/PointToInterlockingConnection.cs
+++ b/src/FieldElementSubsystems/Connections/EulynxBaseline4R1/PointToInterlockingConnection.cs
@@ -9,6 +9,29 @@
 
 namespace EulynxLive.FieldElementSubsystems.Connections.EulynxBaseline4R1;
 
+
+public class PointToInterlockingConnectionBuilder : IPointToInterlockingConnectionBuilder
+{
+    private readonly ILogger<PointToInterlockingConnection> _logger;
+    private readonly CancellationToken _stoppingToken;
+    private readonly IConfiguration _configuration;
+  
+    public PointToInterlockingConnectionBuilder(
+        ILogger<PointToInterlockingConnection> logger,
+        IConfiguration configuration,
+        CancellationToken stoppingToken)
+    {
+        _logger = logger;
+        _stoppingToken = stoppingToken;
+        _configuration = configuration;
+    }
+
+    public IPointToInterlockingConnection Connect(IConnection conn)
+    {
+        return new PointToInterlockingConnection(_logger, _configuration, _stoppingToken, conn);
+    }
+}
+
 public class PointToInterlockingConnection : IPointToInterlockingConnection
 {
     private readonly ILogger _logger;
@@ -27,28 +50,21 @@ public class PointToInterlockingConnection : IPointToInterlockingConnection
     public PointToInterlockingConnection(
         ILogger<PointToInterlockingConnection> logger,
         IConfiguration configuration,
-        CancellationToken stoppingToken)
+        CancellationToken stoppingToken, IConnection connection)
     {
         _stoppingToken = stoppingToken;
         _logger = logger;
-        CurrentConnection = null;
+        CurrentConnection = connection;
 
         var config = configuration.GetSection("PointSettings").Get<PointConfiguration>() ?? throw new Exception("No configuration provided");
         _localId = config.LocalId;
         _remoteId = config.RemoteId;
         _pdiVersion = config.PDIVersion;
         _checksum = config.PDIChecksum.HexToByteArray();
-        if (_checksum.Length != 2) throw new InvalidOperationException($"Invalid checksum length. Expected 2 bytes was ${_checksum.Length}.");
         Configuration = config;
         _overrideMessages = Channel.CreateUnbounded<byte[]>();
     }
 
-    public IPointToInterlockingConnection Connect(IConnection connection)
-    {
-        CurrentConnection = connection;
-        return this;
-    }
-
     public async Task<bool> InitializeConnection(GenericPointState state, bool observeAbilityToMove, bool simulateTimeout, CancellationToken cancellationToken)
     {
         var versionCheckReceived = await ReceiveMessage<PointPdiVersionCheckCommand>(cancellationToken);
@@ -63,6 +79,8 @@ public async Task<bool> InitializeConnection(GenericPointState state, bool obser
         {
             // Eu.Gen-SCI.445
             // Eu.SCI-XX.PDI.91 - Eu.SCI-XX.PDI.94
+            // If byte 43 is set to 0x01, byte 45 shall be set to zero.
+            // The bytes 46 ... 46+n-1 shall not be allocated, if PDI-Version from Receiver and Sender does not match
             _logger.LogError("Version check failed.");
             var versionCheckFailedResponse = new PointPdiVersionCheckMessage(_localId, _remoteId, PointPdiVersionCheckMessageResultPdiVersionCheck.PDIVersionsFromReceiverAndSenderDoNotMatch, _pdiVersion, 0, []);
             await SendMessage(versionCheckFailedResponse);
@@ -76,7 +94,7 @@ public async Task<bool> InitializeConnection(GenericPointState state, bool obser
         if (simulateTimeout)
         {
             // Never send the missing initialization messages
-            return false;
+            return true;
         }
         
         if (await ReceiveMessage<PointInitialisationRequestCommand>(cancellationToken) == null)
diff --git a/src/FieldElementSubsystems/Connections/EulynxBaseline4R2/PointToInterlockingConnection.cs b/src/FieldElementSubsystems/Connections/EulynxBaseline4R2/PointToInterlockingConnection.cs
index e4c8579..920454d 100644
--- a/src/FieldElementSubsystems/Connections/EulynxBaseline4R2/PointToInterlockingConnection.cs
+++ b/src/FieldElementSubsystems/Connections/EulynxBaseline4R2/PointToInterlockingConnection.cs
@@ -10,6 +10,28 @@
 
 namespace EulynxLive.FieldElementSubsystems.Connections.EulynxBaseline4R2;
 
+public class PointToInterlockingConnectionBuilder : IPointToInterlockingConnectionBuilder
+{
+    private readonly ILogger<PointToInterlockingConnection> _logger;
+    private readonly CancellationToken _stoppingToken;
+    private readonly IConfiguration _configuration;
+  
+    public PointToInterlockingConnectionBuilder(
+        ILogger<PointToInterlockingConnection> logger,
+        IConfiguration configuration,
+        CancellationToken stoppingToken)
+    {
+        _logger = logger;
+        _stoppingToken = stoppingToken;
+        _configuration = configuration;
+    }
+
+    public IPointToInterlockingConnection Connect(IConnection conn)
+    {
+        return new PointToInterlockingConnection(_logger, _configuration, _stoppingToken, conn);
+    }
+}
+
 public class PointToInterlockingConnection : IPointToInterlockingConnection
 {
     private readonly ILogger _logger;
@@ -28,29 +50,21 @@ public class PointToInterlockingConnection : IPointToInterlockingConnection
     public PointToInterlockingConnection(
         ILogger<PointToInterlockingConnection> logger,
         IConfiguration configuration,
-        CancellationToken stoppingToken)
+        CancellationToken stoppingToken, IConnection connection)
     {
         _stoppingToken = stoppingToken;
         _logger = logger;
-        CurrentConnection = null;
+        CurrentConnection = connection;
 
         var config = configuration.GetSection("PointSettings").Get<PointConfiguration>() ?? throw new Exception("No configuration provided");
         _localId = config.LocalId;
         _remoteId = config.RemoteId;
         _pdiVersion = config.PDIVersion;
         _checksum = config.PDIChecksum.HexToByteArray();
-        if (_checksum.Length != 2) throw new InvalidOperationException($"Invalid checksum length. Expected 2 bytes was ${_checksum.Length}.");
-       
         Configuration = config;
         _overrideMessages = Channel.CreateUnbounded<byte[]>();
     }
 
-    public IPointToInterlockingConnection Connect(IConnection connection)
-    {
-        CurrentConnection = connection;
-        return this;
-    }
-
     public async Task<bool> InitializeConnection(GenericPointState state, bool observeAbilityToMove, bool simulateTimeout, CancellationToken cancellationToken)
     {
         var versionCheckReceived = await ReceiveMessage<PointPdiVersionCheckCommand>(cancellationToken);
@@ -65,6 +79,8 @@ public async Task<bool> InitializeConnection(GenericPointState state, bool obser
         {
             // Eu.Gen-SCI.445
             // Eu.SCI-XX.PDI.91 - Eu.SCI-XX.PDI.94
+            // If byte 43 is set to 0x01, byte 45 shall be set to zero.
+            // The bytes 46 ... 46+n-1 shall not be allocated, if PDI-Version from Receiver and Sender does not match
             _logger.LogError("Version check failed.");
             var versionCheckFailedResponse = new PointPdiVersionCheckMessage(_localId, _remoteId, PointPdiVersionCheckMessageResultPdiVersionCheck.PDIVersionsFromReceiverAndSenderDoNotMatch, _pdiVersion, 0, []);
             await SendMessage(versionCheckFailedResponse);
@@ -78,15 +94,13 @@ public async Task<bool> InitializeConnection(GenericPointState state, bool obser
         if (simulateTimeout)
         {
             // Never send the missing initialization messages
-            return false;
+            return true;
         }
-
         if (await ReceiveMessage<PointInitialisationRequestCommand>(cancellationToken) == null)
         {
             _logger.LogError("Unexpected message.");
             return false;
         }
-
         var startInitialization = new PointStartInitialisationMessage(_localId, _remoteId);
         await SendMessage(startInitialization);
 
diff --git a/src/FieldElementSubsystems/Interfaces/IPointToInterlockingConnection.cs b/src/FieldElementSubsystems/Interfaces/IPointToInterlockingConnection.cs
index 135186d..8a5f6d3 100644
--- a/src/FieldElementSubsystems/Interfaces/IPointToInterlockingConnection.cs
+++ b/src/FieldElementSubsystems/Interfaces/IPointToInterlockingConnection.cs
@@ -2,11 +2,13 @@
 
 namespace EulynxLive.FieldElementSubsystems.Interfaces;
 
+public interface IPointToInterlockingConnectionBuilder {
+    IPointToInterlockingConnection Connect(IConnection conn);
+}
+
 public interface IPointToInterlockingConnection : IDisposable {
     PointConfiguration Configuration { get; }
 
-    IPointToInterlockingConnection Connect(IConnection connection);
-
     Task SendPointPosition(GenericPointState state);
     Task SendSciMessage(byte[] message);
     Task OverrideNextSciMessage(byte[] message);
diff --git a/src/Point/Connections/ConnectionFactory.cs b/src/Point/Connections/ConnectionFactory.cs
index b787939..befd994 100644
--- a/src/Point/Connections/ConnectionFactory.cs
+++ b/src/Point/Connections/ConnectionFactory.cs
@@ -15,16 +15,16 @@ public ConnectionFactory(ILogger<ConnectionFactory> logger, IConfiguration confi
         _configuration = configuration;
     }
 
-    public IPointToInterlockingConnection CreateConnection(IServiceProvider x) {
+    public IPointToInterlockingConnectionBuilder CreateConnection(IServiceProvider x) {
         var connectionProtocol = _configuration.GetSection("PointSettings").Get<PointConfiguration>()?.ConnectionProtocol;
         switch (connectionProtocol){
             case ConnectionProtocol.EulynxBaseline4R1:
-                return ActivatorUtilities.CreateInstance<EulynxBaseline4R1.PointToInterlockingConnection>(x, _configuration, CancellationToken.None);
+                return ActivatorUtilities.CreateInstance<EulynxBaseline4R1.PointToInterlockingConnectionBuilder>(x, _configuration, CancellationToken.None);
             case ConnectionProtocol.EulynxBaseline4R2:
-                return ActivatorUtilities.CreateInstance<EulynxBaseline4R2.PointToInterlockingConnection>(x, _configuration, CancellationToken.None);
+                return ActivatorUtilities.CreateInstance<EulynxBaseline4R2.PointToInterlockingConnectionBuilder>(x, _configuration, CancellationToken.None);
             case null:
                 _logger.LogWarning($"No connection protocol specified. Using EulynxBaseline4R2.");
-                return ActivatorUtilities.CreateInstance<EulynxBaseline4R2.PointToInterlockingConnection>(x, _configuration, CancellationToken.None);
+                return ActivatorUtilities.CreateInstance<EulynxBaseline4R2.PointToInterlockingConnectionBuilder>(x, _configuration, CancellationToken.None);
             default:
                 throw new NotImplementedException($"Unknown connection protocol {connectionProtocol}.");
         }
diff --git a/src/Point/IPoint.cs b/src/Point/IPoint.cs
index 6b36b09..c5cbed2 100644
--- a/src/Point/IPoint.cs
+++ b/src/Point/IPoint.cs
@@ -6,7 +6,7 @@ namespace EulynxLive.Point
 {
     public interface IPoint {
         ConnectionProtocol? ConnectionProtocol { get; }
-        IPointToInterlockingConnection Connection { get; }
+        IPointToInterlockingConnection? Connection { get; }
         GenericPointState PointState { get; }
 
         void EnableTimeoutLeft(bool enableMovementFailed);
diff --git a/src/Point/Point.cs b/src/Point/Point.cs
index ce5d6ac..89923e8 100644
--- a/src/Point/Point.cs
+++ b/src/Point/Point.cs
@@ -19,7 +19,9 @@ namespace EulynxLive.Point
 {
     public partial class Point : BackgroundService, IPoint
     {
-        public IPointToInterlockingConnection Connection { get; set; }
+        public IPointToInterlockingConnectionBuilder? ConnectionBuilder { get; }
+
+        public IPointToInterlockingConnection? Connection { get; private set; }
 
         public bool AllPointMachinesCrucial { get; }
         public bool ObserveAbilityToMove { get; }
@@ -33,13 +35,14 @@ public partial class Point : BackgroundService, IPoint
         private bool _initialized;
 
         private readonly ILogger<Point> _logger;
+        private readonly IPointToInterlockingConnectionBuilder _connectionBuilder;
         private readonly IConnectionProvider _connectionProvider;
         private readonly PointConfiguration _config;
         private CancellationTokenSource _resetTokenSource = CancellationTokenSource.CreateLinkedTokenSource(CancellationToken.None);
 
-        public Point(ILogger<Point> logger, IConfiguration configuration, IPointToInterlockingConnection connection, IConnectionProvider connectionProvider, IHubContext<StatusHub> statusHub)
+        public Point(ILogger<Point> logger, IConfiguration configuration, IPointToInterlockingConnectionBuilder connectionBuilder, IConnectionProvider connectionProvider, IHubContext<StatusHub> statusHub)
         {
-            Connection = connection;
+            _connectionBuilder = connectionBuilder;
             _connectionProvider = connectionProvider;
             _logger = logger;
 
@@ -95,6 +98,7 @@ public Point(ILogger<Point> logger, IConfiguration configuration, IPointToInterl
 
         public async Task SendSciMessage(SciMessage message)
         {
+            if (Connection == null) throw new InvalidOperationException("Connection is null. Did you call Connect()?");
             _logger.LogInformation("Sending SCI message: {}", message.Message);
             await Connection.SendSciMessage(message.Message.ToByteArray());
         }
@@ -102,12 +106,13 @@ public async Task SendSciMessage(SciMessage message)
         /// <summary>
         /// Sets the sets the initialization timeout flag for the next initialization.
         /// </summary>
-        public void EnableInitializationTimeout(bool enableInitialisationTimeout)
+        public void EnableInitializationTimeout(bool enableInitializationTimeout)
         {
-            _logger.LogInformation("Reset and Timeout on next initialisation handshake enabled.");
+            if (Connection == null) throw new InvalidOperationException("Connection is null. Did you call Connect()?");
+            _logger.LogInformation("Reset and Timeout on next initialization handshake enabled.");
             _simulatedPointState = _simulatedPointState with
             {
-                SimulateInitializationTimeout = enableInitialisationTimeout
+                SimulateInitializationTimeout = enableInitializationTimeout
             };
         }
 
@@ -158,6 +163,7 @@ public async Task SetAbilityToMove(AbilityToMoveMessage abilityToMoveMessage)
 
             if (_initialized)
             {
+                if (Connection == null) throw new InvalidOperationException("Connection is null. Did you call Connect()?");
                 await Connection.SendAbilityToMove(PointState);
             }
         }
@@ -184,6 +190,7 @@ public async Task PutIntoUnintendedPosition(DegradedPositionMessage simulatedPos
 
             if (_initialized)
             {
+                if (Connection == null) throw new InvalidOperationException("Connection is null. Did you call Connect()?");
                 await Connection.SendPointPosition(PointState);
             }
         }
@@ -260,8 +267,8 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
             while (!stoppingToken.IsCancellationRequested)
             {
                 _logger.LogTrace("Connecting...");
-                var conn = _connectionProvider.Connect(Connection.Configuration, stoppingToken);
-                using (Connection = Connection.Connect(conn))
+                var conn = _connectionProvider.Connect(_config, stoppingToken);
+                using (Connection = _connectionBuilder.Connect(conn))
                 {
                     _resetTokenSource = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken);
 
@@ -303,6 +310,7 @@ await AllMovePointCommands(_resetTokenSource.Token)
 
         private async IAsyncEnumerable<GenericPointPosition> AllMovePointCommands([EnumeratorCancellation] CancellationToken stoppingToken)
         {
+            if (Connection == null) throw new InvalidOperationException("Connection is null. Did you call Connect()?");
             while (!stoppingToken.IsCancellationRequested)
             {
                 var commandedPointPosition = await Connection.ReceiveMovePointCommand(stoppingToken);
@@ -332,6 +340,7 @@ private async Task HandleCommandedPointPosition(GenericPointPosition commandedPo
                 return;
             }
 
+            if (Connection == null) throw new InvalidOperationException("Connection is null. Did you call Connect()?");
             _logger.LogDebug("Moving to {}.", commandedPointPosition);
 
             if (PointState.PointPosition != GenericPointPosition.NoEndPosition)
diff --git a/src/Point/Program.cs b/src/Point/Program.cs
index 270219c..52a7a84 100644
--- a/src/Point/Program.cs
+++ b/src/Point/Program.cs
@@ -34,6 +34,8 @@ public static IHostBuilder CreateHostBuilder(string[] args) =>
                         { "--initial-point-position", "PointSettings:InitialPointPosition" },
                         { "--initial-degraded-point-position", "PointSettings:InitialDegradedPointPosition" },
                         { "--initial-ability-to-move", "PointSettings:InitialAbilityToMove" },
+                        { "--pdi-version", "PointSettings:PDIVersion"},
+                        { "--pdi-checksum", "PointSettings:PDIChecksum"}
                     };
                     webBuilder
                         .ConfigureAppConfiguration((hostingContext, config) =>
diff --git a/src/Point/Services/PointService.cs b/src/Point/Services/PointService.cs
index 0ab5d2a..44ee377 100644
--- a/src/Point/Services/PointService.cs
+++ b/src/Point/Services/PointService.cs
@@ -18,7 +18,6 @@ public PointService(IPoint point)
 
         public override Task<Empty> Reset(Empty request, ServerCallContext context)
         {
-            // TODO: We have to disconnect here!
             _point.Reset();
             return Task.FromResult(new Empty());
         }
@@ -49,11 +48,12 @@ public override async Task<Empty> SendSciMessage(SciMessage request, ServerCallC
 
         public override async Task<Empty> OverrideSciMessage(SciMessage request, ServerCallContext context)
         {
+            if (_point.Connection == null) throw new InvalidOperationException("Connection is null. Did you call Connect()?");
             await _point.Connection.OverrideNextSciMessage(request.Message.ToByteArray());
             return new Empty();
         }
 
-        public override Task<Empty> ScheduleInitializationTimeout(EnableInitializationFailedMessage request, ServerCallContext context)
+        public override Task<Empty> ScheduleInitializationFailed(EnableInitializationFailedMessage request, ServerCallContext context)
         {
             _point.EnableInitializationTimeout(request.EnableInitializationFailed);
             return Task.FromResult(new Empty());
diff --git a/src/Point/appsettings.json b/src/Point/appsettings.json
index 9148003..5cf049d 100644
--- a/src/Point/appsettings.json
+++ b/src/Point/appsettings.json
@@ -17,7 +17,7 @@
     "InitialAbilityToMove": "AbleToMove",
     "ConnectionProtocol": "EulynxBaseline4R1",
     "PDIVersion": "1",
-    "PDIChecksum": "0x0000"
+    "PDIChecksum": "0x00"
   },
   "Kestrel": {
     "EndPoints": {
diff --git a/src/Point/rasta-point-web/src/App.tsx b/src/Point/rasta-point-web/src/App.tsx
index dab3b63..47ddb5f 100644
--- a/src/Point/rasta-point-web/src/App.tsx
+++ b/src/Point/rasta-point-web/src/App.tsx
@@ -34,6 +34,8 @@ export type SimulatorConfiguration = {
   initialDegradedPointPosition: string,
   initialAbilityToMove: string,
   connectionProtocol: 'EulynxBaseline4R1' | 'EulynxBaseline4R2',
+  pdiVersion: string,
+  pdiChecksum: string,
 };
 
 function App() {
diff --git a/src/Point/rasta-point-web/src/Point.tsx b/src/Point/rasta-point-web/src/Point.tsx
index 1fd1f0c..1413088 100644
--- a/src/Point/rasta-point-web/src/Point.tsx
+++ b/src/Point/rasta-point-web/src/Point.tsx
@@ -55,7 +55,7 @@ function ButtonGroup({ items }: { items: { active: boolean, label: string, disab
   return (
     <div className="flex flex-wrap items-center">
       <div className="m-1.5">
-        <div className="flex flex-wrap -space-x-px">
+        <div className="flex sm:flex-row -space-x-px">
           {items.map((item, index) => (
             <button key={item.label} type="button" onClick={() => item.disabled || item.onClick?.(index)} className={(item.active ? activeClassName : defaultClassName) + (item.disabled ? disabledClassName : enabledClassName)}>{item.label}</button>
           ))}
@@ -136,6 +136,20 @@ function Point({
               {' '}
               s
             </PropertyLabel>
+            <div className="flex flex-row">
+              <SemiBoldPropertyLabel>
+                PDI Version
+              </SemiBoldPropertyLabel>
+              <PropertyLabel>
+                {simulatorConfiguration?.pdiVersion}
+              </PropertyLabel>
+              <SemiBoldPropertyLabel>
+                PDI Checksum
+              </SemiBoldPropertyLabel>
+              <PropertyLabel>
+                {simulatorConfiguration?.pdiChecksum}
+              </PropertyLabel>
+            </div>
             <Toggle label="Observe Ability to Move" active={simulatorConfiguration?.observeAbilityToMove || false} disabled />
             <Toggle label="All Point Machines are Crucial" active={simulatorConfiguration?.allPointMachinesCrucial || false} disabled />
           </div>
@@ -360,7 +374,7 @@ function Point({
                   label="Enable Initialization Timeout"
                   active={simulatedPointState?.simulateInitializationTimeout || false}
                   onChange={
-                    (enable) => sendCommand((client) => client.scheduleInitializationTimeout(new EnableInitializationFailedMessage().setEnableinitializationfailed(enable), null))
+                    (enable) => sendCommand((client) => client.scheduleInitializationFailed(new EnableInitializationFailedMessage().setEnableinitializationfailed(enable), null))
                   }
                 />
               </div>
diff --git a/src/Point/rasta-point-web/src/proto/PointServiceClientPb.ts b/src/Point/rasta-point-web/src/proto/PointServiceClientPb.ts
index 5124741..15d8fac 100644
--- a/src/Point/rasta-point-web/src/proto/PointServiceClientPb.ts
+++ b/src/Point/rasta-point-web/src/proto/PointServiceClientPb.ts
@@ -513,8 +513,8 @@ export class PointClient {
     this.methodDescriptorScheduleTimeoutLeft);
   }
 
-  methodDescriptorScheduleInitializationTimeout = new grpcWeb.MethodDescriptor(
-    '/point.Point/ScheduleInitializationTimeout',
+  methodDescriptorScheduleInitializationFailed = new grpcWeb.MethodDescriptor(
+    '/point.Point/ScheduleInitializationFailed',
     grpcWeb.MethodType.UNARY,
     point_pb.EnableInitializationFailedMessage,
     google_protobuf_empty_pb.Empty,
@@ -524,17 +524,17 @@ export class PointClient {
     google_protobuf_empty_pb.Empty.deserializeBinary
   );
 
-  scheduleInitializationTimeout(
+  scheduleInitializationFailed(
     request: point_pb.EnableInitializationFailedMessage,
     metadata: grpcWeb.Metadata | null): Promise<google_protobuf_empty_pb.Empty>;
 
-  scheduleInitializationTimeout(
+  scheduleInitializationFailed(
     request: point_pb.EnableInitializationFailedMessage,
     metadata: grpcWeb.Metadata | null,
     callback: (err: grpcWeb.RpcError,
                response: google_protobuf_empty_pb.Empty) => void): grpcWeb.ClientReadableStream<google_protobuf_empty_pb.Empty>;
 
-  scheduleInitializationTimeout(
+  scheduleInitializationFailed(
     request: point_pb.EnableInitializationFailedMessage,
     metadata: grpcWeb.Metadata | null,
     callback?: (err: grpcWeb.RpcError,
@@ -542,18 +542,18 @@ export class PointClient {
     if (callback !== undefined) {
       return this.client_.rpcCall(
         this.hostname_ +
-          '/point.Point/ScheduleInitializationTimeout',
+          '/point.Point/ScheduleInitializationFailed',
         request,
         metadata || {},
-        this.methodDescriptorScheduleInitializationTimeout,
+        this.methodDescriptorScheduleInitializationFailed,
         callback);
     }
     return this.client_.unaryCall(
     this.hostname_ +
-      '/point.Point/ScheduleInitializationTimeout',
+      '/point.Point/ScheduleInitializationFailed',
     request,
     metadata || {},
-    this.methodDescriptorScheduleInitializationTimeout);
+    this.methodDescriptorScheduleInitializationFailed);
   }
 
   methodDescriptorReset = new grpcWeb.MethodDescriptor(
diff --git a/src/ProtobufInterfaces/proto/point.proto b/src/ProtobufInterfaces/proto/point.proto
index 979a6b7..b8f662b 100644
--- a/src/ProtobufInterfaces/proto/point.proto
+++ b/src/ProtobufInterfaces/proto/point.proto
@@ -41,7 +41,7 @@ service Point {
     rpc ScheduleTimeoutRight (EnableMovementFailedMessage) returns (google.protobuf.Empty) {}
     rpc ScheduleTimeoutLeft (EnableMovementFailedMessage) returns (google.protobuf.Empty) {}
 
-    rpc ScheduleInitializationTimeout (EnableInitializationFailedMessage) returns (google.protobuf.Empty) {}
+    rpc ScheduleInitializationFailed (EnableInitializationFailedMessage) returns (google.protobuf.Empty) {}
     rpc Reset (google.protobuf.Empty) returns (google.protobuf.Empty) {}
 }