asio :: टाइमआउट

Question

के साथ पढ़ें मुझे टाइमआउट के साथ पढ़ने (सिंक या एसिंक कोई फर्क नहीं पड़ता) को जानने की आवश्यकता है। मैं यह जांचना चाहता हूं कि कोई डिवाइस सीरियल पोर्ट से कनेक्ट है या नहीं।

इसके लिए मैं asio::write का उपयोग करता हूं और फिर मैं डिवाइस की प्रतिक्रिया के लिए प्रतीक्षा करता हूं।

एक डिवाइस कनेक्ट asio::read(serial, boost::asio::buffer(&r,1)) है, तो ठीक काम करता है, लेकिन कोई डिवाइस कार्यक्रम बंद हो जाता है, जो वहाँ है अगर कारण है कि मैं समय समाप्ति की जरूरत

मुझे पता है कि मैं एक deadline_timer की जरूरत है, लेकिन मैं यह कैसे उपयोग करने के लिए पता नहीं है async_read फ़ंक्शन में।

यह कैसे काम करता है इसका एक उदाहरण वास्तव में सहायक होगा।

मुझे पता है कि कई समान धागे हैं और मैंने उनमें से बहुत कुछ पढ़ा है लेकिन मुझे कोई समाधान नहीं मिल रहा है जो मेरी समस्या को हल करने में मेरी सहायता करता है!

Answer 1

कोई भी या आसान उत्तर प्रति से है, क्योंकि यदि आप एसिंक पढ़ते हैं, तो भी कॉलबैक कभी नहीं बुलाया जाता है और अब आपके पास कहीं ढीला धागा है।

आप यह मानने में सही हैं कि deadline_timer संभावित समाधानों में से एक है, लेकिन यह कुछ विचित्र और साझा राज्य लेता है। blocking TCP example है, लेकिन यह async_connect के लिए है और इसके बारे में कुछ भी नहीं है जब इसे वापस करने के लिए कुछ भी नहीं है। read ऐसा नहीं करेगा, सबसे खराब स्थिति परिदृश्य - यह & अमान्य संसाधन का कारण 'बर्बाद कर देगा। तो deadline timer बात अपने विकल्पों में से एक है, लेकिन वहाँ वास्तव में एक आसान एक है, कि इस तरह कुछ हद तक चला जाता है है:

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

मूल रूप से, एक और धागा में पढ़ा करते हैं और इसे अगर यह समय समाप्त बंद मार डालते हैं। आपको Boost.Threads पर पढ़ना चाहिए।

यदि आप इसे बाधित करते हैं, तो सुनिश्चित करें कि संसाधन बंद हैं।

Answer 2

आप deadline_timerasync_read में उपयोग नहीं करते हैं। लेकिन आप दो एसिंक प्रक्रियाओं को शुरू कर सकते हैं:

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

Answer 3

एक समय की बात

, पुस्तकालय लेखक निम्नलिखित तरीके to read synchronously with timeout प्रस्तावित (इस उदाहरण 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); 
    } 

Answer 4

code posted by 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); 
}