usb-asio

A libusb wrapper for Asio. Header-only, supports both standalone and boost versions of Asio. Requires a C++20 compiler (only tested on gcc-10). This is an early version, some features might not work as expected.

Using with standalone Asio

By default, boost version of Asio is used. To use standalone asio:

• When using as a conan package, add -o usb_asio:asio=standalone.
• When using as a cmake subproject, add -DUSB_ASIO_USE_STANDALONE_ASIO=ON

• Otherwise, define USB_ASIO_USE_STANDALONE_ASIO.

  Example

  Find a device with a given VID and PID, and read some data from the bulk endpoint 3 at interface 1 with alt setting 2.

  
  #include <usb_asio/usb_asio.hpp>

auto main() -> int { auto ctx = asio::io_context{};

auto future = asio::co_spawn(
    ctx.get_executor(),
    [&]() -> asio::awaitable<int> {
        auto dev = usb_asio::usb_device{ctx};

        for (auto const& dev_info : usb_asio::list_usb_devices(ctx))
        {
            auto const desc = dev_info.device_descriptor();
            if (desc.idVendor == 0xABCDu && desc.idProduct == 0x1234u)
            {
                dev.open(dev_info);
            }
        }

        if (dev.is_open())
        {
            auto const interface_number = std::uint8_t{1};
            // Claim the interface
            auto interface = usb_asio::usb_interface{
                dev, interface_number};

            auto const alt_setting_number = std::uint8_t{2};
            // Set interface alt setting
            co_await interface.async_set_alt_setting(
                alt_setting_number, asio::use_awaitable);

            auto const endpoint_number = std::uint8_t{3};
            auto const timeout = std::chrono::seconds{1};
            auto transfer = usb_asio::usb_in_bulk_transfer{
                dev, endpoint_number, timeout};

            auto buff = std::array<char, 512>{};
            // Read from the bulk endpoint 
            auto const n = co_await transfer.async_read_some(
                asio::buffer(buff), asio::use_awaitable);

            std::cout << std::string_view{buff.data(), n} << "\n";

            // Unclaim the interface (otherwise the destructor would
            // do this synchronously, blocking the executor).
            // If you do not care about resetting the interface,
            // you can call interface.release() instead.
            co_await interface.async_unclaim(asio::use_awaitable);

            co_return EXIT_SUCCESS;
        }

        co_return EXIT_FAILURE;
    },
    asio::use_future);

ctx.run();

return future.get();

}