pyfastnet 1.2.4__tar.gz → 2.0.0__tar.gz

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

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

pyfastnet-2.0.0/fastnet_decoder/decode_fastnet.py

@@ -0,0 +1,237 @@
+import datetime
+from .utils import calculate_checksum
+from .mappings import ADDRESS_LOOKUP, COMMAND_LOOKUP, CHANNEL_LOOKUP, FORMAT_SIZE_MAP
+from .mappings import SEGMENT_A, SEGMENT_B, AUTOPILOT_MODES
+from .logger import logger
+
+
+_DIVISOR_MAP = {0b00: 1, 0b01: 10, 0b10: 100, 0b11: 1000}
+_DP_MAP = {1: 0, 10: 1, 100: 2, 1000: 3}
+
+
+def _sign_from_layout(layout: str) -> int:
+    return -1 if layout in ("-[data]", "=[data]") else 1
+
+
+def _display_from_layout(layout: str, formatted: str) -> str:
+    if layout == "°M":        return f"{formatted}°M"
+    if layout == "H[data]":   return f"H{formatted}"
+    if layout == "[data]H":   return f"{formatted}H"
+    if layout in ("[data]=", "[data]-"):
+        return f"{formatted}{layout[-1]}"
+    return formatted
+
+
+def decode_frame(frame: bytes) -> dict:
+    try:
+        logger.debug(f"Starting frame decoding. Frame length: {len(frame)}, Frame contents: {frame.hex()}")
+
+        to_address      = frame[0]
+        from_address    = frame[1]
+        body_size       = frame[2]
+        command         = frame[3]
+        header_checksum = frame[4]
+        body            = frame[5:-1]
+        body_checksum   = frame[-1]
+
+        logger.debug(
+            f"Parsed header: to_address=0x{to_address:02X}, from_address=0x{from_address:02X}, "
+            f"body_size={body_size}, command=0x{command:02X}, header_checksum=0x{header_checksum:02X}"
+        )
+
+        if calculate_checksum(frame[:4]) != header_checksum:
+            logger.debug(f"Header checksum mismatch. Frame dropped: {frame.hex()}")
+            return {"error": "Header checksum mismatch"}
+
+        if calculate_checksum(body) != body_checksum:
+            logger.debug(f"Body checksum mismatch. Frame dropped: {frame.hex()}")
+            return {"error": "Body checksum mismatch"}
+
+        if len(body) < 2 or len(body) != body_size:
+            logger.debug(f"Invalid body size: Expected {body_size}, Actual {len(body)}. Frame: {frame.hex()}")
+            return {"error": "Invalid body size"}
+
+        logger.debug("Header and body checksums are valid.")
+
+        decoded_data = {
+            "to_address":  ADDRESS_LOOKUP.get(to_address,   f"Unknown (0x{to_address:02X})"),
+            "from_address": ADDRESS_LOOKUP.get(from_address, f"Unknown (0x{from_address:02X})"),
+            "command":     COMMAND_LOOKUP.get(command,       f"Unknown (0x{command:02X})"),
+            "values":      {}
+        }
+
+        index = 0
+        while index < len(body):
+            if index + 1 >= len(body):
+                logger.debug(
+                    f"Insufficient bytes to decode channel ID and format byte at index {index}. "
+                    f"Remaining length: {len(body) - index}"
+                )
+                return {"error": "Insufficient bytes for channel header"}
+
+            channel_id  = body[index]
+            format_byte = body[index + 1]
+            index      += 2
+
+            data_length = FORMAT_SIZE_MAP.get(format_byte & 0x0F, 0)
+            if index + data_length > len(body):
+                logger.debug(
+                    f"Incomplete data for channel 0x{channel_id:02X}. "
+                    f"Expected length: {data_length}, Available: {len(body) - index}"
+                )
+                return {"error": f"Incomplete data for channel 0x{channel_id:02X}"}
+
+            data_bytes = body[index:index + data_length]
+            index     += data_length
+
+            decoded_value = decode_format_and_data(channel_id, format_byte, data_bytes)
+            channel_name  = CHANNEL_LOOKUP.get(channel_id, f"Unknown (0x{channel_id:02X})")
+
+            decoded_data["values"][channel_name] = decoded_value
+            logger.debug(f"Decoded value for channel {channel_name}: {decoded_value}")
+
+        return decoded_data
+
+    except Exception as e:
+        logger.error(f"Unexpected error during frame decoding: {e}. Frame contents: {frame.hex()}")
+        return {"error": "Decoding failure"}
+
+
+def decode_ascii_frame(frame: bytes) -> dict:
+    try:
+        to_address      = frame[0]
+        from_address    = frame[1]
+        command         = frame[3]
+        header_checksum = frame[4]
+        body            = frame[5:-1]
+
+        channel_id   = body[0]
+        data_bytes   = body[2:]
+        channel_name = CHANNEL_LOOKUP.get(channel_id, f"Unknown (0x{channel_id:02X})")
+
+        try:
+            ascii_text = data_bytes.decode("ascii").strip()
+        except UnicodeDecodeError as e:
+            logger.warning(f"Failed to decode ASCII text: {e}")
+            return {"error": "ASCII decode failed"}
+
+        return {
+            "to_address":  ADDRESS_LOOKUP.get(to_address,   f"Unknown (0x{to_address:02X})"),
+            "from_address": ADDRESS_LOOKUP.get(from_address, f"Unknown (0x{from_address:02X})"),
+            "command":     COMMAND_LOOKUP.get(command,       f"Unknown (0x{command:02X})"),
+            "values": {
+                channel_name: {
+                    "channel_id":   f"0x{channel_id:02X}",
+                    "value":        None,
+                    "display_text": ascii_text,
+                    "layout":       None,
+                }
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"Error decoding ASCII frame: {e}")
+        return {"error": str(e)}
+
+
+def decode_format_and_data(channel_id, format_byte, data_bytes):
+    try:
+        logger.debug(f"Decoding channel ID: 0x{channel_id:02X}, format byte: 0x{format_byte:02X}, data: {data_bytes.hex()}")
+
+        divisor     = _DIVISOR_MAP[(format_byte >> 6) & 0b11]
+        dp          = _DP_MAP[divisor]
+        format_bits = format_byte & 0b1111
+
+        if len(data_bytes) == 0:
+            logger.debug("decode_format_and_data: Empty data bytes; cannot decode.")
+            return None
+
+        layout = None
+
+        if format_bits == 0x01:
+            if len(data_bytes) != 2:
+                return None
+            raw = int.from_bytes(data_bytes, byteorder="big", signed=True)
+            if channel_id == 0xB5:
+                value        = float(raw)
+                display_text = AUTOPILOT_MODES.get(raw, f"Unknown ({raw})")
+            else:
+                value        = raw / divisor
+                display_text = f"{value:.{dp}f}"
+
+        elif format_bits == 0x02:
+            if len(data_bytes) != 2:
+                return None
+            unsigned = ((data_bytes[0] & 0b11) << 8) | data_bytes[1]
+            value        = unsigned / divisor
+            display_text = f"{value:.{dp}f}"
+
+        elif format_bits == 0x03:
+            if len(data_bytes) != 2:
+                return None
+            layout   = SEGMENT_A.get(data_bytes[0], "?")
+            unsigned = data_bytes[1]
+            value    = _sign_from_layout(layout) * unsigned / divisor
+            display_text = _display_from_layout(layout, f"{value:.{dp}f}")
+
+        elif format_bits == 0x04:
+            if len(data_bytes) != 4:
+                return None
+            unsigned     = int.from_bytes(data_bytes[1:], byteorder="big", signed=False)
+            value        = unsigned / divisor
+            display_text = f"{value:.{dp}f}"
+
+        elif format_bits == 0x05:
+            if len(data_bytes) != 4:
+                return None
+            h, m, s  = data_bytes[1], data_bytes[2], data_bytes[3]
+            value    = float(h * 3600 + m * 60 + s)
+            display_text = str(datetime.timedelta(hours=h, minutes=m, seconds=s))
+
+        elif format_bits == 0x06:
+            if len(data_bytes) != 4:
+                return None
+            value        = None
+            display_text = "".join(SEGMENT_B.get(b, "?") for b in data_bytes)
+            logger.debug(f"Decoded 7-segment text: {display_text}")
+
+        elif format_bits == 0x07:
+            if len(data_bytes) != 4:
+                return None
+            layout   = SEGMENT_A.get(data_bytes[1], "?")
+            msb      = data_bytes[2] & 0b01111111
+            unsigned = (msb << 8) | data_bytes[3]
+            value    = _sign_from_layout(layout) * unsigned / divisor
+            display_text = _display_from_layout(layout, f"{value:.{dp}f}")
+
+        elif format_bits == 0x08:
+            if len(data_bytes) != 2:
+                return None
+            segment_code = (data_bytes[0] >> 1) & 0b01111111
+            layout       = SEGMENT_A.get(segment_code, "?")
+            unsigned     = ((data_bytes[0] & 0b1) << 8) | data_bytes[1]
+            value        = unsigned / divisor
+            display_text = _display_from_layout(layout, f"{value:.{dp}f}")
+
+        elif format_bits == 0x0A:
+            if len(data_bytes) != 4:
+                return None
+            first  = int.from_bytes(data_bytes[:2], byteorder="big", signed=True) / divisor
+            second = int.from_bytes(data_bytes[2:], byteorder="big", signed=True) / divisor
+            value        = first
+            display_text = f"{first:.{dp}f} / {second:.{dp}f}"
+
+        else:
+            logger.debug(f"Unsupported format: 0x{format_bits:02X}.")
+            return None
+
+        return {
+            "channel_id":   f"0x{channel_id:02X}",
+            "value":        value,
+            "display_text": display_text,
+            "layout":       layout,
+        }
+
+    except Exception as e:
+        logger.error(f"Error decoding channel 0x{channel_id:02X}: {e}")
+        return None

{pyfastnet-1.2.4 → pyfastnet-2.0.0}/fastnet_decoder/mappings.py

@@ -275,6 +275,25 @@ CHANNEL_LOOKUP = {
 }
 
 
+SEGMENT_A = {
+    0x66: "°M",
+    0x28: "[data]=",  0xa8: "=[data]",
+    0x20: "[data]-",  0xa0: "-[data]",
+    0x8c: "=[data]",  0x0c: "[data]=",
+    0xf3: "H[data]",  0x73: "[data]H",
+    0x00: " ",
+}
+
+SEGMENT_B = {
+    0xBE: "O", 0xE8: "F", 0x62: "n",
+    0x72: "o", 0x40: "-", 0x00: " ",
+}
+
+AUTOPILOT_MODES = {
+    20484: "Standby", 20737: "Compass", 20738: "Power",
+    20740: "Wind",    20755: "NMEA WP",
+}
+
 FORMAT_SIZE_MAP = {
     0x00: 4,  # 32 bits (4 bytes)
     0x01: 2,  # 16 bits (2 bytes)

pyfastnet-2.0.0/fastnet_decoder/utils.py

@@ -0,0 +1,48 @@
+
+
+def calculate_checksum(data):
+    """
+    Calculates the checksum for the given data bytes this one is for Fastnet Checksum
+    Args:
+        data (bytes): The data bytes to calculate checksum for.
+    Returns:
+        int: The calculated checksum.
+    """
+    return (0x100 - sum(data) % 0x100) & 0xFF
+
+
+def calculate_nmea_checksum(sentence):
+    """
+    Calculates the NMEA checksum for a given sentence (excluding '$' and '*').
+    Args:
+        sentence (str): NMEA sentence string without '$' and checksum '*'.
+    Returns:
+        str: Hexadecimal checksum as a string.
+    """
+    checksum = 0
+    for char in sentence:
+        checksum ^= ord(char)
+    return f"{checksum:02X}"
+
+
+
+def parse_format_byte(format_byte):
+    """
+    Parses the format byte into divisor, digits, and format type.
+    Args:
+        format_byte (int): The format byte.
+    Returns:
+        dict: Parsed divisor, digits, and format type.
+    """
+    divisor_bits = (format_byte >> 6) & 0b11  # First two bits
+    digits_bits = (format_byte >> 4) & 0b11   # Next two bits
+    format_type = format_byte & 0x0F          # Last 4 bits (format type)
+
+    divisor_map = {0b00: 1, 0b01: 10, 0b10: 100, 0b11: 1000}
+    digits_map = {0b00: 1, 0b01: 2, 0b10: 3, 0b11: 4}
+
+    return {
+        "divisor": divisor_map.get(divisor_bits, 1),
+        "digits": digits_map.get(digits_bits, 1),
+        "format_type": format_type,
+    }

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

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

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

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="pyfastnet",
-    version="1.2.4",  # Ensure this matches your intended version
+    version="2.0.0",  # 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 → pyfastnet-2.0.0}/tests/test_depth_frame.py

@@ -34,20 +34,20 @@ class TestDepthFrame(unittest.TestCase):
         self.assertIn("Depth (Fathoms)", self.values)
 
     def test_depth_meters(self):
-        self.assertEqual(self.values["Depth (Meters)"]["interpreted"], 12.0)
+        self.assertEqual(self.values["Depth (Meters)"]["value"], 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)
+        self.assertEqual(self.values["Depth (Feet)"]["value"], 39.5)
 
     def test_depth_fathoms(self):
-        self.assertEqual(self.values["Depth (Fathoms)"]["interpreted"], 6.6)
+        self.assertEqual(self.values["Depth (Fathoms)"]["value"], 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"]
+        meters = self.values["Depth (Meters)"]["value"]
+        feet = self.values["Depth (Feet)"]["value"]
+        fathoms = self.values["Depth (Fathoms)"]["value"]
 
         # 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.

{pyfastnet-1.2.4 → pyfastnet-2.0.0}/tests/test_format07_msb_regression.py

@@ -40,14 +40,14 @@ class TestFormat07MSBRegression(unittest.TestCase):
 
     def test_tidal_set_value(self):
         values = self._decode(self.TIDAL_SET_FRAME)
-        self.assertEqual(values["Tidal Set"]["interpreted"], 297.0,
+        self.assertEqual(values["Tidal Set"]["value"], 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)
+        self.assertAlmostEqual(values["Tidal Drift"]["value"], 0.48, places=2)
 
     # ------------------------------------------------------------------
     # Autopilot Compass Target (0xA6) — raw 354, format_byte 0x07, divisor 1
@@ -63,14 +63,14 @@ class TestFormat07MSBRegression(unittest.TestCase):
 
     def test_autopilot_target_value(self):
         values = self._decode(self.AUTOPILOT_TARGET_FRAME)
-        self.assertEqual(values["Autopilot Compass Target"]["interpreted"], 354.0,
+        self.assertEqual(values["Autopilot Compass Target"]["value"], 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")
+        self.assertEqual(values["Autopilot Mode"]["display_text"], "Compass")
 
 
 if __name__ == "__main__":

{pyfastnet-1.2.4 → pyfastnet-2.0.0}/tests/test_format08_layout.py

@@ -6,15 +6,14 @@ 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.
+    Format 0x08: 7-bit segment code + 9-bit unsigned value.
+    Segment code 0x66 activates the "°M" annunciator, indicating magnetic reference.
 
     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°
+          unsigned_value = 0x29 = 41 → value 41.0
       - Heading Raw (0x4a), format 0x0a
     """
 
@@ -30,31 +29,22 @@ class TestFormat08Layout(unittest.TestCase):
     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_value(self):
+        self.assertEqual(self.heading["value"], 41.0)
 
     def test_heading_layout_is_magnetic(self):
-        self.assertEqual(self.heading["raw"]["layout"], "°M")
+        self.assertEqual(self.heading["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_heading_display_text(self):
+        self.assertEqual(self.heading["display_text"], "41°M")
 
     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)")
+            self.assertEqual(cog["layout"], " ", "GPS COG should have blank layout (no magnetic indicator)")
 
 
 if __name__ == "__main__":

pyfastnet-1.2.4/fastnet_decoder/decode_fastnet.py

@@ -1,407 +0,0 @@
-import datetime
-from .utils import calculate_checksum, convert_segment_b_to_char, convert_segment_a_to_char
-from .mappings import  ADDRESS_LOOKUP, COMMAND_LOOKUP,  CHANNEL_LOOKUP, FORMAT_SIZE_MAP
-from .logger import logger
-
-
-
-def decode_frame(frame: bytes) -> dict:
-    try:
-        logger.debug(f"Starting frame decoding. Frame length: {len(frame)}, Frame contents: {frame.hex()}")
-
-        # Parse the header
-        to_address     = frame[0]
-        from_address   = frame[1]
-        body_size      = frame[2]
-        command        = frame[3]
-        header_checksum= frame[4]
-        body           = frame[5:-1]
-        body_checksum  = frame[-1]
-
-        logger.debug(
-            f"Parsed header: to_address=0x{to_address:02X}, from_address=0x{from_address:02X}, "
-            f"body_size={body_size}, command=0x{command:02X}, header_checksum=0x{header_checksum:02X}"
-        )
-
-        # Validate checksums
-        if calculate_checksum(frame[:4]) != header_checksum:
-            logger.debug(f"Header checksum mismatch. Frame dropped: {frame.hex()}")
-            return {"error": "Header checksum mismatch"}
-
-        if calculate_checksum(body) != body_checksum:
-            logger.debug(f"Body checksum mismatch. Frame dropped: {frame.hex()}")
-            return {"error": "Body checksum mismatch"}
-
-        # Validate body size explicitly
-        if len(body) < 2 or len(body) != body_size:
-            logger.debug(
-                f"Invalid body size: Expected {body_size}, Actual {len(body)}. Frame: {frame.hex()}"
-            )
-            return {"error": "Invalid body size"}
-
-        logger.debug("Header and body checksums are valid.")
-
-        decoded_data = {
-            "to_address": ADDRESS_LOOKUP.get(to_address, f"Unknown (0x{to_address:02X})"),
-            "from_address": ADDRESS_LOOKUP.get(from_address, f"Unknown (0x{from_address:02X})"),
-            "command":     COMMAND_LOOKUP.get(command,     f"Unknown (0x{command:02X})"),
-            "values":     {}
-        }
-
-        # Decode body
-        index = 0
-        while index < len(body):
-            # Make sure we have at least channel ID + format byte
-            if index + 1 >= len(body):
-                logger.debug(
-                    f"Insufficient bytes to decode channel ID and format byte at index {index}. "
-                    f"Remaining length: {len(body) - index}"
-                )
-                return {"error": "Insufficient bytes for channel header"}
-
-            channel_id  = body[index]
-            format_byte = body[index + 1]
-            index      += 2
-
-            # Determine how many data bytes this format expects
-            data_length = FORMAT_SIZE_MAP.get(format_byte & 0x0F, 0)
-            if index + data_length > len(body):
-                logger.debug(
-                    f"Incomplete data for channel 0x{channel_id:02X}. "
-                    f"Expected length: {data_length}, Available: {len(body) - index}"
-                )
-                return {"error": f"Incomplete data for channel 0x{channel_id:02X}"}
-
-            data_bytes = body[index:index + data_length]
-            index     += data_length
-
-            # Decode the actual value
-            decoded_value = decode_format_and_data(channel_id, format_byte, data_bytes)
-            channel_name  = CHANNEL_LOOKUP.get(channel_id, f"Unknown (0x{channel_id:02X})")
-
-            decoded_data["values"][channel_name] = decoded_value
-            logger.debug(f"Decoded value for channel {channel_name}: {decoded_value}")
-
-        return decoded_data
-
-    except Exception as e:
-        logger.error(f"Unexpected error during frame decoding: {e}. Frame contents: {frame.hex()}")
-        return {"error": "Decoding failure"}
-
-
-
-# def decode_frame(frame: bytes) -> dict:
-#     try:
-#         logger.debug(f"Starting frame decoding. Frame length: {len(frame)}, Frame contents: {frame.hex()}")
-
-#         # Parse the header
-#         to_address = frame[0]
-#         from_address = frame[1]
-#         body_size = frame[2]
-#         command = frame[3]
-#         header_checksum = frame[4]
-#         body = frame[5:-1]
-#         body_checksum = frame[-1]
-
-#         logger.debug(f"Parsed header: to_address=0x{to_address:02X}, from_address=0x{from_address:02X}, "
-#                      f"body_size={body_size}, command=0x{command:02X}, header_checksum=0x{header_checksum:02X}")
-
-#         # Validate checksums
-#         if calculate_checksum(frame[:4]) != header_checksum:
-#             logger.info(f"Header checksum mismatch. Frame dropped: {frame.hex()}")
-#             return {"error": "Header checksum mismatch"}
-
-#         if calculate_checksum(body) != body_checksum:
-#             logger.info(f"Body checksum mismatch. Frame dropped: {frame.hex()}")
-#             return {"error": "Body checksum mismatch"}
-
-#         # Validate body size explicitly
-#         if len(body) < 2 or len(body) != body_size:
-#             logger.info(f"Invalid body size: Expected {body_size}, Actual {len(body)}. Frame: {frame.hex()}")
-#             return {"error": "Invalid body size"}
-
-#         logger.debug("Header and body checksums are valid.")
-
-#         # Decode frame...
-#         decoded_data = {
-#             "to_address": ADDRESS_LOOKUP.get(to_address, f"Unknown (0x{to_address:02X})"),
-#             "from_address": ADDRESS_LOOKUP.get(from_address, f"Unknown (0x{from_address:02X})"),
-#             "command": COMMAND_LOOKUP.get(command, f"Unknown (0x{command:02X})"),
-#             "values": {}
-#         }
-
-#         # Decode body
-#         index = 0
-#         while index < len(body):
-#             if index + 1 >= len(body):
-#                 raise ValueError(f"Insufficient bytes to decode channel ID and format byte at index {index}. Remaining length: {len(body) - index}")
-
-#             channel_id = body[index]
-#             format_byte = body[index + 1]
-#             index += 2
-
-#             data_length = FORMAT_SIZE_MAP.get(format_byte & 0x0F, 0)
-#             if index + data_length > len(body):
-#                 raise ValueError(f"Incomplete data for channel 0x{channel_id:02X}. Expected length: {data_length}, Available: {len(body) - index}")
-
-#             data_bytes = body[index:index + data_length]
-#             index += data_length
-
-#             decoded_value = decode_format_and_data(channel_id, format_byte, data_bytes)
-#             channel_name = CHANNEL_LOOKUP.get(channel_id, f"Unknown (0x{channel_id:02X})")
-
-#             decoded_data["values"][channel_name] = decoded_value
-#             logger.debug(f"Decoded value for channel {channel_name}: {decoded_value}")
-
-#         return decoded_data
-
-#     except Exception as e:
-#         logger.error(f"Error during frame decoding: {e}. Frame contents: {frame.hex()}")
-#         return None
-
-
-
-
-
-
-
-
-        
-
-def decode_ascii_frame(frame: bytes) -> dict:
-    """
-    Decodes an ASCII FastNet frame and returns interpreted values.
-    
-    Args:
-        frame (bytes): The full ASCII frame (header + body).
-        
-    Returns:
-        dict: Decoded data including addresses, command, and channel values.
-    """
-    try:
-        to_address = frame[0]
-        from_address = frame[1]
-        body_size = frame[2]
-        command = frame[3]
-        header_checksum = frame[4]
-        body = frame[5:-1]  # Body starts after header checksum
-        body_checksum = frame[-1]
-
-        channel_id = body[0]
-        format_byte = body[1]
-        data_bytes = body[2:]
-
-        channel_name = CHANNEL_LOOKUP.get(channel_id, f"Unknown (0x{channel_id:02X})")
-
-        try:
-            ascii_text = data_bytes.decode("ascii").strip()
-            interpreted_value = ascii_text
-            raw_value = ascii_text
-        except UnicodeDecodeError as decode_error:
-            logger.warning(f"Failed to decode ASCII text: {decode_error}")
-            return {"error": "ASCII decode failed"}
-
-        decoded_data = {
-            "to_address": ADDRESS_LOOKUP.get(to_address, f"Unknown (0x{to_address:02X})"),
-            "from_address": ADDRESS_LOOKUP.get(from_address, f"Unknown (0x{from_address:02X})"),
-            "command": COMMAND_LOOKUP.get(command, f"Unknown (0x{command:02X})"),
-            "values": {
-                channel_name: {
-                    "channel_id": f"0x{channel_id:02X}",
-                    "format_byte": f"0x{format_byte:02X}",
-                    "data_bytes": data_bytes.hex(),
-                    "raw": raw_value,
-                    "interpreted": interpreted_value
-                }
-            }
-        }
-
-        return decoded_data
-
-    except Exception as e:
-        logger.error(f"Error decoding ASCII frame: {e}")
-        return {"error": str(e)}
-
-def decode_format_and_data(channel_id, format_byte, data_bytes):
-    """
-    Decodes the format byte and interprets the data accordingly.
-
-    Args:
-        channel_id (int): Channel ID (from `CHANNEL_LOOKUP`).
-        format_byte (int): The format byte indicating divisor, digits, and data interpretation.
-        data_bytes (bytes): The raw data to decode.
-
-    Returns:
-        dict: Decoded results including format details and the final interpreted value.
-    """
-    try:
-        logger.debug(f"Decoding channel ID: 0x{channel_id:02X}, format byte: 0x{format_byte:02X}, data: {data_bytes.hex()}")
-
-        # Extract format information from the format byte
-        divisor_bits = (format_byte >> 6) & 0b11  # First two bits
-        digits_bits = (format_byte >> 4) & 0b11   # Next two bits
-        format_bits = format_byte & 0b1111        # Last four bits
-
-        # Map divisor and digits bits to actual values
-        divisor_map = {0b00: 1, 0b01: 10, 0b10: 100, 0b11: 1000}
-        digits_map = {0b00: 1, 0b01: 2, 0b10: 3, 0b11: 4}
-
-        divisor = divisor_map.get(divisor_bits, 1)
-        digits = digits_map.get(digits_bits, 1)
-
-        if len(data_bytes) == 0:
-            logger.debug("decode_format_and_data: Empty data bytes; cannot decode.")
-            return None
-
-        # Decode based on format bits
-        if format_bits == 0x01:  # 16-bit signed integer
-            if len(data_bytes) != 2:
-                logger.debug("Data length mismatch for 16-bit signed integer (expected 2 bytes).")
-                return None
-            raw_value = int.from_bytes(data_bytes, byteorder="big", signed=True)
-            
-            # Special handling for Autopilot Mode (channel 0xB5)
-            if channel_id == 0xB5:
-                autopilot_modes = {
-                    20484: "Standby",
-                    20737: "Compass",
-                    20738: "Power",
-                    20740: "Wind",
-                    20755: "NMEA WP",
-                }
-                interpreted_value = autopilot_modes.get(raw_value, f"Unknown ({raw_value})")
-            else:
-                interpreted_value = raw_value / divisor            
-
-
-        elif format_bits == 0x02:  # 6-bit segment + 10-bit unsigned value
-            if len(data_bytes) != 2:
-                logger.debug("Data length mismatch for 6-bit segment + 10-bit unsigned (expected 2 bytes).")
-                return None
-            segment_code = (data_bytes[0] >> 2) & 0b111111  # 6-bit segment code
-            unsigned_value = ((data_bytes[0] & 0b11) << 8) | data_bytes[1]  # 10-bit unsigned value
-            interpreted_value = unsigned_value / divisor
-            raw_value = {"segment_code": segment_code, "unsigned_value": unsigned_value}
-
-        elif format_bits == 0x03:  
-            if len(data_bytes) != 2:
-                logger.debug("Data length mismatch for 7-bit segment + 9-bit unsigned (expected 2 bytes).")
-                return None
-            # 7-bit segment + 9-bit unsigned - think this is wrong, believe to be  8+8 as per below
-            #segment_code = (data_bytes[0] >> 1) & 0b01111111  # 7-bit segment
-            #unsigned_value = ((data_bytes[0] & 0b1) << 8) | data_bytes[1]  # 9-bit unsigned value
-            segment_code = data_bytes[0]
-            unsigned_value = data_bytes[1]
-
-            layout = convert_segment_a_to_char(segment_code)
-            if layout == "-[data]" or layout == "=[data]":
-                signed_value = -unsigned_value 
-            else:
-                signed_value = unsigned_value
-            interpreted_value = signed_value / divisor
-            raw_value = {"segment_code": hex(segment_code), "segment_code_bin": bin(segment_code), "unsigned_value": unsigned_value, "layout": layout}
-
-        elif format_bits == 0x04:  # 8-bit segment + 24-bit unsigned value
-            if len(data_bytes) != 4:
-                logger.debug("Data length mismatch for 8-bit + 24-bit unsigned (expected 4 bytes).")
-                return None
-            segment_code = data_bytes[0]  # 8-bit segment code
-            unsigned_value = int.from_bytes(data_bytes[1:], byteorder="big", signed=False)  # 24-bit unsigned value
-            interpreted_value = unsigned_value / divisor
-            raw_value = {"segment_code": segment_code, "unsigned_value": unsigned_value}
-
-        elif format_bits == 0x05:  # Timer format (XX YY ZZ WW)
-            if len(data_bytes) != 4:
-                logger.debug("Data length mismatch for timer format (expected 4 bytes).")
-                return None
-            useless = data_bytes[0]  # Useless byte (can be ignored)
-            hours = data_bytes[1]  # Hours (may exceed 24)
-            minutes = data_bytes[2]  # Minutes
-            seconds = data_bytes[3]  # Seconds
-            interpreted_value = datetime.timedelta(hours=hours, minutes=minutes, seconds=seconds)
-            raw_value = {"useless": useless, "hours": hours, "minutes": minutes, "seconds": seconds}
-
-        elif format_bits == 0x06:  # 7-segment display text
-            if len(data_bytes) != 4:
-                logger.debug("Data length mismatch for 7-segment display text (expected 4 bytes).")
-                return None
-            segment_text = "".join(convert_segment_b_to_char(byte) for byte in data_bytes)
-            logger.debug(f"Decoded 7-segment text: {segment_text}")
-            raw_value = [f"{byte:02X}" for byte in data_bytes]  # Raw bytes as hex strings
-            interpreted_value = segment_text
-
-        elif format_bits == 0x07:  # 15-bit unsigned value with 4-byte input
-            if len(data_bytes) != 4:
-                logger.debug("Data length mismatch for 15-bit unsigned (expected 4 bytes).")
-                return None
-            # unused - SegCodeA - 7bit MSB, 8 bit LSB
-            segment_code = data_bytes[1]
-            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
-
-            layout = convert_segment_a_to_char(segment_code)
-            if layout == "H[data]" or layout == "-[data]":
-                signed_value = -unsigned_value 
-            else:
-                signed_value = unsigned_value
-            
-            interpreted_value = signed_value / divisor
-            
-            raw_value = {"segment_code": hex(segment_code), "segment_code_bin": bin(segment_code), "unsigned_value": unsigned_value, "layout": layout}
-
-
-        #elif format_bits == 0x07:  # 15-bit unsigned value with 4-byte input
-        #    if len(data_bytes) != 4:
-        #        logger.warning("Data length mismatch for 15-bit unsigned (expected 4 bytes).")
-        #        return None
-        #    msb = (data_bytes[2] >> 1) & 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
-        #    interpreted_value = unsigned_value / divisor
-        #    raw_value = unsigned_value
-
-
-        elif format_bits == 0x08:  # 7-bit segment + 9-bit unsigned (0x08 format)
-            if len(data_bytes) != 2:
-                logger.debug("decode_format_and_data: Data length mismatch for 0x08 (7-bit segment + 9-bit unsigned).")
-                return None
-            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
-            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:
-                logger.debug("Data length mismatch for 16-bit + 16-bit signed (expected 4 bytes).")
-                return None
-            first_value = int.from_bytes(data_bytes[:2], byteorder="big", signed=True)  # First 16-bit signed integer
-            second_value = int.from_bytes(data_bytes[2:], byteorder="big", signed=True)  # Second 16-bit signed integer
-            interpreted_first_value = first_value / divisor
-            interpreted_second_value = second_value / divisor
-            interpreted_value = interpreted_first_value
-            raw_value = {"first": interpreted_first_value, "second": interpreted_second_value}
-
-
-        else:
-            logger.debug(f"Unsupported format: 0x{format_bits:02X}.")
-            return None
-
-        # Return the result
-        result = {
-            "channel_id": f"0x{channel_id:02X}",
-            "format_byte": f"0x{format_byte:02X}",
-            "data_bytes": data_bytes.hex(),
-            "divisor": divisor,
-            "digits": digits,
-            "format_bits": format_bits,
-            "raw": raw_value,
-            "interpreted": interpreted_value
-        }
-        #ogger.debug(f"Decoded value for channel 0x{channel_id:02X}: {interpreted_value}")
-        return result
-
-    except Exception as e:
-        logger.error(f"Error decoding channel 0x{channel_id:02X}: {e}")
-        return None

pyfastnet-1.2.4/fastnet_decoder/utils.py

@@ -1,98 +0,0 @@
-
-
-def calculate_checksum(data):
-    """
-    Calculates the checksum for the given data bytes this one is for Fastnet Checksum
-    Args:
-        data (bytes): The data bytes to calculate checksum for.
-    Returns:
-        int: The calculated checksum.
-    """
-    return (0x100 - sum(data) % 0x100) & 0xFF
-
-
-def calculate_nmea_checksum(sentence):
-    """
-    Calculates the NMEA checksum for a given sentence (excluding '$' and '*').
-    Args:
-        sentence (str): NMEA sentence string without '$' and checksum '*'.
-    Returns:
-        str: Hexadecimal checksum as a string.
-    """
-    checksum = 0
-    for char in sentence:
-        checksum ^= ord(char)
-    return f"{checksum:02X}"
-
-
-def convert_segment_b_to_char(segment_byte):
-    """
-    Converts a 7-segment display byte into a human-readable character, will add more as we figure them out
-    Args:
-        segment_byte (int): The byte representing the 7-segment display.
-    Returns:
-        str: The corresponding character or '?' if unknown.
-    """
-    segment_mapping = {
-        0xBE: "O",
-        0xE8: "F",
-        0x62: "n",
-        0x72: "o",
-        0x40: "-",
-        0x00: " ",  # Blank
-    }
-    return segment_mapping.get(segment_byte, "?")
-
-def convert_segment_a_to_char(segment_byte):
-    """
-    Converts a 7-segment display byte into a human-readable character, will add more as we figure them out
-    Args:
-        segment_byte (int): The byte representing the 7-segment display.
-    Returns:
-        str: The corresponding character or '?' if unknown.
-    """
-    #segment_mapping = {
-    #    0x14: "[data]=",
-    #    0x54: "=[data]",
-    #    0x10: "[data]-",
-    #    0x50: "-[data]",
-    #    0x46: "=[data]", #Rudder angle top and bottom segments, but lets just call it an =
-    #    0x06: "[data]=", #Rudder angle top and bottom segments, but lets just call it an =
-    #    0x00: " ",  # Blank
-    #}
-
-    segment_mapping = {
-        0x66: "°M",  # magnetic bearing indicator (seen on Heading, Course, TWD, Tidal Set)
-        0x28: "[data]=",
-        0xa8: "=[data]",
-        0x20: "[data]-",
-        0xa0: "-[data]",
-        0x8c: "=[data]", #Rudder angle top and bottom segments, but lets just call it an =
-        0x0c: "[data]=", #Rudder angle top and bottom segments, but lets just call it an =
-        0xf3: "H[data]", #Heel to port
-        0x73: "[data]H", #Heel to stb
-        0x00: " ",  # Blank
-    }
-    return segment_mapping.get(segment_byte, "?")
-
-
-def parse_format_byte(format_byte):
-    """
-    Parses the format byte into divisor, digits, and format type.
-    Args:
-        format_byte (int): The format byte.
-    Returns:
-        dict: Parsed divisor, digits, and format type.
-    """
-    divisor_bits = (format_byte >> 6) & 0b11  # First two bits
-    digits_bits = (format_byte >> 4) & 0b11   # Next two bits
-    format_type = format_byte & 0x0F          # Last 4 bits (format type)
-
-    divisor_map = {0b00: 1, 0b01: 10, 0b10: 100, 0b11: 1000}
-    digits_map = {0b00: 1, 0b01: 2, 0b10: 3, 0b11: 4}
-
-    return {
-        "divisor": divisor_map.get(divisor_bits, 1),
-        "digits": digits_map.get(digits_bits, 1),
-        "format_type": format_type,
-    }