串口通讯类

最新推荐文章于 2019-07-31 15:46:55 发布
最新推荐文章于 2019-07-31 15:46:55 发布
阅读量353 收藏 2
点赞数
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuoyefeng1990/article/details/62036772
版权

PC与外设通讯、与下位机经常用到串口通讯，为了高效方便封装一个好的串口操作类是必要的啦，以下是代码。

//Commhelper.cs
using System;
using System.Runtime.InteropServices;
namespace Comm
{
    public class myCom
    {
        #region WINAPI常量
        /// <summary>
        /// 写标志
        /// </summary>
        private const uint GENERIC_READ = 0x80000000;
        /// <summary>
        /// 读标志
        /// </summary>
        private const uint GENERIC_WRITE = 0x40000000;
        /// <summary>
        /// 打开已存在
        /// </summary>
        private const int OPEN_EXISTING = 3;
        /// <summary>
        /// 无效句柄
        /// </summary>
        private const int INVALID_HANDLE_VALUE = -1;
        #endregion

        #region 成员变量
        /// <summary>
        /// 端口名称(COM1,COM2...COM4...)
        /// </summary>
        public int PortNum;
        /// <summary>
        /// 波特率9600
        /// </summary>
        public int BaudRate;
        /// <summary>
        /// 数据位4-8
        /// </summary>
        public byte ByteSize;
        /// <summary>
        /// 奇偶校验0-4=no,odd,even,mark,space
        /// </summary>
        public byte Parity;
        /// <summary>
        /// 停止位
        /// </summary>
        public byte StopBits; // 0,1,2 = 1, 1.5, 2
        /// <summary>
        /// 超时长
        /// </summary>
        public int ReadTimeout;
        /// <summary>
        /// COM口句柄
        /// </summary>
        private int hComm = INVALID_HANDLE_VALUE;
        /// <summary>
        /// 串口是否已经打开
        /// </summary>
        public bool Opened = false;
        #endregion
        /// <summary>
        /// 设备控制块结构体类型
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        public struct DCB
        {
            /// <summary>
            /// DCB长度
            /// </summary>
            public int DCBlength;
            /// <summary>
            /// 指定当前波特率
            /// </summary>
            public int BaudRate;
            /// <summary>
            /// 指定是否允许二进制模式
            /// </summary>
            public int fBinary;
            /// <summary>
            /// 指定是否允许奇偶校验
            /// </summary>
            public int fParity;
            /// <summary>
            /// 指定CTS是否用于检测发送控制，当为TRUE是CTS为OFF，发送将被挂起。
            /// </summary>
            public int fOutxCtsFlow;
            /// <summary>
            /// 指定CTS是否用于检测发送控制
            /// </summary>
            public int fOutxDsrFlow;
            /// <summary>
            /// DTR_CONTROL_DISABLE值将DTR置为OFF, DTR_CONTROL_ENABLE值将DTR置为ON, DTR_CONTROL_HANDSHAKE允许DTR"握手"
            /// </summary>
            public int fDtrControl;
            /// <summary>
            /// 当该值为TRUE时DSR为OFF时接收的字节被忽略
            /// </summary>
            public int fDsrSensitivity;
            /// <summary>
            /// 指定当接收缓冲区已满,并且驱动程序已经发送出XoffChar字符时发送是否停止。
            /// TRUE时，在接收缓冲区接收到缓冲区已满的字节XoffLim且驱动程序已经发送出
            /// XoffChar字符中止接收字节之后，发送继续进行。　FALSE时，在接收缓冲区接
            /// 收到代表缓冲区已空的字节XonChar且驱动程序已经发送出恢复发送的XonChar之
            /// 后，发送继续进行。XOFF continues Tx
            /// </summary>
            public int fTXContinueOnXoff;
            /// <summary>
            /// TRUE时，接收到XoffChar之后便停止发送接收到XonChar之后将重新开始 XON/XOFF
            /// out flow control
            /// </summary>
            public int fOutX;
            /// <summary>
            /// TRUE时，接收缓冲区接收到代表缓冲区满的XoffLim之后，XoffChar发送出去接收
            /// 缓冲区接收到代表缓冲区空的XonLim之后，XonChar发送出去 XON/XOFF in flow control
            /// </summary>
            public int fInX;
            /// <summary>
            /// 该值为TRUE且fParity为TRUE时，用ErrorChar 成员指定的字符代替奇偶校验错误
            /// 的接收字符 enable error replacement
            /// </summary>
            public int fErrorChar;
            /// <summary>
            /// eTRUE时，接收时去掉空（0值）字节 enable null stripping
            /// </summary>
            public int fNull;
            /// <summary>
            /// RTS flow control RTS_CONTROL_DISABLE时,RTS置为OFF RTS_CONTROL_ENABLE时, RTS置为ON
            /// RTS_CONTROL_HANDSHAKE时,当接收缓冲区小于半满时RTS为ON当接收缓冲区超过四分之
            /// 三满时RTS为OFF RTS_CONTROL_TOGGLE时,当接收缓冲区仍有剩余字节时RTS为ON ,否则
            /// 缺省为OFF
            /// </summary>
            public int fRtsControl;
            /// <summary>
            /// TRUE时,有错误发生时中止读和写操作 abort on error
            /// </summary>
            public int fAbortOnError;
            /// <summary>
            /// 未使用
            /// </summary>
            public int fDummy2;
            /// <summary>
            /// 标志位
            /// </summary>
            public uint flags;
            /// <summary>
            /// 未使用,必须为0
            /// </summary>
            public ushort wReserved;
            /// <summary>
            /// 指定在XON字符发送这前接收缓冲区中可允许的最小字节数
            /// </summary>
            public ushort XonLim;
            /// <summary>
            /// 指定在XOFF字符发送这前接收缓冲区中可允许的最小字节数
            /// </summary>
            public ushort XoffLim;
            /// <summary>
            /// 指定端口当前使用的数据位
            /// </summary>
            public byte ByteSize;
            /// <summary>
            /// 指定端口当前使用的奇偶校验方法,可能为:EVENPARITY,MARKPARITY,NOPARITY,ODDPARITY 0-4=no,odd,even,mark,space
            /// </summary>
            public byte Parity;
            /// <summary>
            /// 指定端口当前使用的停止位数,可能为:ONESTOPBIT,ONE5STOPBITS,TWOSTOPBITS 0,1,2 = 1, 1.5, 2
            /// </summary>
            public byte StopBits;
            /// <summary>
            /// 指定用于发送和接收字符XON的值 Tx and Rx XON character
            /// </summary>
            public char XonChar;
            /// <summary>
            /// 指定用于发送和接收字符XOFF值 Tx and Rx XOFF character
            /// </summary>
            public char XoffChar;
            /// <summary>
            /// 本字符用来代替接收到的奇偶校验发生错误时的值
            /// </summary>
            public char ErrorChar;
            /// <summary>
            /// 当没有使用二进制模式时,本字符可用来指示数据的结束
            /// </summary>
            public char EofChar;
            /// <summary>
            /// 当接收到此字符时,会产生一个事件
            /// </summary>
            public char EvtChar;
            /// <summary>
            /// 未使用
            /// </summary>
            public ushort wReserved1;
        }
        /// <summary>
        /// 串口超时时间结构体类型
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        private struct COMMTIMEOUTS
        {
            public int ReadIntervalTimeout;
            public int ReadTotalTimeoutMultiplier;
            public int ReadTotalTimeoutConstant;
            public int WriteTotalTimeoutMultiplier;
            public int WriteTotalTimeoutConstant;
        }
        /// <summary>
        /// 湓出缓冲区结构体类型
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        private struct OVERLAPPED
        {
            public int Internal;
            public int InternalHigh;
            public int Offset;
            public int OffsetHigh;
            public int hEvent;
        }
        /// <summary>
        /// 打开串口
        /// </summary>
        /// <param name="lpFileName">要打开的串口名称</param>
        /// <param name="dwDesiredAccess">指定串口的访问方式，一般设置为可读可写方式</param>
        /// <param name="dwShareMode">指定串口的共享模式，串口不能共享，所以设置为0</param>
        /// <param name="lpSecurityAttributes">设置串口的安全属性，WIN9X下不支持，应设为NULL</param>
        /// <param name="dwCreationDisposition">对于串口通信，创建方式只能为OPEN_EXISTING</param>
        /// <param name="dwFlagsAndAttributes">指定串口属性与标志，设置为FILE_FLAG_OVERLAPPED(重叠I/O操作)，指定串口以异步方式通信</param>
        /// <param name="hTemplateFile">对于串口通信必须设置为NULL</param>
        [DllImport("kernel32.dll")]
        private static extern int CreateFile(string lpFileName, uint dwDesiredAccess, int dwShareMode,
        int lpSecurityAttributes, int dwCreationDisposition, int dwFlagsAndAttributes, int hTemplateFile);
        /// <summary>
        /// 得到串口状态
        /// </summary>
        /// <param name="hFile">通信设备句柄</param>
        /// <param name="lpDCB">设备控制块DCB</param>
        [DllImport("kernel32.dll")]
        private static extern bool GetCommState(int hFile, ref DCB lpDCB);
        /// <summary>
        /// 建立串口设备控制块
        /// </summary>
        /// <param name="lpDef">设备控制字符串</param>
        /// <param name="lpDCB">设备控制块</param>
        [DllImport("kernel32.dll")]
        private static extern bool BuildCommDCB(string lpDef, ref DCB lpDCB);
        /// <summary>
        /// 设置串口状态
        /// </summary>
        /// <param name="hFile">通信设备句柄</param>
        /// <param name="lpDCB">设备控制块</param>
        [DllImport("kernel32.dll")]
        private static extern bool SetCommState(int hFile, ref DCB lpDCB);
        /// <summary>
        /// 读取串口超时时间
        /// </summary>
        /// <param name="hFile">通信设备句柄</param>
        /// <param name="lpCommTimeouts">超时时间</param>
        [DllImport("kernel32.dll")]
        private static extern bool GetCommTimeouts(int hFile, ref COMMTIMEOUTS lpCommTimeouts);
        /// <summary>
        /// 设置串口超时时间
        /// </summary>
        /// <param name="hFile">通信设备句柄</param>
        /// <param name="lpCommTimeouts">超时时间</param>
        [DllImport("kernel32.dll")]
        private static extern bool SetCommTimeouts(int hFile, ref COMMTIMEOUTS lpCommTimeouts);
        /// <summary>
        /// 读取串口数据
        /// </summary>
        /// <param name="hFile">通信设备句柄</param>
        /// <param name="lpBuffer">数据缓冲区</param>
        /// <param name="nNumberOfBytesToRead">多少字节等待读取</param>
        /// <param name="lpNumberOfBytesRead">读取多少字节</param>
        /// <param name="lpOverlapped">溢出缓冲区</param>
        [DllImport("kernel32.dll")]
        private static extern bool ReadFile(int hFile, byte[] lpBuffer,
        int nNumberOfBytesToRead, ref int lpNumberOfBytesRead, ref OVERLAPPED lpOverlapped);
        /// <summary>
        /// 写串口数据
        /// </summary>
        /// <param name="hFile">通信设备句柄</param>
        /// <param name="lpBuffer">数据缓冲区</param>
        /// <param name="nNumberOfBytesToWrite">多少字节等待写入</param>
        /// <param name="lpNumberOfBytesWritten">已经写入多少字节</param>
        /// <param name="lpOverlapped">溢出缓冲区</param>
        [DllImport("kernel32.dll")]
        private static extern bool WriteFile(int hFile, byte[] lpBuffer,
        int nNumberOfBytesToWrite, ref int lpNumberOfBytesWritten, ref OVERLAPPED lpOverlapped);
        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern bool FlushFileBuffers(int hFile);
        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern bool PurgeComm(int hFile, uint dwFlags);
        /// <summary>
        /// 关闭串口
        /// </summary>
        /// <param name="hObject">通信设备句柄</param>
        [DllImport("kernel32.dll")]
        private static extern bool CloseHandle(int hObject);
        /// <summary>
        /// 得到串口最后一次返回的错误
        /// </summary>
        [DllImport("kernel32.dll")]
        private static extern uint GetLastError();
        /// <summary>
        /// 建立与串口的连接
        /// </summary>
        public bool Open()
        {
            DCB dcbCommPort = new DCB();
            COMMTIMEOUTS ctoCommPort = new COMMTIMEOUTS();
            // 打开串口
            hComm = CreateFile("COM" + PortNum, GENERIC_READ | GENERIC_WRITE,
             0, 0, OPEN_EXISTING, 0, 0);
            if (hComm == INVALID_HANDLE_VALUE)
            {
                return false;
            }
            // 设置通信超时时间
            GetCommTimeouts(hComm, ref ctoCommPort);
            ctoCommPort.ReadTotalTimeoutConstant = ReadTimeout;
            ctoCommPort.ReadTotalTimeoutMultiplier = 0;
            ctoCommPort.WriteTotalTimeoutMultiplier = 0;
            ctoCommPort.WriteTotalTimeoutConstant = 0;
            SetCommTimeouts(hComm, ref ctoCommPort);
            // 设置串口
            GetCommState(hComm, ref dcbCommPort);
            dcbCommPort.fOutxCtsFlow = 524800;
            dcbCommPort.BaudRate = BaudRate;
            dcbCommPort.flags = 0;
            dcbCommPort.flags |= 1;
            if (Parity > 0)
            {
                dcbCommPort.flags |= 2;
            }
            dcbCommPort.Parity = Parity;
            dcbCommPort.ByteSize = ByteSize;
            dcbCommPort.StopBits = StopBits;
            dcbCommPort.fOutxCtsFlow = 524800;
            if (!SetCommState(hComm, ref dcbCommPort))
            {
                return false;
            }
            Opened = true;
            return true;
        }
        /// <summary>
        /// 关闭串口,结束通讯
        /// </summary>
        public bool Close()
        {
            if (hComm != INVALID_HANDLE_VALUE)
            {
                CloseHandle(hComm);
                Opened = false;
                return true;
            }
            return false;
        }
        /// <summary>
        /// 读取串口返回的数据
        /// </summary>
        /// <param name="NumBytes">数据长度</param>
        public byte[] Read(int NumBytes)
        {
            byte[] BufBytes;
            byte[] OutBytes;
            BufBytes = new byte[NumBytes];
            if (hComm != INVALID_HANDLE_VALUE)
            {
                OVERLAPPED ovlCommPort = new OVERLAPPED();
                int BytesRead = 0;

                ReadFile(hComm, BufBytes, NumBytes, ref BytesRead, ref ovlCommPort);
                OutBytes = new byte[BytesRead];
                Array.Copy(BufBytes, OutBytes, BytesRead);
                return OutBytes;
            }
            else
            {
                return new byte[0];
            }
        }
        /// <summary>
        /// 清空COM口缓冲区数据
        /// </summary>
        /// <returns></returns>
        public bool ClearPortData()
        {
            if (hComm != INVALID_HANDLE_VALUE)
            {
                return PurgeComm(hComm, 0);
            }
            return false;
        }
        /// <summary>
        /// 向串口写数据
        /// </summary>
        /// <param name="WriteBytes">数据数组</param>
        public int Write(byte[] WriteBytes)
        {
            bool result;
            if (hComm != INVALID_HANDLE_VALUE)
            {
                OVERLAPPED ovlCommPort = new OVERLAPPED();
                int BytesWritten = 0;
                WriteFile(hComm, WriteBytes, WriteBytes.Length,
                 ref BytesWritten, ref ovlCommPort);
                return BytesWritten;
            }
            else
            {
                return 0;
            }
        }
    }
}


zuoyefeng1990
关注
专栏目录
【QT开发】串口通信管理QSerialPort类详解及实战应用
科技改变人类，技术成就未来
07-16 4926
QSerialPort 是 Qt 提供的一个功能强大、简单易用的串口通信类。通过本文的学习，您应该对 QSerialPort 的基本使用、高级应用技巧及相关注意事项有了全面的理解。在实际项目中，QSerialPort 可以帮助实现与外部设备的串口通信，确保数据的可靠传输和接收。希望本文能帮助您更好地理解和使用 QSerialPort，在各种应用场景中实现高效稳定的串口通信。
串口通讯类（SerialPort类）
03-26
串口通讯SerialPort类，不错的资源，可以在此基础上做二次开发
串口通信类
04-09
封装的一个串口通信类，可实现收发数据，可发字符串，
引用kernel32.dll中的API来进行串口通讯
yylooker2008的专栏
06-04 2567
<br />串口通讯可以引出kernel32.dll中的API来操作,相关源码如下:<br />using System;<br />using System.Runtime.InteropServices;<br /><br />namespace Telehome.GSM<br />{<br />/// <summary><br />/// **********************************************************************************
一个串口通讯的类
大伟的代码空间
12-12 1051
一个串口通讯的类 /**//* CommUtils.h */#ifndef _CommUtils_H__#define _CommUtils_H__class CommUtils  {public:    bool ReadCom(unsigned char * ReceiveData, DWORD& ReceiveLength);    void CloseCom();    bool 
串口通信类(2)
weixin_30455023的博客
07-31 191
现假设有一系列产品我们需要使用软件控制其运作,我们可以通过向设备发送各种指令来达到此要求,首先由于产品种类较多,而且有些产品是纵向升级的,升级之后的产品基本上保持原有功能基础上加了些新功能,基于此要求,我们在设计相应类时,可以使用继承的方法,通信基类使用抽象类不允许直接实例化,仅提供一般串口操作的方法,比如发送指令及关串口等操作(初始化串口及打开串口操作在构造函数中完成),这样有任何产品只要从这个...
[065]VC++串口通讯类应用实例233626488基于VC++的一个串口通讯类应用实例.z上位机开发VC串口学习资料源码ip
05-04
[065]VC++串口通讯类应用实例233626488基于VC++的一个串口通讯类应用实例.z上位机开发VC串口学习资料源码ip[065]VC++串口通讯类应用实例233626488基于VC++的一个串口通讯类应用实例.z上位机开发VC串口学习资料源码ip...
VC++串口通讯类应用实例233626488基于VC++的一个串口通讯类应用实例.rar
最新发布
06-20
在本文中，我们将深入探讨基于VC++的串口通讯类应用实例，这是一款适用于嵌入式软件开发上位机的工具。使用Visual C++（VC++）和Microsoft Foundation Classes（MFC）框架，我们可以构建强大的串口通信功能，这对于...
[064]VC++串口通讯类，用于初学串口通讯，及串口通讯原理有一定帮助.zip上位机开发VC串口学习资料源码下载
05-04
[064]VC++串口通讯类，用于初学串口通讯，及串口通讯原理有一定帮助.zip上位机开发VC串口学习资料源码下载[064]VC++串口通讯类，用于初学串口通讯，及串口通讯原理有一定帮助.zip上位机开发VC串口学习资料源码下载...
串口通信类（c++ 代码）
08-24
资源是用c++封装的串口通信类，可以直接调用该类的对象进行通信且参数会自动保存到配置文件可以自由设置
VC开发的串口通讯类（静态库，含使用范例和注解）
09-13
这是我用VC写的一个串口通信类，是静态库形式的，可随工程一起编译。里面还有在MFC中使用的简单范例，当然Win32程序也可以调用，因为设计时就是用纯API打造的，当初也是为Win32应用程序做的接口类。因为采用的是多线程的方式处理，对CPU的占用率也是很低很低的，运行效率还不错，使用也方便，还有类似于 VB 事件的概念。 看范例就知道了。
最新版本CserialPort类 强大串口通讯类
11-27
简单而强大的多线程串口编程工具CserialPort类（附VC基于MFC详细编程步骤）
串口通信类SerialPort
11-08
从网上搜集的各种串口通信类，源代码库和Demo代码，赋有下载连接说明。
使用API函数实现的串口通讯DLL（含源码VC++）
05-14
使用API函数实现的串口通讯DLL，使用VC++编写，可以单独使用，注意看“使用说明.txt”,奇怪，为什么现在有这种限制了
一个实用的串口通信类
逸涵科技
10-03 4180
     算起来，我在CSDN上注册也有四年了啊，没想到他们还保存着这个文档。    现在整理BLOG，也把它整理一下吧。    这是一个通过计算机串口发送和接收数据的类，是一个不成熟的类，现在我没有再使用它了，但它却把串口的API操作全用到了，如果你对这很熟了，我想你可以不用再花时间了看了，代码编写和你心中想的一样“rubbsh”，因为这段代码还完成了其它功能，不是一个单独的模块。   
通用串口通信类
weixin_30924239的博客
10-28 229
　　以前串口通信一直用AxInterop.MSCommLib第三方串口通信类，但是发现那个东西用着很麻烦，因为需要设置ActiveX控件的持久状态OcxState，这个东西又蛋疼的一般在Winform的Designer里面，随意调整一下界面的布局，那个OcxState的设定就不见了。。。还有个蛋疼的地方就是打开和关闭串口需要比较久的时间。 　　于是我就想要自己写一个串口通信类，就叫做Serial...
.net 封装串口通讯类
07-03
### 回答1： 在.NET中，我们可以使用SerialPort类来封装...总之，通过.NET封装串口通讯类，可以方便地实现对串口的读取和写入操作，并可以根据具体的需求封装自定义的方法和事件，以实现更加灵活和高效的串口通信功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值