fastnet2ip 1.0.0__py3-none-any.whl

fastnet2ip/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

fastnet2ip/__main__.py

@@ -0,0 +1,153 @@
+import argparse
+import logging
+import queue
+import socket
+import time
+
+import serial
+from fastnet_decoder import FrameBuffer, set_log_level
+
+from fastnet2ip.core.data_store import live_data, update_live_data
+from fastnet2ip.core.input import initialize_input_source, read_input_source
+from fastnet2ip.core.display import print_live_data
+from fastnet2ip.handlers.nmea0183 import NMEA0183Handler
+from fastnet2ip.handlers.nmea2000 import NMEA2000Handler
+
+_HANDLERS = {
+    "nmea0183": NMEA0183Handler,
+    "nmea2000": NMEA2000Handler,
+}
+
+_GPS_CHANNELS = frozenset({
+    "LatLon",
+    "Speed Over Ground",
+    "Course Over Ground (True)",
+    "Course Over Ground (Mag)",
+})
+
+_HEADING_CHANNELS = frozenset({
+    "Heading",
+    "Heading (Raw)",
+})
+
+
+def _drain_frame_queue(fq, handler, udp_socket, ignore_gps=False, ignore_heading=False):
+    while True:
+        try:
+            frame = fq.get_nowait()
+        except queue.Empty:
+            break
+        if not frame:
+            continue
+        for channel_name, channel_data in frame.get("values", {}).items():
+            if not channel_data:
+                continue
+            if ignore_gps and channel_name in _GPS_CHANNELS:
+                continue
+            if ignore_heading and channel_name in _HEADING_CHANNELS:
+                continue
+            channel_id   = channel_data.get("channel_id", "??")
+            value        = channel_data.get("value")
+            display_text = channel_data.get("display_text", "")
+            layout       = channel_data.get("layout")
+
+            old_entry = live_data.get(channel_name)
+            update_live_data(channel_name, channel_id, value, display_text, layout)
+            handler.process_channel(channel_name, old_entry, udp_socket)
+
+
+def run_loop(input_source, is_file, handler, udp_socket, show_live_data, ignore_gps=False, ignore_heading=False):
+    fb = FrameBuffer()
+    last_print = time.monotonic()
+    while True:
+        data = read_input_source(input_source, is_file)
+        if data:
+            fb.add_to_buffer(data)
+            fb.get_complete_frames()
+            _drain_frame_queue(fb.frame_queue, handler, udp_socket, ignore_gps, ignore_heading)
+
+        handler.tick(udp_socket)
+
+        if show_live_data and time.monotonic() - last_print >= 1:
+            print_live_data(fb)
+            last_print = time.monotonic()
+
+        if is_file and data is None:
+            break
+
+
+def main():
+    # First pass: resolve --output so the handler can register its own flags.
+    pre_parser = argparse.ArgumentParser(add_help=False)
+    pre_parser.add_argument("--output", default="nmea0183", choices=list(_HANDLERS))
+    pre_args, _ = pre_parser.parse_known_args()
+
+    handler_class = _HANDLERS[pre_args.output]
+
+    parser = argparse.ArgumentParser(description="FastNet Protocol Decoder")
+    parser.add_argument(
+        "--output", default="nmea0183", choices=list(_HANDLERS),
+        help="Output format (default: nmea0183)",
+    )
+    parser.add_argument("--serial",    type=str, help="Serial port (e.g., /dev/ttyUSB0)")
+    parser.add_argument("--file",      type=str, help="Path to hex data file")
+    parser.add_argument("--log-level", type=str, default="INFO",
+                        help="Log level: DEBUG, INFO, WARNING, ERROR (default: INFO)")
+    parser.add_argument("--live-data", action="store_true",
+                        help="Print live channel table to console once per second")
+    parser.add_argument("--ignore-gps", action="store_true",
+                        help="Suppress GPS channels (LatLon, COG, SOG) — use when GPS is "
+                             "already on the network to avoid duplicate/looping data")
+    parser.add_argument("--ignore-heading", action="store_true",
+                        help="Suppress heading channels (Heading, Heading (Raw)) — use when "
+                             "a compass is already on the network to avoid duplicate/looping data")
+    parser.add_argument("--host", type=str, default="255.255.255.255",
+                        help="UDP destination host (default: 255.255.255.255)")
+    parser.add_argument("--udp-port", type=int, default=None,
+                        help="UDP port (default: 2002 for nmea0183, 2000 for nmea2000)")
+
+    handler_class.add_arguments(parser)
+    args = parser.parse_args()
+
+    if args.udp_port is None:
+        args.udp_port = 2002 if args.output == "nmea0183" else 2000
+
+    set_log_level(args.log_level)
+    logging.getLogger("fastnet2ip").setLevel(
+        getattr(logging, args.log_level.upper(), logging.INFO)
+    )
+    logging.getLogger("fastnet2ip.handlers.nmea2000").setLevel(
+        getattr(logging, args.log_level.upper(), logging.INFO)
+    )
+
+    if args.ignore_gps:
+        from fastnet_decoder import logger
+        logger.info(f"GPS suppressed: {', '.join(sorted(_GPS_CHANNELS))}")
+
+    if args.ignore_heading:
+        from fastnet_decoder import logger
+        logger.info(f"Heading suppressed: {', '.join(sorted(_HEADING_CHANNELS))}")
+
+    handler = handler_class()
+    handler.setup(args)
+
+    input_source, is_file = initialize_input_source(args)
+
+    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+
+    handler.startup(udp_socket)
+
+    try:
+        run_loop(input_source, is_file, handler, udp_socket, args.live_data, args.ignore_gps, args.ignore_heading)
+    except KeyboardInterrupt:
+        from fastnet_decoder import logger
+        logger.info("Shutting down. Goodbye!")
+    finally:
+        udp_socket.close()
+        if isinstance(input_source, serial.Serial) and input_source.is_open:
+            input_source.close()
+
+
+if __name__ == "__main__":
+    main()

fastnet2ip/core/data_store.py

@@ -0,0 +1,34 @@
+from datetime import datetime, timezone
+
+# Single-threaded access only: written and read from the main run loop.
+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, as_string=False):
+    entry = live_data.get(name)
+    if not entry:
+        return None
+    val = entry.get("value")
+    if as_string:
+        return str(val) if val is not None else entry.get("display_text")
+    return val
+
+
+def get_live_display(name):
+    entry = live_data.get(name)
+    return entry.get("display_text") if entry else None
+
+
+def get_live_layout(name):
+    entry = live_data.get(name)
+    return entry.get("layout") if entry else None

fastnet2ip/core/display.py

@@ -0,0 +1,23 @@
+from datetime import datetime, timezone
+
+from fastnet2ip.core.data_store import live_data
+
+
+def print_live_data(fb):
+    print("\033c", end="")
+    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} "
+            f"{str(data.get('layout', '')):<12} "
+            f"{age:<10}"
+        )
+    print(f"Buffer: {fb.get_buffer_size()}\n")

fastnet2ip/core/input.py

@@ -0,0 +1,57 @@
+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
+
+
+def initialize_input_source(args):
+    from fastnet_decoder import set_log_level as _sl  # avoid circular at module load
+    if args.serial:
+        from fastnet_decoder import logger
+        logger.info(f"Serial port: {args.serial}")
+        try:
+            return serial.Serial(
+                port=args.serial, baudrate=BAUDRATE, bytesize=BYTE_SIZE,
+                stopbits=STOP_BITS, parity=PARITY, timeout=0,
+            ), False
+        except (serial.SerialException, OSError) as e:
+            logger.error(f"Cannot open {args.serial}: {e}")
+            raise SystemExit(1)
+    elif args.file:
+        from fastnet_decoder import logger
+        logger.info(f"File: {args.file}")
+        try:
+            with open(args.file) as f:
+                hex_data = f.read().strip().replace(" ", "")
+            if not hex_data:
+                raise ValueError("File is empty")
+            binary = bytes.fromhex(hex_data)
+        except (OSError, ValueError) as e:
+            logger.error(f"File error: {e}")
+            raise SystemExit(1)
+        return iter([binary[i:i + READ_SIZE] for i in range(0, len(binary), READ_SIZE)]), True
+    else:
+        from fastnet_decoder import logger
+        logger.error("Specify --serial or --file")
+        raise SystemExit(1)
+
+
+def read_input_source(input_source, is_file):
+    if is_file:
+        try:
+            time.sleep(FILE_READ_DELAY)
+            return next(input_source)
+        except StopIteration:
+            return None
+    else:
+        rlist, _, _ = select.select([input_source], [], [], 1)
+        if input_source in rlist:
+            return input_source.read(READ_SIZE)
+    return None

fastnet2ip/handlers/base.py

@@ -0,0 +1,43 @@
+import argparse
+import socket
+from abc import ABC, abstractmethod
+
+
+class OutputHandler(ABC):
+
+    @classmethod
+    @abstractmethod
+    def add_arguments(cls, parser: argparse.ArgumentParser) -> None:
+        """Register format-specific CLI flags on the shared parser."""
+
+    @abstractmethod
+    def setup(self, args: argparse.Namespace) -> None:
+        """Called once after arg parsing. Configure state from args."""
+
+    @abstractmethod
+    def startup(self, udp_socket: socket.socket) -> None:
+        """Called once before the main loop. Send any startup messages."""
+
+    @abstractmethod
+    def process_channel(
+        self,
+        channel_name: str,
+        old_entry: dict | None,
+        udp_socket: socket.socket,
+    ) -> None:
+        """Encode and transmit output for one updated channel.
+
+        Called after live_data has been updated. The handler owns all
+        rate-limit and value-change logic.
+        """
+
+    def tick(self, udp_socket: socket.socket) -> None:
+        """Called once per run_loop iteration. Override for periodic tasks."""
+
+    @property
+    @abstractmethod
+    def udp_host(self) -> str: ...
+
+    @property
+    @abstractmethod
+    def udp_port(self) -> int: ...