diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs
index 5f6cbb2..95a751f 100644
--- a/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs
+++ b/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs
@@ -27,7 +27,7 @@ namespace Modbus.Net.Modbus
     /// <summary>
     ///     Modbus基础Api入口
     /// </summary>
-    public class ModbusUtility : BaseUtility, IIUtilityMethodTime
+    public class ModbusUtility : BaseUtility, IUtilityMethodTime
     {
         /// <summary>
         ///     Modbus协议类型
diff --git a/Tests/Modbus.Net.Tests/ModbusMultiStationTest.cs b/Tests/Modbus.Net.Tests/ModbusMultiStationTest.cs
index f86fac3..37bfa33 100644
--- a/Tests/Modbus.Net.Tests/ModbusMultiStationTest.cs
+++ b/Tests/Modbus.Net.Tests/ModbusMultiStationTest.cs
@@ -22,7 +22,7 @@ namespace Modbus.Net.Tests
         }
 
         [TestMethod]
-        public async Task Get()
+        public async Task MultiStation()
         {
             var addresses = new List<AddressUnit>
             {
@@ -85,56 +85,72 @@ namespace Modbus.Net.Tests
             _modbusRtuMachine1.GetAddresses = addresses.ToList();
             _modbusRtuMachine2.GetAddresses = addresses.ToList();
 
-            await _modbusRtuMachine1.SetDatasAsync(MachineSetDataType.CommunicationTag, new Dictionary<string, double>()
+            Random r = new Random();
+            var dic1 = new Dictionary<string, double>()
             {
                 {
-                    "A1", 70
+                    "A1", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A2", 71
+                    "A2", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A3", 72
+                    "A3", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A4", 73
+                    "A4", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A5", 717870
+                    "A5", r.Next()
                 },
                 {
-                    "A6", 717871
+                    "A6", r.Next()
                 },
-            });
-            await _modbusRtuMachine2.SetDatasAsync(MachineSetDataType.CommunicationTag, new Dictionary<string, double>()
+            };
+
+            var dic2 = new Dictionary<string, double>()
             {
                 {
-                    "A1", 74
+                    "A1", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A2", 75
+                    "A2", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A3", 76
+                    "A3", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A4", 77
+                    "A4", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A5", 717873
+                    "A5", r.Next()
                 },
                 {
-                    "A6", 717874
+                    "A6", r.Next()
                 },
-            });
+            };
+
+            await _modbusRtuMachine1.SetDatasAsync(MachineSetDataType.CommunicationTag, dic1);
+            await _modbusRtuMachine2.SetDatasAsync(MachineSetDataType.CommunicationTag, dic2);
+
             var ans = await _modbusRtuMachine1.GetDatasAsync(MachineGetDataType.CommunicationTag);
             var ans2 = await _modbusRtuMachine2.GetDatasAsync(MachineGetDataType.CommunicationTag);
 
             _modbusRtuMachine1.Disconnect();
             _modbusRtuMachine2.Disconnect();
 
-            Assert.AreEqual(ans["A1"].PlcValue, 70);
-            Assert.AreEqual(ans2["A1"].PlcValue, 74);
+            Assert.AreEqual(ans["A1"].PlcValue, dic1["A1"]);
+            Assert.AreEqual(ans2["A1"].PlcValue, dic2["A1"]);
+            Assert.AreEqual(ans["A2"].PlcValue, dic1["A2"]);
+            Assert.AreEqual(ans2["A2"].PlcValue, dic2["A2"]);
+            Assert.AreEqual(ans["A3"].PlcValue, dic1["A3"]);
+            Assert.AreEqual(ans2["A3"].PlcValue, dic2["A3"]);
+            Assert.AreEqual(ans["A4"].PlcValue, dic1["A4"]);
+            Assert.AreEqual(ans2["A4"].PlcValue, dic2["A4"]);
+            Assert.AreEqual(ans["A5"].PlcValue, dic1["A5"]);
+            Assert.AreEqual(ans2["A5"].PlcValue, dic2["A5"]);
+            Assert.AreEqual(ans["A6"].PlcValue, dic1["A6"]);
+            Assert.AreEqual(ans2["A6"].PlcValue, dic2["A6"]);
         }
     }
 }
diff --git a/Tests/Modbus.Net.Tests/ModbusTest.cs b/Tests/Modbus.Net.Tests/ModbusTest.cs
index 6e25dd6..b4b4833 100644
--- a/Tests/Modbus.Net.Tests/ModbusTest.cs
+++ b/Tests/Modbus.Net.Tests/ModbusTest.cs
@@ -20,6 +20,8 @@ namespace Modbus.Net.Tests
         [TestMethod]
         public async Task ModbusCoilSingle()
         {
+            Random r = new Random();
+
             var addresses = new List<AddressUnit>
             {
                 new AddressUnit
@@ -33,15 +35,17 @@ namespace Modbus.Net.Tests
                 }
             };
 
-            _modbusTcpMachine.GetAddresses = addresses;
-            await _modbusTcpMachine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
+            var dic1 = new Dictionary<string, double>()
             {
                 {
-                    "0X 1.0", 1
+                    "0X 1.0", r.Next(0, 2)
                 }
-            });
+            };
+
+            _modbusTcpMachine.GetAddresses = addresses;
+            await _modbusTcpMachine.SetDatasAsync(MachineSetDataType.Address, dic1);
             var ans = await _modbusTcpMachine.GetDatasAsync(MachineGetDataType.Address);
-            Assert.AreEqual(ans["0X 1.0"].PlcValue, 1);
+            Assert.AreEqual(ans["0X 1.0"].PlcValue, dic1["0X 1.0"]);
         }
 
         [TestMethod]
@@ -89,6 +93,8 @@ namespace Modbus.Net.Tests
         [TestMethod]
         public async Task ModbusRegSingle()
         {
+            Random r = new Random();
+
             var addresses = new List<AddressUnit>
             {
                 new AddressUnit
@@ -102,20 +108,24 @@ namespace Modbus.Net.Tests
                 }
             };
 
-            _modbusTcpMachine.GetAddresses = addresses;
-            await _modbusTcpMachine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
+            var dic1 = new Dictionary<string, double>()
             {
                 {
-                    "4X 1", 31125
+                    "4X 1", r.Next(0, UInt16.MaxValue)
                 }
-            });
+            };
+
+            _modbusTcpMachine.GetAddresses = addresses;
+            await _modbusTcpMachine.SetDatasAsync(MachineSetDataType.Address, dic1);
             var ans = await _modbusTcpMachine.GetDatasAsync(MachineGetDataType.Address);
-            Assert.AreEqual(ans["4X 1.0"].PlcValue, 31125);
+            Assert.AreEqual(ans["4X 1.0"].PlcValue, dic1["4X 1"]);
         }
 
         [TestMethod]
         public async Task ModbusRegMultiple()
         {
+            Random r = new Random();
+
             var addresses = new List<AddressUnit>
             {
                 new AddressUnit
@@ -174,35 +184,38 @@ namespace Modbus.Net.Tests
                 }
             };
 
-            _modbusTcpMachine.GetAddresses = addresses;
-            await _modbusTcpMachine.SetDatasAsync(MachineSetDataType.CommunicationTag, new Dictionary<string, double>()
+            var dic1 = new Dictionary<string, double>()
             {
                 {
-                    "A1", 70
+                    "A1", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A2", 71
+                    "A2", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A3", 72
+                    "A3", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A4", 73
+                    "A4", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A5", 717870
+                    "A5", r.Next()
                 },
                 {
-                    "A6", 717871
+                    "A6", r.Next()
                 },
-            });
+            };
+
+            _modbusTcpMachine.GetAddresses = addresses;
+            await _modbusTcpMachine.SetDatasAsync(MachineSetDataType.CommunicationTag, dic1);
+
             var ans = await _modbusTcpMachine.GetDatasAsync(MachineGetDataType.CommunicationTag);
-            Assert.AreEqual(ans["A1"].PlcValue, 70);
-            Assert.AreEqual(ans["A2"].PlcValue, 71);
-            Assert.AreEqual(ans["A3"].PlcValue, 72);
-            Assert.AreEqual(ans["A4"].PlcValue, 73);
-            Assert.AreEqual(ans["A5"].PlcValue, 717870);
-            Assert.AreEqual(ans["A6"].PlcValue, 717871);
+            Assert.AreEqual(ans["A1"].PlcValue, dic1["A1"]);
+            Assert.AreEqual(ans["A2"].PlcValue, dic1["A2"]);
+            Assert.AreEqual(ans["A3"].PlcValue, dic1["A3"]);
+            Assert.AreEqual(ans["A4"].PlcValue, dic1["A4"]);
+            Assert.AreEqual(ans["A5"].PlcValue, dic1["A5"]);
+            Assert.AreEqual(ans["A6"].PlcValue, dic1["A6"]);
         }
     }
 }
diff --git a/Tests/Modbus.Net.Tests/SiemensTest.cs b/Tests/Modbus.Net.Tests/SiemensTest.cs
index 313595b..6d4b9af 100644
--- a/Tests/Modbus.Net.Tests/SiemensTest.cs
+++ b/Tests/Modbus.Net.Tests/SiemensTest.cs
@@ -21,6 +21,8 @@ namespace Modbus.Net.Tests
         [TestMethod]
         public async Task SiemensCoilSingle()
         {
+            Random r = new Random();
+
             var addresses = new List<AddressUnit>
             {
                 new AddressUnit
@@ -34,15 +36,18 @@ namespace Modbus.Net.Tests
                 }
             };
 
-            _siemensTcpMachine.GetAddresses = addresses;
-            await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
+            var dic1 = new Dictionary<string, double>()
             {
                 {
-                    "Q 0.0", 1
+                    "Q 0.0", r.Next(0, 2)
                 }
-            });
+            };
+
+            _siemensTcpMachine.GetAddresses = addresses;
+            await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.Address, dic1);
+
             var ans = await _siemensTcpMachine.GetDatasAsync(MachineGetDataType.Address);
-            Assert.AreEqual(ans["Q 0.0"].PlcValue, 1);
+            Assert.AreEqual(ans["Q 0.0"].PlcValue, dic1["Q 0.0"]);
         }
 
         [TestMethod]
@@ -69,6 +74,8 @@ namespace Modbus.Net.Tests
         [TestMethod]
         public async Task SiemensMSingle()
         {
+            Random r = new Random();
+
             var addresses = new List<AddressUnit>
             {
                 new AddressUnit
@@ -84,19 +91,23 @@ namespace Modbus.Net.Tests
 
             _siemensTcpMachine.GetAddresses = addresses;
 
-            await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
+            var dic1 = new Dictionary<string, double>()
             {
                 {
-                    "M 0", 31125
+                    "M 0", r.Next(0, UInt16.MaxValue)
                 }
-            });
+            };
+
+            await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.Address, dic1);
             var ans = await _siemensTcpMachine.GetDatasAsync(MachineGetDataType.Address);
-            Assert.AreEqual(ans["M 0.0"].PlcValue, 31125);
+            Assert.AreEqual(ans["M 0.0"].PlcValue, dic1["M 0"]);
         }
 
         [TestMethod]
         public async Task SiemensMSingleBool()
         {
+            Random r = new Random();
+
             var addresses = new List<AddressUnit>
             {
                 new AddressUnit
@@ -112,19 +123,24 @@ namespace Modbus.Net.Tests
 
             _siemensTcpMachine.GetAddresses = addresses;
 
-            await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
+            var dic1 = new Dictionary<string, double>()
             {
                 {
-                    "M 0.0", 1
+                    "M 0.0", r.Next(0, 2)
                 }
-            });
+            };
+
+            await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.Address, dic1);
+
             var ans = await _siemensTcpMachine.GetDatasAsync(MachineGetDataType.Address);
-            Assert.AreEqual(ans["M 0.0"].PlcValue, 1);
+            Assert.AreEqual(ans["M 0.0"].PlcValue, dic1["M 0.0"]);
         }
 
         [TestMethod]
         public async Task SiemensDbSingle()
         {
+            Random r = new Random();
+
             var addresses = new List<AddressUnit>
             {
                 new AddressUnit
@@ -138,20 +154,25 @@ namespace Modbus.Net.Tests
                 }
             };
 
-            _siemensTcpMachine.GetAddresses = addresses;
-            await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
+            var dic1 = new Dictionary<string, double>()
             {
                 {
-                    "DB2 0.0", 31125
+                    "DB2 0.0", r.Next(0, UInt16.MaxValue)
                 }
-            });
+            };
+
+            _siemensTcpMachine.GetAddresses = addresses;
+            await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.Address, dic1);
+
             var ans = await _siemensTcpMachine.GetDatasAsync(MachineGetDataType.Address);
-            Assert.AreEqual(ans["DB2 0.0"].PlcValue, 31125);
+            Assert.AreEqual(ans["DB2 0.0"].PlcValue, dic1["DB2 0.0"]);
         }
 
         [TestMethod]
         public async Task SiemensDbMultiple()
         {
+            Random r = new Random();
+
             var addresses = new List<AddressUnit>
             {
                 new AddressUnit
@@ -210,35 +231,37 @@ namespace Modbus.Net.Tests
                 }
             };
 
-            _siemensTcpMachine.GetAddresses = addresses;
-            await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.CommunicationTag, new Dictionary<string, double>()
+            var dic1 = new Dictionary<string, double>()
             {
                 {
-                    "A1", 70
+                    "A1", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A2", 71
+                    "A2", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A3", 72
+                    "A3", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A4", 73
+                    "A4", r.Next(0, UInt16.MaxValue)
                 },
                 {
-                    "A5", 717870
+                    "A5", r.Next()
                 },
                 {
-                    "A6", 717871
+                    "A6", r.Next()
                 },
-            });
+            };
+
+            _siemensTcpMachine.GetAddresses = addresses;
+            await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.CommunicationTag, dic1);
             var ans = await _siemensTcpMachine.GetDatasAsync(MachineGetDataType.CommunicationTag);
-            Assert.AreEqual(ans["A1"].PlcValue, 70);
-            Assert.AreEqual(ans["A2"].PlcValue, 71);
-            Assert.AreEqual(ans["A3"].PlcValue, 72);
-            Assert.AreEqual(ans["A4"].PlcValue, 73);
-            Assert.AreEqual(ans["A5"].PlcValue, 717870);
-            Assert.AreEqual(ans["A6"].PlcValue, 717871);
+            Assert.AreEqual(ans["A1"].PlcValue, dic1["A1"]);
+            Assert.AreEqual(ans["A2"].PlcValue, dic1["A2"]);
+            Assert.AreEqual(ans["A3"].PlcValue, dic1["A3"]);
+            Assert.AreEqual(ans["A4"].PlcValue, dic1["A4"]);
+            Assert.AreEqual(ans["A5"].PlcValue, dic1["A5"]);
+            Assert.AreEqual(ans["A6"].PlcValue, dic1["A6"]);
         }
     }
 }