Minor changes for YModemReceive with timers and signals

TimeoutSerial.cpp

@@ -73,9 +73,9 @@ void TimeoutSerial::setTimeout(const boost::posix_time::time_duration& t)
     timeout=t;
 }
 
-void TimeoutSerial::write(const char *data, size_t size)
+size_t TimeoutSerial::write(const char *data, size_t size)
 {
-    asio::write(port,asio::buffer(data,size));
+    return asio::write(port,asio::buffer(data,size));
 }
 
 void TimeoutSerial::write(const std::vector<char>& data)
@@ -88,7 +88,7 @@ void TimeoutSerial::writeString(const std::string& s)
     asio::write(port,asio::buffer(s.c_str(),s.size()));
 }
 
-void TimeoutSerial::read(char *data, size_t size)
+size_t TimeoutSerial::read(char *data, size_t size)
 {
     if(readData.size()>0)//If there is some data from a previous read
     {
@@ -97,7 +97,7 @@ void TimeoutSerial::read(char *data, size_t size)
         is.read(data,toRead);
         data+=toRead;
         size-=toRead;
-        if(size==0) return;//If read data was enough, just return
+        if(size==0) return 0;//If read data was enough, just return
     }
     
     setupParameters=ReadSetupParameters(data,size);
@@ -120,7 +120,7 @@ void TimeoutSerial::read(char *data, size_t size)
         {
             case resultSuccess:
                 timer.cancel();
-                return;
+                return this->bytesTransferred;
             case resultTimeoutExpired:
                 port.cancel();
                 throw(timeout_exception("Timeout expired"));

TimeoutSerial.h

@@ -101,7 +101,7 @@ public:
      * \param size array size
      * \throws boost::system::system_error if any error
      */
-    void write(const char *data, size_t size);
+    size_t write(const char *data, size_t size);
 
      /**
      * Write data
@@ -126,7 +126,7 @@ public:
      * \throws boost::system::system_error if any error
      * \throws timeout_exception in case of timeout
      */
-    void read(char *data, size_t size);
+    size_t read(char *data, size_t size);
 
     /**
      * Read some data, blocking
@@ -227,6 +227,7 @@ private:
     boost::asio::io_service io; ///< Io service object
     boost::asio::serial_port port; ///< Serial port object
     boost::asio::deadline_timer timer; ///< Timer for timeout
+
     boost::posix_time::time_duration timeout; ///< Read/write timeout
     boost::asio::streambuf readData; ///< Holds eventual read but not consumed
     enum ReadResult result;  ///< Used by read with timeout

YmodemFileReceive.cpp

@@ -14,21 +14,22 @@ using namespace boost;
 #define WRITE_TIME_OUT  (100)
 
 YmodemFileReceive::YmodemFileReceive() :
+    io(), readTimer(io), writeTimer(io)
 {
     setTimeDivide(499);
     setTimeMax(5);
     setErrorMax(999);
 
-    //connect(readTimer, SIGNAL(timeout()), this, SLOT(readTimeOut()));
+    readTimer.async_wait(readTimeOut);
-    //connect(writeTimer, SIGNAL(timeout()), this, SLOT(writeTimeOut()));
+    writeTimer.async_wait(writeTimeOut);
 }
 
 YmodemFileReceive::~YmodemFileReceive()
 {
-    delete file;
+   // delete file;
-    delete readTimer;
+   // delete readTimer;
-    delete writeTimer;
+   // delete writeTimer;
-    delete serialPort;
+   // delete serialPort;
 }
 
 void YmodemFileReceive::setFilePath(const string &path)
@@ -51,13 +52,13 @@ bool YmodemFileReceive::startReceive()
     progress = 0;
     status   = StatusEstablish;
 
-    serialPort->setTimeout(posix_time::seconds(10));
+    serialPort->setTimeout(posix_time::seconds(0));
     return true;
 }
 
 void YmodemFileReceive::stopReceive()
 {
-    file->close();
+    file.close();
     abort();
     status = StatusAbort;
 }
@@ -72,26 +73,27 @@ Ymodem::Status YmodemFileReceive::getReceiveStatus()
     return status;
 }
 
-/*
+
-void YmodemFileReceive::readTimeOut()
+void YmodemFileReceive::readTimeOut(const boost::system::error_code& e)
 {
-    readTimer->stop();
+    readTimer.cancel();
 
     receive();
 
     if((status == StatusEstablish) || (status == StatusTransmit))
     {
-        readTimer->start(READ_TIME_OUT);
+        readTimer.expires_from_now(boost::posix_time::millisec(READ_TIME_OUT));
+        readTimer.async_wait(readTimeOut);
     }
 }
 
-void YmodemFileReceive::writeTimeOut()
+void YmodemFileReceive::writeTimeOut(const boost::system::error_code& e)
 {
-    writeTimer->stop();
+    writeTimer.cancel();
     serialPort->close();
     receiveStatus(status);
 }
-*/
+
 Ymodem::Code YmodemFileReceive::callback(Status status, uint8_t *buff, uint32_t *len)
 {
     switch(status)
@@ -136,7 +138,8 @@ Ymodem::Code YmodemFileReceive::callback(Status status, uint8_t *buff, uint32_t
                 {
                     YmodemFileReceive::status = StatusError;
 
-                    writeTimer->start(WRITE_TIME_OUT);
+                    writeTimer.expires_from_now(boost::posix_time::millisec(WRITE_TIME_OUT));
+                    writeTimer.async_wait(writeTimeOut);
 
                     return CodeCan;
                 }
@@ -145,7 +148,8 @@ Ymodem::Code YmodemFileReceive::callback(Status status, uint8_t *buff, uint32_t
             {
                 YmodemFileReceive::status = StatusError;
 
-                writeTimer->start(WRITE_TIME_OUT);
+                writeTimer.expires_from_now(boost::posix_time::millisec(WRITE_TIME_OUT));
+                writeTimer.async_wait(writeTimeOut);
 
                 return CodeCan;
             }
@@ -155,13 +159,13 @@ Ymodem::Code YmodemFileReceive::callback(Status status, uint8_t *buff, uint32_t
         {
             if((fileSize - fileCount) > *len)
             {
-                file->write((char *)buff, *len);
+                file.write((char *)buff, *len);
 
                 fileCount += *len;
             }
             else
             {
-                file->write((char *)buff, fileSize - fileCount);
+                file.write((char *)buff, fileSize - fileCount);
 
                 fileCount += fileSize - fileCount;
             }
@@ -178,22 +182,25 @@ Ymodem::Code YmodemFileReceive::callback(Status status, uint8_t *buff, uint32_t
 
         case StatusFinish:
         {
-            file->close();
+            file.close();
 
             YmodemFileReceive::status = StatusFinish;
 
-            writeTimer->start(WRITE_TIME_OUT);
+            writeTimer.expires_from_now(boost::posix_time::millisec(WRITE_TIME_OUT));
+            writeTimer.async_wait(writeTimeOut);
 
             return CodeAck;
         }
 
         case StatusAbort:
         {
-            file->close();
+            file.close();
 
             YmodemFileReceive::status = StatusAbort;
 
-            writeTimer->start(WRITE_TIME_OUT);
+
+            writeTimer.expires_from_now(boost::posix_time::millisec(WRITE_TIME_OUT));
+            writeTimer.async_wait(writeTimeOut);
 
             return CodeCan;
         }
@@ -202,18 +209,20 @@ Ymodem::Code YmodemFileReceive::callback(Status status, uint8_t *buff, uint32_t
         {
             YmodemFileReceive::status = StatusTimeout;
 
-            writeTimer->start(WRITE_TIME_OUT);
+            writeTimer.expires_from_now(boost::posix_time::millisec(WRITE_TIME_OUT));
+            writeTimer.async_wait(writeTimeOut);
 
             return CodeCan;
         }
 
         default:
         {
-            file->close();
+            file.close();
 
             YmodemFileReceive::status = StatusError;
 
-            writeTimer->start(WRITE_TIME_OUT);
+            writeTimer.expires_from_now(boost::posix_time::millisec(WRITE_TIME_OUT));
+            writeTimer.async_wait(writeTimeOut);
 
             return CodeCan;
         }

YmodemFileReceive.h

@@ -4,6 +4,8 @@
 #include "TimeoutSerial.h"
 #include "Ymodem.h"
 #include <boost/signals2.hpp>
+#include <boost/utility.hpp>
+#include <boost/asio.hpp>
 #include <iostream>
 #include <fstream>
 #include <string>
@@ -30,11 +32,10 @@ public:
 
     boost::signals2::signal<void (int)> receiveProgress;
     boost::signals2::signal<void (YmodemFileReceive::Status status)> receiveStatus;
-/*
+
-private slots:
+    void readTimeOut(const boost::system::error_code& e);
-    void readTimeOut();
+    void writeTimeOut(const boost::system::error_code& e);
-    void writeTimeOut();
+
-*/
 private:
     Code callback(Status status, uint8_t *buff, uint32_t *len);
 
@@ -42,8 +43,9 @@ private:
     uint32_t write(uint8_t *buff, uint32_t len);
 
     ofstream       file;
-    QTimer      *readTimer;
+    boost::asio::io_service io; ///< Io service object
-    QTimer      *writeTimer;
+    boost::asio::deadline_timer readTimer; ///< Timer for timeout
+    boost::asio::deadline_timer writeTimer; ///< Timer for timeout
     TimeoutSerial *serialPort;
 
     int      progress;