mavlink

Author: raphaelscholle

.gitignore

@@ -6,3 +6,4 @@ CMakeUserPresets.json
 *.deb
 examples/media/
 examples/examples/
+/CMakeFiles

AGENTS.md

@@ -28,8 +28,10 @@ The video path has priority over everything else. `GlideView` should be able to
 - A development preview backend exists using SDL2 plus OpenGL ES. It is for WSL/Windows-style development only and does not replace the production DRM/KMS path.
 - `glide-ui` now uses LVGL v9.2.2 with LVGL's SDL backend for WSL development. Do not revive the hand-drawn GLES UI path.
 - `openhd-glide --preview-stack` runs the WSL development stack by launching `glide-flow` first and an LVGL/SDL `glide-ui` sidebar preview over the left side.
+- `examples/run-wsl-ui-preview.sh` now launches the full WSL preview stack by default so Flow OSD controls are visible with the UI; set `GLIDE_UI_ONLY=1` for the old standalone LVGL UI preview.
 - `openhd-glide --kms-stack` is the target-device stack entry point. It validates DRM/KMS probing, process startup, CPU assignment, Unix-socket IPC, and starts `glide-flow` with a direct GBM/EGL KMS scanout surface. `--kmd-stack` is accepted as a typo-compatible alias.
 - The WSL preview stack starts a controller-owned Unix socket at `/tmp/openhd-glide.sock` by default. Workers register with `hello <worker>`. `glide-ui` toggles the Flow FPS overlay by sending `set fps 0/1`; the controller broadcasts `state fps 0/1` to `glide-flow`.
+- `openhd-glide --preview-stack` and `--kms-stack` include a controller-owned MAVLink UDP bridge on port 14550 by default. It decodes common MAVLink telemetry and OpenHD/QOpenHD parameter/status traffic into the existing `mav ...` IPC state lines for OSD/UI use, and translates UI `mav set ...` / `mav command ...` actions back to MAVLink packets once a UDP peer is known.
 - `glide-ui` has a first LVGL QOpenHD-style sidebar shell: large icon rail, `Find Air Unit` scan panel, and an FPS overlay toggle in the `MISC` panel. In WSL the UI window is sized as a sidebar surface, not a transparent full-screen overlay.
 - On the device stack, `glide-ui --headless` is used until the LVGL shared-buffer/plane backend exists. Do not make the UI a DRM/KMS master.
 - `glide-view --udp-video --udp-port 5600` uses GStreamer to receive RTP/H.264 over UDP and decode into `appsink`. It must not use `kmssink` because only `openhd-glide` should own KMS. It prefers `v4l2h264dec`/`v4l2slh264dec` and warns if it falls back to `avdec_h264`.

CMakeLists.txt

@@ -25,6 +25,7 @@ add_library(glide_common
     src/common/ipc.cpp
     src/common/logging.cpp
     src/common/mavlink_state.cpp
+    src/common/mavlink_udp_bridge.cpp
     src/common/preview_control.cpp
     src/platform/core_assignment.cpp
     src/platform/cpu_topology.cpp

README.md

@@ -254,10 +254,10 @@ examples/run-wsl-ui-preview.sh
 examples/run-wsl-minimap-preview.sh
 ```
 
-For WSL development, `openhd-glide --preview-stack` starts `glide-flow` first and then places a
+For WSL development, `openhd-glide --preview-stack` starts `glide-view`, `glide-flow`, and then places a
 `glide-ui` LVGL/SDL preview over the left side. In WSL, the UI preview is kept as a sidebar surface to avoid
-covering the Flow preview. The sidebar contains a `MISC` panel with an FPS overlay toggle wired through the
-controller Unix socket.
+covering the Flow preview. The sidebar `OSD` panel has toggles for FPS, coordinates, and the Flow speed/altitude
+ladder versus compact text mode. The custom wind indicator is rendered by Flow inside the performance horizon.
 The UI preview also owns the LVGL minimap layer. Press `M` to cycle menu -> minimap -> hidden, or press `N` to
 cycle minimap -> menu -> hidden. When the minimap is visible, `+` zooms in and `-` zooms out. The two views share one
 layer and are never displayed at the same time.
@@ -301,8 +301,10 @@ The helper script does the same build and tile generation steps:
 examples/run-wsl-minimap-preview.sh
 ```
 
-`examples/run-wsl-ui-preview.sh` also generates the fake minimap tiles and exports `GLIDE_MINIMAP_TILE_ROOT`, so the
-integrated UI preview can show the round minimap with `M` or `N` immediately. Use `+` and `-` to zoom the map.
+`examples/run-wsl-ui-preview.sh` starts that full preview stack by default, generates the fake minimap tiles, and
+exports `GLIDE_MINIMAP_TILE_ROOT`, so the integrated UI preview can show the round minimap with `M` or `N`
+immediately. Use `GLIDE_UI_ONLY=1 examples/run-wsl-ui-preview.sh` for the old standalone UI window. Use `+` and `-`
+to zoom the map.
 
 To install the WSL build into `~/.local`:
 
@@ -333,9 +335,17 @@ Terminal and MAVLink-state IPC helpers:
 ./build-kms/glide-send mav message "FC heartbeat received"
 ```
 
-`mav ...` lines are intentionally a temporary bridge contract: the real MAVLink reader should publish the same state
-updates to the controller IPC socket, and UI actions emit `mav set ...` / `mav command ...` lines that the MAVLink
-writer can translate into OpenHD parameter writes and commands.
+`mav ...` lines are the internal bridge contract: the controller publishes decoded MAVLink state to workers, and UI
+actions emit `mav set ...` / `mav command ...` lines that the controller can translate into OpenHD parameter writes and
+commands.
+
+`openhd-glide --preview-stack` and `--kms-stack` now start a controller-owned MAVLink UDP bridge on `0.0.0.0:14550`
+by default. Override it with `--mavlink-udp-port <port>` or disable it with `--no-mavlink`. The bridge decodes common
+MAVLink flight data (`HEARTBEAT`, `ATTITUDE`, `GPS_RAW_INT`, `GLOBAL_POSITION_INT`, `VFR_HUD`, `SYS_STATUS`,
+`RC_CHANNELS`, `STATUSTEXT`) and OpenHD/QOpenHD-style parameter/status traffic (`PARAM_VALUE`, `PARAM_EXT_VALUE`,
+plus custom OpenHD message IDs as status lines), then broadcasts normalized `mav ...` state to Flow and UI. Menu
+actions are translated back into MAVLink `PARAM_EXT_SET`, numeric `PARAM_SET`, or command-long packets when a peer has
+been seen on the UDP socket.
 
 UI navigation is directional: `up/down` moves through the sidebar or focused setting rows, `right` enters the settings
 panel, `left` returns to the sidebar or collapses it, and `enter` activates the focused row.

docs/architecture.md

@@ -91,10 +91,12 @@ uses before drawing the FPS overlay. The socket path can be changed with `--ipc-
 
 The LVGL UI is intentionally backend-isolated: the current SDL display driver is for WSL/Windows-style iteration. The target backend should render the same LVGL tree into shared buffers or a plane-owned buffer path supplied by `openhd-glide`, without letting `glide-ui` become DRM/KMS master.
 
-The UI and Flow consume a small controller-broadcast `mav ...` IPC vocabulary while the real MAVLink bridge is being
-built. This keeps the rendering processes decoupled from MAVLink transport details: a bridge can publish snapshots such
-as `mav alive air 1`, `mav link 5745 20 2 1200`, `mav scan 50`, and `mav message ...`; UI actions emit `mav set ...` or
-`mav command ...` for the bridge to translate into OpenHD `PARAM_EXT_*` writes and command-long calls.
+The UI and Flow consume a small controller-broadcast `mav ...` IPC vocabulary. The controller owns the MAVLink UDP
+bridge by default on `0.0.0.0:14550` (`--mavlink-udp-port`, `--no-mavlink`) and keeps rendering processes decoupled
+from transport details. It decodes common flight messages into snapshots such as `mav attitude ...`, `mav position ...`,
+`mav speed ...`, `mav battery ...`, `mav rc ...`, plus OpenHD/QOpenHD-style `PARAM_VALUE` and `PARAM_EXT_VALUE` settings
+into `mav param ...`. UI actions emit `mav set ...` or `mav command ...`; the controller translates those back into
+MAVLink parameter writes or command-long packets once it has seen a UDP peer.
 
 ## Device KMS Mode
 

examples/run-wsl-ui-preview.sh

@@ -8,17 +8,40 @@ WIDTH="${GLIDE_UI_WIDTH:-760}"
 HEIGHT="${GLIDE_UI_HEIGHT:-720}"
 X="${GLIDE_PREVIEW_X:-80}"
 Y="${GLIDE_PREVIEW_Y:-40}"
-IPC_SOCKET="${GLIDE_IPC_SOCKET:-/tmp/openhd-glide-ui-preview.sock}"
+FLOW_WIDTH="${GLIDE_FLOW_WIDTH:-${GLIDE_WIDTH:-1280}}"
+FLOW_HEIGHT="${GLIDE_FLOW_HEIGHT:-${GLIDE_HEIGHT:-720}}"
+PORT="${GLIDE_VIEW_PORT:-5600}"
+CODEC="${GLIDE_VIEW_CODEC:-${GLIDE_CODEC:-h264}}"
+IPC_SOCKET="${GLIDE_IPC_SOCKET:-/tmp/openhd-glide.sock}"
 TILE_ROOT="${GLIDE_MINIMAP_TILE_ROOT:-${ROOT_DIR}/assets/maps}"
 MINIMAP_ZOOM="${GLIDE_MINIMAP_ZOOM:-15}"
+UI_ONLY="${GLIDE_UI_ONLY:-0}"
+
+CODEC="$(printf "%s" "$CODEC" | tr '[:upper:]' '[:lower:]')"
+case "$CODEC" in
+  h264|avc)
+    CODEC="h264"
+    ;;
+  h265|hevc)
+    CODEC="h265"
+    ;;
+  *)
+    echo "unsupported codec '${CODEC}'; use h264 or h265" >&2
+    exit 2
+    ;;
+esac
 
 if [ "${GLIDE_SKIP_BUILD:-0}" != "1" ]; then
   if ! command -v cmake >/dev/null 2>&1; then
-    echo "cmake is required to build glide-ui; set GLIDE_SKIP_BUILD=1 to reuse an existing binary" >&2
+    echo "cmake is required to build the WSL preview; set GLIDE_SKIP_BUILD=1 to reuse existing binaries" >&2
     exit 1
   fi
   cmake -S "${ROOT_DIR}" -B "${BUILD_DIR}"
-  cmake --build "${BUILD_DIR}" --target glide-ui -j"$(nproc)"
+  if [ "${UI_ONLY}" = "1" ]; then
+    cmake --build "${BUILD_DIR}" --target glide-ui -j"$(nproc)"
+  else
+    cmake --build "${BUILD_DIR}" --target openhd-glide glide-view glide-flow glide-ui -j"$(nproc)"
+  fi
 fi
 
 if [ "${GLIDE_SKIP_TILE_GEN:-0}" != "1" ]; then
@@ -30,27 +53,56 @@ if [ "${GLIDE_SKIP_TILE_GEN:-0}" != "1" ]; then
   fi
 fi
 
-if [ ! -x "${BUILD_DIR}/glide-ui" ]; then
-  echo "missing executable: ${BUILD_DIR}/glide-ui" >&2
-  exit 1
+if [ "${UI_ONLY}" = "1" ]; then
+  REQUIRED_BINARIES="glide-ui"
+else
+  REQUIRED_BINARIES="openhd-glide glide-view glide-flow glide-ui"
 fi
 
-if command -v ldd >/dev/null 2>&1; then
-  LDD_OUTPUT="$(ldd "${BUILD_DIR}/glide-ui" 2>&1 || true)"
-  MISSING_LIBS="$(printf "%s\n" "${LDD_OUTPUT}" | sed -n '/=>.*not found/p;/Error loading shared library/p')"
-  if [ -n "${MISSING_LIBS}" ]; then
-    echo "glide-ui is missing runtime libraries:" >&2
-    echo "${MISSING_LIBS}" >&2
+for binary in ${REQUIRED_BINARIES}; do
+  if [ ! -x "${BUILD_DIR}/${binary}" ]; then
+    echo "missing executable: ${BUILD_DIR}/${binary}" >&2
     exit 1
   fi
+done
+
+if command -v ldd >/dev/null 2>&1; then
+  for binary in ${REQUIRED_BINARIES}; do
+    LDD_OUTPUT="$(ldd "${BUILD_DIR}/${binary}" 2>&1 || true)"
+    MISSING_LIBS="$(printf "%s\n" "${LDD_OUTPUT}" | sed -n '/=>.*not found/p;/Error loading shared library/p')"
+    if [ -n "${MISSING_LIBS}" ]; then
+      echo "${binary} is missing runtime libraries:" >&2
+      echo "${MISSING_LIBS}" >&2
+      exit 1
+    fi
+  done
+fi
+
+if [ "${UI_ONLY}" = "1" ]; then
+  GLIDE_MINIMAP_TILE_ROOT="${TILE_ROOT}" \
+  GLIDE_MINIMAP_ZOOM="${MINIMAP_ZOOM}" \
+  exec "${BUILD_DIR}/glide-ui" \
+    --preview \
+    --width "${WIDTH}" \
+    --height "${HEIGHT}" \
+    --x "${X}" \
+    --y "${Y}" \
+    --ipc-socket "${IPC_SOCKET}"
 fi
 
+echo "Starting WSL preview stack with Flow OSD, LVGL UI, and View decode worker." >&2
+echo "Feed video with: examples/stream-videotestsrc-to-glide-view.sh 127.0.0.1 ${PORT}" >&2
+
 GLIDE_MINIMAP_TILE_ROOT="${TILE_ROOT}" \
 GLIDE_MINIMAP_ZOOM="${MINIMAP_ZOOM}" \
-exec "${BUILD_DIR}/glide-ui" \
-  --preview \
-  --width "${WIDTH}" \
-  --height "${HEIGHT}" \
-  --x "${X}" \
-  --y "${Y}" \
+exec "${BUILD_DIR}/openhd-glide" \
+  --preview-stack \
+  --preview-width "${FLOW_WIDTH}" \
+  --flow-height "${FLOW_HEIGHT}" \
+  --ui-width "${WIDTH}" \
+  --ui-height "${HEIGHT}" \
+  --preview-x "${X}" \
+  --preview-y "${Y}" \
+  --view-udp-port "${PORT}" \
+  --view-udp-codec "${CODEC}" \
   --ipc-socket "${IPC_SOCKET}"

manual-wsl.md

@@ -90,7 +90,7 @@ PowerShell form:
 wsl -d Ubuntu-22.04 -- openhd-glide --preview-stack --preview-width 1280 --flow-height 720 --ui-width 760 --preview-x 60 --preview-y 40 --ui-opacity 1.0
 ```
 
-The UI `OSD` panel has switches for the video FPS overlay and the compact Flow coordinate field. The coordinate switch sends `set coords 0/1` through the preview IPC socket.
+The UI `OSD` panel has switches for the video FPS overlay, coordinates, and the speed/altitude ladder versus compact text mode. The wind indicator is drawn by Flow in the performance horizon, so run the controller-owned preview stack or `examples/run-wsl-ui-preview.sh` without `GLIDE_UI_ONLY=1` when checking it.
 
 ## Rebuild And Reinstall
 

src/common/mavlink_state.cpp

@@ -1,6 +1,7 @@
 #include "common/mavlink_state.hpp"
 
 #include <algorithm>
+#include <cctype>
 #include <sstream>
 
 namespace glide::mavlink {
@@ -36,6 +37,23 @@ void push_message(Snapshot& snapshot, std::string message)
     snapshot.messages.back() = std::move(message);
 }
 
+std::string upper_copy(std::string value)
+{
+    std::transform(value.begin(), value.end(), value.begin(), [](unsigned char c) {
+        return static_cast<char>(std::toupper(c));
+    });
+    return value;
+}
+
+int parse_int_or(int fallback, const std::string& value)
+{
+    try {
+        return std::stoi(value);
+    } catch (...) {
+        return fallback;
+    }
+}
+
 } // namespace
 
 bool apply_ipc_line(Snapshot& snapshot, const std::string& line)
@@ -67,6 +85,35 @@ bool apply_ipc_line(Snapshot& snapshot, const std::string& line)
         snapshot.armed = armed != 0;
         return true;
     }
+    if (key == "attitude") {
+        stream >> snapshot.roll_degrees >> snapshot.pitch_degrees >> snapshot.yaw_degrees;
+        snapshot.attitude_valid = true;
+        return true;
+    }
+    if (key == "position") {
+        stream >> snapshot.latitude_deg >> snapshot.longitude_deg >> snapshot.altitude_m;
+        snapshot.position_valid = true;
+        snapshot.altitude_valid = true;
+        return true;
+    }
+    if (key == "speed") {
+        stream >> snapshot.ground_speed_mps >> snapshot.airspeed_mps;
+        snapshot.speed_valid = true;
+        return true;
+    }
+    if (key == "battery") {
+        stream >> snapshot.voltage_v >> snapshot.battery_percent;
+        snapshot.battery_valid = true;
+        return true;
+    }
+    if (key == "gps") {
+        stream >> snapshot.satellites;
+        return true;
+    }
+    if (key == "mode") {
+        snapshot.flight_mode = rest_after(stream);
+        return true;
+    }
     if (key == "link") {
         stream >> snapshot.frequency_mhz >> snapshot.channel_width_mhz >> snapshot.mcs_index >> snapshot.tx_power_mw;
         return true;
@@ -87,20 +134,37 @@ bool apply_ipc_line(Snapshot& snapshot, const std::string& line)
         std::string param;
         stream >> target >> param;
         const auto value = rest_after(stream);
-        if (param == "RESOLUTION_FPS") {
+        const auto upper_param = upper_copy(param);
+        if (upper_param == "RESOLUTION_FPS" || upper_param == "VIDEO_FORMAT" || upper_param == "CAMERA_FORMAT") {
             snapshot.resolution_fps = value;
-        } else if (param == "ROTATION_FLIP" || param == "ROTATION_DEG") {
+        } else if (upper_param == "ROTATION_FLIP" || upper_param == "ROTATION_DEG" || upper_param == "VIDEO_ROTATION") {
             snapshot.rotation = value;
-        } else if (param == "AIR_RECORDING_E") {
+        } else if (upper_param == "AIR_RECORDING_E" || upper_param == "RECORDING" || upper_param == "REC_ENABLED") {
             snapshot.recording = value;
-        } else if (param == "WIFI_MODE" && target == "air") {
+        } else if (upper_param == "WIFI_MODE" && target == "air") {
             snapshot.air_wifi_mode = value;
-        } else if (param == "WIFI_MODE" && target == "ground") {
+        } else if (upper_param == "WIFI_MODE" && target == "ground") {
             snapshot.ground_wifi_mode = value;
-        } else if (param == "WIFI_HOTSPOT_E" && target == "air") {
+        } else if (upper_param == "WIFI_HOTSPOT_E" && target == "air") {
             snapshot.air_hotspot = value;
-        } else if (param == "WIFI_HOTSPOT_E" && target == "ground") {
+        } else if (upper_param == "WIFI_HOTSPOT_E" && target == "ground") {
             snapshot.ground_hotspot = value;
+        } else if (upper_param == "FREQ" || upper_param == "FREQUENCY" || upper_param == "FREQUENCY_MHZ" || upper_param == "WB_FREQUENCY") {
+            snapshot.frequency_mhz = parse_int_or(snapshot.frequency_mhz, value);
+        } else if (upper_param == "CHANNEL_WIDTH" || upper_param == "CHANNEL_WIDTH_MHZ" || upper_param == "WB_CHANNEL_WIDTH" || upper_param == "BANDWIDTH") {
+            snapshot.channel_width_mhz = parse_int_or(snapshot.channel_width_mhz, value);
+        } else if (upper_param == "MCS" || upper_param == "MCS_INDEX" || upper_param == "WB_MCS_INDEX") {
+            snapshot.mcs_index = parse_int_or(snapshot.mcs_index, value);
+        } else if (upper_param == "TX_POWER" || upper_param == "TX_POWER_MW" || upper_param == "WB_TX_POWER_MW") {
+            snapshot.tx_power_mw = parse_int_or(snapshot.tx_power_mw, value);
+        } else if (upper_param == "OPENHD_VERSION" || upper_param == "VERSION") {
+            snapshot.openhd_version = value;
+        } else if (upper_param == "AIR_CHIPSET") {
+            snapshot.air_chipset = value;
+        } else if (upper_param == "GROUND_CHIPSET") {
+            snapshot.ground_chipset = value;
+        } else if (upper_param == "CAMERA" || upper_param == "CAMERA_TYPE") {
+            snapshot.camera = value;
         }
         return true;
     }

src/common/mavlink_state.hpp

@@ -10,12 +10,29 @@ struct Snapshot {
     bool ground_alive {};
     bool fc_alive {};
     bool armed {};
+    bool attitude_valid {};
+    bool altitude_valid {};
+    bool speed_valid {};
+    bool position_valid {};
+    bool battery_valid {};
     int frequency_mhz { 5745 };
     int channel_width_mhz { 20 };
     int mcs_index { 2 };
     int tx_power_mw { 1200 };
     int scan_progress { 0 };
     int rc_channels[4] { 1500, 1500, 1000, 1500 };
+    int battery_percent { -1 };
+    int satellites {};
+    float roll_degrees {};
+    float pitch_degrees {};
+    float yaw_degrees {};
+    float altitude_m {};
+    float ground_speed_mps {};
+    float airspeed_mps {};
+    float voltage_v {};
+    double latitude_deg {};
+    double longitude_deg {};
+    std::string flight_mode { "N/A" };
     std::string resolution_fps { "1920x1080@120" };
     std::string rotation { "0 deg" };
     std::string recording { "Disabled" };