pyfastnet 2.0.2__tar.gz → 2.0.4__tar.gz

{pyfastnet-2.0.2/pyfastnet.egg-info → pyfastnet-2.0.4}/PKG-INFO

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

{pyfastnet-2.0.2 → pyfastnet-2.0.4}/fastnet_decoder/decode_fastnet.py

@@ -1,53 +1,54 @@
 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}
+_DECIMAL_PLACES_MAP = {1: 0, 10: 1, 100: 2, 1000: 3}
 
+# Layout strings describe how the display reads around the numeric value.
+# "[data]" is a placeholder for the number. Examples:
+#   "[data]-"  →  value is positive, trailing minus means port/starboard convention
+#   "-[data]"  →  value is negative (subtract sign)
+#   "=[data]"  →  value is negative (equals sign variant)
+#   "H[data]"  →  "H" prefix, e.g. H045 for a heading
+#   "°M"       →  magnetic bearing, suffix added after value
 
 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]}"
+    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 == "[data]=": return f"{formatted}="
+    if layout == "[data]-": return f"{formatted}-"
     return formatted
 
 
 def decode_frame(frame: bytes) -> dict:
     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_checksum   = frame[-1]
-
-        if calculate_checksum(frame[:4]) != header_checksum:
-            logger.debug(f"FRAME discard  header-checksum  [{frame.hex()[:16]}...]")
-            return {"error": "Header checksum mismatch"}
-
-        if calculate_checksum(body) != body_checksum:
-            logger.debug(f"FRAME discard  body-checksum  [{frame.hex()[:16]}...]")
-            return {"error": "Body checksum mismatch"}
+        to_address   = frame[0]
+        from_address = frame[1]
+        body_size    = frame[2]
+        command      = frame[3]
+        # frame[4] is the header checksum — already validated by FrameBuffer before this is called
+        body         = frame[5:-1]
 
         if len(body) < 2 or len(body) != body_size:
             logger.debug(f"FRAME discard  body-size  expected={body_size}  actual={len(body)}")
             return {"error": "Invalid body size"}
 
+        to_name   = ADDRESS_LOOKUP.get(to_address)
+        from_name = ADDRESS_LOOKUP.get(from_address)
+        cmd_name  = COMMAND_LOOKUP.get(command)
+
         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})"),
+            "to_address":   to_name   if to_name   is not None else f"Unknown (0x{to_address:02X})",
+            "from_address": from_name if from_name is not None else f"Unknown (0x{from_address:02X})",
+            "command":      cmd_name  if cmd_name  is not None else f"Unknown (0x{command:02X})",
             "values":       {}
         }
 
@@ -59,8 +60,10 @@ def decode_frame(frame: bytes) -> dict:
 
             channel_id   = body[index]
             format_byte  = body[index + 1]
-            channel_name = CHANNEL_LOOKUP.get(channel_id, f"Unknown (0x{channel_id:02X})")
-            index       += 2
+            channel_name = CHANNEL_LOOKUP.get(channel_id)
+            if channel_name is None:
+                channel_name = f"Unknown (0x{channel_id:02X})"
+            index += 2
 
             data_length = FORMAT_SIZE_MAP.get(format_byte & 0x0F, 0)
             if index + data_length > len(body):
@@ -73,20 +76,22 @@ def decode_frame(frame: bytes) -> dict:
             data_bytes = body[index:index + data_length]
             index     += data_length
 
-            logger.debug(
-                f"  CH  0x{channel_id:02X} {channel_name}  "
-                f"fmt=0x{format_byte:02X}  data=[{data_bytes.hex()}]"
-            )
-
             decoded_value = decode_format_and_data(channel_id, format_byte, data_bytes)
             decoded_data["values"][channel_name] = decoded_value
 
             if decoded_value:
                 logger.debug(
-                    f"       value={decoded_value['value']}  "
+                    f"  CH  0x{channel_id:02X} {channel_name}  "
+                    f"fmt=0x{format_byte:02X}  data=[{data_bytes.hex()}]  "
+                    f"value={decoded_value['value']}  "
                     f"display='{decoded_value['display_text']}'  "
                     f"layout={decoded_value['layout']}"
                 )
+            else:
+                logger.debug(
+                    f"  CH  0x{channel_id:02X} {channel_name}  "
+                    f"fmt=0x{format_byte:02X}  data=[{data_bytes.hex()}]  (no decode)"
+                )
 
         return decoded_data
 
@@ -103,8 +108,11 @@ def decode_ascii_frame(frame: bytes) -> dict:
         body         = frame[5:-1]
 
         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, f"Unknown (0x{channel_id:02X})")
+        channel_name = CHANNEL_LOOKUP.get(channel_id)
+        if channel_name is None:
+            channel_name = f"Unknown (0x{channel_id:02X})"
 
         try:
             ascii_text = data_bytes.decode("ascii").strip()
@@ -114,10 +122,14 @@ def decode_ascii_frame(frame: bytes) -> dict:
 
         logger.debug(f"  CH  0x{channel_id:02X} {channel_name}  ascii='{ascii_text}'")
 
+        to_name   = ADDRESS_LOOKUP.get(to_address)
+        from_name = ADDRESS_LOOKUP.get(from_address)
+        cmd_name  = COMMAND_LOOKUP.get(command)
+
         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})"),
+            "to_address":   to_name   if to_name   is not None else f"Unknown (0x{to_address:02X})",
+            "from_address": from_name if from_name is not None else f"Unknown (0x{from_address:02X})",
+            "command":      cmd_name  if cmd_name  is not None else f"Unknown (0x{command:02X})",
             "values": {
                 channel_name: {
                     "channel_id":   f"0x{channel_id:02X}",
@@ -135,9 +147,9 @@ def decode_ascii_frame(frame: bytes) -> dict:
 
 def decode_format_and_data(channel_id, format_byte, data_bytes):
     try:
-        divisor     = _DIVISOR_MAP[(format_byte >> 6) & 0b11]
-        dp          = _DP_MAP[divisor]
-        format_bits = format_byte & 0b1111
+        divisor        = _DIVISOR_MAP[(format_byte >> 6) & 0b11]
+        decimal_places = _DECIMAL_PLACES_MAP[divisor]
+        format_bits    = format_byte & 0b1111
 
         if len(data_bytes) == 0:
             return None
@@ -153,14 +165,14 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
                 display_text = AUTOPILOT_MODES.get(raw, f"Unknown ({raw})")
             else:
                 value        = raw / divisor
-                display_text = f"{value:.{dp}f}"
+                display_text = f"{value:.{decimal_places}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}"
+            display_text = f"{value:.{decimal_places}f}"
 
         elif format_bits == 0x03:
             if len(data_bytes) != 2:
@@ -168,18 +180,20 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
             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}")
+            display_text = _display_from_layout(layout, f"{value:.{decimal_places}f}")
 
         elif format_bits == 0x04:
             if len(data_bytes) != 4:
                 return None
+            # data_bytes[0] is a status/flag byte, not part of the value
             unsigned     = int.from_bytes(data_bytes[1:], byteorder="big", signed=False)
             value        = unsigned / divisor
-            display_text = f"{value:.{dp}f}"
+            display_text = f"{value:.{decimal_places}f}"
 
         elif format_bits == 0x05:
             if len(data_bytes) != 4:
                 return None
+            # data_bytes[0] is a status/flag byte; bytes 1-3 are h, m, s
             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))
@@ -193,11 +207,12 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
         elif format_bits == 0x07:
             if len(data_bytes) != 4:
                 return None
+            # data_bytes[0] is a status/flag byte; byte 1 is the segment/layout code
             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}")
+            display_text = _display_from_layout(layout, f"{value:.{decimal_places}f}")
 
         elif format_bits == 0x08:
             if len(data_bytes) != 2:
@@ -206,7 +221,7 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
             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}")
+            display_text = _display_from_layout(layout, f"{value:.{decimal_places}f}")
 
         elif format_bits == 0x0A:
             if len(data_bytes) != 4:
@@ -214,9 +229,10 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
             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}"
+            display_text = f"{first:.{decimal_places}f} / {second:.{decimal_places}f}"
 
         else:
+            # format 0x09 has not been observed in captured data
             logger.debug(f"       unsupported format 0x{format_bits:02X}")
             return None
 

{pyfastnet-2.0.2 → pyfastnet-2.0.4}/fastnet_decoder/frame_buffer.py

@@ -1,3 +1,4 @@
+import logging
 from .utils import calculate_checksum
 from .mappings import COMMAND_LOOKUP, IGNORED_COMMANDS
 from .decode_fastnet import decode_frame, decode_ascii_frame
@@ -52,29 +53,34 @@ class FrameBuffer:
             frame         = self.buffer[:full_frame_length]
             body          = self.buffer[5:full_frame_length - 1]
             body_checksum = self.buffer[full_frame_length - 1]
-            frame_hex     = bytes(frame[:8]).hex()
+
+            debug = logger.isEnabledFor(logging.DEBUG)
 
             if calculate_checksum(self.buffer[:4]) != header_checksum:
-                logger.debug(f"FRAME discard  header-checksum  [{frame_hex}...]")
+                if debug:
+                    logger.debug(f"FRAME discard  header-checksum  [{bytes(frame).hex()}]")
                 self.buffer = self.buffer[1:]
                 continue
 
             if calculate_checksum(body) != body_checksum:
-                logger.debug(f"FRAME discard  body-checksum  [{frame_hex}...]")
+                if debug:
+                    logger.debug(f"FRAME discard  body-checksum  [{bytes(frame).hex()}]")
                 self.buffer = self.buffer[1:]
                 continue
 
             self.buffer = self.buffer[full_frame_length:]
 
             if command_name in IGNORED_COMMANDS:
-                logger.debug(f"FRAME skip    cmd={command_name}")
+                if debug:
+                    logger.debug(f"FRAME skip    cmd={command_name}")
                 continue
 
-            logger.debug(
-                f"FRAME cmd={command_name}  "
-                f"0x{to_address:02X}←0x{from_address:02X}  "
-                f"body={body_size}B  [{frame_hex}...]"
-            )
+            if debug:
+                logger.debug(
+                    f"FRAME cmd={command_name}  "
+                    f"0x{to_address:02X}←0x{from_address:02X}  "
+                    f"body={body_size}B  [{bytes(frame).hex()}]"
+                )
             self.decode_and_queue_frame(frame, command_name)
 
     def decode_and_queue_frame(self, frame, command_name):
@@ -82,17 +88,19 @@ class FrameBuffer:
         decoder = decode_ascii_frame if command_name == "LatLon" else decode_frame
         decoded_frame = decoder(frame)
         if decoded_frame and "values" in decoded_frame:
-            channel_names = list(decoded_frame["values"].keys())
-            names_str = ", ".join(channel_names[:4])
-            if len(channel_names) > 4:
-                names_str += f", +{len(channel_names) - 4} more"
             try:
                 self.frame_queue.put_nowait(decoded_frame)
-                logger.debug(f"QUEUE {len(channel_names)} channel(s)  [{names_str}]")
+                if logger.isEnabledFor(logging.DEBUG):
+                    channel_names = list(decoded_frame["values"].keys())
+                    names_str = ", ".join(channel_names[:4])
+                    if len(channel_names) > 4:
+                        names_str += f", +{len(channel_names) - 4} more"
+                    logger.debug(f"  QUEUE {len(channel_names)} channel(s)  [{names_str}]")
             except Full:
                 logger.warning("Frame queue full, dropping frame.")
         else:
-            logger.debug(f"QUEUE fail    decode error  [{frame.hex()[:16]}...]")
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"  QUEUE fail    decode error  [{frame.hex()}]")
 
     def get_buffer_size(self):
         return len(self.buffer)

{pyfastnet-2.0.2 → pyfastnet-2.0.4}/fastnet_decoder/mappings.py

@@ -301,7 +301,7 @@ FORMAT_SIZE_MAP = {
     0x03: 2,  # 16 bits (2 bytes)
     0x04: 4,  # 32 bits (4 bytes)
     0x05: 4,  # 32 bits (4 bytes)
-    0x06: 4,  # 16 bits (2 bytes)
+    0x06: 4,  # 32 bits (4 bytes)
     0x07: 4,  # 16 bits (2 bytes)
     0x08: 2,  # 16 bits (2 bytes)
     0x0A: 4   # 32 bits (4 bytes)

{pyfastnet-2.0.2 → pyfastnet-2.0.4}/fastnet_decoder/utils.py

@@ -8,7 +8,7 @@ def calculate_checksum(data):
     Returns:
         int: The calculated checksum.
     """
-    return (0x100 - sum(data) % 0x100) & 0xFF
+    return (-sum(data)) & 0xFF
 
 
 def calculate_nmea_checksum(sentence):

{pyfastnet-2.0.2 → pyfastnet-2.0.4/pyfastnet.egg-info}/PKG-INFO

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

{pyfastnet-2.0.2 → pyfastnet-2.0.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="pyfastnet",
-    version="2.0.2",  # Ensure this matches your intended version
+    version="2.0.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.",