Slow walking man

 $GPGGA,142243.731,3739.0081,N,12704.0193,E,0,00,,,M,,,,0000*05

DWORD CSerialz::ReadData(BYTE *pBuff, DWORD nToRead)
{
 DWORD dwRead;
 DWORD dwError;

 //COMSTAT은 현재 읽기, 쓰기 버퍼등 통신에 관련된 상태를 담는 구조체
 DWORD dwErrorFlags;
 COMSTAT comstat;

//장치를 사용 할 수 있도록 오류플래그를 받아오고 오류 상태를 해제한다.

//그리고 장치 상태를 얻어온다.
ClearCommError(m_hIDComDev, &dwErrorFlags, &comstat);
 
 // 읽기버퍼에 들어와있지만 아직 읽지 못하고 남아있는 바이트 수
 dwRead = comstat.cbInQue;

//읽기 버퍼에 아직 읽지 못하고 남아있는 바이트가 남아 있는 경우
 if(dwRead > 0)
 {
    //읽기 버퍼를 nToRead만큼 읽어 들여온다. 그리고 읽기 성공한 바이트 수를 

    //dwRead에 다시 저장 비동기 함수라 바로 FALSE 반환
    if(!ReadFile(m_hIDComDev, pBuff, nToRead, &dwRead, &m_OverlappedRead))
   {
       //정상적으로 읽기 작업이 작업 큐에 저장
       if(GetLastError() == ERROR_IO_PENDING)
      { 
          // timeouts에 정해준 시간만큼 기다려준다.

          //COMMTIMEOUTS에 읽기는 기다리지 않도록 설정한 상태
          while (! GetOverlappedResult(m_hIDComDev,

                                                    &m_OverlappedRead,

                                                    &dwRead,

                                                    TRUE))
          {
               //읽을 때까지 기다렸는데 미리 설정한 타임아웃 이내에 읽지 못한 경우 
               dwError = GetLastError();
               if (dwError != ERROR_IO_INCOMPLETE)
               {

                   //장치의 에러 상태를 해제한다.
                   ClearCommError(m_hIDComDev, &dwErrorFlags, &comstat);
                   break;

                }
           }
       }

       //작업큐에 읽기 작업이 정상적으로 저장되지 못한 경우
       else
       {
            dwRead = 0;

             //에러상태를 해제한다.
            ClearCommError(m_hIDComDev, &dwErrorFlags, &comstat);
        }
     }
 }

 //실제로 읽은 바이트 수 반환
 return(dwRead); 
} 

//COM 포트에서 이벤트가 일어나는지 감시하는 스레드 함수 DWORD CSerialz::THWatchEvPort(CSerialz *pComm)
{
   DWORD  dwEvent;
   OVERLAPPED os;
   BOOL  bOk = TRUE;  
   BYTE  buff[4096]; 
   DWORD  dwBufferCounter;   

   // Overap Structure 설정
   memset(&os, 0, sizeof(OVERLAPPED));
   if(!(os.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL))) bOk = FALSE;

   // m_hIDComDev COM 포트의 읽기 버퍼에 데이터가 들어왔을 때 발생하는

   //이벤트및 몇가지 에러 상황을 감지하도록 설정
   if(! SetCommMask(pComm->m_hIDComDev, 

                             EV_RXCHAR  |  EV_BREAK  |  EV_ERR )) bOk = FALSE;

   // OVERLAPPED 구조체 설정및 COM포트의 감지 이벤트 설정 중에 문제가

   //발생했으면 return FALSE
   if(!bOk) { 

      AfxMessageBox(_T("Error while Receive Waiting") + pComm->szPort); 

      return FALSE; 

   }

   // port가 열려 있는 동안.....포트가 PortClose에 의해 닫히면 m_bPortOnOff

   // 가 FALSE가 되어 종료.
   while(pComm->m_bPortOnOff)  
   {         
      dwEvent = 0;
    
       //이미 이벤트가 발생해 있는 상태라면 TRUE 반환, 이벤트 미발생 상태로

       //펜딩되면 FALSE 반환. OVERLAPPED의 이벤트는 함수 호출시 자동 RESET   
       BOOL result = WaitCommEvent(pComm->m_hIDComDev, &dwEvent, &os);  
  
       //WaitCommEvent함수 호출시 이벤트 발생된 상태로 바로 이벤트 감지
       if(result)
       {
          //DoNothing
        }
        else
       {
           //WaitCommEvent가 PENDING된 경우
           if(GetLastError() == ERROR_IO_PENDING)
          {

              //이벤트가 발생하면 다음단계로 진행
              WaitForSingleObject(os.hEvent,INFINITE);
           }  

          //에러로 인한 이벤트 발생시 스레드 종료
          else
          {
                break;
           }
      }     

      //발생 이벤트가 읽기 버퍼에 데이터 수신으로 인한 이벤트인 경우
      if((dwEvent & EV_RXCHAR) == EV_RXCHAR)
      {   // 포트에서 읽을 수 있는 만큼 읽는다.
          do

          {

                //읽기 버퍼에서 4096 (전체 버퍼 싸이즈) 만큼 읽어 들여와서 읽기

                //성공한 바이트 수를 dwBufferConter에 저장한다.
                dwBufferCounter = pComm->ReadData(buff, 4096);    // 데이터 읽기. 
                pComm->FrmTHRcvData(buff, (BYTE)dwBufferCounter);  //data 사용   
           }while (dwBufferCounter); // 읽을 수 있는 data가 없을 때까지 읽어온다.   
       }
       else
      {
          //에러 상황으로 인해 이벤트가 발생한 경우는 그냥 이 스레드를 종료시킴
          break;
       }
    }

 //OVERLAPPED 구조체의 이벤트 핸들을 닫고 스레드 포인터를 NULL로 한다.
 CloseHandle(os.hEvent);
 pComm->m_ThrdEvPort = NULL;

 return(TRUE);
}

 BOOL WINAPI WriteFile(
  __in         HANDLE hFile,
  __in         LPCVOID lpBuffer,
  __in         DWORD nNumberOfBytesToWrite,
  __out_opt    LPDWORD lpNumberOfBytesWritten,
  __inout_opt  LPOVERLAPPED lpOverlapped
);

BOOL CSerialz::WriteCommByte(unsigned char ucByte)
{
 BOOL bWriteStat;
 DWORD dwBytesWritten;

//1바이트를 쓰고 다 쓰면 m_OverlappedWirte.hEvent를 set시킨다. 

bWriteStat = WriteFile(m_hIDComDev,

                              (LPSTR) &ucByte,

                              1,

                              &dwBytesWritten,

                              &m_OverlappedWrite);  

//overlapped write는 FALSE를 바로 반환하고 LASTERROR가 ERROR_IO_PENDING

if(!bWriteStat && (GetLastError() == ERROR_IO_PENDING))
{
      if(WaitForSingleObject(m_OverlappedWrite.hEvent, 1000))
          dwBytesWritten = 0;
      else
     {
          GetOverlappedResult(m_hIDComDev,

                                        &m_OverlappedWrite,

                                        &dwBytesWritten,

                                        FALSE);

           //사실 이 부분은 잘못된 예이다. 시리얼 통신을 비롯한 모든

           //통신 디바이스 에서는 overlapped.offset이 0으로 설정되어야 한다. 빼도좋다.
           m_OverlappedWrite.Offset += dwBytesWritten;   

      }
 }

//의미있는 반환값을 가지려면 쓰기성공한 바이트 수가 0 이상인지 체크해야 한다.

 return(TRUE);
} 

 BOOL WINAPI GetOverlappedResult(
  _In_   HANDLE hFile,
  _In_   LPOVERLAPPED lpOverlapped,
  _Out_  LPDWORD lpNumberOfBytesTransferred,
  _In_   BOOL bWait
);

1. bWait == TRUE  && OVERLAPPED.internal == STATUS_PENDING

   bWait가 TRUE인 경우에 미리 COMMTIMEOUTS에 설정한 타임아웃 값

   만큼 기다린다. 기다리는 도중 완료되면 TRUE 반환 TIMEOUT되면 FALSE 반환

   GetLastError() 함수는 ERROR_IO_INCOMPLETE 반환

2. bWait == FALSE : && OVERLAPPED.internal == STATUS_PENDING

   bWait가 FALSE인 경우에 완료되길 기다리지 않고 바로 쓰기한 바이트를 넣고 반환된다.

   아직 쓰기작업이 끝나지 않았다면 FALSE를 반환하고 GetLastError() 함수는

   ERROR_IO_INCOMPLETE 반환

// 버퍼로부터 설정된 데이터를 사이즈만큼 쓴다.

int CSerialz::SendData(char *buffer, int size) 

{

    // port가 제대로 설정되어 있지 않을 때 - 쓰기 실패
    if(!m_bPortOnOff || m_hIDComDev == NULL) return(0); 

    DWORD dwBytesWritten = 0;

    for(int i=0; i<size; i++)
    {  

        // 여러 바이트를 쓰기 위하여 한 바이트씩 쓰는 함수를 중복 호출
        WriteCommByte(buffer[i]); // 쓰기 위한 함수 호출

        //요부분에 writeCommByte의 TRUE FALSE를 분간하는 코드가 있음좋다.
        dwBytesWritten++;
    }

    return((int)dwBytesWritten);  // 쓰기에 성공한 바이트 수 리턴
}