当前位置: 代码迷 >> C# >> 第五章     串口和网络统一IO设计
  详细解决方案

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

热度:415   发布时间:2016-04-28 08:29:37.0
[连载]《C#通讯(串口和网络)框架的设计与实现》- 5.串口和网络统一IO设计

目       录

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

5.1           统一IO接口... 2

5.1.1    串口IO.. 4

5.1.2    网络IO.. 7

5.1.3    扩展应用... 12

5.2           IO管理器... 12

5.2.1    串口I O管理器... 13

5.2.2    网络IO管理器... 15

5.2.2.1   网络侦听... 16

5.2.2.2   连接远程服务器... 17

5.2.2.3   互斥操作... 18

5.3           小结... 19

 

第五章     串口和网络统一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应该怎么实现?

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

  1. 重写IRunDevice设备驱动中的Send接口函数,直接return返回,不进行发送数据。
  2. 重写IRunDevice设备驱动中的Receive接口函数,把接收上来的数据入到缓存里。
  3. 启动IRunDevice设备驱动中的IsStartTimer 的定时器,在DeviceTimer中定时分析缓存里的数据并处理数据。
  4. 查到可用的数据,调用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     网络侦听

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

  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:[email protected]

QQ:504547114

.NET开发技术联盟:54256083

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

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

  相关解决方案