开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 驱动编程 > 查看源码
Tserial_event.cpp
资源名称：rs232application.rar　[点击查看]
上传用户：shoubosun
上传日期：2015-09-13
资源大小：1801k
文件大小：29k
源码类别：

驱动编程

开发平台：

Visual C++

Tserial_event.cpp：源码内容
  4. /* ------------------------------------------------------------------------ --
  5. --                                                                          --
  6. --                        PC serial port connection object                  --
  7. --                           for  event-driven programs                     --
  8. --                                                                          --
  9. --                                                                          --
  10. m                         --
  11. --                                                                          --
  12. --                                                                          --
  13. --                                                                          --
  14. -- ------------------------------------------------------------------------ --
  15. --                                                                          --
  16. --  Filename : Tserial_event.cpp                                            --
  17. --  Author   : Wang Bin                                            --
  18. --  Created  : 3rd Aug 2007                                           --
  19. --  Modified :                                             --
  20. --  Plateform: Windows 95, 98, NT, 2000 (Win32)                             --
  21. -- ------------------------------------------------------------------------ --
  23. -- ------------------------------------------------------------------------ --
  24. --                                                                          --
  25. --    Note to Visual C++ users:  Don't forget to compile with the           --
  26. --     "Multithreaded" option in your project settings                      --
  27. --                                                                          --
  28. --         See   Project settings                                           --
  29. --                   |                                                      --
  30. --                   *--- C/C++                                             --
  31. --                          |                                               --
  32. --                          *--- Code generation                            --
  33. --                                       |                                  --
  34. --                                       *---- Use run-time library         --
  35. --                                                     |                    --
  36. --                                                     *---- Multithreaded  --
  37. --                                                                          --
  38. --                                                                          --
  39. --                                                                          --
  40. -- ------------------------------------------------------------------------ */
  45. /* ---------------------------------------------------------------------- */
  47. #define STRICT
  48. #include <stdio.h>
  49. #include <stdlib.h>
  50. #include <string.h>
  51. #include <process.h>
  52. #include <conio.h>
  53. #include <windows.h>
  56. #include "Tserial_event.h"
  58. #define SIG_POWER_DOWN     0
  59. #define SIG_READER         1
  60. #define SIG_READ_DONE      2    // data received has been read
  61. #define SIG_WRITER         3
  62. #define SIG_DATA_TO_TX     4    // data waiting to be sent
  63. #define SIG_MODEM_EVENTS   5
  64. #define SIG_MODEM_CHECKED  6
  66. void Tserial_event_thread_start(void *arg);
  68. typedef unsigned (WINAPI *PBEGINTHREADEX_THREADFUNC) (LPVOID lpThreadParameter);
  69. typedef unsigned *PBEGINTHREADEX_THREADID;
  71. /* ---------------------------------------------------------------------- */
  72. /* ---------------------  Tserial_event_thread_start  ------------------- */
  73. /* ---------------------------------------------------------------------- */
  74. /**
  75.     This function is not part of the Tserial_event object. It is simply used
  76.     to start the thread from an external point of the object.
  77. */
  78. void Tserial_event_thread_start(void *arg)
  79. {
  80.     class Tserial_event *serial_unit;
  82.     serial_unit = (Tserial_event *) arg;
  83.     
  84.     if (serial_unit!=0)
  85.         serial_unit->run();
  86. }
  88. /* -------------------------------------------------------------------- */
  89. /* -------------------------    Tserial_event ------------------------- */
  90. /* -------------------------------------------------------------------- */
  91. Tserial_event::Tserial_event()
  92. {
  93.     int i;
  95.     ready            = false;
  96.     parityMode       = SERIAL_PARITY_NONE;
  97.     port[0]          = 0;
  98.     rate             = 0;
  99.     threadid         = 0;
  100.     serial_handle    = INVALID_HANDLE_VALUE;
  101.     tx_in_progress   = 0;
  102.     rx_in_progress   = 0;
  103.     max_rx_size      = 1;
  104.     tx_size          = 0;
  105.     received_size    = 0;
  106.     check_modem      = false;
  108.     manager          = 0;
  110.     /* -------------------------------------------------------------- */
  111.     // creating Events for the different sources
  112.     for (i=0; i<SERIAL_SIGNAL_NBR; i++)
  113.     {
  114.         if ((i==SIG_READER) || (i==SIG_WRITER) || (i==SIG_MODEM_EVENTS))
  115.             serial_events[i] = CreateEvent(NULL, TRUE, FALSE, NULL);  // Manual Reset
  116.         else
  117.             serial_events[i] = CreateEvent(NULL, FALSE, FALSE, NULL); // Auto reset
  118.     }
  119. }
  121. /* -------------------------------------------------------------------- */
  122. /* --------------------------    ~Tserial_event ----------------------- */
  123. /* -------------------------------------------------------------------- */
  124. Tserial_event::~Tserial_event()
  125. {
  126.     int i;
  128.     /* -------------------------------------------------------- */
  129.     for (i=0; i<SERIAL_SIGNAL_NBR; i++)         // deleting the events
  130.     {
  131.         if (serial_events[i]!=INVALID_HANDLE_VALUE)
  132.             CloseHandle(serial_events[i]);
  133.         serial_events[i] = INVALID_HANDLE_VALUE;
  134.     }
  136.     if (serial_handle!=INVALID_HANDLE_VALUE)
  137.         CloseHandle(serial_handle);
  138.     serial_handle = INVALID_HANDLE_VALUE;
  139. }
  140. /* -------------------------------------------------------------------- */
  141. /* --------------------------    disconnect   ------------------------- */
  142. /* -------------------------------------------------------------------- */
  143. void Tserial_event::disconnect(void)
  144. {
  145.     ready = false;
  146.     SetEvent(serial_events[SIG_POWER_DOWN]);
  147. }
  148. /* -------------------------------------------------------------------- */
  149. /* --------------------------    connect      ------------------------- */
  150. /* -------------------------------------------------------------------- */
  151. /**
  152.      Serial port, file and overlapped structures initialization
  153. */
  154. int  Tserial_event::connect (char *port_arg, int  rate_arg,  int parity_arg,
  155.                              char ByteSize , bool modem_events)
  156. {
  157.     int  erreur;
  158.     DCB  dcb;
  159.     int  i;
  160.     COMMTIMEOUTS cto = { 0, 0, 0, 0, 0 };
  162.     /* --------------------------------------------- */
  163.     if (serial_handle!=INVALID_HANDLE_VALUE)
  164.         CloseHandle(serial_handle);
  165.     serial_handle = INVALID_HANDLE_VALUE;
  167.     if (port_arg!=0)
  168.     {
  169.         strncpy(port, port_arg, 10);
  170.         rate        = rate_arg;
  171.         parityMode  = parity_arg;
  172.         check_modem = modem_events;
  174.         erreur      = 0;
  175.         ZeroMemory(&ovReader   ,sizeof(ovReader)   );  // clearing the overlapped
  176.         ZeroMemory(&ovWriter   ,sizeof(ovWriter)   );
  177.         ZeroMemory(&ovWaitEvent,sizeof(ovWaitEvent));
  178.         memset(&dcb,0,sizeof(dcb));
  180.         /* -------------------------------------------------------------------- */
  181.         // set DCB to configure the serial port
  182.         dcb.DCBlength       = sizeof(dcb);                   
  183.         
  184.         /* ---------- Serial Port Config ------- */
  185.         dcb.BaudRate        = rate;
  187.         switch(parityMode)
  188.         {
  189.             case SERIAL_PARITY_NONE:
  190.                             dcb.Parity      = NOPARITY;
  191.                             dcb.fParity     = 0;
  192.                             break;
  193.             case SERIAL_PARITY_EVEN:
  194.                             dcb.Parity      = EVENPARITY;
  195.                             dcb.fParity     = 1;
  196.                             break;
  197.             case SERIAL_PARITY_ODD:
  198.                             dcb.Parity      = ODDPARITY;
  199.                             dcb.fParity     = 1;
  200.                             break;
  201.         }
  204.         dcb.StopBits        = ONESTOPBIT;
  205.         dcb.ByteSize        = (BYTE) ByteSize;
  207.         dcb.fOutxCtsFlow    = 0;
  208.         dcb.fOutxDsrFlow    = 0;
  209.         dcb.fDtrControl     = DTR_CONTROL_DISABLE;
  210.         dcb.fDsrSensitivity = 0;
  211.         dcb.fRtsControl     = RTS_CONTROL_DISABLE;
  212.         dcb.fOutX           = 0;
  213.         dcb.fInX            = 0;
  214.         
  215.         /* ----------------- misc parameters ----- */
  216.         dcb.fErrorChar      = 0;
  217.         dcb.fBinary         = 1;
  218.         dcb.fNull           = 0;
  219.         dcb.fAbortOnError   = 0;
  220.         dcb.wReserved       = 0;
  221.         dcb.XonLim          = 2;
  222.         dcb.XoffLim         = 4;
  223.         dcb.XonChar         = 0x13;
  224.         dcb.XoffChar        = 0x19;
  225.         dcb.EvtChar         = 0;
  226.         
  227.         /* -------------------------------------------------------------------- */
  228.         serial_handle    = CreateFile(port, GENERIC_READ | GENERIC_WRITE,
  229.                    0, NULL, OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);
  230.                    // opening serial port
  232.         ovReader.hEvent    = serial_events[SIG_READER];
  233.         ovWriter.hEvent    = serial_events[SIG_WRITER];
  234.         ovWaitEvent.hEvent = serial_events[SIG_MODEM_EVENTS];
  236.         if (serial_handle    != INVALID_HANDLE_VALUE)
  237.         {
  238.             if (check_modem)
  239.             {
  240.                 if(!SetCommMask(serial_handle, EV_RING | EV_RLSD))
  241.                     erreur = 1;
  242.             }
  243.             else
  244.             {
  245.                 if(!SetCommMask(serial_handle, 0))
  246.                     erreur = 1;
  247.             }
  249.                 
  250.             // set timeouts
  251.             if(!SetCommTimeouts(serial_handle,&cto))
  252.                 erreur = 2;
  254.             // set DCB
  255.             if(!SetCommState(serial_handle,&dcb))
  256.                 erreur = 4;
  257.         }
  258.         else
  259.             erreur = 8;
  260.     }
  261.     else
  262.         erreur = 16;
  265.     /* --------------------------------------------- */
  266.     for (i=0; i<SERIAL_SIGNAL_NBR; i++)
  267.     {
  268.         if (serial_events[i]==INVALID_HANDLE_VALUE)
  269.             erreur = 32;
  270.     }
  272.     /* --------------------------------------------- */
  273.     if (erreur!=0)
  274.     {
  275.         CloseHandle(serial_handle);
  276.         serial_handle = INVALID_HANDLE_VALUE;
  277.     }
  278.     else
  279.     {
  280.         // start thread
  281.         _beginthreadex(NULL,0,(PBEGINTHREADEX_THREADFUNC) Tserial_event_thread_start,
  282.                   (void *) this, 0, &threadid);
  283.     }
  285.     /* --------------------------------------------- */
  286.     return(erreur);
  287. }
  288. /* -------------------------------------------------------------------- */
  289. /* ---------------------           setManager     --------------------- */
  290. /* -------------------------------------------------------------------- */
  291. void         Tserial_event::setManager(type_myCallBack manager_arg)
  292. {
  293.         manager = manager_arg;
  294. }
  295. /* -------------------------------------------------------------------- */
  296. /* ---------------------           setRxSize      --------------------- */
  297. /* -------------------------------------------------------------------- */
  298. void         Tserial_event::setRxSize(int size)
  299. {
  300.         max_rx_size = size;
  301.         if (max_rx_size>SERIAL_MAX_RX)
  302.             max_rx_size = SERIAL_MAX_RX;
  303. }
  304. /* -------------------------------------------------------------------- */
  305. /* ---------------------           setManager     --------------------- */
  306. /* -------------------------------------------------------------------- */
  307. char *      Tserial_event::getDataInBuffer(void)
  308. {
  309.     return(rxBuffer);
  310. }
  311. /* -------------------------------------------------------------------- */
  312. /* ---------------------           setManager     --------------------- */
  313. /* -------------------------------------------------------------------- */
  314. int      Tserial_event::getDataInSize(void)
  315. {
  316.     return(received_size);
  317. }
  318. /* -------------------------------------------------------------------- */
  319. /* ---------------------           setManager     --------------------- */
  320. /* -------------------------------------------------------------------- */
  321. void   Tserial_event::dataHasBeenRead(void)
  322. {
  323.     SetEvent(serial_events[SIG_READ_DONE]);
  324. }
  325. /* -------------------------------------------------------------------- */
  326. /* -----------------------   getNbrOfBytes  --------------------------- */
  327. /* -------------------------------------------------------------------- */
  328. int Tserial_event::getNbrOfBytes    (void)
  329. {
  330.     struct _COMSTAT status;
  331.     int             n;
  332.     unsigned long   etat;
  334.     n = 0;
  336.     if (serial_handle!=INVALID_HANDLE_VALUE)
  337.     {
  338.         ClearCommError(serial_handle, &etat, &status);
  339.         n = status.cbInQue;
  340.     }
  341.     return(n);
  342. }
  343. /* -------------------------------------------------------------------- */
  344. /* --------------------------    sendData     ------------------------- */
  345. /* -------------------------------------------------------------------- */
  346. void Tserial_event::sendData (char *buffer, int size)
  347. {
  348.     if ((!tx_in_progress) && (size<SERIAL_MAX_TX) && (buffer!=0))
  349.     {
  350.         tx_in_progress = 1;
  351.         memcpy(txBuffer, buffer, size);
  352.         tx_size = size;
  353.         SetEvent(serial_events[SIG_DATA_TO_TX]);
  354.         // indicating data to be sent
  355.     }
  356. }
  357. /* -------------------------------------------------------------------- */
  358. /* --------------------------    OnEvent      ------------------------- */
  359. /* -------------------------------------------------------------------- */
  360. void Tserial_event::OnEvent (unsigned long events)
  361. {
  362.     unsigned long ModemStat;
  364.     GetCommModemStatus(serial_handle, &ModemStat);
  366.     if ((events & EV_RING)!=0)
  367.     {
  368.         if ((ModemStat &  MS_RING_ON)!= 0)
  369.         {
  370.             if (manager!=0)
  371.                 manager((uint32) this, SERIAL_RING);
  372.         }
  373.     }
  375.     if ((events & EV_RLSD)!=0)
  376.     {
  377.         if ((ModemStat &  MS_RLSD_ON)!= 0)
  378.         {
  379.             if (manager!=0)
  380.                 manager((uint32) this, SERIAL_CD_ON);
  381.         }
  382.         else
  383.         {
  384.             if (manager!=0)
  385.                 manager((uint32) this, SERIAL_CD_OFF);
  386.         }
  387.     }
  388. }
  389. /* -------------------------------------------------------------------- */
  390. /* --------------------------       run       ------------------------- */
  391. /* -------------------------------------------------------------------- */
  393. /**
  394.  this function is the main loop of the Tserial object. There is a
  395.  do while() loop executed until either an error or a PowerDown is 
  396.  received.
  397.  this is not a busy wait since we use the WaitForMultipleObject function
  398. */
  400. /* * /
  401. #define DEBUG_EVENTS
  402. /* */
  404. void Tserial_event::run(void)
  405. {
  406.     bool          done;
  407.     long          status;
  408.     unsigned long read_nbr, result_nbr;
  409.     char          success;
  411.     ready                   = true;
  412.     done                    = false;
  413.     tx_in_progress          = 0;
  414.     rx_in_progress          = 0;
  415.     WaitCommEventInProgress = 0;
  417.     if (manager!=0)
  418.         manager((uint32) this, SERIAL_CONNECTED);
  420.     GetLastError();               // just to clear any pending error
  421.     SetEvent(serial_events[SIG_READ_DONE]);
  422.     if (check_modem)
  423.         SetEvent(serial_events[SIG_MODEM_CHECKED]);
  425.     /* ----------------------------------------------------------- */
  426.     while(!done)
  427.     {
  428.         /* ------------------------------------------------------------------ */
  429.         /*                                                                    */
  430.         /*                                                                    */
  431.         /*                                                                    */
  432.         /*                          Waiting  for signals                      */
  433.         /*                                                                    */
  434.         /*                                                                    */
  435.         /*                                                                    */
  436.         /* ------------------------------------------------------------------ */
  437.         // Main wait function. Waiting for something to happen.
  438.         // This may be either the completion of a Read or a Write or
  439.         // the reception of modem events, Power Down, new Tx
  440.         //
  441.         status = WaitForMultipleObjects(SERIAL_SIGNAL_NBR, serial_events,
  442.                                         FALSE, INFINITE);
  444.         // processing answer to filter other failures
  445.         status = status - WAIT_OBJECT_0;
  446.         if ((status<0) || (status>=SERIAL_SIGNAL_NBR))
  447.             done=true;   // error
  448.         else
  449.         {
  450.             /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
  451.             /* ++++++++++++++++++++ EVENT DISPATCHER ++++++++++++++++++ */
  452.             /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
  453.             switch(status)
  454.             {
  455.                 /* ######################################################## */
  456.                 case SIG_POWER_DOWN:
  457.                     // receiving a POWER down signal. Stopping the thread
  458.                     done = true;
  459.                     break;
  460.                 /* ######################################################## */
  461.                 /* #                                                      # */
  462.                 /* #                                                      # */
  463.                 /* #                       RX                             # */
  464.                 /* #                                                      # */
  465.                 /* #                                                      # */
  466.                 /* ######################################################## */
  467.                 case SIG_READ_DONE:
  468.                     // previous reading is finished
  469.                     // I start a new one here
  470.                     if (!rx_in_progress)
  471.                     {
  472.                         // locking reading
  473.                         rx_in_progress = 1;
  474.                         // starting a new read
  475.                         success = (char) ReadFile(serial_handle,&rxBuffer,
  476.                                          max_rx_size,&read_nbr,&ovReader);
  477.                         if (!success)
  478.                         {
  479.                             // failure
  480.                             if(GetLastError() != ERROR_IO_PENDING )
  481.                             {
  482.                                 // real failure => quiting
  483.                                 done = true;
  484.                                 #ifdef DEBUG_EVENTS
  485.                                 printf("Readfile error (not pending)n");
  486.                                 #endif DEBUG_EVENTS
  487.                             }
  488.                             #ifdef DEBUG_EVENTS
  489.                             else
  490.                                 printf("ReadFile pendingn");
  491.                             #endif DEBUG_EVENTS
  492.                         }
  493.                         #ifdef DEBUG_EVENTS
  494.                         else
  495.                         {
  496.                             // I make nothing here since the overlapped
  497.                             // will be signaled anyway, so I'll make
  498.                             // the processing there
  499.                             printf("ReadFile immediate successn");
  500.                         }
  501.                         #endif
  502.                     }
  503.                     break;
  504.                 /* ######################################################## */
  505.                 case SIG_READER:
  506.                     // reading the result of the terminated read
  507.                     //BOOL GetOverlappedResult(
  508.                     //    HANDLE hFile, // handle of file, pipe, or communications device
  509.                     //    LPOVERLAPPED lpOverlapped, // address of overlapped structure
  510.                     //    LPDWORD lpNumberOfBytesTransferred, // address of actual bytes count
  511.                     //    BOOL bWait  // wait flag
  512.                     //   );
  513.                     //
  514.                     if (GetOverlappedResult(serial_handle, &ovReader,
  515.                         &result_nbr, FALSE))
  516.                     {
  517.                         #ifdef DEBUG_EVENTS
  518.                             printf("ReadFile => GetOverlappedResult donen");
  519.                         #endif DEBUG_EVENTS
  520.                         // no error => OK
  521.                         // Read operation completed successfully
  522.                         ResetEvent(serial_events[SIG_READER]);
  523.                         // Write operation completed successfully
  524.                         received_size  = result_nbr;
  525.                         rx_in_progress = 0; // read has ended
  526.                         // if incoming data, I process them
  527.                         if ((result_nbr!=0) &&(manager!=0))
  528.                             manager((uint32) this, SERIAL_DATA_ARRIVAL);
  529.                         // I automatically restart a new read once the
  530.                         // previous is completed.
  531.                         SetEvent(serial_events[SIG_READ_DONE]);
  533.                     }
  534.                     else
  535.                     {
  536.                         // GetOverlapped didn't succeed !
  537.                         // What's the reason ?
  538.                         if(GetLastError()!= ERROR_IO_PENDING )
  539.                             done = 1;  // failure
  540.                     }
  541.                     break;
  542.                 /* ######################################################## */
  543.                 /* #                                                      # */
  544.                 /* #                                                      # */
  545.                 /* #                       TX                             # */
  546.                 /* #                                                      # */
  547.                 /* #                                                      # */
  548.                 /* ######################################################## */
  549.                 case SIG_DATA_TO_TX:
  550.                     // Signal asserted that there is a new valid message
  551.                     // in the "txBuffer" variable
  552.                     // sending data to the port
  553.                     success = (char) WriteFile(serial_handle, txBuffer, tx_size,
  554.                                         &result_nbr, &ovWriter);
  555.                         if (!success)
  556.                         {
  557.                             // ouups, failure
  558.                             if(GetLastError() != ERROR_IO_PENDING )
  559.                             {
  560.                                 // real failure => quiting
  561.                                 done = true;
  562.                                 #ifdef DEBUG_EVENTS
  563.                                 printf("WriteFile error (not pending)n");
  564.                                 #endif DEBUG_EVENTS
  565.                             }
  566.                             #ifdef DEBUG_EVENTS
  567.                             else
  568.                                 printf("WriteFile pendingn");
  569.                             #endif DEBUG_EVENTS
  570.                         }
  571.                         #ifdef DEBUG_EVENTS
  572.                         else
  573.                         {
  574.                             // I make nothing here since the overlapped
  575.                             // will be signaled anyway, so I'll make
  576.                             // the processing there
  577.                             printf("WriteFile immediate successn");
  578.                         }
  579.                         #endif
  580.                     break;
  581.                 /* ######################################################## */
  582.                 case SIG_WRITER:
  583.                     // WriteFile has terminated
  584.                     // checking the result of the operation
  585.                     if (GetOverlappedResult(serial_handle, &ovWriter,
  586.                         &result_nbr, FALSE))
  587.                     {
  588.                         // Write operation completed successfully
  589.                         ResetEvent(serial_events[SIG_WRITER]);
  590.                         // further write are now allowed
  591.                         tx_in_progress = 0;
  592.                         // telling it to the manager
  593.                         if (manager!=0)
  594.                             manager((uint32) this, SERIAL_DATA_SENT);
  595.                     }
  596.                     else
  597.                     {
  598.                         // GetOverlapped didn't succeed !
  599.                         // What's the reason ?
  600.                         if(GetLastError() != ERROR_IO_PENDING )
  601.                             done = 1;  // failure
  602.                     }
  603.                     break;
  604.                 /* ######################################################## */
  605.                 /* #                                                      # */
  606.                 /* #                                                      # */
  607.                 /* #                    MODEM_EVENTS EVENTS                      # */
  608.                 /* #                                                      # */
  609.                 /* #                                                      # */
  610.                 /* ######################################################## */
  611.                 case SIG_MODEM_CHECKED:
  612.                     if ((!WaitCommEventInProgress) && check_modem)
  613.                     // if no wait is in progress I start a new one
  614.                     {            
  615.                         WaitCommEventInProgress=1;
  616.                         success = (char) WaitCommEvent(serial_handle,&dwCommEvent,
  617.                                                        &ovWaitEvent);
  618.                         // reading one byte only to have immediate answer on each byte
  619.                         if (!success)
  620.                         {
  621.                             // ouups, failure
  622.                             if(GetLastError() != ERROR_IO_PENDING )
  623.                             {
  624.                                 // real failure => quiting
  625.                                 done = true;
  626.                                 #ifdef DEBUG_EVENTS
  627.                                 printf("WaitCommEvent error (not pending)n");
  628.                                 #endif DEBUG_EVENTS
  629.                             }
  630.                             #ifdef DEBUG_EVENTS
  631.                             else
  632.                                 printf("WaitCommEvent pendingn");
  633.                             #endif DEBUG_EVENTS
  634.                         }
  635.                         #ifdef DEBUG_EVENTS
  636.                         else
  637.                         {
  638.                             // I make nothing here since the overlapped
  639.                             // will be signaled anyway, so I'll make
  640.                             // the processing there
  641.                             printf("WaitCommEvent immediate successn");
  642.                         }
  643.                         #endif
  644.                     }
  645.                     break;
  646.                 /* ######################################################## */
  647.                 case SIG_MODEM_EVENTS:
  648.                     // reading the result of the terminated wait
  649.                     if (GetOverlappedResult(serial_handle, &ovWaitEvent,
  650.                         &result_nbr, FALSE))
  651.                     {
  652.                         // Wait operation completed successfully
  653.                         ResetEvent(serial_events[SIG_MODEM_EVENTS]);
  654.                         WaitCommEventInProgress = 0;
  655.                         // if incoming data, I process them
  656.                         OnEvent(dwCommEvent);
  657.                         // automatically starting a new check
  658.                         SetEvent(serial_events[SIG_MODEM_CHECKED]);
  659.                     }
  660.                     else
  661.                     {
  662.                         // GetOverlapped didn't succeed !
  663.                         // What's the reason ?
  664.                         if(GetLastError() != ERROR_IO_PENDING )
  665.                             done = 1;  // failure
  666.                     }
  667.                     break;
  668.                 /* ######################################################## */
  669.             }
  670.             /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
  671.             /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
  672.             /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
  673.         }
  674.     };
  676.     // --------------------- Disconnecting ----------------
  677.     ready = false;
  678.     if (serial_handle!=INVALID_HANDLE_VALUE)
  679.         CloseHandle(serial_handle);
  680.     serial_handle = INVALID_HANDLE_VALUE;
  682.     if (manager!=0)
  683.         manager((uint32) this, SERIAL_DISCONNECTED);
  684. }
  685. /* -------------------------------------------------------------------- */
  686. /* -------------------------------------------------------------------- */