public async Task ReadWriteSingles()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10014,r", (float)0.0 }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(float), results[0].Type);
Assert.Equal((float)0.0, (float)results[0].Value);
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10014,r", (float)0.5 }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(float), results[0].Type);
Assert.Equal((float)0.5, (float)results[0].Value);
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task ReadWriteBigDBData()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var data = Enumerable.Repeat((byte)0x00, 1000).ToArray();
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.2500,b,1000", data }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.True(results.FirstOrDefault().Data.ToArray().SequenceEqual(data));
var data2 = Enumerable.Repeat((byte)0x25, 1000).ToArray();
var writeTags = new Dictionary <string, object>
{
{ $"DB2.2500,b,1000", data2 }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.True(results.FirstOrDefault().Data.ToArray().SequenceEqual(data2));
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public void TestReadItemInvalidNumberOfBitsThrowsException()
{
Assert.Throws <Dacs7TypeNotSupportedException>(() => ReadItem.CreateFromTag("DB3.10000,x0,2"));
Assert.Throws <Dacs7TypeNotSupportedException>(() => ReadItem.Create <bool[]>("DB1", 0, 2));
Assert.Throws <Dacs7TypeNotSupportedException>(() => ReadItem.Create <bool>("DB1", 0, 2));
Assert.Throws <Dacs7TypeNotSupportedException>(() => ReadItem.Create <bool[]>("DB1", 0));
Assert.Throws <Dacs7TypeNotSupportedException>(() => ReadItem.Create <bool>("DB1", 0, 2));
}
public async Task Setup()
{
_client = new Dacs7Client(Address, PlcConnectionType.Pg, 5000)
{
MaxAmQCalled = 5,
MaxAmQCalling = 5
};
await _client.ConnectAsync();
_item = ReadItem.CreateFromTag(Tag);
}
public async Task ReadMixedData()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var results = (await client.ReadAsync(ReadItem.CreateFromTag("DB1.4,B,8"),
ReadItem.CreateFromTag("DB1.38,B,8"),
ReadItem.CreateFromTag("DB1.94,B,10"))).ToArray();
Assert.Equal(3, results.Count());
Assert.True(results[0].IsSuccessReturnCode);
Assert.True(results[1].IsSuccessReturnCode);
Assert.True(results[2].IsSuccessReturnCode);
});
}
public async Task ReadMixedData()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.4,B,8", null },
{ $"DB2.38,B,8", null },
{ $"DB2.94,B,10", null },
};
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(3, results.Count());
Assert.True(results[0].IsSuccessReturnCode);
Assert.True(results[1].IsSuccessReturnCode);
Assert.True(results[2].IsSuccessReturnCode);
});
}
public async Task ReadWriteSingleDWords()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10006,dw", (uint)0 },
{ $"DB2.10010,di", 0 }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(uint), results[0].Type);
Assert.Equal((uint)0, (uint)results[0].Value);
Assert.Equal(typeof(int), results[1].Type);
Assert.Equal(0, (int)results[1].Value);
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10006,dw", (uint)15 },
{ $"DB2.10010,di", 25 }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(uint), results[0].Type);
Assert.Equal((ushort)15, (uint)results[0].Value);
Assert.Equal(typeof(int), results[1].Type);
Assert.Equal(25, (int)results[1].Value);
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task ReadWriteSingleBits()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10000,x0", false },
{ $"DB2.10000,x5", false }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(bool), results[0].Type);
Assert.False((bool)results[0].Value);
Assert.Equal(typeof(bool), results[1].Type);
Assert.False((bool)results[1].Value);
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10000,x0", true },
{ $"DB2.10000,x5", true }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(bool), results[0].Type);
Assert.True((bool)results[0].Value);
Assert.Equal(typeof(bool), results[1].Type);
Assert.True((bool)results[1].Value);
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task ReadMultibleByteArrayData()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var readTags = new Dictionary <string, object>
{
{ $"DB2.0,b,1000", 1000 },
{ $"DB2.2200,b,100", 100 },
{ $"DB2.1000,b,1000", 1000 },
{ $"DB2.200,b,100", 100 },
};
var results = (await client.ReadAsync(readTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(4, results.Count());
Assert.Equal(1000, results[0].Data.Length);
Assert.Equal(100, results[1].Data.Length);
Assert.Equal(1000, results[2].Data.Length);
Assert.Equal(100, results[3].Data.Length);
});
}
public async Task ReadWriteMultibleDWords()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10034,dw,2", new uint[] { 0, 0 } }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(uint[]), results[0].Type);
var resultValueDefault = results[0].Value as uint[];
Assert.True(resultValueDefault.SequenceEqual(originWriteTags.FirstOrDefault().Value as uint[]));
var writeData = new uint[] { 22, 21 };
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10034,dw,2", writeData }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Single(results);
Assert.Equal(typeof(uint[]), results[0].Type);
var resultValue = results[0].Value as uint[];
Assert.True(resultValue.SequenceEqual(writeData));
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task ReadWriteSingleStrings2()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10090,s,20", "" },
{ $"DB2.10112,s,20", " " }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(string), results[0].Type);
Assert.Equal("", (string)results[0].Value);
Assert.Equal(typeof(string), results[1].Type);
Assert.Equal(" ", (string)results[1].Value);
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10046,s,20", "A PARTIAL STRING".PadLeft(20).Substring(0, 18) },
{ $"DB2.10068,s,20", "A FULLY STRING IT IS".PadLeft(20) }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(string), results[0].Type);
Assert.Equal("A PARTIAL STRING".PadLeft(20).Substring(0, 18), (string)results[0].Value);
Assert.Equal(typeof(string), results[1].Type);
Assert.Equal("A FULLY STRING IT IS".PadLeft(20), (string)results[1].Value);
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
public async Task ReadWriteSingleStrings()
{
await PlcTestServer.ExecuteClientAsync(async (client) =>
{
var originWriteTags = new Dictionary <string, object>
{
{ $"DB2.10046,s,20", "" },
{ $"DB2.10068,s,20", " " }
};
var writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
var results = (await client.ReadAsync(originWriteTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(string), results[0].Type);
Assert.Equal("", (string)results[0].Value);
Assert.Equal(typeof(string), results[1].Type);
Assert.Equal(" ", (string)results[1].Value);
var writeTags = new Dictionary <string, object>
{
{ $"DB2.10046,s,20", "Test1" },
{ $"DB2.10068,s,20", "Test2 " }
};
writeResults = (await client.WriteAsync(writeTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
results = (await client.ReadAsync(writeTags.Select(w => ReadItem.CreateFromTag(w.Key)))).ToArray();
Assert.Equal(2, results.Count());
Assert.Equal(typeof(string), results[0].Type);
Assert.Equal("Test1", (string)results[0].Value);
Assert.Equal(typeof(string), results[1].Type);
Assert.Equal("Test2 ", (string)results[1].Value);
writeResults = (await client.WriteAsync(originWriteTags.Select(w => WriteItem.CreateFromTag(w.Key, w.Value)))).ToArray();
});
}
private static async Task <int> Serve(ServerOptions options, ILoggerFactory loggerFactory)
{
Dacs7Client client = null;
IPlcDataProvider provider = null;
if (string.IsNullOrWhiteSpace(options.DataProvider) || options.DataProvider.Equals("Simulation", StringComparison.InvariantCultureIgnoreCase))
{
if (options.Tags != null)
{
foreach (var item in options.Tags)
{
var ri = ReadItem.CreateFromTag(item);
Console.WriteLine($"Register tag {item}");
SimulationPlcDataProvider.Instance.Register(ri.Area, ri.NumberOfItems, ri.DbNumber);
}
}
Console.WriteLine("Using Simulation Provider!");
provider = SimulationPlcDataProvider.Instance;
}
else if (options.DataProvider.Equals("Relay", StringComparison.InvariantCultureIgnoreCase))
{
client = new Dacs7Client(options.Address, PlcConnectionType.Pg, 5000, loggerFactory)
{
MaxAmQCalled = (ushort)options.MaxJobs,
MaxAmQCalling = (ushort)options.MaxJobs,
PduSize = options.MaxPduSize
};
RelayPlcDataProvider.Instance.UseClient(client);
Console.WriteLine("Using Relay Provider!");
provider = RelayPlcDataProvider.Instance;
}
var server = new Dacs7Server(options.Port, provider, loggerFactory)
{
MaxAmQCalled = (ushort)options.MaxJobs,
MaxAmQCalling = (ushort)options.MaxJobs,
PduSize = (ushort)480
};
var logger = loggerFactory?.CreateLogger("Dacs7Cli.Serve");
try
{
Console.WriteLine($"Started serving on port {options.Port} !");
await server.ConnectAsync();
if (client != null)
{
await client.ConnectAsync();
}
Console.WriteLine("Please press any key to stop serving!");
Console.ReadKey();
}
catch (Exception ex)
{
logger?.LogError($"An error occured in Serve: {ex.Message} - {ex.InnerException?.Message}");
return(1);
}
finally
{
if (client != null)
{
await client.DisconnectAsync();
}
await server.DisconnectAsync();
}
return(0);
}