SerialPort类

最新推荐文章于 2022-02-10 12:46:45 发布
最新推荐文章于 2022-02-10 12:46:45 发布
阅读量1k 收藏 2
点赞数
文章标签： CSerialPort 串口类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigtree_mfc/article/details/52278179
版权

做个记录自己看。

串口：USB-232（最好使用最新版的驱动）

SerialPort.h

#ifndef __SERIALPORT_H__  
#define __SERIALPORT_H__  
  
#define WM_COMM_BREAK_DETECTED      WM_USER+1     
#define WM_COMM_CTS_DETECTED            WM_USER+2     
#define WM_COMM_DSR_DETECTED            WM_USER+3  
#define WM_COMM_ERR_DETECTED            WM_USER+4     
#define WM_COMM_RING_DETECTED           WM_USER+5     
#define WM_COMM_RLSD_DETECTED           WM_USER+6     
#define WM_COMM_RXCHAR                      WM_USER+7     
#define WM_COMM_RXFLAG_DETECTED     WM_USER+8     
#define WM_COMM_TXEMPTY_DETECTED    WM_USER+9     
  
class CSerialPort  
{  
public:  
    void CloseComm();//2  
    //  
    CSerialPort();  
    virtual     ~CSerialPort();  
  
    //                                        
    BOOL        InitPort(CWnd* pPortOwner, UINT portnr, UINT baud,  
        char parity, UINT databits, UINT stopsbits,  
        DWORD dwCommEvents, UINT nBufferSize);  
  
    //  
    BOOL        StartMonitoring();  
    BOOL        RestartMonitoring();  
    BOOL        StopMonitoring();  
  
    DWORD       GetWriteBufferSize();  
    DWORD       GetCommEvents();  
    DCB         GetDCB();  
  
    void        WriteToPort(char* string);  
protected:  
  
    //   
    void        ProcessErrorMessage(char* ErrorText);  
    static UINT CommThread(LPVOID pParam);  
    static void ReceiveChar(CSerialPort* port, COMSTAT comstat);  
    static void WriteChar(CSerialPort* port);  
  
    //   
    CWinThread*         m_Thread;  
  
    //   
    CRITICAL_SECTION    m_csCommunicationSync;  
    BOOL                m_bThreadAlive;  
  
    //   
    HANDLE              m_hShutdownEvent;  
    HANDLE              m_hComm;  
    HANDLE              m_hWriteEvent;  
  
    //   
    HANDLE              m_hEventArray[3];  
  
    //   
    OVERLAPPED          m_ov;  
    COMMTIMEOUTS        m_CommTimeouts;  
    DCB                 m_dcb;  
  
    //  
    CWnd*               m_pOwner;  
  
    //   
    UINT                m_nPortNr;  
    char*               m_szWriteBuffer;  
    DWORD               m_dwCommEvents;  
    DWORD               m_nWriteBufferSize;  
};  
  
#endif __SERIALPORT_H__

SerialPort.cpp 

#include "stdafx.h"  
#include "SerialPort.h"  
  
#include <assert.h>  
  
  
CSerialPort::CSerialPort()  
{  
    m_hComm = NULL;  
  
  
    m_ov.Offset = 0;  
    m_ov.OffsetHigh = 0;  
  
  
    m_ov.hEvent = NULL;  
    m_hWriteEvent = NULL;  
    m_hShutdownEvent = NULL;  
  
    m_szWriteBuffer = NULL;  
  
    m_bThreadAlive = FALSE;  
}  
  
//  
//  
//  
CSerialPort::~CSerialPort()  
{  
    do  
    {  
        SetEvent(m_hShutdownEvent);  
    } while (m_bThreadAlive);  
  
    TRACE("Thread ended\n");  
  
    delete[] m_szWriteBuffer;  
  
}  
  
//  
//   
//  
BOOL CSerialPort::InitPort(CWnd* pPortOwner,    //   
    UINT  portnr,       //   
    UINT  baud,         //   
    char  parity,       //   
    UINT  databits,     //   
    UINT  stopbits,     //   
    DWORD dwCommEvents, //   
    UINT  writebuffersize)  //   
{  
    assert(portnr > 0 && portnr <= 256);  
    assert(pPortOwner != NULL);  
    unsigned int t = 0;  
    //   
    if (m_bThreadAlive)  
    {  
        MSG message;  
        while (m_bThreadAlive)  
        {  
            if (::PeekMessage(&message, m_pOwner->m_hWnd, 0, 0, PM_REMOVE))  
            {  
                ::TranslateMessage(&message);  
                ::DispatchMessage(&message);  
            }  
            SetEvent(m_hShutdownEvent);  
        }  
  
        TRACE("Thread ended\n");  
    }  
  
    //   
    if (m_ov.hEvent != NULL)  
        ResetEvent(m_ov.hEvent);  
    m_ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);  
  
    if (m_hWriteEvent != NULL)  
        ResetEvent(m_hWriteEvent);  
    m_hWriteEvent = CreateEvent(NULL, TRUE, FALSE, NULL);  
  
    if (m_hShutdownEvent != NULL)  
        ResetEvent(m_hShutdownEvent);  
    m_hShutdownEvent = CreateEvent(NULL, TRUE, FALSE, NULL);  
  
    //   
    m_hEventArray[0] = m_hShutdownEvent;    //   
    m_hEventArray[1] = m_ov.hEvent;  
    m_hEventArray[2] = m_hWriteEvent;  
  
    //   
    InitializeCriticalSection(&m_csCommunicationSync);  
  
    //   
    m_pOwner = pPortOwner;  
  
    if (m_szWriteBuffer != NULL)  
        delete[] m_szWriteBuffer;  
    m_szWriteBuffer = new char[writebuffersize];  
  
    m_nPortNr = portnr;  
  
    m_nWriteBufferSize = writebuffersize;  
    m_dwCommEvents = dwCommEvents;  
  
    BOOL bResult = FALSE;  
    char *szPort = new char[50];  
    char *szBaud = new char[50];  
  
    //   
    EnterCriticalSection(&m_csCommunicationSync);  
  
    //   
    if (m_hComm != NULL)  
    {  
        CloseHandle(m_hComm);  
        m_hComm = NULL;  
    }  
  
    //   
    //  
    if (portnr<10)  
    {  
        sprintf(szPort, "COM%d", portnr);  
    }  
    else  
    {  
        sprintf(szPort, "\\\\.\\COM%d", portnr);  
    }  
    sprintf(szBaud, "baud=%d parity=%c data=%d stop=%d", baud, parity, databits, stopbits);  
  
    //  
    m_hComm = CreateFile(szPort,                        //   
        GENERIC_READ | GENERIC_WRITE,   //   
        0,                              //   
        NULL,                           //  
        OPEN_EXISTING,                  //   
        FILE_FLAG_OVERLAPPED,           //  
        0);                         //   
  
    if (m_hComm == INVALID_HANDLE_VALUE)  
    {  
        //   
        delete[] szPort;  
        delete[] szBaud;  
  
        return FALSE;  
    }  
  
    //   
    m_CommTimeouts.ReadIntervalTimeout = 1000;  
    m_CommTimeouts.ReadTotalTimeoutMultiplier = 1000;  
    m_CommTimeouts.ReadTotalTimeoutConstant = 1000;  
    m_CommTimeouts.WriteTotalTimeoutMultiplier = 1000;  
    m_CommTimeouts.WriteTotalTimeoutConstant = 1000;  
  
    //  
    if (SetCommTimeouts(m_hComm, &m_CommTimeouts))  
    {  
        if (SetCommMask(m_hComm, dwCommEvents))  
        {  
            if (GetCommState(m_hComm, &m_dcb))  
            {  
                m_dcb.fRtsControl = RTS_CONTROL_ENABLE;     //  
                if (BuildCommDCB(szBaud, &m_dcb))  
                {  
  
                    m_dcb.XonLim = 2048;  
                    m_dcb.XoffLim = 2048;  
                    if (SetCommState(m_hComm, &m_dcb))  
                        ; //   
                    else  
                        ProcessErrorMessage("SetCommState()");  
                }  
                else  
                    ProcessErrorMessage("BuildCommDCB()");  
            }  
            else  
                ProcessErrorMessage("GetCommState()");  
        }  
        else  
            ProcessErrorMessage("SetCommMask()");  
    }  
    else  
        ProcessErrorMessage("SetCommTimeouts()");  
  
    delete[] szPort;  
    delete[] szBaud;  
  
    //   
    PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);  
  
    //   
    LeaveCriticalSection(&m_csCommunicationSync);  
  
    TRACE("Initialisation for communicationport %d completed.\nUse Startmonitor to communicate.\n", portnr);  
  
    return TRUE;  
}  
  
//  
//    
//  
UINT CSerialPort::CommThread(LPVOID pParam)  
{  
    //   
    //   
    CSerialPort *port = (CSerialPort*)pParam;  
  
    //   
    //   
    port->m_bThreadAlive = TRUE;  
  
    //   
    DWORD BytesTransfered = 0;  
    DWORD Event = 0;  
    DWORD CommEvent = 0;  
    DWORD dwError = 0;  
    static COMSTAT comstat;  
    BOOL  bResult = TRUE;  
  
    //   
    if (port->m_hComm)       //   
        PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);  
  
    //   
    for (;;)  
    {  
  
  
  
        bResult = WaitCommEvent(port->m_hComm, &Event, &port->m_ov);  
  
        if (!bResult)  
        {  
            //   
            //   
            switch (dwError = GetLastError())  
            {  
            case ERROR_IO_PENDING:  
            {  
                                     //   
                                     //   
                                     //   
                                     break;  
            }  
            case 87:  
            {  
                       //   
                       //   
                       //   
                       break;  
            }  
            default:  
            {  
                       //   
                       //   
                       port->ProcessErrorMessage("WaitCommEvent()");  
                       break;  
            }  
            }  
        }  
        else  
        {  
  
  
            bResult = ClearCommError(port->m_hComm, &dwError, &comstat);  
  
            if (comstat.cbInQue == 0)  
                continue;  
        }   //   
  
        //   
        //   
        Event = WaitForMultipleObjects(3, port->m_hEventArray, FALSE, INFINITE);  
  
        switch (Event)  
        {  
        case 0:  
        {  
                  //   
                  //   
  
                  port->m_bThreadAlive = FALSE;  
  
                  //   
                  AfxEndThread(100);  
                  break;  
        }  
        case 1: //   
        {  
                    GetCommMask(port->m_hComm, &CommEvent);  
                    if (CommEvent & EV_CTS)  
                        ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_CTS_DETECTED, (WPARAM)0, (LPARAM)port->m_nPortNr);  
                    if (CommEvent & EV_RXFLAG)  
                        ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RXFLAG_DETECTED, (WPARAM)0, (LPARAM)port->m_nPortNr);  
                    if (CommEvent & EV_BREAK)  
                        ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_BREAK_DETECTED, (WPARAM)0, (LPARAM)port->m_nPortNr);  
                    if (CommEvent & EV_ERR)  
                        ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_ERR_DETECTED, (WPARAM)0, (LPARAM)port->m_nPortNr);  
                    if (CommEvent & EV_RING)  
                        ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RING_DETECTED, (WPARAM)0, (LPARAM)port->m_nPortNr);  
  
                    if (CommEvent & EV_RXCHAR)  
                        //   
                        ReceiveChar(port, comstat);  
  
                    break;  
        }  
        case 2: //   
        {  
                    //  
                    WriteChar(port);  
                    break;  
        }  
  
        } //   
  
    } //  
  
    return 0;  
}  
  
//  
//   
//  
BOOL CSerialPort::StartMonitoring()  
{  
    if (!(m_Thread = AfxBeginThread(CommThread, this)))  
        return FALSE;  
    TRACE("Thread started\n");  
    return TRUE;  
}  
  
//  
//   
//  
BOOL CSerialPort::RestartMonitoring()  
{  
    TRACE("Thread resumed\n");  
    m_Thread->ResumeThread();  
    return TRUE;  
}  
  
  
//  
//  
//  
BOOL CSerialPort::StopMonitoring()  
{  
    TRACE("Thread suspended\n");  
    m_Thread->SuspendThread();  
    return TRUE;  
}  
  
  
//  
//   
//  
void CSerialPort::ProcessErrorMessage(char* ErrorText)  
{  
    char *Temp = new char[200];  
  
    LPVOID lpMsgBuf;  
  
    FormatMessage(  
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,  
        NULL,  
        GetLastError(),  
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), //   
        (LPTSTR)&lpMsgBuf,  
        0,  
        NULL  
        );  
  
    sprintf(Temp, "WARNING:  %s Failed with the following error: \n%s\nPort: %d\n", (char*)ErrorText, lpMsgBuf, m_nPortNr);  
    MessageBox(NULL, Temp, "Application Error", MB_ICONSTOP);  
  
    LocalFree(lpMsgBuf);  
    delete[] Temp;  
}  
  
//  
//   
//  
void CSerialPort::WriteChar(CSerialPort* port)  
{  
    BOOL bWrite = TRUE;  
    BOOL bResult = TRUE;  
  
    DWORD BytesSent = 0;  
  
    ResetEvent(port->m_hWriteEvent);  
  
    //   
    EnterCriticalSection(&port->m_csCommunicationSync);  
  
    if (bWrite)  
    {  
        //   
        port->m_ov.Offset = 0;  
        port->m_ov.OffsetHigh = 0;  
  
        //   
        PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);  
  
        bResult = WriteFile(port->m_hComm,                           //   
            port->m_szWriteBuffer,                   //   
            strlen((char*)port->m_szWriteBuffer),    //   
            &BytesSent,                             //   
            &port->m_ov);                            //   
  
        //   
        if (!bResult)  
        {  
            DWORD dwError = GetLastError();  
            switch (dwError)  
            {  
            case ERROR_IO_PENDING:  
            {  
                                     //   
                                     BytesSent = 0;  
                                     bWrite = FALSE;  
                                     break;  
            }  
            default:  
            {  
                       //   
                       port->ProcessErrorMessage("WriteFile()");  
            }  
            }  
        }  
        else  
        {  
            LeaveCriticalSection(&port->m_csCommunicationSync);  
        }  
    } //   
  
    if (!bWrite)  
    {  
        bWrite = TRUE;  
  
        bResult = GetOverlappedResult(port->m_hComm, //   
            &port->m_ov,     //  
            &BytesSent,     //   
            TRUE);          //  
  
        LeaveCriticalSection(&port->m_csCommunicationSync);  
  
        //  
        if (!bResult)  
        {  
            port->ProcessErrorMessage("GetOverlappedResults() in WriteFile()");  
        }  
    } //   
  
    //  
    if (BytesSent != strlen((char*)port->m_szWriteBuffer))  
    {  
        TRACE("WARNING: WriteFile() error.. Bytes Sent: %d; Message Length: %d\n", BytesSent, strlen((char*)port->m_szWriteBuffer));  
    }  
}  
  
//  
//   
//  
void CSerialPort::ReceiveChar(CSerialPort* port, COMSTAT comstat)  
{  
    BOOL  bRead = TRUE;  
    BOOL  bResult = TRUE;  
    DWORD dwError = 0;  
    DWORD BytesRead = 0;  
    unsigned char RXBuff;  
  
    for (;;)  
    {  
        //   
        //  
        //   
  
        EnterCriticalSection(&port->m_csCommunicationSync);  
  
        //   
        //   
  
        bResult = ClearCommError(port->m_hComm, &dwError, &comstat);  
  
        LeaveCriticalSection(&port->m_csCommunicationSync);  
  
  
  
        if (comstat.cbInQue == 0)  
        {  
            //   
            break;  
        }  
  
        EnterCriticalSection(&port->m_csCommunicationSync);  
  
        if (bRead)  
        {  
            bResult = ReadFile(port->m_hComm,        //   
                &RXBuff,                //  
                1,                  //   
                &BytesRead,         //  
                &port->m_ov);        //  
            //  
            if (!bResult)  
            {  
                switch (dwError = GetLastError())  
                {  
                case ERROR_IO_PENDING:  
                {  
                                         //   
                                         //   
                                         bRead = FALSE;  
                                         break;  
                }  
                default:  
                {  
                           //   
                           port->ProcessErrorMessage("ReadFile()");  
                           break;  
                }  
                }  
            }  
            else  
            {  
                //   
                bRead = TRUE;  
            }  
        }  //   
  
        if (!bRead)  
        {  
            bRead = TRUE;  
            bResult = GetOverlappedResult(port->m_hComm, //   
                &port->m_ov,     //   
                &BytesRead,     //  
                TRUE);          //  
  
            //  
            if (!bResult)  
            {  
                port->ProcessErrorMessage("GetOverlappedResults() in ReadFile()");  
            }  
        }  //  
  
        LeaveCriticalSection(&port->m_csCommunicationSync);  
  
        //  
        ::SendMessage((port->m_pOwner)->m_hWnd, WM_COMM_RXCHAR, (WPARAM)RXBuff, (LPARAM)port->m_nPortNr);  
    } //  
  
}  
  
//  
//   
//  
void CSerialPort::WriteToPort(char* string)  
{  
    assert(m_hComm != 0);  
    memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));  
    strcpy(m_szWriteBuffer, string);  
  
  
    //   
    SetEvent(m_hWriteEvent);  
}  
  
//  
//   
//  
DCB CSerialPort::GetDCB()  
{  
    return m_dcb;  
}  
  
//  
//   
//  
DWORD CSerialPort::GetCommEvents()  
{  
    return m_dwCommEvents;  
}  
  
//  
//   
//  
DWORD CSerialPort::GetWriteBufferSize()  
{  
    return m_nWriteBufferSize;  
}  
  
  
void CSerialPort::CloseComm()  
{  
    CloseHandle(m_hComm);  
}





大树学长
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SerialPort类源代码分析.pdf
05-05
介绍并分析SerialPort类，它把Windows API封装好，方便开发利用 1、Win32下串口大致操作流程 (1)打开串口：CreateFile函数 (2)建立串口通信事件:CreateEvent函数 (3)初始化串口:SetCommState函数 (4)建立监视线程,即...
SerialPort类的用法与示例
热门推荐
xiaoshihd的博客
03-26 1万+
SerialPort类的用法与示例 文章目录SerialPort类的用法与示例1. 串口硬件信号定义2. 串口端口号搜索3. 串口属性参数设置4. 串口发送信息5. 串口接收信息串口工具类串口使用注意事项 从Microsoft .Net 2.0版本以后，就默认提供了System.IO.Ports.SerialPort类，用户可以非常简单地编写少量代码就完成串口的信息收发程序。本文将介绍如何在PC端用C# .Net 来开发串口应用程序。 1. 串口硬件信号定义 DB9 Connector 信号定义
C#串口通信 SerialPort类
fangyuan621的专栏
02-10 3667
因为公司项目需要将USB扫码枪改为串口扫码枪，串口扫码的好处在于不需要一个输入框来接受USB扫出来的文本，能解决多个扫码枪一起扫码时的并发问题，所以需要用到多线程及串口技术。 一、串口通信简介 串行接口（串口）是一种可以将接受来自CPU的并行数据字符转换为连续的串行数据流发送出去，同时可将接受的串行数据流转换为并行的数据字符供给CPU的器件。一般完成这种功能的电路，我们称为串行接口电路。 串口通信（Serial Communications）的概念非常简单，串口按位（bit）发送和接收字节。尽管比按字节
以类的方式 添加SerialPort
action20的专栏
07-08 1319
2．以类的方式   VB： 1)        定义SerialPort类实例       Dim SpCom As NewSystem.IO.Ports.SerialPort() 2)        设置通讯端口号及波特率、数据位、停止位和校验位。        SpCom.PortName= "COM1"        SpCom.BaudRate= 9600
# 串口编程（SerialPort类）
qq_43196058的博客
05-24 2334
串口编程（SerialPort类） 转自https://www.cnblogs.com/xinai/ 近期由于项目中用到串口编程，而以前有从未使用过，查阅相关资料，先将串口编程整个过程整理如下，以备不时之需。 SerialPort类简述 此类位于System.IO.Ports命名空间下。用于控制串行端口文件资源，此类提供同步I/O和事件驱动的I/O、对管脚和中断状态的访问以及对串行驱动程序的访问。...
CSerialPort类解析
shuaiqidiudiu的专栏
06-02 3624
CserialPort类支持线连接（非MODEM）的串口编程操作。 CserialPort类是基于多线程的，其工作流程如下：首先设置好串口参数，再开启串口检测工作线程，串口检测工作线程检测到串口接收到的数据、流控制事件或其他串口事件后，就以消息方式通知主程序，激发消息处理函数来进行数据处理，这是对接受数据而言的，发送数据可直接向串口发送。 CserialPort类定义的消息如表
（MFC）SerialPort类实现串口发送16进制数字
07-16
总的来说，"（MFC）SerialPort类实现串口发送16进制数字"涉及到的知识点包括：MFC框架的理解、SerialPort类的使用、串口参数的设置、16进制数字与字节流的转换、串口通信的调试和监控，以及虚拟串口技术的应用。...
SerialPort类最新版
07-09
这个"SerialPort类最新版"可能包含了一些针对原有类的改进和修复，以解决之前版本中可能存在的一些问题和bug。 SerialPort类提供了一系列丰富的属性、方法和事件，用于配置和管理串行端口。以下是一些关键知识点： ...
基于MFC的串口类CSerialPort的使用
心-无可取代
01-18 5497
VS2010的MFC环境中串口CSerialPort类的使用说明
vc++基于VS2010用SerialPort类实现串口通信
01-02
基于VS2010平台下VC++使用SerialPort类完成了简单的串口通信，可以选择串口号
MFC SerialPort类文件
09-09
MFC SerialPort类文件可以进行串口通讯程序的开发，非常方便强大！
C# SerialPort自定义串口DCB
weixin_44557135的博客
08-21 732
转载自https://www.cnblogs.com/moonache/p/6655086.html DCB（Device Control Block）在C++ 里面是用bitfield（位域）表示的，C＃没有bitfield，但有一个枚举位标志。C#有自己的方法来设置怎么存取DCB，而且“SerialStream”里确实也有“SetDcbFlag”方法（该方法接收2个int参数）。在研究了.Ne...
MFC串口操作一：显示串口输入信息
qq_40544338的博客
05-26 3329
目录 一、目的 1、想知道：MFC串口输入输出信息 二、参考 1、无 三、操作 1、运行效果：完成MFC获取串口输入信息功能 1、创建新工程：我取名字为：MyComTest 1、SerialPort.h 1、SerialPort.cpp 1、将SerialPort.h和SerialPort.cpp文件复制到项目中 1、头文件添加现有项：SerialPort.h 1、源文件添加现有项：SerialPort.cpp 1、MyComTestDlg.h：创建串口SerialPort类：记得
CSerialPort串口类最新修正版(解决关闭死锁问题)
shejiannan的专栏
11-08 2215
这是一份优秀的类文件，好多的地方值得我们学习，具体在多线程，事件，自定义消息，类的封装方面等等。 Remon提供的串口类网址为： http://codeguru.earthweb.com/network/serialport.shtml， 由于已经运行十几年了，原文的问答部分列出来这么多年来的问题，经过网友们的总结，补充和修改原来代码后，整理出一份相对比较完美的代码。 此外还附带一份
SerialPort类源代码分析
烟逝爱情的专栏
05-05 2826
前几篇串口编程大致讲述了Windows下串口的大致操作，接下来分析流行的SerialPort类，它把Windows API封装好，方便开发利用1、Win32下串口大致操作流程 (1)打开串口：CreateFile函数 (2)建立串口通信事件:CreateEvent函数 (3)初始化串口:SetCommState函数 (4)建立监视线程,即读写数据线程,因为我们不知道什么时候数据会到来,这里是一个异步事件 (5)写数据:WriteFile (6)结束:关闭线程->停止WaitCommEvent->
SerialPort类读取数据的方法
qq_19390445的博客
11-20 6057
同步方法：Read();ReadLine(); ReadByte();ReadChar();，同步就是和主程序保持一致，只有运行完了ReadByte之后才能运行程序之后的代码 异步方法：ReadExisting();ReadTo();，异步就是重新开启一个线程来处理这些问题，主程序不受到干扰，继续运行。 一般选择的是Read同步读取数据，接收数据的类型是一个byte数据，更容易对数据进行下一步的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值