如何在此环境中设置deadline_timer？

Question

我有点迷失在图书馆的建设中，我不得不纠缠在一起。我需要帮助来介绍一些定时器到这个构造中。

我有以下：

• com.cpp具有main并且包括com.hpp
• com.hpp其包括host.h，需要升压包括并定义了一个类comClient
• host.c与包括host.h
• wrapper.cpp与包括com.hpp和一些必要的升压包括

现在，我com.cpp是创建一个comClient和用途它用于com端口上的异步通信。使用boost::asio::serial_port和boost::asio::io_service。

我需要与一些计时器一起工作，以便在传感器需要太长时间时才能发现。

当创建comClient的实例时，应该初始化参数计时器。

在私有函数使用asynch_read_some comClient，我叫comClient的私人处理，那么这个处理程序调用host.c，这就要求对wrapper.cpp一个函数的函数重新启动计时器。

这是给init定时器功能：

//wrapper.cpp 
void IniPacketTimer(void *pCHandle){ 

    boost::asio::io_service io; 
    boost::asio::deadline_timer t(io, boost::posix_time::milliseconds(25)); 
    t.async_wait(&hostOnTimeout(pCHandle)); 
    io.run(); 
} 

这将是短期的命令链：

//comClient.cpp 
main{ 
    comClient cc(); 
} 
//comClient.hpp 
class comClient(boost::asio::io_service& io_service){ 
    comClient(){ 
    hostInit(); 
    aread(); 
    } 
    private: 
    aread(call aread_done) 
    areaddone(call hostNewData()) 
} 

//host.c 
hostInit(){ 
    IniPacketTimer() 
} 
hostNewData(){ 
    resetTimer 
} 

//wrapper.cpp 
resetTimer(){ 
    t.expires_from_now 
} 

问题：

我如何提供异步定时器，它不会影响串行端口上的异步读/写操作，但会在截止时间为h时触发函数的执行它？

我应该使用已有的io_service还是没关系，如果我只是创建另一个？

为什么我得到一个错误C2102'&'预计我的行的L值为t.async_wait？

Answer 1

你的问题并不清楚，既然你没有发布实际的代码，很难猜测你的问题是什么。
特别是你的线程不清楚，但对于asio非常重要。

下面是一个将编译但不运行的例子。我希望它给你提示如何继续。
它会打开一个串口和一个计时器。每当定时器到期时，它将启动一个新的。这是我前段时间使用的代码的简化版本，所以也许它会帮助你。

#include <boost/asio.hpp> 
#include <boost/asio/serial_port.hpp> 
#include <boost/function.hpp> 
#include <boost/bind.hpp> 
#include <vector> 


class SerialCommunication 
{ 
    public: 
    SerialCommunication(boost::asio::io_service& io_service, const std::string& serialPort) 
     : m_io_service(io_service) 
     , m_serialPort(m_io_service) 
     , m_timeoutTimer(m_io_service, boost::posix_time::milliseconds(5)) 
    { 
     configureSerialPort(serialPort); 
    } 

    void configureSerialPort(const std::string& serialPort) 
    { 
     if(m_serialPort.is_open()) 
     { 
      m_serialPort.close(); 
      m_timeoutTimer.cancel(); 
     } 
     boost::system::error_code ec; 
     m_serialPort.open(serialPort, ec); 
     if(m_serialPort.is_open()) 
     { 
      // start Timer 
      m_timeoutTimer.async_wait(boost::bind(&SerialCommunication::TimerExpired, this, _1)); 
      header_sync(); 
     } 
    } 

    void header_sync() 
    { 
     m_serialPort.async_read_some(boost::asio::buffer(&m_header.back(), 1), 
      boost::bind(&SerialCommunication::header_sync_complete, this, 
        boost::asio::placeholders::error, 
        boost::asio::placeholders::bytes_transferred)); 
    } 

    void header_sync_complete(
     const boost::system::error_code& error, size_t bytes_transferred) 
    { 
     // stripped 
     read_payload(&m_payload[0], 0); 
    } 


    void read_payload(uint8_t* buffer, uint8_t length) 
    { 
     m_serialPort.async_read_some(boost::asio::buffer(buffer, length), 
      boost::bind(&SerialCommunication::payload_read_complete, this, 
        boost::asio::placeholders::error, 
        boost::asio::placeholders::bytes_transferred)); 
    } 

    void payload_read_complete(
     const boost::system::error_code& error, size_t bytes_transferred) 
    { 
     // stripped 
     // timer cancel and reset 
     m_timeoutTimer.cancel(); 
     m_timeoutTimer.expires_at(boost::posix_time::microsec_clock::local_time() + 
          boost::posix_time::milliseconds(5)); 
     m_timeoutTimer.async_wait(boost::bind(&SerialCommunication::TimerExpired, this, _1)); 
     memset(&m_header[0], 0, 3); 
     header_sync(); 
    } 

    void TimerExpired(const boost::system::error_code& e) 
    { 
     m_timeoutTimer.expires_at(m_timeoutTimer.expires_at() + boost::posix_time::milliseconds(5)); 
     m_timeoutTimer.async_wait(boost::bind(&SerialCommunication::TimerExpired, this, _1)); 
    } 

    boost::asio::io_service& m_io_service; 
    boost::asio::deadline_timer m_timeoutTimer; 
    boost::asio::serial_port m_serialPort; 
    std::vector<uint8_t> m_header; 
    std::vector<uint8_t> m_payload; 
}; 



int main() 
{ 
    boost::asio::io_service io_service; 
    SerialCommunication cc(io_service, "/dev/ttyS0"); 

    io_service.run(); 
    return 0; 
}