fastnet2n2k 0.1.3__tar.gz

fastnet2n2k-0.1.3/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+__pycache__/
+*.pyc
+dist/
+build/
+*.egg-info/

fastnet2n2k-0.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 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.

fastnet2n2k-0.1.3/PKG-INFO

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: fastnet2n2k
+Version: 0.1.3
+Summary: Bridge a B&G Fastnet instrument stream onto an NMEA2000 CAN bus
+Project-URL: Homepage, https://github.com/ghotihook/fastnet2n2k
+Project-URL: Repository, https://github.com/ghotihook/fastnet2n2k
+Project-URL: Issues, https://github.com/ghotihook/fastnet2n2k/issues
+Author: ghotihook
+License-Expression: MIT
+License-File: LICENSE
+Keywords: b&g,canbus,fastnet,marine,n2k,nmea2000,socketcan
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications
+Requires-Python: >=3.10
+Requires-Dist: nmea2000>=2026.5
+Requires-Dist: pyfastnet>=2.0.17
+Requires-Dist: pyserial>=3.5
+Requires-Dist: python-can>=4.5
+Description-Content-Type: text/markdown
+
+# fastnet2n2k — B&G Fastnet → NMEA2000 bridge
+
+Reads a **B&G Fastnet** instrument stream (live serial or a captured hex file),
+decodes it with [`pyfastnet`](https://github.com/ghotihook/pyfastnet), maps the
+channels to **NMEA2000** PGNs and transmits them onto a CAN bus. Built for the
+[M5Stack CoreMP135](https://docs.m5stack.com/en/core/M5CoreMP135) but runs on any
+Linux box with a SocketCAN interface.
+
+The CoreMP135 runs Linux on an STM32MP135 and exposes its two FDCAN interfaces
+(SIT1051T transceivers) as the SocketCAN netdevs `can0` (FDCAN1, PE3/PE10) and
+`can1` (FDCAN2, PG0/PE0). NMEA2000 runs at **250 kbit/s** with 29-bit extended IDs.
+Message encoding, CAN-ID construction, fast-packet framing and ISO address claiming
+are handled by the [`nmea2000`](https://github.com/tomer-w/nmea2000) library (canboat-
+based) on top of `python-can`'s socketcan backend.
+
+## What it sends
+
+Each Fastnet channel is mapped to the matching PGN and emitted **only when the
+channel updates** (with a 0.05 s minimum interval and a 5 s maximum re-broadcast),
+so when the instruments go quiet the output stops and consumers time the data out.
+
+| Data | PGN | Priority | Notes |
+|---|---|---|---|
+| Heading | 127250 | 2 | T/M reference taken from the Fastnet display layout (`°M`/`°T`) |
+| Apparent / True wind, TWD | 130306 | 2 | knots→m/s, deg→rad; reference per layout |
+| Boat speed | 128259 | 2 | knots→m/s |
+| Depth | 128267 | 3 | metres |
+| COG/SOG | 129026 | 2 | prefers True COG, falls back to Magnetic |
+| Attitude (heel/trim) | 127257 | 3 | signed value passed through unchanged |
+| Rudder, Leeway, Rate of turn | 127245 / 128000 / 127251 | 2 / 4 / 2 | |
+| Distance log, XTE | 128275 / 129283 | 6 / 3 | NM→m |
+| Position | 129025 | 2 | |
+| Sea / air temperature | 130312 | 5 | °C/°F→Kelvin |
+| Barometric pressure | 130314 | 5 | mbar→Pa |
+| Tidal set & drift | 129291 | 3 | set deg→rad, drift kn→m/s; reference per layout |
+
+The **Priority** column lists each PGN's NMEA2000 standard CAN priority (0 = highest,
+7 = lowest). These are the values used **by default** — when `--n2k-priority` is *not*
+given, every frame keeps the per-PGN priority shown above. Passing `--n2k-priority N`
+overrides the whole column, forcing all frames to a single priority `N`.
+
+**Units** are converted to NMEA2000 SI. **Sign** comes straight from pyfastnet's
+decoded value. **True/Magnetic** is read from the pyfastnet `layout` field (the only
+place it exists); a bearing whose layout can't be resolved is skipped, never guessed.
+The B&G proprietary raw PGNs (65280–65282) are deferred (manufacturer-specific layout).
+
+> **WiFi gateways:** if you feed a WiFi NMEA2000 gateway downstream, configure it for
+> **unicast** UDP, not broadcast — WiFi broadcast is unacknowledged and silently drops
+> frames even at low rates.
+
+## Install
+
+Recommended — install the CLI in its own isolated environment with
+[pipx](https://pipx.pypa.io/):
+
+```bash
+pipx install fastnet2n2k
+fastnet2n2k --serial /dev/ttyUSB0 --channel can0
+```
+
+This puts a `fastnet2n2k` command on your PATH. `python -m fastnet2n2k ...`
+also works once installed.
+
+### From source (development)
+
+```bash
+git clone https://github.com/ghotihook/fastnet2n2k.git
+cd fastnet2n2k
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+## Bring up the CAN bus
+
+Once per boot (250 kbit/s for NMEA2000). `restart-ms 100` makes the controller
+auto-recover from a bus-off instead of staying down:
+
+```bash
+sudo ip link set can0 up type can bitrate 250000 restart-ms 100   # FDCAN1
+# sudo ip link set can1 up type can bitrate 250000 restart-ms 100 # FDCAN2
+ip -details link show can0    # want: state ERROR-ACTIVE, bitrate 250000
+```
+
+If `can0` shows `BUS-OFF`, fix that before expecting output to land — a CAN frame
+needs at least one other node on the wire to acknowledge it (check termination
+≈60 Ω, common ground, and CAN-H/CAN-L not swapped).
+
+## Run
+
+Activate the venv first (`source .venv/bin/activate`), then:
+
+```bash
+# replay a captured Fastnet hex file (safest first test)
+python -m fastnet2n2k --file capture.txt --channel can0
+
+# live from the Fastnet bus
+python -m fastnet2n2k --serial /dev/ttyUSB0 --channel can0
+```
+
+Find your serial adapter with `ls /dev/ttyUSB* /dev/ttyACM* /dev/ttyS*`. Stop with
+Ctrl-C.
+
+Options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `--serial DEV` / `--file PATH` | — | input source (one is required) |
+| `--channel` | `can0` | SocketCAN interface |
+| `--n2k-priority` | per-PGN standard | override CAN priority (0–7, 0=highest) for **all** transmitted frames; **if omitted, each PGN keeps its standard priority** (see the PGN table above) |
+| `--unique` | from hostname | device NAME unique number |
+| `--live-data` | off | print the live channel table to the console once per second |
+| `--log-level` | `INFO` | `DEBUG` / `INFO` / `WARNING` / `ERROR` |
+
+**CAN failure handling:** the device reconnects automatically. If `can0` isn't up at
+start it waits (logging retries) rather than exiting; if the bus drops or goes bus-off
+mid-run, sends fail quietly (logged at most every 5 s) and resume once it recovers — the
+bridge keeps running. Use `--log-level DEBUG` to see connection/retry detail.
+
+## Verify
+
+Watch the raw frames on the board with `can-utils`
+(`sudo apt install can-utils`):
+
+```bash
+candump -ta can0
+```
+
+You should see 29-bit frames appear as instruments update — heading, wind, depth,
+speed, etc. — and stop when they go quiet. On a connected chartplotter / analyzer
+the device appears in the device list after its ISO address claim (PGN 60928).
+
+### Test the whole chain with a loopback (no instruments needed)
+
+With `can0` and `can1` wired together (CAN-H↔CAN-H, CAN-L↔CAN-L, one 120 Ω
+terminator), `can1` provides the ACK so `can0` can transmit:
+
+```bash
+sudo ip link set can1 up type can bitrate 250000 restart-ms 100
+candump -ta can1                                              # terminal 1
+python -m fastnet2n2k --file capture.txt --channel can0      # terminal 2
+```
+
+## Run at boot (systemd)
+
+A unit file is provided in [`fastnet2n2k.service`](fastnet2n2k.service). Edit the
+paths, user and `--serial` device to match your install, then:
+
+Set `ExecStart` to match how you installed it:
+
+- pipx: `ExecStart=/home/<user>/.local/bin/fastnet2n2k --serial /dev/ttySTM3 --channel can0`
+- source venv: `ExecStart=/home/<user>/fastnet2n2k/.venv/bin/python -m fastnet2n2k --serial /dev/ttySTM3 --channel can0`
+
+
+```bash
+sudo cp fastnet2n2k.service /etc/systemd/system/
+sudo systemctl daemon-reload
+sudo systemctl enable --now fastnet2n2k.service
+journalctl -u fastnet2n2k.service -f      # watch logs
+```
+
+The unit brings `can0` up itself (with `restart-ms 100`) before starting, and
+restarts the bridge on failure.
+
+## Tests
+
+```bash
+source .venv/bin/activate
+pip install pytest
+python -m pytest tests/ -q
+```
+
+The suite drives the mapping with pyfastnet's bundled capture files and round-trips
+the resulting NMEA2000 messages to assert PGNs, unit conversions, T/M references,
+sign passthrough, the send throttle, and the full file→decode→send pipeline.
+
+---
+
+## Sender POC (`nmea2000_poc.py`)
+
+A standalone minimal proof-of-concept that transmits a single NMEA2000 PGN (127250
+Vessel Heading) onto the bus — useful for smoke-testing a CAN link independently of
+the Fastnet pipeline.
+
+```bash
+python nmea2000_poc.py --channel can0 --heading 90 --once   # single frame
+python nmea2000_poc.py --channel can0 --heading 90          # ~10 Hz loop
+```
+
+Options: `--channel` (default `can0`), `--heading` degrees, `--ref true|magnetic`,
+`--rate` Hz, `--once`.
+
+### Desk testing without a bus (virtual CAN)
+
+```bash
+sudo modprobe vcan
+sudo ip link add dev vcan0 type vcan
+sudo ip link set up vcan0
+candump vcan0                                                 # terminal 1
+python nmea2000_poc.py --channel vcan0 --heading 90 --once   # terminal 2
+```

fastnet2n2k-0.1.3/README.md

@@ -0,0 +1,201 @@
+# fastnet2n2k — B&G Fastnet → NMEA2000 bridge
+
+Reads a **B&G Fastnet** instrument stream (live serial or a captured hex file),
+decodes it with [`pyfastnet`](https://github.com/ghotihook/pyfastnet), maps the
+channels to **NMEA2000** PGNs and transmits them onto a CAN bus. Built for the
+[M5Stack CoreMP135](https://docs.m5stack.com/en/core/M5CoreMP135) but runs on any
+Linux box with a SocketCAN interface.
+
+The CoreMP135 runs Linux on an STM32MP135 and exposes its two FDCAN interfaces
+(SIT1051T transceivers) as the SocketCAN netdevs `can0` (FDCAN1, PE3/PE10) and
+`can1` (FDCAN2, PG0/PE0). NMEA2000 runs at **250 kbit/s** with 29-bit extended IDs.
+Message encoding, CAN-ID construction, fast-packet framing and ISO address claiming
+are handled by the [`nmea2000`](https://github.com/tomer-w/nmea2000) library (canboat-
+based) on top of `python-can`'s socketcan backend.
+
+## What it sends
+
+Each Fastnet channel is mapped to the matching PGN and emitted **only when the
+channel updates** (with a 0.05 s minimum interval and a 5 s maximum re-broadcast),
+so when the instruments go quiet the output stops and consumers time the data out.
+
+| Data | PGN | Priority | Notes |
+|---|---|---|---|
+| Heading | 127250 | 2 | T/M reference taken from the Fastnet display layout (`°M`/`°T`) |
+| Apparent / True wind, TWD | 130306 | 2 | knots→m/s, deg→rad; reference per layout |
+| Boat speed | 128259 | 2 | knots→m/s |
+| Depth | 128267 | 3 | metres |
+| COG/SOG | 129026 | 2 | prefers True COG, falls back to Magnetic |
+| Attitude (heel/trim) | 127257 | 3 | signed value passed through unchanged |
+| Rudder, Leeway, Rate of turn | 127245 / 128000 / 127251 | 2 / 4 / 2 | |
+| Distance log, XTE | 128275 / 129283 | 6 / 3 | NM→m |
+| Position | 129025 | 2 | |
+| Sea / air temperature | 130312 | 5 | °C/°F→Kelvin |
+| Barometric pressure | 130314 | 5 | mbar→Pa |
+| Tidal set & drift | 129291 | 3 | set deg→rad, drift kn→m/s; reference per layout |
+
+The **Priority** column lists each PGN's NMEA2000 standard CAN priority (0 = highest,
+7 = lowest). These are the values used **by default** — when `--n2k-priority` is *not*
+given, every frame keeps the per-PGN priority shown above. Passing `--n2k-priority N`
+overrides the whole column, forcing all frames to a single priority `N`.
+
+**Units** are converted to NMEA2000 SI. **Sign** comes straight from pyfastnet's
+decoded value. **True/Magnetic** is read from the pyfastnet `layout` field (the only
+place it exists); a bearing whose layout can't be resolved is skipped, never guessed.
+The B&G proprietary raw PGNs (65280–65282) are deferred (manufacturer-specific layout).
+
+> **WiFi gateways:** if you feed a WiFi NMEA2000 gateway downstream, configure it for
+> **unicast** UDP, not broadcast — WiFi broadcast is unacknowledged and silently drops
+> frames even at low rates.
+
+## Install
+
+Recommended — install the CLI in its own isolated environment with
+[pipx](https://pipx.pypa.io/):
+
+```bash
+pipx install fastnet2n2k
+fastnet2n2k --serial /dev/ttyUSB0 --channel can0
+```
+
+This puts a `fastnet2n2k` command on your PATH. `python -m fastnet2n2k ...`
+also works once installed.
+
+### From source (development)
+
+```bash
+git clone https://github.com/ghotihook/fastnet2n2k.git
+cd fastnet2n2k
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+## Bring up the CAN bus
+
+Once per boot (250 kbit/s for NMEA2000). `restart-ms 100` makes the controller
+auto-recover from a bus-off instead of staying down:
+
+```bash
+sudo ip link set can0 up type can bitrate 250000 restart-ms 100   # FDCAN1
+# sudo ip link set can1 up type can bitrate 250000 restart-ms 100 # FDCAN2
+ip -details link show can0    # want: state ERROR-ACTIVE, bitrate 250000
+```
+
+If `can0` shows `BUS-OFF`, fix that before expecting output to land — a CAN frame
+needs at least one other node on the wire to acknowledge it (check termination
+≈60 Ω, common ground, and CAN-H/CAN-L not swapped).
+
+## Run
+
+Activate the venv first (`source .venv/bin/activate`), then:
+
+```bash
+# replay a captured Fastnet hex file (safest first test)
+python -m fastnet2n2k --file capture.txt --channel can0
+
+# live from the Fastnet bus
+python -m fastnet2n2k --serial /dev/ttyUSB0 --channel can0
+```
+
+Find your serial adapter with `ls /dev/ttyUSB* /dev/ttyACM* /dev/ttyS*`. Stop with
+Ctrl-C.
+
+Options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `--serial DEV` / `--file PATH` | — | input source (one is required) |
+| `--channel` | `can0` | SocketCAN interface |
+| `--n2k-priority` | per-PGN standard | override CAN priority (0–7, 0=highest) for **all** transmitted frames; **if omitted, each PGN keeps its standard priority** (see the PGN table above) |
+| `--unique` | from hostname | device NAME unique number |
+| `--live-data` | off | print the live channel table to the console once per second |
+| `--log-level` | `INFO` | `DEBUG` / `INFO` / `WARNING` / `ERROR` |
+
+**CAN failure handling:** the device reconnects automatically. If `can0` isn't up at
+start it waits (logging retries) rather than exiting; if the bus drops or goes bus-off
+mid-run, sends fail quietly (logged at most every 5 s) and resume once it recovers — the
+bridge keeps running. Use `--log-level DEBUG` to see connection/retry detail.
+
+## Verify
+
+Watch the raw frames on the board with `can-utils`
+(`sudo apt install can-utils`):
+
+```bash
+candump -ta can0
+```
+
+You should see 29-bit frames appear as instruments update — heading, wind, depth,
+speed, etc. — and stop when they go quiet. On a connected chartplotter / analyzer
+the device appears in the device list after its ISO address claim (PGN 60928).
+
+### Test the whole chain with a loopback (no instruments needed)
+
+With `can0` and `can1` wired together (CAN-H↔CAN-H, CAN-L↔CAN-L, one 120 Ω
+terminator), `can1` provides the ACK so `can0` can transmit:
+
+```bash
+sudo ip link set can1 up type can bitrate 250000 restart-ms 100
+candump -ta can1                                              # terminal 1
+python -m fastnet2n2k --file capture.txt --channel can0      # terminal 2
+```
+
+## Run at boot (systemd)
+
+A unit file is provided in [`fastnet2n2k.service`](fastnet2n2k.service). Edit the
+paths, user and `--serial` device to match your install, then:
+
+Set `ExecStart` to match how you installed it:
+
+- pipx: `ExecStart=/home/<user>/.local/bin/fastnet2n2k --serial /dev/ttySTM3 --channel can0`
+- source venv: `ExecStart=/home/<user>/fastnet2n2k/.venv/bin/python -m fastnet2n2k --serial /dev/ttySTM3 --channel can0`
+
+
+```bash
+sudo cp fastnet2n2k.service /etc/systemd/system/
+sudo systemctl daemon-reload
+sudo systemctl enable --now fastnet2n2k.service
+journalctl -u fastnet2n2k.service -f      # watch logs
+```
+
+The unit brings `can0` up itself (with `restart-ms 100`) before starting, and
+restarts the bridge on failure.
+
+## Tests
+
+```bash
+source .venv/bin/activate
+pip install pytest
+python -m pytest tests/ -q
+```
+
+The suite drives the mapping with pyfastnet's bundled capture files and round-trips
+the resulting NMEA2000 messages to assert PGNs, unit conversions, T/M references,
+sign passthrough, the send throttle, and the full file→decode→send pipeline.
+
+---
+
+## Sender POC (`nmea2000_poc.py`)
+
+A standalone minimal proof-of-concept that transmits a single NMEA2000 PGN (127250
+Vessel Heading) onto the bus — useful for smoke-testing a CAN link independently of
+the Fastnet pipeline.
+
+```bash
+python nmea2000_poc.py --channel can0 --heading 90 --once   # single frame
+python nmea2000_poc.py --channel can0 --heading 90          # ~10 Hz loop
+```
+
+Options: `--channel` (default `can0`), `--heading` degrees, `--ref true|magnetic`,
+`--rate` Hz, `--once`.
+
+### Desk testing without a bus (virtual CAN)
+
+```bash
+sudo modprobe vcan
+sudo ip link add dev vcan0 type vcan
+sudo ip link set up vcan0
+candump vcan0                                                 # terminal 1
+python nmea2000_poc.py --channel vcan0 --heading 90 --once   # terminal 2
+```

fastnet2n2k-0.1.3/fastnet2n2k/__init__.py

@@ -0,0 +1,8 @@
+"""fastnet2n2k — bridge a B&G Fastnet instrument stream onto an NMEA2000 CAN bus.
+
+Reads Fastnet (serial or a captured hex file), decodes it with ``pyfastnet``, maps
+the decoded channels to NMEA2000 PGNs and transmits them on a SocketCAN interface
+via the ``nmea2000`` (tomer-w) library. Run with ``python -m fastnet2n2k ...``.
+"""
+
+__version__ = "0.1.3"

fastnet2n2k-0.1.3/fastnet2n2k/__main__.py

@@ -0,0 +1,155 @@
+"""fastnet2n2k entry point: Fastnet (serial/file) → decode → NMEA2000 on the CAN bus.
+
+    python -m fastnet2n2k --serial /dev/ttyUSB0 --channel can0
+    python -m fastnet2n2k --file capture.txt    --channel can0
+
+Bring the CAN interface up first:
+    sudo ip link set can0 up type can bitrate 250000
+"""
+
+import argparse
+import asyncio
+import logging
+import socket
+import sys
+import time
+
+import can
+from fastnet_decoder import FrameBuffer
+from nmea2000.device import N2KDevice
+
+from . import __version__, mapping
+from .display import print_live_data
+from .input_source import initialize_input_source, read_input_source
+from .live_store import live_data, update_live_data
+
+logger = logging.getLogger("fastnet2n2k")
+
+
+def fnv_unique() -> int:
+    """A stable 21-bit unique number derived from the hostname, so two boards don't
+    default to the same NMEA2000 NAME."""
+    h = 2166136261
+    for b in socket.gethostname().encode():
+        h = ((h ^ b) * 16777619) & 0xFFFFFFFF
+    return h & 0x1FFFFF
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description=__doc__,
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    src = p.add_mutually_exclusive_group(required=True)
+    src.add_argument("--serial", metavar="DEV", help="Fastnet serial port, e.g. /dev/ttyUSB0")
+    src.add_argument("--file", metavar="PATH", help="Captured Fastnet hex (.txt) to replay")
+    p.add_argument("--channel", default="can0", help="SocketCAN interface (default: can0)")
+    p.add_argument("--n2k-priority", type=lambda x: int(x, 0), default=None,
+                   help="Override the CAN priority (0–7, 0=highest) for ALL transmitted "
+                        "frames. Default: each PGN uses its NMEA2000 standard priority.")
+    p.add_argument("--unique", type=int, default=fnv_unique(),
+                   help="Device NAME unique number (default: derived from hostname)")
+    p.add_argument("--live-data", action="store_true",
+                   help="Print the live channel table to the console once per second")
+    p.add_argument("--log-level", default="INFO",
+                   choices=("DEBUG", "INFO", "WARNING", "ERROR"),
+                   help="Logging verbosity (default: INFO)")
+    args = p.parse_args()
+    if args.n2k_priority is not None and not 0 <= args.n2k_priority <= 7:
+        p.error("--n2k-priority must be 0–7")
+    return args
+
+
+def make_device(args: argparse.Namespace) -> N2KDevice:
+    return N2KDevice.for_python_can(
+        "socketcan", args.channel,
+        unique_number=args.unique,
+        manufacturer_code=2046,    # open-source / unregistered
+        device_function=190,       # 190 = Navigation
+        device_class=60,           # 60 = Navigation
+        industry_group=4,          # 4 = Marine
+        model_id="fastnet2n2k",
+        model_version=__version__,
+        software_version_code=__version__,
+        transmit_pgns=mapping.TX_PGNS,
+    )
+
+
+async def _dispatch_frame(frame: dict) -> None:
+    for channel_name, decoded in frame.get("values", {}).items():
+        old = live_data.get(channel_name)
+        old_copy = dict(old) if old else None
+        update_live_data(channel_name, decoded.get("channel_id"), decoded.get("value"),
+                         decoded.get("display_text"), decoded.get("layout"))
+        await mapping.process_channel(channel_name, old_copy)
+
+
+async def run(args: argparse.Namespace) -> int:
+    try:
+        device = make_device(args)
+    except (OSError, can.CanError) as exc:
+        logger.error("Could not create CAN interface '%s': %s", args.channel, exc)
+        logger.error("Bring it up first: sudo ip link set %s up type can bitrate 250000",
+                     args.channel)
+        return 1
+
+    # connect() retries with backoff until the interface is available, so this waits
+    # (rather than failing) if can0 isn't up yet — the right behaviour for a boat bus
+    # that may power-cycle. Watch the logs; raise --log-level if it seems stuck.
+    logger.info("Connecting to CAN interface %s (waiting if it isn't up yet)…",
+                args.channel)
+    await device.start()
+
+    mapping.set_device(device)
+    if args.n2k_priority is not None:
+        mapping.set_priority_override(args.n2k_priority)
+        logger.info("Overriding priority for all frames: %d", args.n2k_priority)
+    logger.info("Transmitting on %s (src=%d); reading Fastnet from %s",
+                args.channel, device.address, args.serial or args.file)
+    try:
+        await asyncio.wait_for(device.wait_ready(), timeout=10)
+        logger.info("Address claimed: %d", device.address)
+    except asyncio.TimeoutError:
+        logger.warning("Address claim not confirmed within 10s — continuing")
+
+    source, is_file = initialize_input_source(serial_port=args.serial, file_path=args.file)
+    fb = FrameBuffer()
+    last_print = time.monotonic()
+    try:
+        while True:
+            data = await asyncio.to_thread(read_input_source, source, is_file)
+            if data is not None:
+                fb.add_to_buffer(data)
+                fb.get_complete_frames()
+                while not fb.frame_queue.empty():
+                    await _dispatch_frame(fb.frame_queue.get())
+
+            if args.live_data and time.monotonic() - last_print >= 1:
+                print_live_data(fb)
+                last_print = time.monotonic()
+
+            if is_file and data is None:
+                logger.info("File replay complete")
+                break
+    except KeyboardInterrupt:
+        logger.info("Stopping")
+    finally:
+        await device.close()
+        if not is_file:
+            source.close()
+    return 0
+
+
+def main() -> int:
+    args = parse_args()
+    level = getattr(logging, args.log_level)
+    logging.basicConfig(
+        level=level, format="%(asctime)s [%(name)s] %(levelname)-5s %(message)s")
+    # The nmea2000 client is chatty at DEBUG; keep it in step with our level.
+    logging.getLogger("nmea2000").setLevel(level)
+    try:
+        return asyncio.run(run(args))
+    except KeyboardInterrupt:
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fastnet2n2k-0.1.3/fastnet2n2k/display.py

@@ -0,0 +1,28 @@
+"""Optional live channel table for the console (--live-data).
+
+Ported from fastnet2ip/core/display.py. Clears the screen and prints every channel
+currently in the live store with its value, layout and age, so you can eyeball what
+the decoder is producing while the bridge runs.
+"""
+
+from datetime import datetime, timezone
+
+from .live_store import live_data
+
+
+def print_live_data(fb):
+    print("\033c", end="")   # clear screen
+    now = datetime.now(timezone.utc)
+    hdr = f"{'Channel':<35} {'ID':<10} {'Value':<20} {'Layout':<12} {'Age(s)':<10}"
+    print(hdr)
+    print("-" * len(hdr))
+    for name, data in sorted(live_data.items()):
+        ts = data.get("timestamp")
+        val = data.get("value")
+        display = str(val) if val is not None else data.get("display_text", "")
+        age = f"{(now - ts).total_seconds():.1f}" if ts else ""
+        print(
+            f"{str(name):<35} {str(data.get('channel_id', '')):<10} "
+            f"{display:<20} {str(data.get('layout', '')):<12} {age:<10}"
+        )
+    print(f"Buffer: {fb.get_buffer_size()}\n")

fastnet2n2k-0.1.3/fastnet2n2k/input_source.py

@@ -0,0 +1,65 @@
+"""Fastnet input sources: a live serial port or a captured hex file.
+
+Fastnet line settings are 28800 baud, 8 data bits, 2 stop bits, odd parity.
+Ported from fastnet2ip/core/input.py.
+"""
+
+import logging
+import select
+import time
+
+import serial
+
+BAUDRATE        = 28800
+BYTE_SIZE       = serial.EIGHTBITS
+STOP_BITS       = serial.STOPBITS_TWO
+PARITY          = serial.PARITY_ODD
+READ_SIZE       = 256
+FILE_READ_DELAY = 0.05
+
+logger = logging.getLogger("fastnet2n2k.input")
+
+
+def initialize_input_source(serial_port=None, file_path=None):
+    """Return ``(source, is_file)``. ``source`` is a ``serial.Serial`` for a live
+    port, or an iterator of byte chunks for a file."""
+    if serial_port:
+        logger.info("Serial port: %s", serial_port)
+        try:
+            return serial.Serial(
+                port=serial_port, baudrate=BAUDRATE, bytesize=BYTE_SIZE,
+                stopbits=STOP_BITS, parity=PARITY, timeout=0,
+            ), False
+        except (serial.SerialException, OSError) as e:
+            logger.error("Cannot open %s: %s", serial_port, e)
+            raise SystemExit(1)
+    elif file_path:
+        logger.info("File: %s", file_path)
+        try:
+            with open(file_path) as f:
+                hex_data = f.read().strip().replace(" ", "").replace("\n", "")
+            if not hex_data:
+                raise ValueError("File is empty")
+            binary = bytes.fromhex(hex_data)
+        except (OSError, ValueError) as e:
+            logger.error("File error: %s", e)
+            raise SystemExit(1)
+        chunks = [binary[i:i + READ_SIZE] for i in range(0, len(binary), READ_SIZE)]
+        return iter(chunks), True
+    else:
+        logger.error("Specify a serial port or a file")
+        raise SystemExit(1)
+
+
+def read_input_source(input_source, is_file):
+    """Return the next chunk of bytes, or ``None`` (file exhausted / no data yet)."""
+    if is_file:
+        try:
+            time.sleep(FILE_READ_DELAY)
+            return next(input_source)
+        except StopIteration:
+            return None
+    rlist, _, _ = select.select([input_source], [], [], 1)
+    if input_source in rlist:
+        return input_source.read(READ_SIZE)
+    return None

fastnet2n2k-0.1.3/fastnet2n2k/live_store.py

@@ -0,0 +1,32 @@
+"""Latest-value store for decoded Fastnet channels.
+
+Single-threaded: written and read from the main decode loop only. Each entry keeps
+the decoded ``value``, the ``display_text`` and ``layout`` from pyfastnet (the layout
+carries the T/M reference), and a ``timestamp`` so freshness can be reasoned about.
+
+Ported from fastnet2ip/core/data_store.py.
+"""
+
+from datetime import datetime, timezone
+
+live_data: dict = {}
+
+
+def update_live_data(channel_name, channel_id, value, display_text, layout):
+    live_data[channel_name] = {
+        "channel_id":   channel_id,
+        "value":        value,
+        "display_text": display_text,
+        "layout":       layout,
+        "timestamp":    datetime.now(timezone.utc),
+    }
+
+
+def get_live_data(name):
+    entry = live_data.get(name)
+    return entry.get("value") if entry else None
+
+
+def get_live_display(name):
+    entry = live_data.get(name)
+    return entry.get("display_text") if entry else None

fastnet2n2k-0.1.3/fastnet2n2k/mapping.py

@@ -0,0 +1,381 @@
+"""Map decoded Fastnet channels to NMEA2000 messages and send them on the CAN bus.
+
+Uses the ``nmea2000`` library (tomer-w), which is canboat-based: messages are built
+by taking a blank PGN template from :mod:`nmea2000.pgns`, setting the fields we care
+about (by id, in SI units), and handing the resulting ``NMEA2000Message`` to an
+``N2KDevice`` that transmits it over SocketCAN and manages ISO address claiming.
+
+Conventions:
+- **Units** → NMEA2000 SI: knots→m/s, degrees→radians, °C/°F→Kelvin, NM→m, mbar→Pa.
+- **Sign** is taken directly from pyfastnet's decoded ``value``.
+- **T/M reference** is taken from the pyfastnet ``layout`` field (the only place it
+  exists) and mapped to the canboat lookup string. If a bearing channel's layout
+  can't be resolved the frame is skipped and logged — never guessed.
+- **Staleness**: a PGN is sent only when its channel updates (event-driven), with a
+  minimum interval and a maximum re-broadcast age; when the source stops, output
+  stops and consumers time the PGN out themselves.
+"""
+
+import logging
+import time
+from datetime import datetime, timezone
+from math import radians
+
+import nmea2000.pgns as pgns
+
+from .live_store import get_live_data, get_live_display, live_data
+
+logger = logging.getLogger("fastnet2n2k.mapping")
+
+MIN_SEND_INTERVAL = 0.05
+REBROADCAST_AGE   = 5.0
+KN_MS             = 0.514444
+
+_channel_last_sent: dict = {}
+_device = None
+_priority_override = None
+_last_send_error_log = 0.0
+_SEND_ERROR_LOG_INTERVAL = 5.0
+
+
+def set_device(device) -> None:
+    """Register the N2KDevice that frames are transmitted through."""
+    global _device
+    _device = device
+
+
+def set_priority_override(priority) -> None:
+    """Force every transmitted frame to ``priority`` (0–7), ignoring the per-PGN
+    standard priorities. ``None`` restores the standard per-PGN behaviour."""
+    global _priority_override
+    _priority_override = priority
+
+
+def _c_to_k(c):
+    return c + 273.15
+
+
+def _f_to_k(f):
+    return (f - 32) * 5 / 9 + 273.15
+
+
+def _build(pgn, priority, **fields):
+    """Build an NMEA2000Message for ``pgn`` with the given field id → SI value pairs.
+
+    ``None`` values are written through as "data not available". Source is left 0 so
+    the N2KDevice substitutes its claimed address.
+    """
+    msg = getattr(pgns, f"decode_pgn_{pgn}")(0, 0)
+    msg.source = 0
+    msg.priority = _priority_override if _priority_override is not None else priority
+    msg.timestamp = datetime.now(timezone.utc)
+    for f in msg.fields:
+        if f.id in fields:
+            f.raw_value = None
+            f.value = fields[f.id]
+    return msg
+
+
+# ── Layout → canboat reference string (the only source of T/M) ────────────────
+_LAYOUT_BEARING_REF = {"°M": "Magnetic", "°T": "True"}
+_LAYOUT_WIND_REF = {
+    "°M": "Magnetic (ground referenced to Magnetic North)",
+    "°T": "True (ground referenced to North)",
+}
+
+
+def _bearing_ref(name):
+    entry = live_data.get(name)
+    if entry is None:
+        return None
+    ref = _LAYOUT_BEARING_REF.get(entry["layout"])
+    if ref is None:
+        logger.error("%s: unrecognised layout %r — skipping frame", name, entry["layout"])
+    return ref
+
+
+# ── Triggers: each returns one NMEA2000Message, or None ───────────────────────
+
+def _wind(angle_ch, speed_ch, reference):
+    angle = get_live_data(angle_ch)
+    speed = get_live_data(speed_ch)
+    if angle is None and speed is None:
+        return None
+    if angle is not None and angle < 0:        # N2K wind angle is 0..2π
+        angle += 360
+    return _build(130306, 2,
+                  windSpeed=speed * KN_MS if speed is not None else None,
+                  windAngle=radians(angle) if angle is not None else None,
+                  reference=reference)
+
+
+def process_apparent_wind():
+    return _wind("Apparent Wind Angle", "Apparent Wind Speed (Knots)", "Apparent")
+
+
+def process_true_wind():
+    return _wind("True Wind Angle", "True Wind Speed (Knots)", "True (boat referenced)")
+
+
+def process_twd():
+    entry = live_data.get("True Wind Direction")
+    if entry is None:
+        return None
+    ref = _LAYOUT_WIND_REF.get(entry["layout"])
+    if ref is None:
+        logger.error("True Wind Direction: unrecognised layout %r — skipping frame",
+                     entry["layout"])
+        return None
+    return _wind("True Wind Direction", "True Wind Speed (Knots)", ref)
+
+
+def process_heading():
+    hdg = get_live_data("Heading")
+    if hdg is None:
+        return None
+    ref = _bearing_ref("Heading")
+    if ref is None:
+        return None
+    return _build(127250, 2, heading=radians(hdg), reference=ref,
+                  deviation=None, variation=None)
+
+
+def process_boatspeed():
+    bs = get_live_data("Boatspeed (Knots)")
+    if bs is None:
+        return None
+    return _build(128259, 2, speedWaterReferenced=bs * KN_MS,
+                  speedGroundReferenced=None, speedDirection=None)
+
+
+def process_depth():
+    dm = get_live_data("Depth (Meters)")
+    if dm is None:
+        return None
+    return _build(128267, 3, depth=dm, offset=None, range=None)
+
+
+def process_rudder():
+    ra = get_live_data("Rudder Angle")
+    if ra is None:
+        return None
+    return _build(127245, 2, instance=0, position=radians(ra), angleOrder=None)
+
+
+def process_leeway():
+    lw = get_live_data("Leeway")
+    if lw is None:
+        return None
+    return _build(128000, 4, leewayAngle=radians(lw))
+
+
+def process_cog_sog():
+    cog_true = get_live_data("Course Over Ground (True)")
+    cog_mag  = get_live_data("Course Over Ground (Mag)")
+    sog      = get_live_data("Speed Over Ground")
+    if sog is None:
+        return None
+    sog_ms = sog * KN_MS
+    if cog_true is not None:
+        return _build(129026, 2, cogReference="True",
+                      cog=radians(cog_true % 360), sog=sog_ms)
+    if cog_mag is not None:
+        return _build(129026, 2, cogReference="Magnetic",
+                      cog=radians(cog_mag % 360), sog=sog_ms)
+    return _build(129026, 2, cog=None, sog=sog_ms)
+
+
+def process_battery():
+    v = get_live_data("Battery Volts")
+    if v is None:
+        return None
+    return _build(127508, 6, instance=0, voltage=v, current=None, temperature=None)
+
+
+def process_attitude():
+    roll  = get_live_data("Heel Angle")
+    pitch = get_live_data("Fore/Aft Trim")
+    if roll is None and pitch is None:
+        return None
+    return _build(127257, 3, yaw=None,
+                  pitch=radians(pitch) if pitch is not None else None,
+                  roll=radians(roll) if roll is not None else None)
+
+
+def process_pressure():
+    bp = get_live_data("Barometric Pressure")   # mbar / hPa
+    if bp is None:
+        return None
+    return _build(130314, 5, instance=0, source="Atmospheric", pressure=bp * 100)
+
+
+def _temperature(channel_c, channel_f, source):
+    c = get_live_data(channel_c)
+    if c is not None:
+        k = _c_to_k(c)
+    else:
+        f = get_live_data(channel_f)
+        if f is None:
+            return None
+        k = _f_to_k(f)
+    return _build(130312, 5, instance=0, source=source,
+                  actualTemperature=k, setTemperature=None)
+
+
+def process_sea_temp():
+    return _temperature("Sea Temperature (°C)", "Sea Temperature (°F)", "Sea Temperature")
+
+
+def process_air_temp():
+    return _temperature("Air Temperature (°C)", "Air Temperature (°F)", "Outside Temperature")
+
+
+def process_distance_log():
+    stored = get_live_data("Stored Log (NM)")
+    trip   = get_live_data("Trip Log (NM)")
+    if stored is None and trip is None:
+        return None
+    now = datetime.now(timezone.utc)
+    return _build(128275, 6, date=now.date(), time=now.time(),
+                  log=int(stored * 1852) if stored is not None else None,
+                  tripLog=int(trip * 1852) if trip is not None else None)
+
+
+def process_xte():
+    xte = get_live_data("Cross Track Error")
+    if xte is None:
+        return None
+    return _build(129283, 3, xteMode="Autonomous", navigationTerminated="No",
+                  xte=xte * 1852)
+
+
+def process_rate_of_turn():
+    yr = get_live_data("Yaw rate")
+    if yr is None:
+        return None
+    return _build(127251, 2, rate=radians(yr))
+
+
+def process_set_drift():
+    set_deg = get_live_data("Tidal Set")     # degrees
+    drift   = get_live_data("Tidal Drift")   # knots
+    if set_deg is None and drift is None:
+        return None
+    ref = _bearing_ref("Tidal Set")
+    if ref is None:
+        return None
+    return _build(129291, 3, setReference=ref,
+                  set=radians(set_deg % 360) if set_deg is not None else None,
+                  drift=max(0.0, drift) * KN_MS if drift is not None else None)
+
+
+def process_position():
+    latlon = get_live_display("LatLon")          # e.g. "3352.450S15113.920E"
+    if not latlon:
+        return None
+    lat_idx = latlon.find('N') if 'N' in latlon else latlon.find('S')
+    lon_idx = latlon.find('E') if 'E' in latlon else latlon.find('W')
+    if lat_idx == -1 or lon_idx == -1:
+        return None
+    try:
+        lat_part, lat_dir = latlon[:lat_idx], latlon[lat_idx]
+        lon_part, lon_dir = latlon[lat_idx + 1:lon_idx], latlon[lon_idx]
+        lat = int(lat_part[:2]) + float(lat_part[2:]) / 60
+        lon = int(lon_part[:3]) + float(lon_part[3:]) / 60
+    except (ValueError, IndexError):
+        logger.debug("position: could not parse %r", latlon)
+        return None
+    if lat_dir == 'S':
+        lat = -lat
+    if lon_dir == 'W':
+        lon = -lon
+    return _build(129025, 2, latitude=lat, longitude=lon)
+
+
+# ── Channel → trigger map ─────────────────────────────────────────────────────
+_CHANNEL_MAP = {
+    "Heading":                      process_heading,
+    "Rudder Angle":                 process_rudder,
+    "Boatspeed (Knots)":            process_boatspeed,
+    "Depth (Meters)":               process_depth,
+    "Depth (Feet)":                 "duplicate of Depth (Meters)",
+    "Depth (Fathoms)":              "duplicate of Depth (Meters)",
+    "Apparent Wind Angle":          process_apparent_wind,
+    "Apparent Wind Speed (Knots)":  "covered by 'Apparent Wind Angle' (same frame)",
+    "True Wind Angle":              process_true_wind,
+    "True Wind Direction":          process_twd,
+    "True Wind Speed (Knots)":      "covered by True Wind Angle/Direction (same frame)",
+    "True Wind Speed (m/s)":        "covered by True Wind Angle/Direction (same frame)",
+    "Leeway":                       process_leeway,
+    "Speed Over Ground":            process_cog_sog,
+    "Course Over Ground (True)":    "covered by 'Speed Over Ground' (same frame)",
+    "Course Over Ground (Mag)":     "covered by 'Speed Over Ground' (same frame)",
+    "Battery Volts":                process_battery,
+    "Heel Angle":                   process_attitude,
+    "Fore/Aft Trim":                "covered by 'Heel Angle' (same frame)",
+    "Stored Log (NM)":              process_distance_log,
+    "Trip Log (NM)":                "covered by 'Stored Log (NM)' (same frame)",
+    "Sea Temperature (°C)":         process_sea_temp,
+    "Sea Temperature (°F)":         process_sea_temp,
+    "Air Temperature (°C)":         process_air_temp,
+    "Air Temperature (°F)":         process_air_temp,
+    "LatLon":                       process_position,
+    "Barometric Pressure":          process_pressure,
+    "Yaw rate":                     process_rate_of_turn,
+    "Cross Track Error":            process_xte,
+    "Tidal Set":                    process_set_drift,
+    "Tidal Drift":                  "covered by 'Tidal Set' (same frame)",
+    # Deferred: B&G proprietary raw PGNs (65280-65282) — manufacturer-specific.
+    "Boatspeed (Raw)":             "TODO: proprietary PGN 65282 (deferred)",
+    "Heading (Raw)":               "TODO: proprietary PGN 65281 (deferred)",
+    "Apparent Wind Speed (Raw)":   "TODO: proprietary PGN 65280 (deferred)",
+    "Apparent Wind Angle (Raw)":   "TODO: proprietary PGN 65280 (deferred)",
+}
+
+# PGNs this node transmits — advertised to the bus by the N2KDevice.
+TX_PGNS = [127245, 127250, 127251, 127257, 127508, 128000, 128259, 128267,
+           128275, 129025, 129026, 129283, 129291, 130306, 130312, 130314]
+
+
+def trigger_n2k_frame(channel_name):
+    entry = _CHANNEL_MAP.get(channel_name)
+    if callable(entry):
+        return entry()
+    if isinstance(entry, str):
+        logger.debug("No trigger for %r — %s", channel_name, entry)
+    else:
+        logger.debug("No trigger for %r", channel_name)
+    return None
+
+
+async def process_channel(channel_name, old_entry):
+    """Apply the throttle policy, then build and transmit the channel's frame."""
+    now = time.monotonic()
+    current = live_data.get(channel_name)
+    new_key = (current["value"], current["display_text"]) if current else (None, None)
+    old_key = (old_entry["value"], old_entry["display_text"]) if old_entry else (None, None)
+
+    last_sent = _channel_last_sent.get(channel_name)
+    if last_sent is not None:
+        if (now - last_sent) < MIN_SEND_INTERVAL:
+            return
+        if new_key == old_key and (now - last_sent) < REBROADCAST_AGE:
+            return
+
+    msg = trigger_n2k_frame(channel_name)
+    if msg is None:
+        return
+    if _device is None or not _device.ready:
+        return   # not connected / address not claimed — retry on the next update
+    _channel_last_sent[channel_name] = now
+    try:
+        await _device.send(msg)
+    except Exception as exc:   # noqa: BLE001 — bus-off / interface drop / reconnect
+        # The N2KDevice client reconnects underneath; don't let a transient CAN
+        # failure tear down the bridge. Log at most once per interval to avoid
+        # flooding while the bus is down.
+        global _last_send_error_log
+        if now - _last_send_error_log >= _SEND_ERROR_LOG_INTERVAL:
+            logger.warning("CAN send failed (%s) — continuing; the device will reconnect",
+                           exc)
+            _last_send_error_log = now

fastnet2n2k-0.1.3/fastnet2n2k.service

@@ -0,0 +1,33 @@
+# systemd unit for the fastnet2n2k bridge.
+#
+# Edit User=, the paths, and the --serial device to match your install, then:
+#   sudo cp fastnet2n2k.service /etc/systemd/system/
+#   sudo systemctl daemon-reload
+#   sudo systemctl enable --now fastnet2n2k.service
+#   journalctl -u fastnet2n2k.service -f
+#
+# The service runs as an unprivileged user; the ExecStartPre line uses systemd's
+# "+" prefix so only the CAN bring-up runs as root. Make sure that user is in the
+# "dialout" group so it can read the Fastnet serial device:
+#   sudo usermod -aG dialout <user>
+
+[Unit]
+Description=Fastnet to NMEA2000 bridge
+After=network.target
+
+[Service]
+Type=simple
+User=alex060
+WorkingDirectory=/home/alex060/fastnet2n2k
+
+# Bring can0 up at the NMEA2000 bitrate before starting (run as root via "+").
+# restart-ms 100 lets the controller auto-recover from a bus-off.
+ExecStartPre=+/bin/sh -c 'ip link set can0 down 2>/dev/null; ip link set can0 up type can bitrate 250000 restart-ms 100'
+
+ExecStart=/home/alex060/fastnet2n2k/.venv/bin/python -m fastnet2n2k --serial /dev/ttySTM3 --channel can0
+
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target

fastnet2n2k-0.1.3/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fastnet2n2k"
+dynamic = ["version"]
+description = "Bridge a B&G Fastnet instrument stream onto an NMEA2000 CAN bus"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "ghotihook" }]
+keywords = ["nmea2000", "fastnet", "n2k", "canbus", "marine", "b&g", "socketcan"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: End Users/Desktop",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3",
+  "Topic :: Communications",
+]
+dependencies = [
+  "nmea2000>=2026.5",
+  "python-can>=4.5",
+  "pyfastnet>=2.0.17",
+  "pyserial>=3.5",
+]
+
+[project.scripts]
+fastnet2n2k = "fastnet2n2k.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/ghotihook/fastnet2n2k"
+Repository = "https://github.com/ghotihook/fastnet2n2k"
+Issues = "https://github.com/ghotihook/fastnet2n2k/issues"
+
+[tool.hatch.version]
+path = "fastnet2n2k/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fastnet2n2k"]
+
+[tool.hatch.build.targets.sdist]
+include = ["fastnet2n2k", "README.md", "LICENSE", "fastnet2n2k.service"]