WaitCommEvent等待EV_RXCHAR事件为什么会发生2次？

zhangjingrui

WaitCommEvent等待EV_RXCHAR事件为什么会发生2次？ [复制链接]

writefile()指令之后，为什么会收到两次EV_RXCHAR事件？按道理应该收到一次EV_RXCHAR事件，可是收到两次EV_RXCHAR事件
这到底是什么原因？？？

1. 
   
2. ...
   
3. for(;;)
   
4.     {
   
5.         bResult=WaitCommEvent(m_hCom,&hMask,&ReadOver);   
   
6.         if(OpenCloseFlag==1)  //串口已被打开才做下一部
   
7.         {
   
8.             if(!bResult)
   
9.             {
   
10.                 switch(dwErr=GetLastError())
    
11.                 {
    
12.                     case ERROR_IO_PENDING:
    
13.                          Flag^=1;
    
14.                          break;
    
15.                    /*case 87:
    
16.                         break;*/
    
17.                     default:
    
18.                         SetDlgItemText((HWND)lparam,IDC_COMMSTATE,"WaitCommEvent Error");
    
19.                         goto ErrorNext;
    
20.                 }
    
21.             }else
    
22.             {
    
23.                 bResult=ClearCommError(m_hCom,&dwErr,&comstat);
    
24.                 if(comstat.cbInQue==0)
    
25.                    continue;
    
26.             }         
    
27.             WaitForSingleObject(ReadOver.hEvent,INFINITE);///等侍异步操作完成
    
28.             Flag=0;
    
29.             GetCommMask(m_hCom,&hMask);
    
30.             if(hMask & EV_RXCHAR)         
    
31.             {   
    
32.                 EnterCriticalSection(§ion);
    
33.                    bResult=ClearCommError(m_hCom,&dwErr,&comstat);
    
34.                 if(!ReadFile(m_hCom,pszRecv,100,&ReadBytes,&ReadOver))
    
35.                 {
    
36.                     switch(dwErr=GetLastError())
    
37.                     {
    
38.                         case ERROR_IO_PENDING:
    
39.                             Flag^=1;
    
40.                             break;
    
41.                         default:
    
42.                             goto ErrorNext;
    
43.                     }
    
44.                 }
    
45.                      
    
46.                 if(Flag & 1)
    
47.                 {
    
48.                      SetDlgItemText((HWND)lparam,IDC_COMMSTATE,"正在读取数据");
    
49.                      WaitForSingleObject(ReadOver.hEvent,INFINITE);
    
50. 
    
51.                     if(GetOverlappedResult(m_hCom,&ReadOver,&ReadBytes,TRUE))
    
52.                     {
    
53.                         SetDlgItemText((HWND)lparam,IDC_COMMSTATE,"读取数据完成");
    
54.                         SetDlgItemText((HWND)lparam,IDC_SHOWINFO,pszRecv);
    
55.                     }
    
56.                 }   
    
57.                  
    
58.                         
    
59.                LeaveCriticalSection(§ion);
    
60. 
    
61.             }
    
62. ErrorNext:
    
63.         Flag=0;
    
64.         PurgeComm(m_hCom,PURGE_TXABORT | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_RXCLEAR);
    
65.   
    
66.         }   
    
67.      
    
68.     }
    
69.     return 1;
    
70. }
    
71. ...
    
72. 
    
73. 
    
74. 
    
75. 
    
76. 
    

复制代码

video_wang

先调用SetCommMask函数设定要等待的串口事件，例如串口有数据到来（EV_RXCHAR）事件；然后在读串口线程中调用WaitCommEvent阻塞线程，等待EV_RXCHAR事件的发生。当等待的EV_RXCHAR事件发生时，调用ClearCommError函数清除通信错误信息，并且获取串口的当前状态，主要是获取串口接收缓冲区中的字节数，然后调用ReadFile函数将接收缓冲区的数据全部读出。最后调用PostMessage函数将这些数据发送给主线程进行处理。

shixing312

引用 1 楼 duojinian 的回复:
先调用SetCommMask函数设定要等待的串口事件，例如串口有数据到来（EV_RXCHAR）事件；然后在读串口线程中调用WaitCommEvent阻塞线程，等待EV_RXCHAR事件的发生。当等待的EV_RXCHAR事件发生时，调用ClearCommError函数清除通信错误信息，并且获取串口的当前状态，主要是获取串口接收缓冲区中的字节数，然后调用ReadFile函数将接收缓冲区的数据全部读出。最后调用PostMessage函数将这些数据发送给主线程进行处理。

你好，谢谢你的回答！按照你的手法好像不行！贴上读线程代码：

1. 
   
2. DWORD WINAPI ReadCommThread(LPARAM lparam)///读线程
   
3. {
   
4. 
   
5.     extern HANDLE m_hCom;
   
6.     extern OpenCloseFlag;
   
7.     extern unsigned char pszRecv[1024];
   
8.     DWORD ReadBytes;
   
9.         DWORD bResult;
   
10.         DWORD dwErr;
    
11.         OVERLAPPED ReadOver={0};
    
12.         DWORD hMask;
    
13.         DWORD CommEvent;
    
14.         int i=0;
    
15.         CRITICAL_SECTION section;
    
16.         COMSTAT comstat;
    
17. 
    
18.         DWORD Flag=0;
    
19.         memset(&ReadOver,0x00,sizeof(OVERLAPPED));
    
20.         ReadOver.Internal=0;
    
21.         ReadOver.InternalHigh=0;
    
22.        ReadOver.Offset=0;
    
23.        ReadOver.OffsetHigh=0;
    
24.         ReadOver.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
    
25.         PurgeComm(m_hCom,PURGE_TXABORT | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_RXCLEAR);
    
26.         InitializeCriticalSection(§ion);
    
27.   for(;;)
    
28.     {
    
29.    
    
30.         bResult=WaitCommEvent(m_hCom,&hMask,&ReadOver);   
    
31. 
    
32.         if(OpenCloseFlag==1)  //串口已被打开才做下一部
    
33.         {
    
34.             if(!bResult)
    
35.             {
    
36.                 switch(dwErr=GetLastError())
    
37.                 {
    
38.                     case ERROR_IO_PENDING:
    
39.                          Flag^=1;
    
40.                          break;
    
41.                    /*case 87:
    
42.                         break;*/
    
43.                     default:
    
44.                         SetDlgItemText((HWND)lparam,IDC_COMMSTATE,"WaitCommEvent Error");
    
45.                         goto ErrorNext;
    
46.                 }
    
47.             }else
    
48.             {
    
49.                 bResult=ClearCommError(m_hCom,&dwErr,&comstat);
    
50.                 if(comstat.cbInQue==0)
    
51.                    continue;
    
52.             }         
    
53.             WaitForSingleObject(ReadOver.hEvent,INFINITE);///等侍异步操作完成
    
54.             Flag=0;
    
55.             GetCommMask(m_hCom,&hMask);
    
56.             if(hMask & EV_RXCHAR)         
    
57.             {   
    
58.                 EnterCriticalSection(§ion);
    
59.                    bResult=ClearCommError(m_hCom,&dwErr,&comstat);
    
60.                 if(!ReadFile(m_hCom,pszRecv,100,&ReadBytes,&ReadOver))
    
61.                 {
    
62.                     switch(dwErr=GetLastError())
    
63.                     {
    
64.                         case ERROR_IO_PENDING:
    
65.                             Flag^=1;
    
66.                             break;
    
67.                         default:
    
68.                             goto ErrorNext;
    
69.                     }
    
70.                 }
    
71.                      
    
72.                 if(Flag & 1)
    
73.                 {
    
74.                      SetDlgItemText((HWND)lparam,IDC_COMMSTATE,"正在读取数据");
    
75.                      WaitForSingleObject(ReadOver.hEvent,INFINITE);
    
76. 
    
77.                     if(GetOverlappedResult(m_hCom,&ReadOver,&ReadBytes,TRUE))
    
78.                     {
    
79.                         SetDlgItemText((HWND)lparam,IDC_COMMSTATE,"读取数据完成");
    
80.                         SetDlgItemText((HWND)lparam,IDC_SHOWINFO,pszRecv);
    
81.                     }
    
82.                 }   
    
83.                  
    
84.                         
    
85.                LeaveCriticalSection(§ion);
    
86. 
    
87.             }
    
88. ErrorNext:
    
89.         Flag=0;
    
90.         PurgeComm(m_hCom,PURGE_TXABORT | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_RXCLEAR);
    
91.   
    
92.         }   
    
93.      
    
94.     }
    
95.     return 1;
    
96. }
    
97. 
    
98. 
    
99. 
    

复制代码

piaofu

这是写入串口的函数：

1. 
   
2. BOOL WriteComm(HWND hWnd)   //写串口
   
3. {
   
4.     extern char *pszReadWriteComm;
   
5.     extern HANDLE m_hCom;
   
6.     extern FileSize,WriteFlag;
   
7.     char pszWriteBuffer[1024];
   
8.         DWORD WriteBytes;
   
9.         OVERLAPPED hWriteOver;///重叠IO
   
10.         int FlagState=1,dwErr;
    
11.     // OVERLAPPED结构实始化为0
    
12.         memset(&hWriteOver,0x00,sizeof(OVERLAPPED));
    
13.         hWriteOver.Internal=0;
    
14.         hWriteOver.InternalHigh=0;
    
15.         hWriteOver.Offset=0;
    
16.         hWriteOver.OffsetHigh=0;
    
17.         hWriteOver.hEvent=CreateEvent(0,TRUE,FALSE,0);
    
18.     if(hWriteOver.hEvent!=NULL)
    
19.         {
    
20.                 if(WriteFlag==1)
    
21.                 {
    
22.                         if(!WriteFile(m_hCom,pszReadWriteComm,FileSize,&WriteBytes,&hWriteOver))
    
23.                         {
    
24.                                 if(GetLastError()!=ERROR_IO_PENDING)
    
25.                                         MessageBox(hWnd,"写串口失败",0,MB_OK);
    
26.                                 else
    
27.                                 {
    
28.                     
    
29.                                         dwErr=WaitForSingleObject(hWriteOver.hEvent,INFINITE);
    
30.                                         switch(dwErr)
    
31.                                         {
    
32.                         
    
33.                                             case WAIT_OBJECT_0:
    
34.                                                     if(!GetOverlappedResult(m_hCom,&hWriteOver,&WriteBytes,FALSE))
    
35.                                                             MessageBox(hWnd,"重叠IO失败",0,MB_OK);
    
36.                                            
    
37.                                                     break;
    
38.                                             default:
    
39.                                                     MessageBox(hWnd,"重叠IO失败",0,MB_OK);
    
40.                                                     break;
    
41.                                         }
    
42. 
    
43.                                  }
    
44.                          }
    
45.             }
    
46.                 else
    
47.                 {
    
48. 
    
49.                     byte buffsg[8]={0x00,0x03,0x00,0x50,0x00,0x0A,0x00,0x00};
    
50.                 if(!WriteFile(m_hCom,buffsg,8,&WriteBytes,&hWriteOver))
    
51.                         {
    
52.                    //ShowError();
    
53.                                 if(GetLastError()!=ERROR_IO_PENDING)
    
54.                                         MessageBox(hWnd,"写串口失败",0,MB_OK);
    
55.                                 else
    
56.                                 {
    
57.          
    
58.                                         dwErr=WaitForSingleObject(hWriteOver.hEvent,INFINITE);
    
59.                                         switch(dwErr)
    
60.                                         {
    
61.                                             case WAIT_OBJECT_0:
    
62.                                                     if(!GetOverlappedResult(m_hCom,&hWriteOver,&WriteBytes,FALSE))
    
63.                                                             MessageBox(hWnd,"重叠IO失败",0,MB_OK);
    
64.                                                     break;
    
65.                                             default:
    
66.                                                     MessageBox(hWnd,"重叠IO失败",0,MB_OK);
    
67.                                                     break;
    
68. 
    
69.                                         }
    
70. 
    
71.                                 }
    
72.                         }
    
73. 
    
74.                 }
    
75. 
    
76.         }
    
77. 
    
78.      PurgeComm(m_hCom,PURGE_TXABORT | PURGE_TXCLEAR);
    
79.        
    
80.         return TRUE;
    
81. }
    
82. 
    

复制代码

dzghl163

我给串口发送指令后，仪表也返回串口数据。问题是现在EV_RXCHAR被触发了两次，第二次触发好像是没用，为什么会触发第二次，实在是找不到原因？？？