/users/dtb26/GITROOT/vetsim/vs-core/include/asserial.h

Go to the documentation of this file.

/*
* AUTHOR    : David Brooks (dtb26@cornell.edu)
* PLATFORM  : non-specific
* DATE      : 4/4/2012 9:18:44 AM
* COPYRIGHT : TBD
*
* File      : $Source:$
* Revision  : $Revision:$
* Author    : $Author:$
* Date      : $Date:$
* Tag name  : $Name:$
* Locker    : $Locker:$
* State     : $State: Exp $
*/

// MSVC++ 6.0  _MSC_VER = 1200
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
        #pragma once
        #pragma warning( disable : 4355 )       
#endif

#ifndef VET_ASYNCH_SERIAL_H_INCLUDED
#define VET_ASYNCH_SERIAL_H_INCLUDED
#include "excepts.h"
#include <string>
#include <deque>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/asio/serial_port.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <boost/signals2.hpp>

namespace cornelluniversity {

namespace vetserial {

// --- picks a reasonable default device name
#if defined(unix) || defined(__unix__) || defined(__unix) || defined(__linux__)
        const static std::string DFLT_DEVICE = "/dev/ttyS0";
#elif defined(__APPLE__)
        // this may be a good bet, but hard to find a definitive answer
        const static std::string DFLT_DEVICE = "/dev/ttyUSB0";
#else
        const static std::string DFLT_DEVICE = "COM1";
#endif

class asynch_serial {

        typedef boost::signals2::signal<void (const std::string &)> Reader;  
        typedef Reader::slot_type ReaderSlotType;                                                        
    public:
                asynch_serial( boost::asio::io_service& ios ) : active_(false), reading_(false), io_service_(ios), serial_port_(io_service_){;}
                
                asynch_serial( boost::asio::io_service& io_service, unsigned int baud, const std::string& device );
                
                inline  boost::asio::io_service& ioservice(){ return(serial_port_.get_io_service()); }          
                
                virtual ~asynch_serial( void ){;}
                
                void open( const std::string& device );
                
                void open( unsigned int baud = 9600, const std::string& device = DFLT_DEVICE );

                inline void close( void ) { this->serial_port_.get_io_service().post( boost::bind(&asynch_serial::do_close, this, boost::system::error_code()) ); }

                inline bool active() const { return( this->active_ ); }

                inline void active( const bool on_off ) { this->active_ = on_off; }

        inline void write( const char msg ) { this->serial_port_.get_io_service().post( boost::bind(&asynch_serial::do_write, this, msg) ); }

                inline boost::signals2::connection register_reader( const ReaderSlotType & slot ) { return(reader_.connect(slot)); }

                template<typename SettableSerialPortOption>
                void setopt( const SettableSerialPortOption & opt ){ this->serial_port_.set_option( opt );}

                inline void start_reading( void ){ if(serial_port_.is_open() && !reading_){this->read_start(); reading_ = true;} }

        private:
                void do_close( const boost::system::error_code& error );

        void do_write( const char msg );

        void write_start( void );

        void write_complete( const boost::system::error_code& error );

        void read_start( void );

        void read_complete( const boost::system::error_code& error, size_t bytes_transferred );

        private:
                static const int         max_read_length = 512;      
        bool                     active_;                    
                bool                                     reading_;                                       
        boost::asio::io_service& io_service_;                
        boost::asio::serial_port serial_port_;               
        char                     read_msg_[max_read_length]; 
                std::deque<char>         write_msgs_;                
                Reader                                   reader_;                                        
};
}//eon vetserial
}//eon cornelluniversity

#endif /*VET_ASYNCH_SERIAL_H_INCLUDED*/

/*
VERSION LOG
===========
$Log:$

*/

---