C# SerialPort 串口读写

最新推荐文章于 2025-11-13 11:58:14 发布
原创 最新推荐文章于 2025-11-13 11:58:14 发布 · 4w 阅读 · 119 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#源码 #c# #技术

本文作者分享了在经历多次尝试后，如何基于C#编写一个可靠的串口读写类库。文章详细介绍了实现过程，包括定义串口操作类，实现DataReceived事件处理数据接收，通过后台线程监控数据接收完成，并定义多个事件通知数据状态。作者还提供了源码示例，供读者下载参考。

之前一直从博客园看别人的技术文章，下载别人的资源，今天终于忍不住自己写下这篇博客。为了实现稳定串口读写最近也折腾了很久，但是在网上找了很久都没有找到比较好的代码。最后去了一些外国的网站学习了别人的思想后，通过自己的理解终于写了一个测试程序，本程序经过测试发送接收大量数据均无bug出现。


首先介绍一下实现流程。

1.首先我们需要定义一个专门的串口操作类。

2.类中实现串口事件DataReceived接收数据。

3.需要后台开启一个监控线程来监控是否数据接收完成，因为串口事件是触发式，在双方没有固定协议的情况下不知道什么时候才标志接收完整的数据包。在这里思考了很久，目前本人只想到了通过时间来判定，似乎没有其他更好方法，如果在指定的时间内没有收到数据我们则认为数据接收终止。

4.定义3个事件，用来通知数据接收完成、数据发送完成、每次接收数据。

好了不多说了下面先贴上该类的源码吧


串口主要处理类

  /// <summary>
    /// 委托处理结果
    /// </summary>
    /// <param name="data"></param>
    public delegate void HandResult(object sender,SerialPortEvents e);

    /// <summary>
    /// 委托处理接收数据完成
    /// </summary>
    /// <param name="data"></param>
    public delegate void OnReceivedData(object sender,SerialPortEvents e);

    /// <summary>
    /// 发送数据回调
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public delegate void OnSendData(object sender,SerialPortEvents e);

    public class SerialPortListener
    {
        #region 成员变量
        /// <summary>
        /// 定义接收缓冲区数据
        /// </summary>
        private List<byte> m_buffer = null;

        public event HandResult SerialPortResult;

        public event OnReceivedData OnSerialPortReceived;

        public event OnSendData OnSeriaPortSend;

        delegate void AsyncCallResult(byte[] data);

        delegate void AsyncSend(byte[] data);

        bool m_isReceiving = false;

        /// <summary>
        /// 串口对象
        /// </summary>
        SerialPort m_serialPort = null;

        Thread m_threadMonitor = null;

        /// <summary>
        /// 结束符号
        /// </summary>
        char m_endChar = '\0';
        public char EndChar
        {
            get { return m_endChar; }
            set { m_endChar = value; }
        }

        /// <summary>
        /// 发送缓冲区大小
        /// </summary>
        int m_writeBufferSize = 1024;
        public int WriteBufferSize
        {
            get { return m_writeBufferSize; }
            set { m_writeBufferSize = value;}
        }

        /// <summary>
        /// 是否启用结束符
        /// </summary>
        bool m_useEndChar = true;
        public bool UseEndChar
        {
            get { return m_useEndChar; }
            set { m_useEndChar = value; }
        }


        /// <summary>
        /// 发送间隔时间
        /// </summary>
        int m_sendInterval = 100;

        public int SendInterval
        {
            get { return m_sendInterval; }
            set { m_sendInterval = value; }
        }

        /// <summary>
        /// 连续接收超时时间
        /// </summary>
        int m_receiveTimeout =1000;

        public int ReceiveTimeout
        {
            get { return m_receiveTimeout; }
            set { m_receiveTimeout = value; }
        }

        /// <summary>
        /// 最后接收时间
        /// </summary>
        DateTime m_lastReceiveTime;

        public DateTime LastReceiveTime
        {
            get { return m_lastReceiveTime; }
        }

        /// <summary>
        /// 缓冲区接收大小
        /// </summary>
        private int m_bufferSize = 1;

        public int BufferSize
        {
            get { return m_bufferSize; }
            set { m_bufferSize = value; }
        }

        /// <summary>
        /// 串口名称
        /// </summary>
        private string m_portName = "COM1";

        public string PortName
        {
            get { return m_portName; }
            set { m_portName = value; }
        }

        /// <summary>
        /// 波特率
        /// </summary>
        private int m_baudRate = 9600;

        public int BaudRate
        {
            get { return m_baudRate; }
            set { m_baudRate = value; }
        }

        /// <summary>
        /// 停止位长度
        /// </summary>
        private StopBits m_stopBits = StopBits.None;

        public StopBits StopBits
        {
            get { return m_stopBits; }
            set { m_stopBits = value; }
        }

        /// <summary>
        /// 基偶校验位
        /// </summary>
        private Parity m_parity = Parity.None;

        public Parity Parity
        {
            get { return m_parity; }
            set { m_parity = value; }
        }

        /// <summary>
        /// 控制协议
        /// </summary>
        private Handshake m_handshake = Handshake.None;

        public Handshake Handshake
        {
            get { return m_handshake; }
            set { m_handshake = value; }
        }

        /// <summary>
        /// 标准数据长度
        /// </summary>
        private int m_dataBits = 8;

        public int DataBits
        {
            get { return m_dataBits; }
            set { m_dataBits = value; }
        }

        /// <summary>
        /// 缓冲区大小
        /// </summary>
        private int m_readBufferSize = 4;

        public int ReadBufferSize
        {
            get { return m_readBufferSize; }
            set { m_readBufferSize = value; }
        }

        /// <summary>
        /// 输入缓冲区中的字节数
        /// </summary>
        private int m_receivedBytesThreshold = 1;

        public int ReceivedBytesThreshold
        {
            get { return m_receivedBytesThreshold; }
            set { m_receivedBytesThreshold = value;}
        }

        /// <summary>
        /// 获取当前是否打开
        /// </summary>
        public bool IsOpen {
            get {
                return m_serialPort == null ? false : m_serialPort.IsOpen;
            }
        }
        #endregion

        #region 构造方法
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="portName"></param>
        /// <param name="baudRate"></param>
        public SerialPortListener(string portName, int baudRate)
        {
            m_portName = portName;
            m_baudRate = baudRate;
            m_buffer = new List<byte>();
            m_serialPort = new SerialPort(portName, baudRate);
            m_serialPort.DataReceived += new SerialDataReceivedEventHandler(SerialPort_DataReceived);
        }
        #endregion

        #region 开启关闭串口
        /// <summary>
        /// 开始接收
        /// </summary>
        public bool Start()
        {
            try
            {
                m_serialPort.Parity = m_parity;
                m_serialPort.StopBits = m_stopBits;
                m_serialPort.Handshake = m_handshake;
                m_serialPort.DataBits = m_dataBits;
                m_serialPort.ReadBufferSize = m_readBufferSize;
                m_serialPort.ReceivedBytesThreshold = m_receivedBytesThreshold;
                m_serialPort.WriteBufferSize = m_writeBufferSize;
                m_serialPort.Open();
                m_threadMonitor = new Thread(new ThreadStart(SerialPortMonitor));
                m_threadMonitor.IsBackground = true;
                m_threadMonitor.Start();
                return true;
            }
            catch
            {
                throw new SerialPortException(string.Format("无法打开串口:{0}",m_serialPort.PortName));
            }
        }

        /// <summary>
        /// 停止
        /// </summary>
        public void Stop()
        {
            m_threadMonitor.Abort();
            m_serialPort.Close();
            m_buffer.Clear();
            GC.Collect();
        }
        #endregion

        #region 接收数据
        /// <summary>
        /// 接收数据
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void SerialPort_DataReceived(object sender, EventArgs e)
        {
            StartReceive();
            int availCount = m_serialPort.BytesToRead;
            byte[] bs = new byte[availCount];
            bool bEnd = false;
            for (int i = 0; i < availCount; i++)
            {
                //单个字节读取
                byte b = (byte)m_serialPort.ReadByte();
                if (m_useEndChar && b == m_endChar)
                {
                    //结束接收
                    bEnd = true;
                    break;
                }
                bs[i] = b;
            }
            lock (m_buffer)
                m_buffer.AddRange(bs);
            EndReceive(bs);
            if (bEnd)
                CallEndResult();
        }

        /// <summary>
        /// 开始接收
        /// </summary>
        void StartReceive()
        {
            if (!m_isReceiving)
                m_isReceiving = true;
        }

        /// <summary>
        /// 结束接收
        /// </summary>
        void EndReceive(byte[] bs)
        {
            //设置最后接收时间
            m_lastReceiveTime = DateTime.Now;
            m_isReceiving = false;
            if (OnSerialPortReceived != null
                &&bs!=null
                && bs.Length != 0)
            {
                AsyncCallResult call = new AsyncCallResult(CalReceived);
                call.BeginInvoke(bs, null, null); 
            }  
        }

        void CalReceived(byte[] data)
        {
            OnSerialPortReceived(this, new SerialPortEvents(data));
        }

        /// <summary>
        /// 读取结束监控
        /// </summary>
        void SerialPortMonitor()
        {
            if (!m_isReceiving)
            {
                if (DateTime.Now.Subtract(m_lastReceiveTime).TotalMilliseconds > m_receiveTimeout && m_buffer.Count != 0)
                {
                    CallEndResult();
                }
            }
            Thread.Sleep(50);
            SerialPortMonitor();
        }

        /// <summary>
        /// 处理接收数据完成
        /// </summary>
        void CallEndResult()
        {
            byte[] result = CopyBuffer(true);
            if (result != null && result.Length > 0)
            {
                if (SerialPortResult != null)
                {
                    //异步通知接收完成
                    AsyncCallResult call = new AsyncCallResult(CalResult);
                    call.BeginInvoke(result, null, null);      
                }
            }
        }

        void CalResult(byte[] data)
        {
            SerialPortResult(this, new SerialPortEvents(data));   
        }

        byte[] CopyBuffer(bool isClean=false)
        {
            byte[] bs=null;
            lock(m_buffer)
            {
                bs = new byte[m_buffer.Count];
                m_buffer.CopyTo(bs);
                if (isClean)
                    m_buffer.Clear();
            }
            return bs;
        }
        #endregion

        #region 发送数据
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="bs"></param>
        public void Send(byte[] bs)
        {
            if (!m_serialPort.IsOpen)
            {
                throw new SerialPortException("不能在串口关闭状态发送数据");
            }
            //异步发送
            AsyncSend call = new AsyncSend(DoAsyncSend);
            call.BeginInvoke(bs, null, null);
        }
        
        /// <summary>
        /// 异步发送
        /// </summary>
        /// <param name="data"></param>
        void DoAsyncSend(byte[] data)
        {
            int s = 0;

            if (data == null || data.Length == 0)
                return;
            if (m_useEndChar)
            {
                Array.Resize<byte>(ref data, data.Length + 1);
                data[data.Length - 1] = BitConverter.GetBytes(m_endChar)[0];
            }
            if (data.Length > m_writeBufferSize)
            {
                //分包发送
                int sendCount = 0;
                while (sendCount < data.Length)
                {
                    byte[] sendBytes;
                    if (sendCount + m_writeBufferSize > data.Length)
                    {
                        sendBytes = new byte[data.Length - sendCount];
                        Array.Copy(data, sendCount == 0 ? 0 : sendCount - 1, sendBytes, 0, sendBytes.Length);
                        sendCount = data.Length;
                    }
                    else
                    {
                        sendBytes = new byte[m_writeBufferSize];
                        Array.Copy(data, sendCount == 0 ? 0 : sendCount - 1, sendBytes, 0, sendBytes.Length);
                        sendCount += m_writeBufferSize;
                    }
                    //发送数据
                    m_serialPort.Write(sendBytes, 0, sendBytes.Length);
                    s += sendBytes.Length;
                    if (OnSeriaPortSend != null)
                        OnSeriaPortSend(this, new SerialPortEvents(sendBytes));
                    Array.Resize<byte>(ref sendBytes, 0);
                    Thread.Sleep(m_sendInterval);
                }
            }
            else
            { 
                //一次发送
                m_serialPort.Write(data, 0, data.Length);
            }
            //清理数据
            Array.Clear(data, 0, data.Length);
            data = null;
        }
        #endregion
    }

自定义事件类 

    public class SerialPortEvents:EventArgs
    {
        /// <summary>
        /// 传递数据
        /// </summary>
        private byte[] m_bufferData;
        public byte[] BufferData
        {
            get { return m_bufferData; }
            set { m_bufferData = value; }
        }

        public SerialPortEvents()
            : base()
        { 
        }

        public SerialPortEvents(byte[] data)
            : base()
        {
            m_bufferData = data;
        }

    }

调用方法： 

  SerialPortListener m_SerialPort = null;
            if (m_SerialPort == null)
            {
                m_SerialPort = new SerialPortListener(tbPort.Text, Convert.ToInt32(tbFrequency.Text));
                m_SerialPort.Parity = Parity.None;
                m_SerialPort.StopBits = StopBits.One;
                m_SerialPort.Handshake = Handshake.None;
                m_SerialPort.DataBits = 8;
                m_SerialPort.ReadBufferSize = 100;
                m_SerialPort.ReceivedBytesThreshold = 1;
                m_SerialPort.BufferSize = 4;
                m_SerialPort.ReceiveTimeout = Convert.ToInt32(tbTimeout.Text);
                m_SerialPort.WriteBufferSize = 100;
                m_SerialPort.SendInterval = 100;
                m_SerialPort.SerialPortResult += new HandResult(SerialPort_Result);
                m_SerialPort.OnSerialPortReceived += new OnReceivedData(SerialPort_Received);
                m_SerialPort.OnSeriaPortSend += new OnSendData(SerialPort_Send);
            }

            if (m_SerialPort.IsOpen)
            {
                m_SerialPort.Stop();
                btnListen.Text = "启动监听";
            }
            else
            {
                m_SerialPort.Start();
                btnListen.Text = "关闭监听";
            }

定义三个事件，用来通知UI线程：

1.收到结果触发

        void SerialPort_Result(object sender,SerialPortEvents e)
        {
            this.Invoke(new MethodInvoker(() => {
                //处理结果
                rtbResult.Text += Encoding.GetEncoding("GB2312").GetString(e.BufferData);
            }));
        }

2.串口有数据接收的时候触发 

        void SerialPort_Received(object sender, SerialPortEvents e)
        {
            this.Invoke(new MethodInvoker(() =>
            {
                long receivedCount = Convert.ToInt64(lbReceivedCount.Text);
                if (e.BufferData != null)
                {
                    receivedCount += e.BufferData.Length;
                }
                lbReceivedCount.Text = receivedCount.ToString();
            }));
        }

3.发送数据的时候触发 

        void SerialPort_Send(object sender, SerialPortEvents e)
        {
            this.Invoke(new MethodInvoker(() =>
            {
                long sendCount = Convert.ToInt64(lbSendCount.Text);
                if (e.BufferData != null)
                {
                    sendCount += e.BufferData.Length;
                }
                lbSendCount.Text = sendCount.ToString();
            }));
        }


附上效果图：



发送界面



接收界面：



系统源码已上传到博客园，下载地址：http://download.csdn.net/detail/kolvin2008/9655420


Ben-Tech
关注
C# SerialPort串口通信
m0_48285588的博客
02-17 552
串行通信的方式相较于并行通信的方式传输速度较慢，但所需的传输线路较少，较为适合长距离通信和简化设备通信。3.数据读写：通过SerialPort的Read和Write读写方法，来读取和写入数据，多应用于嵌入式系统开发和远程通信。硬件发来一串消息,将其拆分为一帧一帧的数据，每一帧的数据是10个字节，帧头是0x23，帧尾是0x46。2、创建一个实体类用于存放所有的串口，便于其他类调用,具体的数据解析根据自己的需求进行编写，这里就不给出详细案例了。2.串口参数有：串口号、波特率、校验位、数据位等。
C# SerialPort连接串口，读写串口数据
热门推荐
Fred_1986的博客
09-23 1万+
C# SerialPort连接串口，读写串口数据 一、起始 最近在公司做上位机，上位机要求是能够读取一款支持串口通信的传感器并且把传感器的数据用图表显示出来,且上位机能对传感器发送指令，需求有涉及到串口通信和绘制图表。 那么首先要解决的问题就是能够让电脑上的程序进行串口通信，有串口通信的编程语言有很多，C++,C#,JAVA,Python等语言都是支持串口通信的。我选择了使用C#，因为上位机主要是在Windows操作系统上运行，而C#对于winodws桌面应用的开发支持是比较方便的，功能也比较强大，尤其是W
基于C#串口读写程序
01-03
基于C#串口读写程序 //程序开启，串口初始化 private void Form1_Load(object sender, System.EventArgs e) { mycom1.PortNum = iPort; mycom1.BaudRate = iRate; mycom1.ByteSize = bSize; mycom1.Parity = bParity; mycom1.StopBits = bStopBits; mycom1.ReadTimeout = iTimeout; if (this.OpenCom()) msg.AppendText("串口初始化成功……\r\n"); else msg.AppendText("串口初始化失败！\r\n"); } //显示包信息 public string dis_package(byte[] reb) { string temp = ""; foreach (byte b in reb) temp += b.ToString("X2") + " "; return temp; } //开串口 public bool OpenCom() { try { if (mycom1.Opened) { mycom1.Close(); mycom1.Open(); //打开串口
C# 简单的serialport控件读取数据
09-27
C# 简单的serialport控件读取数据
C#SerialPort实现串口数据发送与接收（仿真器版）
最新发布
weixin_51928672的博客
11-13 372
简单编写一个串口调试程序，仿真软件、代码都有，欢迎学习讨论
用c#操作串口进行有效的数据读写，使用serialport类进行编程
02-26
用c#开发的一个串口通信程序，实现用c#操作串口进行数据的读写，相当实用
.NET 2.0中串口通讯类SerialPort
10-25 2149
1。简介随着USB的流行，串口通讯已经应用到日常生活的很多方面了，USB是一种高速的串口通讯协议，USB接口非常复杂，通常被用在需要传输大量数据数据的地方，如U盘、相机、打印机等。除了USB这种较为奢侈的串口外，在工控和嵌入式行业，大量被使用的是另一种古老的串口协议，RS-232串口。RS-232是一种非常简洁的低速串口通讯接口，它可以同时进行数据接收和发送的工作。2。.NET 2.0对串
C# SerialPort 串行端口类 学习笔记
YLM1996的博客
10-15 1752
SerialPort 中的属性 1 :PortName 通讯端口名称 2：BaudRate 波特率 3：DataBits 数据位 4：StopBits 停止位 5：ReadTimeout 超时时间 6：IsOpen() SerialPort对象是否打开 SerialPort 中使用到的(方法)函数 Open() 打开串行端口链接 Close() 关闭端口链接 发送数据: 1 /Write 该函数有三个重载 Write(string text) 向串行端口发送字符串 Write...
C# 中的 SerialPort
weixin_54498280的博客
11-11 4676
C# 中的SerialPort类提供了对串行端口（如 COM 端口）进行通信的功能。通过SerialPort类，你可以打开、关闭端口，读取和写入数据以及设置通信参数等。
C#Com串口收发指令读写RFID
06-20
C#开发的RS232串口读写NFC卡源码，使用Serial port类，展示了打开串口设置不同的波特率、数据位、停止位、校验位，向串口发送读、写NFC标签的指令，串口接收读取的NFC标签数据等，解决串口接收数据不完整易分包等...
C# 调用SerialPort类读取和发送串口数据
08-11
简单明了的利用SerialPort类读取和发送串口数据
c#串口读写类，这对串口的读写操作
05-24
c#串口读写类，这对串口的读写的操作的类
ReadSerialPortData
12-02
简单的C# Console小程序，打开串口，读取数据，保存数据到本地
C#通过串口读取和发送数据
03-16
C#通过串口读取和发送数据，简单的串口读取发送数据例子，简单易懂，适合初学者，欢迎下载
C#实现串口操作（包括读写串口，显示数据）
10-04
C#实现打开串口，关闭串口，利用串口接收和发送数据，并且能把数据实时显示在屏幕上，实现世博功能！
精选资源
C# SerialPort IO操作 支持大数据收发
02-03
支持串口大量数据读写操作，能一次性读取数据，通过设置超时大小控制一次读取串口所有数据。支持事件触发，异步发送接收数据。附件有demo，可下载Virtual Serial Port Driver模拟串口测试。
C# SerialPort 使用详解
鲤籽鲲的博客
03-21 5182
C# SerialPort 使用详解
C# SerialPort串口ReadTimeout 超时异常。“System.TimeoutException”
Peter的博客
06-13 6203
Button x:Name="BtnConnect" Content="连接" HorizontalAlignment="Left" Margin="33,175,0,0" VerticalAlignment="Top" Width="75" Click="Connect_Click" Grid.Column="2" Height="22"/>在读取数据时，如果一直没有遇到换行符，那么在等待ReadTimeout时间后，抛出一个TimeoutException。才符合大彩屏的指令接收要求。
C# SerialPort串口调试程序的功能与应用
以下，我们将详细探讨在给定文件描述中提到的C# SerialPort串口通信编程的相关知识点。 ### 串口参数配置与存储 在串口通信中，正确配置串口参数至关重要，包括但不限于波特率、数据位、停止位和校验位。这些参数...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值