0
回答
C#开发串口总结,并提炼串口辅助类到公用类库中
终于搞明白,存储TCO原来是这样算的>>>   

开发C#相关的项目有很多年了,一直没有接触串口的开发,近期由于工作的需要,需要了解熟悉对硬件串口的开发,通过对串口的深入了解,串口也不再是什么神秘的东西,利用SerailPort组件,对串口的各种操作也非常的方便,由于本人总是喜欢把一些常用的东西封装成可供重复利用的类库,因此,阅百家代码,提炼总结优化,把对串口的操作封装成一个公用的类库,应付日常的串口编程开发,也算是工作的一个阶段性总结吧。

先上图,了解串口的一些基本的东西,并逐步介绍相关的知识。

 

微软在 .NET FrameWork2.0中对串口通讯进行了封装,我们可以在.net2.0及以上版本开发时直接使用SerialPort类对串口进行读写操作。
SerialPort类的属性主要包括:
    1)串口名称(PortName) 
    2)波特率(BaudRate)
    3)数据位 DataBits
    4)停止位 StopBits
    5)奇偶校验 Parity 
SerialPort类的事件主要包括:
    DataReceived:用于异步接收串口数据事件

    ErrorReceived:错误处理事件

SerialPort类的方法主要包括: 

    Open();Close();Read();Write()、DiscardInBuffer()、DiscardOutBuffer()等

 

从上面的测试例子图中,我们可以看到,一般对串口的操作,需要提供串口号、波特率、数据位、停止位、奇偶校验的参数,用来构造一个串口操作类,以便实现具体的串口操作,而这些参数有的是系统内置的枚举参数,我们可以通过遍历枚举对象来绑定下来列表(如停止位、奇偶校验);但有些参数却不是系统内置的枚举类型,例如波特率、数据位等,而且对这些参数操作也是串口开发经常用到的,因此,第一步,我对这些参数的绑定做了一个简单的封装。

1、先构造波特率、数据位这两个枚举对象,方便实际操作。

     ///   <summary>
    
///  串口数据位列表(5,6,7,8)
    
///   </summary>
     public   enum  SerialPortDatabits :  int
    {
        FiveBits 
=   5 ,
        SixBits 
=   6 ,
        SeventBits 
=   7 ,
        EightBits 
=   8
    }

    
///   <summary>
    
///  串口波特率列表。
    
///  75,110,150,300,600,1200,2400,4800,9600,14400,19200,28800,38400,56000,57600,
    
///  115200,128000,230400,256000
    
///   </summary>
     public   enum  SerialPortBaudRates :  int
    {
        BaudRate_75 
=   75 ,
        BaudRate_110 
=   110 ,
        BaudRate_150 
=   150 ,
        BaudRate_300 
=   300 ,
        BaudRate_600 
=   600 ,
        BaudRate_1200 
=   1200 ,
        BaudRate_2400 
=   2400 ,
        BaudRate_4800 
=   4800 ,
        BaudRate_9600 
=   9600 ,
        BaudRate_14400 
=   14400 ,
        BaudRate_19200 
=   19200 ,
        BaudRate_28800 
=   28800 ,
        BaudRate_38400 
=   38400 ,
        BaudRate_56000 
=   56000 ,
        BaudRate_57600 
=   57600 ,
        BaudRate_115200 
=   115200 ,
        BaudRate_128000 
=   128000 ,
        BaudRate_230400 
=   230400 ,
        BaudRate_256000 
=   256000
   } 

 

2、对常用的参数下拉列表绑定做一个封装。

         ///   <summary>
        
///  设置串口号
        
///   </summary>
        
///   <param name="obj"></param>
         public   static   void  SetPortNameValues(ComboBox obj)
        {
            obj.Items.Clear();
            
foreach  ( string  str  in  SerialPort.GetPortNames())
            {
                obj.Items.Add(str);
            }
        }

        
///   <summary>
        
///  设置波特率
        
///   </summary>
         public   static   void  SetBauRateValues(ComboBox obj)
        {
            obj.Items.Clear();
            
foreach  (SerialPortBaudRates rate  in  Enum.GetValues( typeof (SerialPortBaudRates)))
            {
                obj.Items.Add(((
int )rate).ToString());
            }
        }

        
///   <summary>
        
///  设置数据位
        
///   </summary>
         public   static   void  SetDataBitsValues(ComboBox obj)
        {
            obj.Items.Clear();
            
foreach  (SerialPortDatabits databit  in  Enum.GetValues( typeof (SerialPortDatabits)))
            {
                obj.Items.Add(((
int )databit).ToString());
            }
        }

        
///   <summary>
        
///  设置校验位列表
        
///   </summary>
         public   static    void  SetParityValues(ComboBox obj)
        {
            obj.Items.Clear();
            
foreach  ( string  str  in  Enum.GetNames( typeof (Parity)))
            {
                obj.Items.Add(str);
            }
        }

        
///   <summary>
        
///  设置停止位
        
///   </summary>
         public   static   void  SetStopBitValues(ComboBox obj)
        {
            obj.Items.Clear();
            
foreach  ( string  str  in  Enum.GetNames( typeof (StopBits)))
            {
                obj.Items.Add(str);
            } 
       }

这样我们在窗体界面代码中,绑定相关参数的数据源就很方便了,如下所示。

        private void Form1_Load(object sender, EventArgs e)
        {
            BindData();
        }

        
private void BindData()
        {
            
//绑定端口号
            SerialPortUtil.SetPortNameValues(txtPort);
            txtPort.SelectedIndex 
= 0;

            
//波特率
            SerialPortUtil.SetBauRateValues(txtBaudRate);
            txtBaudRate.SelectedText 
= "57600";

            
//数据位
            SerialPortUtil.SetDataBitsValues(txtDataBits);
            
this.txtDataBits.SelectedText = "8";

            
//校验位
            SerialPortUtil.SetParityValues(txtParity);
            
this.txtParity.SelectedIndex = 0;

            
//停止位
            SerialPortUtil.SetStopBitValues(txtStopBit);
            
this.txtStopBit.SelectedIndex = 1;
          
            
this.btnSend.Enabled = isOpened;
        }

 

 

3、 为了方便构造封装的窗口类,提供了两个不同类型参数的串口辅助类构造函数,一个可以使用枚举参数,一个使用字符串参数(最终转换为枚举参数对象),如下所示。使用枚举对象,不需要记住不同参数应该填写那些值,只需要从枚举中选择即可,方便又直观。

         ///   <summary>
        
///  参数构造函数(使用枚举参数构造)
        
///   </summary>
        
///   <param name="baud"> 波特率 </param>
        
///   <param name="par"> 奇偶校验位 </param>
        
///   <param name="sBits"> 停止位 </param>
        
///   <param name="dBits"> 数据位 </param>
        
///   <param name="name"> 串口号 </param>
         public  SerialPortUtil( string  name, SerialPortBaudRates baud, Parity par, SerialPortDatabits dBits, StopBits sBits)
        {
            _portName 
=  name;
            _baudRate 
=  baud;
            _parity 
=  par;
            _dataBits 
=  dBits;
            _stopBits 
=  sBits;

            comPort.DataReceived 
+=   new  SerialDataReceivedEventHandler(comPort_DataReceived);
            comPort.ErrorReceived 
+=   new  SerialErrorReceivedEventHandler(comPort_ErrorReceived);
        }

        
///   <summary>
        
///  参数构造函数(使用字符串参数构造)
        
///   </summary>
        
///   <param name="baud"> 波特率 </param>
        
///   <param name="par"> 奇偶校验位 </param>
        
///   <param name="sBits"> 停止位 </param>
        
///   <param name="dBits"> 数据位 </param>
        
///   <param name="name"> 串口号 </param>
         public  SerialPortUtil( string  name,  string  baud,  string  par,  string  dBits,  string  sBits)
        {
            _portName 
=  name;
            _baudRate 
=  (SerialPortBaudRates)Enum.Parse( typeof (SerialPortBaudRates), baud);
            _parity 
=  (Parity)Enum.Parse( typeof (Parity), par);
            _dataBits 
=  (SerialPortDatabits)Enum.Parse( typeof (SerialPortDatabits), dBits);
            _stopBits 
=  (StopBits)Enum.Parse( typeof (StopBits), sBits);

            comPort.DataReceived 
+=   new  SerialDataReceivedEventHandler(comPort_DataReceived);
            comPort.ErrorReceived 
+=   new  SerialErrorReceivedEventHandler(comPort_ErrorReceived);
       }

构造函数做好了,就很方便在实际的窗体界面函数中构造串口实例了,如下使用代码所示:

         private   void  btnConnect_Click( object  sender, EventArgs e)
        {
            
try
            {
                
if  (serial  ==   null )
                {
                    
try
                    {
                        
string  portname  =   this .txtPort.Text;
                        SerialPortBaudRates rate 
=  (SerialPortBaudRates)Enum.Parse( typeof (SerialPortBaudRates),  this .txtBaudRate.Text); // int.Parse(this.txtBaudRate.Text);
                        SerialPortDatabits databit  =  (SerialPortDatabits) int .Parse( this .txtDataBits.Text);
                        Parity party 
=  (Parity)Enum.Parse( typeof (Parity),  this .txtParity.Text);
                        StopBits stopbit 
=  (StopBits)Enum.Parse( typeof (StopBits),  this .txtStopBit.Text);

                        
// 使用枚举参数构造
                        
// serial = new SerialPortUtil(portname, rate, party, databit, stopbit);
                        
                        
// 使用字符串参数构造
                        serial  =   new  SerialPortUtil(portname,  this .txtBaudRate.Text,  this .txtParity.Text,  this .txtDataBits.Text,  this .txtStopBit.Text);
                        serial.DataReceived 
+=   new  DataReceivedEventHandler(serial_DataReceived);

                    }
                    
catch  (Exception ex)
                    {
                        MessageBox.Show(ex.Message);
                        serial 
=   null ;
                        
return ;
                    }
                }

                
if  ( ! isOpened)
                {                    
                    serial.OpenPort();
                    btnConnect.Text 
=   " 断开 " ;
                }
                
else
                {
                    serial.ClosePort();
                    serial 
=   null ;

                    btnConnect.Text 
=   " 连接 " ;
                }
                
                isOpened 
=   ! isOpened;
                
this .btnSend.Enabled  =  isOpened;
                
this .lblTips.Text  =  isOpened  ?   " 已连接 "  :  " 未连接 " ;
            }
            
catch  (Exception ex)
            {
                
this .lblTips.Text  =  ex.Message;
                MessageBox.Show(ex.Message);
            }
       }

 

4、对串口数据的发送以及串口的一些基本操作进行简单封装,方便辅助类对串口进行相关操作。

         ///   <summary>
        
///  端口是否已经打开
        
///   </summary>
         public   bool  IsOpen
        {
            
get
            {
                
return  comPort.IsOpen;
            }
        }

        
///   <summary>
        
///  打开端口
        
///   </summary>
        
///   <returns></returns>
         public   void  OpenPort()
        {
            
if  (comPort.IsOpen) comPort.Close();

            comPort.PortName 
=  _portName;
            comPort.BaudRate 
=  ( int )_baudRate;
            comPort.Parity 
=  _parity;
            comPort.DataBits 
=  ( int )_dataBits;
            comPort.StopBits 
=  _stopBits;

            comPort.Open();
        }

        
///   <summary>
        
///  关闭端口
        
///   </summary>
         public   void  ClosePort()
        {
            
if  (comPort.IsOpen) comPort.Close();
        }

        
///   <summary>
        
///  丢弃来自串行驱动程序的接收和发送缓冲区的数据
        
///   </summary>
         public   void  DiscardBuffer()
        {
            comPort.DiscardInBuffer();
            comPort.DiscardOutBuffer();
        }

        
///   <summary>
        
///  写入数据
        
///   </summary>
        
///   <param name="msg"></param>
         public   void  WriteData( string  msg)
        {
            
if  ( ! (comPort.IsOpen)) comPort.Open();

            comPort.Write(msg);
        }

        
///   <summary>
        
///  写入数据
        
///   </summary>
        
///   <param name="msg"> 写入端口的字节数组 </param>
         public   void  WriteData( byte [] msg)
        {
            
if  ( ! (comPort.IsOpen)) comPort.Open();

            comPort.Write(msg, 
0 , msg.Length);
        }

        
///   <summary>
        
///  写入数据
        
///   </summary>
        
///   <param name="msg"> 包含要写入端口的字节数组 </param>
        
///   <param name="offset"> 参数从0字节开始的字节偏移量 </param>
        
///   <param name="count"> 要写入的字节数 </param>
         public   void  WriteData( byte [] msg,  int  offset,  int  count)
        {
            
if  ( ! (comPort.IsOpen)) comPort.Open();

            comPort.Write(msg, offset, count);
        }

 

6、接收数据的还原

这样基本上就对串口封装的差不多了,不过还有一个重要的操作就是对串口的数据进行接收,并进行处理。由于串口获取数据不是一次性完整的获取的,可能会被拆分为好几段,因此,如何还原接收到的数据也就是一个值得注意的问题,这个最好能根据协议来确定,如我的协议基本上是以“~”符号开始,以“#”符号结束,因此我对协议数据的还原,就有可依据的准则。

1)首先要构造一个数据处理的代理,和一个数据处理的事件参数类,如下所示。 

     public   class  DataReceivedEventArgs : EventArgs
    {
        
public   string  DataReceived;
        
public  DataReceivedEventArgs( string  m_DataReceived)
        {
            
this .DataReceived  =  m_DataReceived;
        }
    }

     public   delegate   void  DataReceivedEventHandler(DataReceivedEventArgs e); 

2)然后构造一个数据接收和错误处理的事件,如下所示

         ///   <summary>
        
///  完整协议的记录处理事件
        
///   </summary>
         public   event  DataReceivedEventHandler DataReceived;
         public   event  SerialErrorReceivedEventHandler Error; 

3)在构造函数添加相关的事件处理,如下所示

         ///   <summary>
        
///  参数构造函数(使用枚举参数构造)
        
///   </summary>
        
///   <param name="baud"> 波特率 </param>
        
///   <param name="par"> 奇偶校验位 </param>
        
///   <param name="sBits"> 停止位 </param>
        
///   <param name="dBits"> 数据位 </param>
        
///   <param name="name"> 串口号 </param>
         public  SerialPortUtil( string  name, SerialPortBaudRates baud, Parity par, SerialPortDatabits dBits, StopBits sBits)
        {
            _portName 
=  name;
            _baudRate 
=  baud;
            _parity 
=  par;
            _dataBits 
=  dBits;
            _stopBits 
=  sBits;

            comPort.DataReceived 
+=   new  SerialDataReceivedEventHandler(comPort_DataReceived);
            comPort.ErrorReceived 
+=   new  SerialErrorReceivedEventHandler(comPort_ErrorReceived);
      }

 4)实现对数据的接收和错误的处理 

        /// <summary>
        /// 结束符比特
        /// </summary>
        public byte EndByte = 0x23;//string End = "#";

        
///   <summary>
        
///  数据接收处理
        
///   </summary>
         void  comPort_DataReceived( object  sender, SerialDataReceivedEventArgs e)
        {
            
// 禁止接收事件时直接退出
             if  (ReceiveEventFlag)  return ;

            
#region  根据结束字节来判断是否全部获取完成
            List
< byte >  _byteData  =   new  List < byte > ();
            
bool  found  =   false ; // 是否检测到结束符号
             while  (comPort.BytesToRead  >   0   ||   ! found)
            {
                
byte [] readBuffer  =   new   byte [comPort.ReadBufferSize  +   1 ];
                
int  count  =  comPort.Read(readBuffer,  0 , comPort.ReadBufferSize);
                
for  ( int  i  =   0 ; i  <  count; i ++ )
                {
                    _byteData.Add(readBuffer[i]);

                    
if  (readBuffer[i]  ==  EndByte)
                    {
                        found 
=   true ;
                    }
                }
            } 
            
#endregion
            
            
// 字符转换
             string  readString  =  System.Text.Encoding.Default.GetString(_byteData.ToArray(),  0 , _byteData.Count);
            
            
// 触发整条记录的处理
             if  (DataReceived  !=   null )
            {
                DataReceived(
new  DataReceivedEventArgs(readString));
            }
        }

        
///   <summary>
        
///  错误处理函数
        
///   </summary>
         void  comPort_ErrorReceived( object  sender, SerialErrorReceivedEventArgs e)
        {
            
if  (Error  !=   null )
            {
                Error(sender, e);
            }
       }


在数据的接收还原中,我们用到了

 EndByte的变量,这个变量是协议数据的结束字符,如果检测到有这个字符的,就表明收到了一条完整的协议,可以把收到的字节数组组装成文本字符串,然后交给委托事件进行处理即可。

 

在外部的宿主程序中,当有数据收到的时候,辅助类会通知其对数据进行处理,如我们在宿主程序中绑定处理代码如下所示。

         void  serial_DataReceived(DataReceivedEventArgs e)
        {
            
this .txtReceived.Invoke( new  MethodInvoker( delegate
            {
                
this .txtReceived.AppendText(e.DataReceived  +  Environment.NewLine);
            }));
        }


这样,一旦收到一条完整的协议,界面上就会在文本框中增加一行数据,如前面的图所示

 

  

最后呈上该串口辅助类库提供下载,欢迎大家提供改善意见,多多交流。

http://files.cnblogs.com/wuhuacong/SerialPortUtil.rar 

 


原文链接:http://www.cnblogs.com/wuhuacong/archive/2011/07/19/2111055.html
<无标签>
举报
长平狐
发帖于5年前 0回/312阅
顶部