pyfastnet 1.2.2__tar.gz → 1.2.4__tar.gz

{pyfastnet-1.2.2/pyfastnet.egg-info → pyfastnet-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfastnet
-Version: 1.2.2
+Version: 1.2.4
 Summary: A Python library for decoding FastNet protocol data streams.
 Home-page: https://github.com/ghotihook/pyfastnet
 Author: Alex Salmon

{pyfastnet-1.2.2 → pyfastnet-1.2.4}/fastnet_decoder/decode_fastnet.py

@@ -336,7 +336,7 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
                 return None
             # unused - SegCodeA - 7bit MSB, 8 bit LSB
             segment_code = data_bytes[1]
-            msb = (data_bytes[2] >> 1) & 0b01111111  # 7 bits from third byte
+            msb = data_bytes[2] & 0b01111111  # 7 bits from third byte
             lsb = data_bytes[3]  # Full 8 bits from fourth byte
             unsigned_value = (msb << 8) | lsb  # Combine MSB and LSB into 15-bit value
 
@@ -369,7 +369,8 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
             segment_code = (data_bytes[0] >> 1) & 0b01111111  # 7-bit segment
             unsigned_value = ((data_bytes[0] & 0b1) << 8) | data_bytes[1]  # 9-bit unsigned value
             interpreted_value = unsigned_value / divisor
-            raw_value = {"segment_code": segment_code, "unsigned_value": unsigned_value}
+            layout = convert_segment_a_to_char(segment_code)
+            raw_value = {"segment_code": segment_code, "layout": layout, "unsigned_value": unsigned_value}
 
         elif format_bits == 0x0A:  # 16-bit signed + 16-bit signed
             if len(data_bytes) != 4:

{pyfastnet-1.2.2 → pyfastnet-1.2.4}/fastnet_decoder/utils.py

@@ -62,6 +62,7 @@ def convert_segment_a_to_char(segment_byte):
     #}
 
     segment_mapping = {
+        0x66: "°M",  # magnetic bearing indicator (seen on Heading, Course, TWD, Tidal Set)
         0x28: "[data]=",
         0xa8: "=[data]",
         0x20: "[data]-",

{pyfastnet-1.2.2 → pyfastnet-1.2.4/pyfastnet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfastnet
-Version: 1.2.2
+Version: 1.2.4
 Summary: A Python library for decoding FastNet protocol data streams.
 Home-page: https://github.com/ghotihook/pyfastnet
 Author: Alex Salmon

{pyfastnet-1.2.2 → pyfastnet-1.2.4}/pyfastnet.egg-info/SOURCES.txt

@@ -14,6 +14,9 @@ pyfastnet.egg-info/dependency_links.txt
 pyfastnet.egg-info/top_level.txt
 tests/test_apparent_frame.py
 tests/test_autopilot_frame.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

{pyfastnet-1.2.2 → pyfastnet-1.2.4}/setup.py

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

pyfastnet-1.2.4/tests/test_depth_frame.py

@@ -0,0 +1,61 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_frame
+
+
+class TestDepthFrame(unittest.TestCase):
+    """
+    Tests for depth channel decoding (0xC1 Meters, 0xC2 Feet, 0xC3 Fathoms).
+
+    The format 0x07 decoder uses a 15-bit value split across two bytes:
+        msb = data_bytes[2] & 0x7F   (7 bits)
+        lsb = data_bytes[3]          (8 bits)
+        value = (msb << 8) | lsb
+
+    When depth > 25.5 m (raw value > 255), data_bytes[2] is non-zero.
+    This is the case that previously decoded incorrectly due to a spurious >> 1.
+    """
+
+    # Real broadcast frame captured from fastnet_record.txt.
+    # from_address = 0x01 (Normal CPU / Depth Board).
+    # Contains: Depth Meters=12.0, Depth Feet=39.5, Depth Fathoms=6.6
+    # plus Dead Reckoning Distance and Dead Reckoning Course.
+    DEPTH_FRAME_HEX = "ff011c01e3c14700800078c2470080018bc357008000428184ff000000d308cd64ff"
+
+    def setUp(self):
+        self.decoded = decode_frame(bytes.fromhex(self.DEPTH_FRAME_HEX))
+        self.values = self.decoded["values"]
+
+    def test_no_decode_error(self):
+        self.assertNotIn("error", self.decoded)
+
+    def test_all_depth_channels_present(self):
+        self.assertIn("Depth (Meters)", self.values)
+        self.assertIn("Depth (Feet)", self.values)
+        self.assertIn("Depth (Fathoms)", self.values)
+
+    def test_depth_meters(self):
+        self.assertEqual(self.values["Depth (Meters)"]["interpreted"], 12.0)
+
+    def test_depth_feet(self):
+        # Raw value is 395 (> 255), so data_bytes[2] = 0x01 — this is the case
+        # that was broken before the msb >> 1 fix. Correct value is 39.5 ft.
+        self.assertEqual(self.values["Depth (Feet)"]["interpreted"], 39.5)
+
+    def test_depth_fathoms(self):
+        self.assertEqual(self.values["Depth (Fathoms)"]["interpreted"], 6.6)
+
+    def test_depth_units_are_consistent(self):
+        meters = self.values["Depth (Meters)"]["interpreted"]
+        feet = self.values["Depth (Feet)"]["interpreted"]
+        fathoms = self.values["Depth (Fathoms)"]["interpreted"]
+
+        # Allow 0.2 tolerance: each channel is independently rounded to 0.1 of its
+        # own unit by the instrument, so cross-unit comparisons can differ by ~0.15.
+        self.assertAlmostEqual(meters * 3.28084, feet, delta=0.2,
+                               msg="Feet should equal meters × 3.28084")
+        self.assertAlmostEqual(meters / 1.8288, fathoms, delta=0.2,
+                               msg="Fathoms should equal meters / 1.8288")
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfastnet-1.2.4/tests/test_format07_msb_regression.py

@@ -0,0 +1,77 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_frame
+
+
+class TestFormat07MSBRegression(unittest.TestCase):
+    """
+    Regression tests for the format 0x07 MSB bit-shift bug.
+
+    The bug: msb was computed as (data_bytes[2] >> 1) & 0x7F instead of
+    data_bytes[2] & 0x7F. The spurious >> 1 discarded bit 0 of data_bytes[2],
+    collapsing the MSB contribution to zero for any raw value > 255
+    (i.e. whenever data_bytes[2] is non-zero).
+
+    All frames below are real captures where the raw value exceeds 255, so
+    data_bytes[2] == 0x01. The table shows the wrong vs correct reading:
+
+      Channel                    Raw   Buggy        Correct
+      Depth (Feet)      0xC2     465   20.9 ft   →  46.5 ft
+      Tidal Set         0x84     297   41.0 °    →  297.0 °
+      Autopilot Target  0xA6     354   98.0 °    →  354.0 °
+      VMG (Knots)       0x7F     415    1.59 kn  →  4.15 kn
+    """
+
+    def _decode(self, hex_str):
+        decoded = decode_frame(bytes.fromhex(hex_str))
+        self.assertNotIn("error", decoded, f"Frame decode error: {decoded}")
+        return decoded["values"]
+
+    # ------------------------------------------------------------------
+    # Tidal Set (0x84) — raw 297, format_byte 0x07, divisor 1
+    # Buggy result: 41°  (297 - 256 = 41, MSB dropped)
+    # Correct:     297°
+    # Frame also contains Tidal Drift (0x83) as a sanity cross-check.
+    # ------------------------------------------------------------------
+    TIDAL_SET_FRAME = "ff600a01968407006601298383bb30f4"
+
+    def test_tidal_set_present(self):
+        values = self._decode(self.TIDAL_SET_FRAME)
+        self.assertIn("Tidal Set", values)
+
+    def test_tidal_set_value(self):
+        values = self._decode(self.TIDAL_SET_FRAME)
+        self.assertEqual(values["Tidal Set"]["interpreted"], 297.0,
+                         "Tidal Set should be 297° (was 41° with the >> 1 bug)")
+
+    def test_tidal_drift_unaffected(self):
+        # Tidal Drift raw value is 48 (< 256), so data_bytes[2] == 0 — unaffected by bug
+        values = self._decode(self.TIDAL_SET_FRAME)
+        self.assertIn("Tidal Drift", values)
+        self.assertAlmostEqual(values["Tidal Drift"]["interpreted"], 0.48, places=2)
+
+    # ------------------------------------------------------------------
+    # Autopilot Compass Target (0xA6) — raw 354, format_byte 0x07, divisor 1
+    # Buggy result:  98°  (354 - 256 = 98, MSB dropped)
+    # Correct:      354°
+    # Frame also contains Autopilot Mode as a sanity cross-check.
+    # ------------------------------------------------------------------
+    AUTOPILOT_TARGET_FRAME = "ff120a01e4b5015101a6070066016282"
+
+    def test_autopilot_target_present(self):
+        values = self._decode(self.AUTOPILOT_TARGET_FRAME)
+        self.assertIn("Autopilot Compass Target", values)
+
+    def test_autopilot_target_value(self):
+        values = self._decode(self.AUTOPILOT_TARGET_FRAME)
+        self.assertEqual(values["Autopilot Compass Target"]["interpreted"], 354.0,
+                         "Autopilot Compass Target should be 354° (was 98° with the >> 1 bug)")
+
+    def test_autopilot_mode_unaffected(self):
+        # Autopilot Mode uses format 0x01 (16-bit signed), not format 0x07 — unaffected
+        values = self._decode(self.AUTOPILOT_TARGET_FRAME)
+        self.assertIn("Autopilot Mode", values)
+        self.assertEqual(values["Autopilot Mode"]["interpreted"], "Compass")
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfastnet-1.2.4/tests/test_format08_layout.py

@@ -0,0 +1,61 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_frame
+
+
+class TestFormat08Layout(unittest.TestCase):
+    """
+    Tests for format 0x08 layout field (magnetic bearing indicator).
+
+    Format 0x08: SEGCODE_B-derived 7-bit segment code + 9-bit unsigned value.
+    Segment code 0x66 (segments f+g+a+b = degree symbol) activates the "°M"
+    annunciator on the Hydra 2000 FFD, indicating a magnetic-referenced bearing.
+
+    Frame "ff120e01e00b038c274908cc294a0a1cdd6067e5" contains:
+      - Rudder Angle (0x0b), format 0x03
+      - Heading     (0x49), format 0x08, data=[0xCC, 0x29]
+          data[0]=0xCC → segment_code = (0xCC >> 1) & 0x7F = 0x66 → layout "°M"
+          unsigned_value = 0x29 = 41 → interpreted 41.0°
+      - Heading Raw (0x4a), format 0x0a
+    """
+
+    FRAME_HEX = "ff120e01e00b038c274908cc294a0a1cdd6067e5"
+
+    def setUp(self):
+        self.decoded = decode_frame(bytes.fromhex(self.FRAME_HEX))
+        self.heading = self.decoded["values"]["Heading"]
+
+    def test_no_decode_error(self):
+        self.assertNotIn("error", self.decoded)
+
+    def test_heading_present(self):
+        self.assertIn("Heading", self.decoded["values"])
+
+    def test_heading_interpreted_value(self):
+        self.assertEqual(self.heading["interpreted"], 41.0)
+
+    def test_heading_format_is_08(self):
+        self.assertEqual(self.heading["format_bits"], 8)
+
+    def test_heading_raw_has_layout(self):
+        self.assertIn("layout", self.heading["raw"])
+
+    def test_heading_layout_is_magnetic(self):
+        self.assertEqual(self.heading["raw"]["layout"], "°M")
+
+    def test_heading_segment_code(self):
+        # 0x66 = segments f+g+a+b = degree symbol, co-activates Hydra 2000 "M" annunciator
+        self.assertEqual(self.heading["raw"]["segment_code"], 0x66)
+
+    def test_cog_true_has_blank_layout(self):
+        # COG True is GPS-derived — no magnetic indicator, segment code 0x00 = blank
+        # Frame: ff051601e5 ... e9 08 00 XX ... (COG True channel 0xe9)
+        # Use a frame that contains COG True with blank segment code
+        cog_frame = bytes.fromhex("FF051601E555610030566100185903A86B7F8700BB00016D08CD0DCB")
+        decoded = decode_frame(cog_frame)
+        cog = decoded["values"].get("Course Over Ground (True)")
+        if cog:
+            self.assertEqual(cog["raw"]["layout"], " ", "GPS COG should have blank layout (no magnetic indicator)")
+
+
+if __name__ == "__main__":
+    unittest.main()