sprint/io/serial.h

Go to the documentation of this file.

#ifndef _SPRINT_SERIAL_H
#define _SPRINT_SERIAL_H


#define OUTPUTDEBUGSTRING(a) 

#ifdef WIN32
# include <windows.h>
#endif

#include <vector>
#include <string>

namespace sprint {

namespace io {
/*
For instance, if one thread were waiting for a ReadFile function to return, any other thread that issued a WriteFile function would be blocked. 
*/
          
#ifdef WIN32

BOOL Win32_Serial_Write(HANDLE hComm, const char * lpBuf, DWORD dwToWrite);
DWORD Win32_Serial_Read(HANDLE hComm, char *buffer, DWORD buffer_lenght);
#endif
          

class serial {
        LPCOMMPROP lpCommProp;

public:
        HANDLE hComm;

public:
        serial();

        serial(LPCTSTR lpszComName);
        
        ~serial();

        bool open(LPCTSTR lpszInput, bool read, bool write, bool async);
    
        LPCOMMPROP GetProp();

        bool good() const {
                        return hComm!=INVALID_HANDLE_VALUE;
        }

        static bool IsAvaiable(LPCTSTR lpszCommName);
        static BOOL Configure(HWND hWnd, LPCTSTR lpszComName);
        static bool Test(LPCTSTR lpszCommName, LPTSTR lpszMsgBuffer);
        static BOOL TestDCB(LPCTSTR lpszCommName, DCB *test);
        static void DCBString(LPSTR lpszBuffer, UINT uBufferLen, DCB *test);
        
        // static bool ComboBox_EnumPort(HWND hCombo);

        inline void SetTimeouts(COMMTIMEOUTS *pcto)
        {
                SetCommTimeouts(hComm, pcto);
        }

        inline BOOL SetState(DCB *dcb)
        {
                return SetCommState(hComm, dcb);
        }

        inline BOOL GetState(DCB *dcb) const
        {
                return GetCommState(hComm, dcb);
        }

        bool SetBaudRate(int rate)
        {
                DCB dcb;
                memset(&dcb, 0, sizeof(DCB));

                dcb.DCBlength = sizeof(DCB);
                if(::GetCommState(hComm, &dcb) == FALSE)
            return false;

                dcb.BaudRate = rate;


                return ::SetCommState(hComm, &dcb) == TRUE;
        }
        
    bool SetParity(int parity)
     {
         
     }

        bool SetFlowControl(int mode)
        {
                DCB dcb;
                memset(&dcb, 0, sizeof(DCB));

                dcb.DCBlength = sizeof(DCB);
                if(::GetCommState(hComm, &dcb) == FALSE)
            return false;

       dcb.fOutxCtsFlow = FALSE; // No CTS output flow control 
       dcb.fOutxDsrFlow = FALSE; // No DSR output flow control 
       dcb.fTXContinueOnXoff = TRUE; // XOFF continues Tx 
       dcb.fDtrControl = DTR_CONTROL_ENABLE; // DTR flow control type 
       dcb.fDsrSensitivity = FALSE; // DSR sensitivity 
       dcb.fOutX = FALSE;  // No XON/XOFF out flow control
       dcb.fInX = FALSE;   // No XON/XOFF in flow control
       dcb.fRtsControl = RTS_CONTROL_ENABLE; // RTS flow control: RTS active

                if(mode == 0)
                {
  /*
        dcb.fDtrControl = DTR_CONTROL_DISABLE; // DTR flow control type 
        dcb.fRtsControl = RTS_CONTROL_DISABLE; // RTS flow control
  */
        
//        dcb.c_iflag &= ~(IXOFF | IXON);
        }
        else
                if(mode == 1)
                {
                dcb.fOutX = TRUE;
                dcb.fInX = TRUE;
//        dcb.c_iflag |= IXOFF | IXON;
//        dcb.c_cflag |= CRTSCTS;
        }
        else
                if(mode == 2)
                {
                dcb.fOutxCtsFlow = TRUE;
                dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
//        dcb.c_iflag |= IXOFF | IXON;
//        dcb.c_cflag |= CRTSCTS;
        }


                return ::SetCommState(hComm, &dcb) == TRUE;
        }

        inline BOOL EscapeFunction(DWORD dwFunc)
        {
                return EscapeCommFunction(hComm, dwFunc);
        }

        inline BOOL GetModemStatus(LPDWORD lpModemStat)
        {
                return GetCommModemStatus(hComm, lpModemStat);
        }

        inline void close()
                {
                CloseHandle(hComm);
                hComm = INVALID_HANDLE_VALUE;
                }

  BOOL Read(char *buffer, UINT uBufferSize, LPDWORD lpdwNumberOfBytesRead, LPDWORD lpdwStatus);
  BOOL Write(const char *buffer, UINT uBufferSize, LPDWORD lpdwNumberOfBytesWritten, LPDWORD lpdwStatus);

  int read(char *buf, int size)
  {
    DWORD dwSize;
    BOOL ret = Read(buf, size, &dwSize, NULL);
    return (ret) ? (int) dwSize : -1;
  }
  
  int get()
  {
    DWORD dwSize;
    char buf;
    do {
    BOOL ret = Read(&buf, 1, &dwSize, NULL);
    if(!ret)
        return -1;
    } while(dwSize == 0);
    
    return buf;
  }
  
  int write(const char *buf, int size)
  {
    DWORD dwSize;
    BOOL ret = Write(buf, size, &dwSize, NULL);
    return (ret) ? dwSize : -1;
  }

};

} // io

} // sprint

#endif