dario/marte-debug
1
0
Fork 0
forked from martino/marte-debug
Code Pull Requests Activity
Files
4be38cf57b5e7de220d34eb1a9d3a58539fab26b
marte-debug/Tools/gui_client/src/main.rs
T

3012 lines
133 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use arrow::array::Float64Array;
use arrow::datatypes::{DataType, Field, Schema};
use arrow::record_batch::RecordBatch;
use chrono::Local;
use crossbeam_channel::{unbounded, Receiver, Sender};
use eframe::egui;
use egui_plot::{Line, LineStyle, MarkerShape, Plot, PlotBounds, PlotPoints, VLine};
use once_cell::sync::Lazy;
use parquet::arrow::arrow_writer::ArrowWriter;
use parquet::file::properties::WriterProperties;
use regex::Regex;
use rfd::FileDialog;
use serde::{Deserialize, Serialize};
use socket2::{Domain, Protocol, Socket, Type};
use std::collections::{HashMap, VecDeque};
use std::fs::File;
use std::io::{BufRead, BufReader, Write};
use std::net::{TcpStream, UdpSocket};
use std::sync::{Arc, Mutex};
use std::thread;
static BASE_TELEM_TS: Lazy<Mutex<Option<u64>>> = Lazy::new(|| Mutex::new(None));
// --- Models ---
#[derive(Serialize, Deserialize, Clone, Debug)]
struct Signal {
name: String,
id: u32,
#[serde(rename = "type")]
sig_type: String,
#[serde(default)]
dimensions: u8,
#[serde(default = "default_elements")]
elements: u32,
}
fn default_elements() -> u32 { 1 }
#[derive(Deserialize)]
struct DiscoverResponse {
#[serde(rename = "Signals")]
signals: Vec<Signal>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
struct TreeItem {
#[serde(rename = "Name")]
name: String,
#[serde(rename = "Class")]
class: String,
#[serde(rename = "Children")]
children: Option<Vec<TreeItem>>,
#[serde(rename = "Type")]
sig_type: Option<String>,
#[serde(rename = "Dimensions")]
dimensions: Option<u8>,
#[serde(rename = "Elements")]
elements: Option<u32>,
#[serde(rename = "IsTraceable")]
is_traceable: Option<bool>,
#[serde(rename = "IsForcable")]
is_forcable: Option<bool>,
}
#[derive(Clone)]
struct LogEntry {
time: String,
level: String,
message: String,
}
struct TraceData {
values: VecDeque<[f64; 2]>,
last_value: f64,
recording_tx: Option<Sender<[f64; 2]>>,
recording_path: Option<String>,
is_monitored: bool,
}
struct SignalMetadata {
names: Vec<String>,
sig_type: String,
dimensions: u8,
elements: u32,
}
#[derive(Clone)]
struct ConnectionConfig {
ip: String,
tcp_port: String,
udp_port: String,
log_port: String,
version: u64,
}
#[derive(Clone, Copy, PartialEq, Debug)]
enum PlotType {
Normal,
LogicAnalyzer,
}
#[derive(Clone, Copy, PartialEq, Debug)]
enum AcquisitionMode {
FreeRun,
Triggered,
}
#[derive(Clone, Copy, PartialEq, Debug)]
enum TriggerEdge {
Rising,
Falling,
Both,
}
#[derive(Clone, Copy, PartialEq, Debug)]
enum TriggerType {
Single,
Continuous,
}
#[derive(Clone, Copy, PartialEq, Debug)]
enum MarkerType {
None,
Circle,
Square,
}
impl MarkerType {
fn to_shape(&self) -> Option<MarkerShape> {
match self {
MarkerType::None => None,
MarkerType::Circle => Some(MarkerShape::Circle),
MarkerType::Square => Some(MarkerShape::Square),
}
}
}
#[derive(Clone)]
struct SignalPlotConfig {
source_name: String,
label: String,
unit: String,
color: egui::Color32,
line_style: LineStyle,
marker_type: MarkerType,
gain: f64,
offset: f64,
}
struct PlotInstance {
id: String,
plot_type: PlotType,
signals: Vec<SignalPlotConfig>,
auto_bounds: bool,
max_points: usize,
follow: bool,
reset_view: bool,
}
#[derive(Clone, PartialEq)]
enum MsgStatus {
Unknown,
Success,
Failure,
}
#[derive(Clone)]
struct MessageHistoryEntry {
time: String,
destination: String,
function: String,
payload: String,
wait_reply: bool,
raw_cmd: String,
response: String,
status: MsgStatus,
}
#[derive(Clone, PartialEq)]
enum MainTab {
Plots,
Config,
}
enum InternalEvent {
Log(LogEntry),
Discovery(Vec<Signal>),
Tree(TreeItem),
CommandResponse(String),
NodeInfo(String),
ConfigResponse(String),
Connected,
Disconnected,
InternalLog(String),
TraceRequested(String, bool), // Name, IsMonitored
ClearTrace(String),
UdpStats(u64),
UdpDropped(u32),
RecordPathChosen(String, String), // SignalName, FilePath
RecordingError(String, String), // SignalName, ErrorMessage
TelemMatched(u32),
ServiceConfig { udp_port: String, log_port: String },
StepStatus { paused: bool, paused_at_gam: String, step_remaining: u32, step_thread: String },
SignalValue { path: String, value_text: String, found: bool },
}
// --- App State ---
struct ForcingDialog {
signal_path: String,
value: String,
}
struct MonitorDialog {
signal_path: String,
period_ms: String,
}
struct BreakDialog {
signal_path: String,
op: String, // ">", "<", "==", ">=", "<=", "!="
threshold: String,
}
struct MessageDialog {
destination: String,
function: String,
payload: String,
expect_reply: bool,
}
struct InfoDialog {
path: String,
is_signal: bool,
config_text: String,
is_loading: bool,
value_text: Option<String>,
value_loading: bool,
}
struct LogFilters {
show_debug: bool,
show_info: bool,
show_warning: bool,
show_error: bool,
paused: bool,
content_regex: String,
}
struct ScopeSettings {
enabled: bool,
window_ms: f64,
mode: AcquisitionMode,
paused: bool,
trigger_type: TriggerType,
trigger_source: String,
trigger_edge: TriggerEdge,
trigger_threshold: f64,
pre_trigger_percent: f64,
trigger_active: bool,
last_trigger_time: f64,
is_armed: bool,
}
struct MarteDebugApp {
connected: bool,
is_breaking: bool,
config: ConnectionConfig,
shared_config: Arc<Mutex<ConnectionConfig>>,
app_tree: Option<TreeItem>,
id_to_meta: Arc<Mutex<HashMap<u32, SignalMetadata>>>,
traced_signals: Arc<Mutex<HashMap<String, TraceData>>>,
plots: Vec<PlotInstance>,
forced_signals: HashMap<String, String>,
break_conditions: HashMap<String, (String, f64)>, // signal -> (op, threshold)
break_dialog: Option<BreakDialog>,
step_status: Option<(bool, String, u32)>, // (paused, paused_at_gam, step_remaining)
last_step_poll: std::time::Instant,
step_thread: String,
info_dialog: Option<InfoDialog>,
logs: VecDeque<LogEntry>,
log_filters: LogFilters,
show_left_panel: bool,
show_right_panel: bool,
show_bottom_panel: bool,
selected_node: String,
node_info: String,
udp_packets: u64,
udp_dropped: u64,
forcing_dialog: Option<ForcingDialog>,
monitoring_dialog: Option<MonitorDialog>,
message_dialog: Option<MessageDialog>,
style_editor: Option<(usize, usize)>,
tx_cmd: Sender<String>,
rx_events: Receiver<InternalEvent>,
internal_tx: Sender<InternalEvent>,
shared_x_range: Option<[f64; 2]>,
scope: ScopeSettings,
active_main_tab: MainTab,
app_config_text: String,
message_history: Vec<MessageHistoryEntry>,
show_message_history: bool,
pending_msg_idx: Option<usize>,
}
impl MarteDebugApp {
fn new(_cc: &eframe::CreationContext<'_>) -> Self {
let (tx_cmd, rx_cmd_internal) = unbounded::<String>();
let (tx_events, rx_events) = unbounded::<InternalEvent>();
let internal_tx = tx_events.clone();
let config = ConnectionConfig {
ip: "127.0.0.1".to_string(),
tcp_port: "8080".to_string(),
udp_port: "8081".to_string(),
log_port: "8082".to_string(),
version: 0,
};
let shared_config = Arc::new(Mutex::new(config.clone()));
let id_to_meta = Arc::new(Mutex::new(HashMap::new()));
let traced_signals = Arc::new(Mutex::new(HashMap::new()));
let id_to_meta_clone = id_to_meta.clone();
let traced_signals_clone = traced_signals.clone();
let shared_config_cmd = shared_config.clone();
let shared_config_log = shared_config.clone();
let shared_config_udp = shared_config.clone();
let tx_events_c = tx_events.clone();
thread::spawn(move || {
tcp_command_worker(shared_config_cmd, rx_cmd_internal, tx_events_c);
});
let tx_events_log = tx_events.clone();
thread::spawn(move || {
tcp_log_worker(shared_config_log, tx_events_log);
});
let tx_events_udp = tx_events.clone();
thread::spawn(move || {
udp_worker(
shared_config_udp,
id_to_meta_clone,
traced_signals_clone,
tx_events_udp,
);
});
Self {
connected: false,
is_breaking: false,
config,
shared_config,
app_tree: None,
id_to_meta,
traced_signals,
plots: vec![PlotInstance {
id: "Plot 1".to_string(),
plot_type: PlotType::Normal,
signals: Vec::new(),
auto_bounds: true,
max_points: 5000,
follow: true,
reset_view: false,
}],
forced_signals: HashMap::new(),
break_conditions: HashMap::new(),
break_dialog: None,
step_status: None,
last_step_poll: std::time::Instant::now(),
step_thread: String::new(),
info_dialog: None,
logs: VecDeque::with_capacity(2000),
log_filters: LogFilters {
show_debug: true,
show_info: true,
show_warning: true,
show_error: true,
paused: false,
content_regex: "".to_string(),
},
show_left_panel: true,
show_right_panel: true,
show_bottom_panel: true,
selected_node: "".to_string(),
node_info: "".to_string(),
udp_packets: 0,
udp_dropped: 0,
forcing_dialog: None,
monitoring_dialog: None,
message_dialog: None,
style_editor: None,
tx_cmd,
rx_events,
internal_tx,
shared_x_range: None,
scope: ScopeSettings {
enabled: false,
window_ms: 1000.0,
mode: AcquisitionMode::FreeRun,
paused: false,
trigger_type: TriggerType::Continuous,
trigger_source: "".to_string(),
trigger_edge: TriggerEdge::Rising,
trigger_threshold: 0.0,
pre_trigger_percent: 25.0,
trigger_active: false,
last_trigger_time: 0.0,
is_armed: true,
},
active_main_tab: MainTab::Plots,
app_config_text: String::new(),
message_history: Vec::new(),
show_message_history: true,
pending_msg_idx: None,
}
}
fn next_color(idx: usize) -> egui::Color32 {
let colors = [
egui::Color32::from_rgb(100, 200, 255),
egui::Color32::from_rgb(255, 100, 100),
egui::Color32::from_rgb(100, 255, 100),
egui::Color32::from_rgb(255, 200, 100),
egui::Color32::from_rgb(255, 100, 255),
egui::Color32::from_rgb(100, 255, 255),
egui::Color32::from_rgb(200, 255, 100),
egui::Color32::WHITE,
];
colors[idx % colors.len()]
}
fn apply_trigger_logic(&mut self) {
if self.scope.mode != AcquisitionMode::Triggered || !self.scope.is_armed {
return;
}
if self.scope.trigger_source.is_empty() {
return;
}
let data_map = self.traced_signals.lock().unwrap();
if let Some(data) = data_map.get(&self.scope.trigger_source) {
if data.values.len() < 2 {
return;
}
let start_idx = if data.values.len() > 100 {
data.values.len() - 100
} else {
0
};
for i in (start_idx + 1..data.values.len()).rev() {
let v_prev = data.values[i - 1][1];
let v_curr = data.values[i][1];
let t_curr = data.values[i][0];
if t_curr <= self.scope.last_trigger_time {
continue;
}
let triggered = match self.scope.trigger_edge {
TriggerEdge::Rising => {
v_prev < self.scope.trigger_threshold
&& v_curr >= self.scope.trigger_threshold
}
TriggerEdge::Falling => {
v_prev > self.scope.trigger_threshold
&& v_curr <= self.scope.trigger_threshold
}
TriggerEdge::Both => {
(v_prev < self.scope.trigger_threshold
&& v_curr >= self.scope.trigger_threshold)
|| (v_prev > self.scope.trigger_threshold
&& v_curr <= self.scope.trigger_threshold)
}
};
if triggered {
self.scope.last_trigger_time = t_curr;
self.scope.trigger_active = true;
if self.scope.trigger_type == TriggerType::Single {
self.scope.is_armed = false;
}
break;
}
}
}
}
fn get_all_objects(&self) -> Vec<String> {
let mut objects = Vec::new();
if let Some(tree) = &self.app_tree {
fn collect(item: &TreeItem, path: String, objects: &mut Vec<String>) {
let current_path = if path.is_empty() {
if item.name == "Root" {
"".to_string()
} else {
item.name.clone()
}
} else {
format!("{}.{}", path, item.name)
};
if !current_path.is_empty() && !item.class.contains("Signal") {
objects.push(current_path.clone());
}
if let Some(children) = &item.children {
for child in children {
collect(child, current_path.clone(), objects);
}
}
}
collect(tree, "".to_string(), &mut objects);
}
objects.sort();
objects
}
fn get_threads(&self) -> Vec<String> {
let mut threads = Vec::new();
if let Some(tree) = &self.app_tree {
fn collect(item: &TreeItem, out: &mut Vec<String>) {
if item.class == "RealTimeThread" {
out.push(item.name.clone());
}
if let Some(children) = &item.children {
for child in children { collect(child, out); }
}
}
collect(tree, &mut threads);
}
threads
}
fn render_tree(&mut self, ui: &mut egui::Ui, item: &TreeItem, path: String) {
let current_path = if path.is_empty() {
if item.name == "Root" {
"".to_string()
} else {
item.name.clone()
}
} else {
if path.is_empty() {
item.name.clone()
} else {
format!("{}.{}", path, item.name)
}
};
let label = if item.class == "Signal" {
format!("📈 {}", item.name)
} else {
item.name.clone()
};
if let Some(children) = &item.children {
let header = egui::CollapsingHeader::new(format!("{} [{}]", label, item.class))
.id_salt(&current_path);
header.show(ui, |ui| {
ui.horizontal(|ui| {
if !current_path.is_empty() {
if ui
.selectable_label(self.selected_node == current_path, "ℹ Info")
.clicked()
{
self.selected_node = current_path.clone();
let _ = self.tx_cmd.send(format!("INFO {}", current_path));
self.info_dialog = Some(InfoDialog {
path: current_path.clone(),
is_signal: false,
config_text: String::new(),
is_loading: true,
value_text: None,
value_loading: false,
});
}
}
});
for child in children {
self.render_tree(ui, child, current_path.clone());
}
});
} else {
ui.horizontal(|ui| {
let resp = ui.selectable_label(
self.selected_node == current_path,
format!("{} [{}]", label, item.class),
);
if resp.clicked() {
self.selected_node = current_path.clone();
let _ = self.tx_cmd.send(format!("INFO {}", current_path));
}
if resp.double_clicked() {
self.selected_node = current_path.clone();
let _ = self.tx_cmd.send(format!("INFO {}", current_path));
let is_sig = item.class.contains("Signal");
let mut value_loading = false;
if is_sig {
let _ = self.tx_cmd.send(format!("VALUE {}", current_path));
value_loading = true;
}
self.info_dialog = Some(InfoDialog {
path: current_path.clone(),
is_signal: is_sig,
config_text: String::new(),
is_loading: true,
value_text: None,
value_loading,
});
}
if !resp.double_clicked() && !resp.clicked() {
// keep the existing Info button for non-signal leaf nodes
if !item.class.contains("Signal") && ui.selectable_label(self.selected_node == current_path, "ℹ Info").clicked() {
self.selected_node = current_path.clone();
let _ = self.tx_cmd.send(format!("INFO {}", current_path));
self.info_dialog = Some(InfoDialog {
path: current_path.clone(),
is_signal: false,
config_text: String::new(),
is_loading: true,
value_text: None,
value_loading: false,
});
}
}
if item.class.contains("Signal") {
let elements = item.elements.unwrap_or(1);
if elements > 1 {
let header = egui::CollapsingHeader::new(format!("{} [{}] ({} elems)", label, item.class, elements))
.id_salt(&current_path);
header.show(ui, |ui| {
for i in 0..elements {
let elem_path = format!("{}[{}]", current_path, i);
ui.horizontal(|ui| {
ui.label(format!("{}[{}]", item.name, i));
if ui.button("Trace").clicked() {
let _ = self.tx_cmd.send(format!("TRACE {} 1", current_path));
let _ = self.internal_tx.send(InternalEvent::TraceRequested(elem_path.clone(), false));
}
if item.class == "Signal" {
if ui.button("Monitor").clicked() {
self.monitoring_dialog = Some(MonitorDialog {
signal_path: current_path.clone(),
period_ms: "100".to_string(),
});
// Note: internal monitoring logic will handle individual elements via naming convention
let _ = self.internal_tx.send(InternalEvent::TraceRequested(elem_path.clone(), true));
}
}
});
}
});
} else {
let traceable = item.is_traceable.unwrap_or(false);
let forcable = item.is_forcable.unwrap_or(false);
if traceable && ui.button("Trace").clicked() {
let _ = self.tx_cmd.send(format!("TRACE {} 1", current_path));
let _ = self
.internal_tx
.send(InternalEvent::TraceRequested(current_path.clone(), false));
}
if item.class == "Signal" {
if ui.button("Monitor").clicked() {
self.monitoring_dialog = Some(MonitorDialog {
signal_path: current_path.clone(),
period_ms: "100".to_string(),
});
}
}
if forcable && ui.button("⚡ Force").clicked() {
self.forcing_dialog = Some(ForcingDialog {
signal_path: current_path.clone(),
value: "".to_string(),
});
}
if traceable {
let has_break = self.break_conditions.contains_key(&current_path);
let btn_text = if has_break { "🔴 Break*" } else { "🔴 Break" };
if ui.button(btn_text).clicked() {
let (op, thr) = self.break_conditions
.get(&current_path)
.cloned()
.unwrap_or_else(|| (">".to_string(), 0.0));
self.break_dialog = Some(BreakDialog {
signal_path: current_path.clone(),
op,
threshold: thr.to_string(),
});
}
}
}
}
});
}
}
}
/// Emit the body of a JSON object as MARTe2 config lines at the given indent level.
/// `Class` is always emitted first; child objects with a `Class` key get `+` prefix.
fn json_node_to_marte(map: &serde_json::Map<String, serde_json::Value>, indent: usize) -> String {
let pad = " ".repeat(indent);
let mut out = String::new();
// Class first
if let Some(serde_json::Value::String(cls)) = map.get("Class") {
out.push_str(&format!("{}Class = {}\n", pad, cls));
}
// Collect and sort remaining keys so output is deterministic
let mut keys: Vec<&String> = map.keys().filter(|k| k.as_str() != "Class").collect();
keys.sort();
for key in keys {
let val = &map[key];
match val {
serde_json::Value::Object(child_map) => {
let prefix = if child_map.contains_key("Class") { "+" } else { "" };
out.push_str(&format!("{}{}{} = {{\n", pad, prefix, key));
out.push_str(&json_node_to_marte(child_map, indent + 1));
out.push_str(&format!("{}}}\n", pad));
}
serde_json::Value::String(s) => {
out.push_str(&format!("{}{} = {}\n", pad, key, s));
}
serde_json::Value::Null => {
out.push_str(&format!("{}{} =\n", pad, key));
}
other => {
out.push_str(&format!("{}{} = {}\n", pad, key, other));
}
}
}
out
}
fn convert_config_json(json_text: &str) -> String {
let root = match serde_json::from_str::<serde_json::Value>(json_text) {
Ok(v) => v,
Err(_) => return json_text.to_string(),
};
let map = match root.as_object() {
Some(m) => m,
None => return json_text.to_string(),
};
let mut out = String::new();
let mut keys: Vec<&String> = map.keys().collect();
keys.sort();
for key in keys {
let val = &map[key];
match val {
serde_json::Value::Object(child_map) => {
// Top-level nodes always get + (they are named MARTe2 objects)
out.push_str(&format!("+{} = {{\n", key));
out.push_str(&json_node_to_marte(child_map, 1));
out.push_str("}\n\n");
}
serde_json::Value::String(s) => {
out.push_str(&format!("{} = {}\n", key, s));
}
other => {
out.push_str(&format!("{} = {}\n", key, other));
}
}
}
out
}
fn tcp_command_worker(
shared_config: Arc<Mutex<ConnectionConfig>>,
rx_cmd: Receiver<String>,
tx_events: Sender<InternalEvent>,
) {
let mut current_version = 0;
let mut current_addr = String::new();
loop {
{
let config = shared_config.lock().unwrap();
if config.version != current_version {
current_version = config.version;
current_addr = format!("{}:{}", config.ip, config.tcp_port);
}
}
if current_addr.is_empty() || current_addr.starts_with(":") {
thread::sleep(std::time::Duration::from_secs(1));
continue;
}
if let Ok(mut stream) = TcpStream::connect(&current_addr) {
let _ = stream.set_nodelay(true);
let mut reader = BufReader::new(stream.try_clone().unwrap());
let _ = tx_events.send(InternalEvent::Connected);
let stop_flag = Arc::new(Mutex::new(false));
let stop_flag_reader = stop_flag.clone();
let tx_events_inner = tx_events.clone();
thread::spawn(move || {
let mut line = String::new();
let mut json_acc = String::new();
let mut in_json = false;
while reader.read_line(&mut line).is_ok() {
if *stop_flag_reader.lock().unwrap() {
break;
}
let trimmed = line.trim();
if trimmed.is_empty() {
line.clear();
continue;
}
if !in_json && trimmed.starts_with("{") {
in_json = true;
json_acc.clear();
}
if in_json {
json_acc.push_str(trimmed);
if trimmed.contains("OK DISCOVER") {
in_json = false;
let json_clean =
json_acc.split("OK DISCOVER").next().unwrap_or("").trim();
match serde_json::from_str::<DiscoverResponse>(json_clean) {
Ok(resp) => {
let _ = tx_events_inner
.send(InternalEvent::Discovery(resp.signals));
}
Err(e) => {
let _ =
tx_events_inner.send(InternalEvent::InternalLog(format!(
"Discovery JSON Error: {} | Payload: {}",
e, json_clean
)));
}
}
json_acc.clear();
} else if trimmed.contains("OK TREE") {
in_json = false;
let json_clean = json_acc.split("OK TREE").next().unwrap_or("").trim();
match serde_json::from_str::<TreeItem>(json_clean) {
Ok(resp) => {
let _ = tx_events_inner.send(InternalEvent::Tree(resp));
}
Err(e) => {
let _ = tx_events_inner.send(InternalEvent::InternalLog(
format!("Tree JSON Error: {}", e),
));
}
}
json_acc.clear();
} else if trimmed.contains("OK INFO") {
in_json = false;
let json_clean = json_acc.split("OK INFO").next().unwrap_or("").trim();
let _ = tx_events_inner
.send(InternalEvent::NodeInfo(json_clean.to_string()));
json_acc.clear();
} else if trimmed.contains("OK CONFIG") {
in_json = false;
let text = json_acc.split("OK CONFIG").next().unwrap_or("").trim();
let _ = tx_events_inner
.send(InternalEvent::ConfigResponse(text.to_string()));
json_acc.clear();
} else if trimmed.contains("OK STEP_STATUS") {
in_json = false;
let json_clean = json_acc.split("OK STEP_STATUS").next().unwrap_or("").trim();
let paused = json_clean.contains("\"Paused\": true");
let gam = json_clean.split("\"PausedAtGam\": \"")
.nth(1)
.and_then(|s| s.split('"').next())
.unwrap_or("")
.to_string();
let remaining = json_clean.split("\"StepRemaining\": ")
.nth(1)
.and_then(|s| s.split(',').next())
.and_then(|s| s.trim().parse::<u32>().ok())
.unwrap_or(0);
let step_thread = json_clean.split("\"StepThread\": \"")
.nth(1)
.and_then(|s| s.split('"').next())
.unwrap_or("")
.to_string();
let _ = tx_events_inner.send(InternalEvent::StepStatus {
paused,
paused_at_gam: gam,
step_remaining: remaining,
step_thread,
});
json_acc.clear();
} else if trimmed.contains("OK VALUE") {
in_json = false;
let json_clean = json_acc.split("OK VALUE").next().unwrap_or("").trim();
let found = !json_clean.contains("\"Error\"");
let path = json_clean.split("\"Name\": \"")
.nth(1)
.and_then(|s| s.split('"').next())
.unwrap_or("")
.to_string();
// Value is a quoted string: "Value": "..."
let value_text = json_clean.split("\"Value\": \"")
.nth(1)
.and_then(|s| s.split('"').next())
.unwrap_or("")
.to_string();
let _ = tx_events_inner.send(InternalEvent::SignalValue { path, value_text, found });
json_acc.clear();
}
} else {
if trimmed.starts_with("OK SERVICE_INFO") {
// OK SERVICE_INFO TCP_CTRL:8110 UDP_STREAM:8111 TCP_LOG:8082 STATE:RUNNING
let parts: Vec<&str> = trimmed.split_whitespace().collect();
let mut udp = String::new();
let mut log = String::new();
for p in parts {
if p.starts_with("UDP_STREAM:") {
udp = p.split(':').nth(1).unwrap_or("").to_string();
}
if p.starts_with("TCP_LOG:") {
log = p.split(':').nth(1).unwrap_or("").to_string();
}
}
if !udp.is_empty() || !log.is_empty() {
let _ = tx_events_inner.send(InternalEvent::ServiceConfig {
udp_port: udp,
log_port: log,
});
}
}
let _ = tx_events_inner
.send(InternalEvent::CommandResponse(trimmed.to_string()));
}
line.clear();
}
});
while let Ok(cmd) = rx_cmd.recv() {
{
let config = shared_config.lock().unwrap();
if config.version != current_version {
*stop_flag.lock().unwrap() = true;
let _ = tx_events.send(InternalEvent::Disconnected);
break;
}
}
if stream.write_all(format!("{}\n", cmd).as_bytes()).is_err() {
let _ = tx_events.send(InternalEvent::Disconnected);
break;
}
// Small delay to allow server to process and send response
thread::sleep(std::time::Duration::from_millis(100));
}
let _ = tx_events.send(InternalEvent::Disconnected);
}
thread::sleep(std::time::Duration::from_secs(2));
}
}
fn tcp_log_worker(shared_config: Arc<Mutex<ConnectionConfig>>, tx_events: Sender<InternalEvent>) {
let mut current_version = 0;
let mut current_addr = String::new();
loop {
{
let config = shared_config.lock().unwrap();
if config.version != current_version {
current_version = config.version;
current_addr = format!("{}:{}", config.ip, config.log_port);
}
}
if current_addr.is_empty() || current_addr.starts_with(":") {
thread::sleep(std::time::Duration::from_secs(1));
continue;
}
if let Ok(stream) = TcpStream::connect(&current_addr) {
let mut reader = BufReader::new(stream);
let mut line = String::new();
while reader.read_line(&mut line).is_ok() {
if shared_config.lock().unwrap().version != current_version {
break;
}
let trimmed = line.trim();
if trimmed.starts_with("LOG ") {
let parts: Vec<&str> = trimmed[4..].splitn(2, ' ').collect();
if parts.len() == 2 {
let _ = tx_events.send(InternalEvent::Log(LogEntry {
time: Local::now().format("%H:%M:%S%.3f").to_string(),
level: parts[0].to_string(),
message: parts[1].to_string(),
}));
}
}
line.clear();
}
}
thread::sleep(std::time::Duration::from_secs(2));
}
}
fn recording_worker(
rx: Receiver<[f64; 2]>,
path: String,
signal_name: String,
tx_events: Sender<InternalEvent>,
) {
let file = match File::create(&path) {
Ok(f) => f,
Err(e) => {
let _ = tx_events.send(InternalEvent::RecordingError(
signal_name,
format!("File Error: {}", e),
));
return;
}
};
let schema = Arc::new(Schema::new(vec![
Field::new("timestamp", DataType::Float64, false),
Field::new("value", DataType::Float64, false),
]));
let mut writer = match ArrowWriter::try_new(
file,
schema.clone(),
Some(WriterProperties::builder().build()),
) {
Ok(w) => w,
Err(e) => {
let _ = tx_events.send(InternalEvent::RecordingError(
signal_name,
format!("Parquet Error: {}", e),
));
return;
}
};
let (mut t_acc, mut v_acc) = (Vec::with_capacity(1000), Vec::with_capacity(1000));
while let Ok([t, v]) = rx.recv() {
t_acc.push(t);
v_acc.push(v);
if t_acc.len() >= 1000 {
let batch = RecordBatch::try_new(
schema.clone(),
vec![
Arc::new(Float64Array::from(t_acc.clone())),
Arc::new(Float64Array::from(v_acc.clone())),
],
)
.unwrap();
let _ = writer.write(&batch);
t_acc.clear();
v_acc.clear();
}
}
if !t_acc.is_empty() {
let batch = RecordBatch::try_new(
schema.clone(),
vec![
Arc::new(Float64Array::from(t_acc)),
Arc::new(Float64Array::from(v_acc)),
],
)
.unwrap();
let _ = writer.write(&batch);
}
let _ = writer.close();
}
fn udp_worker(
shared_config: Arc<Mutex<ConnectionConfig>>,
id_to_meta: Arc<Mutex<HashMap<u32, SignalMetadata>>>,
traced_data: Arc<Mutex<HashMap<String, TraceData>>>,
tx_events: Sender<InternalEvent>,
) {
let mut current_version = 0;
let mut socket: Option<UdpSocket> = None;
let mut last_seq: Option<u32> = None;
let mut last_warning_time = std::time::Instant::now();
loop {
let (ver, port) = {
let config = shared_config.lock().unwrap();
(config.version, config.udp_port.clone())
};
if ver != current_version || socket.is_none() {
current_version = ver;
{
let mut base = BASE_TELEM_TS.lock().unwrap();
*base = None;
}
if port.is_empty() {
socket = None;
continue;
}
let port_num: u16 = port.parse().unwrap_or(8081);
let s = Socket::new(Domain::IPV4, Type::DGRAM, Some(Protocol::UDP)).ok();
let mut bound = false;
if let Some(sock) = s {
let _ = sock.set_reuse_address(true);
#[cfg(all(unix, not(target_os = "solaris"), not(target_os = "illumos")))]
let _ = sock.set_reuse_port(true);
let _ = sock.set_recv_buffer_size(10 * 1024 * 1024);
let addr = format!("0.0.0.0:{}", port_num)
.parse::<std::net::SocketAddr>()
.unwrap();
if sock.bind(&addr.into()).is_ok() {
socket = Some(sock.into());
bound = true;
}
}
if !bound {
thread::sleep(std::time::Duration::from_secs(5));
continue;
}
let _ = socket
.as_ref()
.unwrap()
.set_read_timeout(Some(std::time::Duration::from_millis(500)));
last_seq = None;
}
let s = if let Some(sock) = socket.as_ref() {
sock
} else {
thread::sleep(std::time::Duration::from_secs(1));
continue;
};
let mut buf = [0u8; 4096];
let mut total_packets = 0u64;
loop {
if shared_config.lock().unwrap().version != current_version {
break;
}
if let Ok(n) = s.recv(&mut buf) {
total_packets += 1;
if (total_packets % 500) == 0 {
let _ = tx_events.send(InternalEvent::UdpStats(total_packets));
}
if n < 20 {
continue;
}
if u32::from_le_bytes(buf[0..4].try_into().unwrap()) != 0xDA7A57AD {
continue;
}
let seq = u32::from_le_bytes(buf[4..8].try_into().unwrap());
if let Some(last) = last_seq {
if seq != last + 1 && seq > last {
let _ = tx_events.send(InternalEvent::UdpDropped(seq - last - 1));
}
}
last_seq = Some(seq);
let count = u32::from_le_bytes(buf[16..20].try_into().unwrap());
let mut offset = 20;
let mut local_updates: HashMap<String, Vec<[f64; 2]>> = HashMap::new();
let mut last_values: HashMap<String, f64> = HashMap::new();
let metas = id_to_meta.lock().unwrap();
if metas.is_empty() && count > 0 && last_warning_time.elapsed().as_secs() > 5 {
let _ = tx_events.send(InternalEvent::InternalLog(
"UDP received but Metadata empty. Still discovering?".to_string(),
));
last_warning_time = std::time::Instant::now();
}
// Resolve the base timestamp once per packet, not per signal.
// BASE_TELEM_TS is a global lazy Mutex; locking it inside the
// inner loop at 1 kHz × N_signals/packet was a major bottleneck.
let packet_base_ts: Option<u64> = {
let mut guard = BASE_TELEM_TS.lock().unwrap();
if guard.is_none() {
// Peek at the first signal's timestamp to initialise base
if n >= 20 + 12 {
let first_ts = u64::from_le_bytes(
buf[20 + 4..20 + 12].try_into().unwrap(),
);
*guard = Some(first_ts);
}
}
*guard
};
for _ in 0..count {
if offset + 16 > n {
break;
}
let id = u32::from_le_bytes(buf[offset..offset + 4].try_into().unwrap());
let ts_raw =
u64::from_le_bytes(buf[offset + 4..offset + 12].try_into().unwrap());
let size =
u32::from_le_bytes(buf[offset + 12..offset + 16].try_into().unwrap());
offset += 16;
if offset + size as usize > n {
break;
}
let data_slice = &buf[offset..offset + size as usize];
let ts_s = if let Some(base) = packet_base_ts {
if ts_raw >= base { (ts_raw - base) as f64 / 1_000_000.0 } else { 0.0 }
} else {
0.0
};
if let Some(meta) = metas.get(&id) {
// Do NOT send a channel event per signal — at 1kHz×N this
// floods the event queue and causes the UI spiral slowdown.
let t = meta.sig_type.as_str();
let type_size = if meta.elements > 0 { size / meta.elements } else { size };
for i in 0..meta.elements {
let elem_offset = (i * type_size) as usize;
if elem_offset + type_size as usize > data_slice.len() { break; }
let elem_data = &data_slice[elem_offset..elem_offset + type_size as usize];
let val = match type_size {
1 => {
if t.contains('u') {
elem_data[0] as f64
} else {
(elem_data[0] as i8) as f64
}
}
2 => {
let b = elem_data[0..2].try_into().unwrap();
if t.contains('u') {
u16::from_le_bytes(b) as f64
} else {
i16::from_le_bytes(b) as f64
}
}
4 => {
let b = elem_data[0..4].try_into().unwrap();
if t.contains("float") {
f32::from_le_bytes(b) as f64
} else if t.contains('u') {
u32::from_le_bytes(b) as f64
} else {
i32::from_le_bytes(b) as f64
}
}
8 => {
let b = elem_data[0..8].try_into().unwrap();
if t.contains("float") {
f64::from_le_bytes(b)
} else if t.contains('u') {
u64::from_le_bytes(b) as f64
} else {
i64::from_le_bytes(b) as f64
}
}
_ => 0.0,
};
for name in &meta.names {
let target_name = if meta.elements > 1 {
format!("{}[{}]", name, i)
} else {
name.clone()
};
local_updates
.entry(target_name.clone())
.or_default()
.push([ts_s, val]);
last_values.insert(target_name, val);
}
}
}
offset += size as usize;
}
drop(metas);
if !local_updates.is_empty() {
let mut data_map = traced_data.lock().unwrap();
for (name, new_points) in local_updates {
if let Some(entry) = data_map.get_mut(&name) {
for point in new_points {
entry.values.push_back(point);
if let Some(tx) = &entry.recording_tx {
let _ = tx.send(point);
}
}
if let Some(lv) = last_values.get(&name) {
entry.last_value = *lv;
}
while entry.values.len() > 100000 {
entry.values.pop_front();
}
}
}
}
}
}
}
}
impl eframe::App for MarteDebugApp {
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
while let Ok(event) = self.rx_events.try_recv() {
match event {
InternalEvent::Log(log) => {
if !self.log_filters.paused {
self.logs.push_back(log);
if self.logs.len() > 2000 {
self.logs.pop_front();
}
}
}
InternalEvent::Discovery(signals) => {
let mut metas = self.id_to_meta.lock().unwrap();
metas.clear();
for s in &signals {
let meta = metas.entry(s.id).or_insert_with(|| SignalMetadata {
names: Vec::new(),
sig_type: s.sig_type.clone(),
dimensions: s.dimensions,
elements: s.elements,
});
if !meta.names.contains(&s.name) {
meta.names.push(s.name.clone());
}
}
self.logs.push_back(LogEntry {
time: Local::now().format("%H:%M:%S").to_string(),
level: "GUI_INFO".to_string(),
message: format!("Discovery complete: {} signals mapped", signals.len()),
});
}
InternalEvent::Tree(tree) => {
self.app_tree = Some(tree);
}
InternalEvent::NodeInfo(info) => {
self.node_info = info.clone();
if let Some(dialog) = &mut self.info_dialog {
// Try to pretty-print as MARTe2 config if it's a JSON object
let display = if info.trim_start().starts_with('{') {
let converted = convert_config_json(&info);
if converted.is_empty() { info } else { converted }
} else {
info
};
dialog.config_text = display;
dialog.is_loading = false;
}
}
InternalEvent::TraceRequested(name, is_monitored) => {
let mut data_map = self.traced_signals.lock().unwrap();
let entry = data_map.entry(name.clone()).or_insert_with(|| TraceData {
values: VecDeque::with_capacity(10000),
last_value: 0.0,
recording_tx: None,
recording_path: None,
is_monitored,
});
entry.is_monitored = is_monitored;
self.logs.push_back(LogEntry {
time: Local::now().format("%H:%M:%S").to_string(),
level: "GUI_INFO".to_string(),
message: format!("Trace requested for: {}", name),
});
}
InternalEvent::ClearTrace(name) => {
let mut data_map = self.traced_signals.lock().unwrap();
data_map.remove(&name);
for plot in &mut self.plots {
plot.signals.retain(|s| s.source_name != name);
}
}
InternalEvent::UdpStats(count) => {
self.udp_packets = count;
}
InternalEvent::UdpDropped(dropped) => {
self.udp_dropped += dropped as u64;
}
InternalEvent::Connected => {
self.connected = true;
// Wait for connection to stabilize before sending commands
std::thread::sleep(std::time::Duration::from_millis(200));
let _ = self.tx_cmd.send("SERVICE_INFO".to_string());
std::thread::sleep(std::time::Duration::from_millis(100));
let _ = self.tx_cmd.send("TREE".to_string());
// Wait for TREE response before sending next command
std::thread::sleep(std::time::Duration::from_millis(500));
let _ = self.tx_cmd.send("DISCOVER".to_string());
}
InternalEvent::ServiceConfig { udp_port, log_port } => {
let mut changed = false;
if !udp_port.is_empty() && self.config.udp_port != udp_port {
self.config.udp_port = udp_port;
changed = true;
}
if !log_port.is_empty() && self.config.log_port != log_port {
self.config.log_port = log_port;
changed = true;
}
if changed {
self.config.version += 1;
*self.shared_config.lock().unwrap() = self.config.clone();
self.logs.push_back(LogEntry {
time: Local::now().format("%H:%M:%S").to_string(),
level: "GUI_INFO".to_string(),
message: format!("Config updated from server: UDP={}, LOG={}", self.config.udp_port, self.config.log_port),
});
}
}
InternalEvent::Disconnected => {
self.connected = false;
}
InternalEvent::InternalLog(msg) => {
self.logs.push_back(LogEntry {
time: Local::now().format("%H:%M:%S").to_string(),
level: "GUI_ERROR".to_string(),
message: msg,
});
}
InternalEvent::CommandResponse(resp) => {
// Resolve pending MSG history entry
if let Some(idx) = self.pending_msg_idx {
if resp.contains("MSG") {
if let Some(entry) = self.message_history.get_mut(idx) {
entry.response = resp.clone();
entry.status = if resp.starts_with("OK") {
MsgStatus::Success
} else {
MsgStatus::Failure
};
}
self.pending_msg_idx = None;
}
}
self.logs.push_back(LogEntry {
time: Local::now().format("%H:%M:%S").to_string(),
level: "CMD_RESP".to_string(),
message: resp,
});
}
InternalEvent::ConfigResponse(text) => {
self.app_config_text = convert_config_json(&text);
}
InternalEvent::TelemMatched(_) => {}
InternalEvent::StepStatus { paused, paused_at_gam, step_remaining, step_thread: _ } => {
self.step_status = Some((paused, paused_at_gam, step_remaining));
if paused {
self.is_breaking = true;
}
}
InternalEvent::SignalValue { path, value_text, found } => {
if let Some(dialog) = &mut self.info_dialog {
if dialog.path == path {
dialog.value_loading = false;
dialog.value_text = if found { Some(value_text) } else { None };
}
}
}
InternalEvent::RecordPathChosen(name, path) => {
let mut data_map = self.traced_signals.lock().unwrap();
if let Some(entry) = data_map.get_mut(&name) {
let (tx, rx) = unbounded();
entry.recording_tx = Some(tx);
entry.recording_path = Some(path.clone());
let tx_err = self.internal_tx.clone();
thread::spawn(move || {
recording_worker(rx, path, name, tx_err);
});
}
}
InternalEvent::RecordingError(name, err) => {
self.logs.push_back(LogEntry {
time: Local::now().format("%H:%M:%S").to_string(),
level: "REC_ERROR".to_string(),
message: format!("{}: {}", name, err),
});
}
}
}
// Poll STEP_STATUS: fast while debugging, slow background poll to catch conditional breaks
if self.connected {
let elapsed = self.last_step_poll.elapsed();
let interval = if self.is_breaking {
std::time::Duration::from_millis(500)
} else {
std::time::Duration::from_secs(2)
};
if elapsed >= interval {
let _ = self.tx_cmd.send("STEP_STATUS".to_string());
self.last_step_poll = std::time::Instant::now();
}
if self.is_breaking {
ctx.request_repaint_after(std::time::Duration::from_millis(500));
}
}
if self.scope.enabled {
self.apply_trigger_logic();
}
if let Some(dragged_name) =
ctx.data_mut(|d| d.get_temp::<String>(egui::Id::new("drag_signal")))
{
egui::Area::new(egui::Id::new("drag_ghost"))
.fixed_pos(ctx.input(|i| i.pointer.hover_pos().unwrap_or(egui::Pos2::ZERO)))
.order(egui::Order::Tooltip)
.show(ctx, |ui| {
ui.group(|ui| {
ui.label(format!("📈 {}", dragged_name));
});
});
}
if let Some(dialog) = &mut self.forcing_dialog {
let mut close = false;
egui::Window::new("Force Signal").show(ctx, |ui| {
ui.label(&dialog.signal_path);
ui.text_edit_singleline(&mut dialog.value);
ui.horizontal(|ui| {
if ui.button("Apply").clicked() {
let _ = self
.tx_cmd
.send(format!("FORCE {} {}", dialog.signal_path, dialog.value));
self.forced_signals
.insert(dialog.signal_path.clone(), dialog.value.clone());
close = true;
}
if ui.button("Cancel").clicked() {
close = true;
}
});
});
if close {
self.forcing_dialog = None;
}
}
if self.break_dialog.is_some() {
let mut dialog = self.break_dialog.take().unwrap();
let mut close = false;
let ops = [">", "<", "==", ">=", "<=", "!="];
egui::Window::new("Set Conditional Break").show(ctx, |ui| {
ui.label(egui::RichText::new(&dialog.signal_path).monospace().strong());
ui.separator();
ui.horizontal(|ui| {
ui.label("Condition:");
egui::ComboBox::from_id_salt("break_op_combo")
.selected_text(&dialog.op)
.width(60.0)
.show_ui(ui, |ui| {
for op in &ops {
ui.selectable_value(&mut dialog.op, op.to_string(), *op);
}
});
ui.text_edit_singleline(&mut dialog.threshold);
});
ui.label(egui::RichText::new(format!(
"Pause RT when: signal {} {}",
dialog.op, dialog.threshold
)).small().color(egui::Color32::GRAY));
ui.separator();
ui.horizontal(|ui| {
if ui.button("✔ Apply").clicked() {
if let Ok(thr) = dialog.threshold.parse::<f64>() {
let _ = self.tx_cmd.send(format!(
"BREAK {} {} {}",
dialog.signal_path, dialog.op, thr
));
self.break_conditions.insert(
dialog.signal_path.clone(),
(dialog.op.clone(), thr),
);
}
close = true;
}
if ui.button("🗑 Clear Break").clicked() {
let _ = self.tx_cmd.send(format!("BREAK {} OFF", dialog.signal_path));
self.break_conditions.remove(&dialog.signal_path);
close = true;
}
if ui.button("Cancel").clicked() {
close = true;
}
});
});
if !close {
self.break_dialog = Some(dialog);
}
}
if let Some(dialog) = &mut self.monitoring_dialog {
let mut close = false;
egui::Window::new("Monitor Signal").show(ctx, |ui| {
ui.label(&dialog.signal_path);
ui.horizontal(|ui| {
ui.label("Period (ms):");
ui.text_edit_singleline(&mut dialog.period_ms);
});
ui.horizontal(|ui| {
if ui.button("Apply").clicked() {
let period = dialog.period_ms.parse::<u32>().unwrap_or(100);
let _ = self
.tx_cmd
.send(format!("MONITOR SIGNAL {} {}", dialog.signal_path, period));
let _ = self.tx_cmd.send("DISCOVER".to_string());
// Check if it's an array signal to add all elements to view
let mut elements = 1;
if let Some(tree) = &self.app_tree {
// Helper to find item in tree
fn find_item<'a>(item: &'a TreeItem, target: &str, current: &str) -> Option<&'a TreeItem> {
let path = if current.is_empty() { item.name.clone() } else { format!("{}.{}", current, item.name) };
if path == target || (current.is_empty() && item.name == "Root" && target.is_empty()) { return Some(item); }
if let Some(children) = &item.children {
for child in children {
if let Some(found) = find_item(child, target, &path) { return Some(found); }
}
}
None
}
if let Some(found) = find_item(tree, &dialog.signal_path, "") {
elements = found.elements.unwrap_or(1);
}
}
if elements > 1 {
for i in 0..elements {
let elem_path = format!("{}[{}]", dialog.signal_path, i);
let _ = self.internal_tx.send(InternalEvent::TraceRequested(elem_path, true));
}
} else {
let _ = self
.internal_tx
.send(InternalEvent::TraceRequested(dialog.signal_path.clone(), true));
}
close = true;
}
if ui.button("Cancel").clicked() {
close = true;
}
});
});
if close {
self.monitoring_dialog = None;
}
}
if self.message_dialog.is_some() {
let mut dialog = self.message_dialog.take().unwrap();
let mut close = false;
let objects = self.get_all_objects();
egui::Window::new("Send MARTe Message").show(ctx, |ui| {
egui::Grid::new("msg_grid").num_columns(2).show(ui, |ui| {
ui.label("Destination:");
egui::ComboBox::from_id_salt("dest_combo")
.selected_text(&dialog.destination)
.width(200.0)
.show_ui(ui, |ui| {
for obj in objects {
ui.selectable_value(&mut dialog.destination, obj.clone(), obj);
}
});
ui.end_row();
ui.label("Function:");
ui.text_edit_singleline(&mut dialog.function);
ui.end_row();
ui.label("Payload:");
ui.vertical(|ui| {
ui.text_edit_multiline(&mut dialog.payload);
ui.label(egui::RichText::new("Format: Key = Value (one per line)").small().weak());
});
ui.end_row();
ui.label("Wait Reply:");
ui.checkbox(&mut dialog.expect_reply, "");
ui.end_row();
});
ui.horizontal(|ui| {
if ui.button("🚀 Send").clicked() {
let wait = if dialog.expect_reply { "1" } else { "0" };
let encoded_payload = dialog.payload.replace('\n', "\\n");
let cmd = format!(
"MSG {} {} {} {}",
dialog.destination, dialog.function, wait, encoded_payload
);
let idx = self.message_history.len();
self.message_history.push(MessageHistoryEntry {
time: Local::now().format("%H:%M:%S").to_string(),
destination: dialog.destination.clone(),
function: dialog.function.clone(),
payload: dialog.payload.clone(),
wait_reply: dialog.expect_reply,
raw_cmd: cmd.clone(),
response: String::new(),
status: MsgStatus::Unknown,
});
self.pending_msg_idx = Some(idx);
let _ = self.tx_cmd.send(cmd);
close = true;
}
if ui.button("Cancel").clicked() {
close = true;
}
});
});
if !close {
self.message_dialog = Some(dialog);
}
}
if let Some((p_idx, s_idx)) = self.style_editor {
let mut close = false;
egui::Window::new("Signal Style").show(ctx, |ui| {
if let Some(plot) = self.plots.get_mut(p_idx) {
if let Some(sig) = plot.signals.get_mut(s_idx) {
ui.horizontal(|ui| {
ui.label("Label:");
ui.text_edit_singleline(&mut sig.label);
});
ui.horizontal(|ui| {
ui.label("Unit:");
ui.text_edit_singleline(&mut sig.unit);
});
ui.horizontal(|ui| {
ui.label("Color:");
let mut color = sig.color.to_array();
if ui
.color_edit_button_srgba_unmultiplied(&mut color)
.changed()
{
sig.color = egui::Color32::from_rgba_unmultiplied(
color[0], color[1], color[2], color[3],
);
}
});
ui.horizontal(|ui| {
ui.label("Gain:");
ui.add(egui::DragValue::new(&mut sig.gain).speed(0.1));
});
ui.horizontal(|ui| {
ui.label("Offset:");
ui.add(egui::DragValue::new(&mut sig.offset).speed(1.0));
});
if ui.button("Close").clicked() {
close = true;
}
}
}
});
if close {
self.style_editor = None;
}
}
if self.info_dialog.is_some() {
let mut close = false;
let mut send_value_cmd: Option<String> = None;
{
let dialog = self.info_dialog.as_mut().unwrap();
let max_h = ctx.available_rect().height() * 0.75;
let title = format!("ℹ {}", dialog.path);
egui::Window::new(title)
.resizable(true)
.default_width(480.0)
.max_height(max_h)
.show(ctx, |ui| {
// Always-visible close button at top-right
ui.horizontal(|ui| {
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.button("✖ Close").clicked() {
close = true;
}
});
});
ui.separator();
if dialog.is_signal {
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Value:").color(egui::Color32::GRAY));
if dialog.value_loading {
ui.spinner();
} else {
match &dialog.value_text {
Some(v) => {
ui.label(egui::RichText::new(v.as_str())
.monospace().strong()
.color(egui::Color32::from_rgb(100, 220, 255)));
}
None => {
ui.label(egui::RichText::new("—").color(egui::Color32::GRAY));
}
}
}
if ui.small_button("🔄").on_hover_text("Refresh value").clicked() {
send_value_cmd = Some(dialog.path.clone());
dialog.value_loading = true;
}
});
ui.separator();
}
if dialog.is_loading {
ui.spinner();
ui.label(egui::RichText::new("Loading config…").italics().color(egui::Color32::GRAY));
} else if dialog.config_text.is_empty() {
ui.label(egui::RichText::new("No config available").italics().color(egui::Color32::GRAY));
} else {
egui::ScrollArea::both()
.auto_shrink([true, true])
.max_height(max_h - 120.0)
.show(ui, |ui| {
ui.add(
egui::Label::new(
egui::RichText::new(&dialog.config_text).monospace().small()
).selectable(true),
);
});
}
});
}
if let Some(path) = send_value_cmd {
let _ = self.tx_cmd.send(format!("VALUE {}", path));
}
if close {
self.info_dialog = None;
}
}
egui::TopBottomPanel::top("top").show(ctx, |ui| {
ui.horizontal(|ui| {
ui.toggle_value(&mut self.show_left_panel, "🗂 Tree");
ui.toggle_value(&mut self.show_right_panel, "📊 Signals");
ui.toggle_value(&mut self.show_message_history, "💬 Msgs");
ui.toggle_value(&mut self.show_bottom_panel, "📜 Logs");
ui.separator();
if ui.button("➕ Plot").clicked() {
self.plots.push(PlotInstance {
id: format!("Plot {}", self.plots.len() + 1),
plot_type: PlotType::Normal,
signals: Vec::new(),
auto_bounds: true,
max_points: 5000,
follow: true,
reset_view: false,
});
}
ui.separator();
let (btn_text, btn_color) = if self.is_breaking {
("▶ Resume App", egui::Color32::GREEN)
} else {
("⏸ Pause App", egui::Color32::YELLOW)
};
if ui
.button(egui::RichText::new(btn_text).color(btn_color))
.clicked()
{
self.is_breaking = !self.is_breaking;
let _ = self.tx_cmd.send(if self.is_breaking {
"PAUSE".to_string()
} else {
"RESUME".to_string()
});
if !self.is_breaking {
self.step_status = None;
}
self.last_step_poll = std::time::Instant::now() - std::time::Duration::from_secs(1);
}
ui.separator();
ui.checkbox(&mut self.scope.enabled, "🔭 Scope");
if self.scope.enabled {
egui::ComboBox::from_id_salt("window_size")
.selected_text(format!("{}ms", self.scope.window_ms))
.show_ui(ui, |ui| {
for ms in [
10.0, 20.0, 50.0, 100.0, 200.0, 500.0, 1000.0, 2000.0, 5000.0,
10000.0,
] {
ui.selectable_value(
&mut self.scope.window_ms,
ms,
format!("{}ms", ms),
);
}
});
ui.selectable_value(&mut self.scope.mode, AcquisitionMode::FreeRun, "Free");
ui.selectable_value(&mut self.scope.mode, AcquisitionMode::Triggered, "Trig");
if self.scope.mode == AcquisitionMode::FreeRun {
if ui
.button(if self.scope.paused {
"▶ Resume"
} else {
"⏸ Pause"
})
.clicked()
{
self.scope.paused = !self.scope.paused;
}
} else {
if ui
.button(if self.scope.is_armed {
"🔴 Armed"
} else {
"⚪ Single"
})
.clicked()
{
self.scope.is_armed = true;
self.scope.trigger_active = false;
}
ui.menu_button("⚙ Trig", |ui| {
egui::Grid::new("trig").num_columns(2).show(ui, |ui| {
ui.label("Source:");
ui.text_edit_singleline(&mut self.scope.trigger_source);
ui.end_row();
ui.label("Edge:");
egui::ComboBox::from_id_salt("edge")
.selected_text(format!("{:?}", self.scope.trigger_edge))
.show_ui(ui, |ui| {
ui.selectable_value(
&mut self.scope.trigger_edge,
TriggerEdge::Rising,
"Rising",
);
ui.selectable_value(
&mut self.scope.trigger_edge,
TriggerEdge::Falling,
"Falling",
);
ui.selectable_value(
&mut self.scope.trigger_edge,
TriggerEdge::Both,
"Both",
);
});
ui.end_row();
ui.label("Thresh:");
ui.add(
egui::DragValue::new(&mut self.scope.trigger_threshold)
.speed(0.1),
);
ui.end_row();
ui.label("Pre %:");
ui.add(egui::Slider::new(
&mut self.scope.pre_trigger_percent,
0.0..=100.0,
));
ui.end_row();
ui.label("Type:");
ui.selectable_value(
&mut self.scope.trigger_type,
TriggerType::Single,
"Single",
);
ui.selectable_value(
&mut self.scope.trigger_type,
TriggerType::Continuous,
"Cont",
);
ui.end_row();
});
});
}
}
ui.separator();
ui.menu_button("🔌 Conn", |ui| {
egui::Grid::new("conn_grid").num_columns(2).show(ui, |ui| {
ui.label("IP:");
ui.text_edit_singleline(&mut self.config.ip);
ui.end_row();
ui.label("Control:");
ui.text_edit_singleline(&mut self.config.tcp_port);
ui.end_row();
ui.label("Telemetry (Auto):");
ui.label(&self.config.udp_port);
ui.end_row();
ui.label("Logs (Auto):");
ui.label(&self.config.log_port);
ui.end_row();
});
if ui.button("🔄 Apply").clicked() {
self.config.version += 1;
*self.shared_config.lock().unwrap() = self.config.clone();
ui.close_menu();
}
if ui.button("📡 Re-Discover").clicked() {
let _ = self.tx_cmd.send("DISCOVER".to_string());
ui.close_menu();
}
if ui.button("❌ Off").clicked() {
self.config.version += 1;
let mut cfg = self.config.clone();
cfg.ip = "".to_string();
*self.shared_config.lock().unwrap() = cfg;
ui.close_menu();
}
});
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.button("✉ Send Msg").clicked() {
self.message_dialog = Some(MessageDialog {
destination: "".to_string(),
function: "".to_string(),
payload: "".to_string(),
expect_reply: false,
});
}
ui.separator();
ui.label(format!(
"UDP: OK[{}] DROP[{}]",
self.udp_packets, self.udp_dropped
));
});
});
});
if self.show_left_panel {
egui::SidePanel::left("left")
.resizable(true)
.width_range(200.0..=500.0)
.show(ctx, |ui| {
egui::ScrollArea::vertical().show(ui, |ui| {
if let Some(tree) = self.app_tree.clone() {
self.render_tree(ui, &tree, "".to_string());
}
});
});
}
if self.show_right_panel {
egui::SidePanel::right("right")
.resizable(true)
.width_range(250.0..=400.0)
.show(ctx, |ui| {
// Debug Controls pane — shown when app is paused / breaking
if self.is_breaking {
let paused = self.step_status.as_ref().map(|(p, _, _)| *p).unwrap_or(false);
let gam = self.step_status.as_ref().map(|(_, g, _)| g.clone()).unwrap_or_default();
let remaining = self.step_status.as_ref().map(|(_, _, r)| *r).unwrap_or(0);
let threads = self.get_threads();
ui.group(|ui| {
ui.label(egui::RichText::new("⏸ Debug Controls").strong().color(egui::Color32::YELLOW));
ui.separator();
if paused {
if gam.is_empty() {
ui.label(egui::RichText::new("Paused (waiting for break)").color(egui::Color32::from_rgb(255, 200, 100)));
} else {
ui.label(egui::RichText::new("Paused at GAM:").color(egui::Color32::GRAY).small());
ui.label(egui::RichText::new(&gam).monospace().strong().color(egui::Color32::from_rgb(255, 180, 80)));
}
} else {
ui.label(egui::RichText::new(format!("Running ({} steps left)", remaining)).color(egui::Color32::from_rgb(100, 220, 100)));
}
if !threads.is_empty() {
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Thread:").color(egui::Color32::GRAY).small());
let sel = if self.step_thread.is_empty() { "(all)" } else { &self.step_thread };
egui::ComboBox::from_id_salt("step_thread_combo")
.selected_text(sel)
.width(140.0)
.show_ui(ui, |ui| {
ui.selectable_value(&mut self.step_thread, String::new(), "(all)");
for t in &threads {
ui.selectable_value(&mut self.step_thread, t.clone(), t.as_str());
}
});
});
}
ui.add_space(4.0);
ui.horizontal(|ui| {
let thread_arg = if self.step_thread.is_empty() {
String::new()
} else {
format!(" {}", self.step_thread)
};
if ui.button("Step 1").on_hover_text("Run one output broker cycle, then pause").clicked() {
let _ = self.tx_cmd.send(format!("STEP 1{}", thread_arg));
self.step_status = self.step_status.as_ref().map(|(_, g, _)| (false, g.clone(), 1));
}
if ui.button("Step 5").on_hover_text("Run 5 output broker cycles, then pause").clicked() {
let _ = self.tx_cmd.send(format!("STEP 5{}", thread_arg));
self.step_status = self.step_status.as_ref().map(|(_, g, _)| (false, g.clone(), 5));
}
if ui.button(egui::RichText::new("▶ Resume").color(egui::Color32::GREEN)).clicked() {
let _ = self.tx_cmd.send("RESUME".to_string());
self.is_breaking = false;
self.step_status = None;
}
});
});
ui.separator();
}
ui.heading("Traced Signals");
let mut names: Vec<_> = {
let data_map = self.traced_signals.lock().unwrap();
data_map.keys().cloned().collect()
};
names.sort();
let mut open_info_signal: Option<(String, f64)> = None;
egui::ScrollArea::vertical()
.id_salt("traced_scroll")
.show(ui, |ui| {
for key in names {
let (last_val, is_recording, is_monitored) = {
let dm = self.traced_signals.lock().unwrap();
if let Some(e) = dm.get(&key) {
(e.last_value, e.recording_tx.is_some(), e.is_monitored)
} else {
continue;
}
};
ui.horizontal(|ui| {
if is_recording {
ui.label(egui::RichText::new("●").color(egui::Color32::RED));
}
let response = ui.add(
egui::Label::new(format!("{}: {:.2}", key, last_val))
.sense(egui::Sense::drag().union(egui::Sense::click())),
);
if response.drag_started() {
ctx.data_mut(|d| {
d.insert_temp(egui::Id::new("drag_signal"), key.clone())
});
}
if response.double_clicked() {
open_info_signal = Some((key.clone(), last_val));
}
if ui.small_button("ℹ").on_hover_text("Show info / last value").clicked() {
open_info_signal = Some((key.clone(), last_val));
}
response.context_menu(|ui| {
if !is_recording {
if ui.button("⏺ Record to Parquet").clicked() {
let tx = self.internal_tx.clone();
let name_clone = key.clone();
thread::spawn(move || {
if let Some(path) = FileDialog::new()
.add_filter("Parquet", &["parquet"])
.save_file()
{
let _ = tx.send(InternalEvent::RecordPathChosen(
name_clone,
path.to_string_lossy().to_string(),
));
}
});
ui.close_menu();
}
} else {
if ui.button("⏹ Stop").clicked() {
let mut dm = self.traced_signals.lock().unwrap();
if let Some(e) = dm.get_mut(&key) {
e.recording_tx = None;
}
ui.close_menu();
}
}
});
if ui.button("❌").clicked() {
if is_monitored {
let _ = self.tx_cmd.send(format!("UNMONITOR SIGNAL {}", key));
} else {
let _ = self.tx_cmd.send(format!("TRACE {} 0", key));
}
let _ = self.internal_tx.send(InternalEvent::ClearTrace(key.clone()));
}
});
}
});
if let Some((sig_path, last_val)) = open_info_signal {
let _ = self.tx_cmd.send(format!("INFO {}", sig_path));
let _ = self.tx_cmd.send(format!("VALUE {}", sig_path));
self.info_dialog = Some(InfoDialog {
path: sig_path,
is_signal: true,
config_text: String::new(),
is_loading: true,
value_text: None,
value_loading: true,
});
}
ui.separator();
ui.heading("Forced Signals");
let mut to_delete = Vec::new();
for (path, val) in &self.forced_signals {
ui.horizontal(|ui| {
ui.label(format!("{}: {}", path, val));
if ui.button("❌").clicked() {
let _ = self.tx_cmd.send(format!("UNFORCE {}", path));
to_delete.push(path.to_owned());
}
});
}
for key in to_delete.iter() {
self.forced_signals.remove(key);
}
ui.separator();
ui.heading("Breakpoints");
if self.break_conditions.is_empty() {
ui.label(egui::RichText::new("No active breakpoints").italics().color(egui::Color32::GRAY));
} else {
let mut to_clear: Vec<String> = Vec::new();
let mut to_edit: Option<String> = None;
let mut sorted_breaks: Vec<_> = self.break_conditions.iter().collect();
sorted_breaks.sort_by_key(|(k, _)| k.as_str());
for (path, (op, thr)) in &sorted_breaks {
ui.horizontal(|ui| {
ui.label(
egui::RichText::new(format!("🔴 {} {} {}", path, op, thr))
.color(egui::Color32::from_rgb(255, 120, 120))
.monospace()
.small(),
);
if ui.small_button("✏").on_hover_text("Edit").clicked() {
to_edit = Some(path.to_string());
}
if ui.small_button("❌").on_hover_text("Clear break").clicked() {
to_clear.push(path.to_string());
}
});
}
for path in to_clear {
let _ = self.tx_cmd.send(format!("BREAK {} OFF", path));
self.break_conditions.remove(&path);
}
if let Some(path) = to_edit {
let (op, thr) = self.break_conditions[&path].clone();
self.break_dialog = Some(BreakDialog {
signal_path: path,
op,
threshold: thr.to_string(),
});
}
}
if self.show_message_history {
ui.separator();
ui.horizontal(|ui| {
ui.heading("Message History");
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.small_button("🗑 Clear").clicked() {
self.message_history.clear();
self.pending_msg_idx = None;
}
});
});
if self.message_history.is_empty() {
ui.label(egui::RichText::new("No messages sent yet").italics().color(egui::Color32::GRAY));
} else {
egui::ScrollArea::vertical()
.id_salt("msg_history_scroll")
.max_height(300.0)
.auto_shrink([false, true])
.show(ui, |ui| {
let mut resend_cmd: Option<String> = None;
let mut edit_dialog: Option<MessageDialog> = None;
for entry in self.message_history.iter().rev() {
let (status_icon, status_color) = match entry.status {
MsgStatus::Success => ("✔", egui::Color32::from_rgb(100, 220, 100)),
MsgStatus::Failure => ("✘", egui::Color32::from_rgb(255, 100, 100)),
MsgStatus::Unknown => ("…", egui::Color32::from_rgb(255, 220, 50)),
};
ui.group(|ui| {
ui.horizontal(|ui| {
ui.label(egui::RichText::new(status_icon).color(status_color).strong());
ui.label(egui::RichText::new(&entry.time).color(egui::Color32::GRAY).monospace().small());
});
ui.label(format!("→ {}.{}", entry.destination, entry.function));
if !entry.payload.is_empty() {
ui.label(egui::RichText::new(&entry.payload).monospace().small().color(egui::Color32::from_rgb(180, 180, 255)));
}
if !entry.response.is_empty() {
ui.label(egui::RichText::new(&entry.response).small().color(status_color));
}
ui.horizontal(|ui| {
if ui.small_button("↩ Resend").clicked() {
resend_cmd = Some(entry.raw_cmd.clone());
}
if ui.small_button("✏ Edit").clicked() {
edit_dialog = Some(MessageDialog {
destination: entry.destination.clone(),
function: entry.function.clone(),
payload: entry.payload.clone(),
expect_reply: entry.wait_reply,
});
}
});
});
}
if let Some(cmd) = resend_cmd {
let idx = self.message_history.len();
// find the matching history entry to clone metadata
if let Some(orig) = self.message_history.iter().find(|e| e.raw_cmd == cmd) {
self.message_history.push(MessageHistoryEntry {
time: Local::now().format("%H:%M:%S").to_string(),
destination: orig.destination.clone(),
function: orig.function.clone(),
payload: orig.payload.clone(),
wait_reply: orig.wait_reply,
raw_cmd: cmd.clone(),
response: String::new(),
status: MsgStatus::Unknown,
});
}
self.pending_msg_idx = Some(idx);
let _ = self.tx_cmd.send(cmd);
}
if let Some(dialog) = edit_dialog {
self.message_dialog = Some(dialog);
}
});
}
}
});
}
if self.show_bottom_panel {
egui::TopBottomPanel::bottom("log_panel")
.resizable(true)
.default_height(150.0)
.show(ctx, |ui| {
ui.horizontal(|ui| {
ui.heading("Logs");
ui.separator();
ui.checkbox(&mut self.log_filters.show_debug, "Debug");
ui.checkbox(&mut self.log_filters.show_info, "Info");
ui.checkbox(&mut self.log_filters.show_warning, "Warn");
ui.checkbox(&mut self.log_filters.show_error, "Error");
ui.separator();
ui.label("Filter:");
ui.text_edit_singleline(&mut self.log_filters.content_regex);
if ui.button("🗑 Clear").clicked() {
self.logs.clear();
}
});
ui.separator();
let regex = if !self.log_filters.content_regex.is_empty() {
Regex::new(&self.log_filters.content_regex).ok()
} else {
None
};
egui::ScrollArea::vertical()
.stick_to_bottom(true)
.auto_shrink([false, false])
.show(ui, |ui| {
for log in &self.logs {
let show = match log.level.as_str() {
"Debug" => self.log_filters.show_debug,
"Information" | "GUI_INFO" | "GUI_WARN" | "CMD_RESP" => {
self.log_filters.show_info
}
"Warning" => self.log_filters.show_warning,
"FatalError" | "OSError" | "ParametersError" | "GUI_ERROR"
| "REC_ERROR" => self.log_filters.show_error,
_ => true,
};
if !show {
continue;
}
if let Some(re) = &regex {
if !re.is_match(&log.message) && !re.is_match(&log.level) {
continue;
}
}
let color = match log.level.as_str() {
"FatalError" | "OSError" | "ParametersError" | "GUI_ERROR"
| "REC_ERROR" => egui::Color32::from_rgb(255, 100, 100),
"Warning" | "GUI_WARN" => {
egui::Color32::from_rgb(255, 255, 100)
}
"Information" | "GUI_INFO" => {
egui::Color32::from_rgb(100, 255, 100)
}
"Debug" => egui::Color32::from_rgb(100, 100, 255),
"CMD_RESP" => egui::Color32::from_rgb(255, 255, 255),
_ => egui::Color32::WHITE,
};
ui.horizontal_wrapped(|ui| {
ui.label(
egui::RichText::new(&log.time)
.color(egui::Color32::GRAY)
.monospace(),
);
ui.label(
egui::RichText::new(format!("[{}]", log.level))
.color(color)
.strong(),
);
ui.add(egui::Label::new(&log.message).wrap());
});
}
});
});
}
egui::CentralPanel::default().show(ctx, |ui| {
ui.horizontal(|ui| {
ui.selectable_value(&mut self.active_main_tab, MainTab::Plots, "📈 Plots");
ui.selectable_value(&mut self.active_main_tab, MainTab::Config, "⚙ Config");
});
ui.separator();
if self.active_main_tab == MainTab::Config {
ui.horizontal(|ui| {
if ui.button("🔄 Refresh").clicked() {
let _ = self.tx_cmd.send("CONFIG".to_string());
}
ui.label(egui::RichText::new("Application Configuration").color(egui::Color32::GRAY));
});
ui.separator();
egui::ScrollArea::both()
.auto_shrink([false, false])
.show(ui, |ui| {
if self.app_config_text.is_empty() {
ui.label(egui::RichText::new("Press Refresh to load the configuration").italics().color(egui::Color32::GRAY));
} else {
ui.add(
egui::Label::new(
egui::RichText::new(&self.app_config_text).monospace(),
)
.selectable(true),
);
}
});
return;
}
let n_plots = self.plots.len();
if n_plots > 0 {
let plot_height = ui.available_height() / n_plots as f32;
let mut to_remove = None;
let mut current_range = None;
for (p_idx, plot_inst) in self.plots.iter_mut().enumerate() {
ui.group(|ui| {
ui.horizontal(|ui| {
ui.label(egui::RichText::new(&plot_inst.id).strong());
ui.selectable_value(&mut plot_inst.plot_type, PlotType::Normal, "Series");
ui.selectable_value(&mut plot_inst.plot_type, PlotType::LogicAnalyzer, "Logic");
ui.separator();
let follow_text = if plot_inst.follow {
egui::RichText::new("▶ Follow").color(egui::Color32::from_rgb(100, 220, 100))
} else {
egui::RichText::new("▶ Follow").color(egui::Color32::GRAY)
};
if ui.toggle_value(&mut plot_inst.follow, follow_text)
.on_hover_text("Follow latest data (auto-scroll X axis)")
.changed()
{
if plot_inst.follow {
plot_inst.auto_bounds = true;
self.shared_x_range = None;
}
}
if ui.button("↺ Reset").on_hover_text("Reset view to fit all data").clicked() {
plot_inst.auto_bounds = true;
plot_inst.follow = true;
plot_inst.reset_view = true;
self.shared_x_range = None;
}
ui.separator();
ui.label(egui::RichText::new("Pts:").color(egui::Color32::GRAY).small());
ui.add(egui::DragValue::new(&mut plot_inst.max_points).range(100..=100000).speed(100.0))
.on_hover_text("Max points per line (lower = faster rendering)");
ui.separator();
if ui.button("🗑").clicked() {
to_remove = Some(p_idx);
}
});
let mut plot = Plot::new(&plot_inst.id)
.height(plot_height - 40.0)
.show_axes([true, true]);
plot = plot.x_axis_formatter(|mark, _range| {
let val = mark.value;
let hours = (val / 3600.0) as u32;
let mins = ((val % 3600.0) / 60.0) as u32;
let secs = val % 60.0;
format!("{:02}:{:02}:{:05.2}", hours, mins, secs)
});
let data_map = self.traced_signals.lock().unwrap();
let mut latest_t = 0.0;
for sig_cfg in &plot_inst.signals {
if let Some(data) = data_map.get(&sig_cfg.source_name) {
if let Some(last) = data.values.back() {
if last[0] > latest_t {
latest_t = last[0];
}
}
}
}
if self.scope.enabled {
let window_s = self.scope.window_ms / 1000.0;
let center_t = if self.scope.mode == AcquisitionMode::Triggered {
if self.scope.trigger_active {
self.scope.last_trigger_time
} else {
latest_t
}
} else {
latest_t
};
let x_min =
center_t - (self.scope.pre_trigger_percent / 100.0) * window_s;
plot = plot.include_x(x_min).include_x(x_min + window_s);
if !self.scope.paused {
plot = plot.auto_bounds(egui::Vec2b::new(true, true));
}
} else {
if let Some(range) = self.shared_x_range {
if !plot_inst.auto_bounds {
plot = plot.include_x(range[0]).include_x(range[1]);
}
}
if plot_inst.auto_bounds {
plot = plot.auto_bounds(egui::Vec2b::new(true, true));
}
}
// Pre-compute fit bounds if a reset was requested (reset_view flag).
// Must be done before plot.show() so we can call set_plot_bounds inside.
let fit_bounds: Option<PlotBounds> = if plot_inst.reset_view {
let mut min_t = f64::INFINITY;
let mut max_t = f64::NEG_INFINITY;
let mut min_v = f64::INFINITY;
let mut max_v = f64::NEG_INFINITY;
let max_pts = plot_inst.max_points;
for (s_idx, sig_cfg) in plot_inst.signals.iter().enumerate() {
if let Some(data) = data_map.get(&sig_cfg.source_name) {
for [t, v] in data.values.iter().rev().take(max_pts) {
let mut fv = *v * sig_cfg.gain + sig_cfg.offset;
if plot_inst.plot_type == PlotType::LogicAnalyzer {
fv = (s_idx as f64 * 1.5) + (if fv > 0.5 { 1.0 } else { 0.0 });
}
if *t < min_t { min_t = *t; }
if *t > max_t { max_t = *t; }
if fv < min_v { min_v = fv; }
if fv > max_v { max_v = fv; }
}
}
}
if min_t.is_finite() && max_t.is_finite() && min_v.is_finite() && max_v.is_finite() {
let pad_t = (max_t - min_t).abs() * 0.02 + 0.01;
let pad_v = (max_v - min_v).abs() * 0.05 + 0.01;
Some(PlotBounds::from_min_max(
[min_t - pad_t, min_v - pad_v],
[max_t + pad_t, max_v + pad_v],
))
} else {
None
}
} else {
None
};
let plot_resp = plot.show(ui, |plot_ui| {
if let Some(bounds) = fit_bounds {
plot_ui.set_plot_bounds(bounds);
plot_inst.reset_view = false;
}
if !self.scope.enabled && !plot_inst.auto_bounds {
if let Some(range) = self.shared_x_range {
let bounds = plot_ui.plot_bounds();
plot_ui.set_plot_bounds(PlotBounds::from_min_max(
[range[0], bounds.min()[1]],
[range[1], bounds.max()[1]],
));
}
}
if self.scope.enabled
&& self.scope.mode == AcquisitionMode::Triggered
&& self.scope.trigger_active
{
plot_ui.vline(
VLine::new(self.scope.last_trigger_time)
.color(egui::Color32::YELLOW)
.style(LineStyle::Dashed { length: 5.0 }),
);
}
let max_pts = plot_inst.max_points;
for (s_idx, sig_cfg) in plot_inst.signals.iter().enumerate() {
if let Some(data) = data_map.get(&sig_cfg.source_name) {
let points_iter =
data.values.iter().rev().take(max_pts).rev().map(|[t, v]| {
let mut final_v = *v * sig_cfg.gain + sig_cfg.offset;
if plot_inst.plot_type == PlotType::LogicAnalyzer {
final_v = (s_idx as f64 * 1.5)
+ (if final_v > 0.5 { 1.0 } else { 0.0 });
}
[*t, final_v]
});
plot_ui.line(
Line::new(PlotPoints::from_iter(points_iter))
.name(&sig_cfg.label)
.color(sig_cfg.color),
);
}
}
if p_idx == 0 || current_range.is_none() {
let b = plot_ui.plot_bounds();
current_range = Some([b.min()[0], b.max()[0]]);
}
});
drop(data_map);
if plot_resp.response.hovered() && ctx.input(|i| i.pointer.any_released()) {
if let Some(dropped) =
ctx.data_mut(|d| d.get_temp::<String>(egui::Id::new("drag_signal")))
{
let color = Self::next_color(plot_inst.signals.len());
plot_inst.signals.push(SignalPlotConfig {
source_name: dropped.clone(),
label: dropped.clone(),
unit: "".to_string(),
color,
line_style: LineStyle::Solid,
marker_type: MarkerType::None,
gain: 1.0,
offset: 0.0,
});
ctx.data_mut(|d| {
d.remove_temp::<String>(egui::Id::new("drag_signal"))
});
}
}
if plot_resp.response.dragged()
|| ctx.input(|i| i.smooth_scroll_delta.y != 0.0)
{
if plot_resp.response.hovered() {
plot_inst.auto_bounds = false;
plot_inst.follow = false;
let b = plot_resp.transform.bounds();
self.shared_x_range = Some([b.min()[0], b.max()[0]]);
}
}
// Re-apply follow on each frame when follow is active
if plot_inst.follow && !self.scope.enabled {
plot_inst.auto_bounds = true;
}
plot_resp.response.context_menu(|ui| {
if ui.button("🔍 Fit View").clicked() {
plot_inst.auto_bounds = true;
plot_inst.follow = true;
plot_inst.reset_view = true;
self.shared_x_range = None;
ui.close_menu();
}
ui.separator();
let mut sig_to_remove = None;
for (s_idx, sig) in plot_inst.signals.iter().enumerate() {
ui.horizontal(|ui| {
ui.label(&sig.label);
if ui.button("🎨 Style").clicked() {
self.style_editor = Some((p_idx, s_idx));
ui.close_menu();
}
if ui.button("❌ Remove").clicked() {
sig_to_remove = Some(s_idx);
ui.close_menu();
}
});
}
if let Some(idx) = sig_to_remove {
plot_inst.signals.remove(idx);
}
});
});
}
if let Some(idx) = to_remove {
self.plots.remove(idx);
}
if !self.scope.enabled {
if let Some(range) = current_range {
if self.shared_x_range.is_none() {
self.shared_x_range = Some(range);
}
}
}
} else {
ui.centered_and_justified(|ui| {
ui.label("Add a plot panel to begin analysis");
});
}
});
ctx.request_repaint_after(std::time::Duration::from_millis(16));
}
}
#[cfg(test)]
mod tests {
use super::*;
/// Parse MARTe2 config text into a serde_json Value tree so tests can do
/// structural comparisons without caring about whitespace or key ordering.
///
/// Rules:
/// `[+]Name = {` → start of a named block
/// `}` → close current block
/// `Name = Value` → leaf key-value (value stripped of surrounding quotes)
/// `Name = {value}` (e.g. `Functions = {GAM1}`) → leaf, not a block
fn parse_marte_config(text: &str) -> serde_json::Value {
let mut stack: Vec<serde_json::Map<String, serde_json::Value>> =
vec![serde_json::Map::new()];
let mut name_stack: Vec<String> = vec![];
for line in text.lines() {
let trimmed = line.trim();
if trimmed.is_empty() || trimmed.starts_with("//") || trimmed.starts_with("/*") {
continue;
}
if trimmed == "}" {
if stack.len() > 1 {
let child = stack.pop().unwrap();
let name = name_stack.pop().unwrap();
stack.last_mut().unwrap().insert(name, serde_json::Value::Object(child));
}
continue;
}
let clean = trimmed.trim_start_matches('+');
if let Some(eq_pos) = clean.find('=') {
let key = clean[..eq_pos].trim().to_string();
let val = clean[eq_pos + 1..].trim();
// A block opens only if the value is exactly `{`
if val == "{" {
stack.push(serde_json::Map::new());
name_stack.push(key);
} else {
let val_clean = val.trim_matches('"').to_string();
stack.last_mut().unwrap().insert(key, serde_json::Value::String(val_clean));
}
}
}
serde_json::Value::Object(stack.remove(0))
}
/// Recursively assert that every object key with a `Class` value in `expected`
/// also exists with the same `Class` in `actual`. Missing non-Class keys are
/// tolerated because `ExportData()` does not re-emit config-file-only fields
/// (e.g. signal configurations, Frequency, Samples).
fn assert_classes_match(
expected: &serde_json::Value,
actual: &serde_json::Value,
path: &str,
) {
use serde_json::Value;
if let (Value::Object(exp_map), Value::Object(act_map)) = (expected, actual) {
if let Some(Value::String(exp_class)) = exp_map.get("Class") {
let act_class = act_map
.get("Class")
.and_then(|v| v.as_str())
.unwrap_or("<missing>");
assert_eq!(
exp_class.as_str(),
act_class,
"Class mismatch at '{}': expected '{}', got '{}'",
path,
exp_class,
act_class
);
}
for (key, exp_child) in exp_map {
if key == "Class" {
continue;
}
if let Some(act_child) = act_map.get(key) {
let child_path = if path.is_empty() {
key.clone()
} else {
format!("{}.{}", path, key)
};
assert_classes_match(exp_child, act_child, &child_path);
}
// Extra keys added by MARTe2 runtime are allowed
}
}
}
// ----- Unit tests for the JSON → MARTe2 converter -----
#[test]
fn test_convert_basic_structure() {
let json = r#"{"App":{"Class":"RealTimeApplication","Functions":{"Class":"ReferenceContainer","GAM1":{"Class":"IOGAM"}}}}"#;
let out = convert_config_json(json);
let parsed = parse_marte_config(&out);
assert_eq!(
parsed["App"]["Class"],
serde_json::Value::String("RealTimeApplication".into())
);
assert_eq!(
parsed["App"]["Functions"]["Class"],
serde_json::Value::String("ReferenceContainer".into())
);
assert_eq!(
parsed["App"]["Functions"]["GAM1"]["Class"],
serde_json::Value::String("IOGAM".into())
);
// Objects with Class must get + prefix
assert!(out.contains("+App = {"), "top-level object missing +");
assert!(out.contains(" +Functions = {"), "nested object with Class missing +");
assert!(out.contains(" +GAM1 = {"), "leaf object with Class missing +");
}
#[test]
fn test_no_plus_for_blocks_without_class() {
let json = r#"{"App":{"Class":"RealTimeApplication","Signals":{"Counter":{"Type":"uint32"}}}}"#;
let out = convert_config_json(json);
// Signals block has no Class → no + prefix
assert!(out.contains(" Signals = {"), "plain block should not have +");
assert!(!out.contains(" +Signals"), "plain block must not have + prefix");
}
#[test]
fn test_class_emitted_first() {
let json = r#"{"App":{"ZZZKey":"last","Class":"RealTimeApplication","AAA":"first_alpha"}}"#;
let out = convert_config_json(json);
let class_pos = out.find("Class = RealTimeApplication").unwrap();
let zzz_pos = out.find("ZZZKey = last").unwrap();
assert!(
class_pos < zzz_pos,
"Class must appear before other keys in the block"
);
}
#[test]
fn test_leaf_values_preserved() {
let json = r#"{"App":{"Class":"RealTimeApplication","ControlPort":"8080","StreamIP":"127.0.0.1"}}"#;
let out = convert_config_json(json);
assert!(out.contains("ControlPort = 8080"));
assert!(out.contains("StreamIP = 127.0.0.1"));
}
#[test]
fn test_round_trip_parse() {
// Build a JSON that mirrors what the server produces for debug_test.cfg
let json = r#"{
"App": {
"Class": "RealTimeApplication",
"Data": {"Class": "ReferenceContainer",
"DDB": {"Class": "GAMDataSource"},
"Timer": {"Class": "LinuxTimer"}
},
"Functions": {"Class": "ReferenceContainer",
"GAM1": {"Class": "IOGAM"},
"GAM2": {"Class": "IOGAM"}
},
"Scheduler": {"Class": "GAMScheduler", "TimingDataSource": "DAMS"},
"States": {"Class": "ReferenceContainer",
"State1": {"Class": "RealTimeState"}
}
},
"DebugService": {
"Class": "DebugService",
"ControlPort": "8080",
"UdpPort": "8081"
}
}"#;
let out = convert_config_json(json);
let cfg_path = concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../Test/Configurations/debug_test.cfg"
);
let original = std::fs::read_to_string(cfg_path).expect("debug_test.cfg not found");
// Parse both into trees and check that all Class values from the
// converted output are consistent with the original config
let converted_tree = parse_marte_config(&out);
let original_tree = parse_marte_config(&original);
assert_classes_match(&converted_tree, &original_tree, "");
// And vice-versa for the subset present in the JSON fixture
assert_classes_match(&original_tree, &converted_tree, "");
}
// ----- Integration test (requires running MARTe2 app) -----
#[test]
#[ignore = "requires running MARTe2 debug app — start with ./run_debug_app.sh first"]
fn test_live_config_matches_debug_test_cfg() {
use std::io::{BufRead, BufReader, Write};
use std::net::TcpStream;
use std::time::Duration;
let mut stream = TcpStream::connect("127.0.0.1:8080")
.expect("Could not connect to DebugService on 127.0.0.1:8080");
stream
.set_read_timeout(Some(Duration::from_secs(15)))
.unwrap();
stream.write_all(b"CONFIG\n").unwrap();
// Accumulate lines until the "OK CONFIG" sentinel
let reader = BufReader::new(stream);
let mut json_lines: Vec<String> = Vec::new();
for line in reader.lines() {
let line = line.expect("read error while receiving CONFIG response");
if line.trim() == "OK CONFIG" {
break;
}
json_lines.push(line);
}
let json_text = json_lines.join("\n");
assert!(!json_text.is_empty(), "Received empty CONFIG response from server");
// Convert server JSON to MARTe2 syntax
let converted = convert_config_json(&json_text);
assert!(!converted.is_empty(), "convert_config_json produced empty output");
// Load the reference config
let cfg_path = concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../Test/Configurations/debug_test.cfg"
);
let original = std::fs::read_to_string(cfg_path).expect("debug_test.cfg not found");
let expected_tree = parse_marte_config(&original);
let actual_tree = parse_marte_config(&converted);
// Every named object present in the original config must appear in the live
// config with the same Class. Config-file-only fields (InputSignals,
// OutputSignals, Frequency, etc.) are intentionally not checked because
// ExportData() does not re-emit them after ConfigureApplication().
assert_classes_match(&expected_tree, &actual_tree, "");
}
// ----- Unit tests for STEP_STATUS / VALUE JSON parsing -----
// These mirror the parsing logic inside tcp_command_worker's reader thread.
fn parse_step_status(json: &str) -> (bool, String, u32, String) {
let paused = json.contains("\"Paused\": true");
let gam = json.split("\"PausedAtGam\": \"")
.nth(1)
.and_then(|s| s.split('"').next())
.unwrap_or("")
.to_string();
let remaining = json.split("\"StepRemaining\": ")
.nth(1)
.and_then(|s| s.split(',').next())
.and_then(|s| s.trim().parse::<u32>().ok())
.unwrap_or(0);
let thread = json.split("\"StepThread\": \"")
.nth(1)
.and_then(|s| s.split('"').next())
.unwrap_or("")
.to_string();
(paused, gam, remaining, thread)
}
fn parse_value_response(json: &str) -> (bool, String, String) {
let found = !json.contains("\"Error\"");
let path = json.split("\"Name\": \"")
.nth(1)
.and_then(|s| s.split('"').next())
.unwrap_or("")
.to_string();
// Value is a quoted string: "Value": "..."
let value_text = json.split("\"Value\": \"")
.nth(1)
.and_then(|s| s.split('"').next())
.unwrap_or("")
.to_string();
(found, path, value_text)
}
#[test]
fn test_step_status_paused_with_thread() {
let json = r#"{"Paused": true, "PausedAtGam": "App.Functions.GAM2", "StepRemaining": 0, "StepThread": "Thread1"}"#;
let (paused, gam, remaining, thread) = parse_step_status(json);
assert!(paused);
assert_eq!(gam, "App.Functions.GAM2");
assert_eq!(remaining, 0);
assert_eq!(thread, "Thread1");
}
#[test]
fn test_step_status_running_no_thread() {
let json = r#"{"Paused": false, "PausedAtGam": "", "StepRemaining": 3, "StepThread": ""}"#;
let (paused, gam, remaining, thread) = parse_step_status(json);
assert!(!paused);
assert_eq!(gam, "");
assert_eq!(remaining, 3);
assert_eq!(thread, "");
}
#[test]
fn test_step_status_step_remaining_not_confused_with_thread_port() {
// "StepRemaining" must not accidentally parse digits from "StepThread"
let json = r#"{"Paused": false, "PausedAtGam": "", "StepRemaining": 7, "StepThread": "RT1"}"#;
let (_, _, remaining, thread) = parse_step_status(json);
assert_eq!(remaining, 7);
assert_eq!(thread, "RT1");
}
#[test]
fn test_value_response_found() {
let json = r#"{"Name": "App.Data.DDB.Counter", "Value": "42.5", "Elements": 1}"#;
let (found, path, value_text) = parse_value_response(json);
assert!(found);
assert_eq!(path, "App.Data.DDB.Counter");
assert_eq!(value_text, "42.5");
}
#[test]
fn test_value_response_not_found() {
let json = r#"{"Error": "Signal not found: BadSignal"}"#;
let (found, _path, _value_text) = parse_value_response(json);
assert!(!found);
}
#[test]
fn test_value_response_array() {
let json = r#"{"Name": "App.Data.DDB.Vec", "Value": "1, 2, 3", "Elements": 3}"#;
let (found, path, value_text) = parse_value_response(json);
assert!(found);
assert_eq!(path, "App.Data.DDB.Vec");
assert_eq!(value_text, "1, 2, 3");
}
#[test]
fn test_value_response_negative() {
let json = r#"{"Name": "App.Data.DDB.Err", "Value": "-3.14159", "Elements": 1}"#;
let (found, _, value_text) = parse_value_response(json);
assert!(found);
assert_eq!(value_text, "-3.14159");
}
}
fn main() -> Result<(), eframe::Error> {
let options = eframe::NativeOptions {
viewport: egui::ViewportBuilder::default().with_inner_size([1280.0, 800.0]),
..Default::default()
};
eframe::run_native(
"MARTe2 Debug Explorer",
options,
Box::new(|cc| Ok(Box::new(MarteDebugApp::new(cc)))),
)
}
View Git Blame Copy Permalink