GCS and communications

Example 1 Checking a .plan file with a program

A VTOL flood survey mission at 16 m/s (hypothetical coordinates). The program computes each leg, the flight time and the farthest distance from home, and checks altitude against the 90 m ceiling used for general flights under the CAAT rules.

import math

plan = {"fileType": "Plan", "version": 1, "groundStation": "QGroundControl",
        "mission": {"version": 2, "cruiseSpeed": 16, "plannedHomePosition": [14.0340, 100.6120, 5.0],
                    "items": [
                        {"type": "SimpleItem", "command": 22, "frame": 3, "params": [0, 0, 0, None, 14.0340, 100.6120, 40]},
                        {"type": "SimpleItem", "command": 16, "frame": 3, "params": [0, 0, 0, None, 14.0450, 100.6200, 90]},
                        {"type": "SimpleItem", "command": 16, "frame": 3, "params": [0, 0, 0, None, 14.0450, 100.6400, 90]},
                        {"type": "SimpleItem", "command": 16, "frame": 3, "params": [0, 0, 0, None, 14.0410, 100.6400, 90]},
                        {"type": "SimpleItem", "command": 16, "frame": 3, "params": [0, 0, 0, None, 14.0410, 100.6200, 120]},
                        {"type": "SimpleItem", "command": 20, "frame": 2, "params": [0, 0, 0, 0, 0, 0, 0]},
                    ]}}
MAX_ALT = 90                                   # m above home (frame 3)

def haversine(lat1, lon1, lat2, lon2, r=6_371_000):
    p1, p2 = math.radians(lat1), math.radians(lat2)
    dp, dl = p2 - p1, math.radians(lon2 - lon1)
    h = math.sin(dp / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dl / 2) ** 2
    return 2 * r * math.asin(math.sqrt(h))

m = plan["mission"]
home = m["plannedHomePosition"][:2]
points, problems = [home], []
for i, it in enumerate(m["items"], 1):
    if it["command"] in (16, 22):
        lat, lon, alt = it["params"][4:7]
        points.append([lat, lon])
        if alt > MAX_ALT:
            problems.append(f"item {i}: altitude {alt} m > {MAX_ALT} m")
if m["items"][-1]["command"] != 20:
    problems.append("mission does not end with RETURN_TO_LAUNCH")
points.append(home)
legs = [haversine(*points[k], *points[k + 1]) for k in range(len(points) - 1)]
far = max(haversine(*home, *p) for p in points)
print("legs (m):", [round(x) for x in legs])
print(f"total {sum(legs) / 1000:.2f} km, {sum(legs) / m['cruiseSpeed'] / 60:.1f} min at {m['cruiseSpeed']} m/s, farthest {far / 1000:.2f} km from home")
print("problems:", problems or "none")

legs (m): [0, 1497, 2157, 445, 2157, 1162]
total 7.42 km, 7.7 min at 16 m/s, farthest 3.26 km from home
problems: ['item 5: altitude 120 m > 90 m']

The program finds a waypoint above the ceiling, which is easy to miss on the map screen. Checking every mission file with a program before upload is therefore a cheap and effective safety gate. The computed flight time excludes turns, climbs, descents and wind, so add margin.

Example 2 Radio horizon and minimum altitude

import math

def radio_horizon_km(h1, h2):
    return 4.12 * (math.sqrt(h1) + math.sqrt(h2))

def min_drone_alt(d_km, h_gcs):
    x = d_km / 4.12 - math.sqrt(h_gcs)
    return max(0.0, x) ** 2

print(f"GCS 2 m, drone 90 m: horizon {radio_horizon_km(2, 90):.1f} km")
print(f"GCS 10 m mast, drone 90 m: horizon {radio_horizon_km(10, 90):.1f} km")
for d in (5, 20, 40):
    print(f"to keep radio line of sight at {d:>2} km with a 2 m antenna the drone must be above {min_drone_alt(d, 2):.1f} m")

GCS 2 m, drone 90 m: horizon 44.9 km
GCS 10 m mast, drone 90 m: horizon 52.1 km
to keep radio line of sight at  5 km with a 2 m antenna the drone must be above 0.0 m
to keep radio line of sight at 20 km with a 2 m antenna the drone must be above 11.8 m
to keep radio line of sight at 40 km with a 2 m antenna the drone must be above 68.8 m

The mapping area in this case is less than 4 km away, so the radio horizon is not a constraint. But searching 40 km away would need a height of almost 70 m just to clear the Earth’s curvature, before counting obstacles, and would be a beyond-visual-line-of-sight flight needing specific permission.