#ifndef SERIALCOM_H_INCLUDED
#define SERIALCOM_H_INCLUDED
#include <iostream>
#include <windows.h>
#include <stdio.h>
#include <stdarg.h>
//#include "stdafx.h"



const int QUEUE_SIZE=512 ;

class SERIAL
{ public:
  HANDLE hComPort ;
  HWND hDbg ;
  const char* error ;
  COMMTIMEOUTS orgTimeouts ;
  unsigned char rxbuffer[1024] ;
  DWORD rxlen,rxpos ;

  void debug(const char* txt)
  {
      if(hDbg)std::cout<<txt<<std::endl; //SetWindowText(hDbg,txt) ;
  }

  public:

  //-------------------KONSTRUCTOR-------------------------------
    SERIAL(LPCSTR lpszDevice,int speed,HWND hWnd)
    {
        error=0 ; rxlen=0 ; rxpos=0 ; hDbg=hWnd ;
  try
    {
      COMMTIMEOUTS timeouts;
	  DCB          comDCB;      /* COM-Port Control-Settings   */
	  DWORD dwCommEvents;
	  hComPort= CreateFile(lpszDevice, GENERIC_READ | GENERIC_WRITE,
						   0, 0, OPEN_EXISTING, 0, 0);
	  /* In this application the serial port is used in
	   * nonoverlapped mode!
	   */
	  if (hComPort == INVALID_HANDLE_VALUE) throw "CreateFile" ;


	  if (SetupComm(hComPort, QUEUE_SIZE, QUEUE_SIZE) == 0) throw "SetupComm" ;

	  /* Save original timeout values: */
	  GetCommTimeouts(hComPort, &orgTimeouts);
	  /* Set Windows timeout values (disable build-in timeouts): */
	  timeouts.ReadIntervalTimeout= 0;
	  timeouts.ReadTotalTimeoutMultiplier= 0;
	  timeouts.ReadTotalTimeoutConstant= 0;
	  timeouts.WriteTotalTimeoutMultiplier= 0;
	  timeouts.WriteTotalTimeoutConstant= 0;
	  if (!SetCommTimeouts(hComPort, &timeouts)) throw "SetCommTimeouts" ;

	  dwCommEvents= EV_RXCHAR | EV_TXEMPTY | EV_RXFLAG | EV_ERR;
	  SetCommMask(hComPort, dwCommEvents);


	  /* Get state and modify it: */
	  if (!GetCommState(hComPort, &comDCB)) throw "GetCommState" ;

	  comDCB.BaudRate    = speed ; // variable speed here
	  comDCB.ByteSize    = 8 ;
	  comDCB.Parity      = NOPARITY ;
	  comDCB.StopBits    = ONESTOPBIT ;
	  comDCB.fBinary     = TRUE ;	/* Enable Binary Transmission */
	  comDCB.fParity     = FALSE ;	/* Enable Parity Check        */
	  comDCB.ErrorChar   = (char)0xff ;
	  comDCB.fRtsControl = RTS_CONTROL_DISABLE ; /* For power supply */
	  comDCB.fDtrControl = DTR_CONTROL_DISABLE ; /* For power supply */
	  comDCB.fOutxCtsFlow= FALSE ;
	  comDCB.fOutxDsrFlow= FALSE ;
	  comDCB.fOutX       = FALSE ;
	  comDCB.fInX        = FALSE ;
	  comDCB.fNull       = FALSE ;
	  comDCB.fErrorChar  = FALSE ;

	  if (!SetCommState(hComPort, &comDCB)) throw "SetCommState" ;

	  /* Clear buffers: */
	  PurgeComm(hComPort, PURGE_TXCLEAR | PURGE_TXABORT);
	  PurgeComm(hComPort, PURGE_RXCLEAR | PURGE_RXABORT);
      debug(lpszDevice);
      debug("Port created.\n") ;
	}
  catch(const char* err)
    { error=err ;
      if(hComPort!=INVALID_HANDLE_VALUE)
        {
            CloseHandle(hComPort) ;
            hComPort=INVALID_HANDLE_VALUE ;
        }
    }
}




//--------------DESTRUCTOR-------------------------------

    ~SERIAL()
    {
        if(hComPort!=INVALID_HANDLE_VALUE)
        {
            PurgeComm(hComPort, PURGE_TXCLEAR | PURGE_TXABORT) ;
            PurgeComm(hComPort, PURGE_RXCLEAR | PURGE_RXABORT) ;
            SetCommTimeouts(hComPort, &orgTimeouts) ;
            CloseHandle(hComPort) ;
        }
    }



    bool ok()
    {
        return hComPort!=INVALID_HANDLE_VALUE ;
    }

    const char* what_error()
    {
        return error ;
    }





   //---------------------WRITE----------------------------

    void tx(unsigned char ch)
    {
        debug("txin") ;
        DWORD dwWrite ;
        WriteFile(hComPort,&ch,1,&dwWrite,NULL) ;
        debug("txout") ;
    }





    //-----------------------READ--------------------------

    int rx(int timeout)
    {
    if(rxpos>=rxlen)
    {
        debug("rxin") ;
        int rxCount=0,startTime=GetTickCount() ;

        for(bool wait=true;wait;)
	    { DWORD errors=0 ;
          COMSTAT comState ;    /* COM-Port Status-Information */
		  ClearCommError(hComPort, &errors, &comState) ;
		  debug("checking") ;
          rxCount=comState.cbInQue ; /* dirty time consuming section */
          if(rxCount>0 || timeout==0 || (int)GetTickCount()-startTime>=timeout) wait=false ;
        }
      if(rxCount>=1024) rxCount=1024 ;
      if(rxCount>0)
        { rxpos=0 ; rxlen=0 ;
		  debug("reading") ;
		  bool ok=(ReadFile(hComPort,rxbuffer,rxCount,&rxlen, NULL)==TRUE) ;
          if(!ok || rxlen==0) throw "ReadFile failed" ;
        }
	  debug("rxout") ;
    }
  return (rxpos<rxlen) ? rxbuffer[rxpos++] : -1 ;
}

} ;













#endif // SERIALCOM_H_INCLUDED