SerialPort.h
1 #ifndef __SERIALPORT_H__
2 #define __SERIALPORT_H__
3
4 #define WM_COMM_BREAK_DETECTED WM_USER+1 // A break was detected on input.
5 #define WM_COMM_CTS_DETECTED WM_USER+2 // The CTS (clear-to-send) signal changed state.
6 #define WM_COMM_DSR_DETECTED WM_USER+3 // The DSR (data-set-ready) signal changed state.
7 #define WM_COMM_ERR_DETECTED WM_USER+4 // A line-status error occurred. Line-status errors are CE_FRAME, CE_OVERRUN, and CE_RXPARITY.
8 #define WM_COMM_RING_DETECTED WM_USER+5 // A ring indicator was detected.
9 #define WM_COMM_RLSD_DETECTED WM_USER+6 // The RLSD (receive-line-signal-detect) signal changed state.
10 #define WM_COMM_RXCHAR WM_USER+7 // A character was received and placed in the input buffer.
11 #define WM_COMM_RXFLAG_DETECTED WM_USER+8 // The event character was received and placed in the input buffer.
12 #define WM_COMM_TXEMPTY_DETECTED WM_USER+9 // The last character in the output buffer was sent.
13
14 class CSerialPort
15 {
16 public:
17 // contruction and destruction
18 CSerialPort(); // 构造函数
19 virtual ~CSerialPort(); //析构函数虚拟化了，是为了不同端口对象被消灭的时候，可以进行不同的收尾工作
20
21 // port initialisation
22 BOOL InitPort(CWnd* pPortOwner, UINT portnr = 1, UINT baud = 19200,
23 char parity = ‘N‘, UINT databits = 8, UINT stopsbits = 1,
24 DWORD dwCommEvents = EV_RXCHAR | EV_CTS, UINT nBufferSize = 512,
25
26 DWORD ReadIntervalTimeout = 1000,
27 DWORD ReadTotalTimeoutMultiplier = 1000,
28 DWORD ReadTotalTimeoutConstant = 1000,
29 DWORD WriteTotalTimeoutMultiplier = 1000,
30 DWORD WriteTotalTimeoutConstant = 1000);
31
32 // start/stop comm watching
33 BOOL StartMonitoring();
34 BOOL RestartMonitoring();
35 BOOL StopMonitoring();
36
37 DWORD GetWriteBufferSize();
38 DWORD GetCommEvents();
39 DCB GetDCB();
40
41 void WriteToPort(char* string);
42 void WriteToPort(char* string,int n); // add by mrlong 2007-12-25
43 void WriteToPort(LPCTSTR string); // add by mrlong 2007-12-25
44 void WriteToPort(BYTE* Buffer, int n);// add by mrlong
45 void ClosePort(); // add by mrlong 2007-12-2
46
47 void SendData(LPCTSTR lpszData, const int nLength); //串口发送函数 by mrlong 2008-2-15
48 BOOL RecvData(LPTSTR lpszData, const int nSize); //串口接收函数 by mrlong 2008-2-15
49
50 protected:
51 // protected memberfunctions
52 void ProcessErrorMessage(char* ErrorText);
53 static UINT CommThread(LPVOID pParam);
54 static void ReceiveChar(CSerialPort* port, COMSTAT comstat);
55 static void WriteChar(CSerialPort* port);
56
57 // thread
58 CWinThread* m_Thread;
59
60 // synchronisation objects
61 CRITICAL_SECTION m_csCommunicationSync;
62 BOOL m_bThreadAlive;
63
64 // handles
65 HANDLE m_hShutdownEvent; //stop发生的事件
66 HANDLE m_hComm; // read
67 HANDLE m_hWriteEvent; // write
68
69 // Event array.
70 // One element is used for each event. There are two event handles for each port.
71 // A Write event and a receive character event which is located in the overlapped structure (m_ov.hEvent).
72 // There is a general shutdown when the port is closed.
73 HANDLE m_hEventArray[3];
74
75 // structures
76 OVERLAPPED m_ov;
77 COMMTIMEOUTS m_CommTimeouts;
78 DCB m_dcb;
79
80 // owner window
81 CWnd* m_pOwner;
82
83 // misc
84 UINT m_nPortNr; //?????
85 char* m_szWriteBuffer;
86 DWORD m_dwCommEvents;
87 DWORD m_nWriteBufferSize;
88
89 int m_nWriteSize; //add by mrlong 2007-12-25
90 };
91
92 #endif __SERIALPORT_H__
SerialPort.cpp
1 #include "stdafx.h"
2 #include "SerialPort.h"
3
4 #include <assert.h>
5
6 //
7 // Constructor
8 //
9 CSerialPort::CSerialPort()
10 {
11 m_hComm = NULL;
12
13 // initialize overlapped structure members to zero
14 m_ov.Offset = 0;
15 m_ov.OffsetHigh = 0;
16
17 // create events
18 m_ov.hEvent = NULL;
19 m_hWriteEvent = NULL;
20 m_hShutdownEvent = NULL;
21
22 m_szWriteBuffer = NULL;
23
24 m_bThreadAlive = FALSE;
25 m_nWriteSize = 1;
26 }
27
28 //
29 // Delete dynamic memory
30 //
31 CSerialPort::~CSerialPort()
32 {
33 do
34 {
35 SetEvent(m_hShutdownEvent);
36 } while (m_bThreadAlive);
37
38 if (m_hComm != NULL)
39 {
40 CloseHandle(m_hComm);
41 m_hComm = NULL;
42 }
43 // Close Handles
44 if(m_hShutdownEvent!=NULL)
45 CloseHandle( m_hShutdownEvent);
46 if(m_ov.hEvent!=NULL)
47 CloseHandle( m_ov.hEvent );
48 if(m_hWriteEvent!=NULL)
49 CloseHandle( m_hWriteEvent );
50
51 TRACE("Thread ended\n");
52
53 delete [] m_szWriteBuffer;
54 }
55
56 //
57 // Initialize the port. This can be port 1 to 4.
58 //
59 //
60 //parity:
61 // n=none
62 // e=even
63 // o=odd
64 // m=mark
65 // s=space
66 //data:
67 // 5,6,7,8
68 //stop:
69 // 1,1.5,2
70 //
71 BOOL CSerialPort::InitPort(CWnd* pPortOwner, // the owner (CWnd) of the port (receives message)
72 UINT portnr,
73 UINT baud, // baudrate
74 char parity, // parity
75 UINT databits, // databits
76 UINT stopbits, // stopbits
77 DWORD dwCommEvents, // EV_RXCHAR, EV_CTS etc
78 UINT writebuffersize,// size to the writebuffer
79
80 DWORD ReadIntervalTimeout,
81 DWORD ReadTotalTimeoutMultiplier,
82 DWORD ReadTotalTimeoutConstant,
83 DWORD WriteTotalTimeoutMultiplier,
84 DWORD WriteTotalTimeoutConstant )
85
86 {
87 //assert(portnr > 0 && portnr < 5);//Del by wl 20120612
88 assert(pPortOwner != NULL);
89
90 // if the thread is alive: Kill
91 if (m_bThreadAlive)
92 {
93 do
94 {
95 SetEvent(m_hShutdownEvent);
96 } while (m_bThreadAlive);
97 TRACE("Thread ended\n");
98 }
99
100 // create events
101 if (m_ov.hEvent != NULL)
102 ResetEvent(m_ov.hEvent);
103 else
104 m_ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
105
106 if (m_hWriteEvent != NULL)
107 ResetEvent(m_hWriteEvent);
108 else
109 m_hWriteEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
110
111 if (m_hShutdownEvent != NULL)
112 ResetEvent(m_hShutdownEvent);
113 else
114 m_hShutdownEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
115
116 // initialize the event objects
117 m_hEventArray[0] = m_hShutdownEvent; // highest priority
118 m_hEventArray[1] = m_ov.hEvent;
119 m_hEventArray[2] = m_hWriteEvent;
120
121 // initialize critical section
122 InitializeCriticalSection(&m_csCommunicationSync);
123
124 // set buffersize for writing and save the owner
125 m_pOwner = pPortOwner;
126
127 if (m_szWriteBuffer != NULL)
128 delete [] m_szWriteBuffer;
129 m_szWriteBuffer = new char[writebuffersize];
130
131 m_nPortNr = portnr;
132
133 m_nWriteBufferSize = writebuffersize;
134 m_dwCommEvents = dwCommEvents;
135
136 BOOL bResult = FALSE;
137 char *szPort = new char[50];
138 char *szBaud = new char[50];
139
140 // now it critical!
141 EnterCriticalSection(&m_csCommunicationSync);
142
143 // if the port is already opened: close it
144 if (m_hComm != NULL)
145 {
146 CloseHandle(m_hComm);
147 m_hComm = NULL;
148 }
149
150 // prepare port strings
151 sprintf(szPort, "COM%d", portnr);
152 // stop is index 0 = 1 1=1.5 2=2
153 int mystop;
154 int myparity;
155 switch(stopbits)
156 {
157 case 0:
158 mystop = ONESTOPBIT;
159 break;
160 case 1:
161 mystop = ONE5STOPBITS;
162 break;
163 case 2:
164 mystop = TWOSTOPBITS;
165 break;
166 }
167 myparity = 0;
168 switch(parity)
169 {
170 case ‘N‘:
171 myparity = 0;
172 break;
173 case ‘E‘:
174 myparity = 1;
175 break;
176 case ‘O‘:
177 myparity = 2;
178 break;
179 case ‘M‘:
180 myparity = 3;
181 break;
182 case ‘S‘:
183 myparity = 4;
184 break;
185 }
186 sprintf(szBaud, "baud=%d parity=%c data=%d stop=%d", baud, parity, databits, mystop);
187
188 // get a handle to the port
189 m_hComm = CreateFile(szPort, // communication port string (COMX)
190 GENERIC_READ | GENERIC_WRITE, // read/write types
191 0, // comm devices must be opened with exclusive access
192 NULL, // no security attributes
193 OPEN_EXISTING, // comm devices must use OPEN_EXISTING
194 FILE_FLAG_OVERLAPPED, // Async I/O
195 0); // template must be 0 for comm devices
196
197 if (m_hComm == INVALID_HANDLE_VALUE)
198 {
199 // port not found
200 delete [] szPort;
201 delete [] szBaud;
202
203 return FALSE;
204 }
205
206 // set the timeout values
207 m_CommTimeouts.ReadIntervalTimeout = ReadIntervalTimeout * 1000;
208 m_CommTimeouts.ReadTotalTimeoutMultiplier = ReadTotalTimeoutMultiplier * 1000;
209 m_CommTimeouts.ReadTotalTimeoutConstant = ReadTotalTimeoutConstant * 1000;
210 m_CommTimeouts.WriteTotalTimeoutMultiplier = WriteTotalTimeoutMultiplier * 1000;
211 m_CommTimeouts.WriteTotalTimeoutConstant = WriteTotalTimeoutConstant * 1000;
212
213 // configure
214 if (SetCommTimeouts(m_hComm, &m_CommTimeouts))
215 {
216 if (SetCommMask(m_hComm, dwCommEvents))
217 {
218 if (GetCommState(m_hComm, &m_dcb))
219 {
220 m_dcb.EvtChar = ‘q‘;
221 m_dcb.fRtsControl = RTS_CONTROL_ENABLE; // set RTS bit high!
222 m_dcb.BaudRate = baud; // add by mrlong
223 m_dcb.Parity = myparity;
224 m_dcb.ByteSize = databits;
225 m_dcb.StopBits = mystop;
226
227 if (BuildCommDCB(szBaud, &m_dcb))
228 {
229 if (SetCommState(m_hComm, &m_dcb))
230 ; // normal operation... continue
231 else
232 ProcessErrorMessage("SetCommState()");
233 }
234 else
235 ProcessErrorMessage("BuildCommDCB()");
236 }
237 else
238 ProcessErrorMessage("GetCommState()");
239 }
240 else
241 ProcessErrorMessage("SetCommMask()");
242 }
243 else
244 ProcessErrorMessage("SetCommTimeouts()");
245
246 delete [] szPort;
247 delete [] szBaud;
248
249 // flush the port
250 PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
251
252 // release critical section
253 LeaveCriticalSection(&m_csCommunicationSync);
254
255 TRACE("Initialisation for communicationport %d completed.\nUse Startmonitor to communicate.\n", portnr);
256
257 return TRUE;
258 }
259
260 //
261 // The CommThread Function.
262 //
263 UINT CSerialPort::CommThread(LPVOID pParam)
264 {
265 // Cast the void pointer passed to the thread back to
266 // a pointer of CSerialPort class
267 CSerialPort *port = (CSerialPort*)pParam;
268
269 // Set the status variable in the dialog class to
270 // TRUE to indicate the thread is running.
271 port->m_bThreadAlive = TRUE;
272
273 // Misc. variables
274 DWORD BytesTransfered = 0;
275 DWORD Event = 0;
276 DWORD CommEvent = 0;
277 DWORD dwError = 0;
278 COMSTAT comstat;
279 BOOL bResult = TRUE;
280 // Clear comm buffers at startup
281 if (port->m_hComm) // check if the port is opened
282 PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
283
284 // begin forever loop. This loop will run as long as the thread is alive.
285 for (;;)
286 {
287
288 // Make a call to WaitCommEvent(). This call will return immediatly
289 // because our port was created as an async port (FILE_FLAG_OVERLAPPED
290 // and an m_OverlappedStructerlapped structure specified). This call will cause the
291 // m_OverlappedStructerlapped element m_OverlappedStruct.hEvent, which is part of the m_hEventArray to
292 // be placed in a non-signeled state if there are no bytes available to be read,
293 // or to a signeled state if there are bytes available. If this event handle
294 // is set to the non-signeled state, it will be set to signeled when a
295 // character arrives at the port.
296
297 // we do this for each port!
298
299 bResult = WaitCommEvent(port->m_hComm, &Event, &port->m_ov);
300
301 if (!bResult)
302 {
303 // If WaitCommEvent() returns FALSE, process the last error to determin
304 // the reason..
305 switch (dwError = GetLastError())
306 {
307 case ERROR_IO_PENDING:
308 {
309 // This is a normal return value if there are no bytes
310 // to read at the port.
311 // Do nothing and continue
312 break;
313 }
314 case 87:
315 {
316 // Under Windows NT, this value is returned for some reason.
317 // I have not investigated why, but it is also a valid reply
318 // Also do nothing and continue.
319 break;
320 }
321 default:
322 {
323 // All other error codes indicate a serious error has
324 // occured. Process this error.
325 port->ProcessErrorMessage("WaitCommEvent()");
326 break;
327 }
328 }
329 }
330 else
331 {
332 // If WaitCommEvent() returns TRUE, check to be sure there are
333 // actually bytes in the buffer to read.
334 //
335 // If you are reading more than one byte at a time from the buffer
336 // (which this program does not do) you will have the situation occur
337 // where the first byte to arrive will cause the WaitForMultipleObjects()
338 // function to stop waiting. The WaitForMultipleObjects() function
339 // resets the event handle in m_OverlappedStruct.hEvent to the non-signelead state
340 // as it returns.
341 //
342 // If in the time between the reset of this event and the call to
343 // ReadFile() more bytes arrive, the m_OverlappedStruct.hEvent handle will be set again
344 // to the signeled state. When the call to ReadFile() occurs, it will
345 // read all of the bytes from the buffer, and the program will
346 // loop back around to WaitCommEvent().
347 //
348 // At this point you will be in the situation where m_OverlappedStruct.hEvent is set,
349 // but there are no bytes available to read. If you proceed and call
350 // ReadFile(), it will return immediatly due to the async port setup, but
351 // GetOverlappedResults() will not return until the next character arrives.
352 //
353 // It is not desirable for the GetOverlappedResults() function to be in
354 // this state. The thread shutdown event (event 0) and the WriteFile()
355 // event (Event2) will not work if the thread is blocked by GetOverlappedResults().
356 //
357 // The solution to this is to check the buffer with a call to ClearCommError().
358 // This call will reset the event handle, and if there are no bytes to read
359 // we can loop back through WaitCommEvent() again, then proceed.
360 // If there are really bytes to read, do nothing and proceed.
361
362 bResult = ClearCommError(port->m_hComm, &dwError, &comstat);
363
364 if (comstat.cbInQue == 0)
365 continue;
366 } // end if bResult
367
368 // Main wait function. This function will normally block the thread
369 // until one of nine events occur that require action.
370 Event = WaitForMultipleObjects(3, port->m_hEventArray, FALSE, INFINITE);
371
372 switch (Event)
373 {
374 case 0:
375 {
376 // Shutdown event. This is event zero so it will be
377 // the higest priority and be serviced first.
378
379 port->m_bThreadAlive = FALSE;
380
381 // Kill this thread. break is not needed, but makes me feel better.
382 AfxEndThread(100);
383 break;
384 }
385 case 1: // read event
386 {
387 GetCommMask(port->m_hComm, &CommEvent);
388 memset(&comstat, 0, sizeof(COMSTAT));
389 if (CommEvent & EV_RXCHAR) //接收到字符，并置于输入缓冲区中
390 ReceiveChar(port, comstat);
391
392 if (CommEvent & EV_CTS) //CTS信号状态发生变化
393 ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_CTS_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
394 if (CommEvent & EV_RXFLAG) //接收到事件字符，并置于输入缓冲区中
395 ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RXFLAG_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
396 if (CommEvent & EV_BREAK) //输入中发生中断
397 ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_BREAK_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
398 if (CommEvent & EV_ERR) //发生线路状态错误，线路状态错误包括CE_FRAME,CE_OVERRUN和CE_RXPARITY
399 ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_ERR_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
400 if (CommEvent & EV_RING) //检测到振铃指示
401 ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RING_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
402
403 break;
404 }
405 case 2: // write event
406 {
407 // Write character event from port
408 WriteChar(port);
409 break;
410 }
411
412 } // end switch
413
414 } // close forever loop
415
416 return 0;
417 }
418 //
419 // start comm watching
420 //
421 BOOL CSerialPort::StartMonitoring()
422 {
423 if (!(m_Thread = AfxBeginThread(CommThread, this)))
424 return FALSE;
425 TRACE("Thread started\n");
426 return TRUE;
427 }
428 //
429 // Restart the comm thread
430 //
431 BOOL CSerialPort::RestartMonitoring()
432 {
433 TRACE("Thread resumed\n");
434 m_Thread->ResumeThread();
435 return TRUE;
436 }
437
438
439 //
440 // Suspend the comm thread
441 //
442 BOOL CSerialPort::StopMonitoring()
443 {
444 TRACE("Thread suspended\n");
445 m_Thread->SuspendThread();
446 return TRUE;
447 }
448
449
450 //
451 // If there is a error, give the right message
452 //
453 void CSerialPort::ProcessErrorMessage(char* ErrorText)
454 {
455 char *Temp = new char[200];
456
457 LPVOID lpMsgBuf;
458
459 FormatMessage(
460 FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
461 NULL,
462 GetLastError(),
463 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
464 (LPTSTR) &lpMsgBuf,
465 0,
466 NULL
467 );
468
469 sprintf(Temp, "WARNING: %s Failed with the following error: \n%s\nPort: %d\n", (char*)ErrorText, lpMsgBuf, m_nPortNr);
470 MessageBox(NULL, Temp, "Application Error", MB_ICONSTOP);
471
472 LocalFree(lpMsgBuf);
473 delete[] Temp;
474 }
475
476 //
477 // Write a character.
478 //
479 void CSerialPort::WriteChar(CSerialPort* port)
480 {
481 BOOL bWrite = TRUE;
482 BOOL bResult = TRUE;
483
484 DWORD BytesSent = 0;
485 DWORD SendLen = port->m_nWriteSize;
486 ResetEvent(port->m_hWriteEvent);
487
488
489 // Gain ownership of the critical section
490 EnterCriticalSection(&port->m_csCommunicationSync);
491
492 if (bWrite)
493 {
494 // Initailize variables
495 port->m_ov.Offset = 0;
496 port->m_ov.OffsetHigh = 0;
497
498 // Clear buffer
499 PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
500
501 bResult = WriteFile(port->m_hComm, // Handle to COMM Port
502 port->m_szWriteBuffer, // Pointer to message buffer in calling finction
503 SendLen, // add by mrlong
504 //strlen((char*)port->m_szWriteBuffer), // Length of message to send
505 &BytesSent, // Where to store the number of bytes sent
506 &port->m_ov); // Overlapped structure
507
508 // deal with any error codes
509 if (!bResult)
510 {
511 DWORD dwError = GetLastError();
512 switch (dwError)
513 {
514 case ERROR_IO_PENDING:
515 {
516 // continue to GetOverlappedResults()
517 BytesSent = 0;
518 bWrite = FALSE;
519 break;
520 }
521 default:
522 {
523 // all other error codes
524 port->ProcessErrorMessage("WriteFile()");
525 }
526 }
527 }
528 else
529 {
530 LeaveCriticalSection(&port->m_csCommunicationSync);
531 }
532 } // end if(bWrite)
533
534 if (!bWrite)
535 {
536 bWrite = TRUE;
537
538 bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port
539 &port->m_ov, // Overlapped structure
540 &BytesSent, // Stores number of bytes sent
541 TRUE); // Wait flag
542
543 LeaveCriticalSection(&port->m_csCommunicationSync);
544
545 // deal with the error code
546 if (!bResult)
547 {
548 port->ProcessErrorMessage("GetOverlappedResults() in WriteFile()");
549 }
550 } // end if (!bWrite)
551
552 // Verify that the data size send equals what we tried to send
553 if (BytesSent != SendLen /*strlen((char*)port->m_szWriteBuffer)*/) // add by
554 {
555 TRACE("WARNING: WriteFile() error.. Bytes Sent: %d; Message Length: %d\n", BytesSent, strlen((char*)port->m_szWriteBuffer));
556 }
557 }
558
559 //
560 // Character received. Inform the owner
561 //
562 void CSerialPort::ReceiveChar(CSerialPort* port, COMSTAT comstat)
563 {
564 BOOL bRead = TRUE;
565 BOOL bResult = TRUE;
566 DWORD dwError = 0;
567 DWORD BytesRead = 0;
568 unsigned char RXBuff;
569
570 for (;;)
571 {
572 //add by liquanhai 防止死锁
573 if(WaitForSingleObject(port->m_hShutdownEvent,0)==WAIT_OBJECT_0)
574 return;
575
576 // Gain ownership of the comm port critical section.
577 // This process guarantees no other part of this program
578 // is using the port object.
579
580 EnterCriticalSection(&port->m_csCommunicationSync);
581
582 // ClearCommError() will update the COMSTAT structure and
583 // clear any other errors.
584
585 bResult = ClearCommError(port->m_hComm, &dwError, &comstat);
586
587 LeaveCriticalSection(&port->m_csCommunicationSync);
588
589 if (comstat.cbInQue == 0)
590 {
591 // break out when all bytes have been read
592 break;
593 }
594
595 EnterCriticalSection(&port->m_csCommunicationSync);
596
597 if (bRead)
598 {
599 bResult = ReadFile(port->m_hComm, // Handle to COMM port
600 &RXBuff, // RX Buffer Pointer
601 1, // Read one byte
602 &BytesRead, // Stores number of bytes read
603 &port->m_ov); // pointer to the m_ov structure
604 // deal with the error code
605 if (!bResult)
606 {
607 switch (dwError = GetLastError())
608 {
609 case ERROR_IO_PENDING:
610 {
611 // asynchronous i/o is still in progress
612 // Proceed on to GetOverlappedResults();
613 bRead = FALSE;
614 break;
615 }
616 default:
617 {
618 // Another error has occured. Process this error.
619 port->ProcessErrorMessage("ReadFile()");
620 break;
621 }
622 }
623 }
624 else
625 {
626 // ReadFile() returned complete. It is not necessary to call GetOverlappedResults()
627 bRead = TRUE;
628 }
629 } // close if (bRead)
630
631 if (!bRead)
632 {
633 bRead = TRUE;
634 bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port
635 &port->m_ov, // Overlapped structure
636 &BytesRead, // Stores number of bytes read
637 TRUE); // Wait flag
638
639 // deal with the error code
640 if (!bResult)
641 {
642 port->ProcessErrorMessage("GetOverlappedResults() in ReadFile()");
643 }
644 } // close if (!bRead)
645
646 LeaveCriticalSection(&port->m_csCommunicationSync);
647
648 // notify parent that a byte was received
649 ::SendMessage((port->m_pOwner)->m_hWnd, WM_COMM_RXCHAR, (WPARAM) RXBuff, (LPARAM) port->m_nPortNr);
650 } // end forever loop
651
652 }
653
654 //
655 // Write a string to the port
656 //
657 void CSerialPort::WriteToPort(char* string)
658 {
659 assert(m_hComm != 0);
660
661 memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
662 strcpy(m_szWriteBuffer, string);
663 m_nWriteSize=strlen(string); // add by mrlong
664 // set event for write
665 SetEvent(m_hWriteEvent);
666 }
667
668 //
669 // Return the device control block
670 //
671 DCB CSerialPort::GetDCB()
672 {
673 return m_dcb;
674 }
675
676 //
677 // Return the communication event masks
678 //
679 DWORD CSerialPort::GetCommEvents()
680 {
681 return m_dwCommEvents;
682 }
683
684 //
685 // Return the output buffer size
686 //
687 DWORD CSerialPort::GetWriteBufferSize()
688 {
689 return m_nWriteBufferSize;
690 }
691
692 void CSerialPort::ClosePort()
693 {
694 MSG message;
695 do
696 {
697 SetEvent(m_hShutdownEvent);
698 if(::PeekMessage(&message,m_pOwner->m_hWnd,0,0,PM_REMOVE))
699 {
700 ::TranslateMessage(&message);
701 ::DispatchMessage(&message);
702 }
703
704 } while (m_bThreadAlive);
705
706 // if the port is still opened: close it
707 if (m_hComm != NULL)
708 {
709 CloseHandle(m_hComm);
710 m_hComm = NULL;
711 }
712
713 // Close Handles
714 if(m_hShutdownEvent!=NULL)
715 ResetEvent(m_hShutdownEvent);
716 if(m_ov.hEvent!=NULL)
717 ResetEvent(m_ov.hEvent);
718 if(m_hWriteEvent!=NULL)
719 ResetEvent(m_hWriteEvent);
720
721 //delete [] m_szWriteBuffer;
722
723 }
724
725 void CSerialPort::WriteToPort(char* string,int n)
726 {
727 assert(m_hComm != 0);
728 memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
729 memcpy(m_szWriteBuffer, string, n);
730 m_nWriteSize = n;
731
732 // set event for write
733 SetEvent(m_hWriteEvent);
734 }
735
736 void CSerialPort::WriteToPort(LPCTSTR string)
737 {
738 assert(m_hComm != 0);
739 memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
740 strcpy(m_szWriteBuffer, string);
741 m_nWriteSize=strlen(string);
742 // set event for write
743 SetEvent(m_hWriteEvent);
744 }
745
746 void CSerialPort::WriteToPort(BYTE* Buffer, int n)
747 {
748 assert(m_hComm != 0);
749 memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));//清零
750 int i;
751 for(i=0; i<n; i++)
752 {
753 m_szWriteBuffer[i] = Buffer[i];//读缓存
754 }
755 m_nWriteSize=n;
756
757 // set event for write
758 SetEvent(m_hWriteEvent);//SetEvent/ResetEvent分别将EVENT置为这两种状态分别是发信号与不发信号
759 }
760
761
762 void CSerialPort::SendData(LPCTSTR lpszData, const int nLength)
763 {
764 assert(m_hComm != 0);
765 memset(m_szWriteBuffer, 0, nLength);
766 strcpy(m_szWriteBuffer, lpszData);
767 m_nWriteSize=nLength;
768 // set event for write
769 SetEvent(m_hWriteEvent);
770 }
771
772 BOOL CSerialPort::RecvData(LPTSTR lpszData, const int nSize)
773 {
774 //
775 //接收数据
776 //
777 assert(m_hComm!=0);
778 memset(lpszData,0,nSize);
779 DWORD mylen = 0;
780 DWORD mylen2 = 0;
781 while (mylen<nSize) {
782 if(!ReadFile(m_hComm,lpszData,nSize,&mylen2,NULL))
783 return FALSE;
784 mylen += mylen2;
785
786
787 }
788
789 return TRUE;
790 }
原文地址：https://www.cnblogs.com/tianqiang/p/9988459.html
时间： 2024-11-09 00:13:24