665 lines
23 KiB
Python
665 lines
23 KiB
Python
"""
|
||
Настройки «нашего судна» для Class B / B+ и сборка AIS-сообщений 18, 19, 24.
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import os
|
||
import re
|
||
import socket
|
||
import struct
|
||
import subprocess
|
||
import sys
|
||
import threading
|
||
import time
|
||
from typing import Any, Dict, List, Optional, Tuple
|
||
|
||
from bitarray import bitarray
|
||
|
||
try:
|
||
from pyais.messages import MSG_CLASS
|
||
except ImportError:
|
||
MSG_CLASS = {}
|
||
try:
|
||
from pyais.constants import EpfdType
|
||
except ImportError:
|
||
EpfdType = None # type: ignore
|
||
|
||
from ais_phy import (
|
||
ais_channel_to_nrzi_bytes,
|
||
hdlc_nrzi_bytes_no_preamble,
|
||
phy_frame_bit_counts,
|
||
)
|
||
|
||
try:
|
||
from ais_nrzi_pipeline import phy as _aistx_phy # type: ignore
|
||
except ImportError:
|
||
_aistx_phy = None
|
||
|
||
|
||
def is_aistx_phy_available() -> bool:
|
||
return _aistx_phy is not None
|
||
|
||
|
||
def _expand_nrzi_packed_msb(packed: bytes) -> bytes:
|
||
"""Один байт NRZI → 8 байт 0x00/0xFF (MSB первый)."""
|
||
out = bytearray()
|
||
for byte in packed:
|
||
for i in range(7, -1, -1):
|
||
out.append(0xFF if (byte >> i) & 1 else 0x00)
|
||
return bytes(out)
|
||
|
||
CONFIG_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "transponder_config.json")
|
||
_config_lock = threading.Lock()
|
||
|
||
# Фиксированная доставка NRZI (как тестовый слот / приёмник на устройстве).
|
||
NRZI_UDP_HOST = "127.0.0.1"
|
||
NRZI_UDP_PORT = 6010
|
||
|
||
DEFAULT_TRANSPONDER: Dict[str, Any] = {
|
||
"mmsi": 123456789,
|
||
"shipname": "MYSHIP",
|
||
"callsign": "CALLSG",
|
||
"ship_type": 37,
|
||
"to_bow": 10,
|
||
"to_stern": 10,
|
||
"to_port": 3,
|
||
"to_starboard": 3,
|
||
"vendorid": "1HZZZZ",
|
||
"model": 1,
|
||
"serial": 1,
|
||
"nrzi_mode": "packed",
|
||
# По умолчанию gr-aistx-цепочка; ais_phy — альтернатива (pyais CRC без reverse-byte).
|
||
"nrzi_encoder": "aistx",
|
||
"nrzi_preamble_bits": 24,
|
||
"include_nrzi_preamble": True,
|
||
# Как в GNU Radio: выравнивание payload до октета нулями; добор NRZ до N бит перед NRZI.
|
||
"nrzi_pad_payload_to_octet": True,
|
||
# GNU Radio часто 200; с преамбулой 24+HDLC NRZ обычно >200 бит — добор до 200 не меняет поток.
|
||
"nrzi_pad_nrz_bits": 256,
|
||
"use_gps_motion": True,
|
||
# Заголовок UDP как у «Тест слота»: 1 байт канал + uint16 LE слот + NRZI
|
||
"nrzi_slot_channel": "A",
|
||
"nrzi_slot": 0,
|
||
# После UDP: пауза 50–100 ms, затем запуск скрипта (напр. pulse_once.py на Orange Pi).
|
||
"tx_gpio_pulse_auto": False,
|
||
"tx_gpio_pulse_script": "",
|
||
"tx_gpio_pulse_delay_ms": 75,
|
||
}
|
||
|
||
|
||
def build_slot_udp_payload(channel: str, slot: int, nrzi_body: bytes) -> bytes:
|
||
"""Тот же формат, что /api/send_test_slot: ch(0=A,1=B) + slot<LE> + данные."""
|
||
ch = str(channel).strip().upper()
|
||
ch_byte = b"\x00" if ch == "A" else b"\x01"
|
||
try:
|
||
s = int(slot)
|
||
except (TypeError, ValueError):
|
||
s = 0
|
||
s = max(0, min(2249, s))
|
||
return ch_byte + struct.pack("<H", s) + nrzi_body
|
||
|
||
|
||
def load_transponder_config() -> Dict[str, Any]:
|
||
with _config_lock:
|
||
if not os.path.exists(CONFIG_PATH):
|
||
return dict(DEFAULT_TRANSPONDER)
|
||
try:
|
||
with open(CONFIG_PATH, "r", encoding="utf-8") as f:
|
||
data = json.load(f)
|
||
out = dict(DEFAULT_TRANSPONDER)
|
||
for k, v in data.items():
|
||
if k in DEFAULT_TRANSPONDER:
|
||
out[k] = v
|
||
return out
|
||
except (OSError, json.JSONDecodeError):
|
||
return dict(DEFAULT_TRANSPONDER)
|
||
|
||
|
||
def save_transponder_config(cfg: Dict[str, Any]) -> Dict[str, Any]:
|
||
merged = normalize_transponder_config(cfg)
|
||
with _config_lock:
|
||
with open(CONFIG_PATH, "w", encoding="utf-8") as f:
|
||
json.dump(merged, f, indent=2, ensure_ascii=False)
|
||
return merged
|
||
|
||
|
||
def normalize_transponder_config(cfg: Dict[str, Any]) -> Dict[str, Any]:
|
||
out = dict(DEFAULT_TRANSPONDER)
|
||
for k in DEFAULT_TRANSPONDER:
|
||
if k not in cfg:
|
||
continue
|
||
v = cfg[k]
|
||
if k in (
|
||
"mmsi",
|
||
"ship_type",
|
||
"to_bow",
|
||
"to_stern",
|
||
"to_port",
|
||
"to_starboard",
|
||
"model",
|
||
"serial",
|
||
):
|
||
try:
|
||
out[k] = int(v)
|
||
except (TypeError, ValueError):
|
||
out[k] = DEFAULT_TRANSPONDER[k]
|
||
elif k in ("use_gps_motion", "include_nrzi_preamble"):
|
||
if isinstance(v, str):
|
||
out[k] = v.strip().lower() in ("1", "true", "yes", "on")
|
||
else:
|
||
out[k] = bool(v)
|
||
elif k == "nrzi_mode":
|
||
s = str(v).lower()
|
||
out[k] = s if s in ("packed", "expanded") else "packed"
|
||
elif k == "nrzi_encoder":
|
||
s = str(v).strip().lower()
|
||
if s == "aistx" and _aistx_phy is None:
|
||
out[k] = "ais_phy"
|
||
else:
|
||
out[k] = s if s in ("ais_phy", "aistx") else DEFAULT_TRANSPONDER[k]
|
||
elif k == "nrzi_slot_channel":
|
||
s = str(v).strip().upper()
|
||
out[k] = s if s in ("A", "B") else DEFAULT_TRANSPONDER[k]
|
||
elif k == "nrzi_slot":
|
||
try:
|
||
si = int(v)
|
||
out[k] = max(0, min(2249, si))
|
||
except (TypeError, ValueError):
|
||
out[k] = DEFAULT_TRANSPONDER[k]
|
||
elif k == "nrzi_preamble_bits":
|
||
try:
|
||
n = int(v)
|
||
out[k] = max(0, min(128, n))
|
||
except (TypeError, ValueError):
|
||
out[k] = DEFAULT_TRANSPONDER[k]
|
||
elif k == "nrzi_pad_nrz_bits":
|
||
try:
|
||
n = int(v)
|
||
out[k] = max(0, min(4096, n))
|
||
except (TypeError, ValueError):
|
||
out[k] = DEFAULT_TRANSPONDER[k]
|
||
elif k == "nrzi_pad_payload_to_octet":
|
||
if isinstance(v, str):
|
||
out[k] = v.strip().lower() in ("1", "true", "yes", "on")
|
||
else:
|
||
out[k] = bool(v)
|
||
elif k in ("shipname", "callsign", "vendorid", "tx_gpio_pulse_script"):
|
||
out[k] = str(v) if v is not None else DEFAULT_TRANSPONDER[k]
|
||
elif k == "tx_gpio_pulse_auto":
|
||
if isinstance(v, str):
|
||
out[k] = v.strip().lower() in ("1", "true", "yes", "on")
|
||
else:
|
||
out[k] = bool(v)
|
||
elif k == "tx_gpio_pulse_delay_ms":
|
||
try:
|
||
n = int(v)
|
||
out[k] = max(50, min(100, n))
|
||
except (TypeError, ValueError):
|
||
out[k] = DEFAULT_TRANSPONDER[k]
|
||
else:
|
||
out[k] = v
|
||
return out
|
||
|
||
|
||
def merge_transponder_request(
|
||
base: Dict[str, Any], body: Optional[Dict[str, Any]]
|
||
) -> Dict[str, Any]:
|
||
merged = dict(base)
|
||
if body:
|
||
for k in DEFAULT_TRANSPONDER:
|
||
if k in body:
|
||
merged[k] = body[k]
|
||
return normalize_transponder_config(merged)
|
||
|
||
|
||
def _second_field() -> int:
|
||
return int(time.gmtime(time.time()).tm_sec) % 60
|
||
|
||
|
||
def _motion_from_ownship(cfg: Dict[str, Any], own: Dict[str, Any]) -> Tuple[float, float, float, float, int]:
|
||
lat = float(own.get("lat") or 0.0)
|
||
lon = float(own.get("lon") or 0.0)
|
||
speed = float(own.get("speed") or 0.0) if cfg.get("use_gps_motion", True) else 0.0
|
||
course = float(own.get("course") or 0.0) if cfg.get("use_gps_motion", True) else 0.0
|
||
heading = int(own.get("heading") or own.get("course") or 0) if cfg.get("use_gps_motion", True) else 0
|
||
heading = max(0, min(511, heading))
|
||
return lat, lon, speed, course, heading
|
||
|
||
|
||
def build_type18_dict(cfg: Dict[str, Any], own: Dict[str, Any]) -> Dict[str, Any]:
|
||
lat, lon, speed, course, heading = _motion_from_ownship(cfg, own)
|
||
return {
|
||
"msg_type": 18,
|
||
"repeat": 0,
|
||
"mmsi": int(cfg["mmsi"]),
|
||
"lat": lat,
|
||
"lon": lon,
|
||
"speed": speed,
|
||
"course": course,
|
||
"heading": heading,
|
||
"second": _second_field(),
|
||
}
|
||
|
||
|
||
def build_type19_dict(cfg: Dict[str, Any], own: Dict[str, Any]) -> Dict[str, Any]:
|
||
lat, lon, speed, course, heading = _motion_from_ownship(cfg, own)
|
||
epfd = EpfdType.GPS if EpfdType is not None else 1
|
||
return {
|
||
"msg_type": 19,
|
||
"repeat": 0,
|
||
"mmsi": int(cfg["mmsi"]),
|
||
"lat": lat,
|
||
"lon": lon,
|
||
"speed": speed,
|
||
"course": course,
|
||
"heading": heading,
|
||
"second": _second_field(),
|
||
"shipname": str(cfg.get("shipname") or "")[:20],
|
||
"ship_type": int(cfg.get("ship_type") or 0),
|
||
"to_bow": int(cfg.get("to_bow") or 0),
|
||
"to_stern": int(cfg.get("to_stern") or 0),
|
||
"to_port": int(cfg.get("to_port") or 0),
|
||
"to_starboard": int(cfg.get("to_starboard") or 0),
|
||
"epfd": epfd,
|
||
"raim": False,
|
||
"dte": False,
|
||
"assigned": False,
|
||
}
|
||
|
||
|
||
def build_type24a_dict(cfg: Dict[str, Any]) -> Dict[str, Any]:
|
||
return {
|
||
"msg_type": 24,
|
||
"repeat": 0,
|
||
"partno": 0,
|
||
"mmsi": int(cfg["mmsi"]),
|
||
"shipname": str(cfg.get("shipname") or "")[:20],
|
||
}
|
||
|
||
|
||
def build_type24b_dict(cfg: Dict[str, Any]) -> Dict[str, Any]:
|
||
vid = str(cfg.get("vendorid") or "")[:6]
|
||
if len(vid) < 6:
|
||
vid = (vid + "@@@@@@")[:6]
|
||
return {
|
||
"msg_type": 24,
|
||
"repeat": 0,
|
||
"partno": 1,
|
||
"mmsi": int(cfg["mmsi"]),
|
||
"ship_type": int(cfg.get("ship_type") or 0),
|
||
"vendorid": vid,
|
||
"model": int(cfg.get("model") or 0),
|
||
"serial": int(cfg.get("serial") or 0),
|
||
"callsign": str(cfg.get("callsign") or "")[:7],
|
||
"to_bow": int(cfg.get("to_bow") or 0),
|
||
"to_stern": int(cfg.get("to_stern") or 0),
|
||
"to_port": int(cfg.get("to_port") or 0),
|
||
"to_starboard": int(cfg.get("to_starboard") or 0),
|
||
}
|
||
|
||
|
||
def payload_bits_from_dict(
|
||
data: Dict[str, Any], *, pad_payload_to_octet: bool = False
|
||
) -> bitarray:
|
||
if not MSG_CLASS:
|
||
raise RuntimeError("pyais не установлен")
|
||
raw_t = data.get("msg_type", data.get("type"))
|
||
if raw_t is None:
|
||
raise ValueError("В данных AIS нужен msg_type (или устаревшее type)")
|
||
ais_type = int(raw_t)
|
||
# pyais Payload.create игнорирует неизвестные ключи; type/msg_type не являются полями attrs.
|
||
create_kw = {k: v for k, v in data.items() if k not in ("type", "msg_type")}
|
||
payload = MSG_CLASS[ais_type].create(**create_kw)
|
||
bits = payload.to_bitarray()
|
||
if len(bits) % 8 != 0 and not pad_payload_to_octet:
|
||
raise ValueError(f"Payload type {ais_type} has length {len(bits)} not multiple of 8")
|
||
return bits
|
||
|
||
|
||
def nrzi_bytes_for_payload(
|
||
data: Dict[str, Any],
|
||
mode: str,
|
||
*,
|
||
preamble_bits: int = 24,
|
||
pad_payload_to_octet: bool = False,
|
||
pad_nrz_total_bits: Optional[int] = None,
|
||
) -> bytes:
|
||
bits = payload_bits_from_dict(data, pad_payload_to_octet=pad_payload_to_octet)
|
||
return ais_channel_to_nrzi_bytes(
|
||
bits,
|
||
preamble_bits=preamble_bits,
|
||
nrzi_byte_mode=mode,
|
||
pad_payload_to_octet=pad_payload_to_octet,
|
||
pad_nrz_total_bits=pad_nrz_total_bits,
|
||
)
|
||
|
||
|
||
def nrzi_bytes_hdlc_only(
|
||
data: Dict[str, Any],
|
||
mode: str,
|
||
*,
|
||
pad_payload_to_octet: bool = False,
|
||
pad_nrz_total_bits: Optional[int] = None,
|
||
) -> bytes:
|
||
bits = payload_bits_from_dict(data, pad_payload_to_octet=pad_payload_to_octet)
|
||
return hdlc_nrzi_bytes_no_preamble(
|
||
bits,
|
||
nrzi_byte_mode=mode,
|
||
pad_payload_to_octet=pad_payload_to_octet,
|
||
pad_nrz_total_bits=pad_nrz_total_bits,
|
||
)
|
||
|
||
|
||
def _encode_nrzi_for_dict(
|
||
data: Dict[str, Any],
|
||
cfg: Dict[str, Any],
|
||
*,
|
||
include_preamble: bool,
|
||
mode: str,
|
||
pre_bits: int,
|
||
pad_oct: bool,
|
||
pad_nrz: Optional[int],
|
||
) -> bytes:
|
||
enc = str(cfg.get("nrzi_encoder") or DEFAULT_TRANSPONDER["nrzi_encoder"]).strip().lower()
|
||
if enc == "aistx" and _aistx_phy is not None:
|
||
bits = payload_bits_from_dict(data, pad_payload_to_octet=pad_oct)
|
||
if include_preamble:
|
||
fb = _aistx_phy.build_nrzi_frame(bits.to01(), enable_nrzi=True)
|
||
raw = _aistx_phy.nrzi_bits_to_bytes(fb)
|
||
if mode == "expanded":
|
||
raw = _expand_nrzi_packed_msb(raw)
|
||
return raw
|
||
return nrzi_bytes_hdlc_only(
|
||
data,
|
||
mode,
|
||
pad_payload_to_octet=pad_oct,
|
||
pad_nrz_total_bits=pad_nrz,
|
||
)
|
||
if include_preamble:
|
||
return nrzi_bytes_for_payload(
|
||
data,
|
||
mode,
|
||
preamble_bits=pre_bits,
|
||
pad_payload_to_octet=pad_oct,
|
||
pad_nrz_total_bits=pad_nrz,
|
||
)
|
||
return nrzi_bytes_hdlc_only(
|
||
data,
|
||
mode,
|
||
pad_payload_to_octet=pad_oct,
|
||
pad_nrz_total_bits=pad_nrz,
|
||
)
|
||
|
||
|
||
def parse_nrzi_hex(hex_text: str) -> bytes:
|
||
s = re.sub(r"[\s:,\n\r\t]+", "", (hex_text or "").strip())
|
||
if not s:
|
||
raise ValueError("Пустая hex-строка")
|
||
if len(s) % 2:
|
||
raise ValueError("Hex должен содержать чётное число символов")
|
||
try:
|
||
return bytes.fromhex(s)
|
||
except ValueError as e:
|
||
raise ValueError(f"Некорректный hex: {e}") from e
|
||
|
||
|
||
def _nrzi_pad_opts(cfg: Dict[str, Any]) -> Tuple[bool, Optional[int]]:
|
||
pad_oct = bool(cfg.get("nrzi_pad_payload_to_octet", True))
|
||
try:
|
||
n = int(cfg.get("nrzi_pad_nrz_bits", 256))
|
||
except (TypeError, ValueError):
|
||
n = 256
|
||
pad_nrz = None if n <= 0 else max(1, min(4096, n))
|
||
return pad_oct, pad_nrz
|
||
|
||
|
||
def _send_udp(host: str, port: int, data: bytes) -> None:
|
||
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||
try:
|
||
sock.sendto(data, (host, port))
|
||
finally:
|
||
sock.close()
|
||
|
||
|
||
def tx_gpio_pulse(
|
||
cfg: Dict[str, Any], *, after_udp: bool
|
||
) -> Dict[str, Any]:
|
||
"""
|
||
after_udp=True: только если tx_gpio_pulse_auto; пауза 50–100 ms после UDP, затем скрипт.
|
||
after_udp=False: ручной импульс (без паузы, без проверки auto).
|
||
"""
|
||
if after_udp and not bool(cfg.get("tx_gpio_pulse_auto")):
|
||
return {"skipped": True}
|
||
script = str(cfg.get("tx_gpio_pulse_script") or "").strip()
|
||
if not script:
|
||
if after_udp:
|
||
return {"skipped": True, "reason": "no_script"}
|
||
return {"ok": False, "error": "Не задан путь к скрипту импульса TX"}
|
||
if not os.path.isfile(script):
|
||
err = f"Файл не найден: {script}"
|
||
if after_udp:
|
||
return {"ok": False, "error": err}
|
||
return {"ok": False, "error": err}
|
||
if after_udp:
|
||
try:
|
||
ms = int(cfg.get("tx_gpio_pulse_delay_ms", 75))
|
||
except (TypeError, ValueError):
|
||
ms = 75
|
||
ms = max(50, min(100, ms))
|
||
time.sleep(ms / 1000.0)
|
||
try:
|
||
r = subprocess.run(
|
||
[sys.executable, script],
|
||
capture_output=True,
|
||
text=True,
|
||
timeout=15,
|
||
)
|
||
out: Dict[str, Any] = {
|
||
"ok": r.returncode == 0,
|
||
"returncode": r.returncode,
|
||
}
|
||
if r.stderr and r.stderr.strip():
|
||
out["stderr"] = r.stderr.strip()[:500]
|
||
if r.stdout and r.stdout.strip():
|
||
out["stdout"] = r.stdout.strip()[:300]
|
||
if r.returncode != 0 and not out.get("stderr"):
|
||
out["error"] = f"exit {r.returncode}"
|
||
return out
|
||
except subprocess.TimeoutExpired:
|
||
return {"ok": False, "error": "GPIO script timeout"}
|
||
except OSError as e:
|
||
return {"ok": False, "error": str(e)}
|
||
|
||
|
||
def _append_gpio_result(sent: Dict[str, Any], pulse: Dict[str, Any]) -> None:
|
||
if pulse.get("skipped"):
|
||
return
|
||
lst: List[Dict[str, Any]] = sent.setdefault("gpio_pulse", []) # type: ignore[assignment]
|
||
lst.append(pulse)
|
||
if not pulse.get("ok"):
|
||
err = pulse.get("error") or pulse.get("stderr") or f"code {pulse.get('returncode')}"
|
||
sent["errors"].append(f"GPIO TX: {err}")
|
||
|
||
|
||
def send_raw_nrzi_packet(
|
||
channel: str, slot: int, nrzi_body: bytes, *, cfg: Optional[Dict[str, Any]] = None
|
||
) -> Dict[str, Any]:
|
||
"""UDP: канал + слот + сырой NRZI (как тест слота)."""
|
||
ch = str(channel).strip().upper()
|
||
if ch not in ("A", "B"):
|
||
raise ValueError("channel must be A or B")
|
||
try:
|
||
slot_n = int(slot)
|
||
except (TypeError, ValueError):
|
||
slot_n = 0
|
||
slot_n = max(0, min(2249, slot_n))
|
||
packet = build_slot_udp_payload(ch, slot_n, nrzi_body)
|
||
_send_udp(NRZI_UDP_HOST, NRZI_UDP_PORT, packet)
|
||
out: Dict[str, Any] = {
|
||
"dest": f"{NRZI_UDP_HOST}:{NRZI_UDP_PORT}",
|
||
"slot_channel": ch,
|
||
"slot": slot_n,
|
||
"payload_bytes": len(nrzi_body),
|
||
"udp_bytes": len(packet),
|
||
"errors": [],
|
||
}
|
||
if cfg is not None:
|
||
_append_gpio_result(out, tx_gpio_pulse(cfg, after_udp=True))
|
||
return out
|
||
|
||
|
||
def send_transmission(cfg: Dict[str, Any], own: Dict[str, Any], which: str) -> Dict[str, Any]:
|
||
"""
|
||
Только NRZI по UDP на NRZI_UDP_HOST:NRZI_UDP_PORT.
|
||
which: '18', '19', '24A', '24B', 'broadcast'
|
||
"""
|
||
mode = cfg.get("nrzi_mode") or "packed"
|
||
ch = str(cfg.get("nrzi_slot_channel") or "A").strip().upper()
|
||
if ch not in ("A", "B"):
|
||
ch = "A"
|
||
try:
|
||
slot_n = int(cfg.get("nrzi_slot", 0))
|
||
except (TypeError, ValueError):
|
||
slot_n = 0
|
||
slot_n = max(0, min(2249, slot_n))
|
||
|
||
sent: Dict[str, Any] = {
|
||
"nrzi_bytes": 0,
|
||
"errors": [],
|
||
"dest": f"{NRZI_UDP_HOST}:{NRZI_UDP_PORT}",
|
||
"slot_channel": ch,
|
||
"slot": slot_n,
|
||
}
|
||
include_preamble = bool(cfg.get("include_nrzi_preamble", True))
|
||
try:
|
||
pre_bits = int(cfg.get("nrzi_preamble_bits", 24))
|
||
except (TypeError, ValueError):
|
||
pre_bits = 24
|
||
pre_bits = max(0, min(128, pre_bits))
|
||
pad_oct, pad_nrz = _nrzi_pad_opts(cfg)
|
||
|
||
def one(data: Dict[str, Any], label: str) -> None:
|
||
try:
|
||
raw = _encode_nrzi_for_dict(
|
||
data,
|
||
cfg,
|
||
include_preamble=include_preamble,
|
||
mode=mode,
|
||
pre_bits=pre_bits,
|
||
pad_oct=pad_oct,
|
||
pad_nrz=pad_nrz,
|
||
)
|
||
packet = build_slot_udp_payload(ch, slot_n, raw)
|
||
_send_udp(NRZI_UDP_HOST, NRZI_UDP_PORT, packet)
|
||
sent["nrzi_bytes"] += len(packet)
|
||
_append_gpio_result(sent, tx_gpio_pulse(cfg, after_udp=True))
|
||
except Exception as e:
|
||
sent["errors"].append(f"NRZI {label}: {e}")
|
||
|
||
if which == "broadcast":
|
||
one(build_type18_dict(cfg, own), "18")
|
||
one(build_type19_dict(cfg, own), "19")
|
||
one(build_type24a_dict(cfg), "24A")
|
||
one(build_type24b_dict(cfg), "24B")
|
||
elif which == "18":
|
||
one(build_type18_dict(cfg, own), "18")
|
||
elif which == "19":
|
||
one(build_type19_dict(cfg, own), "19")
|
||
elif which == "24A":
|
||
one(build_type24a_dict(cfg), "24A")
|
||
elif which == "24B":
|
||
one(build_type24b_dict(cfg), "24B")
|
||
else:
|
||
raise ValueError("which must be 18, 19, 24A, 24B, broadcast")
|
||
|
||
return sent
|
||
|
||
|
||
def build_preview(cfg: Dict[str, Any], own: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""NRZI (hex) для типов 18, 19, 24A, 24B; отправка — на 127.0.0.1:6010."""
|
||
if not MSG_CLASS:
|
||
raise RuntimeError("pyais не установлен")
|
||
mode = cfg.get("nrzi_mode") or "packed"
|
||
include_preamble = bool(cfg.get("include_nrzi_preamble", True))
|
||
try:
|
||
pre_bits = int(cfg.get("nrzi_preamble_bits", 24))
|
||
except (TypeError, ValueError):
|
||
pre_bits = 24
|
||
pre_bits = max(0, min(128, pre_bits))
|
||
pad_oct, pad_nrz = _nrzi_pad_opts(cfg)
|
||
|
||
d18 = build_type18_dict(cfg, own)
|
||
d19 = build_type19_dict(cfg, own)
|
||
d24a = build_type24a_dict(cfg)
|
||
d24b = build_type24b_dict(cfg)
|
||
|
||
ch = str(cfg.get("nrzi_slot_channel") or "A").strip().upper()
|
||
if ch not in ("A", "B"):
|
||
ch = "A"
|
||
try:
|
||
slot_n = int(cfg.get("nrzi_slot", 0))
|
||
except (TypeError, ValueError):
|
||
slot_n = 0
|
||
slot_n = max(0, min(2249, slot_n))
|
||
|
||
out: Dict[str, Any] = {
|
||
"nrzi_hex": {},
|
||
"udp_frame_hex": {},
|
||
"dest": f"{NRZI_UDP_HOST}:{NRZI_UDP_PORT}",
|
||
"slot_channel": ch,
|
||
"slot": slot_n,
|
||
"phy": {
|
||
"preamble_bits": pre_bits if include_preamble else 0,
|
||
"include_preamble": include_preamble,
|
||
"nrzi_mode": mode,
|
||
"nrzi_encoder": str(cfg.get("nrzi_encoder") or DEFAULT_TRANSPONDER["nrzi_encoder"]),
|
||
"aistx_phy_note": (
|
||
"Кодер aistx: ais_nrzi_pipeline/phy.py (reverse bits, CRC как gr-aistx, кадр до 256 бит)."
|
||
if str(cfg.get("nrzi_encoder") or "").lower() == "aistx"
|
||
else None
|
||
),
|
||
"fcs": "CRC-16-CCITT poly 0x1021, init 0xFFFF, XOROUT 0xFFFF; 16 бит FCS в потоке MSB первым",
|
||
"hdlc": "флаги 0x7E, bit stuffing между флагами",
|
||
"nrzi": "0 — переключение уровня, 1 — без изменения",
|
||
"packed": "8 NRZI-сэмплов на байт, первый бит — MSB байта (для UDP)",
|
||
"test_slot_note": (
|
||
"«Тест слота» шлёт фиксированный TEST_AIS_NRZI (32 B, проверен на передатчике). "
|
||
"NRZI ниже — по умолчанию ais_nrzi_pipeline/phy.py (gr-aistx); при выборе ais_phy — другая CRC/битовый порядок."
|
||
),
|
||
"pad_payload_to_octet": pad_oct,
|
||
"pad_nrz_total_bits": pad_nrz,
|
||
"per_message": {},
|
||
},
|
||
}
|
||
enc_ui = str(cfg.get("nrzi_encoder") or DEFAULT_TRANSPONDER["nrzi_encoder"]).strip().lower()
|
||
for key, d in [("18", d18), ("19", d19), ("24A", d24a), ("24B", d24b)]:
|
||
bits = payload_bits_from_dict(d, pad_payload_to_octet=pad_oct)
|
||
if enc_ui == "aistx" and _aistx_phy is not None:
|
||
plen = len(bits)
|
||
padb = (8 - (plen % 8)) % 8
|
||
out["phy"]["per_message"][key] = {
|
||
"payload_bits_input": plen,
|
||
"payload_bits_after_pad": plen + padb,
|
||
"encoder": "aistx",
|
||
"hdlc_note": "статы HDLC/stuff — см. phy.py (gr-aistx)",
|
||
}
|
||
else:
|
||
out["phy"]["per_message"][key] = phy_frame_bit_counts(
|
||
bits, pad_payload_to_octet=pad_oct
|
||
)
|
||
raw = _encode_nrzi_for_dict(
|
||
d,
|
||
cfg,
|
||
include_preamble=include_preamble,
|
||
mode=mode,
|
||
pre_bits=pre_bits,
|
||
pad_oct=pad_oct,
|
||
pad_nrz=pad_nrz,
|
||
)
|
||
out["nrzi_hex"][key] = raw.hex()
|
||
out["udp_frame_hex"][key] = build_slot_udp_payload(ch, slot_n, raw).hex()
|
||
out["phy"]["per_message"][key]["nrzi_packed_bytes"] = len(raw)
|
||
out["phy"]["per_message"][key]["udp_total_bytes"] = 3 + len(raw)
|
||
return out
|