pyfastnet 2.0.13__tar.gz → 2.0.15__tar.gz

{pyfastnet-2.0.13/pyfastnet.egg-info → pyfastnet-2.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyfastnet
-Version: 2.0.13
+Version: 2.0.15
 Summary: A Python library for decoding FastNet protocol data streams.
 Home-page: https://github.com/ghotihook/pyfastnet
 Author: Alex Salmon
@@ -17,6 +17,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-python
 Dynamic: summary
 
@@ -99,6 +100,22 @@ Each decoded frame is a dict with `to_address`, `from_address`, `command`, and `
 }
 ```
 
+### Position (LatLon) frames
+
+Position frames (command `LatLon`) appear under the `"LatLon"` key. The raw coordinate
+string (`DDMM.mmm` with hemisphere letters) is carried in `display_text`; `value` is
+`None`. The originating source's marker byte is preserved in `channel_id` (e.g. `0x47`,
+`0x4E`) but does not affect the key:
+
+```python
+"LatLon": {
+    "channel_id":   "0x4E",
+    "value":        None,
+    "display_text": "3352.450S15113.920E",
+    "layout":       None,
+}
+```
+
 ### Layout field
 
 The `layout` field describes the indicator symbol shown on the physical display around the numeric value:

{pyfastnet-2.0.13 → pyfastnet-2.0.15}/README.md

@@ -77,6 +77,22 @@ Each decoded frame is a dict with `to_address`, `from_address`, `command`, and `
 }
 ```
 
+### Position (LatLon) frames
+
+Position frames (command `LatLon`) appear under the `"LatLon"` key. The raw coordinate
+string (`DDMM.mmm` with hemisphere letters) is carried in `display_text`; `value` is
+`None`. The originating source's marker byte is preserved in `channel_id` (e.g. `0x47`,
+`0x4E`) but does not affect the key:
+
+```python
+"LatLon": {
+    "channel_id":   "0x4E",
+    "value":        None,
+    "display_text": "3352.450S15113.920E",
+    "layout":       None,
+}
+```
+
 ### Layout field
 
 The `layout` field describes the indicator symbol shown on the physical display around the numeric value:

{pyfastnet-2.0.13 → pyfastnet-2.0.15}/fastnet_decoder/decode_fastnet.py

@@ -16,13 +16,13 @@ _DECIMAL_PLACES_MAP = {1: 0, 10: 1, 100: 2, 1000: 3}
 #   "°M"       →  magnetic bearing, suffix added after value
 
 def _sign_from_layout(layout: str) -> int:
-    return -1 if layout in ("-[data]", "=[data]", "L[data]") else 1
+    return -1 if layout in ("-[data]", "=[data]", "L[data]", "H[data]") else 1
 
 
 def _display_from_layout(layout: str, formatted: str) -> str:
     if layout is None:        return formatted
     if layout == "°M":        return f"{formatted}°M"
-    if layout == "H[data]":   return f"H{formatted}"
+    if layout == "H[data]":   return f"H{formatted.lstrip('-')}"
     if layout == "[data]H":   return f"{formatted}H"
     if layout == "[data]=":   return f"{formatted}="
     if layout == "[data]-":   return f"{formatted}-"
@@ -119,9 +119,14 @@ def decode_ascii_frame(frame: bytes) -> dict:
         channel_id   = body[0]
         # body[1] is a format byte — not used for ASCII frames
         data_bytes   = body[2:]
-        channel_name = CHANNEL_LOOKUP.get(channel_id)
-        if channel_name is None:
-            channel_name = f"Unknown (0x{channel_id:02X})"
+        # This decoder is only ever called for LatLon command frames, so the
+        # entry is named from the command — not from body[0]. body[0] is a
+        # source/marker byte that varies by GPS unit (0x47, 0x4E, ...) and is
+        # NOT a generic channel id; looking it up in CHANNEL_LOOKUP produced
+        # nonsense names like "Apparent Wind Speed (Raw)". The raw byte is kept
+        # in channel_id below for diagnostics.
+        cmd_name     = COMMAND_LOOKUP.get(command)
+        channel_name = cmd_name if cmd_name is not None else f"Unknown (0x{command:02X})"
 
         try:
             ascii_text = data_bytes.decode("ascii").strip()
@@ -133,7 +138,6 @@ def decode_ascii_frame(frame: bytes) -> dict:
 
         to_name   = ADDRESS_LOOKUP.get(to_address)
         from_name = ADDRESS_LOOKUP.get(from_address)
-        cmd_name  = COMMAND_LOOKUP.get(command)
 
         return {
             "to_address":   to_name   if to_name   is not None else f"Unknown (0x{to_address:02X})",

{pyfastnet-2.0.13 → pyfastnet-2.0.15}/fastnet_decoder/mappings.py

@@ -192,7 +192,6 @@ CHANNEL_LOOKUP = {
     0x42: "Boatspeed (Raw)",
     0x44: "Yaw rate",
     0x46: "Autopilot Speed Fixed (Knots)",
-    0x47: "LatLon",
     0x49: "Heading",
     0x4A: "Heading (Raw)",
     0x4D: "Apparent Wind Speed (Knots)",

{pyfastnet-2.0.13 → pyfastnet-2.0.15/pyfastnet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyfastnet
-Version: 2.0.13
+Version: 2.0.15
 Summary: A Python library for decoding FastNet protocol data streams.
 Home-page: https://github.com/ghotihook/pyfastnet
 Author: Alex Salmon
@@ -17,6 +17,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-python
 Dynamic: summary
 
@@ -99,6 +100,22 @@ Each decoded frame is a dict with `to_address`, `from_address`, `command`, and `
 }
 ```
 
+### Position (LatLon) frames
+
+Position frames (command `LatLon`) appear under the `"LatLon"` key. The raw coordinate
+string (`DDMM.mmm` with hemisphere letters) is carried in `display_text`; `value` is
+`None`. The originating source's marker byte is preserved in `channel_id` (e.g. `0x47`,
+`0x4E`) but does not affect the key:
+
+```python
+"LatLon": {
+    "channel_id":   "0x4E",
+    "value":        None,
+    "display_text": "3352.450S15113.920E",
+    "layout":       None,
+}
+```
+
 ### Layout field
 
 The `layout` field describes the indicator symbol shown on the physical display around the numeric value:

{pyfastnet-2.0.13 → pyfastnet-2.0.15}/pyfastnet.egg-info/SOURCES.txt

@@ -12,13 +12,21 @@ pyfastnet.egg-info/PKG-INFO
 pyfastnet.egg-info/SOURCES.txt
 pyfastnet.egg-info/dependency_links.txt
 pyfastnet.egg-info/top_level.txt
-tests/test_apparent_frame.py
-tests/test_autopilot_frame.py
-tests/test_channels.py
+tests/test_autopilot.py
+tests/test_awa.py
+tests/test_aws.py
+tests/test_battery.py
+tests/test_boatspeed.py
 tests/test_depth_frame.py
 tests/test_format07_msb_regression.py
 tests/test_format08_layout.py
-tests/test_heel_frame.py
-tests/test_rudder_frame.py
-tests/test_tide_frame.py
-tests/test_true_frame.py
+tests/test_heading.py
+tests/test_heel_trim.py
+tests/test_latlon_frame.py
+tests/test_sea_temp.py
+tests/test_sog.py
+tests/test_tidal.py
+tests/test_timer.py
+tests/test_twa.py
+tests/test_twd.py
+tests/test_tws.py

{pyfastnet-2.0.13 → pyfastnet-2.0.15}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="pyfastnet",
-    version="2.0.13",  # Ensure this matches your intended version
+    version="2.0.15",
     author="Alex Salmon",
     author_email="alex@ivila.net",
     description="A Python library for decoding FastNet protocol data streams.",

pyfastnet-2.0.15/tests/test_autopilot.py

@@ -0,0 +1,74 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_frame
+
+
+def _decode(hex_str):
+    result = decode_frame(bytes.fromhex(hex_str))
+    assert "error" not in result, f"Decode error: {result}"
+    return result["values"]
+
+
+class TestAutopilotStandby(unittest.TestCase):
+    """
+    AP Mode = Standby: Autopilot Mode channel (0xB5), format 0x01,
+    raw int 20484 maps to display string "Standby".
+    In Standby the Compass Target channel carries an OFF segment display (value=None).
+    """
+    FRAME = "ff121c01d2b5015004a606bee8e800af06bee8e8005306bee8e8007606bee8e80088"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_mode_display(self):
+        self.assertEqual(self.v["Autopilot Mode"]["display_text"], "Standby")
+
+    def test_target_is_off(self):
+        self.assertIsNone(self.v["Autopilot Compass Target"]["value"])
+        self.assertEqual(self.v["Autopilot Compass Target"]["display_text"], "OFF ")
+
+
+class TestAutopilotCompass(unittest.TestCase):
+    """
+    AP Mode = Compass: target is a magnetic bearing (°M layout).
+    Target = 0°M in this frame (just engaged).
+    """
+    FRAME = "ff120a01e4b5015101a60700660000e5"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_mode_display(self):
+        self.assertEqual(self.v["Autopilot Mode"]["display_text"], "Compass")
+
+    def test_target_value(self):
+        self.assertEqual(self.v["Autopilot Compass Target"]["value"], 0.0)
+
+    def test_target_layout(self):
+        self.assertEqual(self.v["Autopilot Compass Target"]["layout"], "°M")
+
+    def test_target_display(self):
+        self.assertEqual(self.v["Autopilot Compass Target"]["display_text"], "0°M")
+
+
+class TestAutopilotWind(unittest.TestCase):
+    """
+    AP Mode = Wind: target is a magnetic bearing representing a locked wind angle.
+    Target = 331°M in this frame.
+    """
+    FRAME = "ff120a01e4b5015104a6070066014b96"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_mode_display(self):
+        self.assertEqual(self.v["Autopilot Mode"]["display_text"], "Wind")
+
+    def test_target_value(self):
+        self.assertEqual(self.v["Autopilot Compass Target"]["value"], 331.0)
+
+    def test_target_display(self):
+        self.assertEqual(self.v["Autopilot Compass Target"]["display_text"], "331°M")
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfastnet-2.0.15/tests/test_awa.py

@@ -0,0 +1,60 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_frame
+
+
+def _decode(hex_str):
+    result = decode_frame(bytes.fromhex(hex_str))
+    assert "error" not in result, f"Decode error: {result}"
+    return result["values"]
+
+
+# Sign convention (format 0x03, segment byte drives layout):
+#   AWA port: seg 0xa0 → layout '-[data]' → value negative
+#   AWA stb:  seg 0x20 → layout '[data]-' → value positive
+#
+# Dash before digits = port (negative); dash after digits = starboard (positive).
+# The trailing dash on the B&G display is a direction marker, not a minus sign.
+
+
+class TestAWAPort(unittest.TestCase):
+    """
+    AWA to port: segment byte 0xa0 → layout '-[data]'.
+    Leading dash drives sign negative; value is stored negative.
+    """
+    FRAME = "ff051801e34e0a030a02bd4d61004a4f610026520ac4bbc4bb5113a0525e"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)["Apparent Wind Angle"]
+
+    def test_value(self):
+        self.assertAlmostEqual(self.v["value"], -82.0, places=0)
+
+    def test_layout(self):
+        self.assertEqual(self.v["layout"], "-[data]")
+
+    def test_display(self):
+        self.assertEqual(self.v["display_text"], "-82")
+
+
+class TestAWAStarboard(unittest.TestCase):
+    """
+    AWA to starboard: segment byte 0x20 → layout '[data]-'.
+    Trailing dash encodes starboard direction; value is positive.
+    """
+    FRAME = "ff051801e34e0a02cf02804d61005a4f61002e520a128f128f5113201835"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)["Apparent Wind Angle"]
+
+    def test_value(self):
+        self.assertAlmostEqual(self.v["value"], 24.0, places=0)
+
+    def test_layout(self):
+        self.assertEqual(self.v["layout"], "[data]-")
+
+    def test_display(self):
+        self.assertEqual(self.v["display_text"], "24-")
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfastnet-2.0.15/tests/test_aws.py

@@ -0,0 +1,36 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_frame
+
+
+def _decode(hex_str):
+    result = decode_frame(bytes.fromhex(hex_str))
+    assert "error" not in result, f"Decode error: {result}"
+    return result["values"]
+
+
+class TestApparentWindSpeed(unittest.TestCase):
+    """
+    18-channel broadcast containing apparent wind speed in both units.
+    Format 0x01, 16-bit signed, divisor 10.
+    AWA sign variants are in test_awa.py.
+    """
+    FRAME = "ff051801e34e0a061c05fe4d51009c4f610050520a47f347f351032065a0"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_knots_value(self):
+        self.assertAlmostEqual(self.v["Apparent Wind Speed (Knots)"]["value"], 15.6, places=1)
+
+    def test_knots_display(self):
+        self.assertEqual(self.v["Apparent Wind Speed (Knots)"]["display_text"], "15.6")
+
+    def test_ms_value(self):
+        self.assertAlmostEqual(self.v["Apparent Wind Speed (m/s)"]["value"], 8.0, places=1)
+
+    def test_ms_display(self):
+        self.assertEqual(self.v["Apparent Wind Speed (m/s)"]["display_text"], "8.0")
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfastnet-2.0.15/tests/test_battery.py

@@ -0,0 +1,29 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_frame
+
+
+def _decode(hex_str):
+    result = decode_frame(bytes.fromhex(hex_str))
+    assert "error" not in result, f"Decode error: {result}"
+    return result["values"]
+
+
+class TestBatteryVolts(unittest.TestCase):
+    """
+    Battery Volts: format 0x01, 16-bit signed, divisor 100.
+    Channel 0x8D; value 13.18 V.
+    """
+    FRAME = "ff051401e78d8105263b3101fa344700f300cc9b4700a000099b"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)["Battery Volts"]
+
+    def test_value(self):
+        self.assertAlmostEqual(self.v["value"], 13.18, places=2)
+
+    def test_display(self):
+        self.assertEqual(self.v["display_text"], "13.18")
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfastnet-2.0.15/tests/test_boatspeed.py

@@ -0,0 +1,34 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_frame
+
+
+def _decode(hex_str):
+    result = decode_frame(bytes.fromhex(hex_str))
+    assert "error" not in result, f"Decode error: {result}"
+    return result["values"]
+
+
+class TestBoatspeed(unittest.TestCase):
+    """
+    Performance Processor broadcast containing Boatspeed (Knots) and
+    Boatspeed (Raw).
+    - Knots: format 0x01, 16-bit signed, divisor 100
+    - Raw: format 0x0A, two 16-bit signed integers rendered as "first / second"
+    """
+    FRAME = "ff010a01f54192f9dd420a01ec082cea"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_knots_value(self):
+        self.assertAlmostEqual(self.v["Boatspeed (Knots)"]["value"], 4.77, places=2)
+
+    def test_knots_display(self):
+        self.assertEqual(self.v["Boatspeed (Knots)"]["display_text"], "4.77")
+
+    def test_raw_is_pair(self):
+        self.assertIn(" / ", self.v["Boatspeed (Raw)"]["display_text"])
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfastnet-2.0.15/tests/test_heading.py

@@ -0,0 +1,80 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_frame
+
+
+def _decode(hex_str):
+    result = decode_frame(bytes.fromhex(hex_str))
+    assert "error" not in result, f"Decode error: {result}"
+    return result["values"]
+
+
+class TestHeading(unittest.TestCase):
+    """
+    Heading: format 0x08, segment code 0x66 → layout '°M'.
+    9-bit value; MSB=0 for values ≤ 255.
+    """
+    FRAME = "ff120e01e00b038c024908cd634a0afbe13d492d"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)["Heading"]
+
+    def test_value(self):
+        self.assertEqual(self.v["value"], 355.0)
+
+    def test_layout(self):
+        self.assertEqual(self.v["layout"], "°M")
+
+    def test_display(self):
+        self.assertEqual(self.v["display_text"], "355°M")
+
+
+class TestRudder(unittest.TestCase):
+    """
+    Rudder Angle: format 0x03, segment byte 0x8c → layout '=[data]'.
+    '=' is B&G's alternative minus symbol; value is stored negative.
+    Same frame as TestHeading.
+    """
+    FRAME = "ff120e01e00b038c024908cd634a0afbe13d492d"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)["Rudder Angle"]
+
+    def test_value(self):
+        self.assertEqual(self.v["value"], -2.0)
+
+    def test_layout(self):
+        self.assertEqual(self.v["layout"], "=[data]")
+
+    def test_display(self):
+        self.assertEqual(self.v["display_text"], "-2")
+
+
+class TestCourse(unittest.TestCase):
+    """
+    Course (HDG + Leeway): format 0x08, layout '°M'.
+    Heading on Next Tack: format 0x08, layout '°M'.
+    Both from a 4-channel navigation broadcast.
+    """
+    FRAME = "ff051401e74a0afbe1fbe1824700d800006908cd639a08cce65e"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_course_value(self):
+        self.assertEqual(self.v["Course (HDG + Leeway)"]["value"], 355.0)
+
+    def test_course_display(self):
+        self.assertEqual(self.v["Course (HDG + Leeway)"]["display_text"], "355°M")
+
+    def test_next_tack_value(self):
+        self.assertEqual(self.v["Heading on Next Tack"]["value"], 230.0)
+
+    def test_next_tack_display(self):
+        self.assertEqual(self.v["Heading on Next Tack"]["display_text"], "230°M")
+
+    def test_leeway_value(self):
+        self.assertEqual(self.v["Leeway"]["value"], 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfastnet-2.0.15/tests/test_heel_trim.py

@@ -0,0 +1,100 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_frame
+
+
+def _decode(hex_str):
+    result = decode_frame(bytes.fromhex(hex_str))
+    assert "error" not in result, f"Decode error: {result}"
+    return result["values"]
+
+
+# Sign convention (format 0x07, segment byte drives layout):
+#   Heel port:  seg 0xf3 → layout 'H[data]'  → value negative, display "H20.4"
+#   Heel stb:   seg 0x73 → layout '[data]H'  → value positive, display "33.8H"
+#   Trim pos:   seg 0x20 → layout '[data]-'  → value positive, display "19.7-"
+#   Trim neg:   seg 0xa0 → layout '-[data]'  → value negative, display "-24.4"
+
+
+class TestHeelPort(unittest.TestCase):
+    """
+    Heel to port: segment byte 0xf3 → layout 'H[data]'.
+    H before the digits encodes port direction; value is stored negative.
+    Display strips the minus — the H symbol itself carries the sign.
+    """
+    FRAME = "ff051401e78d8105263b3101fa344700f300cc9b4700a000099b"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)["Heel Angle"]
+
+    def test_value(self):
+        self.assertAlmostEqual(self.v["value"], -20.4, places=1)
+
+    def test_layout(self):
+        self.assertEqual(self.v["layout"], "H[data]")
+
+    def test_display(self):
+        self.assertEqual(self.v["display_text"], "H20.4")
+
+
+class TestHeelStarboard(unittest.TestCase):
+    """
+    Heel to starboard: segment byte 0x73 → layout '[data]H'.
+    H after the digits encodes starboard direction; value is positive.
+    """
+    FRAME = "ff051401e78d8105213b3101fb3447007301529b4700a0000899"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)["Heel Angle"]
+
+    def test_value(self):
+        self.assertAlmostEqual(self.v["value"], 33.8, places=1)
+
+    def test_layout(self):
+        self.assertEqual(self.v["layout"], "[data]H")
+
+    def test_display(self):
+        self.assertEqual(self.v["display_text"], "33.8H")
+
+
+class TestTrimPositive(unittest.TestCase):
+    """
+    Positive (bow-down) trim: segment byte 0x20 → layout '[data]-'.
+    Trailing dash encodes positive direction; value is positive.
+    """
+    FRAME = "ff051401e78d8105463b3101e13447007300249b47002000c580"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)["Fore/Aft Trim"]
+
+    def test_value(self):
+        self.assertAlmostEqual(self.v["value"], 19.7, places=1)
+
+    def test_layout(self):
+        self.assertEqual(self.v["layout"], "[data]-")
+
+    def test_display(self):
+        self.assertEqual(self.v["display_text"], "19.7-")
+
+
+class TestTrimNegative(unittest.TestCase):
+    """
+    Negative (bow-up) trim: segment byte 0xa0 → layout '-[data]'.
+    Leading dash encodes negative direction; sign appears in the formatted number.
+    """
+    FRAME = "ff051401e78d8105413b3101df34470073001d9b4700a000f4df"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)["Fore/Aft Trim"]
+
+    def test_value(self):
+        self.assertAlmostEqual(self.v["value"], -24.4, places=1)
+
+    def test_layout(self):
+        self.assertEqual(self.v["layout"], "-[data]")
+
+    def test_display(self):
+        self.assertEqual(self.v["display_text"], "-24.4")
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfastnet-2.0.15/tests/test_latlon_frame.py

@@ -0,0 +1,56 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_ascii_frame
+
+
+class TestLatLonFrame(unittest.TestCase):
+    """
+    Tests for LatLon (position) command frames (command 0x03).
+
+    These frames are dispatched to decode_ascii_frame, which carries the raw
+    coordinate string in display_text. The entry is named from the command
+    ("LatLon") — NOT from body[0]. body[0] is a per-source marker byte that
+    varies by GPS unit (0x4E, 0x47, ...) and is not a generic channel id, so
+    it must not be looked up in CHANNEL_LOOKUP (doing so previously mislabelled
+    positions as "Apparent Wind Speed (Raw)").
+    """
+
+    # Real frame, from_address 0x60 (External Compass NMEA FFD 60).
+    # body[0] = 0x4E. Position: 33°52.450'S, 151°13.920'E (Sydney).
+    FRAME_4E = "ff601503894e50333335322e3435305331353131332e3932304572"
+
+    # Real frame, from_address 0x62 (External Compass NMEA FFD 62).
+    # body[0] = 0x47. Position: 16°46.61'S, 179°20.23'E.
+    FRAME_47 = "ff621503874750313634362e3631205331373932302e3233204595"
+
+    def test_4e_source_keyed_latlon(self):
+        values = decode_ascii_frame(bytes.fromhex(self.FRAME_4E))["values"]
+        self.assertIn("LatLon", values)
+        self.assertNotIn("Apparent Wind Speed (Raw)", values)
+        entry = values["LatLon"]
+        self.assertEqual(entry["channel_id"], "0x4E")
+        self.assertEqual(entry["display_text"], "3352.450S15113.920E")
+        self.assertIsNone(entry["value"])
+
+    def test_47_source_keyed_latlon(self):
+        values = decode_ascii_frame(bytes.fromhex(self.FRAME_47))["values"]
+        self.assertIn("LatLon", values)
+        entry = values["LatLon"]
+        self.assertEqual(entry["channel_id"], "0x47")
+        self.assertEqual(entry["display_text"], "1646.61 S17920.23 E")
+        self.assertIsNone(entry["value"])
+
+    def test_both_sources_share_one_key(self):
+        # The fix normalises differing source bytes to a single consistent key.
+        keys_4e = set(decode_ascii_frame(bytes.fromhex(self.FRAME_4E))["values"])
+        keys_47 = set(decode_ascii_frame(bytes.fromhex(self.FRAME_47))["values"])
+        self.assertEqual(keys_4e, keys_47, {"LatLon"})
+
+    def test_command_metadata(self):
+        decoded = decode_ascii_frame(bytes.fromhex(self.FRAME_4E))
+        self.assertNotIn("error", decoded)
+        self.assertEqual(decoded["command"], "LatLon")
+        self.assertEqual(decoded["from_address"], "External Compass (NMEA FFD 60)")
+
+
+if __name__ == "__main__":
+    unittest.main()