private void SendPackageSiemens(IDriverAdapter ISiemens, Device dv, DataBlock db)
{
try
{
switch (db.DataType)
{
case "Bit":
lock (ISiemens)
{
bool[] bitRs = ISiemens.Read <bool>($"{db.MemoryType}{db.StartAddress}", db.Length);
int length = bitRs.Length;
if (bitRs.Length > db.Tags.Count)
{
length = db.Tags.Count;
}
for (int j = 0; j < length; j++)
{
db.Tags[j].Value = bitRs[j];
db.Tags[j].Checked = bitRs[j];
db.Tags[j].Enabled = bitRs[j];
db.Tags[j].Visible = bitRs[j];
db.Tags[j].ValueSelect1 = bitRs[j];
db.Tags[j].ValueSelect2 = bitRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "Int":
lock (ISiemens)
{
short[] IntRs = ISiemens.Read <Int16>($"{db.MemoryType}{db.StartAddress}", db.Length);
if (IntRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < IntRs.Length; j++)
{
if (db.Tags[j].IsScaled)
{
db.Tags[j].Value = Util.Interpolation(IntRs[j], db.Tags[j].AImin, db.Tags[j].AImax, db.Tags[j].RLmin, db.Tags[j].RLmax);
}
else
{
db.Tags[j].Value = IntRs[j];
}
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "DInt":
lock (ISiemens)
{
int[] DIntRs = ISiemens.Read <Int32>($"{db.MemoryType}{db.StartAddress}", db.Length);
if (DIntRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < DIntRs.Length; j++)
{
db.Tags[j].Value = DIntRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "Word":
lock (ISiemens)
{
var wdRs = ISiemens.Read <UInt16>($"{db.MemoryType}{db.StartAddress}", db.Length);
if (wdRs == null)
{
return;
}
if (wdRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < wdRs.Length; j++)
{
if (db.Tags[j].IsScaled)
{
db.Tags[j].Value = Util.Interpolation(wdRs[j], db.Tags[j].AImin, db.Tags[j].AImax, db.Tags[j].RLmin, db.Tags[j].RLmax);
}
else
{
db.Tags[j].Value = wdRs[j];
}
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "DWord":
lock (ISiemens)
{
uint[] dwRs = ISiemens.Read <UInt32>($"{db.MemoryType}{db.StartAddress}", (ushort)db.Length);
for (int j = 0; j < dwRs.Length; j++)
{
db.Tags[j].Value = dwRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "Real1":
lock (ISiemens)
{
float[] rl1Rs = ISiemens.Read <float>($"{db.MemoryType}{db.StartAddress}", (ushort)db.Length);
for (int j = 0; j < rl1Rs.Length; j++)
{
db.Tags[j].Value = rl1Rs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "Real2":
lock (ISiemens)
{
double[] rl2Rs = ISiemens.Read <double>($"{db.MemoryType}{db.StartAddress}", (ushort)db.Length);
for (int j = 0; j < rl2Rs.Length; j++)
{
db.Tags[j].Value = rl2Rs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
}
}
catch (SocketException ex)
{
Disconnect();
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
Disconnect();
Console.WriteLine(ex.Message);
}
}
private void SendPackageModbus(IDriverAdapter DriverAdapter, Device dv, DataBlock db)
{
try
{
switch (db.DataType)
{
case "Bit":
lock (DriverAdapter)
{
bool[] bitRs = DriverAdapter.Read <bool>($"{db.StartAddress}", db.Length);
int length = bitRs.Length;
if (bitRs.Length > db.Tags.Count)
{
length = db.Tags.Count;
}
for (int j = 0; j < length; j++)
{
db.Tags[j].Value = bitRs[j];
db.Tags[j].Checked = bitRs[j];
db.Tags[j].Enabled = bitRs[j];
db.Tags[j].Visible = bitRs[j];
db.Tags[j].ValueSelect1 = bitRs[j];
db.Tags[j].ValueSelect2 = bitRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "Int":
lock (DriverAdapter)
{
short[] IntRs = DriverAdapter.Read <Int16>($"{db.StartAddress}", db.Length);
if (IntRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < IntRs.Length; j++)
{
if (db.Tags[j].IsScaled)
{
db.Tags[j].Value = Util.Interpolation(IntRs[j], db.Tags[j].AImin, db.Tags[j].AImax, db.Tags[j].RLmin, db.Tags[j].RLmax);
}
else
{
db.Tags[j].Value = IntRs[j];
}
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "DInt":
lock (DriverAdapter)
{
int[] DIntRs = DriverAdapter.Read <Int32>(string.Format("{0}", db.StartAddress), db.Length);
if (DIntRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < DIntRs.Length; j++)
{
db.Tags[j].Value = DIntRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "Word":
lock (DriverAdapter)
{
var wdRs = DriverAdapter.Read <UInt16>($"{db.StartAddress}", db.Length);
if (wdRs == null)
{
return;
}
if (wdRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < wdRs.Length; j++)
{
if (db.Tags[j].IsScaled)
{
db.Tags[j].Value = Util.Interpolation(wdRs[j], db.Tags[j].AImin, db.Tags[j].AImax, db.Tags[j].RLmin, db.Tags[j].RLmax);
}
else
{
db.Tags[j].Value = wdRs[j];
}
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "DWord":
lock (DriverAdapter)
{
uint[] dwRs = DriverAdapter.Read <UInt32>(string.Format("{0}", db.StartAddress), (ushort)db.Length);
for (int j = 0; j < dwRs.Length; j++)
{
db.Tags[j].Value = dwRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "Real1":
lock (DriverAdapter)
{
float[] rl1Rs = DriverAdapter.Read <float>(string.Format("{0}", db.StartAddress), (ushort)db.Length);
for (int j = 0; j < rl1Rs.Length; j++)
{
db.Tags[j].Value = rl1Rs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "Real2":
lock (DriverAdapter)
{
double[] rl2Rs = DriverAdapter.Read <double>(string.Format("{0}", db.StartAddress), (ushort)db.Length);
for (int j = 0; j < rl2Rs.Length; j++)
{
db.Tags[j].Value = rl2Rs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
}
}
catch (SocketException ex)
{
Disconnect();
EventscadaException?.Invoke(this.GetType().Name, ex.Message);
}
catch (Exception ex)
{
Disconnect();
EventscadaException?.Invoke(this.GetType().Name, ex.Message);
}
}
private void SendPackageLSIS(IDriverAdapter ILSIS, Channel ch, Device dv, DataBlock db)
{
try
{
switch (db.DataType)
{
case "Bit":
byte[] bitArys = null;
lock (ILSIS)
bitArys = ILSIS.BuildReadByte((byte)dv.SlaveId, $"{db.MemoryType.Substring(0, 1)}{2 * db.StartAddress}", (ushort)(2 * db.Length));
if (bitArys == null || bitArys.Length == 0)
{
return;
}
var bitRs = HslCommunication.BasicFramework.SoftBasic.ByteToBoolArray(bitArys);
if (bitRs.Length > db.Tags.Count)
{
return;
}
for (var j = 0; j <= db.Tags.Count - 1; j++)
{
db.Tags[j].Value = bitRs[j];
db.Tags[j].Visible = bitRs[j];
db.Tags[j].Enabled = bitRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
break;
case "Int":
lock (ILSIS)
{
short[] IntRs = ILSIS.Read <Int16>($"{db.MemoryType.Substring(0, 1)}{2 * db.StartAddress}", db.Length);
if (IntRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < IntRs.Length; j++)
{
if (db.Tags[j].IsScaled)
{
db.Tags[j].Value = Util.Interpolation(IntRs[j], db.Tags[j].AImin, db.Tags[j].AImax, db.Tags[j].RLmin, db.Tags[j].RLmax);
}
else
{
db.Tags[j].Value = IntRs[j];
}
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "DInt":
lock (ILSIS)
{
int[] DIntRs = ILSIS.Read <Int32>($"{db.MemoryType.Substring(0, 1)}{2 * db.StartAddress}", db.Length);
if (DIntRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < DIntRs.Length; j++)
{
db.Tags[j].Value = DIntRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "Word":
lock (ILSIS)
{
var wdRs = ILSIS.Read <Int16>($"{db.MemoryType.Substring(0, 1)}{2 * db.StartAddress}", db.Length);
if (wdRs == null)
{
return;
}
if (wdRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < wdRs.Length; j++)
{
if (db.Tags[j].IsScaled)
{
db.Tags[j].Value = Util.Interpolation(wdRs[j], db.Tags[j].AImin, db.Tags[j].AImax, db.Tags[j].RLmin, db.Tags[j].RLmax);
}
else
{
db.Tags[j].Value = wdRs[j];
}
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "DWord":
lock (ILSIS)
{
uint[] dwRs = ILSIS.Read <UInt32>($"{db.MemoryType.Substring(0, 1)}{2 * db.StartAddress}", (ushort)db.Length);
for (int j = 0; j < dwRs.Length; j++)
{
db.Tags[j].Value = dwRs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "Real1":
lock (ILSIS)
{
float[] rl1Rs = ILSIS.Read <float>($"{db.MemoryType.Substring(0, 1)}{2 * db.StartAddress}", (ushort)db.Length);
for (int j = 0; j < rl1Rs.Length; j++)
{
db.Tags[j].Value = rl1Rs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
case "Real2":
lock (ILSIS)
{
double[] rl2Rs = ILSIS.Read <double>($"{db.MemoryType.Substring(0, 1)}{2 * db.StartAddress}", (ushort)db.Length);
for (int j = 0; j < rl2Rs.Length; j++)
{
db.Tags[j].Value = rl2Rs[j];
db.Tags[j].Timestamp = DateTime.Now;
}
}
break;
}
}
catch (SocketException ex)
{
Disconnect();
if (ex.Message == "Hex Character Count Not Even")
{
return;
}
IsConnected = false;
EventscadaException?.Invoke(this.GetType().Name, ex.Message);
}
catch (Exception ex)
{
Disconnect();
Console.WriteLine(ex.Message);
}
}
private void SendPackageLSIS(IDriverAdapter DriverAdapter, DataBlock db)
{
try
{
SendDone.WaitOne(-1);
int baseAddress = db.StartAddress;
switch (db.DataType)
{
case DataTypes.BitOnByte:
baseAddress = ((db.StartAddress >= 2) ? (db.StartAddress / 2) : 0) * 2;
break;
case DataTypes.BitOnWord:
baseAddress = db.StartAddress * 2;
break;
case DataTypes.Bit when db.IsArray:
// baseAddress = ((db.StartAddress >= 16) ? (db.StartAddress / 16) : 0) * 2;
baseAddress = db.StartAddress * 2;
break;
case DataTypes.Byte:
baseAddress = db.StartAddress;
break;
case DataTypes.Short:
case DataTypes.UShort:
baseAddress = db.StartAddress * 2;
break;
case DataTypes.Int:
case DataTypes.UInt:
baseAddress = db.StartAddress * 4;
break;
case DataTypes.Long:
case DataTypes.ULong:
baseAddress = db.StartAddress * 8;
break;
case DataTypes.Float:
baseAddress = db.StartAddress * 4;
break;
case DataTypes.Double:
baseAddress = db.StartAddress * 8;
break;
}
switch (db.DataType)
{
case DataTypes.BitOnByte:
case DataTypes.BitOnWord:
lock (DriverAdapter)
{
bool[] bitArys2 = DriverAdapter.Read <bool>($"{db.MemoryType.Substring(0, 1)}{baseAddress}", (ushort)(2 * db.Length));
if (bitArys2 == null || bitArys2.Length == 0)
{
return;
}
if (bitArys2.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j <= db.Tags.Count - 1; j++)
{
db.Tags[j].Value = bitArys2[j];
db.Tags[j].TimeSpan = DateTime.Now;
}
}
break;
case DataTypes.Bit:
bool[] bitArys = null;
if (db.IsArray)
{
lock (DriverAdapter)
{
bitArys = DriverAdapter.Read <bool>($"{db.MemoryType.Substring(0, 1)}{ baseAddress}", (ushort)(2 * db.Length));
if (bitArys == null || bitArys.Length == 0)
{
return;
}
if (bitArys.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j <= db.Tags.Count - 1; j++)
{
db.Tags[j].Value = bitArys[j];
db.Tags[j].TimeSpan = DateTime.Now;
}
}
}
else
{
lock (DriverAdapter)
{
bitArys = new bool[db.Tags.Count];
for (int i = 0; i < db.Tags.Count; i++)
{
bitArys[i] = DriverAdapter.Read <bool>(db.Tags[i].Address);
if (bitArys == null || bitArys.Length == 0)
{
return;
}
db.Tags[i].Value = bitArys[i];
db.Tags[i].TimeSpan = DateTime.Now;
}
}
}
break;
case DataTypes.Byte:
lock (DriverAdapter)
{
byte[] byteArys = null;
if (db.IsArray)
{
byteArys = DriverAdapter.Read <byte>($"{db.MemoryType.Substring(0, 1)}{baseAddress}", (ushort)(2 * db.Length));
if (byteArys == null || byteArys.Length == 0)
{
return;
}
if (byteArys.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j <= db.Tags.Count - 1; j++)
{
db.Tags[j].Value = byteArys[j];
db.Tags[j].TimeSpan = DateTime.Now;
}
}
else
{
lock (DriverAdapter)
{
byteArys = new byte[db.Tags.Count];
for (int i = 0; i < db.Tags.Count; i++)
{
byteArys[i] = DriverAdapter.Read <byte>(db.Tags[i].Address);
if (byteArys == null || byteArys.Length == 0)
{
return;
}
db.Tags[i].Value = byteArys[i];
db.Tags[i].TimeSpan = DateTime.Now;
}
}
}
}
break;
case DataTypes.Short:
lock (DriverAdapter)
{
short[] IntRs = null;
if (db.IsArray)
{
IntRs = DriverAdapter.Read <short>($"{db.MemoryType.Substring(0, 1)}{baseAddress}", db.Length);
if (IntRs == null || IntRs.Length == 0)
{
return;
}
if (IntRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < IntRs.Length; j++)
{
db.Tags[j].Value = IntRs[j];
db.Tags[j].TimeSpan = DateTime.Now;
}
}
else
{
lock (DriverAdapter)
{
IntRs = new short[db.Tags.Count];
for (int i = 0; i < db.Tags.Count; i++)
{
IntRs[i] = DriverAdapter.Read <short>(db.Tags[i].Address);
if (IntRs == null || IntRs.Length == 0)
{
return;
}
db.Tags[i].Value = IntRs[i];
db.Tags[i].TimeSpan = DateTime.Now;
}
}
}
}
break;
case DataTypes.UShort:
lock (DriverAdapter)
{
ushort[] ushortArys = DriverAdapter.Read <ushort>($"{db.MemoryType.Substring(0, 1)}{baseAddress}", db.Length);
if (ushortArys == null || ushortArys.Length == 0)
{
return;
}
if (ushortArys.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j <= db.Tags.Count - 1; j++)
{
db.Tags[j].Value = ushortArys[j];
db.Tags[j].TimeSpan = DateTime.Now;
}
}
break;
case DataTypes.Int:
lock (DriverAdapter)
{
int[] DIntRs = DriverAdapter.Read <int>($"{db.MemoryType.Substring(0, 1)}{baseAddress}", db.Length);
if (DIntRs == null || DIntRs.Length == 0)
{
return;
}
if (DIntRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < DIntRs.Length; j++)
{
db.Tags[j].Value = DIntRs[j];
db.Tags[j].TimeSpan = DateTime.Now;
}
}
break;
case DataTypes.UInt:
lock (DriverAdapter)
{
uint[] wdRs = DriverAdapter.Read <uint>($"{db.MemoryType.Substring(0, 1)}{baseAddress}", db.Length);
if (wdRs == null || wdRs.Length == 0)
{
return;
}
if (wdRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < db.Tags.Count; j++)
{
db.Tags[j].Value = wdRs[j];
db.Tags[j].TimeSpan = DateTime.Now;
}
}
break;
case DataTypes.Long:
lock (DriverAdapter)
{
long[] dwRs = DriverAdapter.Read <long>($"{db.MemoryType.Substring(0, 1)}{baseAddress}", db.Length);
if (dwRs == null || dwRs.Length == 0)
{
return;
}
if (dwRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < dwRs.Length; j++)
{
db.Tags[j].Value = dwRs[j];
db.Tags[j].TimeSpan = DateTime.Now;
}
}
break;
case DataTypes.ULong:
lock (DriverAdapter)
{
ulong[] dwRs = DriverAdapter.Read <ulong>($"{db.MemoryType.Substring(0, 1)}{baseAddress}", db.Length);
if (dwRs == null || dwRs.Length == 0)
{
return;
}
if (dwRs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < dwRs.Length; j++)
{
db.Tags[j].Value = dwRs[j];
db.Tags[j].TimeSpan = DateTime.Now;
}
}
break;
case DataTypes.Float:
lock (DriverAdapter)
{
float[] rl1Rs = DriverAdapter.Read <float>($"{db.MemoryType.Substring(0, 1)}{baseAddress}", db.Length);
if (rl1Rs == null || rl1Rs.Length == 0)
{
return;
}
if (rl1Rs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < rl1Rs.Length; j++)
{
db.Tags[j].Value = rl1Rs[j];
db.Tags[j].TimeSpan = DateTime.Now;
}
}
break;
case DataTypes.Double:
lock (DriverAdapter)
{
double[] rl2Rs = DriverAdapter.Read <double>($"{db.MemoryType.Substring(0, 1)}{baseAddress}", db.Length);
if (rl2Rs == null || rl2Rs.Length == 0)
{
return;
}
if (rl2Rs.Length > db.Tags.Count)
{
return;
}
for (int j = 0; j < rl2Rs.Length; j++)
{
db.Tags[j].Value = rl2Rs[j];
db.Tags[j].TimeSpan = DateTime.Now;
}
}
break;
case DataTypes.String:
break;
default:
break;
}
}
catch (Exception ex)
{
Disconnect();
EventscadaException?.Invoke(GetType().Name, ex.Message);
}
}