关于2440，ce5中的串口COM_Write函数的WaitReturn = WaitForSingleObject

lianxiangke

关于2440，ce5中的串口COM_Write函数的WaitReturn = WaitForSingleObject [复制链接]

1. 
   
2. ULONG
   
3. COM_Write(HANDLE pHead,         /*@parm [IN]  HANDLE returned by COM_Open.*/
   
4.           PUCHAR pSourceBytes,  /*@parm [IN]  Pointer to bytes to be written.*/
   
5.           ULONG  NumberOfBytes  /*@parm [IN]  Number of bytes to be written. */
   
6.          )
   
7. {
   
8.     PHW_OPEN_INFO   pOpenHead = (PHW_OPEN_INFO)pHead;
   
9.     PHW_INDEP_INFO  pSerialHead = pOpenHead->pSerialHead;
   
10.     ULONG               BytesWritten   = 0;
    
11.     ULONG               TotalWritten   = 0;
    
12.     PHWOBJ              pHWObj         = NULL;
    
13.     PVOID               pHWHead        = NULL;
    
14.     PHW_VTBL            pFuncTbl       = NULL;
    
15.     ULONG               TotalTimeout;   // The Total Timeout
    
16.     ULONG               Timeout;        // The Timeout value actually used
    
17.     ULONG               WaitReturn;
    
18. 
    
19.     DEBUGMSG (ZONE_WRITE|ZONE_FUNCTION,
    
20.               (TEXT("+COM_WRITE(0x%X, 0x%X, %d)\r\n"), pHead,
    
21.                pSourceBytes, NumberOfBytes));      
    
22. 
    
23. 
    
24.     // Check validity of handle
    
25.     if ( !pSerialHead || !pSerialHead->OpenCnt ) {
    
26.         DEBUGMSG (ZONE_WRITE|ZONE_ERROR,
    
27.                   (TEXT("COM_WRITE, device not open\r\n") ));
    
28.         SetLastError (ERROR_INVALID_HANDLE);
    
29.         return(ULONG)-1;
    
30.     }
    
31. 
    
32.     // Make sure the caller has access permissions
    
33.     if ( !(pOpenHead->AccessCode & GENERIC_WRITE) ) {
    
34.         DEBUGMSG(ZONE_USR_READ|ZONE_ERROR,
    
35.                  (TEXT("COM_Write: Access permission failure x%X\n\r"),
    
36.                   pOpenHead->AccessCode));
    
37.         SetLastError (ERROR_INVALID_ACCESS);
    
38.         return(ULONG)-1;
    
39.     }
    
40. 
    
41. #ifdef DEBUG
    
42.     if ( IsBadReadPtr(pSourceBytes, NumberOfBytes) ) {
    
43.         DEBUGMSG (ZONE_WRITE|ZONE_ERROR,
    
44.                   (TEXT("COM_WRITE, bad read pointer\r\n") ));
    
45.         SetLastError(ERROR_INVALID_PARAMETER);
    
46.         return(ULONG)-1;
    
47.     }
    
48. #endif
    
49. 
    
50.     COM_INC_USAGE_CNT(pOpenHead);
    
51. 
    
52.     pHWObj   = pSerialHead->pHWObj;
    
53.     pHWHead  = pSerialHead->pHWHead;
    
54.     pFuncTbl = pHWObj->pFuncTbl;
    
55. 
    
56.     /* Lock out other threads from messing with these pointers.
    
57.      */
    
58.     DEBUGMSG (ZONE_WRITE, (TEXT("COM_Write wait for CritSec %x.\r\n"),
    
59.                            &(pSerialHead->TransmitCritSec1)));
    
60.     EnterCriticalSection(&(pSerialHead->TransmitCritSec1));
    
61.     DEBUGMSG (ZONE_WRITE, (TEXT("COM_Write Got CritSec %x.\r\n"),
    
62.                            &(pSerialHead->TransmitCritSec1)));
    
63. 
    
64.     DEBUGMSG (ZONE_WRITE, (TEXT("COM_Write wait for CritSec %x.\r\n"),
    
65.                            &(pSerialHead->TxBufferInfo.CS)));
    
66.     TxEnterCS(pSerialHead);
    
67.     DEBUGMSG (ZONE_WRITE, (TEXT("COM_Write got CritSec %x.\r\n"),
    
68.                            &(pSerialHead->TxBufferInfo.CS)));
    
69. 
    
70.     pSerialHead->fAbortTransmit = 0;
    
71.     // Clear any pending event
    
72.     WaitForSingleObject(pSerialHead->hTransmitEvent,0);
    
73. 
    
74.     pSerialHead->TxBufferInfo.Permissions = GetCurrentPermissions();
    
75.     pSerialHead->TxBufferInfo.TxCharBuffer = pSourceBytes;
    
76.     pSerialHead->TxBufferInfo.Length = NumberOfBytes;
    
77.     TxRead(pSerialHead) = 0;
    
78.     pSerialHead->TxBytesSent = 0;
    
79.     pSerialHead->TxBytesPending = NumberOfBytes;
    
80. 
    
81.     // Make sure an event isn't hanging around from a previous write time out.
    
82.     ResetEvent( pSerialHead->hTransmitEvent );
    
83. 
    
84.     TxLeaveCS(pSerialHead);
    
85.     DEBUGMSG (ZONE_WRITE|ZONE_FUNCTION,
    
86.               (TEXT("COM_Write released CritSec: %x.\r\n"),
    
87.                &(pSerialHead->TxBufferInfo.CS)));
    
88. 
    
89.     // We call the same write routine that a TX_INTR does.  It queus as
    
90.     // much data as possible, then returns.  From then on, the normal
    
91.     // interrupt mechanism kicks in.
    
92.     DoTxData( pSerialHead );
    
93. 
    
94.     TotalTimeout = pSerialHead->CommTimeouts.WriteTotalTimeoutMultiplier*NumberOfBytes +
    
95.                    pSerialHead->CommTimeouts.WriteTotalTimeoutConstant;
    
96. 
    
97.     if ( !TotalTimeout )
    
98.         Timeout = INFINITE;
    
99.     else
    
100.         Timeout = TotalTimeout;
     
101. 
     
102.     DEBUGMSG (ZONE_WRITE, (TEXT("COM_Write wait for transmission complete event %x.\r\n"),
     
103.                            pSerialHead->hTransmitEvent));
     
104. 
     
105.     [color=#FF0000]WaitReturn = WaitForSingleObject (pSerialHead->hTransmitEvent, Timeout);[/color]
     
106.     [color=#FF0000]这里在等啥事件啊？这个事件是怎么发生的啊？由谁产生的？在哪里被处理的？[/color]
     
107.     // In the absense of WaitForMultipleObjects, we use flags to
     
108.     // handle errors/aborts. Check for aborts or asynchronous closes.
     
109.     if ( pSerialHead->fAbortTransmit ) {
     
110.         DEBUGMSG(ZONE_USR_READ,(TEXT("COM_Write - Aborting write\r\n")));
     
111.         goto LEAVEWRITE;
     
112.     }
     
113. 
     
114.     if ( !pSerialHead->OpenCnt ) {
     
115.         DEBUGMSG(ZONE_WRITE|ZONE_ERROR,
     
116.                  (TEXT("COM_Write - device was closed\n\r")));
     
117.         SetLastError(ERROR_INVALID_HANDLE);
     
118.         goto LEAVEWRITE;
     
119.     }
     
120. 
     
121. #ifdef DEBUG
     
122.     if ( WAIT_TIMEOUT == WaitReturn ) {
     
123.         // Timeout
     
124.         DEBUGMSG (ZONE_WARN, (TEXT("Write timeout %d, %d\r\n"), NumberOfBytes, pSerialHead->TxBytesPending));
     
125.     } else {
     
126.         DEBUGMSG (ZONE_WRITE, (TEXT("COM_Write completed normally.\r\n")));
     
127.     }
     
128. #endif
     
129. 
     
130.     LEAVEWRITE:
     
131.     // Regardless of timeout, we need to clear the TxBufferInfo
     
132.     // to prevent ISR from possibly coming around and trying to use
     
133.     // the buffer after we have returned to the caller.
     
134.     DEBUGMSG (ZONE_WRITE, (TEXT("COM_Write wait for CritSec %x.\r\n"),
     
135.                            &(pSerialHead->TxBufferInfo.CS)));
     
136.     TxEnterCS(pSerialHead);
     
137.     DEBUGMSG (ZONE_WRITE, (TEXT("COM_Write got CritSec %x.\r\n"),
     
138.                            &(pSerialHead->TxBufferInfo.CS)));
     
139.     pSerialHead->TxBufferInfo.Permissions = 0;
     
140.     pSerialHead->TxBufferInfo.TxCharBuffer = NULL;
     
141.     pSerialHead->TxBufferInfo.Length = 0;
     
142.     pSerialHead->TxBytesPending = 0;
     
143.     TxRead(pSerialHead) = 0;
     
144.     TxLeaveCS(pSerialHead);
     
145.     DEBUGMSG (ZONE_WRITE|ZONE_FUNCTION,
     
146.               (TEXT("COM_Write released CritSec: %x.\r\n"),
     
147.                &(pSerialHead->TxBufferInfo.CS)));
     
148. 
     
149. 
     
150.     LeaveCriticalSection(&(pSerialHead->TransmitCritSec1));
     
151.     DEBUGMSG (ZONE_WRITE|ZONE_FUNCTION,
     
152.               (TEXT("COM_Write released CritSec: %x. Exiting\r\n"),
     
153.                &(pSerialHead->TransmitCritSec1)));
     
154. 
     
155.     /* OK, the Transmitter has gone empty.
     
156.      */
     
157.     EvaluateEventFlag(pSerialHead, EV_TXEMPTY);
     
158. 
     
159.     if ( pSerialHead->DCB.fRtsControl == RTS_CONTROL_TOGGLE ) {
     
160.         pFuncTbl->HWClearRTS(pHWHead);
     
161.     }
     
162. 
     
163.     COM_DEC_USAGE_CNT(pOpenHead);
     
164.     DEBUGMSG (ZONE_WRITE|ZONE_FUNCTION,
     
165.               (TEXT("-COM_WRITE, returning %d\n\r"),pSerialHead->TxBytesSent));
     
166.     return(pSerialHead->TxBytesSent);
     
167. }
     

复制代码

铃铛

WaitReturn = WaitForSingleObject (pSerialHead->hTransmitEvent, Timeout);
这里在等啥事件啊？这个事件是怎么发生的啊？由谁产生的？在哪里被处理的？
初学，莫见怪。。谢谢。

zhaofengxiao

在状态转换时Set的，没有其他代码了么？

wujieflash

引用 1 楼 ulovexd 的回复:

WaitReturn = WaitForSingleObject (pSerialHead->hTransmitEvent, Timeout);
这里在等啥事件啊？这个事件是怎么发生的啊？由谁产生的？在哪里被处理的？
初学，莫见怪。。谢谢。

这个是发送啊，你写数据肯定要启动这个线程了。

这个用于操作系统同步的pSerialHead->hTransmitEvent得到响应后，就去执行线程了，否则系统在做别的工作。

woaini911zmz

引用 3 楼 gooogleman 的回复:


这个是发送啊，你写数据肯定要启动这个线程了。

这个用于操作系统同步的pSerialHead->hTransmitEvent得到响应后，就去执行线程了，否则系统在做别的工作。

好像不是这么解释的吧？

在COM_Write()函数中，先ResetEvent(pSerialHead->hTransmitEvent)，然后接着调用DoTxData( pSerialHead )[该函数中又调用HWTxIntrHandler()-->对应驱动中的具体负责发数据发送到串口发送缓冲区的SL_TxIntrEx()函数];然后再WaitReturn = WaitForSingleObject (pSerialHead->hTransmitEvent, Timeout);
所以这里应该是对应做了个写超时的等待！