serial.h

Go to the documentation of this file.

// Copyright (C) 1999-2002 Open Source Telecom Corporation.
//
// 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 General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// 
// As a special exception to the GNU General Public License, permission is 
// granted for additional uses of the text contained in its release 
// of Common C++.
// 
// The exception is that, if you link the Common C++ library with other files
// to produce an executable, this does not by itself cause the
// resulting executable to be covered by the GNU General Public License.
// Your use of that executable is in no way restricted on account of
// linking the Common C++ library code into it.
//
// 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 Common C++.  If you copy code from other releases into a copy of
// 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 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 CCXX_SERIAL_H_
#define CCXX_SERIAL_H_

#ifndef CCXX_MISSING_H_
#include <cc++/missing.h>
#endif

#ifndef CCXX_THREAD_H_
#include <cc++/thread.h>
#endif

#ifndef CCXX_EXCEPTION_H_
#include <cc++/exception.h>
#endif

#ifndef WIN32
typedef int HANDLE;
#define         INVALID_HANDLE_VALUE    (-1)
#endif

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif

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:

        HANDLE  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()
                {endSerial();};

        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 TTYSession : public TTYStream, public Thread
{
public:
        TTYSession(const char *name, int pri = 0, int stack = 0);
};

#ifndef WIN32

//      Not support this right now.......
//
class __EXPORT SerialPort;
class __EXPORT 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 );
        
        bool getDetectPending( void ) const
                { return detect_pending; }
        
        void setDetectOutput( bool );
        
        bool getDetectOutput( void ) const
                { return detect_output; }

        virtual void expired(void)
                {return;};

        virtual void pending(void)
                {return;};

        virtual void disconnect(void)
                {return;};

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

        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)
                {return;};

        virtual void onEvent(void)
                {return;};

        virtual void onCallback(SerialPort *port)
                {return;};

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  COMMON_STD_EXCEPTION
class __EXPORT SerException : public IOException
{
public:
        SerException(const String &str) : IOException(str) {};
};
#endif

#ifdef  CCXX_NAMESPACES
}
#endif

#endif

---