pyfastnet 2.0.0__tar.gz → 2.0.2__tar.gz

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

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

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

@@ -24,8 +24,6 @@ def _display_from_layout(layout: str, formatted: str) -> str:
 
 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]
@@ -34,76 +32,75 @@ def decode_frame(frame: bytes) -> dict:
         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()}")
+            logger.debug(f"FRAME discard  header-checksum  [{frame.hex()[:16]}...]")
             return {"error": "Header checksum mismatch"}
 
         if calculate_checksum(body) != body_checksum:
-            logger.debug(f"Body checksum mismatch. Frame dropped: {frame.hex()}")
+            logger.debug(f"FRAME discard  body-checksum  [{frame.hex()[:16]}...]")
             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()}")
+            logger.debug(f"FRAME discard  body-size  expected={body_size}  actual={len(body)}")
             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})"),
+            "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":      {}
+            "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}"
-                )
+                logger.debug(f"  CH  incomplete header at index={index}")
                 return {"error": "Insufficient bytes for channel header"}
 
-            channel_id  = body[index]
-            format_byte = body[index + 1]
-            index      += 2
+            channel_id   = body[index]
+            format_byte  = body[index + 1]
+            channel_name = CHANNEL_LOOKUP.get(channel_id, f"Unknown (0x{channel_id:02X})")
+            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}"
+                    f"  CH  0x{channel_id:02X} {channel_name}  "
+                    f"incomplete  need={data_length}B  have={len(body) - index}B"
                 )
                 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})")
+            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
-            logger.debug(f"Decoded value for channel {channel_name}: {decoded_value}")
+
+            if decoded_value:
+                logger.debug(
+                    f"       value={decoded_value['value']}  "
+                    f"display='{decoded_value['display_text']}'  "
+                    f"layout={decoded_value['layout']}"
+                )
 
         return decoded_data
 
     except Exception as e:
-        logger.error(f"Unexpected error during frame decoding: {e}. Frame contents: {frame.hex()}")
+        logger.error(f"Unexpected error decoding frame: {e}  [{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]
+        to_address   = frame[0]
+        from_address = frame[1]
+        command      = frame[3]
+        body         = frame[5:-1]
 
         channel_id   = body[0]
         data_bytes   = body[2:]
@@ -112,13 +109,15 @@ def decode_ascii_frame(frame: bytes) -> dict:
         try:
             ascii_text = data_bytes.decode("ascii").strip()
         except UnicodeDecodeError as e:
-            logger.warning(f"Failed to decode ASCII text: {e}")
+            logger.warning(f"  CH  0x{channel_id:02X} {channel_name}  ASCII decode failed: {e}")
             return {"error": "ASCII decode failed"}
 
+        logger.debug(f"  CH  0x{channel_id:02X} {channel_name}  ascii='{ascii_text}'")
+
         return {
-            "to_address":  ADDRESS_LOOKUP.get(to_address,   f"Unknown (0x{to_address:02X})"),
+            "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})"),
+            "command":      COMMAND_LOOKUP.get(command,       f"Unknown (0x{command:02X})"),
             "values": {
                 channel_name: {
                     "channel_id":   f"0x{channel_id:02X}",
@@ -136,14 +135,11 @@ def decode_ascii_frame(frame: bytes) -> dict:
 
 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
@@ -193,7 +189,6 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
                 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:
@@ -222,7 +217,7 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
             display_text = f"{first:.{dp}f} / {second:.{dp}f}"
 
         else:
-            logger.debug(f"Unsupported format: 0x{format_bits:02X}.")
+            logger.debug(f"       unsupported format 0x{format_bits:02X}")
             return None
 
         return {

pyfastnet-2.0.2/fastnet_decoder/frame_buffer.py

@@ -0,0 +1,103 @@
+from .utils import calculate_checksum
+from .mappings import COMMAND_LOOKUP, IGNORED_COMMANDS
+from .decode_fastnet import decode_frame, decode_ascii_frame
+from .logger import logger
+from queue import Queue, Full
+
+
+class FrameBuffer:
+    """
+    Manages an incoming byte stream, extracts valid FastNet frames,
+    decodes them, and queues the results.
+
+    Typical workflow:
+        1. Feed raw bytes via add_to_buffer()
+        2. Call get_complete_frames() to process the buffer
+        3. Pull decoded frames from frame_queue
+    """
+
+    def __init__(self, max_buffer_size=8192, max_queue_size=1000):
+        self.buffer = bytearray()
+        self.max_buffer_size = max_buffer_size
+        self.frame_queue = Queue(maxsize=max_queue_size)
+
+    def add_to_buffer(self, new_data):
+        if not isinstance(new_data, (bytes, bytearray)):
+            logger.error("Invalid data type passed to add_to_buffer. Expected bytes or bytearray.")
+            return
+
+        self.buffer.extend(new_data)
+        logger.debug(f"BUF   +{len(new_data)}B  total={len(self.buffer)}B")
+
+        if len(self.buffer) > self.max_buffer_size:
+            logger.warning("Buffer size exceeded maximum limit. Trimming the oldest data.")
+            self.buffer = self.buffer[-self.max_buffer_size:]
+
+    def get_complete_frames(self):
+        """Extract, validate, and queue complete frames from the buffer."""
+        while len(self.buffer) >= 6:
+            to_address      = self.buffer[0]
+            from_address    = self.buffer[1]
+            body_size       = self.buffer[2]
+            command         = self.buffer[3]
+            header_checksum = self.buffer[4]
+
+            command_name     = COMMAND_LOOKUP.get(command, f"Unknown (0x{command:02X})")
+            full_frame_length = 5 + body_size + 1
+
+            if len(self.buffer) < full_frame_length:
+                logger.debug(f"FRAME wait    need={full_frame_length}B  have={len(self.buffer)}B")
+                break
+
+            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()
+
+            if calculate_checksum(self.buffer[:4]) != header_checksum:
+                logger.debug(f"FRAME discard  header-checksum  [{frame_hex}...]")
+                self.buffer = self.buffer[1:]
+                continue
+
+            if calculate_checksum(body) != body_checksum:
+                logger.debug(f"FRAME discard  body-checksum  [{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}")
+                continue
+
+            logger.debug(
+                f"FRAME cmd={command_name}  "
+                f"0x{to_address:02X}←0x{from_address:02X}  "
+                f"body={body_size}B  [{frame_hex}...]"
+            )
+            self.decode_and_queue_frame(frame, command_name)
+
+    def decode_and_queue_frame(self, frame, command_name):
+        """Decode a frame and add it to the queue if valid."""
+        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}]")
+            except Full:
+                logger.warning("Frame queue full, dropping frame.")
+        else:
+            logger.debug(f"QUEUE fail    decode error  [{frame.hex()[:16]}...]")
+
+    def get_buffer_size(self):
+        return len(self.buffer)
+
+    def get_buffer_contents(self):
+        hex_contents = self.buffer.hex()
+        logger.debug(f"BUF   contents  [{hex_contents}]")
+        return hex_contents

{pyfastnet-2.0.0 → pyfastnet-2.0.2}/fastnet_decoder/logger.py

@@ -1,26 +1,20 @@
 import logging
 
-# Create a logger
-logger = logging.getLogger("fastnet_decoder")
+logger = logging.getLogger("pyfastnet")
 
-# Default log level
 DEFAULT_LOG_LEVEL = logging.INFO
 
-# Avoid duplicate handlers
 if not logger.hasHandlers():
     handler = logging.StreamHandler()
-    formatter = logging.Formatter("%(asctime)s [%(levelname)s] [%(module)s] %(message)s")
+    formatter = logging.Formatter("%(asctime)s [pyfastnet] %(levelname)-5s %(message)s")
     handler.setFormatter(formatter)
     logger.addHandler(handler)
 
 logger.setLevel(DEFAULT_LOG_LEVEL)
 
+
 def set_log_level(level_name: str):
-    """
-    Sets the log level dynamically at runtime.
-    Args:
-        level_name (str): Name of the log level (e.g., "DEBUG", "INFO", "WARNING").
-    """
+    """Sets the log level dynamically at runtime."""
     level = getattr(logging, level_name.upper(), DEFAULT_LOG_LEVEL)
     logger.setLevel(level)
     logger.info(f"Log level set to {level_name.upper()}.")

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

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

{pyfastnet-2.0.0 → pyfastnet-2.0.2}/pyfastnet.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ 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_depth_frame.py
 tests/test_format07_msb_regression.py
 tests/test_format08_layout.py

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

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

@@ -0,0 +1,407 @@
+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"]
+
+
+# ---------------------------------------------------------------------------
+# Boatspeed — format 0x01 (16-bit signed, divisor 100) + 0x0A pair
+# ---------------------------------------------------------------------------
+
+class TestBoatspeed(unittest.TestCase):
+    """
+    Frame from Performance Processor containing Boatspeed (Knots) and
+    Boatspeed (Raw). Raw uses format 0x0A — two 16-bit signed integers.
+    """
+    FRAME = "ff010a01f54192f9dd420a01ec082cea"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_boatspeed_knots_value(self):
+        self.assertAlmostEqual(self.v["Boatspeed (Knots)"]["value"], 4.77, places=2)
+
+    def test_boatspeed_knots_display(self):
+        self.assertEqual(self.v["Boatspeed (Knots)"]["display_text"], "4.77")
+
+    def test_boatspeed_raw_display_pair(self):
+        # format 0x0A renders as "first / second"
+        self.assertIn(" / ", self.v["Boatspeed (Raw)"]["display_text"])
+
+
+# ---------------------------------------------------------------------------
+# Apparent wind — format 0x01 (AWS) + 0x07 with port layout (AWA)
+# ---------------------------------------------------------------------------
+
+class TestApparentWind(unittest.TestCase):
+    """
+    18-channel broadcast frame containing all three apparent wind channels.
+    - AWS Knots / m/s: format 0x01, divisor 10
+    - AWA: format 0x07, layout '[data]-' (trailing dash = port side)
+    """
+    FRAME = "ff051801e34e0a061c05fe4d51009c4f610050520a47f347f351032065a0"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_aws_knots_value(self):
+        self.assertAlmostEqual(self.v["Apparent Wind Speed (Knots)"]["value"], 15.6, places=1)
+
+    def test_aws_knots_display(self):
+        self.assertEqual(self.v["Apparent Wind Speed (Knots)"]["display_text"], "15.6")
+
+    def test_aws_ms_value(self):
+        self.assertAlmostEqual(self.v["Apparent Wind Speed (m/s)"]["value"], 8.0, places=1)
+
+    def test_awa_value(self):
+        # Port/starboard is encoded in layout, not value sign — value stays positive
+        self.assertEqual(self.v["Apparent Wind Angle"]["value"], 101.0)
+
+    def test_awa_layout_port(self):
+        self.assertEqual(self.v["Apparent Wind Angle"]["layout"], "[data]-")
+
+    def test_awa_display_port(self):
+        # Trailing dash is the port indicator rendered in display_text
+        self.assertEqual(self.v["Apparent Wind Angle"]["display_text"], "101-")
+
+
+# ---------------------------------------------------------------------------
+# True wind — format 0x01 (TWS) + 0x07 (TWA starboard, TWD °M, VMG)
+# ---------------------------------------------------------------------------
+
+class TestTrueWind(unittest.TestCase):
+    """
+    16-channel broadcast frame with all true wind and VMG channels.
+    - TWA: format 0x07, layout '[data]=' (trailing equals = starboard)
+    - TWD: format 0x07, layout '°M'
+    - VMG: format 0x07
+    """
+    FRAME = "ff051601e5555100a656610055590328767f8700bb00db6d08cc7061"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_tws_knots(self):
+        self.assertAlmostEqual(self.v["True Wind Speed (Knots)"]["value"], 16.6, places=1)
+
+    def test_tws_ms(self):
+        self.assertAlmostEqual(self.v["True Wind Speed (m/s)"]["value"], 8.5, places=1)
+
+    def test_twa_value(self):
+        self.assertEqual(self.v["True Wind Angle"]["value"], 118.0)
+
+    def test_twa_layout_starboard(self):
+        # Trailing equals = starboard; value remains positive
+        self.assertEqual(self.v["True Wind Angle"]["layout"], "[data]=")
+
+    def test_twa_display_starboard(self):
+        self.assertEqual(self.v["True Wind Angle"]["display_text"], "118=")
+
+    def test_twd_value(self):
+        self.assertEqual(self.v["True Wind Direction"]["value"], 112.0)
+
+    def test_twd_layout_magnetic(self):
+        self.assertEqual(self.v["True Wind Direction"]["layout"], "°M")
+
+    def test_twd_display(self):
+        self.assertEqual(self.v["True Wind Direction"]["display_text"], "112°M")
+
+    def test_vmg(self):
+        self.assertAlmostEqual(self.v["Velocity Made Good (Knots)"]["value"], 2.19, places=2)
+
+
+# ---------------------------------------------------------------------------
+# Heading and Rudder — format 0x08 (Heading °M) + 0x03 (Rudder signed)
+# ---------------------------------------------------------------------------
+
+class TestHeadingAndRudder(unittest.TestCase):
+    """
+    3-channel frame: Heading, Rudder Angle, Heading (Raw).
+    - Heading: format 0x08, segment code 0x66 → layout '°M'
+    - Rudder Angle: format 0x03, segment byte 0x8c → layout '=[data]',
+      value is negative (sign from layout, not from the raw byte)
+    - Heading (Raw): format 0x0A two-signed pair
+    """
+    FRAME = "ff120e01e00b038c024908cd634a0afbe13d492d"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_heading_value(self):
+        self.assertEqual(self.v["Heading"]["value"], 355.0)
+
+    def test_heading_layout(self):
+        self.assertEqual(self.v["Heading"]["layout"], "°M")
+
+    def test_heading_display(self):
+        self.assertEqual(self.v["Heading"]["display_text"], "355°M")
+
+    def test_rudder_negative_value(self):
+        # '=[data]' → _sign_from_layout returns -1; raw byte = 2 → value = -2
+        self.assertEqual(self.v["Rudder Angle"]["value"], -2.0)
+
+    def test_rudder_layout(self):
+        self.assertEqual(self.v["Rudder Angle"]["layout"], "=[data]")
+
+    def test_rudder_display(self):
+        # No layout suffix for '=[data]'; sign appears in the formatted number
+        self.assertEqual(self.v["Rudder Angle"]["display_text"], "-2")
+
+    def test_heading_raw_is_pair(self):
+        # format 0x0A always renders as "signed / signed"
+        self.assertIn(" / ", self.v["Heading (Raw)"]["display_text"])
+
+    def test_heading_raw_first_signed(self):
+        # Both halves signed; first value should be negative here
+        self.assertLess(self.v["Heading (Raw)"]["value"], 0)
+
+
+# ---------------------------------------------------------------------------
+# Course + Leeway + Heading on Next Tack — format 0x08 / 0x07
+# ---------------------------------------------------------------------------
+
+class TestCourseAndNavigation(unittest.TestCase):
+    """
+    4-channel frame: Heading (Raw), Leeway, Course (HDG+Leeway),
+    Heading on Next Tack.
+    Course and Heading on Next Tack use format 0x08 with '°M' layout.
+    Leeway uses format 0x07 with an unrecognised segment code → layout '?'.
+    """
+    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_layout(self):
+        self.assertEqual(self.v["Course (HDG + Leeway)"]["layout"], "°M")
+
+    def test_course_display(self):
+        self.assertEqual(self.v["Course (HDG + Leeway)"]["display_text"], "355°M")
+
+    def test_heading_on_next_tack_value(self):
+        self.assertEqual(self.v["Heading on Next Tack"]["value"], 230.0)
+
+    def test_heading_on_next_tack_layout(self):
+        self.assertEqual(self.v["Heading on Next Tack"]["layout"], "°M")
+
+    def test_heading_on_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)
+
+
+# ---------------------------------------------------------------------------
+# Heel Angle + Fore/Aft Trim — format 0x07, sign from segment layout
+# ---------------------------------------------------------------------------
+
+class TestHeelAndTrim(unittest.TestCase):
+    """
+    Heel-port capture: Heel Angle and Fore/Aft Trim both use format 0x07.
+    - Heel: segment byte 0xf3 → layout 'H[data]' (H prefix, value positive)
+    - Trim: segment byte 0xa0 → layout '-[data]' (value negative = aft trim)
+
+    Battery Volts is also in this frame: format 0x01, divisor 100.
+    """
+    FRAME = "ff051401e78d8105263b3101fa344700f300cc9b4700a000099b"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_heel_positive_value(self):
+        # 'H[data]' does NOT flip sign — port heel is still stored positive
+        self.assertAlmostEqual(self.v["Heel Angle"]["value"], 20.4, places=1)
+
+    def test_heel_layout(self):
+        self.assertEqual(self.v["Heel Angle"]["layout"], "H[data]")
+
+    def test_heel_display_prefix(self):
+        # H prefix indicates port side on the instrument display
+        self.assertEqual(self.v["Heel Angle"]["display_text"], "H20.4")
+
+    def test_trim_negative_value(self):
+        # '-[data]' drives sign negative
+        self.assertAlmostEqual(self.v["Fore/Aft Trim"]["value"], -0.9, places=1)
+
+    def test_trim_layout(self):
+        self.assertEqual(self.v["Fore/Aft Trim"]["layout"], "-[data]")
+
+    def test_trim_display(self):
+        # No suffix; sign is embedded in the formatted number
+        self.assertEqual(self.v["Fore/Aft Trim"]["display_text"], "-0.9")
+
+    def test_battery_volts(self):
+        self.assertAlmostEqual(self.v["Battery Volts"]["value"], 13.18, places=2)
+        self.assertEqual(self.v["Battery Volts"]["display_text"], "13.18")
+
+
+# ---------------------------------------------------------------------------
+# Sea Temperature — format 0x07, unrecognised segment code → layout '?'
+# ---------------------------------------------------------------------------
+
+class TestSeaTemperature(unittest.TestCase):
+    """
+    Stored-log frame also carries sea temperature in Celsius and Fahrenheit.
+    Format 0x07 with a segment byte not present in SEGMENT_A → layout '?'.
+    Cross-check: 23 °C ≈ 73 °F within 1 degree rounding.
+    """
+    FRAME = "ff011801e7cd840000acc7cf84ff0000001f17005c00171e17007400494f"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_sea_temp_celsius(self):
+        self.assertEqual(self.v["Sea Temperature (°C)"]["value"], 23.0)
+        self.assertEqual(self.v["Sea Temperature (°C)"]["display_text"], "23")
+
+    def test_sea_temp_fahrenheit(self):
+        self.assertEqual(self.v["Sea Temperature (°F)"]["value"], 73.0)
+        self.assertEqual(self.v["Sea Temperature (°F)"]["display_text"], "73")
+
+    def test_cross_unit_consistency(self):
+        c = self.v["Sea Temperature (°C)"]["value"]
+        f = self.v["Sea Temperature (°F)"]["value"]
+        self.assertAlmostEqual(c * 9 / 5 + 32, f, delta=1.0)
+
+
+# ---------------------------------------------------------------------------
+# Navigation Log — format 0x04 (3-byte unsigned, divisor 100)
+# ---------------------------------------------------------------------------
+
+class TestNavigationLog(unittest.TestCase):
+    """
+    Stored Log and Trip Log from the same frame as sea temperature.
+    Format 0x04: 4-byte payload, value taken from bytes[1:] (big-endian unsigned).
+    Divisor 100 → two decimal places.
+    """
+    FRAME = "ff011801e7cd840000acc7cf84ff0000001f17005c00171e17007400494f"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_stored_log_value(self):
+        self.assertAlmostEqual(self.v["Stored Log (NM)"]["value"], 442.31, places=2)
+
+    def test_stored_log_display(self):
+        self.assertEqual(self.v["Stored Log (NM)"]["display_text"], "442.31")
+
+    def test_trip_log_zero(self):
+        self.assertEqual(self.v["Trip Log (NM)"]["value"], 0.0)
+        self.assertEqual(self.v["Trip Log (NM)"]["display_text"], "0.00")
+
+
+# ---------------------------------------------------------------------------
+# Timer — format 0x05 (H/M/S bytes → total seconds + HH:MM:SS display)
+# ---------------------------------------------------------------------------
+
+class TestTimer(unittest.TestCase):
+    """
+    Timer channel uses format 0x05: data bytes [unused, H, M, S].
+    value = total seconds; display_text = timedelta string (H:MM:SS).
+    """
+    FRAME = "ff050601f5750501072c064c"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_timer_total_seconds(self):
+        # 7 h × 3600 + 44 min × 60 + 6 s = 27846
+        self.assertEqual(self.v["Timer"]["value"], 27846.0)
+
+    def test_timer_display_hms(self):
+        self.assertEqual(self.v["Timer"]["display_text"], "7:44:06")
+
+
+# ---------------------------------------------------------------------------
+# Speed and Course Over Ground — format 0x01, from NMEA FFD frame
+# ---------------------------------------------------------------------------
+
+class TestSpeedAndCourseOverGround(unittest.TestCase):
+    """
+    SOG / COG True / COG Mag from an NMEA FFD broadcast.
+    - SOG: format 0x01, divisor 10
+    - COG: format 0x01, divisor 1 (integer degrees)
+    """
+    FRAME = "ff600c0194e9310000ea11015beb6100360d"
+
+    def setUp(self):
+        self.v = _decode(self.FRAME)
+
+    def test_sog_value(self):
+        self.assertAlmostEqual(self.v["Speed Over Ground"]["value"], 5.4, places=1)
+
+    def test_sog_display(self):
+        self.assertEqual(self.v["Speed Over Ground"]["display_text"], "5.4")
+
+    def test_cog_mag_value(self):
+        self.assertEqual(self.v["Course Over Ground (Mag)"]["value"], 347.0)
+        self.assertEqual(self.v["Course Over Ground (Mag)"]["display_text"], "347")
+
+    def test_cog_true_value(self):
+        self.assertEqual(self.v["Course Over Ground (True)"]["value"], 0.0)
+
+
+# ---------------------------------------------------------------------------
+# Autopilot modes — format 0x01 raw int mapped to mode name string
+# ---------------------------------------------------------------------------
+
+class TestAutopilotModes(unittest.TestCase):
+    """
+    Autopilot Mode channel (0xB5) uses format 0x01 with a special-case
+    lookup: the raw 16-bit integer is mapped to a mode name string.
+
+    Three frames cover Standby, Compass and Wind modes.
+    In Standby the companion Target channel is OFF (value=None).
+    In Compass/Wind modes, Autopilot Compass Target carries a °M bearing.
+    """
+    STANDBY_FRAME = "ff121c01d2b5015004a606bee8e800af06bee8e8005306bee8e8007606bee8e80088"
+    COMPASS_FRAME = "ff120a01e4b5015101a60700660000e5"
+    WIND_FRAME    = "ff120a01e4b5015104a6070066014b96"
+
+    def _v(self, hex_str):
+        return _decode(hex_str)
+
+    def test_standby_mode_display(self):
+        self.assertEqual(self._v(self.STANDBY_FRAME)["Autopilot Mode"]["display_text"], "Standby")
+
+    def test_standby_target_is_off(self):
+        v = self._v(self.STANDBY_FRAME)
+        self.assertIsNone(v["Autopilot Compass Target"]["value"])
+        self.assertEqual(v["Autopilot Compass Target"]["display_text"], "OFF ")
+
+    def test_compass_mode_display(self):
+        self.assertEqual(self._v(self.COMPASS_FRAME)["Autopilot Mode"]["display_text"], "Compass")
+
+    def test_compass_target_value(self):
+        v = self._v(self.COMPASS_FRAME)
+        self.assertEqual(v["Autopilot Compass Target"]["value"], 0.0)
+
+    def test_compass_target_layout(self):
+        v = self._v(self.COMPASS_FRAME)
+        self.assertEqual(v["Autopilot Compass Target"]["layout"], "°M")
+
+    def test_compass_target_display(self):
+        v = self._v(self.COMPASS_FRAME)
+        self.assertEqual(v["Autopilot Compass Target"]["display_text"], "0°M")
+
+    def test_wind_mode_display(self):
+        self.assertEqual(self._v(self.WIND_FRAME)["Autopilot Mode"]["display_text"], "Wind")
+
+    def test_wind_target_value(self):
+        v = self._v(self.WIND_FRAME)
+        self.assertEqual(v["Autopilot Compass Target"]["value"], 331.0)
+
+    def test_wind_target_display(self):
+        v = self._v(self.WIND_FRAME)
+        self.assertEqual(v["Autopilot Compass Target"]["display_text"], "331°M")
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfastnet-2.0.0/fastnet_decoder/frame_buffer.py

@@ -1,198 +0,0 @@
-from .utils import calculate_checksum  # Import checksum function from utils.py
-from .mappings import COMMAND_LOOKUP, IGNORED_COMMANDS
-from .decode_fastnet import decode_frame, decode_ascii_frame
-from .logger import logger
-from queue import Queue
-
-
-"""
-FrameBuffer Class
-=================
-
-The `FrameBuffer` class is responsible for managing a stream of incoming data, validating and extracting complete 
-frames, and decoding those frames using the FastNet protocol. It is designed to handle real-time data input, making 
-it suitable for scenarios like serial communication with hardware devices.
-
-Core Responsibilities:
------------------------
-1. **Buffer Management**:
-   - The class maintains an internal `bytearray` buffer to store incoming raw data.
-   - New data can be added to the buffer using the `add_to_buffer` method.
-   - The buffer automatically trims its size to a configurable maximum (`max_buffer_size`) to avoid unbounded memory usage.
-
-2. **Frame Extraction**:
-   - The `get_complete_frames` method scans the buffer for complete frames based on the FastNet protocol structure:
-     - A frame consists of a 5-byte header, a variable-length body, and a checksum.
-     - Both the header and body checksums are validated before processing the frame.
-   - Frames that are incomplete or fail checksum validation are skipped, and the buffer is adjusted to search for the next valid frame.
-
-3. **Frame Decoding**:
-   - After extracting a valid frame, the method determines the appropriate decoder (ASCII or standard) based on the command type.
-   - Decoded frames are added to an internal queue (`frame_queue`) for further processing.
-
-4. **Command Filtering**:
-   - Certain command types, such as "Keep Alive" or "Light Intensity," can be ignored based on a configurable list of ignored commands 
-     (managed in the `mappings.py` file).
-
-Key Features:
--------------
-- **Thread-Safe Queue**:
-  The `frame_queue` is implemented using Python's `queue.Queue`, enabling safe concurrent access from multiple threads 
-  (if needed).
-
-- **Error Handling**:
-  - The class is robust against malformed or corrupted data. Frames with invalid checksums are discarded without crashing the application.
-  - Warnings and errors are logged for debugging purposes.
-
-- **Modularity**:
-  - The decoding logic is separated from the frame extraction, adhering to the single-responsibility principle.
-  - The list of ignored commands is managed in `mappings.py`, promoting modularity and ease of configuration.
-
-Typical Workflow:
------------------
-1. Raw data (e.g., from a serial port) is fed into the buffer using the `add_to_buffer` method.
-2. The `get_complete_frames` method scans the buffer for valid frames, processes them, and adds decoded frames to the `frame_queue`.
-3. Another part of the application (e.g., a main loop) retrieves and processes frames from the queue for further action (e.g., broadcasting NMEA sentences).
-
-Configuration Parameters:
--------------------------
-- `max_buffer_size`: Limits the size of the internal buffer. Older data is discarded when the buffer exceeds this size.
-- `max_queue_size`: Specifies the maximum number of frames that can be stored in the `frame_queue`.
-
-Use Cases:
-----------
-The `FrameBuffer` class is ideal for:
-- Real-time data processing systems where incoming data must be validated and decoded before use.
-- Applications where reliability is critical, such as navigation systems or hardware communication protocols.
-
-Example:
---------
-# Initialize the FrameBuffer
-frame_buffer = FrameBuffer(max_buffer_size=8192, max_queue_size=1000)
-
-# Add raw data to the buffer
-frame_buffer.add_to_buffer(new_data)
-
-# Extract and decode complete frames
-frame_buffer.get_complete_frames()
-
-# Process frames from the queue
-while not frame_buffer.frame_queue.empty():
-    frame = frame_buffer.frame_queue.get()
-    # Process the decoded frame
-"""
-
-
-class FrameBuffer:
-    """
-    A class that manages an incoming data stream, extracts valid frames,
-    and decodes them using the FastNet protocol.
-    """
-    def __init__(self, max_buffer_size=8192, max_queue_size=1000):
-        self.buffer = bytearray()
-        self.max_buffer_size = max_buffer_size
-        self.frame_queue = Queue(maxsize=max_queue_size)  # Shared instance for frames
-
-    def add_to_buffer(self, new_data):
-        """
-        Adds new data to the buffer.
-
-        Args:
-            new_data (bytes): New data from the serial input.
-        """
-        if not isinstance(new_data, (bytes, bytearray)):
-            logger.error("Invalid data type passed to add_to_buffer. Expected bytes or bytearray.")
-            return
-
-        self.buffer.extend(new_data)
-        logger.debug(f"Added {len(new_data)} bytes to buffer. Buffer size: {len(self.buffer)} bytes.")
-
-        # Prevent the buffer from growing indefinitely
-        if len(self.buffer) > self.max_buffer_size:
-            logger.warning("Buffer size exceeded maximum limit. Trimming the oldest data.")
-            self.buffer = self.buffer[-self.max_buffer_size:]  # Keep the latest data only
-
-  
-    def get_complete_frames(self):
-        """
-        Extract and validate complete frames from the buffer, then add them to the internal queue.
-        """
-        while len(self.buffer) >= 6:  # Minimum frame size (5 header + 1 body checksum)
-            to_address = self.buffer[0]
-            from_address = self.buffer[1]
-            body_size = self.buffer[2]
-            command = self.buffer[3]
-            header_checksum = self.buffer[4]
-
-            # Identify command name from lookup
-            command_name = COMMAND_LOOKUP.get(command, f"Unknown (0x{command:02X})")
-
-            # Calculate full frame length
-            full_frame_length = 5 + body_size + 1  # Header (5 bytes) + body + body checksum
-            if len(self.buffer) < full_frame_length:
-                logger.debug(f"Incomplete frame: waiting for more bytes (needed {full_frame_length}, got {len(self.buffer)})")
-                break
-
-            # Extract frame data
-            frame = self.buffer[:full_frame_length]
-            body = self.buffer[5:full_frame_length - 1]
-            body_checksum = self.buffer[full_frame_length - 1]
-
-            # Verify header and body checksums
-            if calculate_checksum(self.buffer[:4]) != header_checksum:
-                logger.debug("Header checksum mismatch. Dropping first byte.")
-                self.buffer = self.buffer[1:]
-                continue
-
-            if calculate_checksum(body) != body_checksum:
-                logger.debug("Body checksum mismatch. Dropping first byte.")
-                self.buffer = self.buffer[1:]
-                continue
-
-            # Remove frame from buffer after validation
-            self.buffer = self.buffer[full_frame_length:]
-
-            # Skip ignored commands
-            if command_name in IGNORED_COMMANDS:
-                logger.debug(f"Skipping ignored command: {command_name}")
-                continue
-
-            # Decode the frame
-            self.decode_and_queue_frame(frame, command_name)
-
-
-    def decode_and_queue_frame(self, frame, command_name):
-        """Decode a frame and add it to the queue if valid."""
-        decoder = decode_ascii_frame if command_name == "LatLon" else decode_frame
-        decoded_frame = decoder(frame)
-        if decoded_frame:
-            try:
-                self.frame_queue.put_nowait(decoded_frame)
-                logger.debug(f"Added frame to queue: {decoded_frame}")
-            except queue.Full:
-                logger.warning("Frame queue is full. Dropping frame.")
-        else:
-            logger.debug(f"Failed to decode frame: {frame.hex()}")
-
-        
-                
-    def get_buffer_size(self):
-        """
-        Returns the current size of the buffer.
-        
-        Returns:
-            int: The number of bytes currently in the buffer.
-        """
-        return len(self.buffer)
-
-
-    def get_buffer_contents(self):
-        """
-        Returns the contents of the buffer as a hex string.
-        
-        Returns:
-            str: The hexadecimal representation of the buffer contents.
-        """
-        hex_contents = self.buffer.hex()
-        logger.debug(f"Buffer contents: {hex_contents}")
-        return hex_contents