异步打开串口的方法

异步传输是一种典型的基于字节的输入输出，指数据按每次一个字节进行传输，其传输速度低。同步传输是把数据字节组合起来一起发送，这种组合称之为帧，其传输速度比异步传输快，同步串口的传送速率高，异步串口实现简单，这是异步串口与同步串口间最主要的区别。

一，异步非阻塞串口通讯的优点

读写串行口时，既可以同步执行，也可以重叠（异步）执行。

在同步执行时，函数直到操作完成后才返回。这意味着在同步执行时线程会被阻塞，从而导致效率下降。在重叠执行时，即使操作还未完成，调用的函数也会立即返回。费时的I/O操作在后台进行，这样线程就可以干别的事情。

例如，线程可以在不同的句柄上同时执行I/O操作，甚至可以在同一句柄上同时进行读写操作。"重叠"一词的含义就在于此。

二，异步非阻塞串口通讯的基本原理

首先，确定要打开的串口名、波特率、奇偶校验方式、数据位、停止位，传递给CreateFile()函数打开特定串口；

其次，为了保护系统对串口的初始设置，调用GetCommTimeouts()得到串口的原始超时设置；

然后，初始化DCB对象，调用SetCommState() 设置DCB，调用SetCommTimeouts()设置串口超时控制；

再次，调用SetupComm()设置串口接收发送数据的缓冲区大小，串口的设置就基本完成，之后就可以启动读写线程了。

三，异步非阻塞串口通讯的基础知识

VC串口通信技术网下面来介绍并举例说明一下编写异步非阻塞串口通讯的程序中将会使用到的几个关键函数

CreateFile()

功能：打开串口设备

函数原型

1HANDLE CreateFile（

2LPCTSTR lpFileName, // 串口名称字符串；如："COM1" 或"COM2"

3DWORD dwDesiredAccess, // 设置读写属性（访问模式）；一般为GENERIC_READ|GENERIC_WRITE,

4DWORD dwShareMode, // 共享模式；"必须"为0, 即不能共享

5LPSECURITY_ATTRIBUTES lpSecurityAttributes, // 安全属性；一般为NULL

6DWORD dwCreationDistribution, // 创建方式，串口设置必须设置此值；在这里"必须"

为OPEN_EXISTING

7DWORD dwFlagsAndAttributes, // 文件属性和标志；在这里我们设置成FILE_FLAG_OVERLAPPED ，实现异步I/O

8HANDLE hTemplateFile // 临时文件的句柄，通常为NULL

9）;

函数说明：

如果调用成功，那么该函数返回文件的句柄，如果调用失败，则函数返回INVALID_HANDLE_VALUE。例子：

10Handle m_hComm = CreateFile(com1,GENERIC_READ||GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_FLA G_OVERLAPPED,0);

CloseHandle();

函数原型：

11BOOL CloseHandle（

12HANDLE hObject // handle to object to close

13）

使用比较简单，其中参数hObject为需要关闭的串口句柄。

GetCommState（）

功能：获得串口状态

函数原型：

14BOOL GetCommState（

15HANDLE hFile, // handle of communications device

16LPDCB lpDCB // address of device-control block structure

17）;

SetCommState()

功能：设置串口状态

18BOOL SetCommState（

19HANDLE hFile, // handle of communications device

20LPDCB lpDCB // address of device-control block structure

21）;

函数说明：

在打开通信设备句柄后，常常需要对串行口进行一些初始化工作。这需要通过一个DCB结构来进行。DCB结构包含了诸如波特率、每个字符的数据位数、奇偶校验和停止位数等信息。在查询或配置置串行口的属性时，都要用DCB结构来作为缓冲区。

调用GetCommState函数可以获得串口的配置，该函数把当前配置填充到一个DCB结构中。一般在用CreateFile打开串行口后，可以调用GetCommState函数来获取串行口的初始配置。要修改串行口的配置，应该先修改DCB结构，然后再调用SetCommState函数用指定的DCB结构来设置串行口。举例：

22DCB dcb;

23memset(&dec,0,dizeof(dcb));

24if(!GetCommState(HComm,&dcb))//获取当前DCB配置

25return FALSE;

26dcb.BaudRate = CBR_9600;//修改数据传输率

27............

28if(SetCommState(hComm,&dcb))//设置新参数

29...... //错误处理

BuildCommDCB（）

功能：初始化DCB结构

函数原型：

30BOOL BuildCommDCB(

31LPCTSTR lpDef, // pointer to device-control string

32LPDCB lpDCB // pointer to device-control block

33);

示例：

34DCB dcb;

35memset(&dcb,0,sizeof(dcb));

36dcb.DCBlength = sizeof(dcb);

37if(!BuildCommDCb("9600,n,8,1",&dcb))//"baud=9600 parity=N data=8 stop=1"

38{

39 ...... //参数修改错误

40return FALSE;

41}

42else

43{

44 ...... //己准备就绪

45}

SetupComm()

功能：设置I/O缓冲区的大小

函数原型：

46BOOL SetupComm(

47HANDLE hFile, // handle to communications device

48DWORD dwInQueue, // size of input buffer

49DWORD dwOutQueue // size of output buffer

50);

说明：

除了在DCB中的设置外，程序一般还需要设置I/O缓冲区的大小和超时。Windows用I/O缓冲区来暂存串行口输入和输出的数据，如果通信的速率较高，则应该设置较大的缓冲区。调用SetupComm函数可以设置串行口的输入和输出缓冲区的大小。

先介绍一个结构：COMMTIMEOUTS

51typedef struct _COMMTIMEOUTS {

52DWORD ReadIntervalTimeout; // 读间隔超时

53DWORD ReadTotalTimeoutMultiplier; // 读时间系数

54DWORD ReadTotalTimeoutConstant; // 读时间常量

55DWORD WriteTotalTimeoutMultiplier; // 写时间系数

56DWORD WriteTotalTimeoutConstant; // 写时间常量

57} COMMTIMEOUTS,*LPCOMMTIMEOUTS;

再介绍两个函数

GetCommTimeouts

功能：读取TimeOut的值

函数原型：

58BOOL GetCommTimeouts(

59HANDLE hFile, // handle of communications device

60LPCOMMTIMEOUTS lpCommTimeouts // address of comm.

time-outs structure

61);

SetCommTimeouts

功能：设置TimeOUt的值

函数原型：

62BOOL SetCommTimeouts(

63HANDLE hFile, // handle of communications device

64LPCOMMTIMEOUTS lpCommTimeouts // address of communications time-out structure

65);

这里顺便介绍一下TimeOut机制的两个性质：

超时函数

说明：

在用ReadFile和WriteFile读写串行口时，需要考虑超时问题。如果在指定的时间内没有读出或写入指定数量的字符，那么ReadFile或WriteFile的操作就会结束。要查询当前的超时设置应调用GetCommTimeouts函数，该函数会填充一个COMMTIMEOUTS结构。调用SetCommTimeouts可以用某一个COMMTIMEOUTS结构的内容来设置超时。

有两种超时：间隔超时和总超时。间隔超时是指在接收时两个字符之间的最大时延，总超时是指读写操作总共花费的最大时间。写操作只支持总超时，而读操作两种超时均支持。用COMMTIMEOUTS结构可以规定读/写操作的超时，该结构的定义为：COMMTIMEOUTS结构的成员都以毫秒为单位。总超时的计算公式是：

总超时=时间系数×要求读/写的字符数+ 时间常量

例如，如果要读入10个字符，那么读操作的总超时的计算公式为：

读总超时＝ReadTotalTimeoutMultiplier×10 + ReadTotalTimeoutConstant

可以看出，间隔超时和总超时的设置是不相关的，这可以方便通信程序灵活地设置各种超时。

如果所有写超时参数均为0，那么就不使用写超时。如果ReadIntervalTimeout为0，那么就不使用读间隔超时，如果ReadTotalTimeoutMultiplier和ReadTotalTimeoutConstant都为0，则不使用读总超时。如果读间隔超时被设置成MAXDWORD并且两个读总超时为0，那么在读一次输入缓冲区中的内容后读操作就立即完成，而不管是否读入了要求的字符。

在用重叠方式读写串行口时，虽然ReadFile和WriteFile在完成操作以前就可能返回，但超时仍然是起作用的。在这种情况下，超时规定的是操作的完成时间，而不是ReadFile和WriteFile的返回时间。示例：

66COMMTIMEOUTS timeOver;

67memset(&&timeOver.0.sizeof(timeOver));

68DWORDtimeMultiplier,timeConstant;

69timeOver.ReadTotalTimeoutMultiplier=timeMultiplier;

70timeOver.ReadTotalTimeoutConstant=timeConstant;

71SetCommTimeouts(hComport,&&timeOver);

ReadFile（）

功能：读取数据

函数原型：

72BOOL ReadFile(

73HANDLE hFile, // 串口名称字符串（文件句柄）

74LPVOID lpBuffer, // 读缓冲区

75DWORD nNumberOfBytesToRead, // 要求读入的字节数

76LPDWORD lpNumberOfBytesRead, // 实际读入的字节数

77LPOVERLAPPED lpOverlapped // 指向一个OVERLAPPED结构

78); //若返回TRUE则表明操作成功

示例：

79char *pReciveBuf;

80DWORD nWantRead = 100,

81nReadRead;

82LPOVERLAPPED m_OverlappedRead;

83BOOL bReadStatus = ReadFile( m_hComm, preciveBuf,nWantRead, &&nReadRead, &&m_OverlappedRead );

WriteFile（）

功能：来将资料写入Serial port.

函数原型：

84BOOL WriteFile(

85HANDLE hFile, // handle to file to write to

86LPCVOID lpBuffer, // pointer to data to write to file

87DWORD nNumberOfBytesToWrite, // number of bytes to write

88LPDWORD lpNumberOfBytesWritten, // pointer to number of bytes written

89LPOVERLAPPED lpOverlapped // pointer to structure needed for overlapped I/O

90);

说明：

ReadFile函数只要在串行口输入缓冲区中读入指定数量的字符，就算完成操作。

而WriteFile函数不但要把指定数量的字符拷入到输出缓冲中，而且要等这些字符从串行口送出去后才算完成操作。

当ReadFile 和WriteFile返回FALSE时，不一定就是操作失败，线程应该调用GetLastError函数分析返回的结果。例如，在重叠操作时如果操作还未完成函数就返回，那么函数就返回FALSE，而且GetLastError函数返回ERROR_IO_PENDING。

如果GetLastError函数返回ERROR_IO_PENDING，则说明重叠操作还为完成，线程可以等待操作完成。有两种等待办法：一种办法是用象WaitForSingleObject这样的等待函数来等待OVERLAPPED 结构的hEvent成员，可以规定等待的时间，在等待函数返回后，调用GetOverlappedResult。

另一种办法是调用GetOverlappedResult函数等待，如果指定该函数的bWait参数为TRUE，那么该函数将等待OVERLAPPED结构的hEvent 事件。GetOverlappedResult可以返回一个OVERLAPPED结构来报告包括实际传输字节在内的重叠操作结果。

如果规定了读/写操作的超时，那么当超过规定时间后，hEvent成员会变成有信号的。因此，在超时发生后，WaitForSingleObject和GetOverlappedResult都会结束等待。WaitForSingleObject的dwMilliseconds参数会规定一个等待超时，该函数实际等待的时间是两个超时的最小值。注意GetOverlappedResult不能设置等待的时限，因此如果hEvent成员无信号，则该函数将一直等待下去。ClearCommError（）

功能：从字面上的意思看来, 它是用来清除错误情况用的, 但是实际上它还可以拿来取得目前通讯设备的一些信息.

函数原型

91BOOL ClearCommError(

92HANDLE hFile, // handle to communications device

93LPDWORD lpErrors, // pointer to variable to receive error codes 94LPCOMSTAT lpStat // pointer to buffer for communications status

95);

说明：

在调用ReadFile和WriteFile之前，线程应该调用ClearCommError函数清除错误标志。该函数负责报告指定的错误和设备的当前状态。

PurgeComm（）

功能：终止目前正在进行的读或写的动作

函数原型：

96BOOL PurgeComm(

97HANDLE hFile, // handle of communications resource

98);

参数说明：

HANDLE hFile,//串口名称字符串

dwFlags 共有四种flags:

PURGE_TXABORT: 终止目前正在进行的（背景）写入动作

PURGE_RXABORT: 终正目前正在进行的（背景）读取动作

PURGE_TXCLEAR: flush 写入的buffer

PURGE_TXCLEAR: flush 读取的buffer

调用PurgeComm函数可以终止正在进行的读写操作，该函数还会清除输入或输出缓冲区中的内容。GetCommMask（）

功能：得到设置的通信事件的掩码

函数原型：

99BOOL GetCommMask(

100HANDLE hFile, // handle of communications device

101LPDWORD lpEvtMask // address of variable to get event mask 102);

SetCommMask（）

功能：设置想要得到的通信事件的掩码

函数原型：

103BOOL SetCommMask(

104HANDLE hFile, // handle of communications device

105DWORD dwEvtMask // mask that identifies enabled events

106);

说明：

可设置的通信事件标志（即SetCommMask()函数所设置的掩码）

可以有EV_BREAK、EV_CTS、EV_DSR、EV_ERR、EV_RING、EV_RLSD、EV_RXCHAR、EV_RXFLAG、EV_TXEMPTY。

注：若对端口数据的响应时间要求较严格，可采用事件驱动I/O读写，Windows定义了9种串口通信事件，较常用的有：

EV_RXCHAR: 接收到一个字节，并放入输入缓冲区。

EV_TXEMPTY: 输出缓冲区中的最后一个字符发送出去。

EV_RXFLAG: 接收到事件字符(DCB结构中EvtChar成员)，放入输入缓冲区。

下面是MSDN上的解释：

EV_BREAK A break was detected on input.

EV_CTS The CTS (clear-to-send) signal changed state.

EV_DSR The DSR (data-set-ready) signal changed state.

EV_ERR A line-status error occurred. Line-status errors are CE_FRAME, CE_OVERRUN, and CE_RXPARITY.

EV_RING A ring indicator was detected.

EV_RLSD The RLSD (receive-line-signal-detect) signal changed state.

EV_RXCHAR A character was received and placed in the input buffer.

EV_RXFLAG The event character was received and placed in the input buffer. The event character is specified in the device's DCB structure, which is applied to a serial port by using the SetCommState function.

EV_TXEMPTY The last character in the output buffer was sent.

WaitCommEvent()

功能：等待设定的通讯事件的发生

函数原型：

107BOOL WaitCommEvent(

108HANDLE hFile, // handle of communications device

109LPDWORD lpEvtMask, // address of variable for event that occurred

110LPOVERLAPPED lpOverlapped, // address of overlapped structure 111);

说明：

WaitCommEvent（）会一直block（阻塞）到你所设定的通讯事件发生为止.

所以当WaitCommEvent（）返回时, 你可以由lpEvtMask 取得究竟是那一事件发生, 再来决定要如何处理.

WaitForSingleObject()

功能：保证线程同步的等待函数

函数原型：

112DWORD WaitForSingleObject(HANDLE hHandle,//同步对象的句柄

113DWORD dwMilliseconds//以毫秒为单位的超时间隔,如果设为INFINITE，则超时间隔是无限的

114);

说明：

返回值含义

WAIT_FAILED 函数失败

WAIT_OBJECT_0 指定的同步对象处于有信号的状态

WAIT_ABANDONED 拥有一个mutex的线程已经中断了，但未释放该MUTEX

WAIT_TIMEOUT 超时返回，并且同步对象无信号

WaitForMultipleObjects（）

功能：可以同时监测多个同步对象

函数原型：

115DWORD WaitForMultipleObjects(DWORD nCount,//句柄数组中句柄的数目

116CONST HANDLE *lpHandles,//代表一个句柄数组

117BOOL bWaitAll, //说明了等待类型(),如果为TRUE，那么函数在所有对象都有信号后才返回，

118//如果为FALSE，则只要有一个对象变成有信号的，函数就返

回

119DWORD dwMilliseconds//以毫秒为单位的超时间隔

120);

说明：

返回值含义

WAIT_OBJECT_0到WAIT_ OBJECT_0+nCount-1

若bWaitAll为TRUE，则返回值表明所有对象都是有信号的。如果bWaitAll为FALSE，则返回值减去WAIT_OBJECT_0就是数组中有信号对象的最小索引。

WAIT_ABANDONED_0 到WAIT_ ABANDONED_ 0+nCount-1

若bWaitAll为TRUE，则返回值表明所有对象都有信号，但有一个mutex被放弃了。若bWaitAll为FALSE，则返回值减去WAIT_ABANDONED_0就是被放弃mutex在对象数组中的索引。

WAIT_TIMEOUT 超时返回

实现重叠模型的步骤

下面就结合俺写的一个Console程序简单示例进行说明：

第一步、打开串口

121HANDLE m_hCom = CreateFile("com1",GENERIC_READ | GENERIC_WRITE, 0, NULL, 122OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);

123if (m_hCom == INVALID_HANDLE_VALUE)

124{

125cout<<"CreateFile fail!"<

126return -1;

127}

128cout<<"CreateFile OK!"<< p="" />

第二步、设置缓冲区大小

129if(!SetupComm(m_hCom,2048,2048))

130{

131cout<<"SetupComm fail! Close Comm!"<

132CloseHandle(m_hCom);

133return -1;

134}

135cout<<"SetupComm OK!"<< p="" />

第三步、设置超时

136COMMTIMEOUTS TimeOuts;

137memset(&TimeOuts,0,sizeof(TimeOuts));

138TimeOuts.ReadIntervalTimeout = MAXDWORD;

139TimeOuts.ReadTotalTimeoutConstant = 0;

140TimeOuts.ReadTotalTimeoutMultiplier = 0;

141TimeOuts.WriteT otalTimeoutConstant = 2000;

142TimeOuts.WriteT otalTimeoutMultiplier = 50;

143SetCommTimeouts(m_hCom,&TimeOuts);

第四步、设置串口参数

144DCB dcb;

145if (!GetCommState(m_hCom,&dcb))

146{

147cout<<"GetCommState fail! Comm close"<

148CloseHandle(m_hCom);

149return -1;

150}

151cout<<"GetCommState OK!"<

152

153dcb.DCBlength = sizeof(dcb);

154if (!BuildCommDCB("9600,n,8,1",&dcb))//填充ＤＣＢ的数据传输率、奇偶校验类型、数据位、停止位

155{

156//参数修改错误，进行错误处理

157cout<<"BuileCOmmDCB fail,Comm close!"<

158CloseHandle(m_hCom);

159return -1;

160}

161if(SetCommState(m_hCom,&dcb))

162{

163cout<<"SetCommState OK!"<

164}

第五步、建立并初始化重叠结构

165OVERLAPPED wrOverlapped;

166ZeroMemory(&wrOverlapped,sizeof(wrOverlapped));

167if (wrOverlapped.hEvent != NULL)

168{

169ResetEvent(wrOverlapped.hEvent);

170wrOverlapped.hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);

171}

第六步、封装数据（应按照自己的格式封装需要发送的数据）

172typedef enum

173{

174HEAT_BEAT, //心跳数据

175NET_STATE,//网络状态数据

176PACKET //正常数据包

177//支持可扩展性......

178}ProtocolType;

179

180typedef enum

181{

182Train_No,//无线车次信息

183Attemper_Command,//调度命令信息

184Revert_Command,//调度命令回执信息

185Replay_Command,//重发的调度命令信息

186KGL_SING //开关量数据

187//支持可扩展性......

188}PacketDataType;

189

190//串口数据结构

191typedef struct SerialNetProto

192{

193unsigned long PacketSize; //包总长度,不包括本身字段

194ProtocolType NetState; //协议包类型

195PacketDataType DataType; //数据类型

196unsigned long SourcedAddr; //数据包源地址

197unsigned long DestinationAddr; //数据包目的地址

198unsigned long DataLength; //包的数据段长度

199unsigned long Offset; // 数据在整个包中的偏移地址

200}PacketHead;

201

202int DataLen = 100;

203char *pBuf = new char[DataLen];

204strcpy(pBuf,"Hello World!");

205DataLen = strlen(pBuf);

206PacketHead Myhead;

207Myhead.DestinationAddr = 11;

208Myhead.SourcedAddr = 10;

209Myhead.DataType = Attemper_Command;

210Myhead.DataLength = DataLen;

https://www.360docs.net/doc/c16169240.html,State = PACKET;

212Myhead.PacketSize = sizeof(PacketHead) - sizeof(unsigned long);

213Myhead.Offset = sizeof(Myhead.DestinationAddr) +sizeof(Myhead.SourcedAddr) + sizeof(Myhead.DataType) +sizeof(Myhead.DataLength) + sizeof(https://www.360docs.net/doc/c16169240.html,State) + sizeof(Myhead.PacketSize);

214

215char *pSendBuffer = new char[sizeof(Myhead)+DataLen+ 4];//发送的数据

216memcpy(pSendBuffer,"##",2);//包头标志

217memcpy(pSendBuffer+2,(char*)&Myhead,sizeof(Myhead));//包头

218memcpy(pSendBuffer+2+sizeof(Myhead),pBuf,DataLen);//数据

219memcpy(pSendBuffer+2+sizeof(Myhead)+DataLen,"@@",2);//包尾标志

220

第七步、发送数据

221DWORD dwError;

222//DWORD dwWantSend = 100;

223DWORD dwRealSend = 0;

224char* pReadBuf = NULL;

225if (ClearCommError(m_hCom,&dwError,NULL))

226{

227PurgeComm(m_hCom,PURGE_TXABORT | PURGE_TXCLEAR);

228cout<<"PurgeComm OK!"<

229}

230if (!WriteFile(m_hCom,pSendBuffer,sizeof(Myhead)+DataLen+ 4,&dwRealSend,&wrOverlapped))

231{

232if (GetLastError() == ERROR_IO_PENDING)

233{

234while

(!GetOverlappedResult(m_hCom,&wrOverlapped,&dwRealSend,FALSE))

235{

236if (GetLastError() == ERROR_IO_INCOMPLETE)

237{

238//cout<<"写未完成，继续!"<

239continue;

240}

241else

242{

243cout<<"发生错误，尝试恢复！"<

244ClearCommError(m_hCom,&dwError,NULL);

245break;

246}

247}

248}

249}

第八步、数据接收

250DWORD dwError;

251DWORD dwWantRead = 100;

252DWORD dwRealRead = 0;

253char* pReadBuf = new char[100];

254if (ClearCommError(m_hCom,&dwError,NULL))

255{

256PurgeComm(m_hCom,PURGE_TXABORT | PURGE_TXCLEAR);

257cout<<"PurgeComm OK!"<

258}

259

260if(!ReadFile(m_hComm,pReadBuf,dwWantRead,&RealRead,&wrOverlapped))

261{

262if(dwError = GetLastError()==ERROR_IO_PENDING)

263{

While(GetOverlappedResult(m_hComm,&wrOverlapped,&dwRealRead,FALSE)) 265{

266//对接收到的数据进行数据解析，处理

267//【第九步】............

268cout<<"dwRealRead = "<<

269}

270}

271}

第九步、数据解析(数据解包处理)

272#define MAX_SERIAL_BUFFER 4096

273BOOL CanGetFullFrame(char* pReadBuf,int& dwRealRead)

274{

275static char Buf[MAX_SERIAL_BUFFER*2];//自定义一个数据缓冲区

276static unsigned long nFrameStart = 0;//数据祯的开始位置

277static unsigned long nFrameEnd = 0;//数据祯的结束位置

278static unsigned long nCurrectPos = 0;//指针当前位置

279char *pdest = NULL;

280

281if (pReadBuf && (dwRealRead!= 0))

282{

283memcpy(&Buf[nCurrectPos],pReadBuf,dwRealRead);

284nCurrectPos = nCurrectPos + dwRealRead;//更新当前位置

285}

286//查找数据祯的开始标志

287pdest = (char*)Find(Buf,"##",MAX_SERIAL_BUFFER*2,2);

288if (pdest)

289{

290nFrameStart = unsigned long(pdest - Buf);//找到数据祯的开始位置291}

292else//没有找到开始祯标志"##"

293{

294Buf[0] = Buf[nCurrectPos];//丢弃数据

295nFrameStart = 0;

296return FALSE;

297}

298

299//查找数据祯的结尾标志

300pdest = (char*)Find(Buf,"@@",MAX_SERIAL_BUFFER*2,2);

301if (pdest)

302{

303nFrameEnd = unsigned long (pdest - Buf+2);

304dwRealRead= nFrameEnd - nFrameStart;

305memcpy(pReadBuf,&Buf[nFrameStart],dwRealRead);

307nFrameStart = nFrameEnd;//指向下一帧的开始位置

308nCurrectPos = nCurrectPos - dwRealRead;//修正nCurrentPos值

309memcpy(Buf,&Buf[nFrameEnd],nCurrectPos);//向前移动数据

310return TRUE;

311}

312else

313{

314return FALSE;

315}

316}

317

318//一个在内存块中查找指定字符串的函数

319void* Find(const char *pSour,const char *pDest,int SourLen,int DestLen)

320{

321int i = 0, j = 0;

322while(i < SourLen && j < DestLen)

323{

324if(*(pSour + i) == *(pDest + j))

325{

326i++;

327j++;

328}

329else

330{

331i =i - j + 1;

332j = 0;

333}

334}

335if(j == DestLen)

336{

337return (void*)(pSour + (i - DestLen));

338}

339else

340{

341return NULL;

342}

343

344}

345

【第十步】重新投递Overlapped

.......略.........

以上VC异步串口编程代码未使用任何串口控件或串口类，在VC串口通信技术网的另一篇文章《用Windows API进行串口编程的一般步骤及相关函数讲解》也讲到了VC串口编程时的异步串口和同步串

口操作方法。