public void TestMulti()
{
var operations = new List <ReadOperationParameter>
{
new ReadOperationParameter {
Area = PlcArea.DB, Offset = TestByteOffset, Type = typeof(byte), Args = new int[] { 1, TestDbNr }
},
new ReadOperationParameter {
Area = PlcArea.DB, Offset = TestBitOffset, Type = typeof(bool), Args = new int[] { 1, TestDbNr }
}
};
var writeOperations = new List <WriteOperationParameter>
{
new WriteOperationParameter {
Area = PlcArea.DB, Offset = TestByteOffset, Type = typeof(byte), Args = new int[] { 1, TestDbNr }, Data = (byte)0x05
},
new WriteOperationParameter {
Area = PlcArea.DB, Offset = TestBitOffset, Type = typeof(bool), Args = new int[] { 1, TestDbNr }, Data = true
}
};
var client = new Dacs7Client();
client.Connect(ConnectionString);
client.WriteAny(writeOperations);
var result = client.ReadAnyRaw(operations);
client.Disconnect();
Assert.False(client.IsConnected);
}
public static void Main(string[] args)
{
_client.OnConnectionChange += _client_OnConnectionChange;
_client.Connect(ConnectionString);
GenericsSample();
MultiValuesSample();
var red = _client.ReadAny(PlcArea.DB, 0, typeof(int), new[] { 2, LongDbNumer });
var boolValue = _client.ReadAny <bool>(LongDbNumer, 0, 2);
_client.WriteAny(LongDbNumer, 0, new bool[] { true, true });
var intValue = _client.ReadAny <int>(LongDbNumer, 0, 2);
_client.WriteAny(LongDbNumer, 0, new int[] { 1, 2 });
ReadWriteAnyTest();
ReadWriteMoreThanOnePduTest();
ReadWriteMoreThanOnePduParallelTest();
_client.Disconnect();
Thread.Sleep(1000);
}
public void PerfTest()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
var offset = 0;
var sw = new Stopwatch();
sw.Start();
for (int i = 0; i < 100; i++)
{
var reads = new List <ReadOperationParameter> {
ReadOperationParameter.CreateForBit(250, offset, 0),
ReadOperationParameter.CreateForBit(250, offset, 1),
ReadOperationParameter.CreateForBit(250, offset, 2),
ReadOperationParameter.CreateForBit(250, offset, 3),
ReadOperationParameter.CreateForBit(250, offset, 4)
};
var result = client.ReadAny(reads);
if (!(bool)result.FirstOrDefault())
{
Console.WriteLine($"Bit 0 is false!");
}
Console.WriteLine($"{i}");
}
sw.Stop();
client.Disconnect();
}
public void TestaBunchOfMultiReads()
{
var db = 10;
var operations = new List <ReadOperationParameter>
{
new ReadOperationParameter {
Area = PlcArea.DB, Offset = 0, Type = typeof(byte), Args = new int[] { 1, db }
},
new ReadOperationParameter {
Area = PlcArea.DB, Offset = 1, Type = typeof(bool), Args = new int[] { 1, db }
},
};
for (int i = 0; i < 100; i++)
{
operations.Add(new ReadOperationParameter {
Area = PlcArea.DB, Offset = 1 + i, Type = typeof(bool), Args = new int[] { 1, db }
});
}
var client = new Dacs7Client();
client.Connect(ConnectionString);
var result = client.ReadAnyRaw(operations);
Assert.Equal(operations.Count(), result.Count());
operations.RemoveAt(0);
result = client.ReadAnyRaw(operations);
Assert.Equal(operations.Count(), result.Count());
client.Disconnect();
Assert.False(client.IsConnected);
}
public void ConnectTest()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
client.Disconnect();
Assert.False(client.IsConnected);
}
public void TestGeneric()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
for (int i = 0; i < 8; i++)
{
var offset = TestBitOffset + i;
//Set to false and read
client.WriteAny <bool>(TestDbNr, offset, false);
var boolValue1 = client.ReadAny <bool>(TestDbNr, offset);
//Set to true and read
client.WriteAny(TestDbNr, offset, true);
var boolValue2 = client.ReadAny <bool>(TestDbNr, offset);
Assert.NotEqual(boolValue1, boolValue2);
client.WriteAny <int>(TestDbNr, TestByteOffset, 512);
var intValue1 = client.ReadAny <int>(TestDbNr, TestByteOffset);
client.WriteAny <int>(TestDbNr, TestByteOffset, i);
var intValue2 = client.ReadAny <int>(TestDbNr, TestByteOffset);
Assert.NotEqual(intValue1, intValue2);
Assert.Equal(512, intValue1);
Assert.Equal(i, intValue2);
client.WriteAny(TestDbNr, TestByteOffset, "TEST", 4);
var strValue1 = client.ReadAny <string>(TestDbNr, TestByteOffset, 4)?.FirstOrDefault();
var writeVal = i.ToString().PadRight(4, 'X');
client.WriteAny(TestDbNr, TestByteOffset, writeVal, 4);
var strValue2 = client.ReadAny <string>(TestDbNr, TestByteOffset, 4)?.FirstOrDefault();
Assert.NotEqual(strValue1, strValue2);
Assert.Equal("TEST", strValue1);
Assert.Equal(writeVal, strValue2);
var firstWriteVal = "TEST".ToCharArray();
client.WriteAny(TestDbNr, TestByteOffset, firstWriteVal, 4);
var charValue1 = client.ReadAny <char>(TestDbNr, TestByteOffset, 4);
var secondWriteVal = i.ToString().PadRight(4, 'X').ToCharArray();
client.WriteAny(TestDbNr, TestByteOffset, secondWriteVal, 4);
var charValue2 = client.ReadAny <char>(TestDbNr, TestByteOffset, 4);
Assert.False(charValue1.SequenceEqual(charValue2));
Assert.True(firstWriteVal.SequenceEqual(charValue1));
Assert.True(secondWriteVal.SequenceEqual(charValue2));
}
client.Disconnect();
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
// Dispose managed resources.
_retryCancellation?.Cancel();
//Remove handles if exists
var handler = DataChanged;
if (handler != null)
{
DataChanged -= handler;
}
ClosePapperIfExits();
if (_client != null)
{
_client.OnConnectionChange -= _client_OnConnectionChange;
_client.Disconnect();
_client = null;
}
if (_connectionLock != null)
{
_connectionLock.Dispose();
_connectionLock = null;
}
}
// There are no unmanaged resources to release, but
// if we add them, they need to be released here.
}
_disposed = true;
// If it is available, make the call to the
// base class's Dispose(Boolean) method
// base.Dispose(disposing);
}
public void GetPlcTimeTest()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
var bc = client.GetPlcTime();
client.Disconnect();
Assert.False(client.IsConnected);
}
public void ReadWriteAnyTest()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
client.WriteAny(PlcArea.DB, TestByteOffset, (byte)0x05, new int[] { 1, TestDbNr });
var bytes = client.ReadAny(PlcArea.DB, TestByteOffset, typeof(byte), new int[] { 1, TestDbNr }) as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x05, bytes[0]);
client.WriteAny(PlcArea.DB, TestByteOffset, (byte)0x00, new int[] { 1, TestDbNr });
bytes = client.ReadAny(PlcArea.DB, TestByteOffset, typeof(byte), new int[] { 1, TestDbNr }) as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x00, bytes[0]);
client.WriteAny(PlcArea.DB, TestByteOffset, (byte)0x05, new int[] { 1, TestDbNr });
bytes = client.ReadAny(PlcArea.DB, TestByteOffset, typeof(byte), new int[] { 1, TestDbNr }) as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x05, bytes[0]);
client.WriteAny(PlcArea.DB, TestByteOffset, (byte)0x00, new int[] { 1, TestDbNr });
bytes = client.ReadAny(PlcArea.DB, TestByteOffset, typeof(byte), new int[] { 1, TestDbNr }) as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x00, bytes[0]);
client.WriteAny(PlcArea.DB, TestBitOffset, true, new int[] { 1, TestDbNr });
var state = client.ReadAny(PlcArea.DB, TestBitOffset, typeof(bool), new int[] { 1, TestDbNr }) as byte[];
Assert.NotNull(state);
Assert.Equal((byte)0x01, state[0]);
client.WriteAny(PlcArea.DB, TestBitOffset, false, new int[] { 1, TestDbNr });
state = client.ReadAny(PlcArea.DB, TestBitOffset, typeof(bool), new int[] { 1, TestDbNr }) as byte[];
Assert.NotNull(state);
Assert.Equal((byte)0x00, state[0]);
client.WriteAny(PlcArea.DB, TestBitOffset, true, new int[] { 1, TestDbNr });
state = client.ReadAny(PlcArea.DB, TestBitOffset, typeof(bool), new int[] { 1, TestDbNr }) as byte[];
Assert.NotNull(state);
Assert.Equal((byte)0x01, state[0]);
client.WriteAny(PlcArea.DB, TestBitOffset, false, new int[] { 1, TestDbNr });
state = client.ReadAny(PlcArea.DB, TestBitOffset, typeof(bool), new int[] { 1, TestDbNr }) as byte[];
Assert.NotNull(state);
Assert.Equal((byte)0x00, state[0]);
client.Disconnect();
Assert.False(client.IsConnected);
}
public void GetBlocksOfTypeTest()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
var bc = client.GetBlocksOfType(PlcBlockType.Ob);
client.Disconnect();
Assert.False(client.IsConnected);
}
public void ReadBlockInfoNoExistingTest()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
var blkInfo = client.ReadBlockInfo(PlcBlockType.Db, 9999);
Assert.Equal(9999, blkInfo.BlockNumber);
client.Disconnect();
Assert.False(client.IsConnected);
}
public void ReadBlockInfoFromSdbTest()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
var blkInfo = client.ReadBlockInfo(PlcBlockType.Sdb, 0);
Assert.Equal(0, blkInfo.BlockNumber);
client.Disconnect();
Assert.False(client.IsConnected);
}
public void ReadBlockInfo2Test()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
var blkInfo = client.UploadPlcBlock(PlcBlockType.Db, TestDbNr);
blkInfo = client.UploadPlcBlock(PlcBlockType.Db, 250);
client.Disconnect();
Assert.False(client.IsConnected);
}
public void ReadNotExistingItem()
{
var client = new Dacs7Client();
//client.OnLogEntry += Console.WriteLine;
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
const int length = ushort.MaxValue;
Assert.Throws <Dacs7ContentException>(() => client.ReadAny(PlcArea.DB, 0, typeof(byte), new[] { length, LongDbNumer }));
client.Disconnect();
Assert.False(client.IsConnected);
}
public void GetBlocksOfTypeTest2()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
var bc = client.GetBlocksOfType(PlcBlockType.Sdb);
foreach (var c in bc)
{
Console.WriteLine(c.Number);
}
client.Disconnect();
Assert.False(client.IsConnected);
}
public void TestaBunchOfMultiWrites()
{
var db = 11;
var operations = new List <WriteOperationParameter>();
var readOperations = new List <ReadOperationParameter>();
for (int i = 0; i < 100; i++)
{
operations.Add(new WriteOperationParameter {
Area = PlcArea.DB, Offset = i, Type = typeof(bool), Args = new int[] { 1, db }, Data = false
});
readOperations.Add(new ReadOperationParameter {
Area = PlcArea.DB, Offset = i, Type = typeof(bool), Args = new int[] { 1, db }
});
}
var client = new Dacs7Client();
client.Connect(ConnectionString);
//Reset to false
client.WriteAny(operations);
var result = client.ReadAny(readOperations).ToList();
for (int i = 0; i < operations.Count; i++)
{
operations[i].Data = !((bool)result[i]);
}
client.WriteAny(operations);
result = client.ReadAny(readOperations).ToList();
for (int i = 0; i < operations.Count; i++)
{
Assert.Equal((bool)operations[i].Data, ((bool)result[i]));
}
operations.RemoveAt(0);
client.WriteAny(operations);
client.Disconnect();
Assert.False(client.IsConnected);
}
public void ReadPendingAlarmsTest()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
var alarms = client.ReadPendingAlarms();
foreach (var alm in alarms)
{
var ts = alm.Timestamp;
var i = alm.Id;
var c = alm.IsComing;
var sc = alm.IsAck;
}
client.Disconnect();
Assert.False(client.IsConnected);
}
public void ReadBlockInfoTest()
{
var client = new Dacs7Client();
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
var blkInfo = client.ReadBlockInfo(PlcBlockType.Db, TestDbNr);
Assert.Equal(TestDbNr, blkInfo.BlockNumber);
blkInfo = client.ReadBlockInfo(PlcBlockType.Sdb, 1000);
Assert.Equal(TestDbNr, 1001);
blkInfo = client.ReadBlockInfo(PlcBlockType.Db, 250);
Assert.Equal(250, blkInfo.BlockNumber);
client.Disconnect();
Assert.False(client.IsConnected);
}
public void ReadWriteMoreThanOnePduParallelTest()
{
var client = new Dacs7Client();
//client.OnLogEntry += Console.WriteLine;
client.Connect(ConnectionString);
Assert.True(client.IsConnected);
const int length = 24000;
var testData = new byte[length];
for (var i = 0; i < testData.Length; i++)
{
testData[i] = 0x01;
}
var sw = new Stopwatch();
sw.Start();
client.WriteAnyParallel(PlcArea.DB, 0, testData, new[] { length, LongDbNumer });
sw.Stop();
Console.WriteLine("Write time: {0}ms", sw.ElapsedMilliseconds);
sw.Reset();
sw.Start();
var red = client.ReadAnyParallel(PlcArea.DB, 0, typeof(byte), new[] { length, LongDbNumer }) as byte[];
sw.Stop();
Console.WriteLine("Read time: {0}ms", sw.ElapsedMilliseconds);
Assert.NotNull(red);
Assert.True(testData.SequenceEqual(red));
client.Disconnect();
Assert.False(client.IsConnected);
}
