540 lines
19 KiB
Python
540 lines
19 KiB
Python
# target_simulator/gui/sync_tool_window.py
|
|
import tkinter as tk
|
|
from tkinter import ttk, messagebox
|
|
import time
|
|
import random
|
|
import os
|
|
import csv
|
|
import threading
|
|
from typing import Dict, Optional, List
|
|
from collections import deque
|
|
from datetime import datetime
|
|
|
|
from target_simulator.core.sfp_communicator import SFPCommunicator
|
|
from target_simulator.gui.payload_router import DebugPayloadRouter
|
|
|
|
# Tentativo di importare matplotlib per il grafico
|
|
try:
|
|
import matplotlib
|
|
|
|
matplotlib.use("TkAgg")
|
|
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
|
|
from matplotlib.figure import Figure
|
|
|
|
MATPLOTLIB_AVAILABLE = True
|
|
except ImportError:
|
|
MATPLOTLIB_AVAILABLE = False
|
|
|
|
|
|
class SyncToolWindow(tk.Toplevel):
|
|
"""Finestra per il test di latenza tramite messaggi SYNC con grafico in tempo reale."""
|
|
|
|
def __init__(
|
|
self, master, communicator: SFPCommunicator, router: DebugPayloadRouter
|
|
):
|
|
super().__init__(master)
|
|
self.communicator = communicator
|
|
self.router = router
|
|
|
|
self.title("Latency Sync Tool")
|
|
self.geometry("900x700")
|
|
self.transient(master)
|
|
self.grab_set()
|
|
|
|
self.pending_requests: Dict[int, float] = {} # {cookie: send_timestamp}
|
|
|
|
# Stato per invio periodico
|
|
self.periodic_active = False
|
|
self.periodic_interval_ms = 500 # Default 500ms
|
|
self.periodic_after_id = None
|
|
|
|
# Storico delle latenze per il grafico (max 200 campioni)
|
|
self.latency_history: deque = deque(maxlen=200)
|
|
self.time_history: deque = deque(maxlen=200)
|
|
|
|
# Statistiche
|
|
self.latency_values: List[float] = []
|
|
|
|
# === Sistema di salvataggio CSV (asincrono e non invasivo) ===
|
|
self.csv_enabled = False
|
|
self.csv_filepath: Optional[str] = None
|
|
self.csv_buffer: deque = deque(maxlen=10000) # Buffer grande per evitare perdite
|
|
self.csv_lock = threading.Lock()
|
|
self.csv_writer_thread: Optional[threading.Thread] = None
|
|
self.csv_stop_event = threading.Event()
|
|
self.csv_session_start: Optional[float] = None
|
|
|
|
self._create_widgets()
|
|
|
|
self.protocol("WM_DELETE_WINDOW", self._on_close)
|
|
self.after(100, self._process_sync_queue)
|
|
|
|
def _create_widgets(self):
|
|
main_frame = ttk.Frame(self, padding=10)
|
|
main_frame.pack(fill=tk.BOTH, expand=True)
|
|
|
|
# === CONTROLLI SUPERIORI ===
|
|
controls_frame = ttk.LabelFrame(main_frame, text="Controls", padding=5)
|
|
controls_frame.pack(fill=tk.X, pady=(0, 10))
|
|
|
|
# Riga 1: Invio singolo
|
|
row1 = ttk.Frame(controls_frame)
|
|
row1.pack(fill=tk.X, pady=2)
|
|
|
|
self.send_button = ttk.Button(
|
|
row1, text="Send Single SYNC", command=self._send_sync, width=18
|
|
)
|
|
self.send_button.pack(side=tk.LEFT, padx=(0, 10))
|
|
|
|
self.status_var = tk.StringVar(value="Idle")
|
|
ttk.Label(row1, textvariable=self.status_var, foreground="blue").pack(
|
|
side=tk.LEFT
|
|
)
|
|
|
|
# Riga 2: Invio periodico
|
|
row2 = ttk.Frame(controls_frame)
|
|
row2.pack(fill=tk.X, pady=2)
|
|
|
|
self.start_stop_button = ttk.Button(
|
|
row2, text="Start Periodic", command=self._toggle_periodic, width=18
|
|
)
|
|
self.start_stop_button.pack(side=tk.LEFT, padx=(0, 10))
|
|
|
|
ttk.Label(row2, text="Interval (ms):").pack(side=tk.LEFT, padx=(0, 5))
|
|
self.interval_var = tk.StringVar(value="500")
|
|
interval_entry = ttk.Entry(row2, textvariable=self.interval_var, width=8)
|
|
interval_entry.pack(side=tk.LEFT, padx=(0, 10))
|
|
|
|
ttk.Button(row2, text="Clear History", command=self._clear_history).pack(
|
|
side=tk.LEFT
|
|
)
|
|
|
|
# Riga 3: Salvataggio CSV
|
|
row3 = ttk.Frame(controls_frame)
|
|
row3.pack(fill=tk.X, pady=2)
|
|
|
|
self.csv_check_var = tk.BooleanVar(value=False)
|
|
self.csv_checkbox = ttk.Checkbutton(
|
|
row3,
|
|
text="Save to CSV",
|
|
variable=self.csv_check_var,
|
|
command=self._toggle_csv_save,
|
|
)
|
|
self.csv_checkbox.pack(side=tk.LEFT, padx=(0, 10))
|
|
|
|
self.csv_status_var = tk.StringVar(value="Not saving")
|
|
self.csv_status_label = tk.Label(
|
|
row3, textvariable=self.csv_status_var, foreground="gray"
|
|
)
|
|
self.csv_status_label.pack(side=tk.LEFT)
|
|
|
|
# === STATISTICHE ===
|
|
stats_frame = ttk.LabelFrame(main_frame, text="Statistics", padding=5)
|
|
stats_frame.pack(fill=tk.X, pady=(0, 10))
|
|
|
|
stats_grid = ttk.Frame(stats_frame)
|
|
stats_grid.pack(fill=tk.X)
|
|
|
|
ttk.Label(stats_grid, text="Samples:").grid(
|
|
row=0, column=0, sticky=tk.W, padx=5
|
|
)
|
|
self.samples_var = tk.StringVar(value="0")
|
|
ttk.Label(
|
|
stats_grid,
|
|
textvariable=self.samples_var,
|
|
font=("TkDefaultFont", 10, "bold"),
|
|
).grid(row=0, column=1, sticky=tk.W, padx=5)
|
|
|
|
ttk.Label(stats_grid, text="Last:").grid(row=0, column=2, sticky=tk.W, padx=5)
|
|
self.last_var = tk.StringVar(value="-- ms")
|
|
ttk.Label(
|
|
stats_grid, textvariable=self.last_var, font=("TkDefaultFont", 10, "bold")
|
|
).grid(row=0, column=3, sticky=tk.W, padx=5)
|
|
|
|
ttk.Label(stats_grid, text="Min:").grid(row=0, column=4, sticky=tk.W, padx=5)
|
|
self.min_var = tk.StringVar(value="-- ms")
|
|
ttk.Label(
|
|
stats_grid, textvariable=self.min_var, font=("TkDefaultFont", 10, "bold")
|
|
).grid(row=0, column=5, sticky=tk.W, padx=5)
|
|
|
|
ttk.Label(stats_grid, text="Max:").grid(row=0, column=6, sticky=tk.W, padx=5)
|
|
self.max_var = tk.StringVar(value="-- ms")
|
|
ttk.Label(
|
|
stats_grid, textvariable=self.max_var, font=("TkDefaultFont", 10, "bold")
|
|
).grid(row=0, column=7, sticky=tk.W, padx=5)
|
|
|
|
ttk.Label(stats_grid, text="Avg:").grid(row=0, column=8, sticky=tk.W, padx=5)
|
|
self.avg_var = tk.StringVar(value="-- ms")
|
|
ttk.Label(
|
|
stats_grid, textvariable=self.avg_var, font=("TkDefaultFont", 10, "bold")
|
|
).grid(row=0, column=9, sticky=tk.W, padx=5)
|
|
|
|
# === GRAFICO ===
|
|
if MATPLOTLIB_AVAILABLE:
|
|
graph_frame = ttk.LabelFrame(main_frame, text="Latency Graph", padding=5)
|
|
graph_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
|
|
|
|
self.figure = Figure(figsize=(8, 3), dpi=100)
|
|
self.ax = self.figure.add_subplot(111)
|
|
self.ax.set_xlabel("Time (s)")
|
|
self.ax.set_ylabel("Latency (ms)")
|
|
self.ax.set_title("One-Way Latency Over Time")
|
|
self.ax.grid(True, alpha=0.3)
|
|
|
|
self.canvas = FigureCanvasTkAgg(self.figure, graph_frame)
|
|
self.canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
|
|
|
|
(self.line,) = self.ax.plot([], [], "b-", linewidth=1.5)
|
|
else:
|
|
graph_frame = ttk.LabelFrame(main_frame, text="Latency Graph", padding=5)
|
|
graph_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
|
|
ttk.Label(
|
|
graph_frame,
|
|
text="Matplotlib not available. Install with: pip install matplotlib",
|
|
foreground="red",
|
|
).pack(pady=20)
|
|
|
|
# === TABELLA RISULTATI ===
|
|
tree_frame = ttk.LabelFrame(main_frame, text="Recent Results", padding=5)
|
|
tree_frame.pack(fill=tk.BOTH, expand=True)
|
|
|
|
columns = ("time", "rtt", "latency")
|
|
self.tree = ttk.Treeview(tree_frame, columns=columns, show="headings", height=8)
|
|
self.tree.heading("time", text="Timestamp")
|
|
self.tree.heading("rtt", text="Round Trip (ms)")
|
|
self.tree.heading("latency", text="One-Way Latency (ms)")
|
|
|
|
self.tree.column("time", width=150)
|
|
self.tree.column("rtt", width=150, anchor=tk.E)
|
|
self.tree.column("latency", width=150, anchor=tk.E)
|
|
|
|
scrollbar = ttk.Scrollbar(
|
|
tree_frame, orient=tk.VERTICAL, command=self.tree.yview
|
|
)
|
|
self.tree.configure(yscrollcommand=scrollbar.set)
|
|
|
|
self.tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
|
|
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
|
|
|
|
def _send_sync(self):
|
|
"""Invia una singola richiesta SYNC."""
|
|
if not self.communicator or not self.communicator.is_open:
|
|
messagebox.showerror(
|
|
"Error", "SFP Communicator is not connected.", parent=self
|
|
)
|
|
return
|
|
|
|
cookie = random.randint(0, 2**32 - 1)
|
|
send_time = time.monotonic()
|
|
|
|
if self.communicator.send_sync_request(cookie):
|
|
self.pending_requests[cookie] = send_time
|
|
if not self.periodic_active:
|
|
self.status_var.set(
|
|
f"Sent request with cookie {cookie}. Waiting for reply..."
|
|
)
|
|
else:
|
|
self.status_var.set("Failed to send SYNC request.")
|
|
|
|
def _toggle_periodic(self):
|
|
"""Attiva/disattiva l'invio periodico."""
|
|
if self.periodic_active:
|
|
# Stop
|
|
self.periodic_active = False
|
|
if self.periodic_after_id:
|
|
self.after_cancel(self.periodic_after_id)
|
|
self.periodic_after_id = None
|
|
self.start_stop_button.config(text="Start Periodic")
|
|
self.status_var.set("Periodic sending stopped.")
|
|
else:
|
|
# Start
|
|
try:
|
|
interval = int(self.interval_var.get())
|
|
if interval < 50:
|
|
messagebox.showwarning(
|
|
"Warning", "Interval too short. Minimum is 50ms.", parent=self
|
|
)
|
|
return
|
|
self.periodic_interval_ms = interval
|
|
except ValueError:
|
|
messagebox.showerror("Error", "Invalid interval value.", parent=self)
|
|
return
|
|
|
|
self.periodic_active = True
|
|
self.start_stop_button.config(text="Stop Periodic")
|
|
self.status_var.set(
|
|
f"Periodic sending active (every {self.periodic_interval_ms} ms)"
|
|
)
|
|
self._periodic_send()
|
|
|
|
def _periodic_send(self):
|
|
"""Invia periodicamente richieste SYNC."""
|
|
if not self.periodic_active:
|
|
return
|
|
|
|
self._send_sync()
|
|
self.periodic_after_id = self.after(
|
|
self.periodic_interval_ms, self._periodic_send
|
|
)
|
|
|
|
def _clear_history(self):
|
|
"""Pulisce lo storico e le statistiche."""
|
|
self.latency_history.clear()
|
|
self.time_history.clear()
|
|
self.latency_values.clear()
|
|
self._update_statistics()
|
|
self._update_graph()
|
|
|
|
# Pulisce anche la tabella
|
|
for item in self.tree.get_children():
|
|
self.tree.delete(item)
|
|
|
|
def _update_statistics(self):
|
|
"""Aggiorna le statistiche visualizzate."""
|
|
if not self.latency_values:
|
|
self.samples_var.set("0")
|
|
self.last_var.set("-- ms")
|
|
self.min_var.set("-- ms")
|
|
self.max_var.set("-- ms")
|
|
self.avg_var.set("-- ms")
|
|
else:
|
|
self.samples_var.set(str(len(self.latency_values)))
|
|
self.last_var.set(f"{self.latency_values[-1]:.2f} ms")
|
|
self.min_var.set(f"{min(self.latency_values):.2f} ms")
|
|
self.max_var.set(f"{max(self.latency_values):.2f} ms")
|
|
self.avg_var.set(
|
|
f"{sum(self.latency_values)/len(self.latency_values):.2f} ms"
|
|
)
|
|
|
|
def _update_graph(self):
|
|
"""Aggiorna il grafico della latenza."""
|
|
if not MATPLOTLIB_AVAILABLE:
|
|
return
|
|
|
|
if len(self.time_history) > 0:
|
|
# Converti i tempi assoluti in relativi (secondi dall'inizio)
|
|
times = list(self.time_history)
|
|
latencies = list(self.latency_history)
|
|
|
|
start_time = times[0]
|
|
relative_times = [(t - start_time) for t in times]
|
|
|
|
self.line.set_data(relative_times, latencies)
|
|
|
|
self.ax.relim()
|
|
self.ax.autoscale_view()
|
|
|
|
try:
|
|
self.canvas.draw()
|
|
except:
|
|
pass # Ignora errori durante il disegno
|
|
|
|
def _process_sync_queue(self):
|
|
"""Estrae i risultati dalla coda del router e aggiorna la UI."""
|
|
result = self.router.get_sync_result()
|
|
if result:
|
|
cookie = result.get("cookie")
|
|
reception_time = result.get("reception_timestamp")
|
|
|
|
if cookie in self.pending_requests:
|
|
send_time = self.pending_requests.pop(cookie)
|
|
|
|
rtt_s = reception_time - send_time
|
|
rtt_ms = rtt_s * 1000
|
|
latency_ms = rtt_ms / 2.0
|
|
|
|
# Aggiorna storico
|
|
self.latency_history.append(latency_ms)
|
|
self.time_history.append(reception_time)
|
|
self.latency_values.append(latency_ms)
|
|
|
|
# Limita latency_values per non far crescere troppo la lista
|
|
if len(self.latency_values) > 200:
|
|
self.latency_values.pop(0)
|
|
|
|
# Salva su CSV se abilitato (operazione velocissima, non blocca)
|
|
if self.csv_enabled and self.csv_session_start is not None:
|
|
elapsed_s = reception_time - self.csv_session_start
|
|
server_timetag = result.get("server_timetag", 0)
|
|
self._add_sample_to_csv_buffer(
|
|
elapsed_s, cookie, rtt_ms, latency_ms, server_timetag
|
|
)
|
|
|
|
# Aggiorna UI
|
|
timestamp_str = time.strftime("%H:%M:%S")
|
|
|
|
self.tree.insert(
|
|
"", 0, values=(timestamp_str, f"{rtt_ms:.3f}", f"{latency_ms:.3f}")
|
|
)
|
|
|
|
# Limita il numero di righe nella tabella
|
|
items = self.tree.get_children()
|
|
if len(items) > 50:
|
|
self.tree.delete(items[-1])
|
|
|
|
if not self.periodic_active:
|
|
self.status_var.set(
|
|
f"Received reply for cookie {cookie}. Latency: {latency_ms:.2f} ms"
|
|
)
|
|
|
|
self._update_statistics()
|
|
self._update_graph()
|
|
|
|
# Continua il polling
|
|
self.after(100, self._process_sync_queue)
|
|
|
|
def _toggle_csv_save(self):
|
|
"""Attiva/disattiva il salvataggio CSV asincrono."""
|
|
if self.csv_check_var.get():
|
|
# Avvia salvataggio
|
|
self._start_csv_save()
|
|
else:
|
|
# Ferma salvataggio
|
|
self._stop_csv_save()
|
|
|
|
def _start_csv_save(self):
|
|
"""Avvia il salvataggio CSV in background."""
|
|
if self.csv_enabled:
|
|
return # Già attivo
|
|
|
|
# Crea nome file con timestamp
|
|
project_root = os.path.abspath(
|
|
os.path.join(os.path.dirname(__file__), "..", "..")
|
|
)
|
|
temp_dir = os.path.join(project_root, "Temp")
|
|
os.makedirs(temp_dir, exist_ok=True)
|
|
|
|
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
self.csv_filepath = os.path.join(temp_dir, f"sync_latency_{timestamp}.csv")
|
|
self.csv_session_start = time.monotonic()
|
|
|
|
# Inizializza il file CSV con header
|
|
try:
|
|
with open(self.csv_filepath, "w", newline="") as f:
|
|
writer = csv.writer(f)
|
|
writer.writerow(
|
|
[
|
|
"elapsed_s",
|
|
"timestamp",
|
|
"cookie",
|
|
"rtt_ms",
|
|
"latency_ms",
|
|
"server_timetag",
|
|
]
|
|
)
|
|
self.csv_enabled = True
|
|
self.csv_stop_event.clear()
|
|
|
|
# Avvia thread di scrittura
|
|
self.csv_writer_thread = threading.Thread(
|
|
target=self._csv_writer_loop, daemon=True, name="CSVWriterThread"
|
|
)
|
|
self.csv_writer_thread.start()
|
|
|
|
filename = os.path.basename(self.csv_filepath)
|
|
self.csv_status_var.set(f"Saving to {filename}")
|
|
self.csv_status_label.config(foreground="green")
|
|
|
|
except Exception as e:
|
|
messagebox.showerror(
|
|
"CSV Error", f"Failed to create CSV file: {e}", parent=self
|
|
)
|
|
self.csv_check_var.set(False)
|
|
self.csv_enabled = False
|
|
|
|
def _stop_csv_save(self):
|
|
"""Ferma il salvataggio CSV."""
|
|
if not self.csv_enabled:
|
|
return
|
|
|
|
self.csv_enabled = False
|
|
self.csv_stop_event.set()
|
|
|
|
# Attendi che il thread finisca di scrivere i dati rimanenti
|
|
if self.csv_writer_thread and self.csv_writer_thread.is_alive():
|
|
self.csv_writer_thread.join(timeout=2.0)
|
|
|
|
self.csv_status_var.set("Not saving")
|
|
self.csv_status_label.config(foreground="gray")
|
|
|
|
if self.csv_filepath:
|
|
filename = os.path.basename(self.csv_filepath)
|
|
messagebox.showinfo(
|
|
"CSV Saved",
|
|
f"Latency data saved to:\n{filename}",
|
|
parent=self,
|
|
)
|
|
|
|
def _csv_writer_loop(self):
|
|
"""Thread worker che scrive i dati bufferizzati su disco periodicamente."""
|
|
while not self.csv_stop_event.is_set():
|
|
try:
|
|
# Attendi un po' prima di scrivere (batch writing)
|
|
time.sleep(1.0)
|
|
|
|
# Estrai tutti i dati dal buffer
|
|
rows_to_write = []
|
|
with self.csv_lock:
|
|
while len(self.csv_buffer) > 0:
|
|
rows_to_write.append(self.csv_buffer.popleft())
|
|
|
|
# Scrivi su file (fuori dal lock per non bloccare)
|
|
if rows_to_write and self.csv_filepath:
|
|
try:
|
|
with open(self.csv_filepath, "a", newline="") as f:
|
|
writer = csv.writer(f)
|
|
writer.writerows(rows_to_write)
|
|
except Exception:
|
|
pass # Ignora errori di scrittura per non bloccare
|
|
|
|
except Exception:
|
|
pass
|
|
|
|
# Flush finale dei dati rimanenti
|
|
rows_to_write = []
|
|
with self.csv_lock:
|
|
while len(self.csv_buffer) > 0:
|
|
rows_to_write.append(self.csv_buffer.popleft())
|
|
|
|
if rows_to_write and self.csv_filepath:
|
|
try:
|
|
with open(self.csv_filepath, "a", newline="") as f:
|
|
writer = csv.writer(f)
|
|
writer.writerows(rows_to_write)
|
|
except Exception:
|
|
pass
|
|
|
|
def _add_sample_to_csv_buffer(
|
|
self, elapsed_s: float, cookie: int, rtt_ms: float, latency_ms: float, server_timetag: int
|
|
):
|
|
"""Aggiunge un campione al buffer CSV (operazione velocissima, non blocca)."""
|
|
if not self.csv_enabled:
|
|
return
|
|
|
|
timestamp_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
|
|
row = [
|
|
f"{elapsed_s:.3f}",
|
|
timestamp_str,
|
|
cookie,
|
|
f"{rtt_ms:.3f}",
|
|
f"{latency_ms:.3f}",
|
|
server_timetag,
|
|
]
|
|
|
|
with self.csv_lock:
|
|
self.csv_buffer.append(row)
|
|
|
|
def _on_close(self):
|
|
"""Gestisce la chiusura della finestra."""
|
|
if self.periodic_active:
|
|
self.periodic_active = False
|
|
if self.periodic_after_id:
|
|
self.after_cancel(self.periodic_after_id)
|
|
|
|
# Ferma il salvataggio CSV se attivo
|
|
if self.csv_enabled:
|
|
self.csv_check_var.set(False)
|
|
self._stop_csv_save()
|
|
|
|
self.destroy()
|