commoncpp/serial.h

Go to the documentation of this file.

// Copyright (C) 1999-2005 Open Source Telecom Corporation.
// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// This exception applies only to the code released under the name GNU
// Common C++.  If you copy code from other releases into a copy of GNU
// Common C++, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU Common C++, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

#ifndef COMMONCPP_SERIAL_H_
#define COMMONCPP_SERIAL_H_

#ifndef COMMONCPP_CONFIG_H_
#include <commoncpp/config.h>
#endif

#ifndef COMMONCPP_THREAD_H_
#include <commoncpp/thread.h>
#endif

#ifndef COMMMONCPP_EXCEPTION_H_
#include <commoncpp/exception.h>
#endif

NAMESPACE_COMMONCPP

class __EXPORT Serial
{
public:
    enum Error {
        errSuccess = 0,
        errOpenNoTty,
        errOpenFailed,
        errSpeedInvalid,
        errFlowInvalid,
        errParityInvalid,
        errCharsizeInvalid,
        errStopbitsInvalid,
        errOptionInvalid,
        errResourceFailure,
        errOutput,
        errInput,
        errTimeout,
        errExtended
    };
    typedef enum Error Error;

    enum Flow {
        flowNone,
        flowSoft,
        flowHard,
        flowBoth
    };
    typedef enum Flow Flow;

    enum Parity {
        parityNone,
        parityOdd,
        parityEven
    };
    typedef enum Parity Parity;

    enum Pending {
        pendingInput,
        pendingOutput,
        pendingError
    };
    typedef enum Pending Pending;

private:
    Error errid;
    char *errstr;

    struct {
        bool thrown: 1;
        bool linebuf: 1;
    } flags;

    void    *   original;
    void    *   current;

    void initSerial(void);

protected:

    fd_t    dev;

    int bufsize;

    void        open(const char *fname);

    void        close(void);

    virtual int aRead(char * Data, const int Length);

    virtual int aWrite(const char * Data, const int Length);

    Error error(Error error, char *errstr = NULL);

    inline void error(char *err)
        {error(errExtended, err);};


    inline void setError(bool enable)
        {flags.thrown = !enable;};

    int setPacketInput(int size, unsigned char btimer = 0);

    int setLineInput(char newline = 13, char nl1 = 0);

    void restore(void);

    void flushInput(void);

    void flushOutput(void);

    void waitOutput(void);

    void endSerial(void);

    void initConfig(void);

    Serial()
        {initSerial();};

    Serial(const char *name);


public:

    virtual ~Serial();

    Serial &operator=(const Serial &from);

    Error setSpeed(unsigned long speed);

    Error setCharBits(int bits);

    Error setParity(Parity parity);

    Error setStopBits(int bits);

    Error setFlowControl(Flow flow);

    void toggleDTR(timeout_t millisec);

    void sendBreak(void);

    inline Error getErrorNumber(void)
        {return errid;};

    inline char *getErrorString(void)
        {return errstr;};

    inline int getBufferSize(void)
        {return bufsize;};

    virtual bool isPending(Pending pend, timeout_t timeout = TIMEOUT_INF);
};

class __EXPORT TTYStream : protected std::streambuf, public Serial, public std::iostream
{
private:
    int doallocate();

    friend TTYStream& crlf(TTYStream&);
    friend TTYStream& lfcr(TTYStream&);

protected:
    char *gbuf, *pbuf;
    timeout_t timeout;

    TTYStream();

    void allocate(void);

    void endStream(void);

    int underflow(void);

    int uflow(void);

    int overflow(int ch);

public:
    TTYStream(const char *filename, timeout_t to = 0);

    virtual ~TTYStream();

    inline void setTimeout(timeout_t to)
        {timeout = to;};

    void interactive(bool flag);

    int sync(void);

    bool isPending(Pending pend, timeout_t timeout = TIMEOUT_INF);
};

class __EXPORT ttystream : public TTYStream
{
public:
    ttystream();

    ttystream(const char *name);

    void open(const char *name);

    void close(void);

    inline bool operator!()
        {return (dev < 0);};
};

class __EXPORT TTYSession : public Thread, public TTYStream
{
public:
    TTYSession(const char *name, int pri = 0, int stack = 0);

    virtual ~TTYSession();
};

#ifndef _MSWINDOWS_

//  Not support this right now.......
//
class SerialPort;
class SerialService;

class __EXPORT SerialPort: public Serial, public TimerPort
{
private:
    SerialPort *next, *prev;
    SerialService *service;
#ifdef  USE_POLL
    struct pollfd *ufd;
#endif
    bool detect_pending;
    bool detect_output;
    bool detect_disconnect;

    friend class SerialService;

protected:
    SerialPort(SerialService *svc, const char *name);

    virtual ~SerialPort();

    void setDetectPending( bool );

    inline bool getDetectPending( void ) const
        { return detect_pending; }

    void setDetectOutput( bool );

    inline bool getDetectOutput( void ) const
        { return detect_output; }

    virtual void expired(void);

    virtual void pending(void);

    virtual void disconnect(void);

    inline int output(void *buf, int len)
        {return aWrite((char *)buf, len);};

    virtual void output(void);

    inline int input(void *buf, int len)
        {return aRead((char *)buf, len);};
public:
    void setTimer(timeout_t timeout = 0);

    void incTimer(timeout_t timeout);
};

class __EXPORT SerialService : public Thread, private Mutex
{
private:
    fd_set connect;
    int iosync[2];
    int hiwater;
    int count;
    SerialPort *first, *last;

    void attach(SerialPort *port);

    void detach(SerialPort *port);

    void run(void);

    friend class SerialPort;

protected:
    virtual void onUpdate(unsigned char flag);

    virtual void onEvent(void);

    virtual void onCallback(SerialPort *port);

public:
    void update(unsigned char flag = 0xff);

    SerialService(int pri = 0, size_t stack = 0, const char *id = NULL);

    virtual ~SerialService();

    inline int getCount(void)
        {return count;};
};

#endif

#ifdef  CCXX_EXCEPTIONS
class __EXPORT SerException : public IOException
{
public:
    SerException(const String &str) : IOException(str) {};
};
#endif

END_NAMESPACE

#endif

---