第五章串口和网络统一IO设计

作为通讯框架平台软件，IO是核心部分之一，涉及到与硬件设备、软件之间的信息数据交互，主要包括两部分：IO实例与IO管理器。IO实例负责直接对串口和网络进行操作；IO管理器负责对IO实例进行管理。

受应用环境的影响，IO操作过程中的确出现过一些问题，有些问题的解决也费了好长时间。并不是解决问题有多困难，而是无法确定到底是什么原因引起的。经过不断的完善，IO部分才逐渐稳定下来。

5.1 统一IO接口

框架平台一大特点就是开发一套设备驱动（插件）同时支持串口和网络两种通讯方式，而两种通讯方式的切换只需要改动配制文件。

不同的设备类型和协议、不同的通讯方式，用堆代码的方式进行开发，根本无法适应不同场景的应用，提高了代码的维护成本，以及修改代码可能造成潜在的BUG，是让人很头疼的一件事。

在开始设计框架平台的时候，一个核心的思想就是把变的东西要设计灵活，把不变的东西设计稳定。对于设备的协议就是变的东西，对于IO部分就是相对不变的东西，那就需要对串口IO和网络IO进行整合。不仅在代码层面要运行稳定；在逻辑层面，不管是串口IO还是网络IO在框架内部是统一的接口，所有对IO的操作都会通过这个统一的接口来完成。

统一的IO接口代码如下：

public interface IIOChannel:IDisposable
{
       /// <summary>
       /// 同步锁
       /// </summary>
       object SyncLock { get; }

       /// <summary>
       /// IO关键字，如果是串口通讯为串口号，如：COM1;如果是网络通讯为IP和端口，例如：127.0.0.1:1234
       /// </summary>
       string Key { get; }

       /// <summary>
       /// IO通道，可以是COM，也可以是SOCKET
       /// </summary>
       object IO{get;}
 
       /// <summary>
       /// 读IO;
       /// </summary>
       /// <returns></returns>
       byte[] ReadIO();

       /// <summary>
       /// 写IO
       /// </summary>
       int WriteIO(byte[] data);

       /// <summary>
       /// 关闭
       /// </summary>
       void Close();

       /// <summary>
       /// IO类型
       /// </summary>
       CommunicationType IOType { get; }
 
       /// <summary>
       /// 是否被释放了
       /// </summary>
       bool IsDisposed { get; }
}

串口IO和网络IO都继承自IIOChannel接口，完成特定的IO通讯操作。继承关系图如下：

5.1.1 串口IO

原来串口IO操作使用是的MS自带的SerialPort组件，但是这个组件与一些小众工业串口卡不兼容，操作的时候出现异常"参数不正确"的提示。SerialPort组件本身是对Win32 API的封装，所以分析应该不是这个组件本身的问题。有网友反馈，如下图：

但是，从解决问题的成本角度来考虑，从软件着手解决是成本最低的、效率最高的。基于这方面的考虑，使用MOXA公司的PCOMM.DLL组件进行开发，并没有出现类似的问题。所以，在代码重构中使用了PCOMM.DLL组件，并且运行一直很稳定。

针对串口IO操作比较简单，主要是实现了ReadIO和WriteIO两个接口，代码如下：

public class SessionCom : ISessionCom
{
       ......
       public byte[] ReadIO()
       {
              if (_ReceiveBuffer != null)
              {
                     int num = InternalRead(_ReceiveBuffer, 0, _ReceiveBuffer.Length);
                     if (num > 0)
                     {
                            byte[] data = new byte[num];
                            Buffer.BlockCopy(_ReceiveBuffer, 0, data, 0, data.Length);
                            return data;
                     }
                     else
                     {
                            return new byte[] { };
                     }
              }
              else
              {
                     return new byte[] { };
              }
       }

       public int WriteIO(byte[] data)
       {
              int sendBufferSize = GlobalProperty.GetInstance().ComSendBufferSize;
              if (data.Length <= sendBufferSize)
              {
                     return this.InternalWrite(data);
              }
              else
              {
                     int successNum = 0;
                     int num = 0;
                     while (num < data.Length)
                     {
                            int remainLength = data.Length - num;
                            int sendLength = remainLength >= sendBufferSize
                                   ? sendBufferSize
                                   : remainLength;
                            successNum += InternalWrite(data, num, sendLength);
                            num += sendLength;
                     }
                     return successNum;
              }
       }
       ......
}

针对ReadIO接口函数，可以有多种操作方式，例如：读固定长度、判断结尾字符、一直读到IO缓存为空等。读固定长度，如果偶尔出现通讯干扰或丢失数据，这种方式会给后续正确读取数据造成影响；判断结尾字符，在框架内部的IO实现上又无法做到通用性；一直读到IO缓存为空，如果接收数据的频率大于从IO缓存读取的频率，那么会阻塞轮询调度线程。基于多方面的考虑，现场环境往往比想象的要复杂，在设置读超时的基础上，读一次就返回了。

还要考虑到现场实际的应用环境，例如：USB形式的串口容易松动，造成不稳定；9针串口损坏等情况。所以，有可能因为硬件环境改变引起无法正常对IO进行操作，这时候会通过TryOpen接口函数试着重新打开串口IO；另外，串口参数发生改变时，通过IOSettings接口函数重新配置参数。

5.1.2 网络IO

网络IO通讯的本质是对Socket进行操作，框架平台现在支持TCP方式进行通讯；工作模块支持Server和Client两种，也就是开发一套设备驱动可以支持Tcp Server和Tcp Client两种数据交互方式。现在不支持UDP通讯方式，将会在后续进行完善。

发送和接收的代码实现比较简单，SessionSocket类中的ReadIO和WriteIO是用同步方式实现的；当并发通讯和自控通讯模式时，接收数据是用异步方式来完成的。当然，也可以使用完全的异步编程方式，使用SocketAsyncEventArgs操作类。SessionSocket操作代码实现如下：

public class SessionSocket : ISessionSocket
{
       public byte[] ReadIO()
       {
              if (!this.IsDisposed)
              {
                     if (this.AcceptedSocket.Connected)
                     {
                            if (this.AcceptedSocket.Poll(10, SelectMode.SelectRead))
                            {
                                   if (this.AcceptedSocket.Available > this.AcceptedSocket.ReceiveBufferSize)
                                   {
                                          throw new Exception("接收的数据大于设置的接收缓冲区大小");
                                   }

                                   #region
                                   int num = this.AcceptedSocket.Receive(this._ReceiveBuffer, 0, this._ReceiveBuffer.Length, SocketFlags.None);
                                   if (num <= 0)
                                   {
                                          throw new SocketException((int)SocketError.HostDown);
                                   }
                                   else
                                   {
                                          this._NoneDataCount = 0;
                                          byte[] data = new byte[num];
                                          Buffer.BlockCopy(_ReceiveBuffer, 0, data, 0, data.Length);
                                          return data;
                                   }
                                   #endregion
                            }
                            else
                            {
                                   this._NoneDataCount++;
                                   if (this._NoneDataCount >= 60)
                                   {
                                          this._NoneDataCount = 0;
                                          throw new SocketException((int)SocketError.HostDown);
                                   }
                                   else
                                   {
                                          return new byte[] { };
                                   }
                            }
                     }
                     else
                     {
                            throw new SocketException((int)SocketError.HostDown);
                     }
              }
              else
              {
                    return new byte[] { };
              }
       }

       public int WriteIO(byte[] data)
       {
              if (!this.IsDisposed)
              {
                     if (this.AcceptedSocket.Connected
                            &&
                            this.AcceptedSocket.Poll(10, SelectMode.SelectWrite))
                     {
                            int successNum = 0;
                            int num = 0;
                            while (num < data.Length)
                            {
                                   int remainLength = data.Length - num;
                                   int sendLength = remainLength >= this.AcceptedSocket.SendBufferSize
                                          ? this.AcceptedSocket.SendBufferSize
                                          : remainLength;
                                   SocketError error;
                                   successNum += this.AcceptedSocket.Send(data, num, sendLength, SocketFlags.None, out error);
                                   num += sendLength;
                                   if (successNum <= 0 || error != SocketError.Success)
                                   {
                                          throw new SocketException((int)SocketError.HostDown);
                                   }
                            }
                            return successNum;
                     }
                     else
                     {
                            throw new SocketException((int)SocketError.HostDown);
                     }
              }
              else
              {
                     return 0;
              }
       }
}

ReadIO和WriteIO在操作过程中发生Socket失败后会抛出SocketException异常，框架平台捕捉异常后会对IO实例进行资源销毁。重新被动侦听或主动连接获得Socket实例。

考虑到硬件，由PC机的网卡引起的网络IO操作异常的可能比较小；但是，要考虑到连接到框架平台的各类终端（客户端）硬件设备，例如：DTU、无线路由、网络转换模块等；还涉及到通讯链路，例如：GPRS、2G/3G/4G等；不同的硬件特性、不同的通讯链路，多种原因可能会造成通讯链路失效，例如：另外一端的程序不稳定、无法释放资源等原因导致数据无法正常发送和接收；线路接头虚接导致链路时好时坏导致发送和接收数据不稳定；网络本身的原因出现Socket“假”连接的现象导致显示发送数据成功，而另一端却没有收到等等。

针对Socket通讯，原来在线程里定时轮询IO实例，通过IO实例向另一端发送心跳检测数据，如果发送失败，立即释放IO资源，这种操作方式的缺点是另一端会接收到一些冗余数据信息。重构时改变为另一种方式，对底层进行心跳在线检测，当进行异步发送和接收数据的时候，如果链路出现问题，异步函数会立即返回，并返回结果显示发送和接收0个数，对此进行判断而销毁IO实例资源。在初始化IO实例的时候，增加了对底层心跳检测功能，代码如下：

public SessionSocket(Socket socket)
{
       uint dummy = 0;
       _KeepAliveOptionValues = new byte[Marshal.SizeOf(dummy) * 3];
       _KeepAliveOptionOutValues = new byte[_KeepAliveOptionValues.Length];
       BitConverter.GetBytes((uint)1).CopyTo(_KeepAliveOptionValues, 0);
       BitConverter.GetBytes((uint)(2000)).CopyTo(_KeepAliveOptionValues, Marshal.SizeOf(dummy));
BitConverter.GetBytes((uint)(GlobalProperty.GetInstance().HeartPacketInterval)).CopyTo(_KeepAliveOptionValues, Marshal.SizeOf(dummy) * 2);
       socket.IOControl(IOControlCode.KeepAliveValues, _KeepAliveOptionValues, _KeepAliveOptionOutValues);
       socket.NoDelay = true;
       socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
       ......
}

通过发送、接收抛出异常和底层心跳检测两种方式对Socket IO实例有效性进行检测。对于正常通讯情况下的发送和接收操作很简单，但是也要通过技术手段防止各种意外情况，从而影响框架平台运行的稳定性。

对于通讯说简单也简单，说难也难，因应用场景和环境的原因难易程度不一样。在网络世界发展如火如荼的今天，网络任务调度、分布式消息、大数据处理等无不涉及到多点与多点之间的信息交互，所以在通讯基础上又发展出来各种协议、各种算法以及数据校验等。

5.1.3 扩展应用

把IO设计稳定，但是不代表没有扩展的余地。在《3.设备驱动的设计》的“3.7 IO数据交互设计”中介绍了具体的应用。在调用IRunDevice设备驱动的Send和Receive接口时会把IO实例以参数的形式传递进来，在二次开发过程中可以重写这两个函数，开发特定的发送和接收业务。

有网友问：串口通讯时，硬件设备一直在向软件发送数据，软件分析接收到的数据后进行数据处理，用SuperIO应该怎么实现？

这种单向通讯方式也是存在的，框架设计前已经考虑到这类情况，具体实现步骤如下：

重写IRunDevice设备驱动中的Send接口函数，直接return返回，不进行发送数据。
重写IRunDevice设备驱动中的Receive接口函数，把接收上来的数据入到缓存里。
启动IRunDevice设备驱动中的IsStartTimer 的定时器，在DeviceTimer中定时分析缓存里的数据并处理数据。
查到可用的数据，调用RunIODevice(byte[])驱动函数，其他的代码不需要改动。

5.2 IO管理器

IO管理器是对串口IO和网络IO实例进行管理，他们都继承自IIOChannelManager接口，但是各自的IO管理器的职能又有很大不同，网络IO管理器更复杂一些。继承关系结构图如下：

5.2.1 串口I O管理器

相对简单的多，因为串口IO动态改变的几率比较小，只是创建IO和关闭IO时通过事件反馈到串口监视窗体，主要代码如下：

public class SessionComManager : IOChannelManager,ISessionComManager<string, IIOChannel>
{
       ......
       /// <summary>
       /// 建立并打开串口IO
       /// </summary>
       /// <param name="port"></param>
       /// <param name="baud"></param>
       /// <returns></returns>
       public ISessionCom BuildAndOpenComIO(int port, int baud)
       {
              ISessionCom com = new SessionCom(port, baud);
              com.TryOpen();
              if (COMOpen != null)
              {
                     bool openSuccess = false;
                     if (com.IsOpen)
                     {
                            openSuccess = true;
                     }
                     else
                     {
                            openSuccess = false;
                     }
                     COMOpenArgs args = new COMOpenArgs(port, baud, openSuccess);
                     this.COMOpen(com, args);
              }
              return com;
       }

       /// <summary>
       /// 闭关IO
       /// </summary>
       /// <param name="key"></param>
       public override void CloseIO(string key)
       {
              ISessionCom com = (ISessionCom)this.GetIO(key);
              base.CloseIO(key);
              if (COMClose != null)
              {
                     bool closeSuccess = false;
                     if (com.IsOpen)
                     {
                            closeSuccess = false;
                     }
                     else
                     {
                            closeSuccess = true;
                     }
                     COMCloseArgs args = new COMCloseArgs(com.Port, com.Baud, closeSuccess);
                     this.COMClose(com, args);
              }
       }
       ......
}

5.2.2 网络IO管理器

网络IO管理器相对复杂一些，涉及到Socket的动态连接和断开，以及根据设备驱动设置的工作模式（Server或Client）切换对连接的处理方式。原来的时候，还负责通过线程定时对所有网络IO实例进行心跳检测，现在这部分被底层心跳检测所替代。

5.2.2.1 网络侦听

当侦听并接收到远程的连接实例后，会做两件事：

判断该连接实例的IP在设备管理器中的设备驱动是否设置为Client工作模式，如果是的话，那么则销毁该资源实例，并退出当前事务。设备驱动设置的IP参数和客户端的IP参数一致，但是两端的工作模式又都为Client模式。也就是说在一个网络内存在两个相同的IP和相同的Client工作模式，又要让他们之间进行通讯，这不符合C/S通讯的基本原理。所以，果断拒绝这样的连接并销毁资源。

2.判断当前IO管理器是否存在相同的IP实例对象，如果存在，那么则销毁该IP实例对象。因为有可能这个实例对象已失效，至少认为远程的客户端认为当前的连接已经失效。所以，既然这样，我们双方达成共识，果断销毁这样的IP实例对象，接收新的IP连接实例。

接收连接实例对象的代码如下：

private void Monitor_SocketHanler(object source, AcceptSocketArgs e)
{
       IRunDevice[] devs = DeviceManager.GetInstance().GetDevices(e.RemoteIP, WorkMode.TcpClient);
       if (devs.Length > 0)
       {
              DeviceMonitorLog.WriteLog(String.Format("有设备设置{0}为Tcp Client模式，此IP不支持远程主动连接", e.RemoteIP));
              SessionSocket.CloseSocket(e.Socket);
              return;
       }
       CheckSameSessionSocket(e.RemoteIP);
       _ManualEvent.WaitOne(); //如果正在结束SOCKET操作，等待完成后再执行边接操作 
       ISessionSocket socket = new SessionSocket(e.Socket);
       SessionSocketConnect(socket);
}

5.2.2.2 连接远程服务器

单独开辟一个线程，获得所有工作模式为Client的设备驱动，并检测每一个设备驱动的通讯参数在IO管理器中是否存在相应的IO实例，如果不存在，那么则主动连接远程的服务器，连接成功后把连接的IO实例入到IO管理器。

实现的代码如下：

private void ConnectTarget()
{
       while (true)
       {
              if (!_ConnectThreadRun)
              {
                     break;
              }
              IRunDevice[] devList = DeviceManager.GetInstance().GetDevices(WorkMode.TcpClient);
              for (int i = 0; i < devList.Length; i++)
              {
                     try
                     {
                            if (!this.ContainIO(devList[i].DeviceParameter.NET.RemoteIP))
                            {
                                   ConnectServer(devList[i].DeviceParameter.NET.RemoteIP, devList[i].DeviceParameter.NET.RemotePort);
                            }
                     }
                     catch (Exception ex)
                     {
                            devList[i].OnDeviceRuningLogHandler(ex.Message);
                     }
              }
              System.Threading.Thread.Sleep(2000);
       }
}

5.2.2.3 互斥操作

当有新的连接，在检测是否有相同IP实例存在的时候，如果有相同IP实例存在，在销毁资源未结束之前，不能把新连接的IP实例放到IO管理器。因为相同IP的两个实例，一个在销毁资源、一个在创建资源，有可能把新连接的IP实例一起销毁掉。

防止这种情况的出现，使用ManualResetEvent信号互斥进行状态控制和改变，示意代码如下：

public class SessionSocketManager : IOChannelManager, ISessionSocketManager<string, IIOChannel>
{      
       /// <summary>
       /// 初始状态为终止状态
       /// </summary>
       private ManualResetEvent _ManualEvent = new ManualResetEvent(true);
       private void Monitor_SocketHanler(object source, AcceptSocketArgs e)
       {
              SessionSocketClose(e.RemoteIP);
              _ManualEvent.WaitOne(); //如果正在结束SOCKET操作，等待完成后再执行边接操作 
              ISessionSocket socket = new SessionSocket(e.Socket);
              SessionSocketConnect(socket);
       }

        private void SessionSocketClose(string key)
       {
              this._ManualEvent.Reset(); //为非终止状态
              SessionSocket io = (SessionSocket)GetIO(key);
              if (io != null)
              {
                     CloseIO(key);
              }
              this._ManualEvent.Set();//为终止状态
       }

       private void SessionSocketConnect(ISessionSocket socket)
       {
              if (!this.ContainIO(socket.Key.ToString()))
              {
                     this.AddIO(socket.Key.ToString(), (IIOChannel)socket);
              }
       }
}

5.3 小结

IO这块的设计的思想是一个负责执行一个负责管理，IO实例是具体通道操作，IO管理器负责对IO进行管理，并协调设备和IO之间的关系和工作。

作者：唯笑志在

Email：504547114@qq.com

QQ：504547114

.NET开发技术联盟：54256083

文档下载：http://pan.baidu.com/s/1pJ7lZWf

官方网址：http://www.bmpj.net

[连载]《C#通讯（串口和网络）框架的设计与实现》- 5.串口和网络统一IO设计

第五章串口和网络统一IO设计

5.1 统一IO接口

5.1.1 串口IO

5.1.2 网络IO

5.1.3 扩展应用

5.2 IO管理器

5.2.1 串口I O管理器

5.2.2 网络IO管理器

5.2.2.1 网络侦听

5.2.2.2 连接远程服务器

5.2.2.3 互斥操作

5.3 小结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

[连载]《C#通讯（串口和网络）框架的设计与实现》- 5.串口和网络统一IO设计

第五章 串口和网络统一IO设计

5.1 统一IO接口

5.1.1 串口IO

5.1.2 网络IO

5.1.3 扩展应用

5.2 IO管理器

5.2.1 串口I O管理器

5.2.2 网络IO管理器

5.2.2.1 网络侦听

5.2.2.2 连接远程服务器

5.2.2.3 互斥操作

5.3 小结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

第五章串口和网络统一IO设计