本文将使用一个gitHub开源的项目来扩展实现二次协议的开发，该项目已经搭建好了基础层架构，并实现了三菱，西门子，欧姆龙，MODBUS-TCP的通讯示例，也可以参照这些示例开发其他的通讯协议，并Pull request到这个项目中来实现这个项目的最终目标
github地址：https://github.com/dathlin/HslCommunication 如果喜欢可以star或是fork，还可以打赏支持。
联系作者及加群方式（激活码在群里发放）：http://www.hslcommunication.cn/Cooperation
在Visual Studio 中的NuGet管理器中可以下载安装，也可以直接在NuGet控制台输入下面的指令安装
Install-Package HslCommunication
如果需要教程：Nuget安装教程：http://www.cnblogs.com/dathlin/p/7705014.html
组件的完整信息和其他API介绍参照：http://www.cnblogs.com/dathlin/p/7703805.html 组件的授权协议，更新日志，都在该页面里面。
本文将展示如果进行二次扩展通讯协议，来进行远程交互，可以是PLC协议，自定义协议等等。以一个示例为切入点，根据这个示例来深入讲解
此处使用到了2个命名空间：
using HslCommunication; using HslCommunication.Core.Net;
关于两种模式
本组件所提供的所有客户端类，包括三菱，西门子，欧姆龙，modbus-tcp，以及SimplifyNet都是继承自双模式基类，双模式包含了短连接和长连接，下面就具体介绍下两个模式的区别
短连接：每次读写都是一个单独的请求，请求完毕也就关闭了，如果服务器的端口仅仅支持单连接，那么关闭后这个端口可以被其他连接复用，但是在频繁的网络请求下，容易发生异常，会有其他的请求不成功，尤其是多线程的情况下。
长连接：创建一个公用的连接通道，所有的读写请求都利用这个通道来完成，这样的话，读写性能更快速，即时多线程调用也不会影响，内部有同步机制。如果服务器的端口仅仅支持单连接，那么这个端口就被占用了，比如三菱的端口机制，西门子的Modbus tcp端口机制也是这样的。以下代码默认使用长连接，性能更高，还支持多线程同步。
在短连接的模式下，每次请求都是单独的访问，所以没有重连的困扰，在长连接的模式下，如果本次请求失败了，在下次请求的时候，会自动重新连接服务器，直到请求成功为止。另外，尽量所有的读写都对结果的成功进行判断。
关于日志记录
不管是三菱的数据访问类，还是西门子的，还是Modbus tcp访问类，都有一个LogNet属性用来记录日志，该属性是一个接口类，ILogNet，凡事继承该接口的都可以用来记录日志，该日志会在访问失败时，尤其是因为网络的原因导致访问失败时会进行日志记录（如果你为这个 LogNet 属性配置了真实的日志记录器的话）：如果你想使用该记录日志的功能，请参照如下的博客进行实例化：
http://www.cnblogs.com/dathlin/p/7691693.html
关于基类：public class NetworkDoubleBase<TNetMessage, TTransform> : NetworkBase where TNetMessage : INetMessage, new() where TTransform : IByteTransform, new()
该基类定义了连接方法，单次的数据请求方法，但是需要指定消息类型，TNetMessage指示了该消息类型必须继承自接口INetMessage，至于TTransform指示了一些数据类型的变换规则，这两个类型指定完成后，后面的事情就是定义地址解析器，定义读写指令创建，定义基础的读写方法，然后扩展不同类型的数据读写。
开始二次开发：
先定义消息：消息的接口指示了如果去接收一条完整的消息，通常都是byte[]数据，我们看一下这个接口的定义
/// <summary>
/// 本系统的消息类，包含了各种解析规则，数据信息提取规则
/// </summary>
public interface INetMessage
{
/// <summary>
/// 消息头的指令长度
/// </summary>
int ProtocolHeadBytesLength { get; }
/// <summary>
/// 从当前的头子节文件中提取出接下来需要接收的数据长度
/// </summary>
/// <returns>返回接下来的数据内容长度</returns>
int GetContentLengthByHeadBytes();
/// <summary>
/// 检查头子节的合法性
/// </summary>
/// <param name="token">特殊的令牌，有些特殊消息的验证</param>
/// <returns></returns>
bool CheckHeadBytesLegal(byte[] token);
/// <summary>
/// 获取头子节里的消息标识
/// </summary>
/// <returns></returns>
int GetHeadBytesIdentity();
/// <summary>
/// 消息头字节
/// </summary>
byte[] HeadBytes { get; set; }
/// <summary>
/// 消息内容字节
/// </summary>
byte[] ContentBytes { get; set; }
/// <summary>
/// 发送的字节信息
/// </summary>
byte[] SendBytes { get; set; }
}
}
举例来说明：例子一：Modbus-Tcp消息，通常如下：
byte[0] byte[1] 消息头 byte[0]*256+byte[1]
byte[2] byte[3] 必须都是0，否则不是Modbus协议
byte[4] byte[5] 后面跟着的消息长度，长度为byte[4]*256 + byte[5]
byte[6] 站号
byte[7] 功能码
byte[8] byte[9] 地址
...
...
等等，不管后面是什么了
OK，现在已经可以写TNetMessage了，主要思路是先接收6个长度的头子节，接收完后 HeadBytes 就是6个长度的字节，如果需要验证，就判断byte[2]，byte[3]是不是都为0，然后写一个方法，从这个头子节数据里分析出接下来的数据长度， 然后就可以按照下面写。
下面的验证消息接收的合法性，还需要根据发送消息的消息号，接收的消息号要一致。
/// <summary>
/// Modbus-Tcp协议支持的消息解析类
/// </summary>
public class ModbusTcpMessage : INetMessage
{
/// <summary>
/// 消息头的指令长度
/// </summary>
public int ProtocolHeadBytesLength
{
get { return 6; }
}
/// <summary>
/// 从当前的头子节文件中提取出接下来需要接收的数据长度
/// </summary>
/// <returns>返回接下来的数据内容长度</returns>
public int GetContentLengthByHeadBytes( )
{
return = HeadBytes[4] * 256 + HeadBytes[5];
}
/// <summary>
/// 检查头子节的合法性
/// </summary>
/// <param name="token">特殊的令牌，有些特殊消息的验证</param>
/// <returns></returns>
public bool CheckHeadBytesLegal( byte[] token )
{
if (SendBytes[0] != HeadBytes[0] || SendBytes[1] != HeadBytes[1]) return false;
return HeadBytes[2] == 0x00 && HeadBytes[3] == 0x00;
}
/// <summary>
/// 获取头子节里的消息标识
/// </summary>
/// <returns></returns>
public int GetHeadBytesIdentity( )
{
return HeadBytes[0] * 256 + HeadBytes[1];// 有些协议没有标识就返回0
}
/// <summary>
/// 消息头字节
/// </summary>
public byte[] HeadBytes { get; set; }
/// <summary>
/// 消息内容字节
/// </summary>
public byte[] ContentBytes { get; set; }
/// <summary>
/// 发送的字节信息
/// </summary>
public byte[] SendBytes { get; set; }
}
消息类写好 ，接下来就选取IByteTransform接口的类，这个接口定义了什么呢？定义了常用的数据类型和byte[]数组之间的转换方法。为什么要实现这个接口呢，因为不同设备的数据定义规则是不一样的，比如C#的类库，地位在前，高位在后，三菱PLC中也是类似的，西门子确实地位在后，高位在前，但是modbus-tcp和fins协议却以双字节为单位。
所以本系统系统三个常用的数据转换类，如果有其他的机制，后面可以扩展，这三个类如下：
- RegularByteTransform 常规的数据转换，低位在前，高位在后
- ReverseBytesTransform 高地位反转的数据转换类，高位在前，地位在后
- ReverseWordTransform 以字节为单位进行反转的数据类
那么我们就选择好了类型，然后通讯类已经基本成型了
public class ModbusTcpNet : NetworkDoubleBase<ModbusTcpMessage, ReverseWordTransform>
{
}
然后创建基础的读取指令方法，和写入指令方法，此处简便处理，只针对寄存器进行操作
/// <summary>
/// 读取数据的基础指令，需要指定指令码，地址，长度
/// </summary>
/// <param name="code"></param>
/// <param name="address"></param>
/// <param name="count"></param>
/// <returns></returns>
private OperateResult<byte[]> BuildReadCommandBase( byte code, string address, ushort count )
{
ushort add = ushort.Parse( address );
ushort messageId = (ushort)softIncrementCount.GetCurrentValue( );
byte[] buffer = new byte[12];
buffer[0] = (byte)(messageId / 256);
buffer[1] = (byte)(messageId % 256);
buffer[2] = 0x00;
buffer[3] = 0x00;
buffer[4] = 0x00;
buffer[5] = 0x06;
buffer[6] = station;
buffer[7] = code;
buffer[8] = (byte)(add / 256);
buffer[9] = (byte)(add % 256);
buffer[10] = (byte)(count / 256);
buffer[11] = (byte)(count % 256);
return OperateResult.CreateSuccessResult( buffer );
}
然后读取寄存器的基础方法是这样设计，基类里有个方法：
/// <summary>
/// 使用底层的数据报文来通讯，传入需要发送的消息，返回一条完整的数据指令
/// </summary>
/// <param name="send">发送的完整的报文信息</param>
/// <returns>接收的完整的报文信息</returns>
public OperateResult<byte[]> ReadFromCoreServer( byte[] send );
这个方法是一次数据交互的成功与否，所以我们要封装一个二次方法，不仅仅是进行数据交互，进行消息的二次验证，如果验证失败，就返回错误还有相关的消息
private OperateResult<byte[]> CheckModbusTcpResponse( byte[] send )
{
OperateResult<byte[]> result = ReadFromCoreServer( send );
if (result.IsSuccess)
{
if ((send[7] + 0x80) == result.Content[7])
{
// 发生了错误
result.IsSuccess = false;
result.Message = GetDescriptionByErrorCode( result.Content[8] );
result.ErrorCode = result.Content[8];
}
}
return result;
}
然后在封装一层基础的通信方法，在读取到数据并且验证成功之后，把读取到的数据内容单独提取出来，好让后续进行更加方便的处理。
/// <summary>
/// 读取服务器的数据，需要指定不同的功能码
/// </summary>
/// <param name="code">指令</param>
/// <param name="address">地址</param>
/// <param name="length">长度</param>
/// <returns></returns>
private OperateResult<byte[]> ReadModBusBase( byte code, string address, ushort length )
{
OperateResult<byte[]> command = BuildReadCommandBase( code, address, length );
if (!command.IsSuccess) return OperateResult.CreateFailedResult<byte[]>( command );
OperateResult<byte[]> resultBytes = CheckModbusTcpResponse( command.Content );
if (resultBytes.IsSuccess)
{
// 二次数据处理
if (resultBytes.Content?.Length >= 9)
{
byte[] buffer = new byte[resultBytes.Content.Length - 9];
Array.Copy( resultBytes.Content, 9, buffer, 0, buffer.Length );
resultBytes.Content = buffer;
}
}
return resultBytes;
}
有了上面两层的基础，最终提供了一个读取寄存器的基础方法，也就是第三层的方法
/// <summary>
/// 从Modbus服务器批量读取寄存器的信息，需要指定起始地址，读取长度
/// </summary>
/// <param name="address">起始地址，格式为"1234"</param>
/// <param name="length">读取的数量</param>
/// <returns>带有成功标志的字节信息</returns>
public OperateResult<byte[]> Read( string address, ushort length )
{
OperateResult<byte[]> read = ReadModBusBase( ModbusInfo.ReadRegister, address, length );
if (!read.IsSuccess) return OperateResult.CreateFailedResult<byte[]>( read );
return read;
}
有了上面的读取寄存器的方法，那么我们可以方便的扩展其他基础类型的数据读取了。
/// <summary>
/// 读取指定地址的short数据
/// </summary>
/// <param name="address">起始地址，格式为"1234"</param>
/// <returns>带有成功标志的short数据</returns>
public OperateResult<short> ReadInt16( string address )
{
return GetInt16ResultFromBytes( Read( address, 1 ) );
}
/// <summary>
/// 读取指定地址的ushort数据
/// </summary>
/// <param name="address">起始地址，格式为"1234"</param>
/// <returns>带有成功标志的ushort数据</returns>
public OperateResult<ushort> ReadUInt16( string address )
{
return GetUInt16ResultFromBytes( Read( address, 1 ) );
}
/// <summary>
/// 读取指定地址的int数据
/// </summary>
/// <param name="address">起始地址，格式为"1234"</param>
/// <returns>带有成功标志的int数据</returns>
public OperateResult<int> ReadInt32( string address )
{
return GetInt32ResultFromBytes( Read( address, 2 ) );
}
/// <summary>
/// 读取指定地址的uint数据
/// </summary>
/// <param name="address">起始地址，格式为"1234"</param>
/// <returns>带有成功标志的uint数据</returns>
public OperateResult<uint> ReadUInt32( string address )
{
return GetUInt32ResultFromBytes( Read( address, 2 ) );
}
/// <summary>
/// 读取指定地址的float数据
/// </summary>
/// <param name="address">起始地址，格式为"1234"</param>
/// <returns>带有成功标志的float数据</returns>
public OperateResult<float> ReadFloat( string address )
{
return GetSingleResultFromBytes( Read( address, 2 ) );
}
/// <summary>
/// 读取指定地址的long数据
/// </summary>
/// <param name="address">起始地址，格式为"1234"</param>
/// <returns>带有成功标志的long数据</returns>
public OperateResult<long> ReadInt64( string address )
{
return GetInt64ResultFromBytes( Read( address, 4 ) );
}
/// <summary>
/// 读取指定地址的ulong数据
/// </summary>
/// <param name="address">起始地址，格式为"1234"</param>
/// <returns>带有成功标志的ulong数据</returns>
public OperateResult<ulong> ReadUInt64( string address )
{
return GetUInt64ResultFromBytes( Read( address, 4 ) );
}
/// <summary>
/// 读取指定地址的double数据
/// </summary>
/// <param name="address">起始地址，格式为"1234"</param>
/// <returns>带有成功标志的double数据</returns>
public OperateResult<double> ReadDouble( string address )
{
return GetDoubleResultFromBytes( Read( address, 4 ) );
}
/// <summary>
/// 读取地址地址的String数据，字符串编码为ASCII
/// </summary>
/// <param name="address">起始地址，格式为"1234"</param>
/// <param name="length">字符串长度</param>
/// <returns>带有成功标志的string数据</returns>
public OperateResult<string> ReadString( string address, ushort length )
{
return GetStringResultFromBytes( Read( address, length ) );
}
到这里为止，就写完了寄存器的读取方法，实际上会更加复杂点，会把地址解析专门拿出来做成地址解析器，因为有些PLC的地址是比较复杂，例如西门子的"M100.2"，就需要写个专门的解析器来解析，针对单次读取上限，也可以支持更具地址来多次访问等等操作。
写入数据的例子：
写入的操作通常不会返回数据，只要验证完指令的逻辑性即可，我们把地址解析器拿出来看看，先写地址解析器
/// <summary>
/// 解析数据地址，解析出地址类型，起始地址
/// </summary>
/// <param name="address">数据地址</param>
/// <returns>解析出地址类型，起始地址，DB块的地址</returns>
private OperateResult<int> AnalysisAddress( string address )
{
try
{
return OperateResult.CreateSuccessResult( Convert.ToInt32( address ) );
}
catch (Exception ex)
{
return new OperateResult<int>( )
{
Message = ex.Message
};
}
}
解析完地址后，就创建写入的基础指令，需要指定字节数组，如下的创建方式是针对了多个寄存器写入的代码
private OperateResult<byte[]> BuildWriteRegisterCommand( string address, byte[] data )
{
OperateResult<int> analysis = AnalysisAddress( address );
if (!analysis.IsSuccess) return OperateResult.CreateFailedResult<byte[]>( analysis );
ushort messageId = (ushort)softIncrementCount.GetCurrentValue( );
byte[] buffer = new byte[13 + data.Length];
buffer[0] = (byte)(messageId / 256);
buffer[1] = (byte)(messageId % 256);
buffer[2] = 0x00;
buffer[3] = 0x00;
buffer[4] = (byte)((buffer.Length - 6) / 256);
buffer[5] = (byte)((buffer.Length - 6) % 256);
buffer[6] = station;
buffer[7] = ModbusInfo.WriteRegister;
buffer[8] = (byte)(analysis.Content / 256);
buffer[9] = (byte)(analysis.Content % 256);
buffer[10] = (byte)(data.Length / 2 / 256);
buffer[11] = (byte)(data.Length / 2 % 256);
buffer[12] = (byte)(data.Length);
data.CopyTo( buffer, 13 );
return OperateResult.CreateSuccessResult( buffer );
}
那么写入数据基础方法就是
/// <summary>
/// 将数据写入到Modbus的寄存器上去，需要指定起始地址和数据内容
/// </summary>
/// <param name="address">起始地址，格式为"1234"</param>
/// <param name="value">写入的数据，长度根据data的长度来指示</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, byte[] value )
{
OperateResult<byte[]> command = BuildWriteRegisterCommand( address, value );
if (!command.IsSuccess)
{
return command;
}
return CheckModbusTcpResponse( command.Content );
}
然后我们再想支持其他的数据类型，就好办很多了
#region Write Short
/// <summary>
/// 向寄存器中写入short数组，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="values">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, short[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向寄存器中写入short数据，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, short value )
{
return Write( address, new short[] { value } );
}
#endregion
#region Write UShort
/// <summary>
/// 向寄存器中写入ushort数组，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="values">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, ushort[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向寄存器中写入ushort数据，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, ushort value )
{
return Write( address, new ushort[] { value } );
}
#endregion
#region Write Int
/// <summary>
/// 向寄存器中写入int数组，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="values">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, int[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向寄存器中写入int数据，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, int value )
{
return Write( address, new int[] { value } );
}
#endregion
#region Write UInt
/// <summary>
/// 向寄存器中写入uint数组，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="values">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, uint[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向寄存器中写入uint数据，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, uint value )
{
return Write( address, new uint[] { value } );
}
#endregion
#region Write Float
/// <summary>
/// 向寄存器中写入float数组，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="values">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, float[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向寄存器中写入float数据，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, float value )
{
return Write( address, new float[] { value } );
}
#endregion
#region Write Long
/// <summary>
/// 向寄存器中写入long数组，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="values">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, long[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向寄存器中写入long数据，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, long value )
{
return Write( address, new long[] { value } );
}
#endregion
#region Write ULong
/// <summary>
/// 向寄存器中写入ulong数组，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="values">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, ulong[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向寄存器中写入ulong数据，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, ulong value )
{
return Write( address, new ulong[] { value } );
}
#endregion
#region Write Double
/// <summary>
/// 向寄存器中写入double数组，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="values">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, double[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向寄存器中写入double数据，返回值说明
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="value">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public OperateResult Write( string address, double value )
{
return Write( address, new double[] { value } );
}
#endregion
到这里为止，基础的操作和扩展讲的差不多了。接下来就要针对某些特殊的设备进行适配，比如我在实际的开发中，发现西门子，欧姆龙的通信协议中，没有一个握手信号交互的过程，在西门子里还要进行2次握手，在欧姆龙里要进行一次握手，这些握手信息在网络连接上之后就需要进行交互，不然无法现在读取。在上述的MODBUS协议了就不需要握手信号，如果想支持握手信号，那么就要重写一个方法
/// <summary>
/// 在连接上欧姆龙PLC后，需要进行一步握手协议
/// </summary>
/// <param name="socket"></param>
/// <returns></returns>
protected override OperateResult InitilizationOnConnect( Socket socket )
{
// handSingle就是握手信号字节
OperateResult<byte[], byte[]> read = ReadFromCoreServerBase( socket, handSingle );
if (!read.IsSuccess) return read;
// 检查返回的状态
byte[] buffer = new byte[4];
buffer[0] = read.Content2[7];
buffer[1] = read.Content2[6];
buffer[2] = read.Content2[5];
buffer[3] = read.Content2[4];
int status = BitConverter.ToInt32( buffer, 0 );
if(status != 0)
{
return new OperateResult( )
{
ErrorCode = status,
Message = "初始化失败，具体原因请根据错误码查找"
};
}
// 提取PLC的节点地址
if (read.Content2.Length >= 16)
{
DA1 = read.Content2[15];
}
return OperateResult.CreateSuccessResult( ) ;
}
上面的代码所示就是，欧姆龙协议的握手信号的处理方式，处理成功就返回为真的Result对象，处理失败就返回假的结果对象。
注意：握手信号使用的方法必须是ReadFromCoreServerBase方法。
更复杂的实际开发例子，可以参见项目的源代码，欢迎大家完善开发其他的通讯协议。
创作不易，感谢打赏
