serialport.hpp

Go to the documentation of this file.

 
#ifndef SERIALPORT_HPP
#define SERIALPORT_HPP
 
#include <iostream>
#include <string>
#include <mutex>
#include <thread>
 
#include <boost/asio.hpp>
#include <boost/utility.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/circular_buffer.hpp>
#include <boost/thread/shared_mutex.hpp>
#include <condition_variable>
 
#include <logicalaccess/readerproviders/readerunit.hpp>
#include <logicalaccess/readerproviders/circularbufferparser.hpp>
 
namespace logicalaccess
{
class LLA_CORE_API SerialPort
{
  public:
    SerialPort();
 
    explicit SerialPort(const std::string &dev);
 
    SerialPort(const SerialPort &other) = delete;       // non construction-copyable
    SerialPort &operator=(const SerialPort &) = delete; // non copyable
 
    virtual ~SerialPort()
    {
        close();
    }
 
    void open();
 
    void reopen();
 
    void close();
 
    bool isOpen() const;
 
    const std::string &deviceName() const
    {
        return m_dev;
    }
 
    size_t read(ByteVector &buf);
 
    size_t write(const ByteVector &buf);
 
    void setBaudrate(unsigned int rate);
    unsigned int getBaudrate();
 
    void setFlowControl(const boost::asio::serial_port_base::flow_control::type &type);
    boost::asio::serial_port_base::flow_control::type getFlowControl();
 
    void setParity(const boost::asio::serial_port_base::parity::type &parity);
    boost::asio::serial_port_base::parity::type getParity();
 
    void setStopBits(const boost::asio::serial_port_base::stop_bits::type &stop_bits);
    boost::asio::serial_port_base::stop_bits::type getStopBits();
 
    void setCharacterSize(unsigned int character_size);
    unsigned int getCharacterSize();
 
    void setCircularBufferParser(CircularBufferParser *circular_buffer_parser)
    {
        m_circular_buffer_parser.reset(circular_buffer_parser);
    }
    std::shared_ptr<CircularBufferParser> getCircularBufferParser() const
    {
        return m_circular_buffer_parser;
    }
 
    boost::circular_buffer<unsigned char> &getCircularReadBuffer()
    {
        return m_circular_read_buffer;
    }
 
    template <typename T>
    void waitMoreData(const std::chrono::steady_clock::time_point &until, T &&callback)
    {
        std::unique_lock<std::mutex> ul(cond_var_mutex_);
        cond_var_.wait_until(ul, until, [&]() { return data_flag_; });
        if (data_flag_)
        {
            callback();
        }
    }
 
    template <typename T>
    void lockedExecute(T &&callback)
    {
        std::unique_lock<std::mutex> ul(cond_var_mutex_);
        callback();
    }
 
    void dataConsumed();
 
  private:
    void do_read(const boost::system::error_code &e, size_t bytes_transferred);
 
    void do_close(const boost::system::error_code &error);
 
    void do_write(const ByteVector &buf);
    void write_start();
    void write_complete(const boost::system::error_code &error,
                        const size_t bytes_transferred);
 
    std::string m_dev;
 
    boost::asio::io_service m_io;
 
    boost::asio::serial_port m_serial_port;
 
    boost::circular_buffer<unsigned char> m_circular_read_buffer;
 
    ByteVector m_read_buffer;
 
    ByteVector m_write_buffer;
 
    std::shared_ptr<std::thread> m_thread_reader;
 
    std::shared_ptr<CircularBufferParser> m_circular_buffer_parser;
 
    std::condition_variable cond_var_;
    bool data_flag_;
    std::mutex cond_var_mutex_;
};
}
 
#endif /* SERIALPORT_HPP */