dronecot 2.3.0__tar.gz → 2.3.2__tar.gz

{dronecot-2.3.0 → dronecot-2.3.2}/CHANGELOG.md

@@ -1,3 +1,26 @@
+## DroneCOT 2.3.1
+
+- **Fix: CoT `ce`/`le` reported ODID accuracy ENUM CODES as if they were metres.**
+  ASTM F3411 accuracy fields are enum codes; CoT `<point ce= le=>` are metres.
+  Emitting the raw code claimed precision the aircraft never reported, and the
+  worst case inverted the meaning entirely: code `0` means *"unknown / >= 18.52
+  km"* but rendered as `ce="0"` — a perfect fix. Observed live on a DroneBeacon
+  DB120: `HorizAccuracy=9` (ODID *< 30 m*) was drawn on the map at **9 m**, and
+  `BaroAccuracy=0` (unknown) as **zero error**. Codes now decode to metres via
+  tables mirroring `decodeHorizontalAccuracy()`/`decodeVerticalAccuracy()` in
+  opendroneid-core-c; unknown and reserved codes emit the CoT unknown sentinel
+  rather than a fabricated number. Four existing tests asserted the old raw
+  codes and have been corrected.
+- **Fix: absent altitude rendered as sea level.** `<height value>` defaulted to
+  `0`; an unknown altitude now uses the CoT unknown sentinel like `hae`/`ce`/`le`.
+- **Fix: MAC-less feeds shared one placeholder UID.** Serial/MAVLink receivers
+  (DroneScout Bridge, SiK) report no MAC, so a Location- or System-only message
+  had neither MAC nor serial and rendered as `Unknown-BasicID_0`, colliding
+  across every such source. The UID now falls back to `FEED-<sensor_id>`.
+  Measured on a live DroneScout Bridge: 57 correctly identified events alongside
+  3 placeholders. Aggregation is deliberately NOT keyed on the feed — one
+  receiver reports many aircraft, so that would merge distinct drones.
+
 ## DroneCOT 2.3.0
 
 Correctness release for single-message Remote ID. A BLE legacy transmitter fits

{dronecot-2.3.0/dronecot.egg-info → dronecot-2.3.2}/PKG-INFO

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

{dronecot-2.3.0 → dronecot-2.3.2/dronecot.egg-info}/PKG-INFO

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

{dronecot-2.3.0 → dronecot-2.3.2}/dronecot.egg-info/SOURCES.txt

@@ -32,6 +32,7 @@ src/dronecot/wifi_parse.py
 tests/test_adsb_vehicle.py
 tests/test_bluez_capture.py
 tests/test_functions.py
+tests/test_mavlink_identity.py
 tests/test_rid_normalize.py
 tests/test_rid_track.py
 tests/test_sensor_detail.py

dronecot-2.3.2/src/dronecot/VERSION

@@ -0,0 +1 @@
+2.3.2

{dronecot-2.3.0 → dronecot-2.3.2}/src/dronecot/classes.py

@@ -82,13 +82,64 @@ class SerialWorker(pytak.QueueWorker):
 
         return serial_port, baud_rate
 
-    def _mavlink_pack_to_parse_payload_schema(self, messages, pack_size) -> dict:
+    @staticmethod
+    def _id_or_mac_to_mac(id_or_mac) -> Optional[str]:
+        """Render a MAVLink OpenDroneID ``id_or_mac`` field as an advertiser MAC.
+
+        ODID carries a 20-byte ``id_or_mac`` naming the TRANSMITTER, and it is the
+        only per-aircraft grouping key a MAVLink serial feed offers -- unlike a
+        BLE or Wi-Fi capture there is no radio MAC in the metadata.
+
+        Measured on a DroneScout DS110: populated on 58 of 58 packs, as
+        db:13:81:94:13:55 followed by 14 zero bytes.
+
+        Only a MAC-shaped value (6 significant bytes then padding) is returned.
+        The field may instead carry an opaque ID string, and calling that a MAC
+        would put a wrong-looking value in the CoT UID; such feeds keep the
+        previous behaviour until there is real hardware to test against.
+        """
+        if id_or_mac is None:
+            return None
+        raw = bytes(bytearray(id_or_mac))
+        if not any(raw) or len(raw) < 6 or any(raw[6:]):
+            return None
+        return ":".join("%02X" % b for b in raw[:6])
+
+    def _mavlink_meta(self, id_or_mac=None, payload_type: Optional[str] = None) -> dict:
+        """Sensor metadata for a MAVLink-sourced record.
+
+        The wireless path builds this via rid_normalize.bytes_to_rid_dict; the
+        MAVLink path used to skip it entirely and hand up a record with no
+        ``data`` sub-dict at all. Two consequences, both seen on a live box:
+
+          * no transmitter identity, so a pack carrying only System/OperatorID
+            and no BasicID had nothing to aggregate on and rendered as
+            op-Unknown-BasicID_0 -- every operator in range on ONE track;
+          * no sensor_id, so CoT was attributed to the default
+            dronecot_<hostname> rather than the configured SENSOR_ID, making it
+            impossible to tell which receiver saw a contact.
+        """
+        data = dronecot.rid_normalize.uas_meta_defaults(self.config)
+        if payload_type:
+            data["type"] = payload_type
+        mac = self._id_or_mac_to_mac(id_or_mac)
+        if mac:
+            data["MAC address"] = mac
+        return data
+
+    def _mavlink_pack_to_parse_payload_schema(
+        self, messages, pack_size, id_or_mac=None
+    ) -> dict:
         """Convert MAVLink OPEN_DRONE_ID_MESSAGE_PACK to parse_payload-like schema."""
         parsed = dronecot.odid.message_pack_to_dict(messages, pack_size)
-        return dronecot.rid_normalize.odid_parsed_to_rid_dict(parsed)
+        rid = dronecot.rid_normalize.odid_parsed_to_rid_dict(parsed)
+        rid["data"] = self._mavlink_meta(
+            id_or_mac, payload_type="MAVLink OPEN_DRONE_ID_MESSAGE_PACK"
+        )
+        return rid
 
     @staticmethod
-    def _adsb_vehicle_to_rid_dict(msg) -> dict:
+    def _adsb_vehicle_to_rid_dict(msg, meta: Optional[dict] = None) -> dict:
         """Convert a MAVLink ADSB_VEHICLE to a RIDWorker dict.
 
         The DroneScout Bridge (and similar Remote ID receivers) can emit detected
@@ -113,7 +164,7 @@ class SerialWorker(pytak.QueueWorker):
             "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"},
+            "data": dict(meta) if meta else {"type": "MAVLink ADSB_VEHICLE"},
         }
 
     async def run(self, _=-1) -> None:
@@ -180,11 +231,19 @@ class SerialWorker(pytak.QueueWorker):
                 msg_type = msg.get_type()
                 if msg_type == "OPEN_DRONE_ID_MESSAGE_PACK":
                     parsed_payload = self._mavlink_pack_to_parse_payload_schema(
-                        msg.messages, msg.msg_pack_size
+                        msg.messages,
+                        msg.msg_pack_size,
+                        getattr(msg, "id_or_mac", None),
                     )
                     await self.put_queue(parsed_payload)
                 elif msg_type == "ADSB_VEHICLE":
-                    rid = self._adsb_vehicle_to_rid_dict(msg)
+                    rid = self._adsb_vehicle_to_rid_dict(
+                        msg,
+                        self._mavlink_meta(
+                            getattr(msg, "id_or_mac", None),
+                            payload_type="MAVLink ADSB_VEHICLE",
+                        ),
+                    )
                     if rid:
                         await self.put_queue(rid)
                 elif msg_type == "HEARTBEAT":

{dronecot-2.3.0 → dronecot-2.3.2}/src/dronecot/functions.py

@@ -190,6 +190,60 @@ def _cot_event_with_detail(
     )
 
 
+# ASTM F3411 / Open Drone ID accuracy fields are ENUM CODES, not metres. CoT
+# <point ce=/le=> are metres. Emitting the raw code claims a precision the
+# aircraft never reported -- and the worst case inverts the meaning entirely:
+# code 0 means "unknown / >= 18.52 km" but rendered as ce="0", i.e. a PERFECT
+# fix. Observed live: a DroneBeacon reporting HorizAccuracy=9 (<30 m) was drawn
+# on the map at 9 m, and BaroAccuracy=0 (unknown) as zero error.
+#
+# Values mirror decodeHorizontalAccuracy()/decodeVerticalAccuracy() in
+# opendroneid-core-c. Each code is an upper bound ("less than X"), so using X is
+# the conservative reading.
+CE_LE_UNKNOWN = "9999999.0"
+
+ODID_HORIZ_ACCURACY_M = {
+    1: 18520.0,  # 10 NM
+    2: 7408.0,   # 4 NM
+    3: 3704.0,   # 2 NM
+    4: 1852.0,   # 1 NM
+    5: 926.0,    # 0.5 NM
+    6: 555.6,    # 0.3 NM
+    7: 185.2,    # 0.1 NM
+    8: 92.6,     # 0.05 NM
+    9: 30.0,
+    10: 10.0,
+    11: 3.0,
+    12: 1.0,
+}
+
+ODID_VERT_ACCURACY_M = {1: 150.0, 2: 45.0, 3: 25.0, 4: 10.0, 5: 3.0, 6: 1.0}
+
+
+def _odid_accuracy_m(value, table) -> str:
+    """Map an ODID accuracy enum code to metres for CoT ce/le.
+
+    Returns the CoT unknown sentinel for code 0 (explicitly "unknown"), for any
+    unlisted/reserved code, and for a missing value -- never a fabricated 0.
+    """
+    if value is None:
+        return CE_LE_UNKNOWN
+    try:
+        code = int(value)
+    except (TypeError, ValueError):
+        return CE_LE_UNKNOWN
+    metres = table.get(code)
+    return CE_LE_UNKNOWN if metres is None else str(metres)
+
+
+def _odid_horiz_ce(data: dict) -> str:
+    return _odid_accuracy_m(data.get("HorizAccuracy"), ODID_HORIZ_ACCURACY_M)
+
+
+def _odid_vert_le(data: dict) -> str:
+    return _odid_accuracy_m(data.get("VertAccuracy"), ODID_VERT_ACCURACY_M)
+
+
 def _rid_identity(data: dict) -> Tuple[str, Optional[str]]:
     """Resolve a stable UAS identifier and the advertiser MAC for CoT UIDs.
 
@@ -208,7 +262,24 @@ def _rid_identity(data: dict) -> Tuple[str, Optional[str]]:
     uasid = data.get("BasicID") or data.get("BasicID_0")
     uasid = str(uasid).strip() if uasid else ""
     if not uasid:
-        uasid = f"MAC-{mac.replace(':', '').upper()}" if mac else "Unknown-BasicID_0"
+        if mac:
+            uasid = f"MAC-{mac.replace(':', '').upper()}"
+        else:
+            # Neither serial nor MAC: serial/MAVLink receivers report no MAC at
+            # all. Fall back to the feed that delivered it so two receivers do
+            # not collide, rather than the shared Unknown-BasicID_0 placeholder
+            # that put every such aircraft on one track.
+            # Checked at BOTH levels, for the same reason the MAC is: MQTT and
+            # serial feeds put this at the top level. Looking only in the
+            # sub-dict meant this rung silently never fired for them.
+            feed = (
+                src_data.get("sensor_id")
+                or src_data.get("sensor ID")
+                or data.get("sensor_id")
+                or data.get("sensor ID")
+            )
+            feed = str(feed).strip() if feed else ""
+            uasid = f"FEED-{feed}" if feed else "Unknown-BasicID_0"
 
     return uasid, mac
 
@@ -298,8 +369,8 @@ def rid_op_to_cot_xml(  # NOQA pylint: disable=too-many-locals,too-many-branches
         stale=cot_stale,
         lat=lat,
         lon=lon,
-        ce=str(data.get("HorizAccuracy", "9999999.0")),
-        le=str(data.get("VertAccuracy", "9999999.0")),
+        ce=_odid_horiz_ce(data),
+        le=_odid_vert_le(data),
         hae=str(data.get("OperatorAltitudeGeo", "9999999.0")),
         detail=detail,
         config=config,
@@ -365,7 +436,9 @@ def rid_uas_to_cot_xml(  # NOQA pylint: disable=too-many-locals,too-many-branche
     track.set("course", str(data.get("Direction", 0)))
 
     height: ET.Element = ET.Element("height")
-    height.set("value", str(data.get("AltitudeGeo", 0)))
+    # Never default to 0: an absent altitude is unknown, not sea level. Matches
+    # the CoT unknown sentinel used for hae/ce/le above.
+    height.set("value", str(data.get("AltitudeGeo", CE_LE_UNKNOWN)))
 
     # link: ET.Element = ET.Element("link")
     # link.set("uid", op_uid)
@@ -490,8 +563,8 @@ def rid_uas_to_cot_xml(  # NOQA pylint: disable=too-many-locals,too-many-branche
         stale=cot_stale,
         lat=lat,
         lon=lon,
-        ce=str(data.get("HorizAccuracy", "9999999.0")),
-        le=str(data.get("VertAccuracy", "9999999.0")),
+        ce=_odid_horiz_ce(data),
+        le=_odid_vert_le(data),
         hae=str(data.get("AltitudeGeo", "9999999.0")),
         detail=detail,
         config=config,
@@ -572,8 +645,8 @@ def sensor_status_to_cot(  # NOQA pylint: disable=too-many-locals,too-many-branc
         stale=cot_stale,
         lat=lat,
         lon=lon,
-        ce=str(data.get("HorizAccuracy", "9999999.0")),
-        le=str(data.get("VertAccuracy", "9999999.0")),
+        ce=_odid_horiz_ce(data),
+        le=_odid_vert_le(data),
         hae=hae,
         detail=detail,
         config=config,

{dronecot-2.3.0 → dronecot-2.3.2}/src/dronecot/rid_track.py

@@ -94,8 +94,21 @@ def _is_empty(value: Any) -> bool:
 def track_key(rid: dict) -> Optional[Tuple[str, str]]:
     """Return a ``(kind, value)`` aggregation key for a normalized RID dict.
 
-    Returns ``None`` when the record identifies no transmitter at all, in which
-    case it cannot be safely merged with anything and should pass through.
+    Keyed on the advertiser MAC, falling back to the transmitter's own serial.
+
+    Deliberately NOT keyed on the feed/sensor when neither is present. It is
+    tempting -- a MAC-less serial receiver looks like a single stream -- but a
+    DroneScout-style receiver reports MANY aircraft over one port, so feeding
+    them all into one key would merge distinct drones into a single track: the
+    exact bug this module exists to fix, reintroduced by another route. It also
+    splits rather than merges, because a BasicID message would key on the serial
+    while a Location message from the same aircraft keyed on the feed.
+
+    So a record with neither MAC nor serial passes through unaggregated, and
+    only its rendered UID falls back to the feed (see functions._rid_identity)
+    so that unidentified contacts from different receivers stay distinct.
+
+    Returns ``None`` when the record identifies no transmitter at all.
     """
     meta = rid.get(_META_KEY) or {}
     mac = meta.get("MAC address")

{dronecot-2.3.0 → dronecot-2.3.2}/tests/test_functions.py

@@ -73,8 +73,11 @@ class FunctionsTestCase(unittest.TestCase):
         self.assertIsNotNone(point)
         self.assertEqual(point.get("lat"), "37.7599")
         self.assertEqual(point.get("lon"), "-122.4977")
-        self.assertEqual(point.get("ce"), "12")
-        self.assertEqual(point.get("le"), "5")
+        # ODID accuracy codes, decoded to METRES for CoT: HorizAccuracy 12 is
+        # ODID_HOR_ACC_1_METER and VertAccuracy 5 is ODID_VER_ACC_3_METER. These
+        # previously asserted the raw codes "12"/"5", which claimed 12 m / 5 m.
+        self.assertEqual(point.get("ce"), "1.0")
+        self.assertEqual(point.get("le"), "3.0")
         self.assertEqual(point.get("hae"), "28.0")
 
         detail = cot_xml.find("detail")
@@ -113,8 +116,11 @@ class FunctionsTestCase(unittest.TestCase):
         self.assertIsNotNone(point)
         self.assertEqual(point.get("lat"), "37.7599")
         self.assertEqual(point.get("lon"), "-122.4977")
-        self.assertEqual(point.get("ce"), "12")
-        self.assertEqual(point.get("le"), "5")
+        # ODID accuracy codes, decoded to METRES for CoT: HorizAccuracy 12 is
+        # ODID_HOR_ACC_1_METER and VertAccuracy 5 is ODID_VER_ACC_3_METER. These
+        # previously asserted the raw codes "12"/"5", which claimed 12 m / 5 m.
+        self.assertEqual(point.get("ce"), "1.0")
+        self.assertEqual(point.get("le"), "3.0")
         self.assertEqual(point.get("hae"), "28.0")
 
         detail = cot_xml.find("detail")
@@ -153,8 +159,11 @@ class FunctionsTestCase(unittest.TestCase):
         self.assertIsNotNone(point)
         self.assertEqual(point.get("lat"), "37.7599")
         self.assertEqual(point.get("lon"), "-122.4977")
-        self.assertEqual(point.get("ce"), "12")
-        self.assertEqual(point.get("le"), "5")
+        # ODID accuracy codes, decoded to METRES for CoT: HorizAccuracy 12 is
+        # ODID_HOR_ACC_1_METER and VertAccuracy 5 is ODID_VER_ACC_3_METER. These
+        # previously asserted the raw codes "12"/"5", which claimed 12 m / 5 m.
+        self.assertEqual(point.get("ce"), "1.0")
+        self.assertEqual(point.get("le"), "3.0")
         self.assertEqual(point.get("hae"), "28.0")
 
         detail = cot_xml.find("detail")
@@ -193,8 +202,11 @@ class FunctionsTestCase(unittest.TestCase):
         self.assertIsNotNone(point)
         self.assertEqual(point.get("lat"), "37.7599")
         self.assertEqual(point.get("lon"), "-122.4977")
-        self.assertEqual(point.get("ce"), "12")
-        self.assertEqual(point.get("le"), "5")
+        # ODID accuracy codes, decoded to METRES for CoT: HorizAccuracy 12 is
+        # ODID_HOR_ACC_1_METER and VertAccuracy 5 is ODID_VER_ACC_3_METER. These
+        # previously asserted the raw codes "12"/"5", which claimed 12 m / 5 m.
+        self.assertEqual(point.get("ce"), "1.0")
+        self.assertEqual(point.get("le"), "3.0")
         self.assertEqual(point.get("hae"), "28.0")
 
         detail = cot_xml.find("detail")

dronecot-2.3.2/tests/test_mavlink_identity.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+# Copyright Sensors & Signals LLC https://www.snstac.com/
+# SPDX-License-Identifier: Apache-2.0
+"""Transmitter identity on the MAVLink serial feed (DroneScout Bridge).
+
+Regression tests for operator tracks collapsing onto op-Unknown-BasicID_0.
+
+Measured on a live box (aryaos-4f11, DroneScout DS110, dronecot 2.3.1), 30s of
+CoT on the Mesh SA group, attributed by source IP:
+
+    op-Unknown-BasicID_0          x62   <- every operator on ONE track
+    RID.1787F04BM24010011195.uas  x54   correct
+    op-1787F04BM24010011195       x54   correct
+
+The aircraft UID resolved but the operator UID did not. Cause: the MAVLink path
+called rid_normalize.odid_parsed_to_rid_dict directly and attached no ``data``
+metadata at all, unlike the wireless path (bytes_to_rid_dict). With no MAC and no
+sensor_id, a pack carrying only System/OperatorID had no transmitter identity to
+key on, so functions._rid_identity fell all the way to Unknown-BasicID_0.
+
+MAVLink OpenDroneID carries a 20-byte ``id_or_mac`` naming the transmitter. The
+DS110 populates it on every pack -- measured 58 of 58, as
+db:13:81:94:13:55 + 14 zero bytes -- and it is the only per-aircraft grouping key
+a serial feed offers.
+"""
+
+import types
+import unittest
+from unittest import mock
+
+from dronecot.classes import SerialWorker
+from dronecot.functions import _rid_identity
+
+# Exactly what the DS110 sent, including the 14 bytes of padding.
+DS110_ID_OR_MAC = bytes.fromhex("db13819413550000000000000000000000000000")
+DS110_MAC = "DB:13:81:94:13:55"
+
+
+def _worker(sensor_id="dronescout"):
+    """A SerialWorker with just enough state for the metadata helpers."""
+    w = SerialWorker.__new__(SerialWorker)
+    w.config = {"SENSOR_ID": sensor_id}
+    return w
+
+
+class IdOrMacTestCase(unittest.TestCase):
+    def test_real_ds110_value_renders_as_mac(self):
+        self.assertEqual(SerialWorker._id_or_mac_to_mac(DS110_ID_OR_MAC), DS110_MAC)
+
+    def test_all_zeros_is_no_identity(self):
+        self.assertIsNone(SerialWorker._id_or_mac_to_mac(bytes(20)))
+
+    def test_absent_is_no_identity(self):
+        self.assertIsNone(SerialWorker._id_or_mac_to_mac(None))
+
+    def test_opaque_id_is_not_claimed_to_be_a_mac(self):
+        """Payload past byte 6 means this is an ID string, not a MAC.
+
+        Rendering it as one would put a wrong-looking value in the CoT UID, so it
+        is left alone rather than guessed at.
+        """
+        self.assertIsNone(SerialWorker._id_or_mac_to_mac(b"SERIAL12345678901234"))
+
+    def test_accepts_a_bare_six_byte_field(self):
+        self.assertEqual(
+            SerialWorker._id_or_mac_to_mac(bytes.fromhex("db13819413 55".replace(" ", ""))),
+            DS110_MAC,
+        )
+
+
+class MavlinkMetaTestCase(unittest.TestCase):
+    def test_meta_carries_identity_and_configured_sensor_id(self):
+        meta = _worker()._mavlink_meta(DS110_ID_OR_MAC, payload_type="pack")
+        self.assertEqual(meta["MAC address"], DS110_MAC)
+        # Previously absent, so CoT was attributed to dronecot_<hostname> and you
+        # could not tell which receiver saw a contact.
+        self.assertEqual(meta["sensor_id"], "dronescout")
+        self.assertEqual(meta["type"], "pack")
+
+    def test_no_identity_still_yields_sensor_id(self):
+        meta = _worker()._mavlink_meta(bytes(20))
+        self.assertNotIn("MAC address", meta)
+        self.assertEqual(meta["sensor_id"], "dronescout")
+
+
+class PackIdentityTestCase(unittest.TestCase):
+    """The actual regression: a pack with no BasicID must still identify itself."""
+
+    def _pack(self, parsed):
+        with mock.patch("dronecot.odid.message_pack_to_dict", return_value=parsed):
+            return _worker()._mavlink_pack_to_parse_payload_schema(
+                b"\x00" * 25, 1, DS110_ID_OR_MAC
+            )
+
+    def test_pack_without_basicid_gets_a_distinct_uid(self):
+        rid = self._pack({"OperatorLatitude": 37.7, "OperatorLongitude": -122.4})
+        uasid, mac = _rid_identity(rid)
+        self.assertEqual(mac, DS110_MAC)
+        # The bug: this was "Unknown-BasicID_0" for every transmitter in range.
+        self.assertNotEqual(uasid, "Unknown-BasicID_0")
+        self.assertEqual(uasid, "MAC-DB1381941355")
+
+    def test_pack_with_basicid_prefers_the_real_serial(self):
+        rid = self._pack({"UASID": "1787F04BM24010011195"})
+        uasid, mac = _rid_identity(rid)
+        self.assertEqual(uasid, "1787F04BM24010011195")
+        self.assertEqual(mac, DS110_MAC)
+
+    def test_two_transmitters_do_not_collapse(self):
+        """The DS110 reports many aircraft over one port; they must stay distinct."""
+        other = bytes.fromhex("aabbccddeeff" + "00" * 14)
+        with mock.patch("dronecot.odid.message_pack_to_dict", return_value={}):
+            a = _worker()._mavlink_pack_to_parse_payload_schema(
+                b"\x00" * 25, 1, DS110_ID_OR_MAC
+            )
+            b = _worker()._mavlink_pack_to_parse_payload_schema(
+                b"\x00" * 25, 1, other
+            )
+        self.assertNotEqual(_rid_identity(a)[0], _rid_identity(b)[0])
+
+
+class SensorIdFallbackTestCase(unittest.TestCase):
+    """_rid_identity looked for sensor_id only in data['data'].
+
+    The MAC was already checked at both levels because "MQTT and serial feeds put
+    it at the top level" -- the same is true of sensor_id, so that rung of the
+    fallback silently never fired for those feeds.
+    """
+
+    def test_top_level_sensor_id_is_used(self):
+        uasid, mac = _rid_identity({"sensor_id": "dronescout"})
+        self.assertIsNone(mac)
+        self.assertEqual(uasid, "FEED-dronescout")
+
+    def test_nested_sensor_id_still_works(self):
+        uasid, _ = _rid_identity({"data": {"sensor_id": "dronescout"}})
+        self.assertEqual(uasid, "FEED-dronescout")
+
+    def test_nothing_at_all_is_still_the_last_resort(self):
+        uasid, _ = _rid_identity({})
+        self.assertEqual(uasid, "Unknown-BasicID_0")
+
+
+if __name__ == "__main__":
+    unittest.main()

{dronecot-2.3.0 → dronecot-2.3.2}/tests/test_rid_track.py

@@ -267,6 +267,56 @@ class TestFieldPadding(unittest.TestCase):
         self.assertEqual(event.get("uid"), "RID.SHORTSN.uas")
 
 
+class TestMaclessSources(unittest.TestCase):
+    """Serial/MAVLink receivers report no MAC at all.
+
+    Measured on a live DroneScout Bridge: 57 correctly identified events
+    alongside 3 rendered under the shared ``Unknown-BasicID_0`` placeholder.
+
+    These records must NOT be aggregated on the feed -- one receiver reports
+    many aircraft, so a feed key would merge distinct drones. Instead they pass
+    through, and only the rendered UID falls back to the feed so contacts from
+    different receivers stay distinct.
+    """
+
+    @staticmethod
+    def _serial_rid(msg, sensor="dronescout"):
+        """Normalize a message the way a serial worker does: NO MAC address."""
+        return rid_normalize.bytes_to_rid_dict(
+            msg, {"sensor_id": sensor, "type": "MAVLink"}
+        )
+
+    def test_macless_without_serial_uses_feed_not_placeholder(self):
+        """The fix: never render under the shared placeholder UID."""
+        rid = self._serial_rid(_system_message(51.5, -0.12))
+        uid, mac = functions._rid_identity(rid)
+        self.assertIsNone(mac)
+        self.assertEqual(uid, "FEED-dronescout")
+        self.assertNotEqual(uid, "Unknown-BasicID_0")
+
+    def test_different_receivers_stay_distinct(self):
+        a = functions._rid_identity(self._serial_rid(_system_message(1.0, 2.0), "rx-a"))[0]
+        b = functions._rid_identity(self._serial_rid(_system_message(3.0, 4.0), "rx-b"))[0]
+        self.assertNotEqual(a, b)
+
+    def test_serial_wins_over_feed_in_uid(self):
+        rid = self._serial_rid(_basic_id_message("SERIAL9"))
+        self.assertEqual(functions._rid_identity(rid)[0], "SERIAL9")
+
+    def test_feed_is_NOT_used_as_an_aggregation_key(self):
+        """Guard against merging distinct aircraft from one multi-drone feed."""
+        rid = self._serial_rid(_location_message(51.5, -0.12))
+        self.assertIsNone(
+            rid_track.track_key(rid),
+            "a MAC-less, serial-less record must not be keyed on its feed",
+        )
+
+    def test_mac_still_wins_when_present(self):
+        rid = _rid(_location_message(1.0, 2.0), "AA:BB:CC:DD:EE:FF")
+        rid["data"]["sensor_id"] = "dronescout"
+        self.assertEqual(rid_track.track_key(rid)[0], "mac")
+
+
 class TestRidIdentity(unittest.TestCase):
     def test_missing_basic_id_falls_back_to_mac(self):
         rid = _rid(_location_message(1.0, 2.0), "DF:72:11:D2:6B:95")
@@ -300,3 +350,52 @@ class TestRidIdentity(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class TestAccuracyEnums(unittest.TestCase):
+    """ODID accuracy fields are enum CODES; CoT ce/le are METRES.
+
+    Emitting the raw code claims precision the aircraft never reported. Worst
+    case inverts the meaning: code 0 means "unknown / >= 18.52 km" but rendered
+    as ce="0" -- a perfect fix. Observed live on a DroneBeacon: HorizAccuracy=9
+    (<30 m) drawn at 9 m, BaroAccuracy=0 (unknown) as zero error.
+    """
+
+    def test_horizontal_codes_map_to_metres(self):
+        # Mirrors decodeHorizontalAccuracy() in opendroneid-core-c.
+        for code, metres in ((9, "30.0"), (10, "10.0"), (11, "3.0"), (12, "1.0"),
+                             (1, "18520.0"), (6, "555.6")):
+            self.assertEqual(functions._odid_horiz_ce({"HorizAccuracy": code}), metres)
+
+    def test_vertical_codes_map_to_metres(self):
+        for code, metres in ((1, "150.0"), (2, "45.0"), (4, "10.0"), (6, "1.0")):
+            self.assertEqual(functions._odid_vert_le({"VertAccuracy": code}), metres)
+
+    def test_unknown_code_zero_is_not_perfect_precision(self):
+        """The dangerous inversion: 0 means UNKNOWN, never zero error."""
+        self.assertEqual(functions._odid_horiz_ce({"HorizAccuracy": 0}),
+                         functions.CE_LE_UNKNOWN)
+        self.assertEqual(functions._odid_vert_le({"VertAccuracy": 0}),
+                         functions.CE_LE_UNKNOWN)
+
+    def test_missing_or_reserved_codes_are_unknown(self):
+        for probe in ({}, {"HorizAccuracy": None}, {"HorizAccuracy": 15},
+                      {"HorizAccuracy": "junk"}):
+            self.assertEqual(functions._odid_horiz_ce(probe), functions.CE_LE_UNKNOWN)
+
+    def test_end_to_end_cot_uses_metres_not_the_code(self):
+        pack = (bytes([0xF0, ODID_MESSAGE_SIZE, 2])
+                + _basic_id_message("SERIAL1") + _location_message(37.7, -122.4))
+        rid = rid_normalize.bytes_to_rid_dict(pack, {"MAC address": "AA:BB:CC:DD:EE:FF"})
+        rid["HorizAccuracy"] = 9   # ODID: < 30 m
+        rid["VertAccuracy"] = 2    # ODID: < 45 m
+        point = functions.rid_uas_to_cot_xml(rid, {}).find("point")
+        self.assertEqual(point.get("ce"), "30.0")
+        self.assertEqual(point.get("le"), "45.0")
+
+    def test_absent_altitude_is_not_rendered_as_sea_level(self):
+        rid = _rid(_location_message(1.0, 2.0), "AA:BB:CC:DD:EE:FF")
+        rid.pop("AltitudeGeo", None)
+        event = functions.rid_uas_to_cot_xml(rid, {})
+        height = event.find(".//height")
+        self.assertEqual(height.get("value"), functions.CE_LE_UNKNOWN)

dronecot-2.3.0/src/dronecot/VERSION

@@ -1 +0,0 @@
-2.3.0