偶写的串口通信类

最新推荐文章于 2015-10-10 17:10:54 发布
最新推荐文章于 2015-10-10 17:10:54 发布
阅读量3k 收藏 3
点赞数
分类专栏： BCB 文章标签： null class byte struct buffer delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Waiting4you/article/details/1564567
版权

适用于BCB6.0,  CB2006/TC2006

用法:

TMyComm<ThreadRd,ThreadWrt> Comm;  //异步模式Comm类, 含有读线程和写线程,有OnWritten,OnRead,OnSignal,OnError事件

TMyComm<BlockRd,BlockWrt> Comm;   //同步模式Comm类(阻塞),无读线程和写线程,使用Write和Read方法类似于文件读写的方式

TMyComm<ThreadRd,BlockWrt> Comm;   //有读线程无写线程, Write类似于普通文件写(写完才返回), 能过OnRead事件读到数据 

TMyComm<BlockRd,ThreadWrt> Comm;  //和上面相反, 有写线程无读线程, 不建议使用此模式, 除非只是用写功能或者你知道你在干什么.

另外使用BlockRd模式时建议使用SetTimeouts方法设置超时值,不然死在Read上可别怪我没说:)

//---------------------------------------------------------------------------

#ifndef TMyCommH
#define TMyCommH
#include <Classes.hpp>
#ifndef COMMREADBUFFERSIZE
#define COMMREADBUFFERSIZE 2048
#endif
#pragma option push -w-inl
enum TFlowControl {fcNull=0,fcHardware=1,fcXonXoff=2};
//---------------------------------------------------------------------------
struct TMyDCB :DCB{
        TMyDCB(){
         ZeroMemory(this,sizeof(DCB));
                DCBlength=sizeof(TMyDCB);
        }
        TMyDCB(const DCB &dcb){
         CopyMemory(this,&dcb,sizeof(DCB));
        }
        TMyDCB& operator=(const DCB &dcb){
         CopyMemory(this,&dcb,sizeof(DCB));
                return *this;
        }

 bool Build(const char *strDCB){        //eg."baud=1200 parity=N data=8 stop=1","9600,n,8,1"
         return BuildCommDCB(strDCB,this);
        }

        void SetFlowControl(TFlowControl FlowControl){
                fOutxCtsFlow=(FlowControl==fcHardware);
                fInX=fOutX=(FlowControl==fcXonXoff);
                fRtsControl=(FlowControl==fcHardware)?RTS_CONTROL_HANDSHAKE:RTS_CONTROL_ENABLE;
        }
       
};

template<class p_rd,class p_wt> class TMyComm:
 public p_rd,public p_wt
{
 TMyComm(const TMyComm&);
        TMyComm & operator=(const TMyComm&);
protected:
 HANDLE hComm;
        AnsiString FPort;
        TMyDCB dcb;
        void CheckOpened(){if(!Opened()) throw(Exception("Port do not opened!"));}
public:
 TMyComm():hComm(INVALID_HANDLE_VALUE),p_rd(hComm),p_wt(hComm){;}
        ~TMyComm(){Close();}

        // Open & Close
        void Open(const AnsiString &Port);
        void Close();
        bool Opened(){return hComm!=INVALID_HANDLE_VALUE;}
        AnsiString GetPort(){return FPort;}

        // Read & Write
        bool TransmitCommChar(char c){
         CheckOpened();
                return ::TransmitCommChar(hComm,c);
        }
        //dwFunc: CLRDTR,CLRRTS,SETDTR,SETRTS,SETXOFF,SETXON,SETBREAK,CLRBREAK,RESETDEV
        bool EscapeCommFunction(DWORD dwFunc){
         CheckOpened();
                return ::EscapeCommFunction(hComm,dwFunc);
        }

        void Flush(){CheckOpened();FlushFileBuffers(hComm);}
        void ClearRdBuf(){CheckOpened();PurgeComm(hComm,PURGE_RXABORT|PURGE_RXCLEAR);}
        void ClearWrtBuf(){CheckOpened();PurgeComm(hComm,PURGE_TXABORT|PURGE_TXCLEAR);}

        // Info
        HANDLE GetHandle(){return hComm;}
        DWORD GetCommModemStatus(){         //MS_CTS_ON,MS_DSR_ON,MS_RING_ON,MS_RLSD_ON
         CheckOpened();
                DWORD Result=0;
                Win32Check(::GetCommModemStatus(hComm,&Result));
                return Result;
        }

        // Setting DCB,Must be Opened;
        void SetDCB(const DCB&);
        TMyDCB GetDCB(){CheckOpened();return dcb;}

        void SetBaudRate(DWORD);
        void SetParity(BYTE);
        void SetByteSize(BYTE);
        void SetStopBits(BYTE);
 DWORD GetBaudRate(){return GetDCB().BaudRate;}                 /* Baudrate at which running       */
        BYTE GetParity(){return GetDCB().Parity;}                      /* 0-4=None,Odd,Even,Mark,Space    */
        BYTE GetByteSize(){return GetDCB().ByteSize;}                  /* Number of bits/byte, 4-8        */
        BYTE GetStopBits(){return GetDCB().StopBits;}                  /* 0,1,2 = 1, 1.5, 2               */
        /*//winbase.h defined/
        #define NOPARITY            0
        #define ODDPARITY           1
        #define EVENPARITY          2
        #define MARKPARITY          3
        #define SPACEPARITY         4

        #define ONESTOPBIT          0
        #define ONE5STOPBITS        1
        #define TWOSTOPBITS         2
        /*///
 // Setting TimeOut
        void SetTimeouts(const COMMTIMEOUTS&);
        void SetTimeouts(DWORD RdItv,DWORD RdMult=0,DWORD RdConst=0,
         DWORD WrtMult=0,DWORD WrtConst=0);
        COMMTIMEOUTS GetTimeouts();

        // Setting Buffer
        void SetBuffers(DWORD In,DWORD Out)
        {
         CheckOpened();
                Win32Check(SetupComm(hComm,In,Out));
        }
};
// BlockWrt-------------------------------------------
struct BlockWrt{
 BlockWrt(HANDLE &_hComm):hComm(_hComm),Opened(false){;}
        DWORD Write(void *Buf,DWORD Len)
        {
         if(!Opened)return 0;
                DWORD Result=Len;
                if(Result && !WriteFile(hComm, Buf, Result,&Result,&osWrite))
                {
                        Result=0;
                        if (GetLastError() == ERROR_IO_PENDING)
                                GetOverlappedResult(hComm,&osWrite,&Result,true);
                }
                return Result;
        }
 void Open()
        {
         if(Opened)return;
         ZeroMemory(&osWrite,sizeof(osWrite));
         osWrite.hEvent=CreateEvent(NULL, true, false, NULL);
         Opened=true;
        }
        void Close()
        {
         if(!Opened)return;
                PurgeComm(hComm,PURGE_TXABORT|PURGE_TXCLEAR);
         CloseHandle(osWrite.hEvent);
         Opened=false;
        }
private:
 HANDLE &hComm;
        bool Opened;
        OVERLAPPED osWrite;
};
// BlockRd-------------------------------------------
struct BlockRd{
 BlockRd(HANDLE &_hComm):hComm(_hComm),Opened(false){;}
        DWORD Read(void *Buf,DWORD Len)
        {
                if(!Opened)return 0;
                DWORD Result=Len;
                if (Result && !ReadFile(hComm, Buf, Result, &Result, &osRead))
                {
                        Result=0;
                        if (GetLastError() == ERROR_IO_PENDING)
                                GetOverlappedResult(hComm,&osRead,&Result,true);
                }
                return Result;
        }
 void Open()
        {
         if(Opened)return;
         ZeroMemory(&osRead,sizeof(osRead));
         osRead.hEvent=CreateEvent(NULL, true, false, NULL);
         Opened=true;
        }
        void Close()
        {
         if(!Opened)return;
                PurgeComm(hComm,PURGE_RXABORT|PURGE_RXCLEAR);
         CloseHandle(osRead.hEvent);
         Opened=false;
        }
private:
 HANDLE &hComm;
        bool Opened;
        OVERLAPPED osRead;
};
// ThreadWrt-------------------------------------------
typedef void (__closure *TWrtEvent)(HANDLE,void*,DWORD);
class TCommWriter : public TThread
{
private:
 struct TWrtItem{
         DWORD Len;
                char Buf[0];
        };
 HANDLE &hComm;
        OVERLAPPED osWrite;
 TThreadList *_WriteQueue;
        HANDLE evWrite;
        TWrtEvent OnWritten;
protected:
 void __fastcall Execute()
        {
                while(!Terminated)
                {
                        WaitForSingleObject(evWrite,INFINITE);
                        TWrtItem *Item=NULL;
                        TList *pList = _WriteQueue->LockList();
                        try
                        {
                                if(pList->Count>0)
                                {
                                        Item=(TWrtItem*)pList->First();
                                        pList->Delete(0);
                                }
                                else
                                {
                                        ResetEvent(evWrite);
                                }
                        }
                        __finally
                        {
                                _WriteQueue->UnlockList();
                        }
                        if(Item)
                        {
                                DWORD Result=0;
                                try{
                                        if(Item->Len&&!WriteFile(hComm, Item->Buf ,Item->Len,&Result,&osWrite))
                                        {
                                                if (GetLastError() == ERROR_IO_PENDING)
                                                        GetOverlappedResult(hComm,&osWrite,&Result,true);
                                        }
                                        if(Result&&OnWritten) OnWritten(hComm,Item->Buf,Item->Len);
                                }
                                __finally
                                {
                                 free(Item);
                                }
                        }
                }
        }
public:
 __fastcall TCommWriter(HANDLE &handle,TWrtEvent WrtEvent)
         :TThread(true),hComm(handle),OnWritten(WrtEvent)
        {
  _WriteQueue=new TThreadList;
         evWrite=CreateEvent(NULL,true,false,NULL);
                ZeroMemory(&osWrite,sizeof(osWrite));
                osWrite.hEvent=CreateEvent(NULL,true,false,NULL);
        }
 __fastcall ~TCommWriter()
        {
  Clear();
         CloseHandle(evWrite);
                CloseHandle(osWrite.hEvent);
  delete _WriteQueue;
        }
        void __fastcall Terminate(void)
        {
  TThread::Terminate();
                SetEvent(osWrite.hEvent);
  SetEvent(evWrite);
                PurgeComm(hComm,PURGE_TXABORT|PURGE_TXCLEAR);
        }
 void Write(void *Buf,DWORD Len)
        {
                TWrtItem *Data=(TWrtItem *)malloc(sizeof(TWrtItem)+Len);
                Data->Len=Len;
                CopyMemory(Data->Buf,Buf,Len);
                _WriteQueue->LockList();
                _WriteQueue->Add(Data);
                SetEvent(evWrite);
                _WriteQueue->UnlockList();
        }
 void Clear()
        {
                TList *pList = _WriteQueue->LockList();
                try
                {
                        for (int i = 0; i < pList->Count; i++)
                        {
                                free(pList->Items[i]);
                        }
                        pList->Clear();
                }
                __finally
                {
                        _WriteQueue->UnlockList();
                }
        }
};

struct ThreadWrt{

 ThreadWrt(HANDLE &_hComm):hComm(_hComm),Wrt(NULL),OnWritten(NULL){;}
        ~ThreadWrt(){Close();}
        TWrtEvent OnWritten;

        DWORD Write(void *Buf,DWORD Len)
        {
         if(Wrt==NULL||Len==0)return 0;
                Wrt->Write(Buf,Len);
                return Len;
        }
 void Open()
        {
         if(Wrt)return;
                Wrt=new TCommWriter(hComm,OnWritten);
                Wrt->Resume();
        }
        void Close()
        {
         if(Wrt==NULL)return;
                Wrt->Terminate();
                Wrt->WaitFor();
                delete Wrt;
                Wrt=NULL;
        }
private:
 TCommWriter *Wrt;
        HANDLE &hComm;
};

// ThreadRd-------------------------------------------
typedef void (__closure *TRdEvent)(HANDLE,void*,DWORD);
typedef void (__closure *TRdError)(HANDLE,DWORD ErrorCode);
typedef void (__closure *TRdSignal)(HANDLE,DWORD EvtMask);

class TCommReader : public TThread
{
private:
 HANDLE &hComm;
        TRdEvent OnRead;
        OVERLAPPED osRead;
        OVERLAPPED osStatus;
        HANDLE hExit;
protected:
 void __fastcall Execute()
        {
            char Buffer[COMMREADBUFFERSIZE];
            bool WaitingRead=false;
            bool WaitingStat=false;
            DWORD Len=0;
            DWORD Evt;
            HANDLE hArray[3]={osRead.hEvent,osStatus.hEvent,hExit};
            SetCommMask(hComm,EV_CTS|EV_DSR|EV_ERR|EV_RING|EV_RLSD);

            while(!Terminated)
            {
                if (!WaitingRead)
                {
                    if (!ReadFile(hComm, Buffer, COMMREADBUFFERSIZE, &Len, &osRead))
                    {
                        if (GetLastError() == ERROR_IO_PENDING)  WaitingRead = true;
                    }
                    else
                    {    // read completed immediately
                        if (Len>0)
                        {
                            if(OnRead) OnRead(hComm,Buffer,Len);
                        }
                        else
                            Sleep(1);
                    }
                }
                if (!WaitingStat)
                {
                    if(!WaitCommEvent(hComm, &Evt, &osStatus))
                    {
                        if (GetLastError() == ERROR_IO_PENDING) WaitingStat = true;
                    }
                    else
                    {
                        if(OnSignal) OnSignal(hComm,Evt);
                    }
                }
                if(WaitingRead&&WaitingStat)
                {
                    DWORD dwRes = WaitForMultipleObjects(3,hArray,false,INFINITE);
                    switch(dwRes)
                    {
                        case WAIT_OBJECT_0: //Read
                            if(GetOverlappedResult(hComm, &osRead, &Len, false))
                            {
                             if(Len&&OnRead) OnRead(hComm,Buffer,Len);
                            }
                            WaitingRead = false;
                            break;
                        case WAIT_OBJECT_0+1: //State
                            if(GetOverlappedResult(hComm, &osStatus, &Len, false))
                            {
                                if(Evt&EV_ERR)
                                {
                                    DWORD ErrorCode=0;
                                    if(ClearCommError(hComm, &ErrorCode,NULL)&&OnError)
                                     OnError(hComm,ErrorCode);
                                }
                                else
                                    if(OnSignal) OnSignal(hComm,Evt);
                            }
                            WaitingStat=false;
                            break;
                        case WAIT_OBJECT_0+2: //Exit
                            goto end;
                    }
                }
            }
end:
        }
public:
        TRdError OnError;
        TRdSignal OnSignal;
 __fastcall TCommReader(HANDLE &handle,TRdEvent RdEvent)
         :TThread(true),hComm(handle),OnRead(RdEvent),OnSignal(NULL),OnError(NULL)
        {
         ZeroMemory(&osRead,sizeof(osRead));
                osRead.hEvent=CreateEvent(NULL,true,false,NULL);
                osStatus.hEvent=CreateEvent(NULL,true,false,NULL);
                hExit=CreateEvent(NULL,false,false,NULL);
        }
        __fastcall ~TCommReader()
        {
         CloseHandle(osRead.hEvent);
                CloseHandle(osStatus.hEvent);
                CloseHandle(hExit);
        }
        void __fastcall Terminate(void)
        {
  TThread::Terminate();
                PurgeComm(hComm,PURGE_RXABORT|PURGE_RXCLEAR);
                SetEvent(hExit);
        }
};
struct ThreadRd{
 ThreadRd(HANDLE &_hComm)
         :hComm(_hComm),Rd(NULL),OnRead(NULL),OnSignal(NULL),OnError(NULL)
                {;}
        ~ThreadRd(){Close();}
        TRdEvent OnRead;
        TRdError OnError;
        TRdSignal OnSignal;

        DWORD Read(void *Buf,DWORD Len)
        {
         return 0;
        }
 void Open()
        {
         if(Rd)return;
                Rd=new TCommReader(hComm,OnRead);
                Rd->OnSignal=OnSignal;
                Rd->OnError=OnError;
                Rd->Resume();
        }
        void Close()
        {
         if(Rd==NULL)return;
                Rd->Terminate();
                Rd->WaitFor();
                delete Rd;
                Rd=NULL;
        }
private:
 TCommReader *Rd;
        HANDLE &hComm;
};

#define Micro_DefDCB(v) /
        if(dcb.##v##==##v##)return; /
        TMyDCB tmpDcb=dcb;  /
        tmpDcb.##v##=##v##;   /
        SetDCB(tmpDcb);

//---------------------------------------------------------------------------
template<class p_rd,class p_wt>
void TMyComm<p_rd,p_wt>::Open(const AnsiString &Port)
{
 if(Opened())
        {
         if(SameText(Port,FPort))
                {
                 return;
                }
                else
                {
                 Close();
                }
        }
        FPort=Port;
        hComm = CreateFile( FPort.c_str(),GENERIC_READ | GENERIC_WRITE,
                0,0,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,0);
        if (!Opened()) RaiseLastOSError();

        PurgeComm(hComm,PURGE_RXABORT|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_TXCLEAR);

        ZeroMemory(&dcb,sizeof(dcb));
        if (!GetCommState(hComm, &dcb))
        {
         Close();
                RaiseLastOSError();
        }
        p_rd::Open();
        p_wt::Open();
}

template<class p_rd,class p_wt>
void TMyComm<p_rd,p_wt>::Close()
{
 if(Opened())
        {
         p_rd::Close();
                p_wt::Close();
         CloseHandle(hComm);
                hComm=INVALID_HANDLE_VALUE;
        }
}

template<class p_rd,class p_wt>
void TMyComm<p_rd,p_wt>::SetDCB(const DCB &_dcb)
{
 CheckOpened();
        DCB tmpDcb=_dcb;
        Win32Check(SetCommState(hComm, &tmpDcb));
        dcb=tmpDcb;
}
template<class p_rd,class p_wt>
void TMyComm<p_rd,p_wt>::SetBaudRate(DWORD BaudRate)
{
 Micro_DefDCB(BaudRate)
}
template<class p_rd,class p_wt>
void TMyComm<p_rd,p_wt>::SetParity(BYTE Parity)
{
        if(dcb.Parity==Parity)return;
        TMyDCB tmpDcb=dcb;
        tmpDcb.Parity=Parity;
        tmpDcb.fParity=Parity?1:0;
        SetDCB(tmpDcb);
}
template<class p_rd,class p_wt>
void TMyComm<p_rd,p_wt>::SetByteSize(BYTE ByteSize)
{
 Micro_DefDCB(ByteSize)
}
template<class p_rd,class p_wt>
void TMyComm<p_rd,p_wt>::SetStopBits(BYTE StopBits)
{
 Micro_DefDCB(StopBits)
}
template<class p_rd,class p_wt>
void TMyComm<p_rd,p_wt>::SetTimeouts(const COMMTIMEOUTS& TimeOuts)
{
 CheckOpened();
        COMMTIMEOUTS _TimeOuts=TimeOuts;
        Win32Check(SetCommTimeouts(hComm,&_TimeOuts));
}
template<class p_rd,class p_wt>
void TMyComm<p_rd,p_wt>::SetTimeouts(
 DWORD RdItv,DWORD RdMult,DWORD RdConst,DWORD WrtMult,DWORD WrtConst)
{
        COMMTIMEOUTS _TimeOuts={RdItv,RdMult,RdConst,WrtMult,WrtConst};
        SetTimeouts(_TimeOuts);
}
template<class p_rd,class p_wt>
COMMTIMEOUTS TMyComm<p_rd,p_wt>::GetTimeouts()
{
 CheckOpened();
        COMMTIMEOUTS _TimeOuts={0,0,0,0,0};
        Win32Check(GetCommTimeouts(hComm,&_TimeOuts));
        return _TimeOuts;
}
#pragma option pop
#endif

 

Waiting4you
关注
专栏目录
c++ builder 串口操作
04-29
c++builder常用工具 串口操作
xe10 c++builder 串口控件
03-01
xe10 c++builder 串口控件
C++Builder 串口通信调试
04-03
C++Builder API函数操作串口上位机，实现单片机的串口数据传送到电脑上显示。
串口调试工具(SCom含BCB源码)
12-18
串口调试工具(SCom含BCB源码)本串口应用程序程序支持十六进制输入输出同时支持常规的输入输出，作为串口开发的辅助工具，非常的方便作者：老姜(fjye)主页：http://www.YEStuido.cn
串行通信与重叠I/O
左超
08-26 6389
Win 32系统为串行通信提供了全新的服务。传统的OpenComm、ReadComm、WriteComm、CloseComm等函数已经过时，WM_COMMNOTIFY消息也消失了。取而代之的是文件I/O函数提供的打开和关闭通信资源句柄及读写操作的基本接口。　　新的文件I/O函数(CreateFile、ReadFile、WriteFile等)支持重叠式输入输出，这使得线程可以从费时的I/O操作中
串口通信类
04-09
本项目提供了一个封装的C++串口通信类，旨在简化开发过程，实现数据的收发功能，并且支持发送字符串。下面我们将深入探讨这个话题。 串口通信，又称串行通信，是通过串行数据线进行数据传输的一种方式。它与并行...
VS2017-MFC串口通信(基于CSerialPort类)
04-24
在VS2017中，我们常常会用到MFC中的CSerialPort类来实现串口通信功能。这个项目已经经过测试，适用于32位和64位系统，确保了广泛的兼容性。 ### 1. MFC和CSerialPort类简介 MFC 是一个面向对象的框架，它提供了许多...
M218串口通讯范例_串口_tm218串口通信_施耐德M218PLC程序_
10-01
要实现M218与外部设备的串口通信，首先需要配置PLC的串口参数，这包括波特率（如9600、19200等）、数据位（通常为8位）、停止位（1位或2位）、奇偶校验（无、奇、偶），以及地址设置（如果使用Modbus协议）。...
VC++写的串口通讯的程序，其中的几个串口通讯类可以方便移植到其他需要串口通讯的地方.rar
最新发布
06-20
这个名为"VC++写的串口通讯的程序"的压缩包文件，是使用Microsoft的Visual C++（简称VC++）集成开发环境，并结合MFC（Microsoft Foundation Classes）库创建的一个串口通信应用。MFC是微软提供的一个C++类库，它封装...
完整串口通信程序(发送和接受)源代码.zip_串口发送_串口通信_串口通信代码_串口通讯_通信接受程序
07-14
串口通信是计算机通信的一种常见方式，特别是在嵌入式系统、工业控制以及设备间的数据交换中广泛应用。在给定的“完整串口通信程序(发送和接受)源代码.zip”压缩包中，包含了一个实现串口发送和接收功能的Vc++源代码...
C++ BUILDER中串口通信的实现.PDF
10-10
C++ BUILDC++ BUILDER中串口通信的实现.PDFER中串口通信的实现.PDFC++ BUILDER中串口通信的实现.PDF
C++Builder函数一览
02-22
C++Builder函数一览 包含BCB绝大多数函数，并付有功能注释
基于多线程技术的异步串行通信应用
曾保权的技术专栏
12-13 1317
 1  引言 在工业控制领域，由于串行接口简单、使用方便，从而使得异步串行通信成为计算机之间极为常用的通信手段。C++ Builder 6是Borland公司推出的快速应用程序开发平台，它采用面向对象的C++作为开发语言,同时提供了良好的可视化开发环境,是目前开发Windows应用程序的强大、高效的开发平台之一。在基于Windows 2000的多任务操作平台下的控制系统中,利用C++ Builde
C++ Builder 高手进阶 （五）用BCB编写多线程应用程序
开心果的专栏
01-30 5340
 C++ Builder 高手进阶（五）用BCB编写多线程应用程序nxyc_twz@163.com　　　随着Windows系统的全球性普及，多线程技术已越来越多地运用到许多软件设计中。使用多线程技术可全面提高应用程序的执行效率。以前为了实现多线程编程，基本上都是调用一系列的API函数，如CreateThread、ResumeThread等，不容易控制，还容易出错。在使用BCB以后，
串口通信编程--多线程异步方式
ddy34589的博客
11-12 876
目录 一串口通信基础 1.1串口通信原理与特点 1.2串口通信的传输方式 1.3串口通信的同步技术 1.4串行接口标准 二 API函数实现串口通信 2.1打开串口 2.1.1串口是否有驱动 2.1.2连接串口 2.1.3串口逻辑端口号大于10无法打开问题 2.2串口配置 2.2.1设置...
串口异步读写
misterliwei的专栏
02-20 5779
串口异步读写 最近尝试写了一个串口读写的程序，学习并复习了一些知识点。本文首先讲异步读写注意点，然后讲串口的注意点。因为有些问题没有深入研究下去，所以本文也仅仅当做一个笔记。   1.      文件指针 我们使用ReadFile和WriteFile来进行读写，这两个API是用来读写文件的，在同步读写中，有一个文件指针的概念，但是在异步读写中，系统会忽略文件指针。 OVERLAP
异步读写
xbgprogrammer的专栏
10-10 1947
测试了下异步读写，记录一下。 1. 若要进行异步读写，创建（或打开）文件时需要指定异步标志位（FILE_FLAG_OVERLAPPED）。 2. 读写函数的返回值依赖底层实现，若底层直接完成操作，则函数返回成功，User Mode代码可立即操作缓冲区。若底层挂起操作，则函数返回false，GetLastError()返回997，若  为其它的错误代码，说明底层处理失败。 3. 处理应用层发送
串口通信工程笔记一
weixin_34279579的博客
05-02 193
一、串口API 1.打开串口 　　使用CreateFile函数可以打开串口。通常有两种方式可以打开，一种是同步方式（NonOverlapped），另外一种异步方式（Overlapped）。 HANDLE hComm; hComm = CreateFile( gszPort,...
C#详解SerialPort类实现串口通信
这份文档主要讲解了.NET Framework 2.0中SerialPort类的使用，这是C#中处理串口通信的核心组件。 SerialPort类是.NET框架提供的一个关键类，它包含了丰富的属性和方法来管理和控制串口通信过程。以下是一些重要的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值