636 lines
22 KiB
Python
636 lines
22 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
GNSS Sky Plot Viewer
|
||
Unterstützt UBX über serielle Schnittstelle UND TCP/IP (Ser2net).
|
||
"""
|
||
|
||
import sys
|
||
import struct
|
||
import socket
|
||
import serial
|
||
import serial.tools.list_ports
|
||
import math
|
||
from PyQt5.QtWidgets import (
|
||
QApplication, QMainWindow, QWidget, QVBoxLayout,
|
||
QHBoxLayout, QLabel, QComboBox, QPushButton,
|
||
QStatusBar, QTableWidget, QTableWidgetItem,
|
||
QHeaderView, QSplitter, QTabWidget, QLineEdit,
|
||
QSpinBox, QFormLayout, QGroupBox,
|
||
)
|
||
from PyQt5.QtCore import Qt, QThread, pyqtSignal
|
||
from PyQt5.QtGui import (
|
||
QPainter, QPen, QBrush, QColor, QFont,
|
||
QRadialGradient,
|
||
)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# UBX Protokoll-Konstanten
|
||
# ---------------------------------------------------------------------------
|
||
UBX_SYNC1 = 0xB5
|
||
UBX_SYNC2 = 0x62
|
||
UBX_CLASS_NAV = 0x01
|
||
UBX_ID_NAV_SAT = 0x35
|
||
UBX_ID_NAV_SVINFO = 0x30
|
||
|
||
GNSS_NAMES = {
|
||
0: "GPS",
|
||
1: "SBAS",
|
||
2: "Galileo",
|
||
3: "BeiDou",
|
||
4: "IMES",
|
||
5: "QZSS",
|
||
6: "GLONASS",
|
||
}
|
||
|
||
GNSS_COLORS = {
|
||
0: QColor("#1E90FF"),
|
||
1: QColor("#FFA500"),
|
||
2: QColor("#00C853"),
|
||
3: QColor("#E53935"),
|
||
4: QColor("#9C27B0"),
|
||
5: QColor("#00BCD4"),
|
||
6: QColor("#FF4081"),
|
||
}
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# UBX Hilfsfunktionen
|
||
# ---------------------------------------------------------------------------
|
||
def ubx_checksum(payload: bytes) -> tuple[int, int]:
|
||
ck_a = ck_b = 0
|
||
for b in payload:
|
||
ck_a = (ck_a + b) & 0xFF
|
||
ck_b = (ck_b + ck_a) & 0xFF
|
||
return ck_a, ck_b
|
||
|
||
|
||
def build_ubx(cls: int, msg_id: int, payload: bytes = b"") -> bytes:
|
||
header = bytes([UBX_SYNC1, UBX_SYNC2, cls, msg_id])
|
||
length = struct.pack("<H", len(payload))
|
||
raw = bytes([cls, msg_id]) + length + payload
|
||
ck_a, ck_b = ubx_checksum(raw)
|
||
return header + length + payload + bytes([ck_a, ck_b])
|
||
|
||
|
||
def build_poll(cls: int, msg_id: int) -> bytes:
|
||
return build_ubx(cls, msg_id, b"")
|
||
|
||
|
||
def parse_ubx_frames(data: bytes) -> list[dict]:
|
||
frames, i = [], 0
|
||
while i < len(data) - 7:
|
||
if data[i] == UBX_SYNC1 and data[i + 1] == UBX_SYNC2:
|
||
if i + 6 > len(data):
|
||
break
|
||
cls = data[i + 2]
|
||
msg_id = data[i + 3]
|
||
length = struct.unpack_from("<H", data, i + 4)[0]
|
||
end = i + 6 + length + 2
|
||
if end > len(data):
|
||
break
|
||
payload = data[i + 6: i + 6 + length]
|
||
raw_chk = data[i + 2: i + 6 + length]
|
||
ck_a, ck_b = ubx_checksum(raw_chk)
|
||
if ck_a == data[end - 2] and ck_b == data[end - 1]:
|
||
frames.append({"cls": cls, "id": msg_id, "payload": payload})
|
||
i = end
|
||
else:
|
||
i += 1
|
||
return frames
|
||
|
||
|
||
def parse_nav_sat(payload: bytes) -> list[dict]:
|
||
if len(payload) < 8:
|
||
return []
|
||
num_svs = payload[5]
|
||
sats = []
|
||
for n in range(num_svs):
|
||
off = 8 + n * 12
|
||
if off + 12 > len(payload):
|
||
break
|
||
gnss_id, sv_id, cno, elev, azim, _, flags = struct.unpack_from(
|
||
"<BBBbhiI", payload, off
|
||
)
|
||
sats.append({
|
||
"gnssId": gnss_id, "svId": sv_id, "cno": cno,
|
||
"elev": elev, "azim": azim, "used": bool(flags & 0x08),
|
||
})
|
||
return sats
|
||
|
||
|
||
def parse_nav_svinfo(payload: bytes) -> list[dict]:
|
||
if len(payload) < 8:
|
||
return []
|
||
num_ch = payload[4]
|
||
sats = []
|
||
for n in range(num_ch):
|
||
off = 8 + n * 12
|
||
if off + 12 > len(payload):
|
||
break
|
||
_, svid, flags, _, cno, elev, azim, _ = struct.unpack_from(
|
||
"<BBBBBbhI", payload, off
|
||
)
|
||
sats.append({
|
||
"gnssId": 0, "svId": svid, "cno": cno,
|
||
"elev": elev, "azim": azim, "used": bool(flags & 0x01),
|
||
})
|
||
return sats
|
||
|
||
|
||
def extract_satellites(frames: list[dict]) -> list[dict]:
|
||
for f in frames:
|
||
if f["cls"] == UBX_CLASS_NAV and f["id"] == UBX_ID_NAV_SAT:
|
||
return parse_nav_sat(f["payload"])
|
||
if f["cls"] == UBX_CLASS_NAV and f["id"] == UBX_ID_NAV_SVINFO:
|
||
return parse_nav_svinfo(f["payload"])
|
||
return []
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Abstrakte Transport-Basisklasse
|
||
# ---------------------------------------------------------------------------
|
||
class GnssTransport:
|
||
"""Gemeinsame Lese-/Schreibschnittstelle für seriell und TCP."""
|
||
|
||
def read(self, n: int) -> bytes:
|
||
raise NotImplementedError
|
||
|
||
def write(self, data: bytes) -> None:
|
||
raise NotImplementedError
|
||
|
||
def close(self) -> None:
|
||
raise NotImplementedError
|
||
|
||
|
||
class SerialTransport(GnssTransport):
|
||
def __init__(self, port: str, baudrate: int):
|
||
self._ser = serial.Serial(port, baudrate, timeout=1)
|
||
|
||
def read(self, n: int) -> bytes:
|
||
return self._ser.read(n)
|
||
|
||
def write(self, data: bytes) -> None:
|
||
self._ser.write(data)
|
||
|
||
def close(self) -> None:
|
||
if self._ser.is_open:
|
||
self._ser.close()
|
||
|
||
|
||
class TcpTransport(GnssTransport):
|
||
def __init__(self, host: str, port: int, timeout: float = 5.0):
|
||
self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||
self._sock.settimeout(timeout)
|
||
self._sock.connect((host, port))
|
||
self._sock.settimeout(1.0) # blockierendes Lesen mit 1 s Timeout
|
||
|
||
def read(self, n: int) -> bytes:
|
||
try:
|
||
return self._sock.recv(n)
|
||
except socket.timeout:
|
||
return b""
|
||
|
||
def write(self, data: bytes) -> None:
|
||
self._sock.sendall(data)
|
||
|
||
def close(self) -> None:
|
||
try:
|
||
self._sock.shutdown(socket.SHUT_RDWR)
|
||
except OSError:
|
||
pass
|
||
self._sock.close()
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Einheitlicher GNSS-Lese-Thread
|
||
# ---------------------------------------------------------------------------
|
||
class GnssReader(QThread):
|
||
satellites_updated = pyqtSignal(list)
|
||
error_occurred = pyqtSignal(str)
|
||
connected = pyqtSignal(str)
|
||
|
||
def __init__(self, transport_factory):
|
||
"""
|
||
transport_factory: callable ohne Argumente, das ein GnssTransport
|
||
zurückgibt oder eine Exception wirft.
|
||
"""
|
||
super().__init__()
|
||
self._factory = transport_factory
|
||
self._running = False
|
||
self._transport = None
|
||
|
||
def run(self):
|
||
self._running = True
|
||
buf = b""
|
||
try:
|
||
self._transport = self._factory()
|
||
self.connected.emit("Verbunden")
|
||
poll_msg = build_poll(UBX_CLASS_NAV, UBX_ID_NAV_SAT)
|
||
self._transport.write(poll_msg)
|
||
|
||
while self._running:
|
||
chunk = self._transport.read(512)
|
||
if chunk:
|
||
buf += chunk
|
||
if len(buf) > 8192:
|
||
buf = buf[-1024:]
|
||
frames = parse_ubx_frames(buf)
|
||
sats = extract_satellites(frames)
|
||
if sats:
|
||
self.satellites_updated.emit(sats)
|
||
else:
|
||
# Kein Datum – erneut pollen
|
||
self._transport.write(poll_msg)
|
||
|
||
except (serial.SerialException, OSError, ConnectionRefusedError,
|
||
socket.timeout, socket.gaierror) as exc:
|
||
self.error_occurred.emit(str(exc))
|
||
finally:
|
||
if self._transport:
|
||
self._transport.close()
|
||
|
||
def stop(self):
|
||
self._running = False
|
||
self.wait(3000)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Sky-Plot Widget
|
||
# ---------------------------------------------------------------------------
|
||
class SkyPlotWidget(QWidget):
|
||
def __init__(self, parent=None):
|
||
super().__init__(parent)
|
||
self._satellites = []
|
||
self.setMinimumSize(400, 400)
|
||
self.setStyleSheet("background-color: #1a1a2e;")
|
||
|
||
def update_satellites(self, sats: list):
|
||
self._satellites = sats
|
||
self.update()
|
||
|
||
def paintEvent(self, event):
|
||
painter = QPainter(self)
|
||
painter.setRenderHint(QPainter.Antialiasing)
|
||
w, h = self.width(), self.height()
|
||
cx, cy = w / 2, h / 2
|
||
radius = min(w, h) / 2 - 30
|
||
self._draw_background(painter, cx, cy, radius)
|
||
self._draw_grid(painter, cx, cy, radius)
|
||
self._draw_satellites(painter, cx, cy, radius)
|
||
self._draw_legend(painter)
|
||
|
||
def _draw_background(self, painter, cx, cy, radius):
|
||
grad = QRadialGradient(cx, cy, radius)
|
||
grad.setColorAt(0.0, QColor("#0d1b2a"))
|
||
grad.setColorAt(1.0, QColor("#1a1a2e"))
|
||
painter.setBrush(QBrush(grad))
|
||
painter.setPen(Qt.NoPen)
|
||
painter.drawEllipse(
|
||
int(cx - radius), int(cy - radius),
|
||
int(radius * 2), int(radius * 2),
|
||
)
|
||
|
||
def _draw_grid(self, painter, cx, cy, radius):
|
||
pen = QPen(QColor("#2a4a6a"), 1, Qt.DashLine)
|
||
painter.setPen(pen)
|
||
painter.setFont(QFont("Monospace", 8))
|
||
for elev in (0, 30, 60):
|
||
r = radius * (1 - elev / 90)
|
||
painter.drawEllipse(int(cx - r), int(cy - r), int(r * 2), int(r * 2))
|
||
painter.setPen(QColor("#4a7a9b"))
|
||
painter.drawText(int(cx + 4), int(cy - r), f"{elev}°")
|
||
painter.setPen(pen)
|
||
for azim in range(0, 360, 45):
|
||
rad = math.radians(azim)
|
||
painter.drawLine(
|
||
int(cx + math.sin(rad) * radius * 0.05),
|
||
int(cy - math.cos(rad) * radius * 0.05),
|
||
int(cx + math.sin(rad) * radius),
|
||
int(cy - math.cos(rad) * radius),
|
||
)
|
||
painter.setPen(QColor("#7ab7d4"))
|
||
painter.setFont(QFont("Monospace", 10, QFont.Bold))
|
||
for label, azim in (("N", 0), ("O", 90), ("S", 180), ("W", 270)):
|
||
rad = math.radians(azim)
|
||
painter.drawText(
|
||
int(cx + math.sin(rad) * (radius + 15) - 6),
|
||
int(cy - math.cos(rad) * (radius + 15) + 5),
|
||
label,
|
||
)
|
||
|
||
@staticmethod
|
||
def _az_el_to_xy(azim, elev, cx, cy, radius):
|
||
r = radius * (1 - elev / 90)
|
||
rad = math.radians(azim)
|
||
return cx + math.sin(rad) * r, cy - math.cos(rad) * r
|
||
|
||
def _draw_satellites(self, painter, cx, cy, radius):
|
||
for sat in self._satellites:
|
||
if sat["elev"] < 0:
|
||
continue
|
||
color = GNSS_COLORS.get(sat["gnssId"], QColor("#ffffff"))
|
||
x, y = self._az_el_to_xy(sat["azim"], sat["elev"], cx, cy, radius)
|
||
cno = max(0, min(50, sat["cno"]))
|
||
dot_r = 4 + int(cno / 50 * 8)
|
||
|
||
glow = QColor(color)
|
||
glow.setAlpha(60)
|
||
painter.setBrush(QBrush(glow))
|
||
painter.setPen(Qt.NoPen)
|
||
painter.drawEllipse(
|
||
int(x - dot_r * 1.8), int(y - dot_r * 1.8),
|
||
int(dot_r * 3.6), int(dot_r * 3.6),
|
||
)
|
||
if sat["used"]:
|
||
painter.setBrush(QBrush(color))
|
||
painter.setPen(QPen(QColor("#ffffff"), 1))
|
||
else:
|
||
faded = QColor(color)
|
||
faded.setAlpha(120)
|
||
painter.setBrush(QBrush(faded))
|
||
painter.setPen(QPen(color, 1, Qt.DashLine))
|
||
painter.drawEllipse(int(x - dot_r), int(y - dot_r), dot_r * 2, dot_r * 2)
|
||
painter.setPen(QColor("#ffffff"))
|
||
painter.setFont(QFont("Monospace", 7))
|
||
painter.drawText(int(x + dot_r + 2), int(y + 4), str(sat["svId"]))
|
||
|
||
def _draw_legend(self, painter):
|
||
painter.setFont(QFont("Monospace", 8))
|
||
x, y = 10, 20
|
||
for gnss_id, name in GNSS_NAMES.items():
|
||
color = GNSS_COLORS[gnss_id]
|
||
painter.setBrush(QBrush(color))
|
||
painter.setPen(Qt.NoPen)
|
||
painter.drawEllipse(x, y - 8, 10, 10)
|
||
painter.setPen(QColor("#cccccc"))
|
||
painter.drawText(x + 14, y, name)
|
||
y += 16
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Satelliten-Tabelle
|
||
# ---------------------------------------------------------------------------
|
||
class SatelliteTable(QTableWidget):
|
||
HEADERS = ["GNSS", "SV", "Elevation", "Azimut", "C/N₀ (dB)", "Genutzt"]
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__(0, len(self.HEADERS), parent)
|
||
self.setHorizontalHeaderLabels(self.HEADERS)
|
||
self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
|
||
self.setStyleSheet("""
|
||
QTableWidget {
|
||
background-color: #0d1b2a; color: #cccccc;
|
||
gridline-color: #2a4a6a; font-family: monospace; font-size: 11px;
|
||
}
|
||
QHeaderView::section {
|
||
background-color: #1a3a5c; color: #7ab7d4; padding: 4px;
|
||
}
|
||
""")
|
||
self.setEditTriggers(QTableWidget.NoEditTriggers)
|
||
self.setSelectionBehavior(QTableWidget.SelectRows)
|
||
|
||
def update_satellites(self, sats: list):
|
||
self.setRowCount(0)
|
||
for sat in sorted(sats, key=lambda s: (s["gnssId"], s["svId"])):
|
||
row = self.rowCount()
|
||
self.insertRow(row)
|
||
color = GNSS_COLORS.get(sat["gnssId"], QColor("#ffffff"))
|
||
vals = [
|
||
GNSS_NAMES.get(sat["gnssId"], f"?({sat['gnssId']})"),
|
||
str(sat["svId"]),
|
||
f"{sat['elev']}°",
|
||
f"{sat['azim']}°",
|
||
str(sat["cno"]),
|
||
"✓" if sat["used"] else "–",
|
||
]
|
||
for col, val in enumerate(vals):
|
||
item = QTableWidgetItem(val)
|
||
item.setForeground(color if col == 0 else QColor("#cccccc"))
|
||
if sat["used"]:
|
||
item.setBackground(QColor("#0d2a1a"))
|
||
self.setItem(row, col, item)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Verbindungs-Panel (Tabs: Seriell | TCP/IP)
|
||
# ---------------------------------------------------------------------------
|
||
FIELD_STYLE = """
|
||
QLineEdit, QComboBox, QSpinBox {
|
||
background-color: #0d1b2a;
|
||
color: #cccccc;
|
||
border: 1px solid #2a4a6a;
|
||
padding: 3px 6px;
|
||
border-radius: 3px;
|
||
}
|
||
"""
|
||
|
||
class ConnectionPanel(QGroupBox):
|
||
"""Gibt über connect_requested ein transport_factory-Callable zurück."""
|
||
|
||
connect_requested = pyqtSignal(object, str) # (factory, label)
|
||
disconnect_requested = pyqtSignal()
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__("Verbindung", parent)
|
||
self.setStyleSheet("""
|
||
QGroupBox { color: #7ab7d4; border: 1px solid #2a4a6a;
|
||
border-radius: 4px; margin-top: 8px; padding: 6px; }
|
||
QGroupBox::title { subcontrol-origin: margin; left: 8px; }
|
||
""" + FIELD_STYLE)
|
||
self._build_ui()
|
||
|
||
def _build_ui(self):
|
||
root = QVBoxLayout(self)
|
||
|
||
# Tabs
|
||
self._tabs = QTabWidget()
|
||
self._tabs.setStyleSheet("""
|
||
QTabBar::tab { background: #1a3a5c; color: #cccccc;
|
||
padding: 4px 12px; border-radius: 3px; }
|
||
QTabBar::tab:selected { background: #2a5a8c; color: #ffffff; }
|
||
""")
|
||
|
||
# --- Tab: Seriell ---
|
||
serial_widget = QWidget()
|
||
serial_form = QFormLayout(serial_widget)
|
||
serial_form.setContentsMargins(6, 6, 6, 6)
|
||
|
||
self._port_combo = QComboBox()
|
||
self._port_combo.setMinimumWidth(200)
|
||
refresh_btn = QPushButton("⟳")
|
||
refresh_btn.setFixedWidth(28)
|
||
refresh_btn.clicked.connect(self._refresh_ports)
|
||
port_row = QHBoxLayout()
|
||
port_row.addWidget(self._port_combo)
|
||
port_row.addWidget(refresh_btn)
|
||
serial_form.addRow("Port:", port_row)
|
||
|
||
self._baud_combo = QComboBox()
|
||
for b in ("9600", "19200", "38400", "57600", "115200", "230400", "460800"):
|
||
self._baud_combo.addItem(b)
|
||
self._baud_combo.setCurrentText("9600")
|
||
serial_form.addRow("Baudrate:", self._baud_combo)
|
||
|
||
self._tabs.addTab(serial_widget, "🔌 Seriell")
|
||
|
||
# --- Tab: TCP/IP ---
|
||
tcp_widget = QWidget()
|
||
tcp_form = QFormLayout(tcp_widget)
|
||
tcp_form.setContentsMargins(6, 6, 6, 6)
|
||
|
||
self._tcp_host = QLineEdit("192.168.1.100")
|
||
self._tcp_host.setPlaceholderText("IP-Adresse oder Hostname")
|
||
tcp_form.addRow("Host:", self._tcp_host)
|
||
|
||
self._tcp_port = QSpinBox()
|
||
self._tcp_port.setRange(1, 65535)
|
||
self._tcp_port.setValue(2947) # gpsd-Standard; Ser2net oft 4001
|
||
tcp_form.addRow("Port:", self._tcp_port)
|
||
|
||
self._tcp_timeout = QSpinBox()
|
||
self._tcp_timeout.setRange(1, 30)
|
||
self._tcp_timeout.setValue(5)
|
||
self._tcp_timeout.setSuffix(" s")
|
||
tcp_form.addRow("Timeout:", self._tcp_timeout)
|
||
|
||
self._tabs.addTab(tcp_widget, "🌐 TCP/IP")
|
||
|
||
root.addWidget(self._tabs)
|
||
|
||
# Verbinden-Knopf
|
||
btn_row = QHBoxLayout()
|
||
self._connect_btn = QPushButton("▶ Verbinden")
|
||
self._connect_btn.clicked.connect(self._on_connect_clicked)
|
||
btn_row.addStretch()
|
||
btn_row.addWidget(self._connect_btn)
|
||
root.addLayout(btn_row)
|
||
|
||
self._refresh_ports()
|
||
|
||
def _refresh_ports(self):
|
||
self._port_combo.clear()
|
||
for p in serial.tools.list_ports.comports():
|
||
self._port_combo.addItem(f"{p.device} – {p.description}", p.device)
|
||
if self._port_combo.count() == 0:
|
||
self._port_combo.addItem("Kein Port gefunden", None)
|
||
|
||
def _on_connect_clicked(self):
|
||
if self._connect_btn.text().startswith("■"):
|
||
self.disconnect_requested.emit()
|
||
return
|
||
|
||
if self._tabs.currentIndex() == 0:
|
||
# Seriell
|
||
port = self._port_combo.currentData()
|
||
baud = int(self._baud_combo.currentText())
|
||
if not port:
|
||
return
|
||
factory = lambda p=port, b=baud: SerialTransport(p, b)
|
||
label = f"{port} @ {baud} Baud"
|
||
else:
|
||
# TCP/IP
|
||
host = self._tcp_host.text().strip()
|
||
port = self._tcp_port.value()
|
||
timeout = self._tcp_timeout.value()
|
||
if not host:
|
||
return
|
||
factory = lambda h=host, p=port, t=timeout: TcpTransport(h, p, t)
|
||
label = f"{host}:{port}"
|
||
|
||
self.connect_requested.emit(factory, label)
|
||
|
||
def set_connected(self, connected: bool):
|
||
self._connect_btn.setText("■ Trennen" if connected else "▶ Verbinden")
|
||
self._tabs.setEnabled(not connected)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Hauptfenster
|
||
# ---------------------------------------------------------------------------
|
||
class MainWindow(QMainWindow):
|
||
def __init__(self):
|
||
super().__init__()
|
||
self.setWindowTitle("GNSS Sky Plot – UBX | Seriell + TCP/IP")
|
||
self.resize(980, 680)
|
||
self.setStyleSheet("background-color: #12192b; color: #cccccc;")
|
||
self._reader = None
|
||
self._build_ui()
|
||
|
||
def _build_ui(self):
|
||
central = QWidget()
|
||
self.setCentralWidget(central)
|
||
root = QVBoxLayout(central)
|
||
root.setContentsMargins(8, 8, 8, 8)
|
||
|
||
# --- Obere Leiste ---
|
||
top = QHBoxLayout()
|
||
|
||
self._conn_panel = ConnectionPanel()
|
||
self._conn_panel.connect_requested.connect(self._connect)
|
||
self._conn_panel.disconnect_requested.connect(self._disconnect)
|
||
top.addWidget(self._conn_panel)
|
||
|
||
self._sat_label = QLabel("Satelliten: –")
|
||
self._sat_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
|
||
self._sat_label.setStyleSheet("font-size: 13px; color: #7ab7d4;")
|
||
top.addStretch()
|
||
top.addWidget(self._sat_label)
|
||
|
||
root.addLayout(top)
|
||
|
||
# --- Splitter: Sky Plot | Tabelle ---
|
||
splitter = QSplitter(Qt.Horizontal)
|
||
self._sky_plot = SkyPlotWidget()
|
||
self._table = SatelliteTable()
|
||
splitter.addWidget(self._sky_plot)
|
||
splitter.addWidget(self._table)
|
||
splitter.setSizes([540, 380])
|
||
root.addWidget(splitter)
|
||
|
||
self._status = QStatusBar()
|
||
self.setStatusBar(self._status)
|
||
self._status.showMessage("Nicht verbunden.")
|
||
|
||
def _connect(self, factory, label: str):
|
||
self._reader = GnssReader(factory)
|
||
self._reader.satellites_updated.connect(self._on_satellites)
|
||
self._reader.error_occurred.connect(self._on_error)
|
||
self._reader.connected.connect(
|
||
lambda msg: self._status.showMessage(f"{msg}: {label}")
|
||
)
|
||
self._reader.start()
|
||
self._conn_panel.set_connected(True)
|
||
self._status.showMessage(f"Verbinde mit {label} …")
|
||
|
||
def _disconnect(self):
|
||
if self._reader:
|
||
self._reader.stop()
|
||
self._reader = None
|
||
self._conn_panel.set_connected(False)
|
||
self._status.showMessage("Verbindung getrennt.")
|
||
|
||
def _on_satellites(self, sats: list):
|
||
visible = [s for s in sats if s["elev"] >= 0]
|
||
used = sum(1 for s in sats if s["used"])
|
||
self._sat_label.setText(f"Satelliten: {len(visible)} sichtbar, {used} genutzt")
|
||
self._sky_plot.update_satellites(visible)
|
||
self._table.update_satellites(visible)
|
||
|
||
def _on_error(self, msg: str):
|
||
self._status.showMessage(f"Fehler: {msg}")
|
||
self._disconnect()
|
||
|
||
def closeEvent(self, event):
|
||
self._disconnect()
|
||
super().closeEvent(event)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
if __name__ == "__main__":
|
||
app = QApplication(sys.argv)
|
||
app.setStyle("Fusion")
|
||
win = MainWindow()
|
||
win.show()
|
||
sys.exit(app.exec_())
|