dronecot 2.2.2__tar.gz → 2.2.4__tar.gz

{dronecot-2.2.2 → dronecot-2.2.4}/CHANGELOG.md

@@ -1,3 +1,10 @@
+## DroneCOT 2.2.3
+
+- SerialWorker: handle MAVLink **ADSB_VEHICLE** messages (in addition to
+  OPEN_DRONE_ID_MESSAGE_PACK), so Remote ID receivers that emit ADS-B-style
+  frames — e.g. the **BlueMark DroneScout Bridge (DS101)** in ADS-B output mode
+  — are decoded to CoT. Adds a test for the ADSB_VEHICLE -> RID conversion.
+
 ## DroneCOT 2.2.2
 
 - Fix UTC timestamp handling on Python 3.9 and 3.10.

{dronecot-2.2.2/dronecot.egg-info → dronecot-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dronecot
-Version: 2.2.2
+Version: 2.2.4
 Summary: Display Drones in Team Awareness Kit (TAK).
 Home-page: https://github.com/snstac/dronecot
 Maintainer: Greg Albrecht <oss@undef.net>

{dronecot-2.2.2 → dronecot-2.2.4/dronecot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dronecot
-Version: 2.2.2
+Version: 2.2.4
 Summary: Display Drones in Team Awareness Kit (TAK).
 Home-page: https://github.com/snstac/dronecot
 Maintainer: Greg Albrecht <oss@undef.net>

{dronecot-2.2.2 → dronecot-2.2.4}/dronecot.egg-info/SOURCES.txt

@@ -27,5 +27,7 @@ src/dronecot/rid_normalize.py
 src/dronecot/udp_rid.py
 src/dronecot/wifi_capture.py
 src/dronecot/wifi_parse.py
+tests/test_adsb_vehicle.py
 tests/test_functions.py
-tests/test_rid_normalize.py
+tests/test_rid_normalize.py
+tests/test_wifi_parse.py

dronecot-2.2.4/src/dronecot/VERSION

@@ -0,0 +1 @@
+2.2.4

{dronecot-2.2.2 → dronecot-2.2.4}/src/dronecot/classes.py

@@ -87,6 +87,35 @@ class SerialWorker(pytak.QueueWorker):
         parsed = dronecot.odid.message_pack_to_dict(messages, pack_size)
         return dronecot.rid_normalize.odid_parsed_to_rid_dict(parsed)
 
+    @staticmethod
+    def _adsb_vehicle_to_rid_dict(msg) -> dict:
+        """Convert a MAVLink ADSB_VEHICLE to a RIDWorker dict.
+
+        The DroneScout Bridge (and similar Remote ID receivers) can emit detected
+        Remote ID as MAVLink ADSB_VEHICLE instead of OPEN_DRONE_ID_MESSAGE_PACK.
+        Units: lat/lon 1e-7 deg, altitude mm, hor/ver velocity cm/s, heading cdeg.
+        Returns {} when there is no position.
+        """
+        lat = getattr(msg, "lat", 0) / 1e7
+        lon = getattr(msg, "lon", 0) / 1e7
+        if not lat and not lon:
+            return {}
+        callsign = getattr(msg, "callsign", "") or ""
+        if isinstance(callsign, bytes):
+            callsign = callsign.decode("ascii", "ignore")
+        callsign = callsign.replace("\x00", "").strip()
+        icao = int(getattr(msg, "ICAO_address", 0) or 0)
+        return {
+            "BasicID": callsign or f"ICAO-{icao:06X}",
+            "Latitude": lat,
+            "Longitude": lon,
+            "AltitudeGeo": getattr(msg, "altitude", 0) / 1000.0,  # mm -> m
+            "SpeedHorizontal": getattr(msg, "hor_velocity", 0) / 100.0,  # cm/s -> m/s
+            "SpeedVertical": getattr(msg, "ver_velocity", 0) / 100.0,
+            "Direction": getattr(msg, "heading", 0) / 100.0,  # cdeg -> deg
+            "data": {"type": "MAVLink ADSB_VEHICLE"},
+        }
+
     async def run(self, _=-1) -> None:
         """Read MAVLink messages from serial and enqueue decoded ODID payloads."""
         self._logger.info("Running SerialWorker")
@@ -154,6 +183,10 @@ class SerialWorker(pytak.QueueWorker):
                         msg.messages, msg.msg_pack_size
                     )
                     await self.put_queue(parsed_payload)
+                elif msg_type == "ADSB_VEHICLE":
+                    rid = self._adsb_vehicle_to_rid_dict(msg)
+                    if rid:
+                        await self.put_queue(rid)
                 elif msg_type == "HEARTBEAT":
                     self._logger.debug(
                         "MAVLink heartbeat received at %s",

{dronecot-2.2.2 → dronecot-2.2.4}/src/dronecot/wifi_parse.py

@@ -157,9 +157,16 @@ def extract_odid_from_dot11(frame_bytes: bytes) -> Optional[Tuple[bytes, Dict[st
 
 
 def extract_odid_from_scapy_packet(packet) -> Optional[Tuple[bytes, Dict[str, Any]]]:
-    """Extract ODID from a Scapy packet (Dot11 layer)."""
+    """Extract ODID from a Scapy packet (Dot11 layer).
+
+    Delegates to the byte-level ``extract_odid_from_dot11`` parser on the
+    serialized Dot11 frame. This avoids a class of Scapy field-type bugs — e.g.
+    ``Dot11EltVendorSpecific.oui`` is an int, so ``bytes(elt.oui)`` builds a huge
+    zero buffer instead of the 3 OUI bytes and the ASTM vendor element never
+    matches — and keeps Wi-Fi Beacon and NAN decoding on one proven code path.
+    """
     try:
-        from scapy.layers.dot11 import Dot11, Dot11Beacon, Dot11EltVendorSpecific, RadioTap  # noqa
+        from scapy.layers.dot11 import Dot11, RadioTap  # noqa
     except ImportError:
         return None
 
@@ -167,40 +174,14 @@ def extract_odid_from_scapy_packet(packet) -> Optional[Tuple[bytes, Dict[str, An
         return None
 
     dot11 = packet.getlayer(Dot11)
-    meta: Dict[str, Any] = {"MAC address": dot11.addr2 or dot11.addr3 or ""}
+    result = extract_odid_from_dot11(bytes(dot11))
+    if not result:
+        return None
 
-    if packet.haslayer(RadioTap) and hasattr(packet[RadioTap], "dBm_AntSignal"):
-        rssi = packet[RadioTap].dBm_AntSignal
+    pack, meta = result
+    # Enrich with Scapy-only signal info when present.
+    if packet.haslayer(RadioTap):
+        rssi = getattr(packet[RadioTap], "dBm_AntSignal", None)
         if rssi is not None:
             meta["RSSI"] = int(rssi)
-
-    subtype = dot11.subtype
-
-    if subtype == 8:  # beacon
-        elt = packet.getlayer(Dot11EltVendorSpecific)
-        while elt:
-            if hasattr(elt, "oui") and hasattr(elt, "info"):
-                oui = bytes(elt.oui) if not isinstance(elt.oui, bytes) else elt.oui
-                info = bytes(elt.info) if elt.info else b""
-                ie_data = oui + info
-                pack = parse_beacon_vendor_ie(ie_data)
-                if pack:
-                    meta["type"] = "WiFi beacon"
-                    if dot11.IDinfo:
-                        meta["channel"] = int(getattr(dot11.IDinfo, "channel", 0) or 0)
-                    return pack, meta
-            elt = elt.payload.getlayer(Dot11EltVendorSpecific)
-    elif subtype == 13:  # action
-        raw = bytes(packet[Dot11].payload) if dot11.payload else b""
-        if not raw and packet.haslayer("Raw"):
-            raw = bytes(packet["Raw"].load)
-        frame = bytes(dot11.build()) + raw if raw else bytes(packet.build())
-        # Rebuild full frame for NAN parser
-        full = bytes(packet.build())
-        result = extract_odid_from_dot11(full)
-        if result:
-            pack, nan_meta = result
-            meta.update(nan_meta)
-            return pack, meta
-
-    return None
+    return pack, meta

dronecot-2.2.4/tests/test_adsb_vehicle.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# Copyright Sensors & Signals LLC https://www.snstac.com/
+# SPDX-License-Identifier: Apache-2.0
+"""Tests for SerialWorker MAVLink ADSB_VEHICLE -> RID dict (DroneScout Bridge)."""
+
+import types
+import unittest
+
+from dronecot.classes import SerialWorker
+
+
+def _adsb(**kw):
+    return types.SimpleNamespace(**kw)
+
+
+class AdsbVehicleTestCase(unittest.TestCase):
+    def test_full_conversion(self):
+        rid = SerialWorker._adsb_vehicle_to_rid_dict(
+            _adsb(
+                lat=407128000, lon=-740060000, altitude=120500,
+                hor_velocity=825, ver_velocity=-50, heading=27000,
+                callsign="DRONE1\x00\x00", ICAO_address=0x123456,
+            )
+        )
+        self.assertAlmostEqual(rid["Latitude"], 40.7128, places=6)
+        self.assertAlmostEqual(rid["Longitude"], -74.0060, places=6)
+        self.assertEqual(rid["AltitudeGeo"], 120.5)          # mm -> m
+        self.assertEqual(rid["SpeedHorizontal"], 8.25)       # cm/s -> m/s
+        self.assertEqual(rid["Direction"], 270.0)            # cdeg -> deg
+        self.assertEqual(rid["BasicID"], "DRONE1")
+
+    def test_no_callsign_falls_back_to_icao(self):
+        rid = SerialWorker._adsb_vehicle_to_rid_dict(
+            _adsb(lat=407128000, lon=-740060000, callsign="", ICAO_address=0x123456)
+        )
+        self.assertEqual(rid["BasicID"], "ICAO-123456")
+
+    def test_no_position_dropped(self):
+        self.assertEqual(SerialWorker._adsb_vehicle_to_rid_dict(_adsb(lat=0, lon=0)), {})
+
+
+if __name__ == "__main__":
+    unittest.main()

dronecot-2.2.4/tests/test_wifi_parse.py

@@ -0,0 +1,53 @@
+"""Tests for Wi-Fi Open Drone ID frame parsing.
+
+Regression for the Scapy beacon path: ``Dot11EltVendorSpecific.oui`` is an int,
+so the old ``bytes(elt.oui)`` built a huge zero buffer and the ASTM vendor
+element never matched — ``extract_odid_from_scapy_packet`` decoded nothing even
+though ``extract_odid_from_dot11`` decoded the same frame.
+"""
+
+import struct
+
+import pytest
+
+from dronecot import wifi_parse
+
+
+def _astm_beacon_frame(pack_body: bytes) -> bytes:
+    """Build a raw 802.11 beacon carrying an ASTM ODID vendor IE."""
+    fc = struct.pack("<H", 0x0080)  # mgmt, subtype 8 (beacon)
+    dur = b"\x00\x00"
+    dst = b"\xff\xff\xff\xff\xff\xff"
+    src = b"\xaa\xbb\xcc\xdd\xee\xff"
+    bssid = src
+    seq = b"\x00\x00"
+    fixed = b"\x00" * 8 + b"\x64\x00" + b"\x00\x00"  # timestamp + interval + caps
+    # Vendor IE: OUI FA:0B:BC, type 0x0D, msg_counter 0x01, then the pack body.
+    ie_payload = wifi_parse.ASTM_WIFI_OUI + bytes([0x0D, 0x01]) + pack_body
+    ie = bytes([0xDD, len(ie_payload)]) + ie_payload
+    return fc + dur + dst + src + bssid + seq + fixed + ie
+
+
+def test_extract_odid_from_dot11_beacon():
+    body = bytes(range(25))
+    frame = _astm_beacon_frame(body)
+    result = wifi_parse.extract_odid_from_dot11(frame)
+    assert result is not None
+    pack, meta = result
+    assert pack == body
+    assert meta.get("type") == "WiFi beacon"
+
+
+def test_extract_odid_from_scapy_packet_matches_raw():
+    """The Scapy path must decode the same beacon the byte parser does."""
+    scapy_dot11 = pytest.importorskip("scapy.layers.dot11")
+    body = bytes(range(25))
+    frame = _astm_beacon_frame(body)
+    pkt = scapy_dot11.Dot11(frame)
+
+    raw = wifi_parse.extract_odid_from_dot11(frame)
+    viascapy = wifi_parse.extract_odid_from_scapy_packet(pkt)
+
+    assert raw is not None
+    assert viascapy is not None, "scapy path failed on a frame the byte parser decoded"
+    assert viascapy[0] == raw[0] == body

dronecot-2.2.2/src/dronecot/VERSION

@@ -1 +0,0 @@
-2.2.2