serial.cpp

#ifndef WIN32
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <fcntl.h>
#include <cstdlib>
#include <cstdio>
#include <unistd.h>
#include <termios.h>
#include <string.h>
//#include <QDebug>
#else
# include <cstdlib>
# include <cstdio>
#endif

//#include "logger.h"
#include "serial.h"

/**************************** TYPES ******************************************/

// #define RADIO_DEVICE "/dev/ttyS0"
namespace HAL
{
#ifndef WIN32
  const speed_t baud_rates[][2] =
  {
    {      B0,      0 },
    {     B50,     50 },
    {     B75,     75 },
    {    B110,    110 },
    {    B134,    134 },
    {    B150,    150 },
    {    B200,    200 },
    {    B300,    300 },
    {    B600,    600 },
    {   B1200,   1200 },
    {   B1800,   1800 },
    {   B2400,   2400 },
    {   B4800,   4800 },
    {   B9600,   9600 },
    {  B19200,  19200 },
    {  B38400,  38400 },
    {  B57600,  57600 },
    { B115200, 115200 },
    { B230400, 230400 },
    { B460800, 460800 }
  };

  /**************************** CODE *******************************************/


  /*
   * baud_rate_to_flag -
   *
   * convert from raw baud rate to the
   * appropriate baud flag
   */
  speed_t baud_rate_to_flag(unsigned int speed)
  {
    int i;

    for (i = 0; i < 20; i++)
    {
      if (baud_rates[i][1] == speed)
        return(baud_rates[i][0]);
    }
    return 0;
  }


  /*
   * baud_flag_to_rate -
   *
   * This function converts from the speed s to
   * the baud flag
   */
  int baud_flag_to_rate(speed_t s)
  {
    int i;

    for(i = 0; i < 20; i++)
    {
      if (baud_rates[i][0] == s)
        return(baud_rates[i][1]);
    }
    return 0;
  }

#endif
  /**************************** SERIAL CLASS ***********************************/


  /*
   * open -
   *
   * This function opens the serial port device and configures it
   * to operate at the specified baud rate and parameters
   *
   * Retrun Value: TRUE on success, FALSE on failure
   */
  bool Serial::Open(const std::string& device, int baud)
  {
    #ifdef WIN32
        DCB dcb;
        hCom = CreateFile( device.c_str(), GENERIC_READ | GENERIC_WRITE, 0, // exclusive access                           NULL, // no security attributes
                           OPEN_EXISTING, 0, NULL);

        if (hCom == INVALID_HANDLE_VALUE)
        {
          err("ERROR: Can't open com port %s", device.c_str());
          return false;
        }

        if (!GetCommState(hCom, &dcb))
        {
          err("ERROR: Can't get CommState.\n");
          Close();
          return false;
        }

        switch (baud)
        {
          case 9600:
            dcb.BaudRate = CBR_9600;
            break;

          case 19200:
            dcb.BaudRate = CBR_19200;
            break;

          case 110:
            dcb.BaudRate = CBR_110;
            break;

          case 300:
            dcb.BaudRate = CBR_300;
            break;

          case 38400:
            dcb.BaudRate = CBR_38400;
            break;

          case 600:
            dcb.BaudRate = CBR_600;
            break;

          case 56000:
            dcb.BaudRate = CBR_56000;
            break;

          case 1200:
            dcb.BaudRate = CBR_1200;
            break;

          case 57600:
            dcb.BaudRate = CBR_57600;
            break;

          case 2400:
            dcb.BaudRate = CBR_2400;
            break;

          case 115200:
            dcb.BaudRate = CBR_115200;
            break;

          case 4800:
            dcb.BaudRate = CBR_4800;
            break;

          case 128000:
            dcb.BaudRate = CBR_128000;
            break;

          case 256000:
            dcb.BaudRate = CBR_256000;
            break;

          case 14400:
            dcb.BaudRate = CBR_14400;
            break;

          default:
            fprintf(stderr, "ERROR: Baut rate currently not supported.\n");
            Close();
            return false;
        }

        dcb.ByteSize = 8;
        dcb.fParity = FALSE;
        dcb.fDsrSensitivity = FALSE;
        dcb.fDtrControl = DTR_CONTROL_DISABLE;
        dcb.fOutxCtsFlow = FALSE;
        dcb.fOutxDsrFlow = FALSE;
        dcb.fOutX = FALSE;
        dcb.fInX = FALSE;
        dcb.fRtsControl = RTS_CONTROL_DISABLE;
        dcb.Parity = NOPARITY;
        dcb.StopBits = ONESTOPBIT;

        if(!SetCommState(hCom, &dcb))
        {
          fprintf(stderr, "ERROR: Can't set CommState.\n");
          Close();
          return false;
        }

        return true;
    #else
        struct termios tio;
        speed_t bf;
        int baud_in, baud_out;

        // open device
        fd = ::open(device.c_str(), O_RDWR | O_SYNC);

        if (fd < 0)
          return(false);

        /* set control attributes -
         * binary I/O, no flow control
         */
        tcgetattr(fd, &tio);
        cfmakeraw(&tio);
        tio.c_cflag &= ~(CRTSCTS | IXON | IXOFF);

        // set serial port speed
        bf = baud_rate_to_flag(baud);
        cfsetispeed(&tio, bf);
        cfsetospeed(&tio, bf);
        tcsetattr(fd, TCSANOW, &tio);

        // test what actually got set
        memset(&tio, 0, sizeof(tio));
        tcgetattr(fd, &tio);
        baud_in  = baud_flag_to_rate(cfgetispeed(&tio));
        baud_out = baud_flag_to_rate(cfgetospeed(&tio));
    //    tcflush(fd, TCIOFLUSH);
        return((baud_in == baud) && (baud_out == baud));
    #endif
  }


  /*
   * close -
   *
   * this function closes the serial port module
   */
  void Serial::Close(void)
  {
    #ifdef WIN32

        if(!CloseHandle(hCom))
          fprintf(stderr, "ERROR: Can't close comm port.\n");

        hCom = INVALID_HANDLE_VALUE;
    #else

        if(fd)
        {
          ::close(fd);
          fd = 0;
        }

    #endif
  }

  /*
   * Read -
   *
   * function reads bytes from the serial port
   */
  #ifdef WIN32
    int Serial::Read(void *buf, int size)
    {
      DWORD bytesTransfered;

      if(!ReadFile(hCom, (char*)buf, size, &bytesTransfered, NULL))
      {
        err("ERROR: Can't read from comm port.");
      }

      return bytesTransfered;
    }
  #endif

  /*
   * Write -
   *
   * Function writes bytes to the serial port
   */
  #ifdef WIN32
    int Serial::Write(void *buf, int size)
    {
      DWORD bytesTransfered;

      if(!WriteFile(hCom, (char*)buf, size, &bytesTransfered, NULL ))
      {
        err(stderr, "Can't write to comm port.");
      }

      return bytesTransfered;
    }
  #endif

  /*
   * Writebyte -
   *
   * Function writes a signel byte to the serial port
   */
  int Serial::WriteByte(char b)
  {
    #ifdef WIN32
        return Write(&b, 1);
    #else
        return (::write(fd, &b, 1));
    #endif
  }

  /*
   * ReadByte -
   *
   * function reads a single byte from the serial port
   */
  int Serial::ReadByte(void)
  {
    #ifdef WIN32
        char b;
        return Read(&b, 1);
        return b;
    #else
        char  data;
        int   ret_val;

        if ((ret_val = ::read(fd, &data, 1)) < 0)
          return (ret_val);

        return (data);
    #endif
  }

  void Serial::WriteGen(void *buffer, int nbyte)
  {
    ::write(fd,buffer,nbyte);
  }

  void Serial::WriteString(std::string s)
  {
      for(int i = 0; i < s.size(); ++i)
      {
          WriteByte(s.at(i));
      }
      WriteByte('\n');
  }

  
} // namespace HAL