web-dev-qa-db-ja.com

asio :: readとタイムアウト

タイムアウトを使用して読み取る方法（同期または非同期は関係ありません）を知る必要があります。デバイスがシリアルポートに接続されているかどうかを確認したい。

そのために_asio::write_を使用し、デバイスの応答を待ちます。

デバイスが接続されている場合はasio::read(serial, boost::asio::buffer(&r,1))は正常に機能しますが、デバイスがない場合はプログラムが停止します。そのため、タイムアウトが必要です。

_deadline_timer_が必要なことは知っていますが、_async_read_関数でどのように使用するかわかりません。

それがどのように機能するかの例は本当に役に立ちます。

似たようなスレッドがたくさんあることを知っていて、それらをたくさん読んでいますが、問題を解決するのに役立つ解決策が見つかりません！

c++boosttimeoutserial-portboost-asio
15
Chris K.

Igor Rによって投稿されたコード は私のためにコンパイルされませんでした。これが彼のコードの私の改良版で、完璧に機能します。ラムダを使用して、set_resultヘルパー関数を取り除きます。

template <typename SyncReadStream, typename MutableBufferSequence>
void readWithTimeout(SyncReadStream& s, const MutableBufferSequence& buffers, const boost::asio::deadline_timer::duration_type& expiry_time)
{
    boost::optional<boost::system::error_code> timer_result;
    boost::asio::deadline_timer timer(s.get_io_service());
    timer.expires_from_now(expiry_time);
    timer.async_wait([&timer_result] (const boost::system::error_code& error) { timer_result.reset(error); });

    boost::optional<boost::system::error_code> read_result;
    boost::asio::async_read(s, buffers, [&read_result] (const boost::system::error_code& error, size_t) { read_result.reset(error); });

    s.get_io_service().reset();
    while (s.get_io_service().run_one())
    { 
        if (read_result)
            timer.cancel();
        else if (timer_result)
            s.cancel();
    }

    if (*read_result)
        throw boost::system::system_error(*read_result);
}
11
Robert Hegner

deadline_timerでasync_readを使用しません。ただし、2つの非同期プロセスを開始できます。

  1. シリアルポートのasync_readプロセス。 boost :: asio :: serial_port には cancel メソッドがあり、すべての非同期操作をキャンセルします。
  2. 必要なタイムアウトのある期限タイマー。 deadline_timerの完了ハンドラーで、シリアルポートをcancelできます。これにより、async_read操作が閉じられ、エラーでその完了ハンドラーが呼び出されます。

コード：

#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/array.hpp>

class timed_connection
{
    public:
        timed_connection( int timeout ) :
            timer_( io_service_, boost::posix_time::seconds( timeout ) ),
            serial_port_( io_service_ )
        {
        }

        void start()
        {
              timer_.async_wait
                (
                 boost::bind
                 (
                  &timed_connection::stop, this
                 )
                );

            // Connect socket
            // Write to socket

            // async read from serial port
            boost::asio::async_read
                (
                 serial_port_, boost::asio::buffer( buffer_ ),
                 boost::bind
                 (
                  &timed_connection::handle_read, this,
                  boost::asio::placeholders::error
                 )
                );

            io_service_.run();
        }

    private:
        void stop()
        {  
            serial_port_.cancel();
        }

        void handle_read ( const boost::system::error_code& ec)
        {  
            if( ec )
            {  
                // handle error
            }
            else
            {  
                // do something
            }
        }

    private:
        boost::asio::io_service io_service_;
        boost::asio::deadline_timer timer_;
        boost::asio::serial_port serial_port_;
        boost::array< char, 8192 > buffer_;
};

int main()
{
    timed_connection conn( 5 );
    conn.start();

    return 0;
}
6
Vikas

昔々、図書館の作者は次の方法を提案しました タイムアウトと同期して読み取るため （この例にはtcp::socketが含まれますが、代わりにシリアルポートを使用できます）：

  void set_result(optional<error_code>* a, error_code b) 
  { 
    a->reset(b); 
  } 


  template <typename MutableBufferSequence> 
  void read_with_timeout(tcp::socket& sock, 
      const MutableBufferSequence& buffers) 
  { 
    optional<error_code> timer_result; 
    deadline_timer timer(sock.io_service()); 
    timer.expires_from_now(seconds(1)); 
    timer.async_wait(boost::bind(set_result, &timer_result, _1)); 


    optional<error_code> read_result; 
    async_read(sock, buffers, 
        boost::bind(set_result, &read_result, _1)); 

    sock.io_service().reset(); 
    while (sock.io_service().run_one()) 
    { 
      if (read_result) 
        timer.cancel(); 
      else if (timer_result) 
        sock.cancel(); 
    } 


    if (*read_result) 
      throw system_error(*read_result); 
  }
5
Igor R.

非同期読み取りを行っても、コールバックが呼び出されることはなく、どこかに緩いスレッドがあるため、それ自体は誰もeasyの答えもありません。 。

あなたはdeadline_timerは可能な解決策の1つですが、いじくり回して共有状態にする必要があります。 blocking TCP example がありますが、それはasync_connectそしてそれが何の関係もないときに戻ることについてのクールなことがあります。 readはそれを行いません、最悪のシナリオ-無効なリソースが原因でクラッシュして書き込みます。したがって、deadline timerものはあなたの選択肢の1つですが、実際にはもっと簡単なものがあり、それは次のようになります。

boost::thread *newthread = new boost::thread(boost::bind(&::try_read));
if (!newthread->timed_join(boost::posix_time::seconds(5))) {
    newthread->interrupt();
}

基本的に、別のスレッドで読み取りを行い、タイムアウトした場合は強制終了します。 Boost.Threads を読んでください。

中断する場合は、リソースがすべて閉じていることを確認してください。

0
TC1