---

serial.h

Go to the documentation of this file.

// Copyright (C) 1999-2001 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 APE.
// 
// The exception is that, if you link the APE 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 APE 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 APE.  If you copy code from other releases into a copy of
// APE, 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 APE, 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_CONFIG_H__
#include <cc++/config.h>
#endif

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

#include <iostream>

#ifdef  __NAMESPACES__
namespace ost {
#endif

enum sioerror_t
{
        SERIAL_SUCCESS = 0,
        SERIAL_OPEN_NOTTY,
        SERIAL_OPEN_FAILED,
        SERIAL_SPEED_INVALID,
        SERIAL_FLOW_INVALID,
        SERIAL_PARITY_INVALID,
        SERIAL_CHARSIZE_INVALID,
        SERIAL_STOPBITS_INVALID,
        SERIAL_OPTION_INVALID,
        SERIAL_RESOURCE_FAILURE,
        SERIAL_OUTPUT_ERROR,
        SERIAL_INPUT_ERROR,
        SERIAL_TIMEOUT_ERROR,
        SERIAL_EXTENDED_ERROR
};
typedef enum sioerror_t sioerror_t;

enum sioflow_t
{
        SERIAL_FLOW_NONE,
        SERIAL_FLOW_SOFT,
        SERIAL_FLOW_HARD,
        SERIAL_FLOW_BOTH
};
typedef enum sioflow_t sioflow_t;

enum sioparity_t
{
        SERIAL_PARITY_NONE,
        SERIAL_PARITY_ODD,
        SERIAL_PARITY_EVEN
};
typedef enum sioparity_t sioparity_t;

enum siopend_t
{
        SERIAL_PENDING_INPUT,
        SERIAL_PENDING_OUTPUT,
        SERIAL_PENDING_ERROR
};
typedef enum siopend_t siopend_t;

class Serial
{
private:
        sioerror_t errid;
        char *errstr;

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

        void *original, *current;

        void initSerial(void);

protected:
        int dev;
        int bufsize;

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

        inline void Error(char *errstr)
                {Error(SERIAL_EXTENDED_ERROR, errstr);};


        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(const char *name);

        Serial()
                {initSerial();};

public:
        virtual ~Serial()
                {endSerial();};

        Serial &operator=(const Serial &from);
        
        sioerror_t setSpeed(unsigned long speed);

        sioerror_t setCharBits(int bits);

        sioerror_t setParity(sioparity_t parity);

        sioerror_t setStopBits(int bits);

        sioerror_t setFlowControl(sioflow_t flow);

        void toggleDTR(timeout_t millisec);

        void sendBreak(void);

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

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

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

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

#if defined(STLPORT) || defined(__KCC)
#define iostream iostream_withassign
#endif
class TTYStream : public std::streambuf, public std::iostream, public
Serial
{
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);

        virtual ~TTYStream();

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

        void Interactive(bool flag);
        
        int sync(void); 

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

class 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);
};

class SerialPort;
class SerialService;

class SerialPort: public Serial, public TimerPort
{
private:
        SerialPort *next, *prev;
        SerialService *service;
#ifdef  __CCXX_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 ::write(dev, (char *)buf, len);};

        virtual void Output(void)
                {return;};

        inline int Input(void *buf, int len)
                {return ::read(dev, (char *)buf, len);};

public:
        void setTimer(timeout_t timeout = 0);

        void incTimer(timeout_t timeout);
};

class 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);

        virtual ~SerialService();

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

#ifdef  COMMON_STD_EXCEPTION
class SerException : public IOException
{
public:
        SerException(std::string str) : IOException(str) {};
};
#endif

#ifdef  __NAMESPACES__
};
#endif

#endif

---