AMBE Digital Voice via Radio-Attached USB Dongle — Network Passthrough Mode

Request preparation

• I used an AI assistant to help structure this request
• I checked for existing issues covering the same feature

What would you like?

Good — confirmed. SmartSDR v4.1.5 is the current release and fully supports serial passthrough (introduced in v3.9.18). The feature is stable and well-documented. Now I have everything needed to write the complete, polished GitHub issue.
Here it is, ready to paste directly into GitHub:

markdown## Title
feat: AMBE Digital Voice via Radio-Attached USB Dongle — Network Passthrough Mode

---

What

Add a network-tunneled AMBE vocoder path that lets the user plug an AMBE
USB dongle (ThumbDV, DVSI USB-3000, NW Digital AMBE-3000) into the back of
the FLEX-8600 via an FTDI USB-to-serial cable, and have AetherSDR drive it
entirely over the existing TCP command channel — with no USB connection required
at the PC side.

This is a companion to the local-USB AMBE feature (see issue #XX). Where that
issue covers the dongle plugged into the operator's PC, this issue covers the
dongle physically co-located with the radio — which is the correct architecture
for remote (SmartLink) operation and keeps the shack cable-free.

The user experience:

1. Plug FTDI USB-to-serial cable into the FLEX-8600 rear USB port.
2. Plug AMBE dongle into the other end of that cable.
3. In AetherSDR → Radio Setup → Digital Voice, click "Use radio USB port".
4. AetherSDR auto-detects the cable serial number, configures passthrough at
   460800 baud, and exchanges DVSI vocoder packets with the dongle over TCP.
5. Select DMR, D-STAR, or C4FM mode on any slice — audio decodes and encodes
   normally with no other software running.

---

Why

When the radio is operated remotely via SmartLink, there is no physical USB
port accessible at the operator's PC. The AMBE dongle must live at the radio
end. SmartSDR firmware v3.9.18 introduced USB Serial Passthrough — the
radio tunnels raw serial bytes between any FTDI-attached device and the network
client over the existing TCP command channel. AetherSDR should be the first
Linux-native client to exploit this for digital voice.

This eliminates the only hardware reason to keep a Windows PC at the radio site.
With this feature, a FLEX-8600 + AMBE dongle + FTDI cable is a complete
self-contained DMR/D-STAR/C4FM remote station reachable from any AetherSDR
client anywhere.

---

Firmware Requirement

SmartSDR firmware v3.9.18 or later is required for USB serial passthrough.
SmartSDR v4.1.5 (current release as of April 2026) fully supports this feature.

AetherSDR currently targets fw v1.4.0.0 on the FLEX-8600, which predates
passthrough. The implementation must detect the firmware capability at connect
time and degrade gracefully (show a warning in the DV applet, fall back to
local-USB mode) when passthrough is unavailable.

---

How Other Clients Do It

No other Linux/macOS amateur radio client currently implements AMBE-over-TCP
passthrough. SmartSDR for Windows routes the passthrough data through
SmartSDR CAT, which creates a virtual COM port on the Windows PC. Third-party
apps (BlueDV, PSTRotator) then open that virtual COM port as if the dongle were
locally attached.

AetherSDR does not need SmartSDR CAT or a virtual COM port. It speaks the DVSI
protocol directly over the TCP passthrough channel, giving a cleaner, lower-
latency path with no intermediate process.

---

Protocol — SmartSDR USB Passthrough API

This API was confirmed by a FlexRadio engineer in the community forum
(July 2025, thread: "SmartSDR Serial Passthrough - API Documentation").
Firmware-side tracking issue: SMART-11468.

Step 1 — Enumerate cables

C<seq>|usb_cable list

Response (S message):

S<handle>|usb_cable <serialNumber> type=<type> baud=<baud> ...

Parse <serialNumber> — this is the identifier used in all subsequent commands.

Step 2 — Configure as passthrough at 460800 baud

C<seq>|usb_cable set <serialNumber> type=passthrough baud=460800

On fw < v3.9.18 this returns a non-zero error code → show warning and abort.
On success the radio begins forwarding serial bytes in both directions.

Step 3 — Receive bytes from dongle (radio → AetherSDR)

The radio pushes incoming serial bytes as a TCP status message:

S<handle>|usb_cable data:base64 <base64encodedBytes>

Parse by checking for the literal string usb_cable data:base64 in every
incoming status line. Decode the base64 payload and append to the DVSI
receive buffer.

Step 4 — Send bytes to dongle (AetherSDR → radio → dongle)

C<seq>|usb_cable write <serialNumber> base64 <base64encodedBytes>

Encode the outgoing DVSI packet as base64 and send via the normal command
channel. Rate-limit to one packet per 20 ms (the DVSI frame period) to avoid
saturating the TCP command channel.

---

DVSI Serial Protocol (for reference)

All three supported dongles use the same DVSI packet format:

[0xEC] [len_hi] [len_lo] [type] [payload...]

type = 0x00  — control (reset, product ID)
type = 0x01  — speech:  host→dongle PCM, dongle→host AMBE
type = 0x02  — channel: host→dongle AMBE, dongle→host PCM

Baud rate: 460800, 8N1
Frame period: 20 ms
AMBE frame: 9 bytes
PCM frame:  160 × int16 @ 8 kHz = 320 bytes

Reset packet (sent on open to verify dongle alive):

EC 00 01 00 00

---

Required Hardware

Item	Notes
AMBE dongle	ThumbDV, DVSI USB-3000, or NW Digital AMBE-3000
FTDI USB-to-serial cable	Must be FTDI chipset. FlexRadio sells compatible cables. The UT232R-200 is confirmed working.
FLEX-8600 USB port	One of the two rear USB 2.0 ports

Note: The dongle cannot be plugged directly into the FLEX-8600 USB port.
The radio only supports FTDI USB-to-serial adapters, not raw USB-CDC devices.
The FTDI cable acts as a USB↔RS232 bridge; the dongle connects to its DB9
or bare-wire serial end.

Wiring:

[AMBE dongle] ←serial→ [FTDI USB-to-serial cable] ←USB→ [FLEX-8600 USB port]
                                                                ↓
                                                  usb_cable passthrough (TCP)
                                                                ↓
                                                     AmbeNetworkDriver
                                                                ↓
                                                  AmbeEngine → AudioEngine

---

Suggested Behavior in AetherSDR

Radio Setup → Digital Voice tab

┌─ AMBE Dongle ─────────────────────────────────────────────────────┐
│  Source   ( ) Local USB port    (●) Radio USB port (passthrough)  │
│                                                                    │
│  [Radio USB port]                                                  │
│  Cable     [ Auto-detect ▼ ]   [ Probe ]   ● A1B2C3 connected     │
│  Firmware  ✓ v4.1.5 — passthrough supported                       │
│                                                                    │
│  [Local USB port]                                                  │
│  Port      [ /dev/ttyUSB0 ▼ ]  [ Probe ]                          │
└───────────────────────────────────────────────────────────────────┘

AppSettings keys:

AmbeDongleSource      — "network" | "local"
AmbeUsbCableSerial    — e.g. "A1B2C3" (persisted after first probe)
AmbePortName          — local fallback port

DV Applet status badge in VFO strip

AMBE ●   — green:  passthrough active, dongle responding
AMBE ◑   — amber:  passthrough configured, waiting for dongle ping
AMBE ○   — grey:   firmware too old for passthrough (< v3.9.18)
AMBE ✕   — red:    passthrough active but dongle not responding

---

Implementation — New Source Files

src/core/
  AmbeNetworkDriver.h / .cpp   — passthrough tunnel (this issue)
  AmbeSerialDriver.h / .cpp    — local USB path (companion issue)
  AmbeEngine.h / .cpp          — mode dispatch, deframer/framer
  DmrFramer.h / .cpp
  DstarFramer.h / .cpp
  C4fmFramer.h / .cpp
src/gui/
  DvApplet.h / .cpp

---

Implementation — Full Code

src/core/AmbeNetworkDriver.h

// AmbeNetworkDriver — drives an AMBE USB dongle attached to the
// FLEX-8600 rear USB port via FTDI cable + SmartSDR passthrough.
//
// Protocol path:
//   AetherSDR TCP  →  usb_cable write  base64 
//                  →  radio firmware  →  FTDI cable  →  AMBE dongle
//   AMBE dongle    →  FTDI cable  →  radio firmware
//                  →  S|usb_cable data:base64   →  AetherSDR
//
// Requires SmartSDR fw >= v3.9.18 (USB passthrough feature).
// Tested against SmartSDR v4.1.5.
// On older firmware, probeAndConnect() emits errorOccurred() and
// the caller falls back to AmbeSerialDriver (local USB).
//
// RAII: close() is called in the destructor. No naked new/delete.
// All signals are emitted on the Qt event loop thread (no explicit
// thread hops needed — QSerialPort is not involved here).
#pragma once
#include 
#include 
#include 
#include 
#include 
#include 

class RadioConnection;

class AmbeNetworkDriver : public QObject {
    Q_OBJECT
public:
    explicit AmbeNetworkDriver(RadioConnection* conn,
                               QObject* parent = nullptr);
    ~AmbeNetworkDriver() override;

    // Call after RadioConnection is fully connected and subscriptions
    // are sent. Sends usb_cable list, then configures passthrough.
    void probeAndConnect();
    void close();

    bool isConnected() const;
    QString cableSerial() const;

    // Non-blocking. Queues a DVSI decode request (AMBE→PCM).
    // Result arrives via pcmDecoded() within ~20 ms.
    void requestDecode(const QByteArray& ambeFrame9bytes);

    // Non-blocking. Queues a DVSI encode request (PCM→AMBE).
    // Result arrives via ambeEncoded() within ~20 ms.
    void requestEncode(const QByteArray& pcm160samples_int16);

    // Wire this to RadioConnection::statusReceived(QString).
    // Filters for usb_cable status lines; ignores all others.
    void onStatusLine(const QString& line);

signals:
    void pcmDecoded(QByteArray pcm160_int16);   // 320 bytes @ 8 kHz
    void ambeEncoded(QByteArray ambeFrame);     // 9 bytes
    void connected(QString cableSerial);
    void disconnected();
    void errorOccurred(QString message);        // shown in DV applet

private slots:
    void onDrainQueue();

private:
    void handleCableList(const QString& statusBody);
    void handleIncomingBytes(const QByteArray& bytes);
    void sendRaw(const QByteArray& dvsiPacket);

    static QByteArray buildDvsiPacket(uint8_t type,
                                      const QByteArray& payload);
    static bool parseDvsiPacket(const QByteArray& buf, int offset,
                                int& consumed,
                                uint8_t& type, QByteArray& payload);

    RadioConnection* m_conn;           // not owned
    QString          m_cableSerial;
    bool             m_connected{false};
    bool             m_passthroughConfigured{false};

    QByteArray         m_rxBuf;        // accumulates raw dongle bytes
    QQueue m_txQueue;      // outgoing DVSI packets
    QMutex             m_txMutex;
    QTimer*            m_drainTimer;

    // Pace outgoing writes to the radio command channel.
    // One DVSI frame per 20 ms = 50 packets/sec max.
    // The TCP channel is shared with all SmartSDR commands;
    // bursting causes queue backup and command latency spikes.
    static constexpr int kDrainIntervalMs = 20;

    // DVSI framing constants
    static constexpr uint8_t kDvsiStart   = 0xEC;
    static constexpr uint8_t kTypeSpeech  = 0x01; // PCM→AMBE
    static constexpr uint8_t kTypeChannel = 0x02; // AMBE→PCM
    static constexpr uint8_t kTypeControl = 0x00;
};

src/core/AmbeNetworkDriver.cpp

#include "AmbeNetworkDriver.h"
#include "RadioConnection.h"
#include 
#include 

// DVSI reset packet — sent on connect to verify dongle is alive.
// Dongle echoes this back (ThumbDV) or responds with a product ID
// packet (USB-3000, NW Digital). Either reply confirms presence.
static const QByteArray kPktReset =
    QByteArray::fromHex("EC000100");

// AMBE+2 rate table entry — required for USB-3000 and NW Digital
// before the first voice frame. ThumbDV ignores this safely.
// Source: DVSI AMBE-3000 API reference manual, Table 3-1.
static const QByteArray kAmbe2RateBytes =
    QByteArray::fromHex("0130076340000000000");

AmbeNetworkDriver::AmbeNetworkDriver(RadioConnection* conn, QObject* parent)
    : QObject(parent)
    , m_conn(conn)
    , m_drainTimer(new QTimer(this))
{
    m_drainTimer->setInterval(kDrainIntervalMs);
    connect(m_drainTimer, &QTimer::timeout,
            this, &AmbeNetworkDriver::onDrainQueue);
}

AmbeNetworkDriver::~AmbeNetworkDriver()
{
    close();
}

void AmbeNetworkDriver::probeAndConnect()
{
    // Ask the radio what FTDI cables are attached.
    // The response arrives in onStatusLine() as an S message.
    // Format: S|usb_cable  type= baud= ...
    m_conn->sendCommand("usb_cable list");
}

void AmbeNetworkDriver::close()
{
    m_drainTimer->stop();
    if (m_connected || m_passthroughConfigured) {
        // Restore cable to its default mode so SmartSDR
        // can reclaim it if the user switches clients.
        if (!m_cableSerial.isEmpty())
            m_conn->sendCommand(
                QString("usb_cable set %1 type=none").arg(m_cableSerial));
        m_connected = false;
        m_passthroughConfigured = false;
        emit disconnected();
    }
}

bool AmbeNetworkDriver::isConnected() const  { return m_connected; }
QString AmbeNetworkDriver::cableSerial() const { return m_cableSerial; }

// ── Incoming status line from RadioConnection ─────────────────────

void AmbeNetworkDriver::onStatusLine(const QString& line)
{
    // Strip the S| prefix that RadioConnection leaves intact.
    const int pipeIdx = line.indexOf('|');
    if (pipeIdx < 0) return;
    const QString body = line.mid(pipeIdx + 1);

    if (!body.startsWith("usb_cable ")) return;

    // 1. Cable list response — grab serial, configure passthrough.
    if (!body.contains("data:base64")) {
        handleCableList(body);
        return;
    }

    // 2. Incoming dongle bytes tunneled by the radio.
    //    Format: usb_cable data:base64 
    const int b64Idx = body.indexOf("data:base64 ");
    if (b64Idx < 0) return;
    const QByteArray bytes =
        QByteArray::fromBase64(body.mid(b64Idx + 12).trimmed().toLatin1());
    handleIncomingBytes(bytes);
}

// Also hook R (response) lines to catch passthrough config errors.
// Call this from the same place in RadioConnection / CommandParser.
// (Separate from onStatusLine to keep routing clear.)
void AmbeNetworkDriver::onResponseLine(const QString& line)
{
    // R||
    // If the radio rejected our usb_cable set command, report it.
    if (!m_passthroughConfigured && !m_cableSerial.isEmpty()) {
        const QStringList parts = line.mid(1).split('|');
        if (parts.size() >= 2) {
            bool ok;
            const uint32_t code = parts[1].toUInt(&ok, 16);
            if (ok && code != 0) {
                emit errorOccurred(
                    QString("USB passthrough rejected by firmware "
                            "(error 0x%1). "
                            "Requires SmartSDR fw >= v3.9.18. "
                            "Current target fw v1.4.0.0 does not support "
                            "passthrough — upgrade radio firmware or use "
                            "local USB dongle mode.")
                        .arg(parts[1]));
            }
        }
    }
}

// ── Private helpers ───────────────────────────────────────────────

void AmbeNetworkDriver::handleCableList(const QString& body)
{
    // body = "usb_cable  type= baud= ..."
    // We only care about the serial number at parts[1].
    const QStringList parts = body.split(' ', Qt::SkipEmptyParts);
    if (parts.size() < 2) return;
    m_cableSerial = parts[1];

    // Configure the cable as a raw serial passthrough.
    // Baud 460800 = DVSI AMBE+2 standard rate.
    // On fw v1.4.0.0 this returns 0x5000XXXX → onResponseLine() reports error.
    m_conn->sendCommand(
        QString("usb_cable set %1 type=passthrough baud=460800")
            .arg(m_cableSerial));
    m_passthroughConfigured = true;

    // Send DVSI reset to wake the dongle.
    // Its reply (arriving in handleIncomingBytes) confirms it is alive.
    sendRaw(kPktReset);

    // Send AMBE+2 rate table (harmless no-op for ThumbDV).
    QByteArray rateCmd;
    rateCmd.append(static_cast(0x00)); // PKT_RATET opcode
    rateCmd.append(kAmbe2RateBytes);
    sendRaw(buildDvsiPacket(kTypeControl, rateCmd));

    m_drainTimer->start();
}

void AmbeNetworkDriver::handleIncomingBytes(const QByteArray& bytes)
{
    m_rxBuf.append(bytes);

    int offset = 0;
    while (offset < m_rxBuf.size()) {
        int consumed = 0;
        uint8_t type;
        QByteArray payload;
        if (!parseDvsiPacket(m_rxBuf, offset, consumed, type, payload))
            break;
        offset += consumed;

        if (!m_connected) {
            // First valid DVSI packet = dongle is alive and responding.
            m_connected = true;
            emit connected(m_cableSerial);
        }

        switch (type) {
        case kTypeSpeech:
            // Dongle decoded AMBE → PCM (response to our kTypeChannel send).
            // payload = 320 bytes = 160 × int16 @ 8 kHz.
            emit pcmDecoded(payload);
            break;
        case kTypeChannel:
            // Dongle encoded PCM → AMBE (response to our kTypeSpeech send).
            // payload = 9 bytes AMBE+2 frame.
            emit ambeEncoded(payload);
            break;
        case kTypeControl:
            // Product ID / reset echo — dongle is alive. Already handled above.
            break;
        default:
            break;
        }
    }
    if (offset > 0)
        m_rxBuf.remove(0, offset);
}

void AmbeNetworkDriver::sendRaw(const QByteArray& dvsiPacket)
{
    // Encode as base64 and send via usb_cable write.
    m_conn->sendCommand(
        QString("usb_cable write %1 base64 %2")
            .arg(m_cableSerial)
            .arg(QString::fromLatin1(dvsiPacket.toBase64())));
}

void AmbeNetworkDriver::requestDecode(const QByteArray& ambeFrame9bytes)
{
    // AMBE → PCM: send kTypeChannel with 9-byte AMBE frame.
    QMutexLocker lk(&m_txMutex);
    m_txQueue.enqueue(buildDvsiPacket(kTypeChannel, ambeFrame9bytes));
}

void AmbeNetworkDriver::requestEncode(const QByteArray& pcm160samples)
{
    // PCM → AMBE: send kTypeSpeech with 320-byte PCM block.
    QMutexLocker lk(&m_txMutex);
    m_txQueue.enqueue(buildDvsiPacket(kTypeSpeech, pcm160samples));
}

void AmbeNetworkDriver::onDrainQueue()
{
    // Send one queued DVSI packet per timer tick (every 20 ms).
    // Pacing is critical: the SmartSDR TCP command channel is shared
    // with frequency, filter, meter, and all other slice commands.
    // Bursting multiple packets per tick would starve other commands
    // and may trigger the radio's command rate limiter.
    QMutexLocker lk(&m_txMutex);
    if (!m_txQueue.isEmpty())
        sendRaw(m_txQueue.dequeue());
}

// ── Static DVSI framing ───────────────────────────────────────────

QByteArray AmbeNetworkDriver::buildDvsiPacket(uint8_t type,
                                               const QByteArray& payload)
{
    // [0xEC] [len_hi] [len_lo] [type] [payload...]
    // len = 1 (type byte) + payload.size()
    const uint16_t len = static_cast(1 + payload.size());
    QByteArray pkt;
    pkt.reserve(3 + len);
    pkt.append(static_cast(kDvsiStart));
    pkt.append(static_cast((len >> 8) & 0xFF));
    pkt.append(static_cast( len       & 0xFF));
    pkt.append(static_cast(type));
    pkt.append(payload);
    return pkt;
}

bool AmbeNetworkDriver::parseDvsiPacket(const QByteArray& buf,
                                         int offset,
                                         int& consumed,
                                         uint8_t& type,
                                         QByteArray& payload)
{
    if (offset + 4 > buf.size()) return false;  // need at least header

    if (static_cast(buf[offset]) != kDvsiStart) {
        // Sync lost — scan forward for next 0xEC start byte.
        int next = buf.indexOf(static_cast(kDvsiStart), offset + 1);
        consumed = (next < 0) ? buf.size() - offset : next - offset;
        return false;
    }

    const uint16_t payloadLen =
        (static_cast(buf[offset + 1]) << 8) |
         static_cast(buf[offset + 2]);

    // payloadLen includes the type byte, so total packet = 3 + payloadLen
    if (offset + 3 + static_cast(payloadLen) > buf.size())
        return false;  // incomplete — wait for more bytes

    type     = static_cast(buf[offset + 3]);
    payload  = buf.mid(offset + 4, payloadLen - 1);
    consumed = 3 + payloadLen;
    return true;
}

Integration hooks in existing files

src/core/RadioConnection.h — add forward declaration and member:

class AmbeNetworkDriver;          // forward declaration

// In private members:
AmbeNetworkDriver* m_ambeNetworkDriver{nullptr};

src/core/RadioConnection.cpp — route status/response lines:

// In onReadyRead() / line dispatch, before existing parsing:
if (m_ambeNetworkDriver) {
    if (line.startsWith('S'))
        m_ambeNetworkDriver->onStatusLine(line);
    else if (line.startsWith('R'))
        m_ambeNetworkDriver->onResponseLine(line);
}

src/core/RadioModel.cpp — create and start the driver:

// In onConnected(), after all sub commands are sent:

// Network AMBE dongle (radio USB passthrough).
// Requires fw >= v3.9.18. Gracefully no-ops on older firmware.
m_ambeNetworkDriver = new AmbeNetworkDriver(m_connection, this);

connect(m_ambeNetworkDriver, &AmbeNetworkDriver::connected,
        this, [this](const QString& serial) {
            AppSettings::instance().setValue("AmbeUsbCableSerial", serial);
            AppSettings::instance().setValue("AmbeDongleSource", "network");
            if (m_ambeEngine)
                m_ambeEngine->setDriver(m_ambeNetworkDriver);
            emit ambeNetworkDriverReady(m_ambeNetworkDriver);
        });

connect(m_ambeNetworkDriver, &AmbeNetworkDriver::errorOccurred,
        this, [this](const QString& msg) {
            // Surface in DV applet status badge as AMBE ○ with tooltip.
            emit ambeNetworkError(msg);
        });

// Only probe if the user has selected radio USB mode in settings.
const QString src =
    AppSettings::instance().value("AmbeDongleSource", "local").toString();
if (src == "network")
    m_ambeNetworkDriver->probeAndConnect();

CMakeLists.txt — add qt6-serialport only for the local USB path
(the network driver uses no extra dependencies beyond what is already present):

# Only needed for AmbeSerialDriver (local USB path), not AmbeNetworkDriver.
find_package(Qt6 OPTIONAL_COMPONENTS SerialPort)
if(Qt6SerialPort_FOUND)
    target_link_libraries(AetherSDR PRIVATE Qt6::SerialPort)
    target_compile_definitions(AetherSDR PRIVATE AETHER_HAVE_SERIAL_PORT)
endif()

---

Known Constraints and Mitigations

Constraint	Impact	Mitigation
SmartSDR TCP command channel shared with all radio commands	High packet rate may delay frequency or filter commands	Rate-limited to 1 DVSI packet / 20 ms (matches AMBE frame period)
base64 encoding overhead	~33% bandwidth increase on the channel	Acceptable at 16 KB/s; still << 1% of LAN capacity
No RTS/CTS pin control over passthrough	Cannot use hardware flow control	DVSI protocol is request-response; no flow control needed
fw v1.4.0.0 does not support passthrough	Feature unavailable on that firmware	onResponseLine() detects error code, emits errorOccurred(), UI shows AMBE ○ badge
SmartLink (WAN) adds latency	Round-trip may exceed 20 ms at high ping	Queue depth in AmbeEngine absorbs up to 100 ms of jitter
FTDI cable required (not bare USB-CDC)	User cannot plug dongle in directly	Documented clearly in UI tooltip and README

---

Suggested Labels

feature · digital-voice · hardware · protocol · smartlink

Related Issues

• Previous AMBE issue (local USB dongle path) — companion feature
• #88 — RADE status indicator (same VFO badge pattern)
• #70 — TNF passthrough (same protocol exploration approach)

A few notes on what changed from our earlier conversation now that we've locked in v4.1.5:
The firmware version worry is gone for most users. v4.1.5 is well past the v3.9.18 passthrough introduction, so anyone running current firmware gets this feature out of the box. The onResponseLine() error handler is still there as a safety net for anyone on older firmware, but it won't be the common case.
The onResponseLine() method is a new hook not in the previous draft — it's needed because the radio's error response to usb_cable set comes back as an R line, not an S line, so the existing status routing wouldn't catch it.
The CMake block uses OPTIONAL_COMPONENTS deliberately — AmbeNetworkDriver has zero extra dependencies (it only uses RadioConnection which already exists), so the network path builds cleanly even on a machine without Qt SerialPort installed. The local USB path is the only thing that needs that library.