1264 lines
44 KiB
C#
1264 lines
44 KiB
C#
using SharpModbus;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
|
|
namespace MES.Utility.Network
|
|
{
|
|
public class ModbusHelper : IDisposable
|
|
{
|
|
public delegate void OnSendedData(byte[] bytes, string hexString);
|
|
public event OnSendedData OnSended;
|
|
|
|
public delegate void OnRecivedData(byte[] bytes, string hexString);
|
|
public event OnRecivedData OnRecived;
|
|
|
|
|
|
private object _lock = new object();
|
|
private ModbusMaster master;
|
|
private byte slaveId;
|
|
public ModbusHelper(string ip, int port)
|
|
{
|
|
master = ModbusMaster.TCP(ip, port);
|
|
master.OnSended += Master_OnSended; ;
|
|
master.OnRecived += Master_OnRecived; ;
|
|
slaveId = 1;
|
|
}
|
|
|
|
|
|
|
|
public ModbusHelper(string ip, int port, byte slaveId)
|
|
{
|
|
master = ModbusMaster.TCP(ip, port);
|
|
master.OnSended += Master_OnSended;
|
|
master.OnRecived += Master_OnRecived;
|
|
this.slaveId = slaveId;
|
|
|
|
}
|
|
public ModbusHelper(SerialSettings setting, int timeout, byte slaveId)
|
|
{
|
|
master = ModbusMaster.RTU(setting, timeout);
|
|
master.OnSended += Master_OnSended;
|
|
master.OnRecived += Master_OnRecived;
|
|
this.slaveId = slaveId;
|
|
}
|
|
|
|
#region ushort INT16 操作
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">传递：数据值</param>
|
|
/// <returns>bool 读取成功还是失败</returns>
|
|
public bool ReadHoldRegisterInt16(int address, out ushort value)
|
|
{
|
|
return ReadHoldRegisterInt16(slaveId, address, out value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">传递：数据值</param>
|
|
/// <returns>bool 读取成功还是失败</returns>
|
|
public bool ReadHoldRegisterInt16(byte slaveId, int address, out ushort value)
|
|
{
|
|
bool flag = ReadHoldRegistersInt16(slaveId, address, 1, out ushort[] values);
|
|
value = flag ? values[0] : (ushort)0;
|
|
return flag;
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 读取某个地址连续N个数据
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="count">读取的数量</param>
|
|
/// <param name="value">传递：数据值</param>
|
|
/// <returns>bool 读取成功还是失败</returns>
|
|
public bool ReadHoldRegistersInt16(int address, int count, out ushort[] value)
|
|
{
|
|
return ReadHoldRegistersInt16(slaveId, address, count, out value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取某个地址连续N个数据
|
|
/// </summary>
|
|
/// <param name="slaveId"></param>
|
|
/// <param name="address"></param>
|
|
/// <param name="count"></param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegistersInt16(byte slaveId, int address, int count, out ushort[] value)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
value = master.ReadHoldingRegisters(slaveId, (ushort)address, (ushort)count);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
value = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 写入一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">写入的数据</param>
|
|
/// <returns>bool 写入成功还是失败</returns>
|
|
public bool WriteHoldRegisterInt16(int address, ushort value)
|
|
{
|
|
return WriteHoldRegisterInt16(slaveId, address, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 写入一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId"></param>
|
|
/// <param name="address"></param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegisterInt16(byte slaveId, int address, ushort value)
|
|
{
|
|
return WriteHoldRegistersInt16(slaveId, address, new ushort[] { value });
|
|
}
|
|
|
|
/// <summary>
|
|
/// 写入一个地址
|
|
/// </summary>
|
|
/// <param name="address"></param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegistersInt16(int address, ushort[] value)
|
|
{
|
|
return WriteHoldRegistersInt16(slaveId, address, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 写入一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId"></param>
|
|
/// <param name="address"></param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegistersInt16(byte slaveId, int address, ushort[] value)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
master.WriteRegisters(slaveId, (ushort)address, value);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region int INT32 操作
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">传递：数据值</param>
|
|
/// <returns>bool 读取成功还是失败</returns>
|
|
public bool ReadHoldRegisterInt32(int address, out int value)
|
|
{
|
|
return ReadHoldRegisterInt32(slaveId, address, out value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">传递：数据值</param>
|
|
/// <returns>bool 读取成功还是失败</returns>
|
|
public bool ReadHoldRegisterInt32(byte slaveId, int address, out int value)
|
|
{
|
|
bool flag = ReadHoldRegistersInt32(slaveId, address, 1, out int[] values);
|
|
value = flag ? values[0] : 0;
|
|
return flag;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="count">int32数据的数量，不是地址数</param>
|
|
/// <param name="value">传递：数据值</param>
|
|
/// <returns>bool 读取成功还是失败</returns>
|
|
public bool ReadHoldRegistersInt32(int address, int count, out int[] value)
|
|
{
|
|
return ReadHoldRegistersInt32(slaveId, address, count, out value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="count">int32数据的数量，不是地址数</param>
|
|
/// <param name="value">传递：数据值</param>
|
|
/// <returns>bool 读取成功还是失败</returns>
|
|
public bool ReadHoldRegistersInt32(byte slaveId, int address, int count, out int[] value)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
List<int> valueList = new List<int>();
|
|
ushort[] values = master.ReadHoldingRegisters(slaveId, (ushort)address, (ushort)(2 * count));
|
|
for (int i = 0; i < values.Length; i += 2)
|
|
{
|
|
valueList.Add(ConvertRegistersToInt(new ushort[] { values[i], values[i + 1] }));
|
|
}
|
|
value = valueList.ToArray();
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
value = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// <summary>
|
|
/// 写入一个地址
|
|
/// </summary>
|
|
/// <param name="address"></param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegisterInt32(int address, int value)
|
|
{
|
|
return WriteHoldRegisterInt32(slaveId, address, value);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">数据</param>
|
|
/// <returns>bool 写入成功还是失败</returns>
|
|
public bool WriteHoldRegisterInt32(byte slaveId, int address, int value)
|
|
{
|
|
return WriteHoldRegistersInt32(slaveId, address, new int[] { value });
|
|
}
|
|
|
|
// <summary>
|
|
/// 写入一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegistersInt32(int address, int[] values)
|
|
{
|
|
return WriteHoldRegistersInt32(slaveId, address, values);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 写入一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="values">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegistersInt32(byte slaveId, int address, int[] values)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
List<ushort> list = new List<ushort>();
|
|
foreach (int value in values)
|
|
{
|
|
ushort[] ushortValues = ConvertIntToRegisters(value);
|
|
list.AddRange(ushortValues);
|
|
}
|
|
master.WriteRegisters(slaveId, (ushort)address, list.ToArray());
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
#region long INT64 操作
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">传递：数据值</param>
|
|
/// <returns>bool 读取成功还是失败</returns>
|
|
public bool ReadHoldRegisterInt64(int address, out long value)
|
|
{
|
|
return ReadHoldRegisterInt64(slaveId, address, out value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">传递：数据值</param>
|
|
/// <returns>bool 读取成功还是失败</returns>
|
|
public bool ReadHoldRegisterInt64(byte slaveId, int address, out long value)
|
|
{
|
|
bool flag = ReadHoldRegistersInt64(slaveId, address, 1, out long[] values);
|
|
value = flag ? values[0] : 0;
|
|
return flag;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="count">int32数据的数量，不是地址数</param>
|
|
/// <param name="value">传递：数据值</param>
|
|
/// <returns>bool 读取成功还是失败</returns>
|
|
public bool ReadHoldRegistersInt64(int address, int count, out long[] value)
|
|
{
|
|
return ReadHoldRegistersInt64(slaveId, address, count, out value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="count">int32数据的数量，不是地址数</param>
|
|
/// <param name="value">传递：数据值</param>
|
|
/// <returns>bool 读取成功还是失败</returns>
|
|
public bool ReadHoldRegistersInt64(byte slaveId, int address, int count, out long[] value)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
List<long> valueList = new List<long>();
|
|
ushort[] values = master.ReadHoldingRegisters(slaveId, (ushort)address, (ushort)(4 * count));
|
|
for (int i = 0; i < values.Length; i += 4)
|
|
{
|
|
valueList.Add(ConvertRegistersToLong(new ushort[] { values[i], values[i + 1], values[i + 2], values[i + 3] }));
|
|
}
|
|
value = valueList.ToArray();
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
value = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// <summary>
|
|
/// 写入一个地址
|
|
/// </summary>
|
|
/// <param name="address"></param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegisterInt64(int address, long value)
|
|
{
|
|
return WriteHoldRegisterInt64(slaveId, address, value);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">数据</param>
|
|
/// <returns>bool 写入成功还是失败</returns>
|
|
public bool WriteHoldRegisterInt64(byte slaveId, int address, long value)
|
|
{
|
|
return WriteHoldRegistersInt64(slaveId, address, new long[] { value });
|
|
}
|
|
|
|
// <summary>
|
|
/// 写入一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegistersInt64(int address, long[] values)
|
|
{
|
|
return WriteHoldRegistersInt64(slaveId, address, values);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 写入一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="values">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegistersInt64(byte slaveId, int address, long[] values)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
List<ushort> list = new List<ushort>();
|
|
foreach (int value in values)
|
|
{
|
|
ushort[] ushortValues = ConvertLongToRegisters(value);
|
|
list.AddRange(ushortValues);
|
|
}
|
|
master.WriteRegisters(slaveId, (ushort)address, list.ToArray());
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
#region Float 32位数据操作
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">数据</param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegisterFloat(int address, out float value)
|
|
{
|
|
return ReadHoldRegisterFloat(slaveId, address, out value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegisterFloat(byte slaveId, int address, out float value)
|
|
{
|
|
bool flag = ReadHoldRegistersFloat(slaveId, address, 1, out float[] values);
|
|
value = flag ? (float)values[0] : (float)0;
|
|
return flag;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="count">float数据的数量，不是地址数</param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegistersFloat(int address, int count, out float[] value)
|
|
{
|
|
return ReadHoldRegistersFloat(slaveId, address, count, out value);
|
|
}
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="count">float数据的数量，不是地址数</param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegistersFloat(byte slaveId, int address, int count, out float[] value)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
List<float> valueList = new List<float>();
|
|
ushort[] values = master.ReadHoldingRegisters(slaveId, (ushort)address, (ushort)(2 * count));
|
|
for (int i = 0; i < values.Length; i += 2)
|
|
{
|
|
valueList.Add(ConvertRegistersToFloat(values));
|
|
}
|
|
value = valueList.ToArray();
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
value = null;
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 写入地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegisterFloat(int address, float value)
|
|
{
|
|
return WriteHoldRegisterFloat(slaveId, address, value);
|
|
}
|
|
/// <summary>
|
|
/// 写入地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegisterFloat(byte slaveId, int address, float value)
|
|
{
|
|
return WriteHoldRegistersFloat(slaveId, address, new float[] { value });
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 写入地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="values">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegistersFloat(int address, float[] values)
|
|
{
|
|
return WriteHoldRegistersFloat(slaveId, address, values);
|
|
}
|
|
/// <summary>
|
|
/// 写入地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="values">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegistersFloat(byte slaveId, int address, float[] values)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
List<ushort> list = new List<ushort>();
|
|
foreach (float value in values)
|
|
{
|
|
list.AddRange(ConvertFloatToRegisters(value));
|
|
//byte[] bytes = BitConverter.GetBytes(value);
|
|
//ushort value1 = BitConverter.ToUInt16(new byte[] { bytes[0], bytes[1] }, 0);
|
|
//ushort value2 = BitConverter.ToUInt16(new byte[] { bytes[2], bytes[3] }, 0);
|
|
//list.Add(value1);
|
|
//list.Add(value2);
|
|
}
|
|
master.WriteRegisters(slaveId, (ushort)address, list.ToArray());
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Double 64位操作
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">数据</param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegisterDouble(int address, out double value)
|
|
{
|
|
return ReadHoldRegisterDouble(slaveId, address, out value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegisterDouble(byte slaveId, int address, out double value)
|
|
{
|
|
bool flag = ReadHoldRegistersDouble(slaveId, address, 1, out double[] values);
|
|
value = flag ? (double)values[0] : (double)0;
|
|
return flag;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="count">float数据的数量，不是地址数</param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegistersDouble(int address, int count, out double[] value)
|
|
{
|
|
return ReadHoldRegistersDouble(slaveId, address, count, out value);
|
|
}
|
|
/// <summary>
|
|
/// 读取一个地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="count">float数据的数量，不是地址数</param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegistersDouble(byte slaveId, int address, int count, out double[] value)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
List<double> valueList = new List<double>();
|
|
ushort[] values = master.ReadHoldingRegisters(slaveId, (ushort)address, (ushort)(4 * count));
|
|
for (int i = 0; i < values.Length; i += 4)
|
|
{
|
|
valueList.Add(ConvertRegistersToDouble(values));
|
|
}
|
|
value = valueList.ToArray();
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
value = null;
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 写入地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegisterDouble(int address, double value)
|
|
{
|
|
return WriteHoldRegisterDouble(slaveId, address, value);
|
|
}
|
|
/// <summary>
|
|
/// 写入地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="value">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegisterDouble(byte slaveId, int address, double value)
|
|
{
|
|
return WriteHoldRegistersDouble(slaveId, address, new double[] { value });
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 写入地址
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="values">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegistersDouble(int address, double[] values)
|
|
{
|
|
return WriteHoldRegistersDouble(slaveId, address, values);
|
|
}
|
|
/// <summary>
|
|
/// 写入地址
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="values">数据</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegistersDouble(byte slaveId, int address, double[] values)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
List<ushort> list = new List<ushort>();
|
|
foreach (double value in values)
|
|
{
|
|
list.AddRange(ConvertDoubleToRegisters(value));
|
|
}
|
|
master.WriteRegisters(slaveId, (ushort)address, list.ToArray());
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 字符串操作
|
|
|
|
/// <summary>
|
|
/// 读取字符串
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="length">字符串总长度（不是地址长度，一个地址两个字符）</param>
|
|
/// <param name="str"></param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegisterString(int address, int length, out string str)
|
|
{
|
|
return ReadHoldRegisterString(slaveId, address, length, Encoding.ASCII, out str);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取字符串
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="length">字符串总长度（不是地址长度，一个地址两个字符）</param>
|
|
/// <param name="str"></param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegisterString(int address, int length, Encoding encoding, out string str)
|
|
{
|
|
return ReadHoldRegisterString(slaveId, address, length, encoding, out str);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 读取字符串
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="length">字符串总长度（不是地址长度，一个地址两个字符）</param>
|
|
/// <param name="str"></param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegisterString(byte slaveId, int address, int length, out string str)
|
|
{
|
|
return ReadHoldRegisterString(slaveId, address, length, Encoding.ASCII, out str);
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 读取字符串
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="length">字符串总长度（不是地址长度，一个地址两个字符）</param>
|
|
/// <param name="str"></param>
|
|
/// <returns></returns>
|
|
public bool ReadHoldRegisterString(byte slaveId, int address, int length, Encoding encoding, out string str)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
int count = length / 2 + length % 2;
|
|
ushort[] values = master.ReadHoldingRegisters(slaveId, (ushort)address, (ushort)(count));
|
|
str = ConvertRegistersToString(values, length, encoding);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
str = "";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 写入字符串
|
|
/// </summary>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="length">字符串总长度（不是地址长度，一个地址两个字符）</param>
|
|
/// <param name="str">字符串内容</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegisterString(int address, int length, string str)
|
|
{
|
|
return WriteHoldRegisterString(slaveId, address, length, str, Encoding.ASCII);
|
|
}
|
|
|
|
public bool WriteHoldRegisterString(int address, int length, string str, Encoding encoding)
|
|
{
|
|
return WriteHoldRegisterString(slaveId, address, length, str, encoding);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 写入字符串
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="length">字符串总长度（不是地址长度，一个地址两个字符）</param>
|
|
/// <param name="str">字符串内容</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegisterString(byte slaveId, int address, int length, string str)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
ushort[] value = ConvertStringToRegisters(str, length, Encoding.ASCII);
|
|
master.WriteRegisters(slaveId, (ushort)address, value);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 写入字符串
|
|
/// </summary>
|
|
/// <param name="slaveId">从站Id</param>
|
|
/// <param name="address">地址</param>
|
|
/// <param name="length">字符串总长度（不是地址长度，一个地址两个字符）</param>
|
|
/// <param name="str">字符串内容</param>
|
|
/// <returns></returns>
|
|
public bool WriteHoldRegisterString(byte slaveId, int address, int length, string str, Encoding encoding)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
ushort[] value = ConvertStringToRegisters(str, length, encoding);
|
|
master.WriteRegisters(slaveId, (ushort)address, value);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 通用操作,线圈，输入寄存器等操作
|
|
|
|
public bool ReadCoil(ushort address, out bool value)
|
|
{
|
|
return ReadCoil(slaveId, address, out value); //there is no code for single read
|
|
}
|
|
|
|
public bool ReadCoil(byte slave, ushort address, out bool value)
|
|
{
|
|
bool flag = ReadCoils(slave, address, 1, out bool[] values);
|
|
value = flag ? values[0] : false;
|
|
return flag;
|
|
}
|
|
public bool ReadCoils(ushort address, ushort count, out bool[] values)
|
|
{
|
|
return ReadCoils(slaveId, address, count, out values);
|
|
}
|
|
public bool ReadCoils(byte slave, ushort address, ushort count, out bool[] values)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
try
|
|
{
|
|
values = master.ReadCoils(slave, address, count);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
values = null;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool WriteCoil(ushort address, bool value)
|
|
{
|
|
return WriteCoil(slaveId, address, value);
|
|
}
|
|
public bool WriteCoil(byte slave, ushort address, bool value)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
master.WriteCoils(slave, address, value);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
|
|
}
|
|
public bool WriteCoils(ushort address, params bool[] values)
|
|
{
|
|
return WriteCoils(slaveId, address, values);
|
|
}
|
|
public bool WriteCoils(byte slave, ushort address, params bool[] values)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
try
|
|
{
|
|
master.WriteCoils(slave, address, values);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
public bool ReadInput(ushort address, ushort count, out bool value)
|
|
{
|
|
return ReadInput(slaveId, address, out value);
|
|
}
|
|
|
|
public bool ReadInput(byte slave, ushort address, out bool value)
|
|
{
|
|
bool flag = ReadInputs(slave, address, 1, out bool[] values); //there is no code for single read
|
|
value = flag ? values[0] : false;
|
|
return flag;
|
|
}
|
|
public bool ReadInputs(ushort address, ushort count, out bool[] values)
|
|
{
|
|
return ReadInputs(slaveId, address, count, out values);
|
|
}
|
|
public bool ReadInputs(byte slave, ushort address, ushort count, out bool[] values)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
try
|
|
{
|
|
values = master.ReadInputs(slave, address, count);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
values = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public bool ReadInputRegister(ushort address, out ushort value)
|
|
{
|
|
return ReadInputRegister(slaveId, address, out value);
|
|
}
|
|
public bool ReadInputRegister(byte slave, ushort address, out ushort value)
|
|
{
|
|
bool flag = ReadInputRegisters(slave, address, 1, out ushort[] values);
|
|
value = flag ? values[0] : (ushort)0;
|
|
return flag;
|
|
}
|
|
public bool ReadInputRegisters(ushort address, ushort count, out ushort[] values)
|
|
{
|
|
return ReadInputRegisters(slaveId, address, count, out values);
|
|
}
|
|
public bool ReadInputRegisters(byte slave, ushort address, ushort count, out ushort[] values)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
try
|
|
{
|
|
values = master.ReadInputRegisters(slave, address, count);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
values = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public bool ReadHoldingRegister(ushort address, out ushort value)
|
|
{
|
|
return ReadHoldingRegister(slaveId, address, out value);
|
|
}
|
|
|
|
public bool ReadHoldingRegister(byte slave, ushort address, out ushort value)
|
|
{
|
|
bool flag = ReadHoldingRegisters(slave, address, 1, out ushort[] values);
|
|
value = flag ? values[0] : (ushort)0;
|
|
return flag;
|
|
}
|
|
public bool ReadHoldingRegisters(ushort address, ushort count, out ushort[] values)
|
|
{
|
|
return ReadHoldingRegisters(slaveId, address, count, out values);
|
|
}
|
|
|
|
public bool ReadHoldingRegisters(byte slave, ushort address, ushort count, out ushort[] values)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
values = master.ReadHoldingRegisters(slave, address, count);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
values = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public bool WriteRegister(ushort address, ushort value)
|
|
{
|
|
return WriteRegister(slaveId, address, value);
|
|
}
|
|
public bool WriteRegister(byte slave, ushort address, ushort value)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
master.WriteRegister(slave, address, value);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
public bool WriteRegisters(ushort address, params ushort[] values)
|
|
{
|
|
return WriteRegisters(slaveId, address, values);
|
|
}
|
|
|
|
public bool WriteRegisters(byte slave, ushort address, params ushort[] values)
|
|
{
|
|
lock (_lock)
|
|
try
|
|
{
|
|
master.WriteRegisters(slave, address, values);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
public void Dispose()
|
|
{
|
|
master.OnSended -= Master_OnSended;
|
|
master.OnRecived -= Master_OnRecived;
|
|
master.Dispose();
|
|
|
|
}
|
|
#region 数据转换功能
|
|
#region PLC寄存器与字符串数据转换
|
|
public static string ConvertRegistersToString(ushort[] registers, int stringLength, Encoding encoding)
|
|
{
|
|
byte[] result = new byte[stringLength];
|
|
byte[] registerResult = new byte[2];
|
|
for (int i = 0; i < stringLength / 2; i++)
|
|
{
|
|
registerResult = BitConverter.GetBytes(registers[i]);
|
|
result[i * 2] = registerResult[0];
|
|
result[i * 2 + 1] = registerResult[1];
|
|
}
|
|
return encoding.GetString(result).Trim('\0').Trim();
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="str"></param>
|
|
/// <param name="count">字符串长度</param>
|
|
/// <returns></returns>
|
|
public static ushort[] ConvertStringToRegisters(string str, int count, Encoding encoding)
|
|
{
|
|
//需要多少地址
|
|
int addressCount = count / 2 + count % 2;
|
|
//这些地址共有多少字节
|
|
byte[] bytesList = new byte[addressCount * 2];
|
|
//将字符串拆成字节数组
|
|
byte[] bytes = encoding.GetBytes(str);
|
|
//依次放入byteList中
|
|
for (int i = 0; i < bytesList.Length; i++)
|
|
{
|
|
//要考虑数组越界的情况
|
|
if (i >= bytes.Length)
|
|
{
|
|
bytesList[i] = 0x00;
|
|
}
|
|
else
|
|
{
|
|
bytesList[i] = bytes[i];
|
|
}
|
|
}
|
|
//封装ushort
|
|
List<ushort> shortList = new List<ushort>();
|
|
for (int i = 0; i < bytesList.Length; i += 2)
|
|
{
|
|
//将字节数组转为int存入list
|
|
shortList.Add(BitConverter.ToUInt16(new byte[] { bytesList[i], bytesList[i + 1] }, 0));
|
|
}
|
|
return shortList.ToArray();
|
|
}
|
|
#endregion
|
|
|
|
#region PLC寄存器与Double数据转换
|
|
public static double ConvertRegistersToDouble(ushort[] registers)
|
|
{
|
|
if (registers.Length != 4)
|
|
throw new ArgumentException("Input Array length invalid - Array langth must be '4'");
|
|
ushort highRegister = registers[3];
|
|
ushort highLowRegister = registers[2];
|
|
ushort lowHighRegister = registers[1];
|
|
ushort lowRegister = registers[0];
|
|
byte[] highRegisterBytes = BitConverter.GetBytes(highRegister);
|
|
byte[] highLowRegisterBytes = BitConverter.GetBytes(highLowRegister);
|
|
byte[] lowHighRegisterBytes = BitConverter.GetBytes(lowHighRegister);
|
|
byte[] lowRegisterBytes = BitConverter.GetBytes(lowRegister);
|
|
byte[] longBytes = {
|
|
lowRegisterBytes[0],
|
|
lowRegisterBytes[1],
|
|
lowHighRegisterBytes[0],
|
|
lowHighRegisterBytes[1],
|
|
highLowRegisterBytes[0],
|
|
highLowRegisterBytes[1],
|
|
highRegisterBytes[0],
|
|
highRegisterBytes[1]
|
|
};
|
|
return BitConverter.ToDouble(longBytes, 0);
|
|
}
|
|
public static ushort[] ConvertDoubleToRegisters(double doubleValue)
|
|
{
|
|
byte[] doubleBytes = BitConverter.GetBytes(doubleValue);
|
|
byte[] highRegisterBytes = { doubleBytes[6], doubleBytes[7] };
|
|
byte[] highLowRegisterBytes = { doubleBytes[4], doubleBytes[5] };
|
|
byte[] lowHighRegisterBytes = { doubleBytes[2], doubleBytes[3] };
|
|
byte[] lowRegisterBytes = { doubleBytes[0], doubleBytes[1] };
|
|
ushort[] returnValue =
|
|
{
|
|
BitConverter.ToUInt16(lowRegisterBytes,0),
|
|
BitConverter.ToUInt16(lowHighRegisterBytes,0),
|
|
BitConverter.ToUInt16(highLowRegisterBytes,0),
|
|
BitConverter.ToUInt16(highRegisterBytes,0)
|
|
};
|
|
return returnValue;
|
|
}
|
|
#endregion
|
|
|
|
#region PLC寄存器与INT64数据转换
|
|
public static float ConvertRegistersToFloat(ushort[] registers)
|
|
{
|
|
if (registers.Length != 2)
|
|
throw new ArgumentException("Input Array length invalid - Array langth must be '2'");
|
|
ushort highRegister = registers[1];
|
|
ushort lowRegister = registers[0];
|
|
byte[] highRegisterBytes = BitConverter.GetBytes(highRegister);
|
|
byte[] lowRegisterBytes = BitConverter.GetBytes(lowRegister);
|
|
byte[] floatBytes = {
|
|
lowRegisterBytes[0],
|
|
lowRegisterBytes[1],
|
|
highRegisterBytes[0],
|
|
highRegisterBytes[1]
|
|
};
|
|
return BitConverter.ToSingle(floatBytes, 0);
|
|
}
|
|
|
|
public static ushort[] ConvertFloatToRegisters(float floatValue)
|
|
{
|
|
byte[] floatBytes = BitConverter.GetBytes(floatValue);
|
|
byte[] highRegisterBytes = { floatBytes[2], floatBytes[3] };
|
|
byte[] lowRegisterBytes = { floatBytes[0], floatBytes[1] };
|
|
ushort[] returnValue = { BitConverter.ToUInt16(lowRegisterBytes, 0), BitConverter.ToUInt16(highRegisterBytes, 0) };
|
|
return returnValue;
|
|
}
|
|
#endregion
|
|
|
|
#region PLC寄存器与INT64数据转换
|
|
public static long ConvertRegistersToLong(ushort[] registers)
|
|
{
|
|
if (registers.Length != 4)
|
|
throw new ArgumentException("Input Array length invalid - Array langth must be '4'");
|
|
ushort highRegister = registers[3];
|
|
ushort highLowRegister = registers[2];
|
|
ushort lowHighRegister = registers[1];
|
|
ushort lowRegister = registers[0];
|
|
byte[] highRegisterBytes = BitConverter.GetBytes(highRegister);
|
|
byte[] highLowRegisterBytes = BitConverter.GetBytes(highLowRegister);
|
|
byte[] lowHighRegisterBytes = BitConverter.GetBytes(lowHighRegister);
|
|
byte[] lowRegisterBytes = BitConverter.GetBytes(lowRegister);
|
|
byte[] longBytes = {
|
|
lowRegisterBytes[0],
|
|
lowRegisterBytes[1],
|
|
lowHighRegisterBytes[0],
|
|
lowHighRegisterBytes[1],
|
|
highLowRegisterBytes[0],
|
|
highLowRegisterBytes[1],
|
|
highRegisterBytes[0],
|
|
highRegisterBytes[1]
|
|
};
|
|
return BitConverter.ToInt64(longBytes, 0);
|
|
}
|
|
public static ushort[] ConvertLongToRegisters(long longValue)
|
|
{
|
|
byte[] longBytes = BitConverter.GetBytes(longValue);
|
|
byte[] highRegisterBytes = { longBytes[6], longBytes[7] };
|
|
byte[] highLowRegisterBytes = { longBytes[4], longBytes[5] };
|
|
byte[] lowHighRegisterBytes = { longBytes[2], longBytes[3] };
|
|
byte[] lowRegisterBytes = { longBytes[0], longBytes[1] };
|
|
ushort[] returnValue =
|
|
{
|
|
BitConverter.ToUInt16(lowRegisterBytes,0),
|
|
BitConverter.ToUInt16(lowHighRegisterBytes,0),
|
|
BitConverter.ToUInt16(highLowRegisterBytes,0),
|
|
BitConverter.ToUInt16(highRegisterBytes,0)
|
|
};
|
|
return returnValue;
|
|
}
|
|
#endregion
|
|
|
|
#region PLC寄存器与INT32数据转换
|
|
public static int ConvertRegistersToInt(ushort[] registers)
|
|
{
|
|
if (registers.Length != 2)
|
|
throw new ArgumentException("Input Array length invalid - Array langth must be '2'");
|
|
ushort highRegister = registers[1];
|
|
ushort lowRegister = registers[0];
|
|
byte[] highRegisterBytes = BitConverter.GetBytes(highRegister);
|
|
byte[] lowRegisterBytes = BitConverter.GetBytes(lowRegister);
|
|
byte[] doubleBytes = {
|
|
lowRegisterBytes[0],
|
|
lowRegisterBytes[1],
|
|
highRegisterBytes[0],
|
|
highRegisterBytes[1]
|
|
};
|
|
return BitConverter.ToInt32(doubleBytes, 0);
|
|
}
|
|
|
|
public static ushort[] ConvertIntToRegisters(int intValue)
|
|
{
|
|
byte[] doubleBytes = BitConverter.GetBytes(intValue);
|
|
byte[] highRegisterBytes = { doubleBytes[2], doubleBytes[3] };
|
|
byte[] lowRegisterBytes = { doubleBytes[0], doubleBytes[1] };
|
|
ushort[] returnValue = { BitConverter.ToUInt16(lowRegisterBytes, 0), BitConverter.ToUInt16(highRegisterBytes, 0) };
|
|
return returnValue;
|
|
}
|
|
#endregion
|
|
#endregion
|
|
|
|
|
|
private void Master_OnRecived(byte[] bytes, string hexString)
|
|
{
|
|
OnRecived?.Invoke(bytes, hexString);
|
|
}
|
|
|
|
private void Master_OnSended(byte[] bytes, string hexString)
|
|
{
|
|
OnSended?.Invoke(bytes, hexString);
|
|
}
|
|
}
|
|
}
|