pyfastnet 2.0.12__tar.gz → 2.0.14__tar.gz

pyfastnet-2.0.14/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: pyfastnet
+Version: 2.0.14
+Summary: A Python library for decoding FastNet protocol data streams.
+Home-page: https://github.com/ghotihook/pyfastnet
+Author: Alex Salmon
+Author-email: alex@ivila.net
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# pyfastnet
+
+Python library for decoding the FastNet protocol used by B&G Hydra/H2000 instruments. Developed for personal use and published for general interest.
+
+## Purpose
+
+Feed a raw byte stream from a FastNet bus into the library. It handles synchronisation, checksum validation, and decoding — returning structured instrument data ready for further processing.
+
+## Installation
+
+```
+pip install pyfastnet
+```
+
+## Example usage
+
+```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 channel, decoded in frame["values"].items():
+                print(channel, decoded)
+finally:
+    ser.close()
+```
+
+## Output format
+
+Each decoded frame is a dict with `to_address`, `from_address`, `command`, and `values`. Each entry in `values` is keyed by channel name:
+
+```python
+{
+  "to_address":   "Entire System",
+  "from_address": "Normal CPU (Wind Board in H2000)",
+  "command":      "Broadcast",
+  "values": {
+    "Apparent Wind Speed (Knots)": {
+      "channel_id":   "0x4D",
+      "value":        7.0,
+      "display_text": "7.0",
+      "layout":       None,
+    },
+    "Apparent Wind Angle": {
+      "channel_id":   "0x51",
+      "value":        -6.0,
+      "display_text": "-6.0",
+      "layout":       "-[data]",
+    },
+    "True Wind Direction": {
+      "channel_id":   "0x6D",
+      "value":        213.0,
+      "display_text": "213.0°M",
+      "layout":       "°M",
+    },
+  }
+}
+```
+
+### Position (LatLon) frames
+
+Position frames (command `LatLon`) appear under the `"LatLon"` key. The raw coordinate
+string (`DDMM.mmm` with hemisphere letters) is carried in `display_text`; `value` is
+`None`. The originating source's marker byte is preserved in `channel_id` (e.g. `0x47`,
+`0x4E`) but does not affect the key:
+
+```python
+"LatLon": {
+    "channel_id":   "0x4E",
+    "value":        None,
+    "display_text": "3352.450S15113.920E",
+    "layout":       None,
+}
+```
+
+### Layout field
+
+The `layout` field describes the indicator symbol shown on the physical display around the numeric value:
+
+| `layout` | Meaning | Sign |
+|---|---|---|
+| `None` | No indicator symbol | positive |
+| `"[data]="` | `=` after value (starboard) | positive |
+| `"=[data]"` | `=` before value (port) | negative |
+| `"[data]-"` | `-` after value (starboard) | positive |
+| `"-[data]"` | `-` before value (port) | negative |
+| `"H[data]"` | `H` prefix — heading | positive |
+| `"°M"` | Magnetic bearing suffix | positive |
+| `"u[data]"` | `u` prefix — upwind (VMG) | positive |
+| `"d[data]"` | `d` prefix — downwind (VMG) | positive |
+| `"L[data]"` | `L` before — leeway port | negative |
+| `"[data]L"` | `L` after — AP compass target | positive |
+| `"[data]°C"` | Celsius suffix | positive |
+| `"[data]°F"` | Fahrenheit suffix | positive |
+| `"[data]z"` / `"z[data]"` | Dog-leg symbol — AP off course | positive |
+| `"TBC"` | Symbol seen but not yet identified | positive |
+
+## 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
+```
+
+## Companion apps
+
+- [fastnet2ip](https://github.com/ghotihook/fastnet2ip) — reads FastNet from serial, broadcasts NMEA 0183 via UDP
+- [fastnet2ip_n2k](https://github.com/ghotihook/fastnet2ip_n2k) — reads FastNet from serial, broadcasts NMEA 2000 via UDP
+
+Both run on Raspberry Pi, macOS, or Linux.
+
+## 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

pyfastnet-2.0.14/README.md

@@ -0,0 +1,142 @@
+# pyfastnet
+
+Python library for decoding the FastNet protocol used by B&G Hydra/H2000 instruments. Developed for personal use and published for general interest.
+
+## Purpose
+
+Feed a raw byte stream from a FastNet bus into the library. It handles synchronisation, checksum validation, and decoding — returning structured instrument data ready for further processing.
+
+## Installation
+
+```
+pip install pyfastnet
+```
+
+## Example usage
+
+```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 channel, decoded in frame["values"].items():
+                print(channel, decoded)
+finally:
+    ser.close()
+```
+
+## Output format
+
+Each decoded frame is a dict with `to_address`, `from_address`, `command`, and `values`. Each entry in `values` is keyed by channel name:
+
+```python
+{
+  "to_address":   "Entire System",
+  "from_address": "Normal CPU (Wind Board in H2000)",
+  "command":      "Broadcast",
+  "values": {
+    "Apparent Wind Speed (Knots)": {
+      "channel_id":   "0x4D",
+      "value":        7.0,
+      "display_text": "7.0",
+      "layout":       None,
+    },
+    "Apparent Wind Angle": {
+      "channel_id":   "0x51",
+      "value":        -6.0,
+      "display_text": "-6.0",
+      "layout":       "-[data]",
+    },
+    "True Wind Direction": {
+      "channel_id":   "0x6D",
+      "value":        213.0,
+      "display_text": "213.0°M",
+      "layout":       "°M",
+    },
+  }
+}
+```
+
+### Position (LatLon) frames
+
+Position frames (command `LatLon`) appear under the `"LatLon"` key. The raw coordinate
+string (`DDMM.mmm` with hemisphere letters) is carried in `display_text`; `value` is
+`None`. The originating source's marker byte is preserved in `channel_id` (e.g. `0x47`,
+`0x4E`) but does not affect the key:
+
+```python
+"LatLon": {
+    "channel_id":   "0x4E",
+    "value":        None,
+    "display_text": "3352.450S15113.920E",
+    "layout":       None,
+}
+```
+
+### Layout field
+
+The `layout` field describes the indicator symbol shown on the physical display around the numeric value:
+
+| `layout` | Meaning | Sign |
+|---|---|---|
+| `None` | No indicator symbol | positive |
+| `"[data]="` | `=` after value (starboard) | positive |
+| `"=[data]"` | `=` before value (port) | negative |
+| `"[data]-"` | `-` after value (starboard) | positive |
+| `"-[data]"` | `-` before value (port) | negative |
+| `"H[data]"` | `H` prefix — heading | positive |
+| `"°M"` | Magnetic bearing suffix | positive |
+| `"u[data]"` | `u` prefix — upwind (VMG) | positive |
+| `"d[data]"` | `d` prefix — downwind (VMG) | positive |
+| `"L[data]"` | `L` before — leeway port | negative |
+| `"[data]L"` | `L` after — AP compass target | positive |
+| `"[data]°C"` | Celsius suffix | positive |
+| `"[data]°F"` | Fahrenheit suffix | positive |
+| `"[data]z"` / `"z[data]"` | Dog-leg symbol — AP off course | positive |
+| `"TBC"` | Symbol seen but not yet identified | positive |
+
+## 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
+```
+
+## Companion apps
+
+- [fastnet2ip](https://github.com/ghotihook/fastnet2ip) — reads FastNet from serial, broadcasts NMEA 0183 via UDP
+- [fastnet2ip_n2k](https://github.com/ghotihook/fastnet2ip_n2k) — reads FastNet from serial, broadcasts NMEA 2000 via UDP
+
+Both run on Raspberry Pi, macOS, or Linux.
+
+## 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

{pyfastnet-2.0.12 → pyfastnet-2.0.14}/fastnet_decoder/decode_fastnet.py

@@ -119,9 +119,14 @@ def decode_ascii_frame(frame: bytes) -> dict:
         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)
-        if channel_name is None:
-            channel_name = f"Unknown (0x{channel_id:02X})"
+        # This decoder is only ever called for LatLon command frames, so the
+        # entry is named from the command — not from body[0]. body[0] is a
+        # source/marker byte that varies by GPS unit (0x47, 0x4E, ...) and is
+        # NOT a generic channel id; looking it up in CHANNEL_LOOKUP produced
+        # nonsense names like "Apparent Wind Speed (Raw)". The raw byte is kept
+        # in channel_id below for diagnostics.
+        cmd_name     = COMMAND_LOOKUP.get(command)
+        channel_name = cmd_name if cmd_name is not None else f"Unknown (0x{command:02X})"
 
         try:
             ascii_text = data_bytes.decode("ascii").strip()
@@ -133,7 +138,6 @@ def decode_ascii_frame(frame: bytes) -> dict:
 
         to_name   = ADDRESS_LOOKUP.get(to_address)
         from_name = ADDRESS_LOOKUP.get(from_address)
-        cmd_name  = COMMAND_LOOKUP.get(command)
 
         return {
             "to_address":   to_name   if to_name   is not None else f"Unknown (0x{to_address:02X})",
@@ -211,7 +215,7 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
             if len(data_bytes) != 4:
                 return None
             value        = None
-            display_text = "".join(SEGMENT_B.get(b, "?") for b in data_bytes)
+            display_text = "".join(SEGMENT_B.get(b, "TBC") for b in data_bytes)
 
         elif format_bits == 0x07:
             if len(data_bytes) != 4:

{pyfastnet-2.0.12 → pyfastnet-2.0.14}/fastnet_decoder/mappings.py

@@ -192,7 +192,6 @@ CHANNEL_LOOKUP = {
     0x42: "Boatspeed (Raw)",
     0x44: "Yaw rate",
     0x46: "Autopilot Speed Fixed (Knots)",
-    0x47: "LatLon",
     0x49: "Heading",
     0x4A: "Heading (Raw)",
     0x4D: "Apparent Wind Speed (Knots)",

pyfastnet-2.0.14/fastnet_decoder/utils.py

@@ -0,0 +1,11 @@
+
+
+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 (-sum(data)) & 0xFF

pyfastnet-2.0.14/pyfastnet.egg-info/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: pyfastnet
+Version: 2.0.14
+Summary: A Python library for decoding FastNet protocol data streams.
+Home-page: https://github.com/ghotihook/pyfastnet
+Author: Alex Salmon
+Author-email: alex@ivila.net
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# pyfastnet
+
+Python library for decoding the FastNet protocol used by B&G Hydra/H2000 instruments. Developed for personal use and published for general interest.
+
+## Purpose
+
+Feed a raw byte stream from a FastNet bus into the library. It handles synchronisation, checksum validation, and decoding — returning structured instrument data ready for further processing.
+
+## Installation
+
+```
+pip install pyfastnet
+```
+
+## Example usage
+
+```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 channel, decoded in frame["values"].items():
+                print(channel, decoded)
+finally:
+    ser.close()
+```
+
+## Output format
+
+Each decoded frame is a dict with `to_address`, `from_address`, `command`, and `values`. Each entry in `values` is keyed by channel name:
+
+```python
+{
+  "to_address":   "Entire System",
+  "from_address": "Normal CPU (Wind Board in H2000)",
+  "command":      "Broadcast",
+  "values": {
+    "Apparent Wind Speed (Knots)": {
+      "channel_id":   "0x4D",
+      "value":        7.0,
+      "display_text": "7.0",
+      "layout":       None,
+    },
+    "Apparent Wind Angle": {
+      "channel_id":   "0x51",
+      "value":        -6.0,
+      "display_text": "-6.0",
+      "layout":       "-[data]",
+    },
+    "True Wind Direction": {
+      "channel_id":   "0x6D",
+      "value":        213.0,
+      "display_text": "213.0°M",
+      "layout":       "°M",
+    },
+  }
+}
+```
+
+### Position (LatLon) frames
+
+Position frames (command `LatLon`) appear under the `"LatLon"` key. The raw coordinate
+string (`DDMM.mmm` with hemisphere letters) is carried in `display_text`; `value` is
+`None`. The originating source's marker byte is preserved in `channel_id` (e.g. `0x47`,
+`0x4E`) but does not affect the key:
+
+```python
+"LatLon": {
+    "channel_id":   "0x4E",
+    "value":        None,
+    "display_text": "3352.450S15113.920E",
+    "layout":       None,
+}
+```
+
+### Layout field
+
+The `layout` field describes the indicator symbol shown on the physical display around the numeric value:
+
+| `layout` | Meaning | Sign |
+|---|---|---|
+| `None` | No indicator symbol | positive |
+| `"[data]="` | `=` after value (starboard) | positive |
+| `"=[data]"` | `=` before value (port) | negative |
+| `"[data]-"` | `-` after value (starboard) | positive |
+| `"-[data]"` | `-` before value (port) | negative |
+| `"H[data]"` | `H` prefix — heading | positive |
+| `"°M"` | Magnetic bearing suffix | positive |
+| `"u[data]"` | `u` prefix — upwind (VMG) | positive |
+| `"d[data]"` | `d` prefix — downwind (VMG) | positive |
+| `"L[data]"` | `L` before — leeway port | negative |
+| `"[data]L"` | `L` after — AP compass target | positive |
+| `"[data]°C"` | Celsius suffix | positive |
+| `"[data]°F"` | Fahrenheit suffix | positive |
+| `"[data]z"` / `"z[data]"` | Dog-leg symbol — AP off course | positive |
+| `"TBC"` | Symbol seen but not yet identified | positive |
+
+## 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
+```
+
+## Companion apps
+
+- [fastnet2ip](https://github.com/ghotihook/fastnet2ip) — reads FastNet from serial, broadcasts NMEA 0183 via UDP
+- [fastnet2ip_n2k](https://github.com/ghotihook/fastnet2ip_n2k) — reads FastNet from serial, broadcasts NMEA 2000 via UDP
+
+Both run on Raspberry Pi, macOS, or Linux.
+
+## 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

{pyfastnet-2.0.12 → pyfastnet-2.0.14}/pyfastnet.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ tests/test_depth_frame.py
 tests/test_format07_msb_regression.py
 tests/test_format08_layout.py
 tests/test_heel_frame.py
+tests/test_latlon_frame.py
 tests/test_rudder_frame.py
 tests/test_tide_frame.py
 tests/test_true_frame.py

{pyfastnet-2.0.12 → pyfastnet-2.0.14}/setup.py

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

@@ -0,0 +1,56 @@
+import unittest
+from fastnet_decoder.decode_fastnet import decode_ascii_frame
+
+
+class TestLatLonFrame(unittest.TestCase):
+    """
+    Tests for LatLon (position) command frames (command 0x03).
+
+    These frames are dispatched to decode_ascii_frame, which carries the raw
+    coordinate string in display_text. The entry is named from the command
+    ("LatLon") — NOT from body[0]. body[0] is a per-source marker byte that
+    varies by GPS unit (0x4E, 0x47, ...) and is not a generic channel id, so
+    it must not be looked up in CHANNEL_LOOKUP (doing so previously mislabelled
+    positions as "Apparent Wind Speed (Raw)").
+    """
+
+    # Real frame, from_address 0x60 (External Compass NMEA FFD 60).
+    # body[0] = 0x4E. Position: 33°52.450'S, 151°13.920'E (Sydney).
+    FRAME_4E = "ff601503894e50333335322e3435305331353131332e3932304572"
+
+    # Real frame, from_address 0x62 (External Compass NMEA FFD 62).
+    # body[0] = 0x47. Position: 16°46.61'S, 179°20.23'E.
+    FRAME_47 = "ff621503874750313634362e3631205331373932302e3233204595"
+
+    def test_4e_source_keyed_latlon(self):
+        values = decode_ascii_frame(bytes.fromhex(self.FRAME_4E))["values"]
+        self.assertIn("LatLon", values)
+        self.assertNotIn("Apparent Wind Speed (Raw)", values)
+        entry = values["LatLon"]
+        self.assertEqual(entry["channel_id"], "0x4E")
+        self.assertEqual(entry["display_text"], "3352.450S15113.920E")
+        self.assertIsNone(entry["value"])
+
+    def test_47_source_keyed_latlon(self):
+        values = decode_ascii_frame(bytes.fromhex(self.FRAME_47))["values"]
+        self.assertIn("LatLon", values)
+        entry = values["LatLon"]
+        self.assertEqual(entry["channel_id"], "0x47")
+        self.assertEqual(entry["display_text"], "1646.61 S17920.23 E")
+        self.assertIsNone(entry["value"])
+
+    def test_both_sources_share_one_key(self):
+        # The fix normalises differing source bytes to a single consistent key.
+        keys_4e = set(decode_ascii_frame(bytes.fromhex(self.FRAME_4E))["values"])
+        keys_47 = set(decode_ascii_frame(bytes.fromhex(self.FRAME_47))["values"])
+        self.assertEqual(keys_4e, keys_47, {"LatLon"})
+
+    def test_command_metadata(self):
+        decoded = decode_ascii_frame(bytes.fromhex(self.FRAME_4E))
+        self.assertNotIn("error", decoded)
+        self.assertEqual(decoded["command"], "LatLon")
+        self.assertEqual(decoded["from_address"], "External Compass (NMEA FFD 60)")
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfastnet-2.0.12/PKG-INFO

@@ -1,134 +0,0 @@
-Metadata-Version: 2.2
-Name: pyfastnet
-Version: 2.0.12
-Summary: A Python library for decoding FastNet protocol data streams.
-Home-page: https://github.com/ghotihook/pyfastnet
-Author: Alex Salmon
-Author-email: alex@ivila.net
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-python
-Dynamic: summary
-
-# pyfastnet
-Fastnet is the propriatory protocol used by B&G on some older instruments, tested on Hydra/H2000. It might work on other systems. I developed this for personal use and publishing for general interest only. 
-
-# Purpose
-This library can be fed a stream of fastnet data, it will decode and return structured instrument data for further processing. Syncronisation, checksum and decoding is handled by the library.
-
-# Companion App
-- A full implementation can be found here, it takes input from a serial port or dummy file and broadcasts NMEA messages via UDP [fastnet2ip](https://github.com/ghotihook/fastnet2ip) Easy to install on a raspberry pi, core mp135, mac, linux.
-
-# Example input/output
-Byte string from Fastnet including "ff051801e34e0a02c402754d6100464f610024520af683f6835113a0064b"
-
-to_address: Entire System
-from_address: Normal CPU (Wind Board in H2000)
-command: Broadcast
-values: 
-```
-{
-  'Apparent Wind Speed (Raw)': {'channel_id': '0x4E', 'format_byte': '0x0A', 'data_bytes': '02c40275', 'divisor': 1, 'digits': 1, 'format_bits': 10, 'raw': {'first': 708.0, 'second': 629.0}, 'interpreted': 708.0}, 
-
-  'Apparent Wind Speed (Knots)': {'channel_id': '0x4D', 'format_byte': '0x61', 'data_bytes': '0046', 'divisor': 10, 'digits': 3, 'format_bits': 1, 'raw': 70, 'interpreted': 7.0}, 
-  
-  'Apparent Wind Speed (m/s)': {'channel_id': '0x4F', 'format_byte': '0x61', 'data_bytes': '0024', 'divisor': 10, 'digits': 3, 'format_bits': 1, 'raw': 36, 'interpreted': 3.6}, 
-  
-  'Apparent Wind Angle (Raw)': {'channel_id': '0x52', 'format_byte': '0x0A', 'data_bytes': 'f683f683', 'divisor': 1, 'digits': 1, 'format_bits': 10, 'raw': {'first': -2429.0, 'second': -2429.0}, 'interpreted': -2429.0}, 
-  
-  'Apparent Wind Angle': {'channel_id': '0x51', 'format_byte': '0x13', 'data_bytes': 'a006', 'divisor': 1, 'digits': 2, 'format_bits': 3, 'raw': {'segment_code': '0xa0', 'segment_code_bin': '0b10100000', 'unsigned_value': 6, 'layout': '-[data]'}, 'interpreted': -6.0}}
-```
-
-# Example implementation
-```
-#!/usr/bin/env python3
-import serial
-import time
-from pprint import pprint
-from fastnet_decoder import FrameBuffer
-
-def main():
-    fb = FrameBuffer()
-    # open /dev/ttyUSB0 at 28,800 baud, 8E2, 0.1 s timeout
-    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:
-                time.sleep(0.01)
-                continue
-
-            # 1) feed raw bytes into the frame buffer
-            fb.add_to_buffer(data)
-
-            # 2) extract & decode any complete frames
-            fb.get_complete_frames()
-
-            # 3) peek at the entire queue as a list
-            queue_contents = list(fb.frame_queue.queue)
-            if queue_contents:
-                print("Current decoded frames in queue:")
-                pprint(queue_contents)
-            else:
-                print("Queue is empty.")
-
-            # 4) (optionally) drain the queue for processing
-            while not fb.frame_queue.empty():
-                frame = fb.frame_queue.get()
-                # replace this with whatever you need
-                print("Processing frame:", frame)
-
-    except KeyboardInterrupt:
-        print("Stopping…")
-    finally:
-        ser.close()
-
-if __name__ == "__main__":
-    main()
-```
-
-
-# Important library calls - debug
-- ```set_log_level(DEBUG)```
-- ```fastnetframebuffer.get_buffer_size()```
-- ```fastnetframebuffer.get_buffer_contents()```
-
-
-
-# Installation
-```pip3 install pyfastnet```
-
-On a raspberry pi and some other systems this is done from with a virtual env
-
-```python -m venv --system-site-packages ~/python_environment
-source ~/python_environment/bin/activate
-pip3 install pyfastnet
-deactivate
-~/python_environment/bin/python3 pyfastnet.py -h 
-```
-
-
-## Acknowledgments / References
-
-- [trlafleur - Collector of significant background](https://github.com/trlafleur) 
-- [Oppedijk - Background and patches](https://www.oppedijk.com/bandg/fastnet.html)
-- [timmathews - Significant implementation in Cpp](https://github.com/timmathews/bg-fastnet-driver)
-- Significant help from chatGPT!

pyfastnet-2.0.12/README.md

@@ -1,112 +0,0 @@
-# pyfastnet
-Fastnet is the propriatory protocol used by B&G on some older instruments, tested on Hydra/H2000. It might work on other systems. I developed this for personal use and publishing for general interest only. 
-
-# Purpose
-This library can be fed a stream of fastnet data, it will decode and return structured instrument data for further processing. Syncronisation, checksum and decoding is handled by the library.
-
-# Companion App
-- A full implementation can be found here, it takes input from a serial port or dummy file and broadcasts NMEA messages via UDP [fastnet2ip](https://github.com/ghotihook/fastnet2ip) Easy to install on a raspberry pi, core mp135, mac, linux.
-
-# Example input/output
-Byte string from Fastnet including "ff051801e34e0a02c402754d6100464f610024520af683f6835113a0064b"
-
-to_address: Entire System
-from_address: Normal CPU (Wind Board in H2000)
-command: Broadcast
-values: 
-```
-{
-  'Apparent Wind Speed (Raw)': {'channel_id': '0x4E', 'format_byte': '0x0A', 'data_bytes': '02c40275', 'divisor': 1, 'digits': 1, 'format_bits': 10, 'raw': {'first': 708.0, 'second': 629.0}, 'interpreted': 708.0}, 
-
-  'Apparent Wind Speed (Knots)': {'channel_id': '0x4D', 'format_byte': '0x61', 'data_bytes': '0046', 'divisor': 10, 'digits': 3, 'format_bits': 1, 'raw': 70, 'interpreted': 7.0}, 
-  
-  'Apparent Wind Speed (m/s)': {'channel_id': '0x4F', 'format_byte': '0x61', 'data_bytes': '0024', 'divisor': 10, 'digits': 3, 'format_bits': 1, 'raw': 36, 'interpreted': 3.6}, 
-  
-  'Apparent Wind Angle (Raw)': {'channel_id': '0x52', 'format_byte': '0x0A', 'data_bytes': 'f683f683', 'divisor': 1, 'digits': 1, 'format_bits': 10, 'raw': {'first': -2429.0, 'second': -2429.0}, 'interpreted': -2429.0}, 
-  
-  'Apparent Wind Angle': {'channel_id': '0x51', 'format_byte': '0x13', 'data_bytes': 'a006', 'divisor': 1, 'digits': 2, 'format_bits': 3, 'raw': {'segment_code': '0xa0', 'segment_code_bin': '0b10100000', 'unsigned_value': 6, 'layout': '-[data]'}, 'interpreted': -6.0}}
-```
-
-# Example implementation
-```
-#!/usr/bin/env python3
-import serial
-import time
-from pprint import pprint
-from fastnet_decoder import FrameBuffer
-
-def main():
-    fb = FrameBuffer()
-    # open /dev/ttyUSB0 at 28,800 baud, 8E2, 0.1 s timeout
-    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:
-                time.sleep(0.01)
-                continue
-
-            # 1) feed raw bytes into the frame buffer
-            fb.add_to_buffer(data)
-
-            # 2) extract & decode any complete frames
-            fb.get_complete_frames()
-
-            # 3) peek at the entire queue as a list
-            queue_contents = list(fb.frame_queue.queue)
-            if queue_contents:
-                print("Current decoded frames in queue:")
-                pprint(queue_contents)
-            else:
-                print("Queue is empty.")
-
-            # 4) (optionally) drain the queue for processing
-            while not fb.frame_queue.empty():
-                frame = fb.frame_queue.get()
-                # replace this with whatever you need
-                print("Processing frame:", frame)
-
-    except KeyboardInterrupt:
-        print("Stopping…")
-    finally:
-        ser.close()
-
-if __name__ == "__main__":
-    main()
-```
-
-
-# Important library calls - debug
-- ```set_log_level(DEBUG)```
-- ```fastnetframebuffer.get_buffer_size()```
-- ```fastnetframebuffer.get_buffer_contents()```
-
-
-
-# Installation
-```pip3 install pyfastnet```
-
-On a raspberry pi and some other systems this is done from with a virtual env
-
-```python -m venv --system-site-packages ~/python_environment
-source ~/python_environment/bin/activate
-pip3 install pyfastnet
-deactivate
-~/python_environment/bin/python3 pyfastnet.py -h 
-```
-
-
-## Acknowledgments / References
-
-- [trlafleur - Collector of significant background](https://github.com/trlafleur) 
-- [Oppedijk - Background and patches](https://www.oppedijk.com/bandg/fastnet.html)
-- [timmathews - Significant implementation in Cpp](https://github.com/timmathews/bg-fastnet-driver)
-- Significant help from chatGPT!

pyfastnet-2.0.12/fastnet_decoder/utils.py

@@ -1,48 +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 (-sum(data)) & 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-2.0.12/pyfastnet.egg-info/PKG-INFO

@@ -1,134 +0,0 @@
-Metadata-Version: 2.2
-Name: pyfastnet
-Version: 2.0.12
-Summary: A Python library for decoding FastNet protocol data streams.
-Home-page: https://github.com/ghotihook/pyfastnet
-Author: Alex Salmon
-Author-email: alex@ivila.net
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-python
-Dynamic: summary
-
-# pyfastnet
-Fastnet is the propriatory protocol used by B&G on some older instruments, tested on Hydra/H2000. It might work on other systems. I developed this for personal use and publishing for general interest only. 
-
-# Purpose
-This library can be fed a stream of fastnet data, it will decode and return structured instrument data for further processing. Syncronisation, checksum and decoding is handled by the library.
-
-# Companion App
-- A full implementation can be found here, it takes input from a serial port or dummy file and broadcasts NMEA messages via UDP [fastnet2ip](https://github.com/ghotihook/fastnet2ip) Easy to install on a raspberry pi, core mp135, mac, linux.
-
-# Example input/output
-Byte string from Fastnet including "ff051801e34e0a02c402754d6100464f610024520af683f6835113a0064b"
-
-to_address: Entire System
-from_address: Normal CPU (Wind Board in H2000)
-command: Broadcast
-values: 
-```
-{
-  'Apparent Wind Speed (Raw)': {'channel_id': '0x4E', 'format_byte': '0x0A', 'data_bytes': '02c40275', 'divisor': 1, 'digits': 1, 'format_bits': 10, 'raw': {'first': 708.0, 'second': 629.0}, 'interpreted': 708.0}, 
-
-  'Apparent Wind Speed (Knots)': {'channel_id': '0x4D', 'format_byte': '0x61', 'data_bytes': '0046', 'divisor': 10, 'digits': 3, 'format_bits': 1, 'raw': 70, 'interpreted': 7.0}, 
-  
-  'Apparent Wind Speed (m/s)': {'channel_id': '0x4F', 'format_byte': '0x61', 'data_bytes': '0024', 'divisor': 10, 'digits': 3, 'format_bits': 1, 'raw': 36, 'interpreted': 3.6}, 
-  
-  'Apparent Wind Angle (Raw)': {'channel_id': '0x52', 'format_byte': '0x0A', 'data_bytes': 'f683f683', 'divisor': 1, 'digits': 1, 'format_bits': 10, 'raw': {'first': -2429.0, 'second': -2429.0}, 'interpreted': -2429.0}, 
-  
-  'Apparent Wind Angle': {'channel_id': '0x51', 'format_byte': '0x13', 'data_bytes': 'a006', 'divisor': 1, 'digits': 2, 'format_bits': 3, 'raw': {'segment_code': '0xa0', 'segment_code_bin': '0b10100000', 'unsigned_value': 6, 'layout': '-[data]'}, 'interpreted': -6.0}}
-```
-
-# Example implementation
-```
-#!/usr/bin/env python3
-import serial
-import time
-from pprint import pprint
-from fastnet_decoder import FrameBuffer
-
-def main():
-    fb = FrameBuffer()
-    # open /dev/ttyUSB0 at 28,800 baud, 8E2, 0.1 s timeout
-    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:
-                time.sleep(0.01)
-                continue
-
-            # 1) feed raw bytes into the frame buffer
-            fb.add_to_buffer(data)
-
-            # 2) extract & decode any complete frames
-            fb.get_complete_frames()
-
-            # 3) peek at the entire queue as a list
-            queue_contents = list(fb.frame_queue.queue)
-            if queue_contents:
-                print("Current decoded frames in queue:")
-                pprint(queue_contents)
-            else:
-                print("Queue is empty.")
-
-            # 4) (optionally) drain the queue for processing
-            while not fb.frame_queue.empty():
-                frame = fb.frame_queue.get()
-                # replace this with whatever you need
-                print("Processing frame:", frame)
-
-    except KeyboardInterrupt:
-        print("Stopping…")
-    finally:
-        ser.close()
-
-if __name__ == "__main__":
-    main()
-```
-
-
-# Important library calls - debug
-- ```set_log_level(DEBUG)```
-- ```fastnetframebuffer.get_buffer_size()```
-- ```fastnetframebuffer.get_buffer_contents()```
-
-
-
-# Installation
-```pip3 install pyfastnet```
-
-On a raspberry pi and some other systems this is done from with a virtual env
-
-```python -m venv --system-site-packages ~/python_environment
-source ~/python_environment/bin/activate
-pip3 install pyfastnet
-deactivate
-~/python_environment/bin/python3 pyfastnet.py -h 
-```
-
-
-## Acknowledgments / References
-
-- [trlafleur - Collector of significant background](https://github.com/trlafleur) 
-- [Oppedijk - Background and patches](https://www.oppedijk.com/bandg/fastnet.html)
-- [timmathews - Significant implementation in Cpp](https://github.com/timmathews/bg-fastnet-driver)
-- Significant help from chatGPT!