MAVCONN library

It is mavlink connection and communication library used in MAVROS. Since 2014-11-02 it adopted to use outside from ROS environment by splitting to individual package and removing dependencies to rosconsole.

See the MAVROS documentation and the libmavconn API reference for more details.

Connection URL

Connection defined by URL. Just pass one of that URL to MAVConnInterface::open_url() and get connection object.

Supported schemas:

• Serial: /path/to/serial/device[:baudrate]
• Serial: serial:///path/to/serial/device[:baudrate][?ids=sysid,compid]
• Serial with hardware flow control: serial-hwfc:///path/to/serial/device[:baudrate][?ids=sysid,compid]
• UDP: udp://[bind_host][:port]@[remote_host][:port][/?ids=sysid,compid]
• UDP broadcast until GCS discovery: udp-b://[bind_host][:port]@[:port][/?ids=sysid,compid]
• UDP broadcast (permanent): udp-pb://[bind_host][:port]@[:port][/?ids=sysid,compid]
• TCP client: tcp://[server_host][:port][/?ids=sysid,compid]
• TCP server: tcp-l://[bind_port][:port][/?ids=sysid,compid]

Note: ids from URL overrides ids given by system_id & component_id parameters.

Dependencies

Same as for mavros:

• Linux host
• Asio library ( https://think-async.com/Asio/ )
• console-bridge library
• compiler with C++20 support

Shared io_service (optional)

By default each connection owns and runs its own asio::io_service thread. For multi-connection setups you can provide a shared asio::io_service and run it from your own thread pool.

#include <asio.hpp>
#include <mavconn/interface.hpp>

asio::io_service shared_io;
auto work = std::make_unique<asio::io_service::work>(shared_io);
std::jthread io_thread([&]() { shared_io.run(); });

auto conn = mavconn::MAVConnInterface::open_url(
  "udp://0.0.0.0:14555@127.0.0.1:14550",
  1, mavconn::MAV_COMP_ID_UDP_BRIDGE,
  [](const mavlink::mavlink_message_t *, mavconn::Framing) {},
  {},
  &shared_io);

conn->close();
work.reset();
shared_io.stop();

License

Licensed under terms of LGPLv3, BSD, or GPLv3.

Changelog for package libmavconn

2.15.1 (2026-08-22)

• libmavconn: fix serial baudrate parsing above uint16 url_parse_host hardcoded a uint16 port limit and error label, which rejected serial baudrates above 65535 (e.g. 921600) with a misleading 'invalid port value' error. Make the value range and field name configurable and allow baudrate to use the full int range. Adds a regression test covering a high valid baudrate and invalid zero/non-numeric baudrates. Fix #2265
• Merge pull request #2260 from mavlink/fix-deprecations Fix deprecations
• libmavconn: fix deprecated literal operator whitespace
• libmavconn: avoid -Wformat-security in format() with no args
• Contributors: Vladimir Ermakov

2.15.0 (2026-08-08)

• Merge pull request #2259 from mavlink/docs-refresh docs: refresh, refactor extractor

• docs: refresh subpackage READMEs

  - mavros: point the API docs link at readthedocs/plugin reference instead of the dead wiki.ros.org page; fix ROS1 roslaunch examples to ros2 launch; note that up-to-date install instructions live in the readthedocs guide.

  • mavros_extras: link to the full plugin reference.
  • libmavconn: link to the docs and API reference.
  • mavros_msgs: add the missing README (message/service overview + API links).
  • test_mavros: mark the ROS1-era SITL hand-tests as historical.

• Merge pull request #2256 from mavlink/try-optimize-router Optimize MAVROS router and MAVConn send path

• libmavconn: speed up utils::format with a stack-buffer fast path The old format() called snprintf twice (once to measure, once to fill) and wrote through &ret.front()/capacity(), which is UB for empty output. Format into a small stack buffer first (single snprintf), re-formatting into a heap string only when the output exceeds it. Handles encoding errors and the empty-output case.

• libmavconn: skip send post when chain active, use composed async_write Only the producer that turns the tx queue from idle to active posts a send handler; an in-progress chain drains everything enqueued meanwhile. This removes the per-message asio::post handler allocation and shared_from_this churn on the send path in steady state. Use composed asio::async_write for TCP/serial so partial writes are handled internally, deleting the manual MsgBuffer::pos tracking and resend loop (and the fragile capture of a reference into the tx queue).

• libmavconn: fix serial close deadlock, add serial pair benchmark MAVConnSerial::close() held mutex while joining the io thread, while the io thread (do_read error handler) blocked on that same mutex -> deadlock. Release the mutex before shutdown_owned(), matching UDP/TCP. Add a serial throughput benchmark case over a socat PTY,link=... pair (stable device paths for both ends), now that the close hang is fixed. UDP/TCP/serial pair throughput all benchmark cleanly.

• libmavconn: add tcp pair benchmark, make benchmark standalone Add a TCP client/server pair throughput case next to the UDP one, and rename the UDP case MavconnUdpBenchmark for naming consistency. The benchmark is kept as a standalone executable (not a CI test) because the MAVConn async close/shutdown race intermittently hangs the TCP case under the test harness; run it manually to check mavconn hot-path regressions. A serial (tty) case was attempted over a socat pty pair but dropped: it works in isolation yet reproduces the same intermittent close() hang, and the pty master has no clean device path for a second MAVConnSerial.

• libmavconn: add end-to-end transport pair benchmark A sender/receiver MAVConn UDP pair over loopback measuring sustained message throughput through the full send (enqueue + async send) and receive (async recv + parse_buffer + callback) paths, to catch mavconn hot-path regressions.

• libmavconn: revert pool allocator experiment (benchmark showed it slower) benchmark (deque<MsgBuffer> push/pop, ros2-lyrical, 16-core): PushPopPlain ~71 ns/op PushPopPool ~175 ns/op (~2.5x slower) PushPopPlainInline ~73 ns/op PushPopPoolInline ~185 ns/op (still ~2.5x slower even when the queue fits entirely in the inline chunk) The overhead is intrinsic per-op (chunk_of, free_list_ vector ops, in_use counters, shrink_if_idle on every release); glibc's tcache malloc/free is faster than the hand-rolled pool even for same-size blocks. Restore plain std::deque<MsgBuffer>.

• libmavconn: experiment: pool the tx queue MsgBuffer nodes Back std::deque<MsgBuffer> with a chunked pool allocator: the first 32 blocks come from one contiguous inline array (zero alloc), further blocks from heap chunks freed when the queue drains back to

File truncated at 100 lines see the full file