Wie führe ich einen nicht blockierenden Lesen über asio?

Haben Sie ein paar Optionen, eigentlich. Sie können entweder den seriellen port integrierte async_read_some - Funktion, oder verwenden Sie die stand-alone-Funktion boost::asio::async_read (oder async_read_some).

Du wirst immer in die situation, wo Sie sind gewissermaßen "blockiert", da keiner von diesen rufen die callback-es sei denn, (1) Daten, die gelesen worden ist oder (2) ein Fehler Auftritt. Um dies zu umgehen, werden Sie wollen, zu einem deadline_timer Gegenstand, um ein timeout. Wenn der timeout feuert zuerst, keine Daten verfügbar. Andernfalls müssen Sie die Daten Lesen.

Die zusätzliche Komplexität ist nicht wirklich schlecht. Sie werden am Ende mit zwei Rückrufe mit ähnlichen Verhalten. Wenn entweder "Lesen" oder "timeout" callback feuert mit einem Fehler, wissen Sie, es ist das Rennen der Verlierer. Wenn man entweder feuert ohne Fehler, dann wissen Sie, es ist der Gewinner des Rennens (und sollten Sie Abbrechen, die anderen nennen). In dem Ort, wo Sie hätte Ihre blockierenden Aufruf zu read_some Sie haben nun einen Aufruf io_svc.run(). Ihre Funktion wird immer noch blockiert nach wie vor, wenn er fordert run, aber dieses mal Steuern Sie die Dauer.

Hier ein Beispiel:

void foo()
{
  io_service     io_svc;
  serial_port    ser_port(io_svc, "your string here");
  deadline_timer timeout(io_svc);
  unsigned char  my_buffer[1];
  bool           data_available = false;

  ser_port.async_read_some(boost::asio::buffer(my_buffer),
      boost::bind(&read_callback, boost::ref(data_available), boost::ref(timeout),
                  boost::asio::placeholders::error,
                  boost::asio::placeholders::bytes_transferred));
  timeout.expires_from_now(boost::posix_time::milliseconds(<<your_timeout_here>>));
  timeout.async_wait(boost::bind(&wait_callback, boost::ref(ser_port),
                  boost::asio::placeholders::error));

  io_svc.run();  //will block until async callbacks are finished

  if (!data_available)
  {
    kick_start_the_device();
  }
}

void read_callback(bool& data_available, deadline_timer& timeout, const boost::system::error_code& error, std::size_t bytes_transferred)
{
  if (error || !bytes_transferred)
  {
    //No data was read!
    data_available = false;
    return;
  }

  timeout.cancel();  //will cause wait_callback to fire with an error
  data_available = true;
}

void wait_callback(serial_port& ser_port, const boost::system::error_code& error)
{
  if (error)
  {
    //Data was read and this timeout was canceled
    return;
  }

  ser_port.cancel();  //will cause read_callback to fire with an error
}

Dass sollte Ihnen den Einstieg mit nur ein paar tweaks hier und da an Ihre speziellen Bedürfnisse anpassen. Ich hoffe, das hilft!

Noch ein Hinweis: es gibt Keine zusätzlichen threads notwendig waren, Rückrufe zu handhaben. Alles geschieht im Aufruf run(). Nicht sicher, ob du schon bewusst...

InformationsquelleAutor Brian

Seine eigentlich viel einfacher als die Antworten, die Sie hier angedeutet haben, und Sie können es synchron:

Angenommen, Ihre Blockierung zu Lesen, war etwas wie:

size_t len = socket.receive_from(boost::asio::buffer(recv_buf), sender_endpoint);

Dann ersetzen Sie es mit

socket.non_blocking(true);
size_t len = 0;
error = boost::asio::error::would_block;
while (error == boost::asio::error::would_block)
    //do other things here like go and make coffee
    len = socket.receive_from(boost::asio::buffer(recv_buf), sender_endpoint, 0, error);
std::cout.write(recv_buf.data(), len);

Verwenden Sie die alternative überlastet form von receive_from, die fast alle die send/receive-Methoden haben. Leider nehmen flags-argument, aber 0 scheint gut zu funktionieren.

InformationsquelleAutor S.N.