AI 助理
备案控制台
开发者社区 大数据 文章 正文

C#开发串口总结，并提炼串口辅助类到公用类库中

2017-12-04 1208
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

开发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 

本文转自博客园伍华聪的博客，原文链接：C#开发串口总结，并提炼串口辅助类到公用类库中，如需转载请自行联系原博主。



文章标签：
C#
数据处理
关键词：
C#类
C#类库
C#开发类
walb呀
目录
相关文章
小王老师呀
|
26天前
|
开发框架 .NET C#
C#|.net core 基础 - 删除字符串最后一个字符的七大类N种实现方式
【10月更文挑战第9天】在 C#/.NET Core 中，有多种方法可以删除字符串的最后一个字符，包括使用 `Substring` 方法、`Remove` 方法、`ToCharArray` 与 `Array.Copy`、`StringBuilder`、正则表达式、循环遍历字符数组以及使用 LINQ 的 `SkipLast` 方法。
小王老师呀
47 8
长梦
|
2月前
|
存储 C# 索引
C# 一分钟浅谈：数组与集合类的基本操作
【9月更文挑战第1天】本文详细介绍了C#中数组和集合类的基本操作，包括创建、访问、遍历及常见问题的解决方法。数组适用于固定长度的数据存储，而集合类如`List<T>`则提供了动态扩展的能力。文章通过示例代码展示了如何处理索引越界、数组长度不可变及集合容量不足等问题，并提供了解决方案。掌握这些基础知识可使程序更加高效和清晰。
长梦
73 2
小王老师呀
|
4天前
|
C# Python
使用wxpython开发跨平台桌面应用，对wxpython控件实现类似C#扩展函数处理的探究
【10月更文挑战第30天】使用 `wxPython` 开发跨平台桌面应用时，可以通过创建辅助类来模拟 C# 扩展函数的功能。具体步骤包括：1. 创建辅助类 `WxWidgetHelpers`；2. 在该类中定义静态方法，如 `set_button_color`；3. 在应用中调用这些方法。这种方法提高了代码的可读性和可维护性，无需修改 `wxPython` 库即可为控件添加自定义功能。但需要注意显式调用方法和避免命名冲突。
小王老师呀
6 1
龙大吉
|
11天前
|
JSON C# 开发者
C#语言新特性深度剖析：提升你的.NET开发效率
【10月更文挑战第15天】C#语言凭借其强大的功能和易用性深受开发者喜爱。随着.NET平台的演进，C#不断引入新特性，如C# 7.0的模式匹配和C# 8.0的异步流，显著提升了开发效率和代码可维护性。本文将深入探讨这些新特性，助力开发者在.NET开发中更高效地利用它们。
龙大吉
23 1
追逐时光者
|
17天前
|
开发框架 NoSQL MongoDB
C#/.NET/.NET Core开发实战教程集合
C#/.NET/.NET Core开发实战教程集合
追逐时光者
24 1
c的前世今生
|
2月前
|
物联网 C# C语言
物联网开发中C、C++和C#哪个更好用
在物联网（IoT）开发中，C、C++和C#各有优缺点，适用场景不同。C语言性能高、资源占用低，适合内存和计算能力有限的嵌入式系统，但开发复杂度高，易出错。C++支持面向对象编程，性能优秀，适用于复杂应用，但学习曲线陡峭，编译时间长。C#易于学习，与.NET框架结合紧密，适合快速开发Windows应用，但性能略低，平台支持有限。选择语言需根据具体项目需求、复杂性和团队技术栈综合考虑。
c的前世今生
83 3
何雨晨
|
23天前
|
XML 存储 安全
C#开发的程序如何良好的防止反编译被破解？ConfuserEx .NET混淆工具使用介绍
C#开发的程序如何良好的防止反编译被破解？ConfuserEx .NET混淆工具使用介绍
何雨晨
41 0
Codelinghu
|
24天前
|
Java 程序员 C#
【类的应用】C#应用之派生类构造方法给基类构造方法传参赋值
【类的应用】C#应用之派生类构造方法给基类构造方法传参赋值
Codelinghu
9 0
1919324350086154
|
27天前
|
C#
Delphi可不可以制作出像c#那样的dll类库？
在Delphi中，创建DLL项目（如dll.dpr）并定义一个类TMyCls后，在另一个项目（如test.dpr）中可以引入此DLL并直接实例化和调用类的方法。然而，Delphi目前主要支持两种DLL形式：动态链接库（需显式声明exports，仅支持函数调用）和ActiveX DLL（需定义IDL接口）。这两种方式都较为繁琐。相比之下，C# 的DLL类库更为便捷，编写并编译后即可在其他项目中直接使用。
1919324350086154
58 0
长梦
|
2月前
|
C# 数据安全/隐私保护
C# 一分钟浅谈：类与对象的概念理解
【9月更文挑战第2天】本文从零开始详细介绍了C#中的类与对象概念。类作为一种自定义数据类型，定义了对象的属性和方法；对象则是类的实例，拥有独立的状态。通过具体代码示例，如定义 `Person` 类及其实例化过程，帮助读者更好地理解和应用这两个核心概念。此外，还总结了常见的问题及解决方法，为编写高质量的面向对象程序奠定基础。
长梦
24 2

热门文章

最新文章

  • 1
    C#中读取二维数组每位的长度
  • 2
    如何使用 AllowPartiallyTrustedCallers 属性来调用具有一个强名称从 Web 页通过使用 Visual C#.NET、 Visual C# 2005年或更高版本的程序集
  • 3
    简单干净的C#方法设计案例：SFCUI.AjaxLoadPage()之二
  • 4
    Silverlight C# 游戏开发：自定义鼠标（一）
  • 5
    C#中的结构与类
  • 6
    乐在其中设计模式(C#) - 解释器模式(Interpreter Pattern)
  • 7
    C#并行编程-PLINQ:声明式数据并行
  • 8
    编写高质量代码改善C#程序的157个建议[4-9]
  • 9
    C#使用Xamarin开发可移植移动应用进阶篇(7.使用布局渲染器,修改默认布局),附源码
  • 10
    C#学习笔记——抽象类和抽象方法
  • 1
    C#深度揭秘：常量的魅力和实践，一文让你从新手到专家
    49
  • 2
    C# 读取二维数组集合输出到Word预设表格
    74
  • 3
    C# 读取多条数据记录导出到 Word 标签模板
    59
  • 4
    C# Post数据或文件到指定的服务器进行接收
    70
  • 5
    C# 实现网页内容保存为图片并生成压缩包
    56
  • 6
    C#实现基于Word保护性模板文件的修改
    81
  • 7
    C#实现Excel合并单元格数据导入数据集
    81
  • 8
    C# 读取Word表格到DataSet
    78
  • 9
    C# 将 Word 转化分享为电子期刊
    47
  • 10
    C#动态生成带参数的小程序二维码
    89

    • 相关电子书

    更多
  • 软件定义的数据智能
  • 面向领域的场景驱动设计
  • 动态、高效，蚂蚁动态卡片的内核逻辑

    • 相关实验场景

    更多
  • 使用Java面向对象编写网络通信程序应用
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月