serial.h

/*
 * GearBox Project: Peer-Reviewed Open-Source Libraries for Robotics
 *               http://gearbox.sf.net/
 * Copyright (c) 2004-2010 Alex Brooks, Mathew Ridley
 *
 * This distribution is licensed to you under the terms described in
 * the LICENSE file included in this distribution.
 *
 */
#ifndef GBXSERIALACFR_SERIAL_H
#define GBXSERIALACFR_SERIAL_H

#include <string>
#include <gbxserialacfr/uncopyable.h>
#include <gbxserialacfr/lockfile/lockfile.h>

namespace gbxserialacfr {

class SerialException : public std::exception
{ 
    std::string  message_;
public:
    SerialException(const char *message)
        : message_(message) {}
    SerialException(const std::string &message)
        : message_(message) {}
    ~SerialException()throw(){}
    virtual const char* what() const throw() { return message_.c_str(); }
};

class Serial : public Uncopyable
{
public:

    struct Timeout {
        Timeout( int s, int us )
            : sec(s), usec(us)
            {}
        int sec;
        int usec;
    };

    Serial( const std::string &dev,
            int                baudRate,
            const Timeout     &timeout,
            int                debuglevel  = 0,
            bool               useLockFile = true );

    ~Serial();

    void setDebugLevel( int debugLevel ) { debugLevel_ = debugLevel; }

    void setBaudRate(int baud);

    void setTimeout( const Timeout &timeout );

    const Timeout &timeout() const { return timeout_; }

    int read(void *buf, int count);

    int readFull(void *buf, int count);

    int readStringUntil( std::string &str, char termchar );

    int readLine( std::string &str )
        { return readStringUntil(str,'\n'); }

    int bytesAvailable();

    int bytesAvailableWait();

    int write(const void *buf, int count);

    int writeString(const char *buf);
    inline int writeString(const std::string &s) {
        return writeString(s.c_str());
    }

    void flush();

    void drain();

    int fileDescriptor() { return portFd_; }

    std::string getStatusString();


private:

    // Utility function to wait up to the timeout for data to appear.
    // Returns:
    enum WaitStatus {
        TIMED_OUT,
        DATA_AVAILABLE,
    };
    WaitStatus waitForDataOrTimeout(void);

    // Opens a device @c dev.
    void open(int flags=0);

    // Won't throw exceptions.
    void close() throw();

    bool timeoutsEnabled() const
        { return !( timeout_.sec == 0 && timeout_.usec == 0 ); }

    const std::string dev_;
    int portFd_;

    Timeout timeout_;

    int debugLevel_;

    lockfile::LockFile *lockFile_;
};

}

#endif