SerialPortIO.hh

/*
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
*/

#ifndef SERIALPORTIO_HH_
#define SERIALPORTIO_HH_

#include <bias_config.h>

#include <stdio.h>   /* Standard input/output definitions */
#include <string>  /* String function definitions */

#ifdef WIN32
    #include <windows.h>
#else
  #include <unistd.h>  /* UNIX standard function definitions */
  #include <fcntl.h>   /* File control definitions */
  #include <errno.h>   /* Error number definitions */
  #include <termios.h> /* POSIX terminal control definitions */
#endif

namespace BIAS {

    enum SerialPortParityMode{
        SPPM_NoParity,
        SPPM_EvenParity,
        SPPM_OddParity,
        SPPM_SpaceParity
    };

    /**
     * @class SerialPortIO
     * @brief Communication over the serial port, use OpenPort with e.g. /dev/ttyUSB0 or COM0 to
     * open a port for communication. Default Options will be set when opening the port.
     * if you need other options use the set SetOptions function
     * You can read or write a string to the port.
     * For the PetScan RT100 V5 format a function to get the RFID tag from a read string
     * is given.
     * @ingroup g_utils
     * @date Nov 23, 2010
     * @author: ischiller
     */
    class BIASUtils_EXPORT SerialPortIO {
    public:
    /** \brief standard constructor
      * @param verbose Print messages if port cannot be opened
        */
    SerialPortIO(bool verbose = true);

        /** \brief standard destructor */
        virtual ~SerialPortIO();

        /** \brief Open port, e.g. /dev/ttyUSB0, or COM0
         *  \return true on success, false on failure to open*/
        bool OpenPort(std::string port);

        /** \brief Close port
         *  \return true on success, false on failure to close*/
        bool ClosePort();

        /**\brief Set Options for opened port, use OpenPort before
         * \return true on success, false on failure to close
         *
         * \param canonicalInput[in]: set Canonical input (line oriented) */
        bool SetOptions(unsigned baudrate=9600,
                            SerialPortParityMode parity=SPPM_NoParity,
                                      bool hardwareFlowControl=false,
                                      bool canonicalInput=true,
                                      bool softwareFlowControl=false,
                                      int stopbits=1);

        /**
         * \brief in linux all exept ReadTotalTimeoutConstant is ignored
         * \param ReadIntervalTimeout[in]: tenths of seconds to wait for message
         * \param ReadTotalTimeoutMultiplier[in]: multiplicative factor for ReadTotalTimeoutConstant
         * \param ReadTotalTimeoutConstant[in]: constant to time wait for message
         * \param WriteTotalTimeoutMultiplier[in]: multiplicative factor for WriteTotalTimeoutConstant
         * \param WriteTotalTimeoutConstant[in]: tenths of seconds to wait befor writing message
        */
        bool SetTimeOuts(int ReadIntervalTimeout,
                int ReadTotalTimeoutMultiplier,int ReadTotalTimeoutConstant,
                int WriteTotalTimeoutMultiplier,int WriteTotalTimeoutConstant);

        /**\brief Read a string from port, port has to be open
        * \param waitForMessage[in]: if this parameter is true the call
        * to this function will block until something is read from the port
        * if it is false it will return immediately
    * \param message[in]: the read string*/
    bool ReadString(std::string& message, bool waitForMessage=true);

        /**\brief Read bytes from the port, port has to be open
        * \param waitForMessage[in]: if this parameter is true the call
        * to this function will block until something is read from the port
        * if it is false it will return immediately
        * \param message[out]: the preallocated buffer of size nrBytes to write message to
        * \param nrBytes[out]: the number of bytes which are read from the port
    * \return number of bytes read */
    int ReadBytes(unsigned char* message, int nrBytes, bool waitForMessage=true);

        /**\brief Write a string to the port, port has to be open
        * \param message[in]: the message to write to the port
        * \return true on success, false on failure to close*/
        bool WriteString(std::string message);

        /**\brief Write bytes to the port, port has to be open
        * \param message[in]: the message to write to the port
        * \param nrBytes[in]: the number of bytes to write to the port
        * \return true on success, false on failure to close*/
        bool WriteBytes(unsigned char *message, int nrBytes);

        /**
         * \brief parses values of PetScan RT100 V5 format
         *              Start Chip      Value    *Control
         *              U    FDXB945 000000869846*FFA9
         * \param message[in]: the message to extract the RFID from
         * \param rfig[out]: the rfid extracted from the message string
         * \return true on success, false on failure to close*/
        bool GetPetScanRFIDFromString(std::string message, std::string& rfid);

    protected:
         /** File descriptor for the port */
#ifdef WIN32
         HANDLE serialFD_;
#else
         int serialFD_;
#endif
         bool bIsOpen_;

     bool verbose_;
    };
}//end namespace BIAS
#endif /* SERIALPORTIO_HH_ */