luosheng/Modbus.Net
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2017-05-17 Update 3 Implement log system and add comments

Browse Source
This commit is contained in:
parallelbgls
2017-05-17 18:01:30 +08:00
parent 3c6f18dc69
commit ba56c5be1b
34 changed files with 987 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
Modbus.Net/Modbus.Net.Modbus/AddressFormaterModbus.cs
View File

@@ -5,11 +5,24 @@
/// </summary>
public class AddressFormaterNA200H : AddressFormater
{
/// <summary>
/// 格式化地址
/// </summary>
/// <param name="area">地址区域</param>
/// <param name="address">地址</param>
/// <returns>格式化的地址字符串</returns>
public override string FormatAddress(string area, int address)
{
return area + " " + address;
}
/// <summary>
/// 格式化地址
/// </summary>
/// <param name="area">地址区域</param>
/// <param name="address">地址</param>
/// <param name="subAddress">比特位地址</param>
/// <returns>格式化的地址字符串</returns>
public override string FormatAddress(string area, int address, int subAddress)
{
return area + " " + address + "." + subAddress;
@@ -21,11 +34,24 @@
/// </summary>
public class AddressFormaterModbus : AddressFormater
{
/// <summary>
/// 格式化地址
/// </summary>
/// <param name="area">地址区域</param>
/// <param name="address">地址</param>
/// <returns>格式化的地址字符串</returns>
public override string FormatAddress(string area, int address)
{
return area + " " + address;
}
/// <summary>
/// 格式化地址
/// </summary>
/// <param name="area">地址区域</param>
/// <param name="address">地址</param>
/// <param name="subAddress">比特位地址</param>
/// <returns>格式化的地址字符串</returns>
public override string FormatAddress(string area, int address, int subAddress)
{
return area + " " + address + "." + subAddress;

28
Modbus.Net/Modbus.Net.Modbus/AddressTranslatorModbus.cs
View File

@@ -23,6 +23,9 @@ namespace Modbus.Net.Modbus
/// </summary>
protected Dictionary<string, AreaOutputDef> WriteFunctionCodeDictionary;
/// <summary>
/// 构造器
/// </summary>
public AddressTranslatorNA200H()
{
TransDictionary = new Dictionary<string, int>
@@ -154,6 +157,12 @@ namespace Modbus.Net.Modbus
};
}
/// <summary>
/// 地址转换
/// </summary>
/// <param name="address">格式化的地址</param>
/// <param name="isRead">是否为读取，是为读取，否为写入</param>
/// <returns>翻译后的地址</returns>
public override AddressDef AddressTranslate(string address, bool isRead)
{
address = address.ToUpper();
@@ -188,6 +197,11 @@ namespace Modbus.Net.Modbus
};
}
/// <summary>
/// 获取区域中的单个地址占用的字节长度
/// </summary>
/// <param name="area">区域名称</param>
/// <returns>字节长度</returns>
public override double GetAreaByteLength(string area)
{
return ReadFunctionCodeDictionary[area].AreaWidth;
@@ -209,6 +223,9 @@ namespace Modbus.Net.Modbus
/// </summary>
protected Dictionary<string, AreaOutputDef> WriteFunctionCodeDictionary;
/// <summary>
/// 构造器
/// </summary>
public AddressTranslatorModbus()
{
ReadFunctionCodeDictionary = new Dictionary<string, AreaOutputDef>
@@ -259,6 +276,12 @@ namespace Modbus.Net.Modbus
};
}
/// <summary>
/// 地址转换
/// </summary>
/// <param name="address">格式化的地址</param>
/// <param name="isRead">是否为读取，是为读取，否为写入</param>
/// <returns>翻译后的地址</returns>
public override AddressDef AddressTranslate(string address, bool isRead)
{
address = address.ToUpper();
@@ -293,6 +316,11 @@ namespace Modbus.Net.Modbus
};
}
/// <summary>
/// 获取区域中的单个地址占用的字节长度
/// </summary>
/// <param name="area">区域名称</param>
/// <returns>字节长度</returns>
public override double GetAreaByteLength(string area)
{
return ReadFunctionCodeDictionary[area].AreaWidth;

13
Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocal.cs
View File

@@ -7,11 +7,24 @@ namespace Modbus.Net.Modbus
/// </summary>
public class ModbusAsciiProtocal : ModbusProtocal
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusAsciiProtocal(byte slaveAddress, byte masterAddress, Endian endian)
: this(ConfigurationManager.AppSettings["COM"], slaveAddress, masterAddress, endian)
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="com">串口地址</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusAsciiProtocal(string com, byte slaveAddress, byte masterAddress, Endian endian)
: base(slaveAddress, masterAddress, endian)
{

11
Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocalLinker.cs
View File

@@ -8,13 +8,24 @@ namespace Modbus.Net.Modbus
/// </summary>
public class ModbusAsciiProtocalLinker : ComProtocalLinker
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="com">串口地址</param>
/// <param name="slaveAddress">从站号</param>
public ModbusAsciiProtocalLinker(string com, int slaveAddress)
: base(com, 9600, Parity.None, StopBits.One, 8, slaveAddress)
{
}
/// <summary>
/// 校验返回数据是否正确
/// </summary>
/// <param name="content">返回的数据</param>
/// <returns>校验是否正确</returns>
public override bool? CheckRight(byte[] content)
{
//ProtocalLinker不会返回null
if (!base.CheckRight(content).Value) return false;
//CRC校验失败
var contentString = Encoding.ASCII.GetString(content);

38
Modbus.Net/Modbus.Net.Modbus/ModbusMachine.cs
View File

@@ -9,6 +9,16 @@ namespace Modbus.Net.Modbus
public class ModbusMachine<TKey, TUnitKey> : BaseMachine<TKey, TUnitKey> where TKey : IEquatable<TKey>
where TUnitKey : IEquatable<TUnitKey>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionType">连接类型</param>
/// <param name="connectionString">连接地址</param>
/// <param name="getAddresses">读写的地址</param>
/// <param name="keepConnect">是否保持连接</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusMachine(ModbusType connectionType, string connectionString,
IEnumerable<AddressUnit<TUnitKey>> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress,
Endian endian = Endian.BigEndianLsb)
@@ -20,6 +30,15 @@ namespace Modbus.Net.Modbus
AddressCombinerSet = new AddressCombinerContinus<TUnitKey>(AddressTranslator, 100);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionType">连接类型</param>
/// <param name="connectionString">连接地址</param>
/// <param name="getAddresses">读写的地址</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusMachine(ModbusType connectionType, string connectionString,
IEnumerable<AddressUnit<TUnitKey>> getAddresses, byte slaveAddress, byte masterAddress,
Endian endian = Endian.BigEndianLsb)
@@ -33,6 +52,16 @@ namespace Modbus.Net.Modbus
/// </summary>
public class ModbusMachine : BaseMachine
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionType">连接类型</param>
/// <param name="connectionString">连接地址</param>
/// <param name="getAddresses">读写的地址</param>
/// <param name="keepConnect">是否保持连接</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusMachine(ModbusType connectionType, string connectionString,
IEnumerable<AddressUnit> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress,
Endian endian = Endian.BigEndianLsb)
@@ -44,6 +73,15 @@ namespace Modbus.Net.Modbus
AddressCombinerSet = new AddressCombinerContinus(AddressTranslator, 100);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionType">连接类型</param>
/// <param name="connectionString">连接地址</param>
/// <param name="getAddresses">读写的地址</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusMachine(ModbusType connectionType, string connectionString,
IEnumerable<AddressUnit> getAddresses, byte slaveAddress, byte masterAddress,
Endian endian = Endian.BigEndianLsb)

328
Modbus.Net/Modbus.Net.Modbus/ModbusProtocal.cs
View File

@@ -9,7 +9,14 @@ namespace Modbus.Net.Modbus
/// </summary>
internal enum ModbusProtocalVariableFunctionCode : byte
{
/// <summary>
/// 读变量
/// </summary>
ReadVariable = 20,
/// <summary>
/// 写变量
/// </summary>
WriteVariable = 21
}
@@ -18,7 +25,14 @@ namespace Modbus.Net.Modbus
/// </summary>
public enum ModbusProtocalTimeFunctionCode : byte
{
/// <summary>
/// 读时间
/// </summary>
GetSystemTime = 3,
/// <summary>
/// 写时间
/// </summary>
SetSystemTime = 16
}
@@ -27,9 +41,24 @@ namespace Modbus.Net.Modbus
/// </summary>
public enum ModbusProtocalReadDataFunctionCode : byte
{
/// <summary>
/// 读线圈
/// </summary>
ReadCoilStatus = 1,
/// <summary>
/// 读输入线圈
/// </summary>
ReadInputStatus = 2,
/// <summary>
/// 读保持寄存器
/// </summary>
ReadHoldRegister = 3,
/// <summary>
/// 读输入寄存器
/// </summary>
ReadInputRegister = 4
}
@@ -38,7 +67,24 @@ namespace Modbus.Net.Modbus
/// </summary>
internal enum ModbusProtocalWriteDataFunctionCode : byte
{
/// <summary>
/// 写单个线圈
/// </summary>
WriteSingleCoil = 5,
/// <summary>
/// 写单个寄存器
/// </summary>
WriteSingleRegister = 6,
/// <summary>
/// 写多个线圈
/// </summary>
WriteMultiCoil = 15,
/// <summary>
/// 写多个寄存器
/// </summary>
WriteMultiRegister = 16
}
@@ -47,16 +93,30 @@ namespace Modbus.Net.Modbus
/// </summary>
public abstract class ModbusProtocal : BaseProtocal
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站地址</param>
/// <param name="masterAddress">主站地址</param>
/// <param name="endian">端格式</param>
protected ModbusProtocal(byte slaveAddress, byte masterAddress, Endian endian)
: base(slaveAddress, masterAddress, endian)
{
}
/// <summary>
/// 连接
/// </summary>
/// <returns>是否连接成功</returns>
public override bool Connect()
{
return ProtocalLinker.Connect();
}
/// <summary>
/// 连接
/// </summary>
/// <returns>是否连接成功</returns>
public override async Task<bool> ConnectAsync()
{
return await ProtocalLinker.ConnectAsync();
@@ -65,8 +125,18 @@ namespace Modbus.Net.Modbus
#region 读PLC数据
/// <summary>
/// 读数据输入
/// </summary>
public class ReadDataModbusInputStruct : IInputStruct
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站地址</param>
/// <param name="startAddress">开始地址</param>
/// <param name="getCount">读取个数</param>
/// <param name="addressTranslator">地址翻译器</param>
public ReadDataModbusInputStruct(byte slaveAddress, string startAddress, ushort getCount,
AddressTranslator addressTranslator)
{
@@ -78,17 +148,39 @@ namespace Modbus.Net.Modbus
(ushort) Math.Ceiling(getCount / addressTranslator.GetAreaByteLength(translateAddress.AreaString));
}
/// <summary>
/// 从站地址
/// </summary>
public byte SlaveAddress { get; }
/// <summary>
/// 功能码
/// </summary>
public byte FunctionCode { get; }
/// <summary>
/// 开始地址
/// </summary>
public ushort StartAddress { get; }
/// <summary>
/// 获取个数
/// </summary>
public ushort GetCount { get; }
}
/// <summary>
/// 读数据输出
/// </summary>
public class ReadDataModbusOutputStruct : IOutputStruct
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站号</param>
/// <param name="functionCode">功能码</param>
/// <param name="dataCount">数据个数</param>
/// <param name="dataValue">读取的数据值</param>
public ReadDataModbusOutputStruct(byte slaveAddress, byte functionCode,
int dataCount, byte[] dataValue)
{
@@ -98,17 +190,37 @@ namespace Modbus.Net.Modbus
DataValue = dataValue.Clone() as byte[];
}
/// <summary>
/// 从站号
/// </summary>
public byte SlaveAddress { get; private set; }
/// <summary>
/// 功能码
/// </summary>
public byte FunctionCode { get; private set; }
/// <summary>
/// 数据个数
/// </summary>
public int DataCount { get; private set; }
/// <summary>
/// 数据值
/// </summary>
public byte[] DataValue { get; private set; }
}
/// <summary>
/// 读数据协议
/// </summary>
public class ReadDataModbusProtocal : ProtocalUnit
{
/// <summary>
/// 格式化
/// </summary>
/// <param name="message">读取参数</param>
/// <returns>读取数据的协议核心</returns>
public override byte[] Format(IInputStruct message)
{
var r_message = (ReadDataModbusInputStruct) message;
@@ -116,6 +228,12 @@ namespace Modbus.Net.Modbus
r_message.StartAddress, r_message.GetCount);
}
/// <summary>
/// 反格式化
/// </summary>
/// <param name="messageBytes">设备返回的信息</param>
/// <param name="pos">当前反格式化的位置</param>
/// <returns>反格式化的信息</returns>
public override IOutputStruct Unformat(byte[] messageBytes, ref int pos)
{
var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref pos);
@@ -131,8 +249,19 @@ namespace Modbus.Net.Modbus
#region 写PLC数据
/// <summary>
/// 写数据输入
/// </summary>
public class WriteDataModbusInputStruct : IInputStruct
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站号</param>
/// <param name="startAddress">开始地址</param>
/// <param name="writeValue">写入的数据</param>
/// <param name="addressTranslator">地址翻译器</param>
/// <param name="endian">端格式</param>
public WriteDataModbusInputStruct(byte slaveAddress, string startAddress, object[] writeValue,
AddressTranslator addressTranslator, Endian endian)
{
@@ -147,21 +276,49 @@ namespace Modbus.Net.Modbus
WriteValue = writeByteValue;
}
/// <summary>
/// 从站号
/// </summary>
public byte SlaveAddress { get; }
/// <summary>
/// 功能码
/// </summary>
public byte FunctionCode { get; }
/// <summary>
/// 开始地址
/// </summary>
public ushort StartAddress { get; }
/// <summary>
/// 写入个数
/// </summary>
public ushort WriteCount { get; }
/// <summary>
/// 写入字节个数
/// </summary>
public byte WriteByteCount { get; }
/// <summary>
/// 写入的数据
/// </summary>
public byte[] WriteValue { get; }
}
/// <summary>
/// 写数据输出
/// </summary>
public class WriteDataModbusOutputStruct : IOutputStruct
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站号</param>
/// <param name="functionCode">功能码</param>
/// <param name="startAddress">开始地址</param>
/// <param name="writeCount">写入个数</param>
public WriteDataModbusOutputStruct(byte slaveAddress, byte functionCode,
ushort startAddress, ushort writeCount)
{
@@ -171,20 +328,37 @@ namespace Modbus.Net.Modbus
WriteCount = writeCount;
}
/// <summary>
/// 从站号
/// </summary>
public byte SlaveAddress { get; private set; }
/// <summary>
/// 功能码
/// </summary>
public byte FunctionCode { get; private set; }
/// <summary>
/// 开始地址
/// </summary>
public ushort StartAddress { get; private set; }
/// <summary>
/// 写入个数
/// </summary>
public ushort WriteCount { get; private set; }
}
/// <summary>
/// 写多个寄存器状态
/// 写多个寄存器协议
/// </summary>
public class WriteDataModbusProtocal : ProtocalUnit
{
/// <summary>
/// 格式化
/// </summary>
/// <param name="message">写寄存器参数</param>
/// <returns>写寄存器协议核心</returns>
public override byte[] Format(IInputStruct message)
{
var r_message = (WriteDataModbusInputStruct) message;
@@ -194,6 +368,12 @@ namespace Modbus.Net.Modbus
return formattingBytes;
}
/// <summary>
/// 反格式化
/// </summary>
/// <param name="messageBytes">设备返回的信息</param>
/// <param name="flag">当前反格式化的位置</param>
/// <returns>反格式化的信息</returns>
public override IOutputStruct Unformat(byte[] messageBytes, ref int flag)
{
var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag);
@@ -209,8 +389,15 @@ namespace Modbus.Net.Modbus
#region 读PLC时间
/// <summary>
/// 读时间输入
/// </summary>
public class GetSystemTimeModbusInputStruct : IInputStruct
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站号</param>
public GetSystemTimeModbusInputStruct(byte slaveAddress)
{
SlaveAddress = slaveAddress;
@@ -219,17 +406,45 @@ namespace Modbus.Net.Modbus
GetCount = 5;
}
/// <summary>
/// 从站号
/// </summary>
public byte SlaveAddress { get; }
/// <summary>
/// 功能码
/// </summary>
public byte FunctionCode { get; }
/// <summary>
/// 开始地址
/// </summary>
public ushort StartAddress { get; }
/// <summary>
/// 获取个数
/// </summary>
public ushort GetCount { get; }
}
/// <summary>
/// 读时间输出
/// </summary>
public class GetSystemTimeModbusOutputStruct : IOutputStruct
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站号</param>
/// <param name="functionCode">功能码</param>
/// <param name="writeByteCount">写入个数</param>
/// <param name="year">年</param>
/// <param name="day">日</param>
/// <param name="month">月</param>
/// <param name="hour">时</param>
/// <param name="second">秒</param>
/// <param name="minute">分</param>
/// <param name="millisecond">毫秒</param>
public GetSystemTimeModbusOutputStruct(byte slaveAddress, byte functionCode,
byte writeByteCount, ushort year, byte day, byte month, ushort hour, byte second, byte minute,
ushort millisecond)
@@ -240,20 +455,37 @@ namespace Modbus.Net.Modbus
Time = new DateTime(year, month, day, hour, minute, second, millisecond);
}
/// <summary>
/// 从站号
/// </summary>
public byte SlaveAddress { get; private set; }
/// <summary>
/// 功能码
/// </summary>
public byte FunctionCode { get; private set; }
/// <summary>
/// 写入个数
/// </summary>
public byte WriteByteCount { get; private set; }
/// <summary>
/// 时间
/// </summary>
public DateTime Time { get; private set; }
}
/// <summary>
/// 读系统时间
/// 读系统时间协议
/// </summary>
public class GetSystemTimeModbusProtocal : ProtocalUnit
{
/// <summary>
/// 格式化
/// </summary>
/// <param name="message">写系统时间参数</param>
/// <returns>写系统时间的核心</returns>
public override byte[] Format(IInputStruct message)
{
var r_message = (GetSystemTimeModbusInputStruct) message;
@@ -261,6 +493,12 @@ namespace Modbus.Net.Modbus
r_message.StartAddress, r_message.GetCount);
}
/// <summary>
/// 反格式化
/// </summary>
/// <param name="messageBytes">获取的信息</param>
/// <param name="flag">当前反格式化的位置</param>
/// <returns>反格式化的信息</returns>
public override IOutputStruct Unformat(byte[] messageBytes, ref int flag)
{
var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag);
@@ -282,8 +520,16 @@ namespace Modbus.Net.Modbus
#region 写PLC时间
/// <summary>
/// 写时间输入
/// </summary>
public class SetSystemTimeModbusInputStruct : IInputStruct
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站号</param>
/// <param name="time">时间</param>
public SetSystemTimeModbusInputStruct(byte slaveAddress, DateTime time)
{
SlaveAddress = slaveAddress;
@@ -300,33 +546,79 @@ namespace Modbus.Net.Modbus
Millisecond = (ushort) time.Millisecond;
}
/// <summary>
/// 从站号
/// </summary>
public byte SlaveAddress { get; }
/// <summary>
/// 功能码
/// </summary>
public byte FunctionCode { get; }
/// <summary>
/// 开始地址
/// </summary>
public ushort StartAddress { get; }
/// <summary>
/// 写入个数
/// </summary>
public ushort WriteCount { get; }
/// <summary>
/// 写入字节个数
/// </summary>
public byte WriteByteCount { get; }
/// <summary>
/// 年
/// </summary>
public ushort Year { get; }
/// <summary>
/// 日
/// </summary>
public byte Day { get; }
/// <summary>
/// 月
/// </summary>
public byte Month { get; }
/// <summary>
/// 时
/// </summary>
public ushort Hour { get; }
/// <summary>
/// 秒
/// </summary>
public byte Second { get; }
/// <summary>
/// 分
/// </summary>
public byte Minute { get; }
/// <summary>
/// 毫秒
/// </summary>
public ushort Millisecond { get; }
}
/// <summary>
/// 写时间输出
/// </summary>
public class SetSystemTimeModbusOutputStruct : IOutputStruct
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站号</param>
/// <param name="functionCode">功能码</param>
/// <param name="startAddress">开始地址</param>
/// <param name="writeCount">写入个数</param>
public SetSystemTimeModbusOutputStruct(byte slaveAddress, byte functionCode,
ushort startAddress, ushort writeCount)
{
@@ -336,20 +628,37 @@ namespace Modbus.Net.Modbus
WriteCount = writeCount;
}
/// <summary>
/// 从站号
/// </summary>
public byte SlaveAddress { get; private set; }
/// <summary>
/// 功能码
/// </summary>
public byte FunctionCode { get; private set; }
/// <summary>
/// 开始地址
/// </summary>
public ushort StartAddress { get; private set; }
/// <summary>
/// 写入个数
/// </summary>
public ushort WriteCount { get; private set; }
}
/// <summary>
/// 写系统时间
/// 写系统时间协议
/// </summary>
public class SetSystemTimeModbusProtocal : ProtocalUnit
{
/// <summary>
/// 格式化
/// </summary>
/// <param name="message">写系统时间的参数</param>
/// <returns>写系统时间的核心</returns>
public override byte[] Format(IInputStruct message)
{
var r_message = (SetSystemTimeModbusInputStruct) message;
@@ -359,6 +668,12 @@ namespace Modbus.Net.Modbus
r_message.Month, r_message.Hour, r_message.Second, r_message.Minute, r_message.Millisecond);
}
/// <summary>
/// 反格式化
/// </summary>
/// <param name="messageBytes">获取的信息</param>
/// <param name="flag">当前反格式化的位置</param>
/// <returns>反格式化的信息</returns>
public override IOutputStruct Unformat(byte[] messageBytes, ref int flag)
{
var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag);
@@ -388,12 +703,19 @@ namespace Modbus.Net.Modbus
{501, "RTU_ILLEGAL_CRC"}
};
/// <summary>
/// Modbus错误
/// </summary>
/// <param name="messageNumber">Modbus错误号</param>
public ModbusProtocalErrorException(int messageNumber)
: base(ProtocalErrorDictionary[messageNumber])
{
ErrorMessageNumber = messageNumber;
}
/// <summary>
/// Modbus错误号
/// </summary>
public int ErrorMessageNumber { get; private set; }
}
}

36
Modbus.Net/Modbus.Net.Modbus/ModbusProtocalLinkerBytesExtend.cs
View File

@@ -10,6 +10,11 @@ namespace Modbus.Net.Modbus
/// </summary>
public class ModbusTcpProtocalLinkerBytesExtend : IProtocalLinkerBytesExtend
{
/// <summary>
/// 协议扩展，协议内容发送前调用
/// </summary>
/// <param name="content">扩展前的原始协议内容</param>
/// <returns>扩展后的协议内容</returns>
public byte[] BytesExtend(byte[] content)
{
//Modbus/Tcp协议扩张，前面加6个字节，前面4个为0，后面两个为协议整体内容的长度
@@ -22,6 +27,11 @@ namespace Modbus.Net.Modbus
return newFormat;
}
/// <summary>
/// 协议收缩，协议内容接收后调用
/// </summary>
/// <param name="content">收缩前的完整协议内容</param>
/// <returns>收缩后的协议内容</returns>
public byte[] BytesDecact(byte[] content)
{
//Modbus/Tcp协议收缩，抛弃前面6个字节的内容
@@ -31,8 +41,16 @@ namespace Modbus.Net.Modbus
}
}
/// <summary>
/// Rtu协议字节伸缩
/// </summary>
public class ModbusRtuProtocalLinkerBytesExtend : IProtocalLinkerBytesExtend
{
/// <summary>
/// 协议扩展，协议内容发送前调用
/// </summary>
/// <param name="content">扩展前的原始协议内容</param>
/// <returns>扩展后的协议内容</returns>
public byte[] BytesExtend(byte[] content)
{
var crc = new byte[2];
@@ -44,6 +62,11 @@ namespace Modbus.Net.Modbus
return newFormat;
}
/// <summary>
/// 协议收缩，协议内容接收后调用
/// </summary>
/// <param name="content">收缩前的完整协议内容</param>
/// <returns>收缩后的协议内容</returns>
public byte[] BytesDecact(byte[] content)
{
//Modbus/Rtu协议收缩，抛弃后面2个字节的内容
@@ -53,8 +76,16 @@ namespace Modbus.Net.Modbus
}
}
/// <summary>
/// Ascii协议字节伸缩
/// </summary>
public class ModbusAsciiProtocalLinkerBytesExtend : IProtocalLinkerBytesExtend
{
/// <summary>
/// 协议扩展，协议内容发送前调用
/// </summary>
/// <param name="content">扩展前的原始协议内容</param>
/// <returns>扩展后的协议内容</returns>
public byte[] BytesExtend(byte[] content)
{
//Modbus/Ascii协议扩张，前面增加:，后面增加LRC校验和尾字符
@@ -68,6 +99,11 @@ namespace Modbus.Net.Modbus
return newContent.ToArray();
}
/// <summary>
/// 协议收缩，协议内容接收后调用
/// </summary>
/// <param name="content">收缩前的完整协议内容</param>
/// <returns>收缩后的协议内容</returns>
public byte[] BytesDecact(byte[] content)
{
//Modbus/Ascii协议收缩，抛弃头尾。

13
Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocal.cs
View File

@@ -7,11 +7,24 @@ namespace Modbus.Net.Modbus
/// </summary>
public class ModbusRtuProtocal : ModbusProtocal
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusRtuProtocal(byte slaveAddress, byte masterAddress, Endian endian)
: this(ConfigurationManager.AppSettings["COM"], slaveAddress, masterAddress, endian)
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="com">串口</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusRtuProtocal(string com, byte slaveAddress, byte masterAddress, Endian endian)
: base(slaveAddress, masterAddress, endian)
{

11
Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocalLinker.cs
View File

@@ -7,13 +7,24 @@ namespace Modbus.Net.Modbus
/// </summary>
public class ModbusRtuProtocalLinker : ComProtocalLinker
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="com">串口地址</param>
/// <param name="slaveAddress">从站号</param>
public ModbusRtuProtocalLinker(string com, int slaveAddress)
: base(com, 9600, Parity.None, StopBits.One, 8, slaveAddress)
{
}
/// <summary>
/// 校验返回数据
/// </summary>
/// <param name="content">设备返回的数据</param>
/// <returns>数据是否正确</returns>
public override bool? CheckRight(byte[] content)
{
//ProtocalLinker的CheckRight不会返回null
if (!base.CheckRight(content).Value) return false;
//CRC校验失败
if (!Crc16.GetInstance().CrcEfficacy(content))

21
Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocal.cs
View File

@@ -7,17 +7,38 @@ namespace Modbus.Net.Modbus
/// </summary>
public class ModbusTcpProtocal : ModbusProtocal
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusTcpProtocal(byte slaveAddress, byte masterAddress, Endian endian)
: this(ConfigurationManager.AppSettings["IP"], slaveAddress, masterAddress, endian)
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="ip">ip地址</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusTcpProtocal(string ip, byte slaveAddress, byte masterAddress, Endian endian)
: base(slaveAddress, masterAddress, endian)
{
ProtocalLinker = new ModbusTcpProtocalLinker(ip);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="ip">ip地址</param>
/// <param name="port">端口</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusTcpProtocal(string ip, int port, byte slaveAddress, byte masterAddress, Endian endian)
: base(slaveAddress, masterAddress, endian)
{

15
Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocalLinker.cs
View File

@@ -7,17 +7,32 @@ namespace Modbus.Net.Modbus
/// </summary>
public class ModbusTcpProtocalLinker : TcpProtocalLinker
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="ip">IP地址</param>
public ModbusTcpProtocalLinker(string ip)
: base(ip, int.Parse(ConfigurationManager.AppSettings["ModbusPort"] ?? "502"))
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="ip">IP地址</param>
/// <param name="port">端口</param>
public ModbusTcpProtocalLinker(string ip, int port) : base(ip, port)
{
}
/// <summary>
/// 校验返回数据
/// </summary>
/// <param name="content">设备返回的数据</param>
/// <returns>数据是否正确</returns>
public override bool? CheckRight(byte[] content)
{
//ProtocalLinker的CheckRight不会返回null
if (!base.CheckRight(content).Value) return false;
//长度校验失败
if (content[5] != content.Length - 6)

47
Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Threading.Tasks;
using Serilog;
namespace Modbus.Net.Modbus
{
@@ -34,6 +35,13 @@ namespace Modbus.Net.Modbus
/// </summary>
private ModbusType _modbusType;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionType">协议类型</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusUtility(int connectionType, byte slaveAddress, byte masterAddress,
Endian endian = Endian.BigEndianLsb)
: base(slaveAddress, masterAddress)
@@ -44,6 +52,14 @@ namespace Modbus.Net.Modbus
AddressTranslator = new AddressTranslatorModbus();
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionType">协议类型</param>
/// <param name="connectionString">连接地址</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
/// <param name="endian">端格式</param>
public ModbusUtility(ModbusType connectionType, string connectionString, byte slaveAddress, byte masterAddress,
Endian endian = Endian.BigEndianLsb)
: base(slaveAddress, masterAddress)
@@ -54,8 +70,14 @@ namespace Modbus.Net.Modbus
AddressTranslator = new AddressTranslatorModbus();
}
/// <summary>
/// 端格式
/// </summary>
public override Endian Endian { get; }
/// <summary>
/// Ip地址
/// </summary>
protected string ConnectionStringIp
{
get
@@ -65,6 +87,9 @@ namespace Modbus.Net.Modbus
}
}
/// <summary>
/// 端口
/// </summary>
protected int? ConnectionStringPort
{
get
@@ -76,13 +101,17 @@ namespace Modbus.Net.Modbus
{
return connectionStringSplit.Length < 2 ? (int?) null : int.Parse(connectionStringSplit[1]);
}
catch
catch (Exception e)
{
Log.Error(e, $"ModbusUtility: {ConnectionString} format error");
return null;
}
}
}
/// <summary>
/// 协议类型
/// </summary>
public ModbusType ModbusType
{
get { return _modbusType; }
@@ -136,8 +165,9 @@ namespace Modbus.Net.Modbus
Wrapper[typeof(GetSystemTimeModbusProtocal)], inputStruct);
return outputStruct?.Time ?? DateTime.MinValue;
}
catch (Exception)
catch (Exception e)
{
Log.Error(e, $"ModbusUtility -> GetTime: {ConnectionString} error");
return DateTime.MinValue;
}
}
@@ -157,12 +187,17 @@ namespace Modbus.Net.Modbus
Wrapper[typeof(SetSystemTimeModbusProtocal)], inputStruct);
return outputStruct?.WriteCount > 0;
}
catch (Exception)
catch (Exception e)
{
Log.Error(e, $"ModbusUtility -> SetTime: {ConnectionString} error");
return false;
}
}
/// <summary>
/// 设置协议类型
/// </summary>
/// <param name="connectionType">协议类型</param>
public override void SetConnectionType(int connectionType)
{
ModbusType = (ModbusType) connectionType;
@@ -185,8 +220,9 @@ namespace Modbus.Net.Modbus
inputStruct);
return outputStruct?.DataValue;
}
catch
catch (Exception e)
{
Log.Error(e, $"ModbusUtility -> GetDatas: {ConnectionString} error");
return null;
}
}
@@ -208,8 +244,9 @@ namespace Modbus.Net.Modbus
inputStruct);
return outputStruct?.WriteCount == setContents.Length;
}
catch
catch (Exception e)
{
Log.Error(e, $"ModbusUtility -> SetDatas: {ConnectionString} error");
return false;
}
}

14
Modbus.Net/Modbus.Net.OPC/OpcConnector.cs
View File

@@ -5,6 +5,7 @@ using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Hylasoft.Opc.Common;
using Serilog;
namespace Modbus.Net.OPC
{
@@ -28,12 +29,12 @@ namespace Modbus.Net.OPC
Client?.Dispose();
Client = null;
_connect = false;
AddInfo("client disconnected successfully.");
Log.Information("opc client {ConnectionToken} disconnected success", ConnectionToken);
return true;
}
catch (Exception ex)
{
AddInfo("client disconnected exception: " + ex.Message);
Log.Error(ex, "opc client {ConnectionToken} disconnected error", ConnectionToken);
_connect = false;
return false;
}
@@ -125,7 +126,7 @@ namespace Modbus.Net.OPC
}
catch (Exception e)
{
AddInfo("opc write exception:" + e.Message);
Log.Error(e, "opc client {ConnectionToken} write exception", ConnectionToken);
return new OpcParamOut
{
Success = false
@@ -144,7 +145,7 @@ namespace Modbus.Net.OPC
}
catch (Exception e)
{
AddInfo("opc client exception:" + e.Message);
Log.Error(e, "opc client {ConnectionToken} read exception", ConnectionToken);
return new OpcParamOut
{
Success = false,
@@ -180,13 +181,12 @@ namespace Modbus.Net.OPC
{
Client.Connect();
_connect = true;
AddInfo("client connected.");
Log.Information("opc client {ConnectionToken} connect success", ConnectionToken);
return true;
}
catch (Exception ex)
{
AddInfo("client connected exception: " + ex.Message);
AddInfo("connect failed.");
Log.Error(ex, "opc client {ConnectionToken} connected failed", ConnectionToken);
_connect = false;
return false;
}

5
Modbus.Net/Modbus.Net.OPC/OpcUtility.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Threading.Tasks;
using Serilog;
namespace Modbus.Net.OPC
{
@@ -34,8 +35,9 @@ namespace Modbus.Net.OPC
readRequestOpcInputStruct);
return readRequestOpcOutputStruct?.GetValue;
}
catch (Exception)
catch (Exception e)
{
Log.Error(e, $"OpcUtility -> GetDatas: {ConnectionString} error");
return null;
}
}
@@ -54,6 +56,7 @@ namespace Modbus.Net.OPC
}
catch (Exception e)
{
Log.Error(e, $"OpcUtility -> SetDatas: {ConnectionString} error");
return false;
}
}

26
Modbus.Net/Modbus.Net.Siemens/AddressFormaterSiemens.cs
View File

@@ -5,11 +5,24 @@
/// </summary>
public class AddressFormaterSiemens : AddressFormater
{
/// <summary>
/// 编码地址
/// </summary>
/// <param name="area">地址所在的数据区域</param>
/// <param name="address">地址</param>
/// <returns>编码后的地址</returns>
public override string FormatAddress(string area, int address)
{
return area + " " + address;
}
/// <summary>
/// 编码地址
/// </summary>
/// <param name="area">地址所在的数据区域</param>
/// <param name="address">地址</param>
/// <param name="subAddress">子地址</param>
/// <returns>编码后的地址</returns>
public override string FormatAddress(string area, int address, int subAddress)
{
return area + " " + address + "." + subAddress;
@@ -21,6 +34,12 @@
/// </summary>
public class AddressFormaterSimenseStandard : AddressFormater
{
/// <summary>
/// 编码地址
/// </summary>
/// <param name="area">地址所在的数据区域</param>
/// <param name="address">地址</param>
/// <returns>编码后的地址</returns>
public override string FormatAddress(string area, int address)
{
if (area.Length > 1 &&
@@ -29,6 +48,13 @@
return area.ToUpper() + address;
}
/// <summary>
/// 编码地址
/// </summary>
/// <param name="area">地址所在的数据区域</param>
/// <param name="address">地址</param>
/// <param name="subAddress">子地址</param>
/// <returns>编码后的地址</returns>
public override string FormatAddress(string area, int address, int subAddress)
{
if (area.Length > 1 &&

34
Modbus.Net/Modbus.Net.Siemens/AddressTranslatorSiemens.cs
View File

@@ -9,8 +9,14 @@ namespace Modbus.Net.Siemens
/// </summary>
public class AddressTranslatorSiemens : AddressTranslator
{
/// <summary>
/// 区域的翻译字典
/// </summary>
protected Dictionary<string, int> AreaCodeDictionary;
/// <summary>
/// 构造函数
/// </summary>
public AddressTranslatorSiemens()
{
AreaCodeDictionary = new Dictionary<string, int>
@@ -30,6 +36,12 @@ namespace Modbus.Net.Siemens
};
}
/// <summary>
/// 地址转换
/// </summary>
/// <param name="address">格式化的地址</param>
/// <param name="isRead">是否为读取，是为读取，否为写入</param>
/// <returns>翻译后的地址</returns>
public override AddressDef AddressTranslate(string address, bool isRead)
{
address = address.ToUpper();
@@ -68,6 +80,11 @@ namespace Modbus.Net.Siemens
};
}
/// <summary>
/// 获取区域中的单个地址占用的字节长度
/// </summary>
/// <param name="area">区域名称</param>
/// <returns>字节长度</returns>
public override double GetAreaByteLength(string area)
{
return 1;
@@ -79,8 +96,14 @@ namespace Modbus.Net.Siemens
/// </summary>
public class AddressTranslatorSimenseStandard : AddressTranslator
{
/// <summary>
/// 区域的翻译字典
/// </summary>
protected Dictionary<string, int> AreaCodeDictionary;
/// <summary>
/// 构造函数
/// </summary>
public AddressTranslatorSimenseStandard()
{
AreaCodeDictionary = new Dictionary<string, int>
@@ -100,6 +123,12 @@ namespace Modbus.Net.Siemens
};
}
/// <summary>
/// 地址转换
/// </summary>
/// <param name="address">格式化的地址</param>
/// <param name="isRead">是否为读取，是为读取，否为写入</param>
/// <returns>翻译后的地址</returns>
public override AddressDef AddressTranslate(string address, bool isRead)
{
address = address.ToUpper();
@@ -134,6 +163,11 @@ namespace Modbus.Net.Siemens
};
}
/// <summary>
/// 获取区域中的单个地址占用的字节长度
/// </summary>
/// <param name="area">区域名称</param>
/// <returns>字节长度</returns>
public override double GetAreaByteLength(string area)
{
return 1;

38
Modbus.Net/Modbus.Net.Siemens/SiemensMachine.cs
View File

@@ -9,6 +9,16 @@ namespace Modbus.Net.Siemens
public class SiemensMachine<TKey, TUnitKey> : BaseMachine<TKey, TUnitKey> where TKey : IEquatable<TKey>
where TUnitKey : IEquatable<TUnitKey>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionType">连接类型</param>
/// <param name="connectionString">连接地址</param>
/// <param name="model">设备类型</param>
/// <param name="getAddresses">读写的地址</param>
/// <param name="keepConnect">是否保持连接</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
public SiemensMachine(SiemensType connectionType, string connectionString, SiemensMachineModel model,
IEnumerable<AddressUnit<TUnitKey>> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress)
: base(getAddresses, keepConnect, slaveAddress, masterAddress)
@@ -19,6 +29,15 @@ namespace Modbus.Net.Siemens
AddressCombinerSet = new AddressCombinerContinus<TUnitKey>(AddressTranslator, 100);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionType">连接类型</param>
/// <param name="connectionString">连接地址</param>
/// <param name="model">设备类型</param>
/// <param name="getAddresses">读写的地址</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
public SiemensMachine(SiemensType connectionType, string connectionString, SiemensMachineModel model,
IEnumerable<AddressUnit<TUnitKey>> getAddresses, byte slaveAddress, byte masterAddress)
: this(connectionType, connectionString, model, getAddresses, false, slaveAddress, masterAddress)
@@ -31,6 +50,16 @@ namespace Modbus.Net.Siemens
/// </summary>
public class SiemensMachine : BaseMachine
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionType">连接类型</param>
/// <param name="connectionString">连接地址</param>
/// <param name="model">设备类型</param>
/// <param name="getAddresses">读写的地址</param>
/// <param name="keepConnect">是否保持连接</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
public SiemensMachine(SiemensType connectionType, string connectionString, SiemensMachineModel model,
IEnumerable<AddressUnit> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress)
: base(getAddresses, keepConnect, slaveAddress, masterAddress)
@@ -41,6 +70,15 @@ namespace Modbus.Net.Siemens
AddressCombinerSet = new AddressCombinerContinus(AddressTranslator, 100);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionType">连接类型</param>
/// <param name="connectionString">连接地址</param>
/// <param name="model">设备类型</param>
/// <param name="getAddresses">读写的地址</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
public SiemensMachine(SiemensType connectionType, string connectionString, SiemensMachineModel model,
IEnumerable<AddressUnit> getAddresses, byte slaveAddress, byte masterAddress)
: this(connectionType, connectionString, model, getAddresses, false, slaveAddress, masterAddress)

37
Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocal.cs
View File

@@ -10,22 +10,43 @@ namespace Modbus.Net.Siemens
{
private readonly string _com;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
public SiemensPpiProtocal(byte slaveAddress, byte masterAddress)
: this(ConfigurationManager.AppSettings["COM"], slaveAddress, masterAddress)
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="com">串口地址</param>
/// <param name="slaveAddress">从站号</param>
/// <param name="masterAddress">主站号</param>
public SiemensPpiProtocal(string com, byte slaveAddress, byte masterAddress)
: base(slaveAddress, masterAddress)
{
_com = com;
}
/// <summary>
/// 发送协议内容并接收，一般方法
/// </summary>
/// <param name="content">写入的内容，使用对象数组描述</param>
/// <returns>从设备获取的字节流</returns>
public override byte[] SendReceive(params object[] content)
{
return AsyncHelper.RunSync(() => SendReceiveAsync(Endian, content));
}
/// <summary>
/// 发送协议内容并接收，一般方法
/// </summary>
/// <param name="content">写入的内容，使用对象数组描述</param>
/// <returns>从设备获取的字节流</returns>
public override async Task<byte[]> SendReceiveAsync(params object[] content)
{
if (ProtocalLinker == null || !ProtocalLinker.IsConnected)
@@ -33,16 +54,30 @@ namespace Modbus.Net.Siemens
return await base.SendReceiveAsync(Endian, content);
}
/// <summary>
/// 强行发送，不检测连接状态
/// </summary>
/// <param name="unit">协议核心</param>
/// <param name="content">协议的参数</param>
/// <returns>设备返回的信息</returns>
private async Task<IOutputStruct> ForceSendReceiveAsync(ProtocalUnit unit, IInputStruct content)
{
return await base.SendReceiveAsync(unit, content);
}
/// <summary>
/// 连接设备
/// </summary>
/// <returns>是否连接成功</returns>
public override bool Connect()
{
return AsyncHelper.RunSync(() => ConnectAsync());
return AsyncHelper.RunSync(ConnectAsync);
}
/// <summary>
/// 连接设备
/// </summary>
/// <returns>是否连接成功</returns>
public override async Task<bool> ConnectAsync()
{
ProtocalLinker = new SiemensPpiProtocalLinker(_com, SlaveAddress);

20
Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocalLinker.cs
View File

@@ -9,11 +9,21 @@ namespace Modbus.Net.Siemens
/// </summary>
public class SiemensPpiProtocalLinker : ComProtocalLinker
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="com">串口地址</param>
/// <param name="slaveAddress">从站号</param>
public SiemensPpiProtocalLinker(string com, int slaveAddress)
: base(com, 9600, Parity.Even, StopBits.One, 8, slaveAddress)
{
}
/// <summary>
/// 发送协议内容并接收返回
/// </summary>
/// <param name="content">发送的报文</param>
/// <returns>接收的报文</returns>
public override async Task<byte[]> SendReceiveAsync(byte[] content)
{
var extBytes = BytesExtend(content);
@@ -36,6 +46,11 @@ namespace Modbus.Net.Siemens
return BytesDecact(receiveBytes);
}
/// <summary>
/// 发送协议内容并接收返回，不进行协议扩展和收缩
/// </summary>
/// <param name="content">发送的报文</param>
/// <returns>接收的报文</returns>
public override async Task<byte[]> SendReceiveWithoutExtAndDecAsync(byte[] content)
{
var ans = await base.SendReceiveWithoutExtAndDecAsync(content);
@@ -60,6 +75,11 @@ namespace Modbus.Net.Siemens
return ans;
}
/// <summary>
/// 校验报文
/// </summary>
/// <param name="content">设备返回的信息</param>
/// <returns>报文是否正确</returns>
public override bool? CheckRight(byte[] content)
{
if (!base.CheckRight(content).Value) return false;

20
Modbus.Net/Modbus.Net.Siemens/SiemensProtocalLinkerBytesExtend.cs
View File

@@ -7,6 +7,11 @@ namespace Modbus.Net.Siemens
/// </summary>
public class SiemensTcpProtocalLinkerBytesExtend : IProtocalLinkerBytesExtend
{
/// <summary>
/// 协议扩展，协议内容发送前调用
/// </summary>
/// <param name="content">扩展前的原始协议内容</param>
/// <returns>扩展后的协议内容</returns>
public byte[] BytesExtend(byte[] content)
{
Array.Copy(new byte[] {0x03, 0x00, 0x00, 0x00, 0x02, 0xf0, 0x80}, 0, content, 0, 7);
@@ -14,6 +19,11 @@ namespace Modbus.Net.Siemens
return content;
}
/// <summary>
/// 协议收缩，协议内容接收后调用
/// </summary>
/// <param name="content">收缩前的完整协议内容</param>
/// <returns>收缩后的协议内容</returns>
public byte[] BytesDecact(byte[] content)
{
var newContent = new byte[content.Length - 7];
@@ -27,6 +37,11 @@ namespace Modbus.Net.Siemens
/// </summary>
public class SiemensPpiProtocalLinkerBytesExtend : IProtocalLinkerBytesExtend
{
/// <summary>
/// 协议扩展，协议内容发送前调用
/// </summary>
/// <param name="content">扩展前的原始协议内容</param>
/// <returns>扩展后的协议内容</returns>
public byte[] BytesExtend(byte[] content)
{
var newContent = new byte[content.Length + 2];
@@ -42,6 +57,11 @@ namespace Modbus.Net.Siemens
return newContent;
}
/// <summary>
/// 协议收缩，协议内容接收后调用
/// </summary>
/// <param name="content">收缩前的完整协议内容</param>
/// <returns>收缩后的协议内容</returns>
public byte[] BytesDecact(byte[] content)
{
var newContent = new byte[content.Length - 9];

66
Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocal.cs
View File

@@ -18,12 +18,31 @@ namespace Modbus.Net.Siemens
private readonly ushort _tsapDst;
private int _connectTryCount;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="tdpuSize"></param>
/// <param name="tsapSrc"></param>
/// <param name="tsapDst"></param>
/// <param name="maxCalling"></param>
/// <param name="maxCalled"></param>
/// <param name="maxPdu"></param>
public SiemensTcpProtocal(byte tdpuSize, ushort tsapSrc, ushort tsapDst, ushort maxCalling, ushort maxCalled,
ushort maxPdu)
: this(tdpuSize, tsapSrc, tsapDst, maxCalling, maxCalled, maxPdu, ConfigurationManager.AppSettings["IP"])
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="tdpuSize"></param>
/// <param name="tsapSrc"></param>
/// <param name="tsapDst"></param>
/// <param name="maxCalling"></param>
/// <param name="maxCalled"></param>
/// <param name="maxPdu"></param>
/// <param name="ip">IP地址</param>
public SiemensTcpProtocal(byte tdpuSize, ushort tsapSrc, ushort tsapDst, ushort maxCalling, ushort maxCalled,
ushort maxPdu, string ip)
: this(
@@ -32,6 +51,17 @@ namespace Modbus.Net.Siemens
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="tdpuSize"></param>
/// <param name="tsapSrc"></param>
/// <param name="tsapDst"></param>
/// <param name="maxCalling"></param>
/// <param name="maxCalled"></param>
/// <param name="maxPdu"></param>
/// <param name="ip">IP地址</param>
/// <param name="port">端口</param>
public SiemensTcpProtocal(byte tdpuSize, ushort tsapSrc, ushort tsapDst, ushort maxCalling, ushort maxCalled,
ushort maxPdu, string ip, int port) : base(0, 0)
{
@@ -46,11 +76,21 @@ namespace Modbus.Net.Siemens
_connectTryCount = 0;
}
/// <summary>
/// 发送数据并接收
/// </summary>
/// <param name="content">发送的数据</param>
/// <returns>返回的数据</returns>
public override byte[] SendReceive(params object[] content)
{
return AsyncHelper.RunSync(() => SendReceiveAsync(Endian, content));
}
/// <summary>
/// 发送数据并接收
/// </summary>
/// <param name="content">发送的数据</param>
/// <returns>返回的数据</returns>
public override async Task<byte[]> SendReceiveAsync(params object[] content)
{
if (ProtocalLinker == null || !ProtocalLinker.IsConnected)
@@ -58,11 +98,23 @@ namespace Modbus.Net.Siemens
return await base.SendReceiveAsync(Endian, content);
}
/// <summary>
/// 发送数据并接收
/// </summary>
/// <param name="unit">协议的核心</param>
/// <param name="content">协议的参数</param>
/// <returns>返回的数据</returns>
public override IOutputStruct SendReceive(ProtocalUnit unit, IInputStruct content)
{
return AsyncHelper.RunSync(() => SendReceiveAsync(unit, content));
}
/// <summary>
/// 发送数据并接收
/// </summary>
/// <param name="unit">发送的数据</param>
/// <param name="content">协议的参数</param>
/// <returns>返回的数据</returns>
public override async Task<IOutputStruct> SendReceiveAsync(ProtocalUnit unit, IInputStruct content)
{
if (ProtocalLinker != null && ProtocalLinker.IsConnected) return await base.SendReceiveAsync(unit, content);
@@ -74,16 +126,30 @@ namespace Modbus.Net.Siemens
.ContinueWith(answer => answer.Result ? base.SendReceiveAsync(unit, content) : null);
}
/// <summary>
/// 强制发送数据并接收
/// </summary>
/// <param name="unit">发送的数据</param>
/// <param name="content">协议的参数</param>
/// <returns>返回的数据</returns>
private async Task<IOutputStruct> ForceSendReceiveAsync(ProtocalUnit unit, IInputStruct content)
{
return await base.SendReceiveAsync(unit, content);
}
/// <summary>
/// 连接设备
/// </summary>
/// <returns>设备是否连接成功</returns>
public override bool Connect()
{
return AsyncHelper.RunSync(ConnectAsync);
}
/// <summary>
/// 连接设备
/// </summary>
/// <returns>设备是否连接成功</returns>
public override async Task<bool> ConnectAsync()
{
_connectTryCount++;

14
Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocalLinker.cs
View File

@@ -8,16 +8,30 @@ namespace Modbus.Net.Siemens
/// </summary>
public class SiemensTcpProtocalLinker : TcpProtocalLinker
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="ip">IP地址</param>
public SiemensTcpProtocalLinker(string ip)
: this(ip, int.Parse(ConfigurationManager.AppSettings["SiemensPort"] ?? "102"))
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="ip">IP地址</param>
/// <param name="port">端口</param>
public SiemensTcpProtocalLinker(string ip, int port)
: base(ip, port)
{
}
/// <summary>
/// 校验报文
/// </summary>
/// <param name="content">设备返回的信息</param>
/// <returns>报文是否正确</returns>
public override bool? CheckRight(byte[] content)
{
if (!base.CheckRight(content).Value) return false;

62
Modbus.Net/Modbus.Net.Siemens/SiemensUtility.cs
View File

@@ -1,22 +1,56 @@
using System;
using System.Threading.Tasks;
using Serilog;
namespace Modbus.Net.Siemens
{
/// <summary>
/// 西门子协议类型
/// </summary>
public enum SiemensType
{
/// <summary>
/// PPI
/// </summary>
Ppi = 0,
/// <summary>
/// MPI
/// </summary>
Mpi = 1,
/// <summary>
/// 以太网
/// </summary>
Tcp = 2
}
/// <summary>
/// 西门子设备类型
/// </summary>
public enum SiemensMachineModel
{
/// <summary>
/// S7-200
/// </summary>
S7_200 = 0,
/// <summary>
/// S7-200 Smart
/// </summary>
S7_200_Smart = 1,
/// <summary>
/// S7-300
/// </summary>
S7_300 = 2,
/// <summary>
/// S7-400
/// </summary>
S7_400 = 3,
/// <summary>
/// S7-1200
/// </summary>
S7_1200 = 4,
/// <summary>
/// S7-1500
/// </summary>
S7_1500 = 5
}
@@ -34,6 +68,14 @@ namespace Modbus.Net.Siemens
private SiemensType _siemensType;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionType">连接类型</param>
/// <param name="connectionString">连接字符串</param>
/// <param name="model">设备类型</param>
/// <param name="slaveAddress">从站地址</param>
/// <param name="masterAddress">主站地址</param>
public SiemensUtility(SiemensType connectionType, string connectionString, SiemensMachineModel model,
byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress)
{
@@ -84,15 +126,21 @@ namespace Modbus.Net.Siemens
}
default:
{
throw new NotImplementedException("没有相应的西门子类型");
throw new NotImplementedException("Siemens PLC Model not Supported");
}
}
ConnectionType = connectionType;
AddressTranslator = new AddressTranslatorSiemens();
}
/// <summary>
/// 端格式
/// </summary>
public override Endian Endian => Endian.BigEndianLsb;
/// <summary>
/// IP地址
/// </summary>
protected string ConnectionStringIp
{
get
@@ -102,6 +150,9 @@ namespace Modbus.Net.Siemens
}
}
/// <summary>
/// 端口
/// </summary>
protected int? ConnectionStringPort
{
get
@@ -113,8 +164,9 @@ namespace Modbus.Net.Siemens
{
return connectionStringSplit.Length < 2 ? (int?) null : int.Parse(connectionStringSplit[1]);
}
catch
catch (Exception e)
{
Log.Error(e, $"SiemensUtility: {ConnectionString} format error");
return null;
}
}
@@ -188,8 +240,9 @@ namespace Modbus.Net.Siemens
readRequestSiemensInputStruct);
return readRequestSiemensOutputStruct?.GetValue;
}
catch (Exception)
catch (Exception e)
{
Log.Error(e, $"SiemensUtility -> GetDatas: {ConnectionString} error");
return null;
}
}
@@ -213,8 +266,9 @@ namespace Modbus.Net.Siemens
writeRequestSiemensInputStruct);
return writeRequestSiemensOutputStruct?.AccessResult == SiemensAccessResult.NoError;
}
catch (Exception)
catch (Exception e)
{
Log.Error(e, $"ModbusUtility -> SetDatas: {ConnectionString} error");
return false;
}
}

62
Modbus.Net/Modbus.Net/ComConnector.cs
View File

@@ -61,15 +61,16 @@ namespace Modbus.Net
/// </summary>
private readonly int _timeoutTime;
private int _errorCount;
private int _receiveCount;
private int _sendCount;
/// <summary>
/// Dispose是否执行
/// </summary>
private bool m_disposed;
private int _sendCount;
private int _receiveCount;
private int _errorCount;
/// <summary>
/// 构造器
/// </summary>
@@ -283,7 +284,7 @@ namespace Modbus.Net
{
SerialPort.Close();
}
catch (Exception)
catch
{
//ignore
}
@@ -308,6 +309,24 @@ namespace Modbus.Net
Dispose(false);
}
private void RefreshSendCount()
{
_sendCount++;
Log.Verbose("Tcp client {ConnectionToken} send count: {SendCount}", ConnectionToken, _sendCount);
}
private void RefreshReceiveCount()
{
_receiveCount++;
Log.Verbose("Tcp client {ConnectionToken} receive count: {SendCount}", ConnectionToken, _receiveCount);
}
private void RefreshErrorCount()
{
_errorCount++;
Log.Verbose("Tcp client {ConnectionToken} error count: {ErrorCount}", ConnectionToken, _errorCount);
}
#region 发送接收数据
/// <summary>
@@ -381,7 +400,8 @@ namespace Modbus.Net
Log.Error(e, "Com client {ConnectionToken} disconnect error", ConnectionToken);
return false;
}
Log.Error(new Exception("Linkers or Connectors Dictionary not found"), "Com client {ConnectionToken} disconnect error", ConnectionToken);
Log.Error(new Exception("Linkers or Connectors Dictionary not found"),
"Com client {ConnectionToken} disconnect error", ConnectionToken);
return false;
}
@@ -436,7 +456,8 @@ namespace Modbus.Net
{
try
{
Log.Verbose("Com client {ConnectionToken} send msg length: {Length}", ConnectionToken, sendbytes.Length);
Log.Verbose("Com client {ConnectionToken} send msg length: {Length}", ConnectionToken,
sendbytes.Length);
Log.Verbose("Com client {ConnectionToken} send msg: {SendBytes}", ConnectionToken, sendbytes);
SerialPort.Write(sendbytes, 0, sendbytes.Length);
}
@@ -450,8 +471,10 @@ namespace Modbus.Net
try
{
returnBytes = ReadMsg();
Log.Verbose("Com client {ConnectionToken} receive msg length: {Length}", ConnectionToken, returnBytes.Length);
Log.Verbose("Com client {ConnectionToken} receive msg: {SendBytes}", ConnectionToken, returnBytes);
Log.Verbose("Com client {ConnectionToken} receive msg length: {Length}", ConnectionToken,
returnBytes.Length);
Log.Verbose("Com client {ConnectionToken} receive msg: {SendBytes}", ConnectionToken,
returnBytes);
}
catch (Exception e)
{
@@ -504,7 +527,8 @@ namespace Modbus.Net
{
try
{
Log.Verbose("Com client {ConnectionToken} send msg length: {Length}", ConnectionToken, sendbytes.Length);
Log.Verbose("Com client {ConnectionToken} send msg length: {Length}", ConnectionToken,
sendbytes.Length);
Log.Verbose("Com client {ConnectionToken} send msg: {SendBytes}", ConnectionToken, sendbytes);
SerialPort.Write(sendbytes, 0, sendbytes.Length);
}
@@ -549,23 +573,5 @@ namespace Modbus.Net
}
#endregion
private void RefreshSendCount()
{
_sendCount++;
Log.Verbose("Tcp client {ConnectionToken} send count: {SendCount}", ConnectionToken, _sendCount);
}
private void RefreshReceiveCount()
{
_receiveCount++;
Log.Verbose("Tcp client {ConnectionToken} receive count: {SendCount}", ConnectionToken, _receiveCount);
}
private void RefreshErrorCount()
{
_errorCount++;
Log.Verbose("Tcp client {ConnectionToken} error count: {ErrorCount}", ConnectionToken, _errorCount);
}
}
}

4
Modbus.Net/src/Base.Common/AddressTranslator.cs
View File

@@ -52,9 +52,9 @@ namespace Modbus.Net
/// <summary>
/// 地址转换
/// </summary>
/// <param name="address">地址前地址</param>
/// <param name="address">格式化的地址</param>
/// <param name="isRead">是否为读取，是为读取，否为写入</param>
/// <returns>Key为转换后的地址，Value为辅助码</returns>
/// <returns>翻译后的地址</returns>
public abstract AddressDef AddressTranslate(string address, bool isRead);
/// <summary>

1
Modbus.Net/src/Base.Common/BaseConnector.cs
View File

@@ -7,7 +7,6 @@ namespace Modbus.Net
/// </summary>
public abstract class BaseConnector : BaseConnector<byte[], byte[]>
{
}
/// <summary>

16
Modbus.Net/src/Base.Common/BaseMachine.cs
View File

@@ -3,6 +3,7 @@ using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using Serilog;
namespace Modbus.Net
{
@@ -333,8 +334,9 @@ namespace Modbus.Net
}
catch (Exception e)
{
Console.WriteLine(ConnectionToken + " " + e.Message);
ErrorCount++;
Log.Error(e, $"BaseMachine -> GetDatas, Id:{Id} Connection:{ConnectionToken} error. ErrorCount {ErrorCount}.");
if (ErrorCount >= _maxErrorCount)
Disconnect();
return null;
@@ -532,7 +534,11 @@ namespace Modbus.Net
}
catch (Exception e)
{
Console.WriteLine(ConnectionToken + " " + e.Message);
ErrorCount++;
Log.Error(e, $"BaseMachine -> SetDatas, Id:{Id} Connection:{ConnectionToken} error. ErrorCount {ErrorCount}.");
if (ErrorCount >= _maxErrorCount)
Disconnect();
return false;
}
return true;
@@ -591,7 +597,7 @@ namespace Modbus.Net
.Invoke(this, parameters);
return (TReturnType) returnValue;
}
throw new InvalidCastException($"Machine未实现{typeof(TMachineMethod).Name}的接口");
throw new InvalidCastException($"Machine interface {nameof(TMachineMethod)} not implemented");
}
/// <summary>
@@ -641,9 +647,9 @@ namespace Modbus.Net
{
return GetAddresses.SingleOrDefault(p => p.Id.Equals(addressUnitId));
}
catch (Exception)
catch (Exception e)
{
Console.WriteLine("Id重复，请检查");
Log.Error(e, $"BaseMachine -> GetAddressUnitById Id:{Id} ConnectionToken:{ConnectionToken} addressUnitId:{addressUnitId} Repeated");
return null;
}
}

3
Modbus.Net/src/Base.Common/BaseProtocal.cs
View File

@@ -85,7 +85,8 @@ namespace Modbus.Net
//自动寻找存在的协议并将其加载
var protocalUnit =
Activator.CreateInstance(type.GetTypeInfo().Assembly.GetType(protocalName)) as TProtocalUnit;
if (protocalUnit == null) throw new InvalidCastException("没有相应的协议内容");
if (protocalUnit == null)
throw new InvalidCastException($"No ProtocalUnit {nameof(TProtocalUnit)} implemented");
protocalUnit.Endian = Endian;
Register(protocalUnit);
return Protocals[protocalName];

12
Modbus.Net/src/Base.Common/BaseUtility.cs
View File

@@ -2,6 +2,7 @@
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Serilog;
/// <summary>
/// 端格式
@@ -124,8 +125,9 @@ namespace Modbus.Net
var getBytes = getReturnValue;
return ValueHelper.GetInstance(Endian).ByteArrayToObjectArray(getBytes, getTypeAndCount);
}
catch (Exception)
catch (Exception e)
{
Log.Error(e, $"ModbusUtility -> GetDatas: {ConnectionString} error");
return null;
}
}
@@ -159,8 +161,9 @@ namespace Modbus.Net
new KeyValuePair<Type, int>(typeof(T), getByteCount));
return ValueHelper.GetInstance(Endian).ObjectArrayToDestinationArray<T>(getBytes);
}
catch (Exception)
catch (Exception e)
{
Log.Error(e, $"ModbusUtility -> GetDatas Generic: {ConnectionString} error");
return null;
}
}
@@ -199,8 +202,9 @@ namespace Modbus.Net
var getBytes = getReturnValue;
return ValueHelper.GetInstance(Endian).ByteArrayToObjectArray(getBytes, translateTypeAndCount);
}
catch (Exception)
catch (Exception e)
{
Log.Error(e, $"ModbusUtility -> GetDatas pair: {ConnectionString} error");
return null;
}
}
@@ -290,7 +294,7 @@ namespace Modbus.Net
.Invoke(this, parameters);
return (TReturnType) returnValue;
}
throw new InvalidCastException($"Utility未实现{typeof(TUtilityMethod).Name}的接口");
throw new InvalidCastException($"Utility interface {nameof(TUtilityMethod)} not implemented");
}
/// <summary>

5
Modbus.Net/src/Base.Common/TaskManager.cs
View File

@@ -9,6 +9,7 @@ using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Nito.AsyncEx;
using Serilog;
namespace Modbus.Net
{
@@ -864,7 +865,7 @@ namespace Modbus.Net
}
catch (Exception e)
{
Console.WriteLine($"设备返回错误 {e.Message}");
Log.Error(e, $"Device {id} return error");
return null;
}
}
@@ -889,7 +890,7 @@ namespace Modbus.Net
}
catch (Exception e)
{
Console.WriteLine($"设备返回错误 {e.Message}");
Log.Error(e, $"Device {connectionToken} return error");
return null;
}
}

11
Modbus.Net/src/Base.Common/TcpConnector.cs
View File

@@ -40,9 +40,10 @@ namespace Modbus.Net
/// </summary>
private readonly byte[] _receiveBuffer = new byte[1024];
private int _sendCount;
private int _receiveCount;
private int _errorCount;
private int _receiveCount;
private int _sendCount;
private TcpClient _socketClient;
@@ -73,7 +74,8 @@ namespace Modbus.Net
/// </summary>
public int TimeoutTime
{
get => _timeoutTime;
get =>
_timeoutTime;
set
{
_timeoutTime = value;
@@ -286,7 +288,8 @@ namespace Modbus.Net
RefreshSendCount();
var receiveBytes = await ReceiveAsync(stream);
Log.Verbose("Tcp client {ConnectionToken} receive text len = {Length}", ConnectionToken, receiveBytes.Length);
Log.Verbose("Tcp client {ConnectionToken} receive text len = {Length}", ConnectionToken,
receiveBytes.Length);
Log.Verbose("Tcp client {ConnectionToken} receive: {Datagram}", ConnectionToken, receiveBytes);
return receiveBytes;

4
Modbus.Net/src/Base.Common/TcpProtocalLinker.cs
View File

@@ -1,6 +1,6 @@
#if NET40||NET45||NET451||NET452||NET46||NET461||NET462||NET47
#if NET40||NET45||NET451||NET452||NET46||NET461||NET462||NET47
using System.Configuration;
#endif
namespace Modbus.Net

2
Modbus.Net/src/Base.Common/TypeExtensions.cs
View File

@@ -36,7 +36,7 @@ namespace Modbus.Net
throw new NullReferenceException("The type has not been specified.");
if (string.IsNullOrEmpty(methodName))
throw new ArgumentNullException("methodName", "The name of the method has not been specified.");
throw new ArgumentNullException(nameof(methodName), "The name of the method has not been specified.");
var methods =

14
Modbus.Net/src/Base.Common/ValueHelper.cs
View File

@@ -3,6 +3,7 @@ using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Serilog;
namespace Modbus.Net
{
@@ -707,12 +708,13 @@ namespace Modbus.Net
}
default:
{
throw new NotImplementedException("没有实现除整数以外的其它转换方式");
throw new NotImplementedException("Number casting not implemented");
}
}
}
catch (Exception)
catch (Exception e)
{
Log.Error(e, "ValueHelper -> ByteArrayToObjectArray error");
count = contents.Length;
}
}
@@ -798,7 +800,7 @@ namespace Modbus.Net
}
default:
{
throw new NotImplementedException("没有实现除整数以外的其它转换方式");
throw new NotImplementedException("Number casting not implemented");
}
}
}
@@ -818,8 +820,9 @@ namespace Modbus.Net
Array.Copy(datas, 0, contents, pos, datas.Length);
return true;
}
catch (Exception)
catch (Exception e)
{
Log.Error(e, "ValueHelper -> SetValue set value failed");
return false;
}
}
@@ -866,8 +869,9 @@ namespace Modbus.Net
contents[pos] = SetBit(contents[pos], subPos, setValue);
return true;
}
catch (Exception)
catch (Exception e)
{
Log.Error(e, "ValueHelper -> SetBit set bit failed");
return false;
}
}