SerialStreamBuf.h

Go to the documentation of this file.

/*
 * Time-stamp: <04/05/05 16:21:47 pagey>
 *
 * $Id: SerialStreamBuf.h,v 1.7 2005/09/05 14:19:55 wedesoft Exp $
 *
 *
 */
#ifndef _SerialStreamBuf_h_
#define _SerialStreamBuf_h_

#ifndef _termios_h_INCLUDED_
#    include <termios.h>
#    define _termios_h_INCLUDED_
#endif

#ifndef _unistd_h_INCLUDED_
#    include <unistd.h>
#    define _unistd_h_INCLUDED_
#endif

#ifndef _std_iosfwd_INCLUDED_
#    include <iosfwd>
#    define _std_iosfwd_INCLUDED_
#endif

#ifndef _std_streambuf_INCLUDED_
#    include <streambuf>
#    define _std_streambuf_INCLUDED_
#endif

#ifndef _std_string_INCLUDED_
#    include <string>
#    define _std_string_INCLUDED_
#endif

extern "C++" {
    namespace LibSerial {
        class SerialStreamBuf : public std::streambuf {
        public:


            enum BaudRateEnum {
                BAUD_50    = B50,         
                BAUD_75    = B75,         
                BAUD_110   = B110,        
                BAUD_134   = B134,        
                BAUD_150   = B150,        
                BAUD_200   = B200,        
                BAUD_300   = B300,        
                BAUD_600   = B600,        
                BAUD_1200  = B1200,       
                BAUD_1800  = B1800,       
                BAUD_2400  = B2400,       
                BAUD_4800  = B4800,       
                BAUD_9600  = B9600,       
                BAUD_19200 = B19200,      
                BAUD_38400 = B38400,      
                BAUD_57600 = B57600,      
                BAUD_115200 = B115200,    
                BAUD_INVALID              
            } ;

            enum CharSizeEnum {
                CHAR_SIZE_5 = CS5, 
                CHAR_SIZE_6 = CS6, 
                CHAR_SIZE_7 = CS7, 
                CHAR_SIZE_8 = CS8, 
                CHAR_SIZE_INVALID  
            } ;

            enum ParityEnum {
                PARITY_EVEN,     
                PARITY_ODD,      
                PARITY_NONE,     
                PARITY_INVALID   
            } ;      

            enum FlowControlEnum {
                FLOW_CONTROL_HARD,   
                FLOW_CONTROL_SOFT,   
                FLOW_CONTROL_NONE,   
                FLOW_CONTROL_INVALID 
            } ;

            /* ------------------------------------------------------------
             * Public Static Members
             * ------------------------------------------------------------
             */
            static const BaudRateEnum DEFAULT_BAUD ;

            static const CharSizeEnum DEFAULT_CHAR_SIZE ;

            static const short DEFAULT_NO_OF_STOP_BITS ;

            static const ParityEnum DEFAULT_PARITY ;
      
            static const FlowControlEnum DEFAULT_FLOW_CONTROL ;

            static const short DEFAULT_VMIN ;

            static const short DEFAULT_VTIME ;





            SerialStreamBuf() ;

            ~SerialStreamBuf() ;

            bool is_open() const ;

            SerialStreamBuf* open( const std::string filename, 
                                   std::ios_base::openmode mode = 
                                   std::ios_base::in | std::ios_base::out ) ;

            SerialStreamBuf* close() ;

            int SetParametersToDefault() ;

            const BaudRateEnum SetBaudRate(const BaudRateEnum baud_rate) ;

            const BaudRateEnum BaudRate() const ;

            const CharSizeEnum SetCharSize(const CharSizeEnum char_size) ;

            const CharSizeEnum CharSize() const ;

            short SetNumOfStopBits(short stop_bits) ;

            short NumOfStopBits() const ; 

            const ParityEnum SetParity(const ParityEnum parity) ;

            const ParityEnum Parity() const ;

            const FlowControlEnum SetFlowControl(const FlowControlEnum flow_c) ;

            const FlowControlEnum FlowControl() const ;

            const short SetVMin( short vtime ) ;

            const short VMin() const;

            const short SetVTime( short vtime ) ;

            const short VTime() const;




            /* ------------------------------------------------------------
             * Friends
             * ------------------------------------------------------------
             */
        protected:
            /* ------------------------------------------------------------
             * Protected Data Members
             * ------------------------------------------------------------
             */
            static const char CTRL_Q = 0x11 ;
      
            static const char CTRL_S = 0x13 ;
            /* ------------------------------------------------------------
             * Protected Methods
             * ------------------------------------------------------------
             */
            virtual std::streambuf* setbuf( char_type*, 
                                            std::streamsize ) ;

            virtual std::streamsize xsgetn( char_type*      s, 
                                            std::streamsize n ) ;

            virtual std::streamsize showmanyc();

            virtual int_type underflow() ;

            virtual int_type   uflow() ;

            virtual int_type pbackfail(int_type c = traits_type::eof()) ;

            virtual std::streamsize xsputn( const char_type* s, 
                                            std::streamsize  n ) ;

            virtual int_type overflow(int_type c) ;

        private:
            /* ------------------------------------------------------------
             * Private Data Members
             * ------------------------------------------------------------
             */
            char mPutbackChar ;

            bool mPutbackAvailable ;
      
            int mFileDescriptor ;
            /* ------------------------------------------------------------
             * Private Methods
             * ------------------------------------------------------------
             */
            int InitializeSerialPort() ;
        } ; // class SerialStreamBuf

        inline 
        SerialStreamBuf::SerialStreamBuf() :
            mPutbackChar(0),
            mPutbackAvailable(false),
            mFileDescriptor(-1)
        {
            setbuf(0, 0) ;
            return ;
        }

        inline 
        SerialStreamBuf::~SerialStreamBuf() 
        {
            if( this->is_open() ) {
                this->close() ;
            }
            return ;
        }

        inline
        bool
        SerialStreamBuf::is_open() const 
        {
            return (-1 != mFileDescriptor) ;
        }
    
        inline
        std::streambuf* 
        SerialStreamBuf::setbuf(char_type *, std::streamsize) 
        {
            return std::streambuf::setbuf(0, 0) ;
        }

        inline
        SerialStreamBuf*
        SerialStreamBuf::close() 
        {
            //
            // Return a null pointer if the serial port is not currently open. 
            //
            if( this->is_open() == false ) {
                return 0 ;
            }
            //
            // Otherwise, close the serial port and set the file descriptor
            // to an invalid value.
            //
            if( -1 == ::close(mFileDescriptor) ) {
                //
                // If the close failed then return a null pointer. 
                //
                return 0 ;
            } else {
                //
                // Set the file descriptor to an invalid value, -1. 
                //
                mFileDescriptor = -1 ;
                //
                // On success, return "this" as required by the C++ standard.
                //
                return this ;
            }
        }
    
        inline
        std::streambuf::int_type
        SerialStreamBuf::uflow() 
        {
            int_type next_ch = underflow() ;
            mPutbackAvailable = false ;
            return next_ch ;
        }

    } ; // namespace LibSerial
} // extern "C++"
#endif // #ifndef _SerialStreamBuf_h_

---