SerialPortIO.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

/*
 * SerialPortIO.cpp
 *
 *  Created on: Nov 23, 2010
 *      Author: ischiller
 *
 * see http://www.easysw.com/~mike/serial/serial.html for help on serial port with POSIX termios
 * and
 * http://www.robbayer.com/files/serial-win.pdf
 * or
 * http://www.codeproject.com/KB/system/serial_com.aspx for help on serial port with Windows
 */

#include <iostream>
#include "SerialPortIO.hh"
#include <Base/Debug/Error.hh>
#include <Base/Common/W32Compat.hh>

using namespace BIAS;
using namespace std;

SerialPortIO::SerialPortIO(bool verbose) {
   verbose_ = verbose;
     serialFD_ =0;
     bIsOpen_=false;
}

SerialPortIO::~SerialPortIO() {

}


bool SerialPortIO::
OpenPort(std::string port)
{

#ifdef WIN32
    serialFD_ = CreateFile(port.c_str(),
            GENERIC_READ | GENERIC_WRITE,
            0,
            0,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,
            0);

    if(serialFD_==INVALID_HANDLE_VALUE){
        if(GetLastError()==ERROR_FILE_NOT_FOUND){
            if (verbose_) BIASERR("Port:"<<port<<" does not exist.");
            return false;
        }
        if (verbose_) BIASERR("Could not open port:"<<port);
        return false;
    }
    cout<<"Created port!"<<endl;
    bIsOpen_ = true;

#else ///LINUX
    serialFD_ = open(port.c_str(), O_RDWR | O_NOCTTY | O_NDELAY);
    if (serialFD_ == -1)
    {
        if (verbose_) BIASERR("Could not open port:"<<port);
        return false;
    }
  else{
    cout<<"Created port!"<<endl;
    fcntl(serialFD_, F_SETFL, 0);
    bIsOpen_ = true;
  }
#endif

    return SetOptions();
}

bool SerialPortIO::
ClosePort(){
    if(!bIsOpen_){
    if (verbose_) BIASERR("Serial port was not opened!");
        return false;
    }
#ifdef WIN32
    CloseHandle(serialFD_);
#else
    close(serialFD_);
#endif
    return true;
}

bool SerialPortIO::
SetOptions(unsigned baudrate,SerialPortParityMode parity,
                     bool hardwareFlowControl, bool canonicalInput,
               bool softwareFlowControl, int stopbits ){
    if(!bIsOpen_){
    if (verbose_) BIASERR("Serial port was not opened!");
        return false;
    }
#ifdef WIN32
    DCB dcbSerialParams = {0};
    dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
    if (!GetCommState(serialFD_, &dcbSerialParams)) {
    if (verbose_) BIASERR("Error getting com port state!");
        return false;
    }
    switch(baudrate){
    case 110:
        dcbSerialParams.BaudRate=CBR_110;
        break;
    case 300:
        dcbSerialParams.BaudRate=CBR_300;
        break;
    case 600:
        dcbSerialParams.BaudRate=CBR_600;
        break;
    case 1200:
        dcbSerialParams.BaudRate=CBR_1200;
        break;
    case 2400:
        dcbSerialParams.BaudRate=CBR_2400;
        break;
    case 4800:
        dcbSerialParams.BaudRate=CBR_4800;
        break;
    case 9600:
        dcbSerialParams.BaudRate=CBR_9600;
        break;
    case 19200:
        dcbSerialParams.BaudRate=CBR_19200;
        break;
    case 38400:
        dcbSerialParams.BaudRate=CBR_38400;
        break;
    case 57600:
        dcbSerialParams.BaudRate=CBR_57600;
        break;
    default:
    BIASWARN("Not a valid Baudrate, setting to 9600 instead");
        dcbSerialParams.BaudRate=CBR_9600;
        break;
    }
    //bytesize
    dcbSerialParams.ByteSize=8;
    //stopbit
    dcbSerialParams.StopBits=ONESTOPBIT;
    //parity
    switch(parity){
    case SPPM_SpaceParity:
    case SPPM_NoParity:
        dcbSerialParams.Parity=NOPARITY;
        break;
    case SPPM_EvenParity:
        dcbSerialParams.Parity=EVENPARITY;
        break;
    case SPPM_OddParity:
        dcbSerialParams.Parity=ODDPARITY;
        break;
    default:
        BIASERR("Invalid partity value!");
        return false;
        break;
    }

    if(!SetCommState(serialFD_, &dcbSerialParams)){
        BIASERR("Error setting com port state!");
    }
#else
    struct termios options;
    /* Get the current options for the port...*/
    tcgetattr(serialFD_, &options);
    /* Set the baud rates to ... */
    switch(baudrate){
    case 0:
        cfsetispeed(&options, B0);
        cfsetospeed(&options, B0);
        break;
    case 50:
        cfsetispeed(&options, B50);
        cfsetospeed(&options, B50);
        break;
    case 75:
        cfsetispeed(&options, B75);
        cfsetospeed(&options, B75);
        break;
    case 110:
        cfsetispeed(&options, B110);
        cfsetospeed(&options, B110);
        break;
    case 134:
        cfsetispeed(&options, B134);
        cfsetospeed(&options, B134);
        break;
    case 150:
        cfsetispeed(&options, B150);
        cfsetospeed(&options, B150);
        break;
    case 200:
        cfsetispeed(&options, B200);
        cfsetospeed(&options, B200);
        break;
    case 300:
        cfsetispeed(&options, B300);
        cfsetospeed(&options, B300);
        break;
    case 600:
        cfsetispeed(&options, B600);
        cfsetospeed(&options, B600);
        break;
    case 1200:
        cfsetispeed(&options, B1200);
        cfsetospeed(&options, B1200);
        break;
    case 1800:
        cfsetispeed(&options, B1800);
        cfsetospeed(&options, B1800);
        break;
    case 2400:
        cfsetispeed(&options, B2400);
        cfsetospeed(&options, B2400);
        break;
    case 4800:
        cfsetispeed(&options, B4800);
        cfsetospeed(&options, B4800);
        break;
    case 9600:
        cfsetispeed(&options, B9600);
        cfsetospeed(&options, B9600);
        break;
    case 19200:
        cfsetispeed(&options, B19200);
        cfsetospeed(&options, B19200);
        break;
    case 38400:
        cfsetispeed(&options, B38400);
        cfsetospeed(&options, B38400);
        break;
    case 57600:
        cfsetispeed(&options, B57600);
        cfsetospeed(&options, B57600);
        break;
    default:
        BIASWARN("Not a valid Baudrate, setting to 9600 instead");
        cfsetispeed(&options, B9600);
        cfsetospeed(&options, B9600);
        break;
    }

    /*Enable the receiver and set local mode...*/
    options.c_cflag |= (CLOCAL | CREAD);

    /* set parity */
    switch(parity){
    case SPPM_NoParity:
    case SPPM_SpaceParity:
        options.c_cflag &= ~PARENB;
        options.c_cflag &= ~CSIZE;
        options.c_cflag |= CS8;
        break;
    case SPPM_EvenParity:
        options.c_cflag |= PARENB;
        options.c_cflag &= ~PARODD;
        options.c_cflag &= ~CSIZE;
        options.c_cflag |= CS7;
        break;
    case SPPM_OddParity:
        options.c_cflag |= PARENB;
        options.c_cflag |= PARODD;
        options.c_cflag &= ~CSIZE;
        options.c_cflag |= CS7;
        break;
    default:
        BIASERR("Invalid partity value!");
        return false;
        break;
    }

    switch(stopbits){
    case 1:
    default:
        options.c_cflag &= ~CSTOPB;
    case 2:
        options.c_cflag |= CSTOPB;
    }

    // no parity
    options.c_iflag &= ~(INPCK | ISTRIP);
    options.c_oflag &= ~OPOST; // raw output

    /* set hardware flow control */
    if(hardwareFlowControl)
        options.c_cflag |= CRTSCTS;
    else
        options.c_cflag &= ~CRTSCTS;

    /* set Canonical input (line oriented) */
    if(canonicalInput)
        options.c_lflag |= (ICANON | ECHO | ECHOE);
    else
        options.c_lflag &= ~(ICANON | ECHO | ECHOE  |ISIG);

    /* set software Flow control */
    if(softwareFlowControl)
        options.c_iflag |= (IXON | IXOFF | IXANY);
    else
        options.c_iflag &= ~(IXON | IXOFF | IXANY);

    options.c_cc[VMIN]=0;
    options.c_cc[VTIME]=3; //tenths of seconds

    /* Set the new options for the port...*/
    tcsetattr(serialFD_, TCSANOW, &options);
    tcflush(serialFD_,TCIFLUSH);
#endif

    return true;
}


/**

 */
bool  SerialPortIO::
SetTimeOuts(int ReadIntervalTimeout,
        int ReadTotalTimeoutMultiplier,int ReadTotalTimeoutConstant,
        int WriteTotalTimeoutMultiplier,int WriteTotalTimeoutConstant){
#ifdef WIN32
    COMMTIMEOUTS timeouts;
    timeouts.ReadIntervalTimeout = ReadIntervalTimeout;
    timeouts.ReadTotalTimeoutMultiplier = ReadTotalTimeoutMultiplier;
    timeouts.ReadTotalTimeoutConstant = ReadTotalTimeoutConstant;
    timeouts.WriteTotalTimeoutMultiplier = WriteTotalTimeoutMultiplier;
    timeouts.WriteTotalTimeoutConstant = WriteTotalTimeoutConstant;
    if (!SetCommTimeouts(serialFD_, &timeouts)) // Error setting time-outs.
    {
        BIASERR("Error setting com port state!");
        return false;
    }
#else
    struct termios options;
    /* Get the current options for the port...*/
    tcgetattr(serialFD_, &options);
    options.c_cc[VMIN]=0;
    options.c_cc[VTIME]=ReadIntervalTimeout;
    /* Set the new options for the port...*/
    int ret = tcsetattr(serialFD_, TCSANOW, &options);
    if(ret<0)
    {
        BIASERR("Error setting com port state!");
        return false;
    }
    tcflush(serialFD_,TCIFLUSH);
#endif
    return true;
}

bool SerialPortIO::
ReadString(std::string& message, bool waitForMessage){
    if(!bIsOpen_){
        BIASERR("Serial port was not opened!");
        return false;
    }

    const int length = 255;
    char buffer[length+1]={0};  /* Input buffer */
#ifdef WIN32
//  COMMTIMEOUTS timeouts;
//  if(waitForMessage){
//      timeouts.ReadIntervalTimeout=5000;
//      timeouts.ReadTotalTimeoutConstant=50;
//      timeouts.ReadTotalTimeoutMultiplier=10;
//  }
//  else{
//      timeouts.ReadIntervalTimeout=50;
//      timeouts.ReadTotalTimeoutConstant=50;
//      timeouts.ReadTotalTimeoutMultiplier=10;
//  }
//  if(!SetCommTimeouts(serialFD_, &timeouts)){
//      BIASWARN("Error setting timeouts to port!");
//  }

    DWORD dwBytesRead = 0;
    if(!ReadFile(serialFD_, buffer, length, &dwBytesRead, NULL)){
        BIASERR("Error reading from serial port!");
        return false;
    }

#else

//  if(waitForMessage)
//      fcntl(serialFD_, F_SETFL, 0);
//  else
//      fcntl(serialFD_, F_SETFL, FNDELAY);

    //read
    char *bufptr;      /* Current char in buffer */
    int  nbytes;       /* Number of bytes read */
    bufptr = buffer;

    while ((nbytes = read(serialFD_, bufptr, buffer + sizeof(buffer) - bufptr - 1)) > 0)
    {
        bufptr += nbytes;
        if (bufptr[-1] == '\n' || bufptr[-1] == '\r')
            break;
    }
#endif

    message = buffer;
    return true;
}

int SerialPortIO::
ReadBytes(unsigned char* message,int nrBytes,bool waitForMessage){
    if(!bIsOpen_){
    BIASERR("Serial port was not opened!")
        return false;
    }

#ifdef WIN32
    COMMTIMEOUTS timeouts={0};
    if(waitForMessage){
        timeouts.ReadIntervalTimeout=5000;
        timeouts.ReadTotalTimeoutConstant=50;
        timeouts.ReadTotalTimeoutMultiplier=10;
    }
    else{
        timeouts.ReadIntervalTimeout=50;
        timeouts.ReadTotalTimeoutConstant=50;
        timeouts.ReadTotalTimeoutMultiplier=10;
    }
    if(!SetCommTimeouts(serialFD_, &timeouts)){
        BIASWARN("Error setting timeouts to port!");
    }

    DWORD dwBytesRead = 0;
    if(!ReadFile(serialFD_, message, nrBytes, &dwBytesRead, NULL)){
        BIASERR("Error reading from serial port!");
    return 0;
    }
  else
    return (int)dwBytesRead;
#else

    if(waitForMessage)
        fcntl(serialFD_, F_SETFL, 0);
    else
        fcntl(serialFD_, F_SETFL, FNDELAY);

    //read  
  int nbytes=0;       /* Number of bytes read */
  nbytes = read(serialFD_, message, nrBytes);
  return nbytes;
#endif
}

bool SerialPortIO::
WriteString(std::string message){
    int attempts = 10;
    if(!bIsOpen_){
    BIASERR("Serial port was not opened!")
        return false;
    }
#ifdef WIN32
    DWORD dwBytesWritten = 0;
    if(!WriteFile(serialFD_, message.c_str(), message.size(), &dwBytesWritten, NULL)){
        BIASERR("Error writing to serial port!");
        return false;
    }
#else
    int n = 0;
    for(int i=0;i<attempts;i++){
        n = write(serialFD_, message.c_str(), message.size());
        if(n > 0) continue;
        biasusleep(500);
    }
    if (n < 0){
        BIASERR("Error writing to serial port!");
        return false;
    }
#endif
    return true;
}

/* returns TRUE if all is OK */
bool SerialPortIO::
WriteBytes(unsigned char *message, int nrBytes)
{
    int attempts = 10;
#ifdef WIN32
    DWORD dwBytesWritten = 0;
    if(!WriteFile(serialFD_, message, nrBytes, &dwBytesWritten, NULL)){
        BIASERR("Error writing to serial port!");
        return false;
    }
#else
    int n = 0;
    for(int i=0;i<attempts;i++){
        n = write(serialFD_, message, nrBytes);
        if(n > 0) continue;
        biasusleep(500);
    }
    if (n < 0){
        BIASERR("Error writing to serial port!");
        return false;
    }
#ifdef BIAS_DEBUG
    cout<<"Wrote:"<<n<<" bytes.\n";
#endif
#endif
    return true;
}

bool SerialPortIO::
GetPetScanRFIDFromString(std::string message, std::string& rfid){

    int length = message.length();
    //std::cout<<"Length:"<<length<<std::endl;
    if(length>=31){
        std::string start = message.substr(0,4);
        std::string chiptype = message.substr(5,4);
        std::string id = message.substr(9,16);
        std::string separator = message.substr(25,1);
        std::string control = message.substr(26,4);
        //      std::cout<<"Start:"<<start<<" chiptype:"<<chiptype<<" id:"<<id<<" separator:"
        //              <<separator<<" control:"<<control<<std::endl;
        rfid = id;

        //check checksum
        //      unsigned int crc_checksum=0xffff;
        //      unsigned int crc_poly = 0x1021;
        //      unsigned char ch=' ';
        //      char i=' ',xor_flag=' ';
        //      unsigned char *inbuffer = (unsigned char *)message.c_str();
        //      while(*inbuffer!=0){
        //          ch=*inbuffer++;
        //          for(i=0;i<8;i++){
        //              xor_flag = (crc_checksum & 0x8000)?1:0;
        //              crc_checksum = crc_checksum<<1;
        //              if(ch & 0x80) crc_checksum++;
        //              if(xor_flag) crc_checksum = crc_checksum ^crc_poly;
        //              ch = ch<<1;
        //          }
        //      }
        //      for(i=0;i<16;i++){
        //          xor_flag=(crc_checksum & 0x8000)?1:0;
        //          crc_checksum = crc_checksum<<1;
        //          if(xor_flag) crc_checksum = crc_checksum ^ crc_poly;
        //      }
        //
        //      unsigned int check = atoi(control.c_str());
        //      std::cout<<"C:"<<check<<std::endl;
        //      std::cout<<"Checksum:"<<crc_checksum<<std::endl;

        return true;
    }
    else{
        rfid = "";
        return false;
    }

}