Implement timeout for async data read

Author: bbogush

qt/reader.cpp

@@ -10,7 +10,7 @@
 #include <QTextBlock>
 #include <QTextCursor>
 
-#define READ_TIMEOUT 10000
+#define READ_TIMEOUT 10
 #define NOTIFY_LIMIT 131072 // 128KB
 
 Q_DECLARE_METATYPE(QtMsgType)
@@ -257,20 +257,13 @@ int Reader::read(char *pbuf, uint32_t len)
     std::function<void(int)> cb = std::bind(&Reader::readCb, this,
         std::placeholders::_1);
 
-    if (serialPort->asyncRead(pbuf, len, cb) < 0)
+    if (serialPort->asyncReadWithTimeout(pbuf, len, cb, READ_TIMEOUT) < 0)
     {
         logErr("Failed to read data");
         return -1;
     }
 
     return 0;
-
-//TODO: handle timeout
-//    if (!serialPort->waitForReadyRead(READ_TIMEOUT))
-//    {
-//        logErr("Read data timeout");
-//        return -1;
-//    }
 }
 
 int Reader::serialPortCreate()

qt/serial_port.cpp

@@ -78,6 +78,65 @@ void SerialPort::onRead(const boost::system::error_code &ec, size_t bytesRead)
     readCb(bytesRead);
 }
 
+int SerialPort::asyncReadWithTimeout(char *buf, int size,
+    std::function<void (int)> cb, int timeout)
+{
+    if (!port || !port.get() || !port->is_open())
+        return -1;
+
+    readCb = cb;
+
+    port->async_read_some(boost::asio::buffer(buf, size),
+        boost::bind(&SerialPort::onReadWithTimeout, this,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred));
+
+    timer = timer_ptr(new boost::asio::deadline_timer(ioService));
+    timer->expires_from_now(boost::posix_time::seconds(timeout));
+    timer->async_wait(boost::bind(&SerialPort::onTimeout, this,
+        boost::asio::placeholders::error));
+
+    if (!isStarted)
+    {
+        thread = thread_ptr(new boost::thread(boost::bind(&boost::asio::
+            io_service::run, &ioService)));
+        isStarted = true;
+    }
+
+    return 0;
+}
+
+void SerialPort::onReadWithTimeout(const boost::system::error_code &ec,
+    size_t bytesRead)
+{
+    boost::mutex::scoped_lock look(mutex);
+
+    timer->cancel();
+    timer = nullptr;
+
+    if (ec)
+    {
+        readCb(-1);
+        isStarted = false;
+        return;
+    }
+
+    readCb(bytesRead);
+}
+
+void SerialPort::onTimeout(const boost::system::error_code &e)
+{
+    if (!e)
+    {
+        std::cout << "timeout: " << e.message() << std::endl;
+        port->cancel();
+        readCb(-1);
+        isStarted = false;
+    }
+    else if (e != boost::asio::error::operation_aborted)
+        std::cout << "Timer error: " << e.message() << std::endl;
+}
+
 std::string SerialPort::errorString()
 {
     return ec.message();
@@ -119,6 +178,12 @@ void SerialPort::stop()
 {
     boost::mutex::scoped_lock look(mutex);
 
+    if (timer)
+    {
+        timer->cancel();
+        timer = nullptr;
+    }
+
     if (port)
     {
         port->cancel();
@@ -130,4 +195,7 @@ void SerialPort::stop()
     ioService.stop();
     ioService.reset();
     isStarted = false;
+
+    if (thread)
+        thread = nullptr;
 }

qt/serial_port.h

@@ -14,22 +14,29 @@
 
 #include <iostream>
 
-typedef boost::shared_ptr<boost::asio::serial_port> serial_port_ptr; 
+typedef boost::shared_ptr<boost::thread> thread_ptr;
+typedef boost::shared_ptr<boost::asio::serial_port> serial_port_ptr;
+typedef boost::shared_ptr<boost::asio::deadline_timer> timer_ptr;
 
 class SerialPort
 {
 private:
     boost::asio::io_service ioService;
+    thread_ptr thread;
     serial_port_ptr port;
     boost::system::error_code ec;
     boost::mutex mutex;
+    timer_ptr timer;
     std::function<void(int)> readCb;
     bool isStarted = false;
 
     SerialPort(const SerialPort &p);
     SerialPort &operator=(const SerialPort &p);
 
     void onRead(const boost::system::error_code &ec, size_t bytesRead);
+    void onReadWithTimeout(const boost::system::error_code &ec,
+        size_t bytesRead);
+    void onTimeout(const boost::system::error_code &e);
 
 public:
     SerialPort();
@@ -41,6 +48,8 @@ class SerialPort
     int write(const char *buf, int size);
     int read(char *buf, int size);
     int asyncRead(char *buf, int size, std::function<void(int)> cb);
+    int asyncReadWithTimeout(char *buf, int size, std::function<void (int)> cb,
+        int timeout);
     std::string errorString();
 };