Simple Serial Communication

CBarCodeReader m_BarCodeReader; 
// CBarCodeReader is a direct descendant of CSerialPort 
// You can use CSerialPort directly.
UINT m_Timer; //The timer value

m_Timer = SetTimer(1, 300 /*Change according to your needs*/, 0);

void CTestDlg::OnTimer(UINT nIDEvent) 
{
  //Check if there is any data in the serial port and save it in the variable 
  //m_BarCode (Cstring) that represent an edit box in the dialog. 
  if ( m_BarCodeReader.Read(m_BarCode) > 0 ) 
  {
    UpdateData(FALSE); //If something was read update the UI
    MessageBeep(MB_ICONASTERISK); //Sound a beep.
  }
  CDialog::OnTimer(nIDEvent);
}

void CTestDlg::OnTimer(UINT nIDEvent) 
{
  //m_SerialPort should be defined in your dialog class interface 
  //as CSerialPort m_SerialPort;
  BYTE buffer[255]; //Use any other method more appropriated to create the buffer
  DWORD read; 
  while ( (read = m_SerialPort.Read(buffer, sizeof(buffer))) > 0 ) 
  {
    //Process the buffer data here 
  }
  CDialog::OnTimer(nIDEvent);
}

• You must declare in your dialog a variable of type CSerialPort.
• In the OnInitDialog handler you must initialize the timer.
• Add a WM_TIMER message handler to your dialog and in the OnTimer handler read the serial port data.
• You must open the port in the OnInitDialog handler or any other.

#define WM_DATAREAD (WM_USER + 1)

class CMainFrame : public CFrameWnd
{  
  //Here would be the code already present in the declaration 
  //…
  // You must add the WM_DESTROY message handler using the Class Wizard and 
  // after add manually the line afx_msg LRESULT OnDataRead(WPARAM, LPARAM); 
  // as follows:
protected:
  //{{AFX_MSG(CMainFrame)
  afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
  afx_msg void OnSetFocus(CWnd *pOldWnd);
  afx_msg void OnDestroy();
  afx_msg LRESULT OnDataRead(WPARAM, LPARAM);
  //}}AFX_MSG
  DECLARE_MESSAGE_MAP()
  //Add the followings lines:
private:
  CStringList m_PortDataList; //String list where data read from port will be set
  CCriticalSection m_CriticalSection; //Used to control access to previous list 
                                      //in a thread safe manner.
  CWinThread* m_pReadPortThread; //Worker thread
  CSerialPort m_Port; //Serial port. 
  void StartPooling(); //Start reading the port
  void StopPooling(); //Stop reading the port
  //Previous methods can be used in a start/stop buttons. 
  static UINT ReadPort(LPVOID pParam); //Worker thread procedure
};

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
  //{{AFX_MSG_MAP(CMainFrame)
  ON_WM_CREATE()
  ON_WM_SETFOCUS()
  ON_WM_DESTROY()
  ON_MESSAGE(WM_DATAREAD, OnDataRead)
  //}}AFX_MSG_MAP
END_MESSAGE_MAP()

CMainFrame::CMainFrame()
{
  // TODO: add member initialization code here
  m_pReadPortThread = NULL;
}
void CMainFrame::OnDestroy() 
{
  StopPooling();
  CFrameWnd::OnDestroy();
}

LRESULT CMainFrame::OnDataRead(WPARAM, LPARAM)
{
  CSingleLock slock(&m_CriticalSection);
  slock.Lock();
  if ( slock.IsLocked() )
  { //m_PortDataList can be accessed safetly
    //TODO: Here the code to process all string of m_PortDataList
  }
  else
  { //Error trying to acquire the critical section object
  }
  slock.Unlock();
  return 0;
}
UINT CMainFrame::ReadPort(LPVOID pParam)
{
  CMainFrame* pMainFrame = (CMainFrame*)pParam;
  char buffer[100];
  DWORD read;
  //End thread when the port get closed 
  while( pMainFrame->m_Port.IsOpen() )
  {
    if ( (read = pMainFrame->m_Port.Read(buffer, sizeof(buffer)-1)) > 0 )
    {
      buffer[read] = 0; //zero end the string
      CString str(buffer); //Convert the read buffer to string. 
                           //I asume that ASCII data was read.
  
      //Use the critical section to use the string array in 
      //the CMainFrame class
      CSingleLock slock(&pMainFrame->m_CriticalSection);
      slock.Lock();
      if ( slock.IsLocked() )
      { //Add read data to list as string
        pMainFrame->m_PortDataList.AddTail(str);
      }
      else
      { //Error trying to acquire the critical section object
      }
      slock.Unlock();
      //Check is the port is still opned
      if ( pMainFrame->m_Port.IsOpen() )
      { //Notify to window that data was arrived
        ::PostMessage(pMainFrame->GetSafeHwnd(), WM_DATAREAD, 0, 0);
      }
    }
  }
  return 0;
}
void CMainFrame::StartPooling()
{
  StopPooling();
  //TODO: Check open result and set correct parameters. 
  m_Port.Open(_T("COM1:"), 9600, 8, NOPARITY, ONESTOPBIT, GENERIC_READ);
  //Create the worker thread
  CWinThread* m_pReadPortThread = AfxBeginThread( ReadPort, 
                                                 (LPVOID)this, 
                                                 THREAD_PRIORITY_NORMAL, 
                                                 0, CREATE_SUSPENDED);
  m_pReadPortThread->m_bAutoDelete = FALSE; //Manual thread deletion
  m_pReadPortThread->ResumeThread();
}
void CMainFrame::StopPooling()
{
  m_Port.Close(); //Close the serial port and the worked thread will end
  if (m_pReadPortThread != NULL)
  {
    //Wait for worker thread termination (maximun 3 secconds)
    if ( WaitForSingleObject(m_pReadPortThread->m_hThread, 3000) != WAIT_OBJECT_0)
    { //Timeout or error. 
      m_pReadPortThread->SuspendThread();
    }
    delete m_pReadPortThread;
    m_pReadPortThread = NULL;
  }
}

class CMainFrame : public CFrameWnd
{
  //…Omitted code
private:
  Tserial_event m_Port;
  
  void StartPooling(); //Start reading the port
  void StopPooling(); //Stop reading the port
}

void SerialEventManager(uint32 object, uint32 event)
{
  char *buffer;
  int size;
  Tserial_event *com;
  com = (Tserial_event *) object;
  if (com!=0)
  {
    switch(event)
    {
      //..Ignore other events 
      case SERIAL_DATA_ARRIVAL :
        size = com->getDataInSize();
        buffer = com->getDataInBuffer();
        //Process here the data read (buffer) 
        //You must take care of not using MFC functions and classes here
        //because Tserial_event don’t use AfxBeginThread.
        //Change the implementation to use AfxBeginThread if you need
        //to use MFC here.
        com->dataHasBeenRead();
        break;
    }
  }
}
CMainFrame::CMainFrame()
{
  // TODO: add member initialization code here
  m_Port.setManager(SerialEventManager);
}
void CMainFrame::OnDestroy() 
{
  StopPooling();
  CFrameWnd::OnDestroy();
}
void CMainFrame::StartPooling()
{
  m_Port. connect("COM1", 19200, SERIAL_PARITY_NONE, 8, true);
} 
void CMainFrame::StopPooling()
{
  m_Port.disconnect();
}