使用 boost::asio::async_wait_until 和 boost::asio::streambuf

Question

我目前正在开发一个应用程序，用于与使用串行通信的设备进行通信。为此，我使用了 boost 库 basic_serial_port。现在，我只是尝试从设备中读取数据，并且正在使用 async_wait_until 函数以及 deadline_timer 类中的 async_wait。设置读取和等待的代码如下所示：

async_read_until(port,readData,io_params.delim,
                  boost::bind(&SerialComm::readCompleted,
                  this,boost::asio::placeholders::error,
                  boost::asio::placeholders::bytes_transferred));

timer.expires_from_now(boost::posix_time::seconds(1));
timer.async_wait(boost::bind(&SerialComm::timeoutExpired,this,
                 boost::asio::placeholders::error));

async_read_until 上的回调看起来像

void SerialComm::readCompleted(const boost::system::error_code& error,
                               const size_t bytesTransferred){
    if (!error){
        wait_result = success;
        bytes_transferred = bytesTransferred;
    }
    else {
        if (error.value() != 125) wait_result = error_out;
        else wait_result = op_canceled;

        cout << "Port handler called with error code " + to_string(error.value()) << endl;
    }

}

成功读取后触发以下代码

string msg;
getline(istream(&readData), msg, '\r');
boost::trim_right_if(msg, boost::is_any_of("\r"));

在此设备的情况下，所有消息都以回车结束，因此在async_read_until 中指定回车应该检索单个消息。但是，我看到的是，在触发处理程序时，新数据不一定会输入缓冲区。所以，我可能看到的是，如果处理程序被触发 20x

• 在第一次调用中将一条线泵入缓冲区
• 在接下来的 6 次调用中都没有
• 下次调用6行
• 接下来的 10 天没有数据
• 10 行以下 ...

我显然没有正确地做某事，但它是什么？

Answer 1

所以，这里发现了问题。这个程序的工作方式是它应该

1. 发送数据请求
2. 启动async_read_until 以读取端口上的数据。
3. 启动async_wait，这样我们就不会永远等待。
4. 使用io_service::run_one 等待超时或成功读取。

第四步的代码看起来如下：

for (;;){
    // This blocks until an event on io_service_ is set.
    n_handlers = io_service_.run_one();


    // Brackets in success case limit scope of new variables
    switch(wait_result){
    case success:{

        char c_[1024];
        //string msg;
        string delims = "\r";

        std::string msg{buffers_begin(readData.data()), buffers_begin(readData.data()) + bytes_transferred- delims.size()};
            // Consume through the first delimiter.
            readData.consume(bytes_transferred);

        data_out = msg;
        cout << msg << endl;

        data_handler(msg);

        return data_out;

        }
    case timeout_expired:

        //Set up for wait and read.
        wait_result = in_progress;
        cout << "Time is up..." << endl;
        return data_out;
        break;
    case error_out:
        cout << "Error out..." << endl;
        return data_out;
        break ;
    case op_canceled:
        return data_out;
        break;

    case in_progress:
        cout << "In progress..." << endl;
        break;
    }

}

只有两种情况会触发退出循环 - timeout_expired 和 success。但是，如您所见，如果操作被取消（op_canceled）或如果出现错误（error_out），系统将退出。

问题在于，当异步操作被取消（即deadline_timer::cancel()）时，它将触发io_service::run_one 拾取的事件，这会将switch 语句评估的状态设置为op_canceled。这会使异步操作在事件循环中堆积。简单的解决方法是在 所有 情况下将 return 语句注释掉，success 和 timeout_expired 除外。

Answer 2

async_read_until 不保证它只会读到第一个分隔符。

由于底层的实现细节，它只会在大多数系统上“读取可用的内容”，如果 streambuf 包含分隔符，它将返回。 其他数据将在流缓冲区中。此外，EOF 可能会返回，即使您还没有预料到。

查看背景Read until a string delimiter in boost::asio::streambuf