SerialPort.hpp

Go to the documentation of this file.

/**
 * \file SerialPort.hpp
 * \brief The serial port with timeout based on Boost.Asio.
 */


#ifndef MT4CPP_SERIAL_PORT_HPP
#define MT4CPP_SERIAL_PORT_HPP

#include <vector>
#include <string>

#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/asio.hpp>
#include <boost/asio/basic_waitable_timer.hpp>

#include <boost/chrono.hpp>

namespace mt4cpp {

    /**
       \brief the template for object represents serial port with timeout

       \param clock_type the type of the clock, e.g. boost::chrono::steady_clock
    */
    template<typename clock_type>
    class BasicSerialPort : boost::noncopyable {
    public:
        typedef std::vector<char> Buffer; //buffer for read or write
        typedef clock_type Clock; //the clock used for timeout
        typedef typename Clock::duration Timeout; //representation of timeout
        typedef boost::function1<bool, const Buffer&> ReadPredicate; //representation of predicate

        /** c-tor */
        BasicSerialPort(const std::string& port_name,
                   const Timeout timeout,
                   boost::asio::serial_port_base::baud_rate baud_rate
                   = boost::asio::serial_port_base::baud_rate(9600),
                   boost::asio::serial_port_base::flow_control flow_control
                   = boost::asio::serial_port_base::flow_control(boost::asio::serial_port_base::flow_control::none),
                   boost::asio::serial_port_base::parity parity
                   = boost::asio::serial_port_base::parity(boost::asio::serial_port_base::parity::none),
                   boost::asio::serial_port_base::stop_bits stop_bits
                   = boost::asio::serial_port_base::stop_bits(boost::asio::serial_port_base::stop_bits::one),
                   boost::asio::serial_port_base::character_size character_size
                   = boost::asio::serial_port_base::character_size(8) )
            :
            timeout_(timeout),
            io_(),
            port_(io_, port_name ),
            timer_(io_)
        {
            port_.set_option(baud_rate);
            port_.set_option(flow_control);
            port_.set_option(parity);
            port_.set_option(stop_bits);
            port_.set_option(character_size);
        }

        /** d-tor */
        ~BasicSerialPort() {
            port_.close();
        }

        /** read from port when predicate return true_type */
        inline const Buffer& read_if(ReadPredicate p) {
            readBuffer_.clear();
            if( !p(readBuffer_) )
                return readBuffer_; //if reading is finished for empty buffer

            timer_.expires_from_now( timeout_ );
            timer_.async_wait(boost::bind(&BasicSerialPort::timerEvent, this, boost::asio::placeholders::error) );
            readSome(p);
            io_.reset();
            io_.run();
            return readBuffer_;
        }

        /** read n bytes */
        inline const Buffer& read_n(int n) {
            return read_if( boost::bind( std::less<int>(), boost::bind(&Buffer::size, _1), n ) );
        }

        /** write into port. Return number bytes written. */
        inline Buffer::size_type write(const Buffer& buf) { //!< write buffer to port. Return number of written bytes
            writeBuffer_ = buf;
            bytesWritten_ = 0;
            cancel_ = false;

            if(writeBuffer_.empty() )
                return 0; //if try to write empty buffer

            timer_.expires_from_now( timeout_ );
            timer_.async_wait(boost::bind(&BasicSerialPort::timerEvent, this, boost::asio::placeholders::error) );
            writeSome();
            io_.reset();
            io_.run();
            return bytesWritten_;
        }
    private:
        Timeout timeout_;
        boost::asio::io_service io_;
        boost::asio::serial_port port_; //boost serial port
        boost::asio::basic_waitable_timer<Clock> timer_; //timer to timeout

        static const Buffer::size_type BUFFER_SIZE = 16;
        char buffer_ [BUFFER_SIZE]; // transmission buffer
        Buffer readBuffer_; //whole message buffer for read
        Buffer writeBuffer_; //whole message buffer for write
        Buffer::size_type bytesWritten_; //number written bytes
        bool cancel_; //cancel the write operation
    private:
        /** start async reading from port using boost asio */
        inline void readSome(ReadPredicate p) {
            port_.async_read_some( boost::asio::buffer(buffer_, 1),
                                   boost::bind(&BasicSerialPort::readEvent, this,
                                               boost::asio::placeholders::error,
                                               boost::asio::placeholders::bytes_transferred,
                                               p) );

        }

        /** start async writting to port using boost asio */
        inline void writeSome() {
            Buffer::size_type to_write = std::min(writeBuffer_.size() - bytesWritten_, BUFFER_SIZE);
            Buffer::const_iterator b = writeBuffer_.begin() + bytesWritten_;
            Buffer::const_iterator e = b + to_write;
            std::copy( b, e, buffer_ );

            port_.async_write_some( boost::asio::buffer(buffer_, to_write ),
                                    boost::bind(&BasicSerialPort::writeEvent, this,
                                                boost::asio::placeholders::error,
                                                boost::asio::placeholders::bytes_transferred) );

        }
        /** callback called by async_read_some on given port */
        inline void readEvent(const boost::system::error_code& error, std::size_t bytes_transferred, ReadPredicate p) {
            if(!error) { //not ERROR and not TIMEOUT
                if(bytes_transferred > 0) { //read some data
                    readBuffer_.push_back(buffer_[0]);
                    if( ! p(readBuffer_) ) { //predicate not true -> finish reading
                        timer_.cancel();  // will cause timer to fire with an error
                        return;
                    }
                }
                readSome(p);
            }
        }

        inline Buffer::size_type initWriteBuffer() {
            Buffer::size_type to_write = std::min(writeBuffer_.size() - bytesWritten_, BUFFER_SIZE);
            Buffer::const_iterator b = writeBuffer_.begin() + bytesWritten_;
            Buffer::const_iterator e = b + to_write;
            std::copy( b, e, buffer_ );
            return to_write;
        }

        /** callback called by async_write_some on given port */
        inline void writeEvent(const boost::system::error_code& error, std::size_t bytes_transferred) {
            //std::cout << "write event, bw_:" << bytesWritten_ << " e: " << error << " tr: " << bytes_transferred << " c:" << cancel_ << std::endl;
            if(!error && !cancel_) { //not ERROR and not TIMEOUT
                if(bytes_transferred > 0) { //write some data
                    bytesWritten_ += bytes_transferred;
                    if(bytesWritten_ >= writeBuffer_.size()) {
                        timer_.cancel(); // will cause timer to fire with an error
                        return;
                    }
                }
                writeSome();
            }
        }

        /** timer event - timeout */
        inline void timerEvent(const boost::system::error_code& error) {
            if( error ) // Data was read and this timeout was canceled
                return;
            port_.cancel();  // will cause readEvent fire with an error
            cancel_ = true;
        }
    };

    /** Typedef for serial port with a timer based on the Boost.Chrono steady clock */
    typedef BasicSerialPort<boost::chrono::steady_clock> SerialPort;

} //namespace mt4cpp

#endif // MT4CPP_SERIAL_PORT_HPP