martino/marte-debug
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Martino Ferrari
2026-02-21 00:58:56 +01:00
commit 5ef0efe7d6
26 changed files with 7999 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
Tools/cli_client/debug_cli Executable file
View File

Binary file not shown.

17
Tools/cli_client/go.mod Normal file
View File

@@ -0,0 +1,17 @@
module marte_debug_cli
go 1.25.7
require (
github.com/gdamore/tcell/v2 v2.13.8
github.com/rivo/tview v0.42.0
)
require (
github.com/gdamore/encoding v1.0.1 // indirect
github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
github.com/rivo/uniseg v0.4.7 // indirect
golang.org/x/sys v0.38.0 // indirect
golang.org/x/term v0.37.0 // indirect
golang.org/x/text v0.31.0 // indirect
)

47
Tools/cli_client/go.sum Normal file
View File

@@ -0,0 +1,47 @@
github.com/gdamore/encoding v1.0.1 h1:YzKZckdBL6jVt2Gc+5p82qhrGiqMdG/eNs6Wy0u3Uhw=
github.com/gdamore/encoding v1.0.1/go.mod h1:0Z0cMFinngz9kS1QfMjCP8TY7em3bZYeeklsSDPivEo=
github.com/gdamore/tcell/v2 v2.13.8 h1:Mys/Kl5wfC/GcC5Cx4C2BIQH9dbnhnkPgS9/wF3RlfU=
github.com/gdamore/tcell/v2 v2.13.8/go.mod h1:+Wfe208WDdB7INEtCsNrAN6O2m+wsTPk1RAovjaILlo=
github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=
github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
github.com/rivo/tview v0.42.0 h1:b/ftp+RxtDsHSaynXTbJb+/n/BxDEi+W3UfF5jILK6c=
github.com/rivo/tview v0.42.0/go.mod h1:cSfIYfhpSGCjp3r/ECJb+GKS7cGJnqV8vfjQPwoXyfY=
github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
golang.org/x/term v0.37.0 h1:8EGAD0qCmHYZg6J17DvsMy9/wJ7/D/4pV/wfnld5lTU=
golang.org/x/term v0.37.0/go.mod h1:5pB4lxRNYYVZuTLmy8oR2BH8dflOR+IbTYFD8fi3254=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

498
Tools/cli_client/main.go Normal file
View File

@@ -0,0 +1,498 @@
package main
import (
"encoding/binary"
"encoding/json"
"fmt"
"net"
"sort"
"strings"
"sync"
"time"
"github.com/gdamore/tcell/v2"
"github.com/rivo/tview"
)
// --- Models ---
type Signal struct {
Name string `json:"name"`
ID uint32 `json:"id"`
Type string `json:"type"`
}
type DiscoverResponse struct {
Signals []Signal `json:"Signals"`
}
type TraceValue struct {
Value string
LastUpdate time.Time
}
type AppState struct {
Signals map[string]Signal
IDToSignal map[uint32]string
ForcedSignals map[string]string
TracedSignals map[string]TraceValue
mu sync.RWMutex
}
var state = AppState{
Signals: make(map[string]Signal),
IDToSignal: make(map[uint32]string),
ForcedSignals: make(map[string]string),
TracedSignals: make(map[string]TraceValue),
}
// --- UI Components ---
var (
app *tview.Application
forcedPane *tview.Table
tracedPane *tview.Table
statusPane *tview.TextView
frameworkLogPane *tview.TextView
cmdInput *tview.InputField
mainFlex *tview.Flex
)
// logToStatus prints command output WITHOUT timestamp
func logToStatus(msg string) {
fmt.Fprintf(statusPane, "%s\n", msg)
}
// logToFramework prints framework logs WITH timestamp
func logToFramework(level, msg string) {
color := "white"
switch level {
case "FatalError", "OSError", "ParametersError":
color = "red"
case "Warning":
color = "yellow"
case "Information":
color = "green"
case "Debug":
color = "blue"
}
fmt.Fprintf(frameworkLogPane, "[%s] [[%s]%s[-]] %s\n", time.Now().Format("15:04:05.000"), color, level, msg)
}
// --- Network Logic ---
var (
tcpConn net.Conn
tcpMu sync.Mutex
responseChan = make(chan string, 2000)
connected = false
)
func connectAndMonitor(addr string) {
for {
conn, err := net.Dial("tcp", addr)
if err != nil {
app.QueueUpdateDraw(func() { statusPane.SetText("[red]Connection failed, retrying...\n") })
connected = false
time.Sleep(2 * time.Second)
continue
}
if tc, ok := conn.(*net.TCPConn); ok {
tc.SetNoDelay(true)
}
tcpConn = conn
connected = true
app.QueueUpdateDraw(func() { logToStatus("[green]Connected to DebugService (TCP 8080)") })
go discover()
buf := make([]byte, 4096)
var line strings.Builder
for {
n, err := conn.Read(buf)
if err != nil {
app.QueueUpdateDraw(func() { logToStatus("[red]TCP Disconnected: " + err.Error()) })
connected = false
break
}
for i := 0; i < n; i++ {
if buf[i] == '\n' {
fullLine := strings.TrimSpace(line.String())
line.Reset()
if strings.HasPrefix(fullLine, "LOG ") {
parts := strings.SplitN(fullLine[4:], " ", 2)
if len(parts) == 2 {
app.QueueUpdateDraw(func() { logToFramework(parts[0], parts[1]) })
}
} else if fullLine != "" {
select {
case responseChan <- fullLine:
default:
}
}
} else {
line.WriteByte(buf[i])
}
}
}
tcpConn.Close()
time.Sleep(2 * time.Second)
}
}
func startUDPListener(port int) {
addr, _ := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", port))
udpConn, err := net.ListenUDP("udp", addr)
if err != nil {
app.QueueUpdateDraw(func() { logToStatus(fmt.Sprintf("UDP Error: %v", err)) })
return
}
defer udpConn.Close()
buf := make([]byte, 2048)
for {
n, _, err := udpConn.ReadFromUDP(buf)
if err != nil || n < 20 {
continue
}
magic := binary.LittleEndian.Uint32(buf[0:4])
if magic != 0xDA7A57AD {
continue
}
count := binary.LittleEndian.Uint32(buf[16:20])
offset := 20
now := time.Now()
for i := uint32(0); i < count; i++ {
if offset+8 > n {
break
}
id := binary.LittleEndian.Uint32(buf[offset : offset+4])
size := binary.LittleEndian.Uint32(buf[offset+4 : offset+8])
offset += 8
if offset+int(size) > n {
break
}
data := buf[offset : offset+int(size)]
offset += int(size)
state.mu.Lock()
if name, ok := state.IDToSignal[id]; ok {
valStr := ""
if size == 4 {
valStr = fmt.Sprintf("%d", binary.LittleEndian.Uint32(data))
} else if size == 8 {
valStr = fmt.Sprintf("%d", binary.LittleEndian.Uint64(data))
} else {
valStr = fmt.Sprintf("%X", data)
}
state.TracedSignals[name] = TraceValue{Value: valStr, LastUpdate: now}
}
state.mu.Unlock()
}
app.QueueUpdateDraw(func() { updateTracedPane() })
}
}
func discover() {
tcpMu.Lock()
defer tcpMu.Unlock()
if !connected {
return
}
app.QueueUpdateDraw(func() { logToStatus("Discovering signals...") })
// Drain old responses
for len(responseChan) > 0 {
<-responseChan
}
fmt.Fprintf(tcpConn, "DISCOVER\n")
var jsonBlock strings.Builder
timeout := time.After(5 * time.Second)
for {
select {
case line := <-responseChan:
if line == "OK DISCOVER" {
goto parsed
}
jsonBlock.WriteString(line)
case <-timeout:
app.QueueUpdateDraw(func() { logToStatus("[red]Discovery Timeout") })
return
}
}
parsed:
var resp DiscoverResponse
if err := json.Unmarshal([]byte(jsonBlock.String()), &resp); err == nil {
state.mu.Lock()
state.IDToSignal = make(map[uint32]string)
for _, s := range resp.Signals {
state.Signals[s.Name] = s
state.IDToSignal[s.ID] = s.Name
}
state.mu.Unlock()
app.QueueUpdateDraw(func() { logToStatus(fmt.Sprintf("Discovered %d signals", len(resp.Signals))) })
}
}
// --- UI Updates ---
func updateForcedPane() {
forcedPane.Clear()
forcedPane.SetCell(0, 0, tview.NewTableCell("Signal").SetTextColor(tcell.ColorYellow).SetAttributes(tcell.AttrBold))
forcedPane.SetCell(0, 1, tview.NewTableCell("Value").SetTextColor(tcell.ColorYellow).SetAttributes(tcell.AttrBold))
state.mu.RLock()
defer state.mu.RUnlock()
keys := make([]string, 0, len(state.ForcedSignals))
for k := range state.ForcedSignals {
keys = append(keys, k)
}
sort.Strings(keys)
for i, k := range keys {
forcedPane.SetCell(i+1, 0, tview.NewTableCell(k))
forcedPane.SetCell(i+1, 1, tview.NewTableCell(state.ForcedSignals[k]).SetTextColor(tcell.ColorGreen))
}
}
func updateTracedPane() {
tracedPane.Clear()
tracedPane.SetCell(0, 0, tview.NewTableCell("Signal").SetTextColor(tcell.ColorBlue).SetAttributes(tcell.AttrBold))
tracedPane.SetCell(0, 1, tview.NewTableCell("Value").SetTextColor(tcell.ColorBlue).SetAttributes(tcell.AttrBold))
tracedPane.SetCell(0, 2, tview.NewTableCell("Last Update").SetTextColor(tcell.ColorBlue).SetAttributes(tcell.AttrBold))
state.mu.RLock()
defer state.mu.RUnlock()
keys := make([]string, 0, len(state.TracedSignals))
for k := range state.TracedSignals {
keys = append(keys, k)
}
sort.Strings(keys)
for i, k := range keys {
tv := state.TracedSignals[k]
tracedPane.SetCell(i+1, 0, tview.NewTableCell(k))
tracedPane.SetCell(i+1, 1, tview.NewTableCell(tv.Value))
tracedPane.SetCell(i+1, 2, tview.NewTableCell(tv.LastUpdate.Format("15:04:05.000")))
}
}
// --- Command Handler ---
func handleInput(text string) {
parts := strings.Fields(text)
if len(parts) == 0 {
return
}
cmd := strings.ToUpper(parts[0])
args := parts[1:]
if !connected && cmd != "EXIT" && cmd != "QUIT" && cmd != "CLEAR" {
logToStatus("[red]Not connected to server")
return
}
switch cmd {
case "LS":
path := ""
if len(args) > 0 {
path = args[0]
}
go func() {
tcpMu.Lock()
defer tcpMu.Unlock()
for len(responseChan) > 0 {
<-responseChan
}
fmt.Fprintf(tcpConn, "LS %s\n", path)
app.QueueUpdateDraw(func() { logToStatus(fmt.Sprintf("Listing nodes under %s...", path)) })
timeout := time.After(2 * time.Second)
for {
select {
case line := <-responseChan:
if line == "OK LS" {
return
}
app.QueueUpdateDraw(func() { logToStatus(line) })
case <-timeout:
app.QueueUpdateDraw(func() { logToStatus("[red]LS Timeout") })
return
}
}
}()
case "FORCE":
if len(args) < 2 {
return
}
path, val := args[0], args[1]
go func() {
tcpMu.Lock()
defer tcpMu.Unlock()
fmt.Fprintf(tcpConn, "FORCE %s %s\n", path, val)
select {
case resp := <-responseChan:
app.QueueUpdateDraw(func() {
logToStatus("Server: " + resp)
state.mu.Lock()
state.ForcedSignals[path] = val
state.mu.Unlock()
updateForcedPane()
})
case <-time.After(1 * time.Second):
app.QueueUpdateDraw(func() { logToStatus("[red]Server Timeout") })
}
}()
case "UNFORCE":
if len(args) < 1 {
return
}
path := args[0]
go func() {
tcpMu.Lock()
defer tcpMu.Unlock()
fmt.Fprintf(tcpConn, "UNFORCE %s\n", path)
select {
case resp := <-responseChan:
app.QueueUpdateDraw(func() {
logToStatus("Server: " + resp)
state.mu.Lock()
delete(state.ForcedSignals, path)
state.mu.Unlock()
updateForcedPane()
})
case <-time.After(1 * time.Second):
app.QueueUpdateDraw(func() { logToStatus("[red]Server Timeout") })
}
}()
case "TRACE":
if len(args) < 1 {
return
}
path := args[0]
decim := "1"
if len(args) > 1 {
decim = args[1]
}
go func() {
tcpMu.Lock()
defer tcpMu.Unlock()
fmt.Fprintf(tcpConn, "TRACE %s 1 %s\n", path, decim)
select {
case resp := <-responseChan:
app.QueueUpdateDraw(func() {
logToStatus("Server: " + resp)
state.mu.Lock()
state.TracedSignals[path] = TraceValue{Value: "...", LastUpdate: time.Now()}
state.mu.Unlock()
updateTracedPane()
})
case <-time.After(1 * time.Second):
app.QueueUpdateDraw(func() { logToStatus("[red]Server Timeout") })
}
}()
case "UNTRACE":
if len(args) < 1 {
return
}
path := args[0]
go func() {
tcpMu.Lock()
defer tcpMu.Unlock()
fmt.Fprintf(tcpConn, "UNTRACE %s\n", path)
select {
case resp := <-responseChan:
app.QueueUpdateDraw(func() {
logToStatus("Server: " + resp)
state.mu.Lock()
delete(state.TracedSignals, path)
state.mu.Unlock()
updateTracedPane()
})
case <-time.After(1 * time.Second):
app.QueueUpdateDraw(func() { logToStatus("[red]Server Timeout") })
}
}()
case "DISCOVER":
go discover()
case "CLEAR":
statusPane.Clear()
frameworkLogPane.Clear()
case "EXIT", "QUIT":
app.Stop()
default:
logToStatus("Unknown command: " + cmd)
}
}
func main() {
app = tview.NewApplication()
forcedPane = tview.NewTable()
forcedPane.SetBorders(true)
forcedPane.SetTitle(" Forced Signals ")
forcedPane.SetBorder(true)
tracedPane = tview.NewTable()
tracedPane.SetBorders(true)
tracedPane.SetTitle(" Traced Signals (Live) ")
tracedPane.SetBorder(true)
statusPane = tview.NewTextView()
statusPane.SetDynamicColors(true)
statusPane.SetRegions(true)
statusPane.SetWordWrap(true)
statusPane.SetChangedFunc(func() {
statusPane.ScrollToEnd()
app.Draw()
})
statusPane.SetTitle(" CLI Status / Command Output ")
statusPane.SetBorder(true)
frameworkLogPane = tview.NewTextView()
frameworkLogPane.SetDynamicColors(true)
frameworkLogPane.SetRegions(true)
frameworkLogPane.SetWordWrap(true)
frameworkLogPane.SetChangedFunc(func() {
frameworkLogPane.ScrollToEnd()
app.Draw()
})
frameworkLogPane.SetTitle(" MARTe2 Framework Logs ")
frameworkLogPane.SetBorder(true)
cmdInput = tview.NewInputField()
cmdInput.SetLabel("marte_debug> ")
cmdInput.SetFieldWidth(0)
cmdInput.SetDoneFunc(func(key tcell.Key) {
if key == tcell.KeyEnter {
text := cmdInput.GetText()
if text != "" {
handleInput(text)
cmdInput.SetText("")
}
}
})
flexTop := tview.NewFlex()
flexTop.SetDirection(tview.FlexColumn)
flexTop.AddItem(forcedPane, 0, 1, false)
flexTop.AddItem(tracedPane, 0, 1, false)
flexTop.AddItem(statusPane, 0, 1, false)
mainFlex = tview.NewFlex()
mainFlex.SetDirection(tview.FlexRow)
mainFlex.AddItem(flexTop, 0, 2, false)
mainFlex.AddItem(frameworkLogPane, 0, 1, false)
mainFlex.AddItem(cmdInput, 1, 0, true)
go connectAndMonitor("127.0.0.1:8080")
go startUDPListener(8081)
if err := app.SetRoot(mainFlex, true).EnableMouse(true).Run(); err != nil {
panic(err)
}
}

BIN
Tools/cli_client/marte_debug_cli Executable file
View File

Binary file not shown.

4526
Tools/gui_client/Cargo.lock generated Normal file
View File

File diff suppressed because it is too large Load Diff

16
Tools/gui_client/Cargo.toml Normal file
View File

@@ -0,0 +1,16 @@
[package]
name = "marte_debug_gui"
version = "0.1.0"
edition = "2021"
[dependencies]
eframe = "0.31.0"
egui = "0.31.0"
egui_plot = "0.31.0"
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
byteorder = "1.4"
chrono = "0.4"
crossbeam-channel = "0.5"
regex = "1.12.3"

673
Tools/gui_client/src/main.rs Normal file
View File

@@ -0,0 +1,673 @@
use eframe::egui;
use egui_plot::{Line, Plot, PlotPoints};
use std::collections::{HashMap, VecDeque};
use std::net::{TcpStream, UdpSocket};
use std::io::{Write, BufReader, BufRead};
use std::sync::{Arc, Mutex};
use std::thread;
use serde::{Deserialize, Serialize};
use chrono::Local;
use crossbeam_channel::{unbounded, Receiver, Sender};
use regex::Regex;
// --- Models ---
#[derive(Serialize, Deserialize, Clone, Debug)]
struct Signal {
name: String,
id: u32,
#[serde(rename = "type")]
sig_type: String,
}
#[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>,
}
#[derive(Clone)]
struct LogEntry {
time: String,
level: String,
message: String,
}
struct TraceData {
values: VecDeque<[f64; 2]>,
}
struct SignalMetadata {
names: Vec<String>,
sig_type: String,
}
enum InternalEvent {
Log(LogEntry),
Discovery(Vec<Signal>),
Tree(TreeItem),
CommandResponse(String),
NodeInfo(String),
Connected,
InternalLog(String),
TraceRequested(String),
ClearTrace(String),
UdpStats(u64),
}
// --- App State ---
struct ForcingDialog {
signal_path: String,
sig_type: String,
dims: u8,
elems: u32,
value: String,
}
struct LogFilters {
content_regex: String,
show_debug: bool,
show_info: bool,
show_warning: bool,
show_error: bool,
paused: bool,
}
struct MarteDebugApp {
#[allow(dead_code)]
connected: bool,
tcp_addr: String,
log_addr: String,
signals: Vec<Signal>,
app_tree: Option<TreeItem>,
traced_signals: Arc<Mutex<HashMap<String, TraceData>>>,
id_to_meta: Arc<Mutex<HashMap<u32, SignalMetadata>>>,
forced_signals: HashMap<String, String>,
is_paused: bool,
logs: VecDeque<LogEntry>,
log_filters: LogFilters,
// UI Panels
show_left_panel: bool,
show_right_panel: bool,
show_bottom_panel: bool,
selected_node: String,
node_info: String,
udp_packets: u64,
forcing_dialog: Option<ForcingDialog>,
tx_cmd: Sender<String>,
rx_events: Receiver<InternalEvent>,
internal_tx: Sender<InternalEvent>,
}
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 tcp_addr = "127.0.0.1:8080".to_string();
let log_addr = "127.0.0.1:8082".to_string();
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 tx_events_c = tx_events.clone();
thread::spawn(move || {
tcp_command_worker(tcp_addr, rx_cmd_internal, tx_events_c);
});
let tx_events_log = tx_events.clone();
thread::spawn(move || {
tcp_log_worker(log_addr, tx_events_log);
});
let tx_events_udp = tx_events.clone();
thread::spawn(move || {
udp_worker(8081, id_to_meta_clone, traced_signals_clone, tx_events_udp);
});
Self {
connected: false,
tcp_addr: "127.0.0.1:8080".to_string(),
log_addr: "127.0.0.1:8082".to_string(),
signals: Vec::new(),
app_tree: None,
id_to_meta,
traced_signals,
forced_signals: HashMap::new(),
is_paused: false,
logs: VecDeque::with_capacity(2000),
log_filters: LogFilters {
content_regex: "".to_string(),
show_debug: true,
show_info: true,
show_warning: true,
show_error: true,
paused: false,
},
show_left_panel: true,
show_right_panel: true,
show_bottom_panel: true,
selected_node: "".to_string(),
node_info: "".to_string(),
udp_packets: 0,
forcing_dialog: None,
tx_cmd,
rx_events,
internal_tx,
}
}
fn render_tree(&mut self, ui: &mut egui::Ui, item: &TreeItem, path: String) {
let current_path = if path.is_empty() {
item.name.clone()
} else if path == "Root" {
item.name.clone()
} else {
format!("{}.{}", path, item.name)
};
if let Some(children) = &item.children {
let header = egui::CollapsingHeader::new(format!("{} [{}]", item.name, item.class))
.id_salt(&current_path);
header.show(ui, |ui| {
ui.horizontal(|ui| {
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));
}
});
for child in children {
self.render_tree(ui, child, current_path.clone());
}
});
} else {
ui.horizontal(|ui| {
if ui.selectable_label(self.selected_node == current_path, format!("{} [{}]", item.name, item.class)).clicked() {
self.selected_node = current_path.clone();
let _ = self.tx_cmd.send(format!("INFO {}", current_path));
}
if item.class.contains("Signal") {
if ui.button("📈 Trace").clicked() {
let _ = self.tx_cmd.send(format!("TRACE {} 1", current_path));
let _ = self.internal_tx.send(InternalEvent::TraceRequested(current_path.clone()));
}
if ui.button("⚡ Force").clicked() {
self.forcing_dialog = Some(ForcingDialog {
signal_path: current_path.clone(),
sig_type: item.sig_type.clone().unwrap_or_else(|| "Unknown".to_string()),
dims: item.dimensions.unwrap_or(0),
elems: item.elements.unwrap_or(1),
value: "".to_string(),
});
}
}
});
}
}
}
fn tcp_command_worker(addr: String, rx_cmd: Receiver<String>, tx_events: Sender<InternalEvent>) {
loop {
if let Ok(mut stream) = TcpStream::connect(&addr) {
let _ = stream.set_nodelay(true);
let mut reader = BufReader::new(stream.try_clone().unwrap());
let _ = tx_events.send(InternalEvent::Connected);
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() {
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 == "OK DISCOVER" {
in_json = false;
let json_clean = json_acc.trim_end_matches("OK DISCOVER").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!("JSON Parse Error (Discover): {}", e))); }
}
json_acc.clear();
} else if trimmed == "OK TREE" {
in_json = false;
let json_clean = json_acc.trim_end_matches("OK TREE").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!("JSON Parse Error (Tree): {}", e))); }
}
json_acc.clear();
} else if trimmed == "OK INFO" {
in_json = false;
let json_clean = json_acc.trim_end_matches("OK INFO").trim();
let _ = tx_events_inner.send(InternalEvent::NodeInfo(json_clean.to_string()));
json_acc.clear();
}
} else {
let _ = tx_events_inner.send(InternalEvent::CommandResponse(trimmed.to_string()));
}
line.clear();
}
});
while let Ok(cmd) = rx_cmd.recv() {
if stream.write_all(format!("{}\n", cmd).as_bytes()).is_err() {
break;
}
}
}
thread::sleep(std::time::Duration::from_secs(2));
}
}
fn tcp_log_worker(addr: String, tx_events: Sender<InternalEvent>) {
loop {
if let Ok(stream) = TcpStream::connect(&addr) {
let mut reader = BufReader::new(stream);
let mut line = String::new();
while reader.read_line(&mut line).is_ok() {
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 udp_worker(port: u16, id_to_meta: Arc<Mutex<HashMap<u32, SignalMetadata>>>, traced_data: Arc<Mutex<HashMap<String, TraceData>>>, tx_events: Sender<InternalEvent>) {
if let Ok(socket) = UdpSocket::bind(format!("0.0.0.0:{}", port)) {
let mut buf = [0u8; 4096];
let start_time = std::time::Instant::now();
let mut total_packets = 0u64;
loop {
if let Ok(n) = socket.recv(&mut buf) {
total_packets += 1;
if (total_packets % 100) == 0 {
let _ = tx_events.send(InternalEvent::UdpStats(total_packets));
}
if n < 20 { continue; }
let mut magic_buf = [0u8; 4]; magic_buf.copy_from_slice(&buf[0..4]);
if u32::from_le_bytes(magic_buf) != 0xDA7A57AD { continue; }
let mut count_buf = [0u8; 4]; count_buf.copy_from_slice(&buf[16..20]);
let count = u32::from_le_bytes(count_buf);
let mut offset = 20;
let now = start_time.elapsed().as_secs_f64();
let metas = id_to_meta.lock().unwrap();
let mut data_map = traced_data.lock().unwrap();
for _ in 0..count {
if offset + 8 > n { break; }
let mut id_buf = [0u8; 4]; id_buf.copy_from_slice(&buf[offset..offset+4]);
let id = u32::from_le_bytes(id_buf);
let mut size_buf = [0u8; 4]; size_buf.copy_from_slice(&buf[offset+4..offset+8]);
let size = u32::from_le_bytes(size_buf);
offset += 8;
if offset + size as usize > n { break; }
let data_slice = &buf[offset..offset + size as usize];
if let Some(meta) = metas.get(&id) {
let t = meta.sig_type.as_str();
let val = match size {
1 => { if t.contains('u') { data_slice[0] as f64 } else { (data_slice[0] as i8) as f64 } },
2 => {
let mut b = [0u8; 2]; b.copy_from_slice(data_slice);
if t.contains('u') { u16::from_le_bytes(b) as f64 } else { i16::from_le_bytes(b) as f64 }
},
4 => {
let mut b = [0u8; 4]; b.copy_from_slice(data_slice);
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 mut b = [0u8; 8]; b.copy_from_slice(data_slice);
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 {
if let Some(entry) = data_map.get_mut(name) {
entry.values.push_back([now, val]);
if entry.values.len() > 2000 { entry.values.pop_front(); }
}
}
}
offset += size as usize;
}
}
}
}
}
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::InternalLog(msg) => {
self.logs.push_back(LogEntry {
time: Local::now().format("%H:%M:%S").to_string(),
level: "GUI_ERROR".to_string(),
message: msg,
});
}
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() });
if !meta.names.contains(&s.name) { meta.names.push(s.name.clone()); }
}
self.signals = signals;
}
InternalEvent::Tree(tree) => {
self.app_tree = Some(tree);
}
InternalEvent::NodeInfo(info) => {
self.node_info = info;
}
InternalEvent::TraceRequested(name) => {
let mut data_map = self.traced_signals.lock().unwrap();
data_map.entry(name).or_insert_with(|| TraceData { values: VecDeque::with_capacity(2000) });
}
InternalEvent::ClearTrace(name) => {
let mut data_map = self.traced_signals.lock().unwrap();
data_map.remove(&name);
}
InternalEvent::CommandResponse(resp) => {
self.logs.push_back(LogEntry {
time: Local::now().format("%H:%M:%S").to_string(),
level: "CMD_RESP".to_string(),
message: resp,
});
}
InternalEvent::UdpStats(count) => {
self.udp_packets = count;
}
InternalEvent::Connected => {
let _ = self.tx_cmd.send("TREE".to_string());
let _ = self.tx_cmd.send("DISCOVER".to_string());
}
}
}
if let Some(dialog) = &mut self.forcing_dialog {
let mut close = false;
egui::Window::new("Force Signal").collapsible(false).resizable(false).show(ctx, |ui| {
ui.label(format!("Signal: {}", dialog.signal_path));
ui.label(format!("Type: {} (Dims: {}, Elems: {})", dialog.sig_type, dialog.dims, dialog.elems));
ui.horizontal(|ui| {
ui.label("Value:");
ui.text_edit_singleline(&mut dialog.value);
});
ui.horizontal(|ui| {
if ui.button("Apply Force").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; }
}
egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
ui.horizontal(|ui| {
ui.toggle_value(&mut self.show_left_panel, "🗂 Tree");
ui.toggle_value(&mut self.show_right_panel, "⚙ Debug");
ui.toggle_value(&mut self.show_bottom_panel, "📜 Logs");
ui.separator();
ui.heading("MARTe2 Debug Explorer");
ui.separator();
if ui.button("🔄 Refresh").clicked() {
let _ = self.tx_cmd.send("TREE".to_string());
let _ = self.tx_cmd.send("DISCOVER".to_string());
}
ui.separator();
if self.is_paused {
if ui.button("▶ Resume").clicked() {
let _ = self.tx_cmd.send("RESUME".to_string());
self.is_paused = false;
}
} else {
if ui.button("⏸ Pause").clicked() {
let _ = self.tx_cmd.send("PAUSE".to_string());
self.is_paused = true;
}
}
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
ui.label(format!("UDP Packets: {}", self.udp_packets));
});
});
});
if self.show_bottom_panel {
egui::TopBottomPanel::bottom("log_panel").resizable(true).default_height(200.0).show(ctx, |ui| {
ui.horizontal(|ui| {
ui.heading("System Logs");
ui.separator();
ui.label("Filter:");
ui.text_edit_singleline(&mut self.log_filters.content_regex);
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.toggle_value(&mut self.log_filters.paused, "⏸ Pause Logs");
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
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" => self.log_filters.show_info,
"Warning" => self.log_filters.show_warning,
"FatalError" | "OSError" | "ParametersError" => 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" => egui::Color32::from_rgb(255, 100, 100),
"Warning" => egui::Color32::from_rgb(255, 255, 100),
"Information" => egui::Color32::from_rgb(100, 255, 100),
"Debug" => egui::Color32::from_rgb(100, 100, 255),
"GUI_ERROR" => egui::Color32::from_rgb(255, 50, 255),
"CMD_RESP" => egui::Color32::from_rgb(255, 255, 255),
_ => egui::Color32::WHITE,
};
ui.scope(|ui| {
ui.horizontal(|ui| {
ui.label(egui::RichText::new(&log.time).monospace().color(egui::Color32::GRAY));
ui.label(egui::RichText::new(format!("[{}]", log.level)).color(color).strong());
ui.add(egui::Label::new(&log.message).wrap());
ui.allocate_space(egui::vec2(ui.available_width(), 0.0));
});
});
}
});
});
}
if self.show_left_panel {
egui::SidePanel::left("signals_panel").resizable(true).width_range(300.0..=600.0).show(ctx, |ui| {
ui.heading("Application Tree");
ui.separator();
egui::ScrollArea::vertical().id_salt("tree_scroll").show(ui, |ui| {
if let Some(tree) = self.app_tree.clone() {
self.render_tree(ui, &tree, "".to_string());
} else {
ui.label("Connecting to server...");
}
});
ui.separator();
ui.heading("Node Information");
egui::ScrollArea::vertical().id_salt("info_scroll").show(ui, |ui| {
if self.node_info.is_empty() {
ui.label("Click 'Info' on a node to view details");
} else {
ui.add(egui::Label::new(egui::RichText::new(&self.node_info).monospace()).wrap());
}
});
});
}
if self.show_right_panel {
egui::SidePanel::right("debug_panel").resizable(true).width_range(200.0..=400.0).show(ctx, |ui| {
ui.heading("Active Controls");
ui.separator();
ui.label(egui::RichText::new("Forced Signals").strong());
egui::ScrollArea::vertical().id_salt("forced_scroll").show(ui, |ui| {
let mut to_update = None;
let mut to_remove = None;
for (path, val) in &self.forced_signals {
ui.horizontal(|ui| {
if ui.selectable_label(false, format!("{}: {}", path, val)).clicked() {
to_update = Some(path.clone());
}
if ui.button("❌").clicked() {
let _ = self.tx_cmd.send(format!("UNFORCE {}", path));
to_remove = Some(path.clone());
}
});
}
if let Some(p) = to_remove { self.forced_signals.remove(&p); }
if let Some(p) = to_update {
self.forcing_dialog = Some(ForcingDialog {
signal_path: p.clone(), sig_type: "Unknown".to_string(), dims: 0, elems: 1,
value: self.forced_signals.get(&p).unwrap().clone(),
});
}
});
ui.separator();
ui.label(egui::RichText::new("Traced Signals").strong());
egui::ScrollArea::vertical().id_salt("traced_scroll").show(ui, |ui| {
let mut names: Vec<_> = {
let data_map = self.traced_signals.lock().unwrap();
data_map.keys().cloned().collect()
};
names.sort();
for key in names {
ui.horizontal(|ui| {
ui.label(&key);
if ui.button("❌").clicked() {
let _ = self.tx_cmd.send(format!("TRACE {} 0", key));
let _ = self.internal_tx.send(InternalEvent::ClearTrace(key));
}
});
}
});
});
}
egui::CentralPanel::default().show(ctx, |ui| {
ui.heading("Oscilloscope");
let plot = Plot::new("traces_plot")
.legend(egui_plot::Legend::default())
.auto_bounds_x()
.auto_bounds_y()
.y_axis_min_width(4.0);
plot.show(ui, |plot_ui| {
let data_map = self.traced_signals.lock().unwrap();
for (name, data) in data_map.iter() {
let points: PlotPoints = data.values.iter().cloned().collect();
plot_ui.line(Line::new(points).name(name));
}
});
});
ctx.request_repaint_after(std::time::Duration::from_millis(16));
}
}
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)))),
)
}