/// <summary>
/// 读取设备的float类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult <float[]> ReadFloat(string address, ushort length)
{
return(ByteTransformHelper.GetResultFromBytes(Read(address, (ushort)(length * WordLength * 2)), m => ByteTransform.TransSingle(m, 0, length)));
}
/// <summary>
/// 向设备中写入double数组，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="values">实际数据</param>
/// <returns>返回写入结果</returns>
/// <example>
/// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="WriteDoubleArray" title="Double类型示例" />
/// </example>
public OperateResult Write(string address, double[] values)
{
return(Write(address, ByteTransform.TransByte(values)));
}
/// <summary>
/// 读取设备的short类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult <short[]> ReadInt16(string address, ushort length)
{
return(ByteTransformHelper.GetResultFromBytes(Read(address, (ushort)(length * WordLength)), m => ByteTransform.TransInt16(m, 0, length)));
}
/// <summary>
/// 向寄存器中写入字符串，编码格式为Unicode
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult WriteUnicodeString(string address, string value)
{
byte[] temp = ByteTransform.TransByte(value, Encoding.Unicode);
return(Write(address, temp));
}
/// <summary>
/// 向寄存器中写入指定长度的字符串,超出截断，不够补0，编码格式为Unicode
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <param name="length">指定的字符串长度，必须大于0</param>
/// <returns>返回写入结果</returns>
public OperateResult WriteUnicodeString(string address, string value, int length)
{
byte[] temp = ByteTransform.TransByte(value, Encoding.Unicode);
temp = SoftBasic.ArrayExpandToLength(temp, length * 2);
return(Write(address, temp));
}
/// <summary>
/// 读取设备的字符串数据，编码为ASCII
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">地址长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult <string> ReadString(string address, ushort length)
{
return(ByteTransformHelper.GetResultFromBytes(Read(address, length), m => ByteTransform.TransString(m, 0, m.Length, Encoding.ASCII)));
}
/// <summary>
/// 读取设备的uint类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
/// <example>
/// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadUInt32Array" title="UInt32类型示例" />
/// </example>
public virtual OperateResult <uint[]> ReadUInt32(string address, ushort length)
{
return(ByteTransformHelper.GetResultFromBytes(Read(address, (ushort)(length * WordLength * 2)), m => ByteTransform.TransUInt32(m, 0, length)));
}
/// <summary>
/// 读取设备的double类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
/// <example>
/// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadDoubleArray" title="Double类型示例" />
/// </example>
public override OperateResult <double[]> ReadDouble(string address, ushort length)
{
return(ByteTransformHelper.GetResultFromBytes(Read(address, length), m => ByteTransform.TransDouble(m, 0, length)));
}
/// <summary>
/// 向设备中写入float数组，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="values">实际数据</param>
/// <returns>返回写入结果</returns>
/// <example>
/// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="WriteFloatArray" title="Float类型示例" />
/// </example>
public override OperateResult Write(string address, float[] values)
{
return(WriteTag(address, AllenBradleyHelper.CIP_Type_Real, ByteTransform.TransByte(values), values.Length));
}
/// <summary>
/// 向设备中写入uint数据，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">实际数据</param>
/// <returns>返回写入结果</returns>
public override OperateResult Write(string address, uint value)
{
return(WriteTag(address, AllenBradleyHelper.CIP_Type_DWord, ByteTransform.TransByte(value)));
}
/// <summary>
/// 读取设备的ulong类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
/// <example>
/// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadUInt64Array" title="UInt64类型示例" />
/// </example>
public override OperateResult <ulong[]> ReadUInt64(string address, ushort length)
{
return(ByteTransformHelper.GetResultFromBytes(Read(address, length), m => ByteTransform.TransUInt64(m, 0, length)));
}
private byte[] WriteByMessage(byte[] command)
{
if (command[2] == 0x01)
{
// 位写入
ushort length = ByteTransform.TransUInt16(command, 8);
int startIndex = (command[6] * 65536 + command[5] * 256 + command[4]);
if (command[7] == MelsecMcDataType.M.DataCode)
{
byte[] buffer = MelsecMcNet.ExtractActualData(SoftBasic.BytesArrayRemoveBegin(command, 10), true).Content;
mBuffer.SetBytes(buffer.Take(length).ToArray( ), startIndex);
return(new byte[0]);
}
else if (command[7] == MelsecMcDataType.X.DataCode)
{
byte[] buffer = MelsecMcNet.ExtractActualData(SoftBasic.BytesArrayRemoveBegin(command, 10), true).Content;
xBuffer.SetBytes(buffer.Take(length).ToArray( ), startIndex);
return(new byte[0]);
}
else if (command[7] == MelsecMcDataType.Y.DataCode)
{
byte[] buffer = MelsecMcNet.ExtractActualData(SoftBasic.BytesArrayRemoveBegin(command, 10), true).Content;
yBuffer.SetBytes(buffer.Take(length).ToArray( ), startIndex);
return(new byte[0]);
}
else
{
throw new Exception(StringResources.Language.NotSupportedDataType);
}
}
else
{
// 字写入
ushort length = ByteTransform.TransUInt16(command, 8);
int startIndex = (command[6] * 65536 + command[5] * 256 + command[4]);
if (command[7] == MelsecMcDataType.M.DataCode)
{
byte[] buffer = SoftBasic.ByteToBoolArray(SoftBasic.BytesArrayRemoveBegin(command, 10)).Select(m => m ? (byte)1 : (byte)0).ToArray( );
mBuffer.SetBytes(buffer, startIndex);
return(new byte[0]);
}
else if (command[7] == MelsecMcDataType.X.DataCode)
{
byte[] buffer = SoftBasic.ByteToBoolArray(SoftBasic.BytesArrayRemoveBegin(command, 10)).Select(m => m ? (byte)1 : (byte)0).ToArray( );
xBuffer.SetBytes(buffer, startIndex);
return(new byte[0]);
}
else if (command[7] == MelsecMcDataType.Y.DataCode)
{
byte[] buffer = SoftBasic.ByteToBoolArray(SoftBasic.BytesArrayRemoveBegin(command, 10)).Select(m => m ? (byte)1 : (byte)0).ToArray( );
yBuffer.SetBytes(buffer, startIndex);
return(new byte[0]);
}
else if (command[7] == MelsecMcDataType.D.DataCode)
{
dBuffer.SetBytes(SoftBasic.BytesArrayRemoveBegin(command, 10), startIndex * 2);
return(new byte[0]);
}
else if (command[7] == MelsecMcDataType.W.DataCode)
{
wBuffer.SetBytes(SoftBasic.BytesArrayRemoveBegin(command, 10), startIndex * 2);
return(new byte[0]);
}
else
{
throw new Exception(StringResources.Language.NotSupportedDataType);
}
}
}
private byte[] ReadByCommand(byte[] command)
{
if (command[2] == 0x01)
{
// 位读取
ushort length = ByteTransform.TransUInt16(command, 8);
int startIndex = (command[6] * 65536 + command[5] * 256 + command[4]);
if (command[7] == MelsecMcDataType.M.DataCode)
{
byte[] buffer = mBuffer.GetBytes(startIndex, length);
return(MelsecHelper.TransBoolArrayToByteData(buffer));
}
else if (command[7] == MelsecMcDataType.X.DataCode)
{
byte[] buffer = xBuffer.GetBytes(startIndex, length);
return(MelsecHelper.TransBoolArrayToByteData(buffer));
}
else if (command[7] == MelsecMcDataType.Y.DataCode)
{
byte[] buffer = yBuffer.GetBytes(startIndex, length);
return(MelsecHelper.TransBoolArrayToByteData(buffer));
}
else
{
throw new Exception(StringResources.Language.NotSupportedDataType);
}
}
else
{
// 字读取
ushort length = ByteTransform.TransUInt16(command, 8);
int startIndex = (command[6] * 65536 + command[5] * 256 + command[4]);
if (command[7] == MelsecMcDataType.M.DataCode)
{
bool[] buffer = mBuffer.GetBytes(startIndex, length * 16).Select(m => m != 0x00).ToArray( );
return(SoftBasic.BoolArrayToByte(buffer));
}
else if (command[7] == MelsecMcDataType.X.DataCode)
{
bool[] buffer = xBuffer.GetBytes(startIndex, length * 16).Select(m => m != 0x00).ToArray( );
return(SoftBasic.BoolArrayToByte(buffer));
}
else if (command[7] == MelsecMcDataType.Y.DataCode)
{
bool[] buffer = yBuffer.GetBytes(startIndex, length * 16).Select(m => m != 0x00).ToArray( );
return(SoftBasic.BoolArrayToByte(buffer));
}
else if (command[7] == MelsecMcDataType.D.DataCode)
{
return(dBuffer.GetBytes(startIndex * 2, length * 2));
}
else if (command[7] == MelsecMcDataType.W.DataCode)
{
return(wBuffer.GetBytes(startIndex * 2, length * 2));
}
else
{
throw new Exception(StringResources.Language.NotSupportedDataType);
}
}
}
private byte[] WriteByMessage(byte[] packCommand)
{
int NameLength = packCommand[28];
int RequestCount = BitConverter.ToUInt16(packCommand, 30 + NameLength);
int _byte2 = 12 + (int)RequestCount;
var result = new List <byte>();
var data5 = new byte[30];
Array.Copy(packCommand, 0, data5, 0, 30);
data5[9] = 0x11;
data5[10] = 0x01;
data5[12] = 0xA0;
data5[13] = 0x11;
data5[16] = (byte)_byte2;
data5[18] = 0x03;
data5[20] = 89;
data5[21] = 0;
data5[22] = 20;
data5[23] = 0;
data5[24] = 0x08;
data5[25] = 0x01;
data5[26] = 0;
data5[27] = 0;
data5[28] = 1;
data5[29] = 0;
result.AddRange(data5);
result.AddRange(BitConverter.GetBytes((ushort)RequestCount));
var DeviceAddress = Encoding.ASCII.GetString(packCommand, 30, NameLength);
var AddressLength = BitConverter.ToUInt16(packCommand, 30 + NameLength);
var startIndex = CheckAddress(DeviceAddress.Remove(0, 3));
if (DeviceAddress.Substring(1, 2) == "DW" || DeviceAddress.Substring(1, 2) == "DB")
{
byte[] data = ByteTransform.TransByte(packCommand, 30 + NameLength + AddressLength, RequestCount);
switch (DeviceAddress[1])
{
case 'C': inputBuffer.SetBytes(data, startIndex); break;
case 'T': outputBuffer.SetBytes(data, startIndex); break;
case 'M': memeryBuffer.SetBytes(data, startIndex); break;
case 'D': dbBlockBuffer.SetBytes(data, startIndex); break;
default: throw new Exception(StringResources.Language.NotSupportedDataType);
}
result.AddRange(data);
return(result.ToArray());
}
else
{
bool value = BitConverter.ToBoolean(packCommand, 30 + NameLength + AddressLength);
switch (DeviceAddress[1])
{
//case 'M': inputBuffer.SetBool(value, startIndex); break;
//case 'M': outputBuffer.SetBool(value, startIndex); break;
case 'M': memeryBuffer.SetBool(value, startIndex); break;
case 'D': dbBlockBuffer.SetBool(value, startIndex); break;
default: throw new Exception(StringResources.Language.NotSupportedDataType);
}
result.AddRange(new byte[] { 0, 0 });
return(result.ToArray());
}
}
/// <summary>
/// 读取设备的ulong类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult <ulong[]> ReadUInt64(string address, ushort length)
{
return(ByteTransformHelper.GetResultFromBytes(Read(address, (ushort)(length * WordLength * 4)), m => ByteTransform.TransUInt64(m, 0, length)));
}
/// <summary>
/// 向设备中写入string数据，返回是否写入成功，该string类型是针对PLC的DINT类型，长度自动扩充到8
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">实际数据</param>
/// <returns>返回写入结果</returns>
public override OperateResult Write(string address, string value)
{
return(WriteTag(address, AllenBradleyHelper.CIP_Type_DWord, BasicFramework.SoftBasic.ArrayExpandToLength(ByteTransform.TransByte(value, Encoding.ASCII), 8)));
}
/// <summary>
/// 读取设备的double类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult <double[]> ReadDouble(string address, ushort length)
{
return(ByteTransformHelper.GetResultFromBytes(Read(address, (ushort)(length * WordLength * 4)), m => ByteTransform.TransDouble(m, 0, length)));
}
/// <summary>
/// 向PLC中写入指定长度的字符串,超出截断，不够补0，编码格式为ASCII
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <param name="length">指定的字符串长度，必须大于0</param>
/// <returns>写入结果</returns>
public OperateResult Write(string address, string value, int length)
{
byte[] temp = ByteTransform.TransByte(value, Encoding.ASCII);
temp = BasicFramework.SoftBasic.ArrayExpandToLength(temp, length);
return(Write(address, temp));
}
/// <summary>
/// 向设备中写入long数组，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="values">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write(string address, long[] values)
{
return(Write(address, ByteTransform.TransByte(values)));
}
/// <summary>
/// 向PLC中字软元件写入字符串，编码格式为ASCII
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <returns>返回读取结果</returns>
public OperateResult Write(string address, string value)
{
byte[] temp = ByteTransform.TransByte(value, Encoding.ASCII);
temp = SoftBasic.ArrayExpandToLengthEven(temp);
return(Write(address, temp));
}