SkillAgentSearch skills...

WildBridge

Ground Station Interface for Lightweight Multi-Drone Control and Telemetry on DJI Platforms

GenerateConvertImprove

Install / Use

/learn @WildDrone/WildBridge
About this skill

Quality Score

0/100

Supported Platforms

Universal

README

<div align="center"> <img src="WildBridge_icon.png" alt="WildBridge App Icon" width="300" height="300"> </div>

WildBridge: Ground Station Interface for Lightweight Multi-Drone Control and Telemetry on DJI Platforms
Part of the WildDrone Project - European Union's Horizon Europe Research Program

Overview

WildBridge is an open-source Android application that extends DJI's Mobile SDK V5 to provide accessible telemetry, video streaming, and low-level control for scientific research applications. Running directly on the DJI remote controller, it exposes network interfaces (HTTP and RTSP) over a local area network, enabling seamless integration with ground stations and external research tools.

WildBridge Diagram

Research and Citation

This work is part of the WildDrone project, funded by the European Union's Horizon Europe Research Program (Grant Agreement No. 101071224). The WildDrone project has also received funding in part from the EPSRC-funded Autonomous Drones for Nature Conservation Missions grant (EP/X029077/1).

Academic Papers:

@inproceedings{Rolland2025WildBridge,
  author    = {Edouard Rolland and Kilian Meier and Murat Bronz and Aditya Shrikhande and Tom Richardson and Ulrik Pagh Schultz Lundquist and Anders Christensen},
  title     = {WildBridge: Ground Station Interface for Lightweight Multi-Drone Control and Telemetry on DJI Platforms},
  booktitle = {Proceedings of the 13th International Conference on Robot Intelligence Technology and Applications (RiTA 2025)},
  year      = {2025},
  month = {December},
  publisher = {Springer},
  address   = {London, United Kingdom},
  note      = {In press},
  url       = {https://portal.findresearcher.sdu.dk/en/publications/wildbridge-ground-station-interface-for-lightweight-multi-drone-c},
}

Key Features

  • Real-time Telemetry: TCP socket streaming (port 8081) for continuous flight data at 20Hz
  • HTTP Command Interface: RESTful API (port 8080) for drone control commands
  • Live Video Streaming: RTSP video feed compatible with OpenCV, FFmpeg, and VLC
  • DJI Native Waypoint Missions: Support for KMZ-based wayline missions via DJI's native system
  • PID-based Navigation: Custom trajectory following with pure pursuit algorithm
  • Multi-drone Coordination: Support for up to 10 concurrent drones with sub-100ms latency
  • Wildlife Monitoring: Integrated YOLO-based object detection and geolocation
  • Scientific Applications: Proven in conservation, wildfire detection, and atmospheric research
  • Cross-platform Integration: Compatible with Python, ROS 2, and standard TCP/HTTP clients

Supported Hardware

DJI Drones (Mobile SDK V5 Compatible)

  • DJI Mini 3/Mini 3 Pro
  • DJI Mini 4 Pro
  • DJI Mavic 3 Enterprise Series
  • DJI Matrice 30 Series (M30/M30T)
  • DJI Matrice 300 RTK
  • DJI Matrice 350 RTK
  • Full list here

Remote Controllers

  • DJI RC Pro - Primary supported controller
  • DJI RC Plus - Enterprise compatibility
  • DJI RC-N3 - Standard controller (tested with smartphones)

Performance Characteristics

Based on controlled experiments with consumer-grade hardware:

Telemetry Performance

  • Latency: <113ms mean, <290ms 90th percentile (up to 10 drones at 32Hz)
  • Scalability: Tested up to 10 concurrent drones

Video Streaming Performance

  • Latency: 1.4-1.6s (1-4 drones), 1.8-1.9s (5-6 drones)
  • Scalability Limit: 6 concurrent video streams before degradation
  • Format: Standard Definition via RTSP
  • Compatibility: FFmpeg, OpenCV, VLC

Quick Start

Prerequisites

  1. Hardware Setup

    • DJI drone and compatible remote controller
    • Local Wi-Fi network (5GHz recommended)
    • Ground station computer

  2. Software Installation

First, you need to install the WildBridge App on your controller: Step-by-Step Android Installation

  1. Enable Developer Mode and USB Debugging on your Android Device

    • Put your Android device in developer mode.
    • Enable USB debugging in developer options.

  2. Install Android Studio

  3. Clone the WildBridge Repository

    • Open a terminal and run: 
      git clone https://github.com/WildDrone/WildBridge.git

  4. Open the Project in Android Studio

    • In Android Studio, select "Open" and choose: 
      WildBridge/WildBridgeApp/android-sdk-v5-as

  5. Become a DJI developer and get an API key

    • Register as a DJI developer and get an API key: https://developer.dji.com/
    • Past your API key in: 
      WildBridge/WildBridgeApp/android-sdk-v5-as/local.properties 

      AIRCRAFT_API_KEY="App key"

  6. Build and Deploy the App

    • Build the app in Android Studio. Install any prompted dependencies.
    • Deploy the app to your controller.

  7. Start the Server on the Drone Controller

    • In WildBridge, click "Testing Tools".
    • Open the "Virtual Stick" page.
    • The server is now running. You can send commands, view RTSP videofeed, and retrieve telemetry.

Refer to the code snippets in the Quick Start section for examples of sending commands and retrieving telemetry.

  1. Python GS Dependencies

    pip install -r GroundStation/Python/requirements.txt

  2. ROS GS Dependencies

    pip install -r GroundStation/ROS/requirements.txt

Basic Usage

1. Remote Controller Setup

  • Connect RC to local Wi-Fi network
  • Note the RC's IP address from network settings
  • Install and launch WildBridge app
  • Navigate to "Testing Tools" -> "Virtual Stick"
  • When using control commands, press "Enable Virtual Stick"

2. Ground Station Connection

Telemetry Access via TCP Socket (Python):

import socket
import json

rc_ip = "192.168.1.100"  # Your RC IP
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((rc_ip, 8081))

buffer = ""
while True:
    data = sock.recv(4096).decode('utf-8')
    buffer += data
    while '\n' in buffer:
        line, buffer = buffer.split('\n', 1)
        if line.strip():
            telemetry = json.loads(line)
            print(f"Battery: {telemetry['batteryLevel']}%")
            print(f"Location: {telemetry['location']}")

Video Streaming (OpenCV):

import cv2

rc_ip = "192.168.1.100"  # Your RC IP
rtsp_url = f"rtsp://aaa:aaa@{rc_ip}:8554/streaming/live/1"
cap = cv2.VideoCapture(rtsp_url)
ret, frame = cap.read()

Control Commands (HTTP POST):

import requests

rc_ip = "192.168.1.100"  # Your RC IP
# Takeoff
requests.post(f"http://{rc_ip}:8080/send/takeoff")

# Navigate to waypoint with PID control
data = "49.306254,4.593728,20,90"  # lat,lon,alt,yaw
requests.post(f"http://{rc_ip}:8080/send/gotoWPwithPID", data=data)

# DJI Native waypoint mission
waypoints = "49.306,4.593,20; 49.307,4.594,25; 49.308,4.595,20"
requests.post(f"http://{rc_ip}:8080/send/navigateTrajectoryDJINative", data=waypoints)

API Reference

Telemetry Stream (TCP Socket - Port 8081)

Connect to the TCP socket on port 8081 to receive continuous JSON telemetry at 20Hz.

Telemetry Fields: | Field | Description | |-------|-------------| | speed | Aircraft velocity (x, y, z) | | heading | Compass heading in degrees | | attitude | Pitch, roll, yaw values | | location | GPS coordinates and altitude | | gimbalAttitude | Gimbal orientation | | batteryLevel | Battery percentage | | satelliteCount | GPS satellite count | | homeLocation | Home point coordinates | | distanceToHome | Distance to home in meters | | waypointReached | Waypoint status flag | | isRecording | Camera recording status | | flightMode | Current flight mode (GPS, MANUAL, GO_HOME, etc.) | | remainingFlightTime | Estimated flight time remaining | | batteryNeededToGoHome | Battery % needed for RTH | | batteryNeededToLand | Battery % needed to land | | timeNeededToGoHome | Time to return home (seconds) | | maxRadiusCanFlyAndGoHome | Max flyable radius (meters) |

Control Endpoints (HTTP POST - Port 8080)

| Endpoint | Description | Parameters | |----------|-------------|------------| | /send/takeoff | Initiate takeoff | None | | /send/land | Initiate landing | None | | /send/RTH | Return to home | None | | /send/gotoWP | Navigate to waypoint | lat,lon,alt | | /send/gotoWPwithPID | Navigate with PID control | lat,lon,alt,yaw | | /send/gotoYaw | Rotate to heading | yaw_angle | | /send/gotoAltitude | Change altitude | altitude | | /send/navigateTrajectory | Follow trajectory (Virtual Stick) | lat,lon,alt;...;lat,lon,alt,yaw | | /send/navigateTrajectoryDJINative | DJI native waypoint mission | lat,lon,alt;lat,lon,alt;... | | /send/abort/DJIMission | Stop DJI native mission | None | | /send/abortMission | Stop and disable Virtual Stick | None | | /send/enableVirtualStick | Enable Virtual Stick mode | None | | /send/stick | Virtual stick input | leftX,leftY,rightX,rightY | | /send/camera/zoom | Camera zoom control | zoom_ratio | | /send/camera/startRecording | Start video recording | None | | /send/camera/stopRecording | Stop video recording | None | | /send/gimbal/pitch | Gimbal pitch control | roll,pitch,yaw | | /send/gimbal/yaw | Gimbal yaw control | roll,pitch,yaw |

Status Endpoints (HTTP GET - Port 8080)

| Endpoint | Description | |----------|-------------| | /status/waypointReached | Check if waypoint reached | | /status/intermediaryWaypointReached | Check intermediary waypoint | | `/stat

WildDrone

View profile

View on GitHub
GitHub Stars42
CategoryDevelopment
Updated16d ago
Forks8
WildDrone/WildBridge

Languages

Kotlin

Security Score

90/100

Audited on Mar 15, 2026

No findings