pyfastnet 2.0.17__tar.gz → 3.0.0__tar.gz

pyfastnet-3.0.0/PKG-INFO

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: pyfastnet
+Version: 3.0.0
+Summary: A Python library for decoding FastNet protocol data streams.
+Author-email: Alex Salmon <alex@ivila.net>
+License: MIT License
+        
+        Copyright (c) 2025 ghotihook
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/ghotihook/pyfastnet
+Project-URL: Repository, https://github.com/ghotihook/pyfastnet
+Project-URL: Issues, https://github.com/ghotihook/pyfastnet/issues
+Keywords: fastnet,bandg,hydra,h2000,marine,sailing,decoder
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: license-file
+
+# pyfastnet
+
+A Python library for decoding the **FastNet** protocol used by B&G Hydra / H2000
+instruments. Feed it raw bytes from the Fastnet bus and it handles
+synchronisation, checksum validation, and decoding — returning instrument data as
+**Signal K paths in SI units**, ready for further processing.
+
+> **v3.0 changes the output format.** Decoded frames are now `{signalk_path:
+> SI_value}` (e.g. `navigation.speedThroughWater = 3.6`) instead of the v2
+> name-keyed `{value, display_text, layout}` dicts. See **Output format** below.
+> The full v2-style decode is still available via `FrameBuffer(project=False)`.
+
+Developed for personal use and published for general interest. Runs on Raspberry
+Pi, macOS, or Linux.
+
+## Quick start
+
+```bash
+pip install pyfastnet
+```
+
+```python
+#!/usr/bin/env python3
+import serial
+from fastnet_decoder import FrameBuffer
+
+fb = FrameBuffer()
+
+ser = serial.Serial(
+    port="/dev/ttyUSB0",
+    baudrate=28800,
+    bytesize=serial.EIGHTBITS,
+    stopbits=serial.STOPBITS_TWO,
+    parity=serial.PARITY_ODD,
+    timeout=0.1,
+)
+
+try:
+    while True:
+        data = ser.read(256)
+        if not data:
+            continue
+        fb.add_to_buffer(data)
+        fb.get_complete_frames()
+        while not fb.frame_queue.empty():
+            frame = fb.frame_queue.get()
+            for path, value in frame["values"].items():
+                print(path, value)   # e.g. navigation.speedThroughWater 3.6
+finally:
+    ser.close()
+```
+
+Serial settings for a B&G Fastnet bus are **28,800 baud, 8 data bits, odd parity,
+2 stop bits**. No instruments to hand? The companion apps below ship recorded
+captures you can replay.
+
+## The Fastnet toolkit
+
+Three projects stack together — pick the layer that matches where you want the
+data to end up:
+
+| Project | What it does | Use it when |
+|---|---|---|
+| **pyfastnet** *(this library)* | **Decoder.** Turns raw Fastnet bytes into Signal K paths in SI units. | You're writing your own Python and want the decoded data. |
+| [fastnet2ip](https://github.com/ghotihook/fastnet2ip) | **Serial → network.** Broadcasts decoded data over UDP as NMEA 0183 or NMEA 2000 (over IP). | Feeding Signal K, OpenCPN, or a plotter over WiFi / Ethernet. |
+| [fastnet2n2k](https://github.com/ghotihook/fastnet2n2k) | **Serial → physical NMEA 2000 bus.** Transmits PGNs onto a CAN backbone via SocketCAN. | Wiring into a real NMEA 2000 network / chartplotter. |
+
+```
+                          ┌─ fastnet2ip   → UDP (NMEA 0183 / NMEA 2000 over IP) → Signal K, OpenCPN, plotters
+B&G Fastnet bus ─(serial)─→ pyfastnet ─┤
+                          └─ fastnet2n2k → SocketCAN (NMEA 2000 PGNs)           → CAN backbone, chartplotter
+```
+
+pyfastnet is the **engine** at the bottom of the stack. If you only want the
+decoded data on your network or NMEA 2000 bus — including running it as an
+always-on systemd service — use one of the companion apps; they handle the serial
+port, a live data store, rate limiting, and output for you.
+
+## Output format
+
+Each decoded frame is a dict with `to_address`, `from_address`, `command`, and
+`values`. `values` maps **Signal K paths to SI values** — one canonical entry per
+physical quantity:
+
+```python
+{
+  "to_address":   "Entire System",
+  "from_address": "Normal CPU (Wind Board in H2000)",
+  "command":      "Broadcast",
+  "values": {
+    "environment.wind.speedApparent":     4.6,    # m/s
+    "environment.wind.angleApparent":     0.419,  # radians
+    "environment.wind.directionMagnetic": 1.239,  # radians
+    "navigation.speedThroughWater":       3.19,   # m/s
+  }
+}
+```
+
+Units follow the Signal K spec: angles in **radians**, speed in **m/s**, distance
+in **metres**, temperature in **Kelvin**, pressure in **Pascals**. A value is a
+`float` (SI), a `str` enum (e.g. `steering.autopilot.state` → `"standby"`), a
+position object, or `None` when unavailable.
+
+Redundant unit-variant channels the bus sends (feet/fathoms depth, knots wind, °F)
+are collapsed to one canonical path. B&G-proprietary channels with no standard
+Signal K path — including the pre-calibration `raw` sensor values — are emitted
+under a `bandg.*` namespace (e.g. `bandg.wind.rawAngleApparent`).
+
+### Units and the full path map
+
+Every emitted path has a canonical SI unit, available programmatically:
+
+```python
+from fastnet_decoder import unit_for
+unit_for("navigation.speedThroughWater")   # "m/s"
+unit_for("navigation.headingMagnetic")      # "rad"
+unit_for("environment.water.temperature")   # "K"
+unit_for("navigation.position")             # "deg"
+```
+
+The complete mapping — every B&G channel id/name → Signal K path + unit, the
+`bandg.*` vendor namespace, layout-driven Magnetic/True routing, and the
+dropped/collapsed channels — is documented in
+[`docs/v3_signalk_mapping.md`](docs/v3_signalk_mapping.md).
+
+### Position
+
+Position frames are emitted as `navigation.position`, a decimal-degree object
+(negative for S / W):
+
+```python
+"navigation.position": {"latitude": -33.8742, "longitude": 151.2320}
+```
+
+### True vs Magnetic
+
+The reference is carried by the **path**, not a separate field:
+`navigation.headingMagnetic` vs `navigation.headingTrue`,
+`environment.wind.directionMagnetic` vs `directionTrue`,
+`environment.current.setMagnetic` vs `setTrue`. The decoder selects the right path
+from the display's indicator symbol at decode time. (The raw stream carries no
+magnetic variation or deviation, so it cannot convert between the two.)
+
+### Complete (rich) decode
+
+`FrameBuffer(project=False)` queues the full internal decode instead of the Signal K
+projection. Each value is then a dict — `value`, `display_text`, `layout`,
+`channel_id` — keyed by human-readable channel name (the v2 format). Useful for
+debugging and reverse-engineering; `display_text` and `layout` are not exposed in
+the default Signal K output.
+
+You can also project a single decoded frame yourself:
+
+```python
+from fastnet_decoder import decode_frame, project
+rich = decode_frame(raw_frame_bytes)      # complete decode
+si = project(rich)                        # {signalk_path: SI_value}
+```
+
+### Debug API
+
+```python
+from fastnet_decoder import set_log_level
+import logging
+set_log_level(logging.DEBUG)
+```
+
+```python
+fb.get_buffer_size()      # bytes currently in buffer
+fb.get_buffer_contents()  # hex string of buffer contents
+```
+
+## Acknowledgments
+
+- [trlafleur](https://github.com/trlafleur) — background research
+- [Oppedijk](https://www.oppedijk.com/bandg/fastnet.html) — protocol documentation
+- [timmathews](https://github.com/timmathews/bg-fastnet-driver) — C++ reference implementation
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pyfastnet-3.0.0/README.md

@@ -0,0 +1,181 @@
+# pyfastnet
+
+A Python library for decoding the **FastNet** protocol used by B&G Hydra / H2000
+instruments. Feed it raw bytes from the Fastnet bus and it handles
+synchronisation, checksum validation, and decoding — returning instrument data as
+**Signal K paths in SI units**, ready for further processing.
+
+> **v3.0 changes the output format.** Decoded frames are now `{signalk_path:
+> SI_value}` (e.g. `navigation.speedThroughWater = 3.6`) instead of the v2
+> name-keyed `{value, display_text, layout}` dicts. See **Output format** below.
+> The full v2-style decode is still available via `FrameBuffer(project=False)`.
+
+Developed for personal use and published for general interest. Runs on Raspberry
+Pi, macOS, or Linux.
+
+## Quick start
+
+```bash
+pip install pyfastnet
+```
+
+```python
+#!/usr/bin/env python3
+import serial
+from fastnet_decoder import FrameBuffer
+
+fb = FrameBuffer()
+
+ser = serial.Serial(
+    port="/dev/ttyUSB0",
+    baudrate=28800,
+    bytesize=serial.EIGHTBITS,
+    stopbits=serial.STOPBITS_TWO,
+    parity=serial.PARITY_ODD,
+    timeout=0.1,
+)
+
+try:
+    while True:
+        data = ser.read(256)
+        if not data:
+            continue
+        fb.add_to_buffer(data)
+        fb.get_complete_frames()
+        while not fb.frame_queue.empty():
+            frame = fb.frame_queue.get()
+            for path, value in frame["values"].items():
+                print(path, value)   # e.g. navigation.speedThroughWater 3.6
+finally:
+    ser.close()
+```
+
+Serial settings for a B&G Fastnet bus are **28,800 baud, 8 data bits, odd parity,
+2 stop bits**. No instruments to hand? The companion apps below ship recorded
+captures you can replay.
+
+## The Fastnet toolkit
+
+Three projects stack together — pick the layer that matches where you want the
+data to end up:
+
+| Project | What it does | Use it when |
+|---|---|---|
+| **pyfastnet** *(this library)* | **Decoder.** Turns raw Fastnet bytes into Signal K paths in SI units. | You're writing your own Python and want the decoded data. |
+| [fastnet2ip](https://github.com/ghotihook/fastnet2ip) | **Serial → network.** Broadcasts decoded data over UDP as NMEA 0183 or NMEA 2000 (over IP). | Feeding Signal K, OpenCPN, or a plotter over WiFi / Ethernet. |
+| [fastnet2n2k](https://github.com/ghotihook/fastnet2n2k) | **Serial → physical NMEA 2000 bus.** Transmits PGNs onto a CAN backbone via SocketCAN. | Wiring into a real NMEA 2000 network / chartplotter. |
+
+```
+                          ┌─ fastnet2ip   → UDP (NMEA 0183 / NMEA 2000 over IP) → Signal K, OpenCPN, plotters
+B&G Fastnet bus ─(serial)─→ pyfastnet ─┤
+                          └─ fastnet2n2k → SocketCAN (NMEA 2000 PGNs)           → CAN backbone, chartplotter
+```
+
+pyfastnet is the **engine** at the bottom of the stack. If you only want the
+decoded data on your network or NMEA 2000 bus — including running it as an
+always-on systemd service — use one of the companion apps; they handle the serial
+port, a live data store, rate limiting, and output for you.
+
+## Output format
+
+Each decoded frame is a dict with `to_address`, `from_address`, `command`, and
+`values`. `values` maps **Signal K paths to SI values** — one canonical entry per
+physical quantity:
+
+```python
+{
+  "to_address":   "Entire System",
+  "from_address": "Normal CPU (Wind Board in H2000)",
+  "command":      "Broadcast",
+  "values": {
+    "environment.wind.speedApparent":     4.6,    # m/s
+    "environment.wind.angleApparent":     0.419,  # radians
+    "environment.wind.directionMagnetic": 1.239,  # radians
+    "navigation.speedThroughWater":       3.19,   # m/s
+  }
+}
+```
+
+Units follow the Signal K spec: angles in **radians**, speed in **m/s**, distance
+in **metres**, temperature in **Kelvin**, pressure in **Pascals**. A value is a
+`float` (SI), a `str` enum (e.g. `steering.autopilot.state` → `"standby"`), a
+position object, or `None` when unavailable.
+
+Redundant unit-variant channels the bus sends (feet/fathoms depth, knots wind, °F)
+are collapsed to one canonical path. B&G-proprietary channels with no standard
+Signal K path — including the pre-calibration `raw` sensor values — are emitted
+under a `bandg.*` namespace (e.g. `bandg.wind.rawAngleApparent`).
+
+### Units and the full path map
+
+Every emitted path has a canonical SI unit, available programmatically:
+
+```python
+from fastnet_decoder import unit_for
+unit_for("navigation.speedThroughWater")   # "m/s"
+unit_for("navigation.headingMagnetic")      # "rad"
+unit_for("environment.water.temperature")   # "K"
+unit_for("navigation.position")             # "deg"
+```
+
+The complete mapping — every B&G channel id/name → Signal K path + unit, the
+`bandg.*` vendor namespace, layout-driven Magnetic/True routing, and the
+dropped/collapsed channels — is documented in
+[`docs/v3_signalk_mapping.md`](docs/v3_signalk_mapping.md).
+
+### Position
+
+Position frames are emitted as `navigation.position`, a decimal-degree object
+(negative for S / W):
+
+```python
+"navigation.position": {"latitude": -33.8742, "longitude": 151.2320}
+```
+
+### True vs Magnetic
+
+The reference is carried by the **path**, not a separate field:
+`navigation.headingMagnetic` vs `navigation.headingTrue`,
+`environment.wind.directionMagnetic` vs `directionTrue`,
+`environment.current.setMagnetic` vs `setTrue`. The decoder selects the right path
+from the display's indicator symbol at decode time. (The raw stream carries no
+magnetic variation or deviation, so it cannot convert between the two.)
+
+### Complete (rich) decode
+
+`FrameBuffer(project=False)` queues the full internal decode instead of the Signal K
+projection. Each value is then a dict — `value`, `display_text`, `layout`,
+`channel_id` — keyed by human-readable channel name (the v2 format). Useful for
+debugging and reverse-engineering; `display_text` and `layout` are not exposed in
+the default Signal K output.
+
+You can also project a single decoded frame yourself:
+
+```python
+from fastnet_decoder import decode_frame, project
+rich = decode_frame(raw_frame_bytes)      # complete decode
+si = project(rich)                        # {signalk_path: SI_value}
+```
+
+### Debug API
+
+```python
+from fastnet_decoder import set_log_level
+import logging
+set_log_level(logging.DEBUG)
+```
+
+```python
+fb.get_buffer_size()      # bytes currently in buffer
+fb.get_buffer_contents()  # hex string of buffer contents
+```
+
+## Acknowledgments
+
+- [trlafleur](https://github.com/trlafleur) — background research
+- [Oppedijk](https://www.oppedijk.com/bandg/fastnet.html) — protocol documentation
+- [timmathews](https://github.com/timmathews/bg-fastnet-driver) — C++ reference implementation
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pyfastnet-3.0.0/fastnet_decoder/__init__.py

@@ -0,0 +1,9 @@
+__version__ = "3.0.0"
+
+from .frame_buffer import FrameBuffer
+from .decode_fastnet import decode_frame, decode_ascii_frame, decode_light_frame
+from .signalk_map import project, unit_for  # v3: projection + per-path SI units
+from .logger import logger, set_log_level  # Import set_log_level for user control
+
+__all__ = ["FrameBuffer", "decode_frame", "decode_ascii_frame", "decode_light_frame",
+           "project", "unit_for", "logger", "set_log_level"]

{pyfastnet-2.0.17 → pyfastnet-3.0.0}/fastnet_decoder/decode_fastnet.py

@@ -1,7 +1,7 @@
 import datetime
 import logging
 from .mappings import ADDRESS_LOOKUP, COMMAND_LOOKUP, CHANNEL_LOOKUP, FORMAT_SIZE_MAP
-from .mappings import SEGMENT_A, SEGMENT_B, AUTOPILOT_MODES
+from .mappings import SEGMENT_A, SEGMENT_B, AUTOPILOT_MODE_BY_LOW, BACKLIGHT_LEVELS
 from .logger import logger
 
 
@@ -13,7 +13,8 @@ _DECIMAL_PLACES_MAP = {1: 0, 10: 1, 100: 2, 1000: 3}
 #   "[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
+#   "H[data]"  →  heel to port; H carries the sign, value stored negative (e.g. H20.4)
+#   "[data]H"  →  heel to starboard; value positive (e.g. 33.8H)
 #   "°M"       →  magnetic bearing, suffix added after value
 
 def _sign_from_layout(layout: str) -> int:
@@ -192,6 +193,8 @@ def decode_ascii_frame(frame: bytes) -> dict:
         command      = frame[3]
         body         = frame[5:-1]
 
+        # TBC: no len(body) guard here (unlike decode_frame/decode_light_frame) —
+        # a short/empty body raises IndexError and falls to the except below.
         channel_id   = body[0]
         # body[1] is a format byte — not used for ASCII frames
         data_bytes   = body[2:]
@@ -234,6 +237,50 @@ def decode_ascii_frame(frame: bytes) -> dict:
         return {"error": str(e)}
 
 
+def decode_light_frame(frame: bytes) -> dict:
+    """
+    Decode a Light Intensity (0xC9) command into the system backlight level.
+
+    Broadcast from a Pilot FFD to the whole system; the body is a single byte
+    giving the backlight level (Off/Low/Medium/High). Surfaced as a synthetic
+    "Backlight" channel so it queues like other channel data.
+    """
+    try:
+        to_address   = frame[0]
+        from_address = frame[1]
+        command      = frame[3]
+        body         = frame[5:-1]
+
+        if len(body) < 1:
+            return {"error": "Invalid body size"}
+
+        level     = body[0]
+        cmd_name  = COMMAND_LOOKUP.get(command)
+        to_name   = ADDRESS_LOOKUP.get(to_address)
+        from_name = ADDRESS_LOOKUP.get(from_address)
+
+        display_text = BACKLIGHT_LEVELS.get(level, f"Unknown ({level})")
+        logger.debug(f"  CH  Backlight  level={level}  display='{display_text}'")
+
+        return {
+            "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": {
+                "Backlight": {
+                    "channel_id":   None,
+                    "value":        float(level),
+                    "display_text": display_text,
+                    "layout":       None,
+                }
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"Error decoding Light Intensity frame: {e}")
+        return {"error": str(e)}
+
+
 def decode_format_and_data(channel_id, format_byte, data_bytes):
     try:
         divisor        = _DIVISOR_MAP[(format_byte >> 6) & 0b11]
@@ -250,8 +297,14 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
                 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})")
+                value     = float(raw)
+                high, low = (raw >> 8) & 0xFF, raw & 0xFF
+                if high == 0x50:
+                    display_text = "Standby"
+                elif high in (0x51, 0x59):
+                    display_text = AUTOPILOT_MODE_BY_LOW.get(low, f"Unknown ({raw})")
+                else:
+                    display_text = f"Unknown ({raw})"
             else:
                 value        = raw / divisor
                 display_text = f"{value:.{decimal_places}f}"

{pyfastnet-2.0.17 → pyfastnet-3.0.0}/fastnet_decoder/frame_buffer.py

@@ -1,7 +1,8 @@
 import logging
 from .utils import calculate_checksum
 from .mappings import COMMAND_LOOKUP, IGNORED_COMMANDS
-from .decode_fastnet import decode_frame, decode_ascii_frame, probe_frame
+from .decode_fastnet import decode_frame, decode_ascii_frame, decode_light_frame, probe_frame
+from . import signalk_map
 from .logger import logger
 from queue import Queue, Full
 
@@ -17,10 +18,13 @@ class FrameBuffer:
         3. Pull decoded frames from frame_queue
     """
 
-    def __init__(self, max_buffer_size=8192, max_queue_size=1000):
+    def __init__(self, max_buffer_size=8192, max_queue_size=1000, project=True):
         self.buffer = bytearray()
         self.max_buffer_size = max_buffer_size
         self.frame_queue = Queue(maxsize=max_queue_size)
+        # v3: queue the {signalk_path: SI_value} projection by default. project=False
+        # queues the complete (rich) decode instead — for the golden guard / debugging.
+        self.project = project
 
     def add_to_buffer(self, new_data):
         if not isinstance(new_data, (bytes, bytearray)):
@@ -87,33 +91,53 @@ class FrameBuffer:
         """
         Decode a frame and add it to the queue if valid.
 
-        Only Broadcast frames carry the channel-record body layout, and LatLon
-        frames carry ASCII; those are decoded and queued. Every other command
-        (pilot messages, NMEA-sourced data, etc.) has an unknown body structure,
-        so it is never queued — it is only probed speculatively for debugging.
+        Broadcast frames carry the channel-record body layout, LatLon frames
+        carry ASCII, and Light Intensity frames carry a backlight level byte;
+        those are decoded and queued. Every other command (pilot messages,
+        NMEA-sourced data, etc.) has an unknown body structure, so it is never
+        queued — it is only probed speculatively for debugging.
         """
         if command_name == "Broadcast":
             decoded_frame = decode_frame(frame)
         elif command_name == "LatLon":
             decoded_frame = decode_ascii_frame(frame)
+        elif command_name == "Light Intensity":
+            decoded_frame = decode_light_frame(frame)
         else:
             probe_frame(frame)
             return
 
-        if decoded_frame and "values" in decoded_frame:
-            try:
-                self.frame_queue.put_nowait(decoded_frame)
+        if not (decoded_frame and "values" in decoded_frame):
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"  QUEUE fail    decode error  [{frame.hex()}]")
+            return
+
+        if self.project:
+            values = signalk_map.project(decoded_frame)
+            if not values:
+                # every channel dropped / unmapped (e.g. Backlight, protocol) — nothing to emit
                 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.")
+                    logger.debug(f"  QUEUE skip    no mapped paths  cmd={command_name}")
+                return
+            queued = {
+                "to_address":   decoded_frame.get("to_address"),
+                "from_address": decoded_frame.get("from_address"),
+                "command":      decoded_frame.get("command"),
+                "values":       values,
+            }
         else:
+            queued = decoded_frame
+
+        try:
+            self.frame_queue.put_nowait(queued)
             if logger.isEnabledFor(logging.DEBUG):
-                logger.debug(f"  QUEUE fail    decode error  [{frame.hex()}]")
+                keys = list(queued["values"].keys())
+                names_str = ", ".join(keys[:4])
+                if len(keys) > 4:
+                    names_str += f", +{len(keys) - 4} more"
+                logger.debug(f"  QUEUE {len(keys)} value(s)  [{names_str}]")
+        except Full:
+            logger.warning("Frame queue full, dropping frame.")
 
     def get_buffer_size(self):
         return len(self.buffer)

{pyfastnet-2.0.17 → pyfastnet-3.0.0}/fastnet_decoder/logger.py

@@ -15,6 +15,11 @@ logger.setLevel(DEFAULT_LOG_LEVEL)
 
 def set_log_level(level_name: str):
     """Sets the log level dynamically at runtime."""
-    level = getattr(logging, level_name.upper(), DEFAULT_LOG_LEVEL)
+    level = logging.getLevelName(level_name.upper())
+    if not isinstance(level, int):
+        logger.warning(
+            f"Unknown log level '{level_name}'; keeping current level."
+        )
+        return
     logger.setLevel(level)
     logger.info(f"Log level set to {level_name.upper()}.")

{pyfastnet-2.0.17 → pyfastnet-3.0.0}/fastnet_decoder/mappings.py

@@ -146,7 +146,10 @@ ADDRESS_LOOKUP = {
 }
 
 
-IGNORED_COMMANDS = {"Keep Alive", "Light Intensity"}
+IGNORED_COMMANDS = {"Keep Alive"}
+
+# Backlight level carried in the 1-byte body of a Light Intensity (0xC9) command.
+BACKLIGHT_LEVELS = {0x00: "Off", 0x01: "Low", 0x02: "Medium", 0x04: "High"}
 
 COMMAND_LOOKUP = {
     0x01: "Broadcast",
@@ -323,9 +326,12 @@ SEGMENT_B = {
     0xB8: "C",   # Celsius label — a,d,e,f segments
 }
 
-AUTOPILOT_MODES = {
-    20484: "Standby", 20737: "Compass", 20738: "Power",
-    20740: "Wind",    20755: "NMEA WP",
+# Autopilot Mode (channel 0xB5) is a 16-bit composite, not an opaque code:
+#   high byte = engagement state  (0x50 standby, 0x51 engaged, 0x59 compass steering)
+#   low  byte = selected mode     (see AUTOPILOT_MODE_BY_LOW)
+# When in standby (high 0x50) the mode is "Standby" regardless of the low byte.
+AUTOPILOT_MODE_BY_LOW = {
+    0x01: "Compass", 0x02: "Power", 0x04: "Wind", 0x13: "NMEA WP",
 }
 
 FORMAT_SIZE_MAP = {