c++ - 如何在此环境中设置 deadline_timer？

Question

我有点迷失在库的构造中，我必须将它们纠缠在一起。我需要帮助将一些计时器引入到这个结构中。

我有以下内容:

• com.cpp 具有 main 并包含 com.hpp
• com.hpp 包含一个 host.h 和所需的 boost 包括并定义一个类 comClient
• host.c 包含 host.h
• wrapper.cpp 包含 com.hpp 和一些需要的 boost 包括

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

我需要使用一些计时器，以便在数据包传输时间过长时捕捉到。

在创建 comClient 的实例时，应该初始化 paket-timer。

在 comClient 的私有(private)函数中使用 asynch_read_some，我调用 comClient 的私有(private)处理程序，然后该处理程序调用 的函数>host.c，它调用 wrapper.cpp 一个函数来重新启动计时器。

这是初始化定时器的函数:

//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
}

问题:

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

我应该使用已经存在的 io_service 还是可以，如果我只是创建另一个？

为什么我收到错误 C2102 '&' expects L-Value for my line 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;
}