From afc4b794bbd6e138fbe1f5d18d0abc388c0bfa6b Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Tue, 25 Aug 2026 14:46:20 +0100 Subject: [PATCH 01/41] Created a devices service and moved the CDashDisplay service to the sahdow realm --- .../cdashdisplay}/connect.go | 0 .../cdashdisplay}/display.go | 3 +- devices/cdashdisplay/info.go | 9 + .../cdashdisplay}/layoutManager.go | 0 .../cdashdisplay}/transportPackets.go | 0 devices/device.go | 9 + go.mod | 2 +- peripheral/devices/devices.go | 5 +- services/cdashdisplay.go | 255 ++++++++---------- services/device.go | 9 - services/devices.go | 123 +++++++++ services/telemetry.go | 15 +- .../{layout.go => cdashdisplay_layout.go} | 116 +++++++- ...ool.go => cdashdisplay_layout_moveTool.go} | 41 ++- tui/internal/controllers/device.go | 9 +- tui/internal/controllers/streaming.go | 24 +- tui/internal/views/layoutTool.go | 2 +- tui/internal/views/layoutTool_forms.go | 2 +- tui/tui.go | 4 +- 19 files changed, 444 insertions(+), 184 deletions(-) rename {cdashdisplay => devices/cdashdisplay}/connect.go (100%) rename {cdashdisplay => devices/cdashdisplay}/display.go (98%) create mode 100644 devices/cdashdisplay/info.go rename {cdashdisplay => devices/cdashdisplay}/layoutManager.go (100%) rename {cdashdisplay => devices/cdashdisplay}/transportPackets.go (100%) create mode 100644 devices/device.go delete mode 100644 services/device.go create mode 100644 services/devices.go rename tui/internal/controllers/{layout.go => cdashdisplay_layout.go} (82%) rename tui/internal/controllers/{layout_moveTool.go => cdashdisplay_layout_moveTool.go} (64%) diff --git a/cdashdisplay/connect.go b/devices/cdashdisplay/connect.go similarity index 100% rename from cdashdisplay/connect.go rename to devices/cdashdisplay/connect.go diff --git a/cdashdisplay/display.go b/devices/cdashdisplay/display.go similarity index 98% rename from cdashdisplay/display.go rename to devices/cdashdisplay/display.go index 9f33c14..433db99 100644 --- a/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -116,7 +116,8 @@ type CDashDisplay struct { State *CDashState } -func NewCDashDisplay() (*CDashDisplay, error) { +// Connect will try to find and connect to the CDashDisplay +func Discover() (*CDashDisplay, error) { // Look for the port p, err := findDisplayPort() if err != nil { diff --git a/devices/cdashdisplay/info.go b/devices/cdashdisplay/info.go new file mode 100644 index 0000000..ecd930a --- /dev/null +++ b/devices/cdashdisplay/info.go @@ -0,0 +1,9 @@ +package cdashdisplay + +import "esdi/peripheral/devices" + +// TODO: I believe we don't need the #esdi/peripheral/devices thing anymore +const ( + ID = devices.CDashDisplayDevID + Name = devices.CDashDisplayDevName +) diff --git a/cdashdisplay/layoutManager.go b/devices/cdashdisplay/layoutManager.go similarity index 100% rename from cdashdisplay/layoutManager.go rename to devices/cdashdisplay/layoutManager.go diff --git a/cdashdisplay/transportPackets.go b/devices/cdashdisplay/transportPackets.go similarity index 100% rename from cdashdisplay/transportPackets.go rename to devices/cdashdisplay/transportPackets.go diff --git a/devices/device.go b/devices/device.go new file mode 100644 index 0000000..c7baab1 --- /dev/null +++ b/devices/device.go @@ -0,0 +1,9 @@ +// Package devices simply defines what a device should have +// and some utils if necessary +package devices + +import "esdi/telemetry" + +type Device interface { + SendData(*telemetry.TelemetryData) +} diff --git a/go.mod b/go.mod index 3d4d8fd..6dbcbdb 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module esdi -go 1.25.5 +go 1.27.0 require ( github.com/ESilva15/ESgoRepl v0.1.0 diff --git a/peripheral/devices/devices.go b/peripheral/devices/devices.go index 34d2684..bfe97fa 100644 --- a/peripheral/devices/devices.go +++ b/peripheral/devices/devices.go @@ -6,8 +6,9 @@ import "esdi/peripheral/types" // IDs for our devices. They need to be correctly mapped on the devices // themselves so we can discover them const ( - CDashDisplayDevID = 0x01 - ESBtnBoxDevID = 0x02 + CDashDisplayDevID = 0x01 + CDashDisplayDevName = "CDashDisplay" + ESBtnBoxDevID = 0x02 ) // DeviceMap maps the implemented devices diff --git a/services/cdashdisplay.go b/services/cdashdisplay.go index 0821075..111b2dc 100644 --- a/services/cdashdisplay.go +++ b/services/cdashdisplay.go @@ -1,148 +1,131 @@ package services -import ( - "context" - "fmt" - "log/slog" - "sync/atomic" +// type CDashService struct { +// Logger *slog.Logger +// CDash *cdashdisplay.CDashDisplay +// // DevClerk *peripheral.PeripheralDeviceClerk +// // Messages chan string +// // Telemetry Channel +// // streamCancel context.CancelFunc +// // TelemCh <-chan telemetry.TelemetryData +// } - "esdi/cdashdisplay" - helper "esdi/helpers" - "esdi/peripheral" - "esdi/telemetry" -) +// func NewCDashService(logger *slog.Logger) *CDashService { +// // sharedChannel := make(chan string, 10) +// return &CDashService{ +// Logger: logger, +// CDash: nil, +// // DevClerk: peripheral.NewPeripheralDeviceClerk(), +// // Messages: sharedChannel, +// } +// } -type CDashService struct { - Logger *slog.Logger - CDash *cdashdisplay.CDashDisplay - DevClerk *peripheral.PeripheralDeviceClerk - Messages chan string - // Telemetry Channel - streamCancel context.CancelFunc - TelemCh <-chan telemetry.TelemetryData -} +// func (ds *CDashService) FindDevice() { +// ds.Messages <- "looking for cdash display...\n" +// ds.Logger.Info("Looking for CDashDisplay") -func NewCDashService(logger *slog.Logger) *CDashService { - sharedChannel := make(chan string, 10) - return &CDashService{ - Logger: logger, - CDash: nil, - DevClerk: peripheral.NewPeripheralDeviceClerk(), - Messages: sharedChannel, - } -} +// cdashdisplay.SetLogger(ds.Logger.With("[device]", "cdashdisplay")) -func (cds *CDashService) FindDevice() { - cds.Messages <- "looking for cdash display...\n" - cds.Logger.Info("Looking for CDashDisplay") +// display, err := cdashdisplay.Discover() +// if err != nil { +// ds.Logger.Info("didn't find cdashdisplay") +// ds.Messages <- "didn't find cdash display\n" +// return +// } +// +// ds.CDash = display +// ds.Logger.Info("found cdashdisplay on: " + display.WT.Cfg.Name) +// ds.Messages <- "found cdashdisplay on: " + display.WT.Cfg.Name + "\n" +// } - cdashdisplay.SetLogger(cds.Logger.With("[device]", "cdashdisplay")) +// func (ds *CDashService) CreateWindow( +// win *cdashdisplay.DesktopUIWindow, +// ) (*cdashdisplay.DesktopUIWindow, error) { +// updatedWindow, err := ds.CDash.CreateWindow(win) +// if err != nil { +// return nil, err +// } +// +// return updatedWindow, nil +// } +// +// func (ds *CDashService) LoadLayout(layoutPath string) error { +// return ds.CDash.LoadLayout(layoutPath) +// } +// +// func (ds *CDashService) SaveLayout(layoutPath string) error { +// return ds.CDash.SaveLayout(layoutPath) +// } +// +// func (ds *CDashService) UnloadLayout() error { +// return ds.CDash.UnloadLayout() +// } +// +// func (ds *CDashService) UpdateWindow(win *cdashdisplay.DesktopUIWindow) error { +// ds.Messages <- fmt.Sprintf("Updating a window:\n%+v\n", win) +// return ds.CDash.UpdateWindow(win) +// } +// +// func (ds *CDashService) DeleteWindow(idx int16) error { +// return ds.CDash.DestroyWindow(idx) +// } +// +// func (ds *CDashService) ResizeWindow(idx int16, vec *helper.Vector) error { +// err := ds.CDash.ResizeWindow(idx, vec) +// if err != nil { +// return err +// } +// +// return nil +// } +// +// func (ds *CDashService) MoveWindow(idx int16, vec *helper.Vector) error { +// return ds.CDash.MoveWindow(idx, vec) +// } - display, err := cdashdisplay.NewCDashDisplay() - if err != nil { - cds.Logger.Info("didn't find cdashdisplay") - cds.Messages <- "didn't find cdash display\n" - return - } +// func (ds *CDashService) SetTelemetryChannel(ch <-chan telemetry.TelemetryData) { +// ds.TelemCh = ch +// } - cds.CDash = display - cds.Logger.Info("found cdashdisplay on: " + display.WT.Cfg.Name) - cds.Messages <- "found cdashdisplay on: " + display.WT.Cfg.Name + "\n" -} - -func (cds *CDashService) CreateWindow( - win *cdashdisplay.DesktopUIWindow, -) (*cdashdisplay.DesktopUIWindow, error) { - updatedWindow, err := cds.CDash.CreateWindow(win) - if err != nil { - return nil, err - } - - return updatedWindow, nil -} - -func (cds *CDashService) LoadLayout(layoutPath string) error { - return cds.CDash.LoadLayout(layoutPath) -} - -func (cds *CDashService) SaveLayout(layoutPath string) error { - return cds.CDash.SaveLayout(layoutPath) -} - -func (cds *CDashService) UnloadLayout() error { - return cds.CDash.UnloadLayout() -} - -func (cds *CDashService) UpdateWindow(win *cdashdisplay.DesktopUIWindow) error { - cds.Messages <- fmt.Sprintf("Updating a window:\n%+v\n", win) - return cds.CDash.UpdateWindow(win) -} - -func (cds *CDashService) DeleteWindow(idx int16) error { - return cds.CDash.DestroyWindow(idx) -} - -func (cds *CDashService) ResizeWindow(idx int16, vec *helper.Vector) error { - err := cds.CDash.ResizeWindow(idx, vec) - if err != nil { - return err - } - - return nil -} - -func (cds *CDashService) MoveWindow(idx int16, vec *helper.Vector) error { - err := cds.CDash.MoveWindow(idx, vec) - if err != nil { - return err - } - - return nil -} - -func (cds *CDashService) SetTelemetryChannel(ch <-chan telemetry.TelemetryData) { - cds.TelemCh = ch -} - -func (cds *CDashService) StartStream() { - // NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this - var ctx context.Context - ctx, cds.streamCancel = context.WithCancel(context.Background()) - - go cds.transmit(ctx) -} - -func (cds *CDashService) StopStream() { - if cds.streamCancel == nil { - return - } - - cds.streamCancel() - cds.streamCancel = nil -} +// func (cds *CDashService) StartStream() { +// // NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this +// var ctx context.Context +// ctx, cds.streamCancel = context.WithCancel(context.Background()) +// +// go cds.transmit(ctx) +// } +// +// func (cds *CDashService) StopStream() { +// if cds.streamCancel == nil { +// return +// } +// +// cds.streamCancel() +// cds.streamCancel = nil +// } // INTERNAL -func (cds *CDashService) transmit(ctx context.Context) { - var isSending atomic.Bool - - for { - select { - case <-ctx.Done(): - return - case data, ok := <-cds.TelemCh: - if !ok { - return - } - - if isSending.Load() { - continue - } - - isSending.Store(true) - - cds.CDash.SendData(&data) - isSending.Store(false) - } - } -} +// func (ds *CDashService) transmit(ctx context.Context) { +// var isSending atomic.Bool +// +// for { +// select { +// case <-ctx.Done(): +// return +// case data, ok := <-ds.TelemCh: +// if !ok { +// return +// } +// +// if isSending.Load() { +// continue +// } +// +// isSending.Store(true) +// +// ds.CDash.SendData(&data) +// isSending.Store(false) +// } +// } +// } diff --git a/services/device.go b/services/device.go deleted file mode 100644 index e1b4db6..0000000 --- a/services/device.go +++ /dev/null @@ -1,9 +0,0 @@ -package services - -// DeviceService will handle sending the data from the telemetry service to the -// actual devices -// NOTE: create a virtual device and make it be the output window or something so -// we can just add it as a device or whatever instead of being a custom made thing -// that would be pretty cool I think -type DeviceService struct { -} diff --git a/services/devices.go b/services/devices.go new file mode 100644 index 0000000..d48870f --- /dev/null +++ b/services/devices.go @@ -0,0 +1,123 @@ +package services + +import ( + "context" + "fmt" + "log/slog" + "sync/atomic" + + "esdi/devices" + "esdi/devices/cdashdisplay" + "esdi/telemetry" +) + +// DeviceService will handle sending the data from the telemetry service to the +// actual devices +// NOTE: create a virtual device and make it be the output window or something so +// we can just add it as a device or whatever instead of being a custom made thing +// that would be pretty cool I think +type DeviceService struct { + Logger *slog.Logger + Devices map[string]devices.Device + // Strem handling + streamCancel context.CancelFunc + TelemCh <-chan telemetry.TelemetryData + // Output + Messages chan string +} + +func NewDeviceService(logger *slog.Logger) *DeviceService { + sharedChannel := make(chan string, 10) + return &DeviceService{ + Devices: make(map[string]devices.Device), + Logger: logger, + Messages: sharedChannel, + } +} + +func (ds *DeviceService) FindDevices() { + // Need to define a list of devices to search for + // For now lets just try to find our cdashdisplay - will think about the rest later + + // Find CDashDisplay + { + ds.Messages <- "looking for " + cdashdisplay.Name + "...\n" + ds.Logger.Info("Looking for " + cdashdisplay.Name) + + cdashdisplay.SetLogger(ds.Logger.With("[device]", cdashdisplay.Name)) + + // Create a cdashdisplay + display, err := cdashdisplay.Discover() + if err == nil { + ds.Devices[cdashdisplay.Name] = display + ds.Logger.Info("found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name) + ds.Messages <- "found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name + "\n" + return + } + + ds.Logger.Info("didn't find " + cdashdisplay.Name) + ds.Messages <- "didn't find " + cdashdisplay.Name + "\n" + // No CDashDisplay available for one reason or another, so we don't set the + // key + } +} + +func (ds *DeviceService) GetDevice(name string) (devices.Device, error) { + val, ok := ds.Devices[name] + if !ok { + return nil, fmt.Errorf("device `%s` couldn't be found", name) + } + + return val, nil +} + +func (ds *DeviceService) StartStream() { + // NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this + var ctx context.Context + ctx, ds.streamCancel = context.WithCancel(context.Background()) + + go ds.transmit(ctx) +} + +func (ds *DeviceService) StopStream() { + if ds.streamCancel == nil { + return + } + + ds.streamCancel() + ds.streamCancel = nil +} + +// SetTelemetryChannel sets the TelemCh to the passed channel +func (ds *DeviceService) SetTelemetryChannel(ch <-chan telemetry.TelemetryData) { + ds.TelemCh = ch +} + +// transmit will send the data to the devices themselves +func (ds *DeviceService) transmit(ctx context.Context) { + var isSending atomic.Bool + + for { + select { + case <-ctx.Done(): + return + case data, ok := <-ds.TelemCh: + if !ok { + return + } + + if isSending.Load() { + continue + } + + isSending.Store(true) + + // TODO: make a copy of the data and send that copy instead of keeping + // the data locked + for _, dev := range ds.Devices { + dev.SendData(&data) + } + isSending.Store(false) + } + } +} diff --git a/services/telemetry.go b/services/telemetry.go index b2b5b5f..f50b532 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -14,8 +14,8 @@ import ( // TelemetryService will be our base struct to handle telemetry data // It should hook to a data sink and handle it like iRacing, BeamNG, AC and so on type TelemetryService struct { - logger *slog.Logger - cdash *CDashService + logger *slog.Logger + devService *DeviceService // Concurrency protection mut sync.RWMutex ativeProvider telem.TelemetryProvider @@ -24,13 +24,16 @@ type TelemetryService struct { cancelForward context.CancelFunc } -func NewTelemetryService(logger *slog.Logger, cdash *CDashService) *TelemetryService { +func NewTelemetryService(logger *slog.Logger, devServo *DeviceService) *TelemetryService { newService := &TelemetryService{ - logger: logger, - cdash: cdash, - listeners: make(map[string]chan telem.TelemetryData), + logger: logger, + devService: devServo, + listeners: make(map[string]chan telem.TelemetryData), } + // TODO: do not create and set a provider here, a background job should be + // detecting providers instead + // Need to instantiate a default provider here // source := "/home/esilva/Desktop/projetos/simracing_peripherals/testTelemetry/gt3_mustang_bathurst.ibt" firstProvider := providers.NewIRacingProvider(slog.Default(), goirsdk.Options{ diff --git a/tui/internal/controllers/layout.go b/tui/internal/controllers/cdashdisplay_layout.go similarity index 82% rename from tui/internal/controllers/layout.go rename to tui/internal/controllers/cdashdisplay_layout.go index a2b3a3d..da21306 100644 --- a/tui/internal/controllers/layout.go +++ b/tui/internal/controllers/cdashdisplay_layout.go @@ -5,11 +5,12 @@ import ( "os" "strconv" - "esdi/cdashdisplay" - helper "esdi/helpers" + "esdi/devices/cdashdisplay" "esdi/services" "esdi/tui/internal/views" + helper "esdi/helpers" + "github.com/gdamore/tcell/v2" "github.com/rivo/tview" ) @@ -19,12 +20,14 @@ type LayoutController struct { OnExit func() LayoutToolView *views.LayoutToolView Messages chan string - DevService *services.CDashService + DevService *services.DeviceService MoveToolState *windowManipState SelectedLayout string // NOTE: This should be a struct to handle its own things + // TODO: create a filter to select the layout + // filter telemetry provider, then filter vehicle in use and so on } -func NewLayoutController(base *Controller, service *services.CDashService) *LayoutController { +func NewLayoutController(base *Controller, service *services.DeviceService) *LayoutController { lc := &LayoutController{ Controller: base, LayoutToolView: views.NewLayoutToolView(), @@ -207,7 +210,20 @@ func (lc *LayoutController) createWindow() { return } - window, err = lc.DevService.CreateWindow(window) + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + if err != nil { + lc.Messages <- "failed to get " + cdashdisplay.Name + return + } + display, ok := displayIF.(*cdashdisplay.CDashDisplay) + if !ok { + lc.Messages <- "failed to acquire " + cdashdisplay.Name + return + } + // --- + + window, err = display.CreateWindow(window) if err != nil { lc.Messages <- "failed to create window\n" return @@ -304,7 +320,20 @@ func (lc *LayoutController) newWindowAction() { } func (lc *LayoutController) updateWindowAction(win *cdashdisplay.DesktopUIWindow) { - err := lc.DevService.UpdateWindow(win) + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + if err != nil { + lc.Messages <- "failed to get " + cdashdisplay.Name + return + } + display, ok := displayIF.(*cdashdisplay.CDashDisplay) + if !ok { + lc.Messages <- "failed to acquire " + cdashdisplay.Name + return + } + // --- + + err = display.UpdateWindow(win) lc.Messages <- fmt.Sprintf("Window: %v\n", win) @@ -317,7 +346,20 @@ func (lc *LayoutController) updateWindowAction(win *cdashdisplay.DesktopUIWindow func (lc *LayoutController) displayLoadedLayouts() { lc.Logger.Debug("We want to view our layout!") - for _, w := range lc.DevService.CDash.State.Layout.Windows { + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + if err != nil { + lc.Messages <- "failed to get " + cdashdisplay.Name + return + } + display, ok := displayIF.(*cdashdisplay.CDashDisplay) + if !ok { + lc.Messages <- "failed to acquire " + cdashdisplay.Name + return + } + // --- + + for _, w := range display.State.Layout.Windows { lc.Logger.Debug("==========================================================================") lc.Logger.Debug(fmt.Sprintf("updating form view for a layout: %+v", w.UIData.TelemetryField)) err := lc.updateFormView(w) @@ -349,8 +391,21 @@ func (lc *LayoutController) getCurrentTreeNodeModel() (*tview.TreeNode, int16, e } func (lc *LayoutController) loadLayout() { + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + if err != nil { + lc.Messages <- "failed to get " + cdashdisplay.Name + return + } + display, ok := displayIF.(*cdashdisplay.CDashDisplay) + if !ok { + lc.Messages <- "failed to acquire " + cdashdisplay.Name + return + } + // --- + // We would get the layout path from somewhere but for nots its layout.yaml - err := lc.DevService.LoadLayout(lc.SelectedLayout) + err = display.LoadLayout(lc.SelectedLayout) if err != nil { lc.Messages <- "failed to load layout: " + err.Error() return @@ -360,7 +415,20 @@ func (lc *LayoutController) loadLayout() { } func (lc *LayoutController) unloadLayout() { - err := lc.DevService.UnloadLayout() + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + if err != nil { + lc.Messages <- "failed to get " + cdashdisplay.Name + return + } + display, ok := displayIF.(*cdashdisplay.CDashDisplay) + if !ok { + lc.Messages <- "failed to acquire " + cdashdisplay.Name + return + } + // --- + + err = display.UnloadLayout() if err != nil { lc.Logger.Error(fmt.Sprintf("Failed to unload layout: %+v", err)) return @@ -368,7 +436,20 @@ func (lc *LayoutController) unloadLayout() { } func (lc *LayoutController) saveLayout() { - err := lc.DevService.SaveLayout(lc.SelectedLayout) + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + if err != nil { + lc.Messages <- "failed to get " + cdashdisplay.Name + return + } + display, ok := displayIF.(*cdashdisplay.CDashDisplay) + if !ok { + lc.Messages <- "failed to acquire " + cdashdisplay.Name + return + } + // --- + + err = display.SaveLayout(lc.SelectedLayout) if err != nil { lc.Messages <- "failed to save layout: " + err.Error() return @@ -388,8 +469,21 @@ func (lc *LayoutController) deleteWindow() { } wID := curNode.GetReference().(int16) + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + if err != nil { + lc.Messages <- "failed to get " + cdashdisplay.Name + return + } + display, ok := displayIF.(*cdashdisplay.CDashDisplay) + if !ok { + lc.Messages <- "failed to acquire " + cdashdisplay.Name + return + } + // --- + // Delete it - err := lc.DevService.DeleteWindow(wID) + err = display.DestroyWindow(wID) if err != nil { lc.Messages <- "failed to delete window: " + err.Error() + "\n" return diff --git a/tui/internal/controllers/layout_moveTool.go b/tui/internal/controllers/cdashdisplay_layout_moveTool.go similarity index 64% rename from tui/internal/controllers/layout_moveTool.go rename to tui/internal/controllers/cdashdisplay_layout_moveTool.go index 41bca62..d363a58 100644 --- a/tui/internal/controllers/layout_moveTool.go +++ b/tui/internal/controllers/cdashdisplay_layout_moveTool.go @@ -1,6 +1,7 @@ package controllers import ( + "esdi/devices/cdashdisplay" helper "esdi/helpers" "github.com/gdamore/tcell/v2" @@ -43,40 +44,68 @@ func keyToVector(r rune) (helper.Vector, bool) { } func (lc *LayoutController) handleMovementCapture(idx int16, - ev *tcell.EventKey) *tcell.EventKey { + ev *tcell.EventKey, +) *tcell.EventKey { vec, ok := keyToVector(ev.Rune()) if !ok { return nil } - err := lc.DevService.MoveWindow(idx, &vec) + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + if err != nil { + lc.Messages <- "failed to get " + cdashdisplay.Name + return nil + } + display, ok := displayIF.(*cdashdisplay.CDashDisplay) + if !ok { + lc.Messages <- "failed to acquire " + cdashdisplay.Name + return nil + } + // --- + + err = display.MoveWindow(idx, &vec) if err != nil { lc.Messages <- "failed to move window: " + err.Error() + "\n" return nil } // Success - update the form - window := lc.DevService.CDash.State.Layout.Windows[idx] + window := display.State.Layout.Windows[idx] lc.LayoutToolView.UpdateFormView(idx, window) return nil } func (lc *LayoutController) handleResizeCapture(idx int16, - ev *tcell.EventKey) *tcell.EventKey { + ev *tcell.EventKey, +) *tcell.EventKey { vec, ok := keyToVector(ev.Rune()) if !ok { return nil } - err := lc.DevService.ResizeWindow(idx, &vec) + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + if err != nil { + lc.Messages <- "failed to get " + cdashdisplay.Name + return nil + } + display, ok := displayIF.(*cdashdisplay.CDashDisplay) + if !ok { + lc.Messages <- "failed to acquire " + cdashdisplay.Name + return nil + } + // --- + + err = display.ResizeWindow(idx, &vec) if err != nil { lc.Messages <- "failed to resize window: " + err.Error() + "\n" return nil } // Success - update the form - window := lc.DevService.CDash.State.Layout.Windows[idx] + window := display.State.Layout.Windows[idx] lc.LayoutToolView.UpdateFormView(idx, window) return nil diff --git a/tui/internal/controllers/device.go b/tui/internal/controllers/device.go index c73ff98..c0f7648 100644 --- a/tui/internal/controllers/device.go +++ b/tui/internal/controllers/device.go @@ -15,12 +15,12 @@ type DeviceController struct { DeviceAPIView *views.DeviceAPIView LayoutCtrl *LayoutController StreamCtrl *StreamingCtrl - DevService *serv.CDashService + DevService *serv.DeviceService } func NewDeviceController( base *Controller, - devService *serv.CDashService, + devService *serv.DeviceService, telemService *serv.TelemetryService, ) *DeviceController { mc := &DeviceController{ @@ -56,7 +56,7 @@ func (mc *DeviceController) setDeviceAPIViewEvents() { SetInputCapture(func(ev *tcell.EventKey) *tcell.EventKey { switch ev.Rune() { case 'r': - go mc.DevService.FindDevice() + go mc.DevService.FindDevices() } return ev }) @@ -75,7 +75,8 @@ func (mc *DeviceController) AddDeviceAPIListItems() { }) mc.DeviceAPIView.DevAPIList. AddItem("stream", "stream data to the display", func() { - views.AddAndShowPage(mc.DeviceAPIView.DevAPIToolView.Pages, + views.AddAndShowPage( + mc.DeviceAPIView.DevAPIToolView.Pages, "streaming-tool", mc.StreamCtrl.StreamView.Flex, ) diff --git a/tui/internal/controllers/streaming.go b/tui/internal/controllers/streaming.go index a743de3..0edfd28 100644 --- a/tui/internal/controllers/streaming.go +++ b/tui/internal/controllers/streaming.go @@ -6,6 +6,7 @@ import ( "sync/atomic" "esdi/config" + "esdi/devices/cdashdisplay" "esdi/providers" "esdi/services" "esdi/telemetry" @@ -17,7 +18,7 @@ import ( type StreamingCtrl struct { *Controller - Service *services.CDashService + Service *services.DeviceService StreamView *views.StreamToolView Messages chan string Internal chan string @@ -32,7 +33,7 @@ type StreamingCtrl struct { func NewStreamingCtrl( base *Controller, - serCDash *services.CDashService, + devService *services.DeviceService, serTelem *services.TelemetryService, ) *StreamingCtrl { // NOTE: looks sus, put this somewhere also. Not very good in here @@ -44,7 +45,7 @@ func NewStreamingCtrl( ctrl := &StreamingCtrl{ Controller: base, - Service: serCDash, + Service: devService, TelemServ: serTelem, Messages: make(chan string, 10), Internal: make(chan string, 10), @@ -155,9 +156,22 @@ func (sc *StreamingCtrl) updateStream() { // Performance reasoning: this is not used during the high frequency data transmission // so we can get away with using a map for convenience here func (sc *StreamingCtrl) SetInternalState() { - fields := make(map[int16]telemetry.FieldID, len(sc.Service.CDash.State.Layout.Windows)) + // Acquire the cdashdisplay + displayIF, err := sc.Service.GetDevice(cdashdisplay.Name) + if err != nil { + sc.Messages <- "failed to get " + cdashdisplay.Name + return + } + display, ok := displayIF.(*cdashdisplay.CDashDisplay) + if !ok { + sc.Messages <- "failed to acquire " + cdashdisplay.Name + return + } + // --- - for _, w := range sc.Service.CDash.State.Layout.Windows { + fields := make(map[int16]telemetry.FieldID, len(display.State.Layout.Windows)) + + for _, w := range display.State.Layout.Windows { fieldID, _ := telemetry.GetFieldID(w.UIData.TelemetryField) fields[w.UIData.IDX] = fieldID } diff --git a/tui/internal/views/layoutTool.go b/tui/internal/views/layoutTool.go index 0c6d150..a8a8b01 100644 --- a/tui/internal/views/layoutTool.go +++ b/tui/internal/views/layoutTool.go @@ -4,7 +4,7 @@ import ( "fmt" "log/slog" - "esdi/cdashdisplay" + "esdi/devices/cdashdisplay" tviewh "esdi/tui/internal/tview_helpers" "github.com/gdamore/tcell/v2" diff --git a/tui/internal/views/layoutTool_forms.go b/tui/internal/views/layoutTool_forms.go index a2a6373..6d4278b 100644 --- a/tui/internal/views/layoutTool_forms.go +++ b/tui/internal/views/layoutTool_forms.go @@ -3,7 +3,7 @@ package views import ( "fmt" - "esdi/cdashdisplay" + "esdi/devices/cdashdisplay" "esdi/telemetry" "github.com/rivo/tview" diff --git a/tui/tui.go b/tui/tui.go index bea2890..747b9d7 100644 --- a/tui/tui.go +++ b/tui/tui.go @@ -23,7 +23,9 @@ func NewControlPanel(logger *slog.Logger) *ControlPanel { App: tview.NewApplication(), } - devService := services.NewCDashService(logger) + // NOTE: create our device service here + devService := services.NewDeviceService(logger) + telemService := services.NewTelemetryService(logger, devService) if telemService == nil { panic("failed to create the telemetry service") From a251f458597615693b42ad34512ee9696e0f971d Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Tue, 25 Aug 2026 22:01:34 +0100 Subject: [PATCH 02/41] basic loop to discover providers --- providers/beamng/utils.go | 33 ++++++++++ providers/iracing/utils.go | 16 +++++ providers/providers.go | 32 ++++++--- services/cdashdisplay.go | 131 ------------------------------------- services/telemetry.go | 61 ++++++++++++----- tui/tui.go | 2 + 6 files changed, 118 insertions(+), 157 deletions(-) create mode 100644 providers/beamng/utils.go create mode 100644 providers/iracing/utils.go delete mode 100644 services/cdashdisplay.go diff --git a/providers/beamng/utils.go b/providers/beamng/utils.go new file mode 100644 index 0000000..2854b74 --- /dev/null +++ b/providers/beamng/utils.go @@ -0,0 +1,33 @@ +package beamng + +import ( + "log/slog" + "net" + "time" +) + +func IsRunning() bool { + // The address should be loaded from some type of configuration + addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:4443") + if err != nil { + return false + } + + conn, err := net.ListenUDP("udp", addr) + defer conn.Close() + if err != nil { + slog.Debug("failed to listen to udp socket: " + err.Error()) + return false + } + + buf := make([]byte, 512) + conn.SetReadDeadline(time.Now().Add(50 * time.Millisecond)) + + n, _, err := conn.ReadFromUDP(buf) + if err != nil { + return false + } + + // Think of a better number or something + return n >= 80 +} diff --git a/providers/iracing/utils.go b/providers/iracing/utils.go new file mode 100644 index 0000000..b7b1d19 --- /dev/null +++ b/providers/iracing/utils.go @@ -0,0 +1,16 @@ +package iracing + +import "github.com/ESilva15/goirsdk" + +func IsRunning() bool { + sdk, err := goirsdk.Init(goirsdk.Options{ + SourceType: goirsdk.SharedMemoryFile, + }) + if err != nil { + return false + } + + sdk.Close() + + return true +} diff --git a/providers/providers.go b/providers/providers.go index e95e079..e635f39 100644 --- a/providers/providers.go +++ b/providers/providers.go @@ -14,28 +14,42 @@ import ( // Make this be some kind of struct where we can access a function that returns // the selected provider by its name type Provider struct { - Name string - Provider telemetry.TelemetryProvider + Name string + NewProvider func(*slog.Logger) telemetry.TelemetryProvider + IsRunning func() bool } var Providers = map[string]Provider{ beamng.NAME: { - Name: beamng.NAME, + Name: beamng.NAME, + NewProvider: NewBeamNGProvider, + IsRunning: beamng.IsRunning, }, iracing.NAME: { - Name: iracing.NAME, + Name: iracing.NAME, + NewProvider: NewLiveIRacingProvider, + IsRunning: iracing.IsRunning, }, } -func NewIRacingProvider(logger *slog.Logger, opts goirsdk.Options, -) telemetry.TelemetryProvider { - provider, _ := iracing.NewIRacingProvider(logger, opts) +// func NewIRacingProvider(logger *slog.Logger, opts goirsdk.Options, +// ) telemetry.TelemetryProvider { +// provider, _ := iracing.NewIRacingProvider(logger, opts) +// +// return provider +// } + +func NewLiveIRacingProvider(logger *slog.Logger) telemetry.TelemetryProvider { + provider, _ := iracing.NewIRacingProvider(logger, goirsdk.Options{ + SourceType: goirsdk.SharedMemoryFile, + }) return provider } -func NewBeamNGProvider(ip string, port int) telemetry.TelemetryProvider { - provider, _ := beamng.NewBeamNGProvider(ip, port) +func NewBeamNGProvider(logger *slog.Logger) telemetry.TelemetryProvider { + // Get from some kind of config or whatever + provider, _ := beamng.NewBeamNGProvider("127.0.0.1", 4443) return provider } diff --git a/services/cdashdisplay.go b/services/cdashdisplay.go deleted file mode 100644 index 111b2dc..0000000 --- a/services/cdashdisplay.go +++ /dev/null @@ -1,131 +0,0 @@ -package services - -// type CDashService struct { -// Logger *slog.Logger -// CDash *cdashdisplay.CDashDisplay -// // DevClerk *peripheral.PeripheralDeviceClerk -// // Messages chan string -// // Telemetry Channel -// // streamCancel context.CancelFunc -// // TelemCh <-chan telemetry.TelemetryData -// } - -// func NewCDashService(logger *slog.Logger) *CDashService { -// // sharedChannel := make(chan string, 10) -// return &CDashService{ -// Logger: logger, -// CDash: nil, -// // DevClerk: peripheral.NewPeripheralDeviceClerk(), -// // Messages: sharedChannel, -// } -// } - -// func (ds *CDashService) FindDevice() { -// ds.Messages <- "looking for cdash display...\n" -// ds.Logger.Info("Looking for CDashDisplay") - -// cdashdisplay.SetLogger(ds.Logger.With("[device]", "cdashdisplay")) - -// display, err := cdashdisplay.Discover() -// if err != nil { -// ds.Logger.Info("didn't find cdashdisplay") -// ds.Messages <- "didn't find cdash display\n" -// return -// } -// -// ds.CDash = display -// ds.Logger.Info("found cdashdisplay on: " + display.WT.Cfg.Name) -// ds.Messages <- "found cdashdisplay on: " + display.WT.Cfg.Name + "\n" -// } - -// func (ds *CDashService) CreateWindow( -// win *cdashdisplay.DesktopUIWindow, -// ) (*cdashdisplay.DesktopUIWindow, error) { -// updatedWindow, err := ds.CDash.CreateWindow(win) -// if err != nil { -// return nil, err -// } -// -// return updatedWindow, nil -// } -// -// func (ds *CDashService) LoadLayout(layoutPath string) error { -// return ds.CDash.LoadLayout(layoutPath) -// } -// -// func (ds *CDashService) SaveLayout(layoutPath string) error { -// return ds.CDash.SaveLayout(layoutPath) -// } -// -// func (ds *CDashService) UnloadLayout() error { -// return ds.CDash.UnloadLayout() -// } -// -// func (ds *CDashService) UpdateWindow(win *cdashdisplay.DesktopUIWindow) error { -// ds.Messages <- fmt.Sprintf("Updating a window:\n%+v\n", win) -// return ds.CDash.UpdateWindow(win) -// } -// -// func (ds *CDashService) DeleteWindow(idx int16) error { -// return ds.CDash.DestroyWindow(idx) -// } -// -// func (ds *CDashService) ResizeWindow(idx int16, vec *helper.Vector) error { -// err := ds.CDash.ResizeWindow(idx, vec) -// if err != nil { -// return err -// } -// -// return nil -// } -// -// func (ds *CDashService) MoveWindow(idx int16, vec *helper.Vector) error { -// return ds.CDash.MoveWindow(idx, vec) -// } - -// func (ds *CDashService) SetTelemetryChannel(ch <-chan telemetry.TelemetryData) { -// ds.TelemCh = ch -// } - -// func (cds *CDashService) StartStream() { -// // NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this -// var ctx context.Context -// ctx, cds.streamCancel = context.WithCancel(context.Background()) -// -// go cds.transmit(ctx) -// } -// -// func (cds *CDashService) StopStream() { -// if cds.streamCancel == nil { -// return -// } -// -// cds.streamCancel() -// cds.streamCancel = nil -// } - -// INTERNAL - -// func (ds *CDashService) transmit(ctx context.Context) { -// var isSending atomic.Bool -// -// for { -// select { -// case <-ctx.Done(): -// return -// case data, ok := <-ds.TelemCh: -// if !ok { -// return -// } -// -// if isSending.Load() { -// continue -// } -// -// isSending.Store(true) -// -// ds.CDash.SendData(&data) -// isSending.Store(false) -// } -// } -// } diff --git a/services/telemetry.go b/services/telemetry.go index f50b532..b68d32c 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -4,11 +4,10 @@ import ( "context" "log/slog" "sync" + "time" "esdi/providers" telem "esdi/telemetry" - - "github.com/ESilva15/goirsdk" ) // TelemetryService will be our base struct to handle telemetry data @@ -19,33 +18,61 @@ type TelemetryService struct { // Concurrency protection mut sync.RWMutex ativeProvider telem.TelemetryProvider + isConnected bool // Channel for the UI listeners map[string]chan telem.TelemetryData cancelForward context.CancelFunc + // Output window + Messages chan string + // Cancel looking for providers + CtxMonitor context.Context + cancelMonitor context.CancelFunc } func NewTelemetryService(logger *slog.Logger, devServo *DeviceService) *TelemetryService { + sharedChannel := make(chan string, 10) newService := &TelemetryService{ - logger: logger, - devService: devServo, - listeners: make(map[string]chan telem.TelemetryData), + logger: logger, + isConnected: false, + devService: devServo, + listeners: make(map[string]chan telem.TelemetryData), + Messages: sharedChannel, } - - // TODO: do not create and set a provider here, a background job should be - // detecting providers instead - - // Need to instantiate a default provider here - // source := "/home/esilva/Desktop/projetos/simracing_peripherals/testTelemetry/gt3_mustang_bathurst.ibt" - firstProvider := providers.NewIRacingProvider(slog.Default(), goirsdk.Options{ - SourceType: goirsdk.SharedMemoryFile, - }) - // firstProvider := providers.NewBeamNGProvider("127.0.0.1", 4443) - - newService.SwitchProvider(firstProvider) + newService.CtxMonitor, newService.cancelMonitor = context.WithCancel(context.Background()) return newService } +func (t *TelemetryService) OnFindProvider(prov providers.Provider) { + t.SwitchProvider(prov.NewProvider(t.logger)) + t.logger.Debug("Found provider for " + prov.Name) +} + +// TODO: add some way of retriggering this. Currently it should: +// start monitoring on startup -> find provider -> stop monitoring +func (t *TelemetryService) FindProvider(ctx context.Context, callback func(providers.Provider), +) { + ticker := time.NewTicker(2 * time.Second) + defer ticker.Stop() + + t.logger.Debug("monitoring for providers") + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + for _, prov := range providers.Providers { + t.logger.Debug("checking provider: " + prov.Name) + if prov.IsRunning() { + callback(prov) + return + } + t.logger.Debug(" wasn't read") + } + } + } +} + func (t *TelemetryService) SwitchProvider(newProvider telem.TelemetryProvider) error { t.mut.Lock() defer t.mut.Unlock() diff --git a/tui/tui.go b/tui/tui.go index 747b9d7..68feb50 100644 --- a/tui/tui.go +++ b/tui/tui.go @@ -31,6 +31,8 @@ func NewControlPanel(logger *slog.Logger) *ControlPanel { panic("failed to create the telemetry service") } + go telemService.FindProvider(telemService.CtxMonitor, telemService.OnFindProvider) + return &ControlPanel{ Controller: baseController, DeviceController: controllers.NewDeviceController(baseController, devService, telemService), From 1d022a4fa855f9c8eda6b15435077151ee9d0c9f Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Thu, 10 Sep 2026 15:11:37 +0100 Subject: [PATCH 03/41] update the iracing provider to be on the same page as the BeamNG one Deprecated the Fetch and Transform methods --- providers/beamng/utils.go | 6 ++ providers/iracing/fieldMapping.go | 61 ++++------- providers/iracing/iracing.go | 172 +++++++++++------------------- providers/iracing/transforms.go | 125 ++++++++++++++++++++-- providers/iracing/utils.go | 27 ++++- providers/providers.go | 10 +- 6 files changed, 231 insertions(+), 170 deletions(-) diff --git a/providers/beamng/utils.go b/providers/beamng/utils.go index 2854b74..98eb459 100644 --- a/providers/beamng/utils.go +++ b/providers/beamng/utils.go @@ -31,3 +31,9 @@ func IsRunning() bool { // Think of a better number or something return n >= 80 } + +// Stalled +// TODO: needs to be implemented +func (i *BeamNG) Stalled() bool { + return false +} diff --git a/providers/iracing/fieldMapping.go b/providers/iracing/fieldMapping.go index 6df98f3..76948fa 100644 --- a/providers/iracing/fieldMapping.go +++ b/providers/iracing/fieldMapping.go @@ -2,44 +2,23 @@ package iracing // This file maps the data from the desktop provider data structure to iRacing -import ( - "esdi/telemetry" -) - -var internalToSDKFieldNames = map[telemetry.FieldID]string{ - telemetry.Speed: "Speed", - telemetry.Gear: "Gear", - telemetry.RPM: "RPM", - telemetry.FuelLevel: "FuelLevel", - // Engine Data - telemetry.OilPress: "OilPress", - telemetry.OilTemp: "OilTemp", - telemetry.WaterTemp: "WaterTemp", - // Engine Warnings - telemetry.PitSpeedLimiter: "irsdk_pitSpeedLimiter", - // Ajudstements - telemetry.BrakeBias: "dcBrakeBias", - telemetry.ABSSetting: "dcABS", - telemetry.TCSetting: "dcTractionControl", - telemetry.ThrottleSetting: "dcThrottleShape", - // Lap Data - telemetry.LapLastLapTime: "LapLastLapTime", - telemetry.LapNumber: "Lap", - // Tire data - telemetry.LFtempL: "LFtempCL", - telemetry.LFtempM: "LFtempCM", - telemetry.LFtempR: "LFtempCR", - telemetry.RFtempL: "RFtempCL", - telemetry.RFtempM: "RFtempCM", - telemetry.RFtempR: "RFtempCR", - telemetry.LRtempL: "LRtempCL", - telemetry.LRtempM: "LRtempCM", - telemetry.LRtempR: "LRtempCR", - telemetry.RRtempL: "RRtempCL", - telemetry.RRtempM: "RRtempCM", - telemetry.RRtempR: "RRtempCR", - // Session Data - telemetry.SessionTime: "SessionTime", - telemetry.ReplaySessionTime: "ReplaySessionTime", - telemetry.Empty: "empty", -} +// TODO: pass these to the new Updaters system +// var internalToSDKFieldNames = map[telemetry.FieldID]string{ +// // Tire data +// telemetry.LFtempL: "LFtempCL", +// telemetry.LFtempM: "LFtempCM", +// telemetry.LFtempR: "LFtempCR", +// telemetry.RFtempL: "RFtempCL", +// telemetry.RFtempM: "RFtempCM", +// telemetry.RFtempR: "RFtempCR", +// telemetry.LRtempL: "LRtempCL", +// telemetry.LRtempM: "LRtempCM", +// telemetry.LRtempR: "LRtempCR", +// telemetry.RRtempL: "RRtempCL", +// telemetry.RRtempM: "RRtempCM", +// telemetry.RRtempR: "RRtempCR", +// // Session Data +// telemetry.SessionTime: "SessionTime", +// telemetry.ReplaySessionTime: "ReplaySessionTime", +// telemetry.Empty: "empty", +// } diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index 395fbdc..65b5c01 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -7,11 +7,9 @@ import ( "context" "fmt" "log/slog" - "strconv" "sync" "time" - conv "esdi/conversions" "esdi/telemetry" "github.com/ESilva15/goirsdk" @@ -57,26 +55,71 @@ func NewIRacingProvider( data: telemetry.NewTelemetryData(), streamCh: make(chan telemetry.TelemetryData, 1), // NOTE: This is because I stupidly recorded a test IBT file in 240 + // TODO: make this configurable from the user side ticker: time.NewTicker(time.Second / 240), } - // provider.updaters = [telemetry.MaxFields]func(*telemetry.TelemetryField){} + provider.updaters = [telemetry.MaxFields]func(*telemetry.TelemetryField){ + telemetry.Speed: provider.speed, + telemetry.Gear: provider.gear, + telemetry.RPM: provider.rpm, + telemetry.FuelLevel: provider.fuelLevel, + // Engine Data + telemetry.OilPress: provider.oilPress, + telemetry.OilTemp: provider.oilTemp, + telemetry.WaterTemp: provider.waterTemp, + // EngineWarnings + telemetry.PitSpeedLimiter: provider.pitSpeedLimiter, + // Adjustements + telemetry.BrakeBias: provider.brakeBias, + telemetry.ABSSetting: provider.absSetting, + telemetry.TCSetting: provider.tcSetting, + telemetry.ThrottleSetting: provider.throttleSetting, + // Lap Data + telemetry.LapLastLapTime: provider.lapTime, + telemetry.LapNumber: provider.lapNumber, + // case telemetry.LFtempM: + // binding.Transform = func(v any, out *telemetry.TelemetryField) { + // out.Type = telemetry.DataTypeSTRING + // out.Str = strconv.FormatFloat(float64(v.(float32)), 'f', 1, 32) + // } + // case telemetry.SessionTime: + // binding.Transform = func(v any, out *telemetry.TelemetryField) { + // out.Type = telemetry.DataTypeSTRING + // out.Str = strconv.FormatFloat(v.(float64), 'f', 1, 32) + // } + // case telemetry.ReplaySessionTime: + // binding.Transform = func(v any, out *telemetry.TelemetryField) { + // out.Type = telemetry.DataTypeSTRING + // out.Str = strconv.FormatFloat(v.(float64), 'f', 1, 32) + // } + // case telemetry.Empty: + // binding.Transform = telemetry.EmptyTransform + // } + } + + // Set the unset telemetry fields on the updaters as unused fields + for k := range int(telemetry.MaxFields) { + if provider.updaters[k] == nil { + provider.updaters[k] = provider.unused + } + } return provider, nil } func (i *IRacing) isDataAvailable() bool { // Its offline telemetry, data must be available - if i.SDK.File != nil { - return true + if i.SDK.File == nil { + return false } // Check if live telemetry is on - if i.SDK.IsConnected() { - return true + if !i.SDK.IsConnected() { + return false } - return false + return true } func (i *IRacing) stream(ctx context.Context) { @@ -84,17 +127,19 @@ func (i *IRacing) stream(ctx context.Context) { go func() { for { - // Explicitly intercpt cancellation + // Explicitly intercept cancellation select { case <-ctx.Done(): return default: } + // TODO: fix this logic // We start by checking if we do or do not have data available - if !i.isDataAvailable() { - continue - } + // if !i.isDataAvailable() { + // i.logger.Info("isDataAvailable check failed. Cancelling stream...") + // i.streamCancel() + // } select { case <-ctx.Done(): @@ -124,18 +169,14 @@ func (i *IRacing) readData() { return } - // Read 1 to 1 data - for _, b := range i.data.ActiveBinds { - v := i.SDK.Vars.Vars[b.Key].Value - - b.Transform(v, &i.data.Values[b.ID]) + // Read 1 to 1 data using our updaters + for _, bind := range i.data.ActiveBinds { + i.updaters[bind.ID](&i.data.Values[bind.ID]) } // Set up virtual binds i.logger.Debug("Entering virtual binds loop") for _, vBind := range i.data.VirtualBinds { - // NOTE: delete the logs here, they are really bad - i.logger.Debug("Processing virtual binds") vBind.Process(i.data) } @@ -173,7 +214,7 @@ func (i *IRacing) Subscribe(requestFields map[int16]telemetry.FieldID) { // First we must add the virtual fields // we will add their dependencies and the primitives to a slice - pendingBinds := make([]telemetry.FieldID, telemetry.MaxFields) + pendingBinds := make([]telemetry.FieldID, 0, telemetry.MaxFields) for winID, id := range requestFields { i.data.Values[id].IDs = append(i.data.Values[id].IDs, winID) @@ -199,97 +240,8 @@ func (i *IRacing) Subscribe(requestFields map[int16]telemetry.FieldID) { continue } - // Translate the UI FieldIDs to this provider's field names - sdkKey, ok := internalToSDKFieldNames[id] - if !ok { - i.logger.Debug("failed to get internal id") - // Need to find a way to pass a message saying something wasn't right - continue - } - binding := telemetry.BoundField{ - Key: sdkKey, - ID: id, - } - - switch id { - case telemetry.Speed: - binding.Transform = func(v any, out *telemetry.TelemetryField) { - out.Type = telemetry.DataTypeUINT16 - out.Raw = uint64(conv.MsToKph(v.(float32))) - } - case telemetry.Gear: - binding.Transform = func(v any, out *telemetry.TelemetryField) { - out.Type = telemetry.DataTypeCHAR - // out.Raw = uint64(v.(int)) - - gear := 0 - if val, ok := v.(int32); ok { - gear = int(val) - } else if val, ok := v.(int); ok { - gear = val - } - - switch { - case gear == 0: - out.Raw = uint64('N') // ASCII 78 - case gear < 0: - out.Raw = uint64('R') // ASCII 82 - case gear > 0 && gear < 10: - // Quickest way to turn 1 into '1', 2 into '2', etc. - // ASCII '0' is 48, so 48 + 1 = 49 ('1') - out.Raw = uint64('0' + gear) - default: - out.Raw = uint64('?') // Fallback - } - } - case telemetry.RPM: - binding.Transform = func(v any, out *telemetry.TelemetryField) { - out.Type = telemetry.DataTypeUINT16 - out.Raw = uint64(uint16(v.(float32))) - } - case telemetry.FuelLevel: - binding.Transform = telemetry.FloatToStringTransformDEPRECATE - // Engine Data - case telemetry.OilPress: - binding.Transform = telemetry.FloatToStringTransformDEPRECATE - case telemetry.OilTemp: - binding.Transform = telemetry.FloatToStringTransformDEPRECATE - case telemetry.WaterTemp: - binding.Transform = telemetry.FloatToStringTransformDEPRECATE - // Something else - case telemetry.PitSpeedLimiter: - binding.Transform = PitSpeedLimiterTransform - // Adjustements - case telemetry.BrakeBias: - binding.Transform = telemetry.FloatToStringTransformDEPRECATE - case telemetry.ABSSetting: - binding.Transform = telemetry.FloatToUInt8TransformDEPRECATE - case telemetry.TCSetting: - binding.Transform = telemetry.FloatToUInt8TransformDEPRECATE - case telemetry.ThrottleSetting: - binding.Transform = telemetry.FloatToUInt8TransformDEPRECATE - case telemetry.LFtempM: - binding.Transform = func(v any, out *telemetry.TelemetryField) { - out.Type = telemetry.DataTypeSTRING - out.Str = strconv.FormatFloat(float64(v.(float32)), 'f', 1, 32) - } - case telemetry.SessionTime: - binding.Transform = func(v any, out *telemetry.TelemetryField) { - out.Type = telemetry.DataTypeSTRING - out.Str = strconv.FormatFloat(v.(float64), 'f', 1, 32) - } - case telemetry.ReplaySessionTime: - binding.Transform = func(v any, out *telemetry.TelemetryField) { - out.Type = telemetry.DataTypeSTRING - out.Str = strconv.FormatFloat(v.(float64), 'f', 1, 32) - } - case telemetry.Empty: - binding.Transform = telemetry.EmptyTransform - case telemetry.LapLastLapTime: - binding.Transform = LapTimeTransform - case telemetry.LapNumber: - binding.Transform = telemetry.UInt8Transform + ID: id, } i.data.ActiveBinds = append(i.data.ActiveBinds, binding) diff --git a/providers/iracing/transforms.go b/providers/iracing/transforms.go index e3e64a4..5c9b74a 100644 --- a/providers/iracing/transforms.go +++ b/providers/iracing/transforms.go @@ -3,15 +3,124 @@ package iracing import ( "time" + conv "esdi/conversions" "esdi/telemetry" + + "github.com/ESilva15/goirsdk" ) const ( LapTimeFormatStr = "04:05.000" ) -func LapTimeTransform(v any, out *telemetry.TelemetryField) { - lapTimeInSeconds := v.(float32) +func getVar[T any](vars map[string]goirsdk.Var, key string, fallback T) T { + raw, ok := vars[key] + if !ok { + return fallback + } + + val, ok := raw.Value.(T) + if !ok { + return fallback + } + + return val +} + +func (i *IRacing) unused(out *telemetry.TelemetryField) { + out.Unused() +} + +func (i *IRacing) speed(out *telemetry.TelemetryField) { + speed := getVar(i.SDK.Vars.Vars, "Speed", float32(0)) + + out.Type = telemetry.DataTypeUINT16 + out.Raw = uint64(conv.MsToKph(speed)) +} + +func (i *IRacing) gear(out *telemetry.TelemetryField) { + gear := getVar(i.SDK.Vars.Vars, "Gear", int32(0)) + + out.Type = telemetry.DataTypeCHAR + + switch { + case gear == 0: + out.Raw = uint64('N') + case gear < 0: + out.Raw = uint64('R') + case gear > 0 && gear < 10: + out.Raw = uint64('0' + gear) + default: + out.Raw = uint64('?') // Fallback + } +} + +func (i *IRacing) rpm(out *telemetry.TelemetryField) { + rpm := getVar(i.SDK.Vars.Vars, "RPM", float32(0)) + + out.Type = telemetry.DataTypeUINT16 + out.Raw = uint64(uint16(rpm)) +} + +func (i *IRacing) fuelLevel(out *telemetry.TelemetryField) { + fuelLevel := getVar(i.SDK.Vars.Vars, "FuelLevel", float32(-1.0)) + telemetry.FloatToStringTransform(fuelLevel, out) +} + +// EngineWarnings +func (i *IRacing) pitSpeedLimiter(out *telemetry.TelemetryField) { + out.Type = telemetry.DataTypeSTRING + out.Str = " " + + if i.SDK.PitSpeedLimiter() { + out.Str = "PIT" + } +} + +// EngineData ↓ +func (i *IRacing) oilPress(out *telemetry.TelemetryField) { + oilPress := getVar(i.SDK.Vars.Vars, "OilPress", float32(-1.0)) + telemetry.FloatToStringTransform(oilPress, out) +} + +func (i *IRacing) oilTemp(out *telemetry.TelemetryField) { + oilTemp := getVar(i.SDK.Vars.Vars, "OilTemp", float32(-1.0)) + telemetry.FloatToStringTransform(oilTemp, out) +} + +func (i *IRacing) waterTemp(out *telemetry.TelemetryField) { + waterTemp := getVar(i.SDK.Vars.Vars, "WaterTemp", float32(-1.0)) + telemetry.FloatToStringTransform(waterTemp, out) +} + +// EngineData ↑ + +// Adjustments ↓ +func (i *IRacing) brakeBias(out *telemetry.TelemetryField) { + bb := getVar(i.SDK.Vars.Vars, "dcBrakeBias", float32(-1.0)) + telemetry.FloatToStringTransform(bb, out) +} + +func (i *IRacing) absSetting(out *telemetry.TelemetryField) { + abs := getVar(i.SDK.Vars.Vars, "dcABS", float32(-1.0)) + telemetry.FloatToUInt8Transform(abs, out) +} + +func (i *IRacing) tcSetting(out *telemetry.TelemetryField) { + tc := getVar(i.SDK.Vars.Vars, "dcTractionControl", float32(-1.0)) + telemetry.FloatToUInt8Transform(tc, out) +} + +func (i *IRacing) throttleSetting(out *telemetry.TelemetryField) { + throttle := getVar(i.SDK.Vars.Vars, "dcThrottleShape", float32(-1.0)) + telemetry.FloatToUInt8Transform(throttle, out) +} + +// Adjustments ↑ + +// Laps ↓ +func (i *IRacing) lapTime(out *telemetry.TelemetryField) { + lapTimeInSeconds := getVar(i.SDK.Vars.Vars, "LapLastLapTime", float32(0)) if lapTimeInSeconds < 0 { lapTimeInSeconds = 0 @@ -24,11 +133,9 @@ func LapTimeTransform(v any, out *telemetry.TelemetryField) { out.Str = lapTime.Format(LapTimeFormatStr) } -func PitSpeedLimiterTransform(v any, out *telemetry.TelemetryField) { - out.Type = telemetry.DataTypeSTRING - if v.(bool) { - out.Str = "PIT" - } else { - out.Str = " " - } +func (i *IRacing) lapNumber(out *telemetry.TelemetryField) { + lapNumber := getVar(i.SDK.Vars.Vars, "Lap", int(0)) + telemetry.UInt8Transform(lapNumber, out) } + +// Laps ↑ diff --git a/providers/iracing/utils.go b/providers/iracing/utils.go index b7b1d19..ac9d2df 100644 --- a/providers/iracing/utils.go +++ b/providers/iracing/utils.go @@ -1,16 +1,39 @@ package iracing -import "github.com/ESilva15/goirsdk" +import ( + "github.com/ESilva15/goirsdk" +) func IsRunning() bool { sdk, err := goirsdk.Init(goirsdk.Options{ SourceType: goirsdk.SharedMemoryFile, }) + defer sdk.Close() if err != nil { return false } - sdk.Close() + // if sdk.SessionStateInvalid() { + // slog.Debug("state is invalid") + // sessionState, ok := sdk.Vars.Vars["SessionState"] + // if !ok { + // slog.Debug("SessionState not ok") + // return false + // } + // + // state, ok := sessionState.Value.(int) + // if !ok { + // slog.Debug(fmt.Sprintf("can't typecast: %+v", sessionState)) + // return false + // } + // + // slog.Debug(fmt.Sprintf("%d", state)) + // return false + // } return true } + +func (i *IRacing) Stalled() bool { + return i.Stalled() +} diff --git a/providers/providers.go b/providers/providers.go index e635f39..f38c1b1 100644 --- a/providers/providers.go +++ b/providers/providers.go @@ -16,7 +16,7 @@ import ( type Provider struct { Name string NewProvider func(*slog.Logger) telemetry.TelemetryProvider - IsRunning func() bool + IsRunning func() bool // To check if this provider is up and running } var Providers = map[string]Provider{ @@ -32,15 +32,9 @@ var Providers = map[string]Provider{ }, } -// func NewIRacingProvider(logger *slog.Logger, opts goirsdk.Options, -// ) telemetry.TelemetryProvider { -// provider, _ := iracing.NewIRacingProvider(logger, opts) -// -// return provider -// } - func NewLiveIRacingProvider(logger *slog.Logger) telemetry.TelemetryProvider { provider, _ := iracing.NewIRacingProvider(logger, goirsdk.Options{ + Logger: logger, SourceType: goirsdk.SharedMemoryFile, }) From 6b09eb5be0da29443d8c84600086db1a68eabb8f Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Thu, 10 Sep 2026 15:12:12 +0100 Subject: [PATCH 04/41] some fixes regarding iracing provider transforms and working the auto detection --- services/telemetry.go | 7 ++--- telemetry/commonTransforms.go | 55 ++++++++++++++++------------------- telemetry/data.go | 10 +++---- telemetry/provider.go | 1 + 4 files changed, 33 insertions(+), 40 deletions(-) diff --git a/services/telemetry.go b/services/telemetry.go index b68d32c..5db8b0c 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -49,7 +49,7 @@ func (t *TelemetryService) OnFindProvider(prov providers.Provider) { } // TODO: add some way of retriggering this. Currently it should: -// start monitoring on startup -> find provider -> stop monitoring +// start monitoring on startup -> find provider -> stop monitoring (when game closes for example) func (t *TelemetryService) FindProvider(ctx context.Context, callback func(providers.Provider), ) { ticker := time.NewTicker(2 * time.Second) @@ -157,9 +157,8 @@ func (t *TelemetryService) StartStream() { // Start the new stream simInCh, _ := t.ativeProvider.Stream() - // if err != nil { - // // NOTE - // } + // TODO: the provider needs to be able to tell the data has stopped + // so we can restart the provider lookup routine // Create the context so we can control the lifecycle ctx, cancel := context.WithCancel(context.Background()) diff --git a/telemetry/commonTransforms.go b/telemetry/commonTransforms.go index b24ef70..eeba914 100644 --- a/telemetry/commonTransforms.go +++ b/telemetry/commonTransforms.go @@ -7,40 +7,35 @@ func EmptyTransform(v any, out *TelemetryField) { out.Raw = uint64('-') } -func UInt8Transform(v any, out *TelemetryField) { +func UInt8Transform(v int, out *TelemetryField) { out.Type = DataTypeUINT8 - if v == nil { - out.Raw = 0 - return - } - - out.Raw = uint64(v.(int)) -} - -func FloatToStringTransform(v float32, out *TelemetryField) { - out.Type = DataTypeSTRING - out.Str = strconv.FormatFloat(float64(v), 'f', 1, 32) -} - -func FloatToStringTransformDEPRECATE(v any, out *TelemetryField) { - out.Type = DataTypeSTRING - - if v == nil { - out.Str = "inv" - return - } - - out.Str = strconv.FormatFloat(float64(v.(float32)), 'f', 1, 32) -} - -func FloatToUInt8TransformDEPRECATE(v any, out *TelemetryField) { - out.Type = DataTypeUINT8 - - if v == nil { + if v < 0 { out.Raw = uint64(0) return } - out.Raw = uint64(v.(float32)) + out.Raw = uint64(v) +} + +func FloatToStringTransform(v float32, out *TelemetryField) { + out.Type = DataTypeSTRING + + if v < 0.0 { + out.Str = "inv" + return + } + + out.Str = strconv.FormatFloat(float64(v), 'f', 1, 32) +} + +func FloatToUInt8Transform(v float32, out *TelemetryField) { + out.Type = DataTypeUINT8 + + if v < 0.0 { + out.Raw = uint64(0) + return + } + + out.Raw = uint64(v) } diff --git a/telemetry/data.go b/telemetry/data.go index 5c3ec38..158e815 100644 --- a/telemetry/data.go +++ b/telemetry/data.go @@ -30,11 +30,8 @@ type VirtualField interface { // BoundField is the data structure we use to bind the telemetry provider's data // to our internal telemetry fields type BoundField struct { - Key string // NOTE: to be deprecated - ID FieldID - Fetch func() any // NOTE: to be deprecated - Transform func(any, *TelemetryField) // NOTE: to be deprecated - Update func(out *TelemetryField) + ID FieldID + Update func(out *TelemetryField) } var bufferPool = sync.Pool{ @@ -105,7 +102,8 @@ func (tf *TelemetryField) Pack(dest []byte) []byte { case DataTypeINT32, DataTypeUINT32: dest = append(dest, uint8(tf.Raw), uint8(tf.Raw>>8), uint8(tf.Raw>>16), uint8(tf.Raw>>24)) case DataTypeINT64, DataTypeUINT64: - dest = append(dest, uint8(tf.Raw), uint8(tf.Raw>>8), uint8(tf.Raw>>16), + dest = append( + dest, uint8(tf.Raw), uint8(tf.Raw>>8), uint8(tf.Raw>>16), uint8(tf.Raw>>24), uint8(tf.Raw>>32), uint8(tf.Raw>>40), uint8(tf.Raw>>48), uint8(tf.Raw>>56), ) diff --git a/telemetry/provider.go b/telemetry/provider.go index 2aea6be..ff3faca 100644 --- a/telemetry/provider.go +++ b/telemetry/provider.go @@ -5,4 +5,5 @@ type TelemetryProvider interface { StopStream() Stream() (<-chan TelemetryData, error) Subscribe(map[int16]FieldID) + Stalled() bool // Return true if no fresh data is coming } From 922c2df88d88fe45bda460ca4fac1da653df7f62 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 11 Sep 2026 12:48:36 +0100 Subject: [PATCH 05/41] Don't allow program to crash if there's no active provider on StartStream action --- services/telemetry.go | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/services/telemetry.go b/services/telemetry.go index 5db8b0c..f9f8566 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -16,9 +16,9 @@ type TelemetryService struct { logger *slog.Logger devService *DeviceService // Concurrency protection - mut sync.RWMutex - ativeProvider telem.TelemetryProvider - isConnected bool + mut sync.RWMutex + activeProvider telem.TelemetryProvider + isConnected bool // Channel for the UI listeners map[string]chan telem.TelemetryData cancelForward context.CancelFunc @@ -78,12 +78,12 @@ func (t *TelemetryService) SwitchProvider(newProvider telem.TelemetryProvider) e defer t.mut.Unlock() // Clean up the current to be old provider - if t.ativeProvider != nil { + if t.activeProvider != nil { t.dropActiveProvider() } // Assign the new provider - t.ativeProvider = newProvider + t.activeProvider = newProvider return nil } @@ -117,7 +117,7 @@ func (t *TelemetryService) dropActiveProvider() { t.cancelForward() } - t.ativeProvider.StopStream() + t.activeProvider.StopStream() } func (t *TelemetryService) SubscribeListener(id string, bufferSize int) <-chan telem.TelemetryData { @@ -149,14 +149,18 @@ func (t *TelemetryService) UnsubscribeListener(id string) { } func (t *TelemetryService) SubscribeToFields(fields map[int16]telem.FieldID) { - t.ativeProvider.Subscribe(fields) + t.activeProvider.Subscribe(fields) } func (t *TelemetryService) StartStream() { slog.Debug("Stream started") // Start the new stream - simInCh, _ := t.ativeProvider.Stream() + if t.activeProvider == nil { + slog.Debug("there's no active provider. not starting the stream") + return + } + simInCh, _ := t.activeProvider.Stream() // TODO: the provider needs to be able to tell the data has stopped // so we can restart the provider lookup routine @@ -177,5 +181,5 @@ func (t *TelemetryService) StopStream() { t.cancelForward = nil } - t.ativeProvider.StopStream() + t.activeProvider.StopStream() } From 7675c7e34adbfe46e2ed1d03f627426808916bfa Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 11 Sep 2026 14:40:16 +0100 Subject: [PATCH 06/41] fixed the iracing Gear transform --- providers/iracing/transforms.go | 40 ++++++++++++++++++++------------- 1 file changed, 24 insertions(+), 16 deletions(-) diff --git a/providers/iracing/transforms.go b/providers/iracing/transforms.go index 5c9b74a..1e202c3 100644 --- a/providers/iracing/transforms.go +++ b/providers/iracing/transforms.go @@ -1,6 +1,7 @@ package iracing import ( + "log/slog" "time" conv "esdi/conversions" @@ -13,14 +14,21 @@ const ( LapTimeFormatStr = "04:05.000" ) -func getVar[T any](vars map[string]goirsdk.Var, key string, fallback T) T { +func getVar[T any]( + vars map[string]goirsdk.Var, + key string, + fallback T, + logger *slog.Logger, +) T { raw, ok := vars[key] if !ok { + logger.Error("key not present in map", "key", key) return fallback } val, ok := raw.Value.(T) if !ok { + logger.Error("could not cast value", "key", key, "val", raw) return fallback } @@ -32,23 +40,23 @@ func (i *IRacing) unused(out *telemetry.TelemetryField) { } func (i *IRacing) speed(out *telemetry.TelemetryField) { - speed := getVar(i.SDK.Vars.Vars, "Speed", float32(0)) + speed := getVar(i.SDK.Vars.Vars, "Speed", float32(0), i.logger) out.Type = telemetry.DataTypeUINT16 out.Raw = uint64(conv.MsToKph(speed)) } func (i *IRacing) gear(out *telemetry.TelemetryField) { - gear := getVar(i.SDK.Vars.Vars, "Gear", int32(0)) + gear := getVar(i.SDK.Vars.Vars, "Gear", int(0), i.logger) out.Type = telemetry.DataTypeCHAR switch { case gear == 0: out.Raw = uint64('N') - case gear < 0: + case gear == -1: out.Raw = uint64('R') - case gear > 0 && gear < 10: + case gear > 0: out.Raw = uint64('0' + gear) default: out.Raw = uint64('?') // Fallback @@ -56,14 +64,14 @@ func (i *IRacing) gear(out *telemetry.TelemetryField) { } func (i *IRacing) rpm(out *telemetry.TelemetryField) { - rpm := getVar(i.SDK.Vars.Vars, "RPM", float32(0)) + rpm := getVar(i.SDK.Vars.Vars, "RPM", float32(0), i.logger) out.Type = telemetry.DataTypeUINT16 out.Raw = uint64(uint16(rpm)) } func (i *IRacing) fuelLevel(out *telemetry.TelemetryField) { - fuelLevel := getVar(i.SDK.Vars.Vars, "FuelLevel", float32(-1.0)) + fuelLevel := getVar(i.SDK.Vars.Vars, "FuelLevel", float32(-1.0), i.logger) telemetry.FloatToStringTransform(fuelLevel, out) } @@ -79,17 +87,17 @@ func (i *IRacing) pitSpeedLimiter(out *telemetry.TelemetryField) { // EngineData ↓ func (i *IRacing) oilPress(out *telemetry.TelemetryField) { - oilPress := getVar(i.SDK.Vars.Vars, "OilPress", float32(-1.0)) + oilPress := getVar(i.SDK.Vars.Vars, "OilPress", float32(-1.0), i.logger) telemetry.FloatToStringTransform(oilPress, out) } func (i *IRacing) oilTemp(out *telemetry.TelemetryField) { - oilTemp := getVar(i.SDK.Vars.Vars, "OilTemp", float32(-1.0)) + oilTemp := getVar(i.SDK.Vars.Vars, "OilTemp", float32(-1.0), i.logger) telemetry.FloatToStringTransform(oilTemp, out) } func (i *IRacing) waterTemp(out *telemetry.TelemetryField) { - waterTemp := getVar(i.SDK.Vars.Vars, "WaterTemp", float32(-1.0)) + waterTemp := getVar(i.SDK.Vars.Vars, "WaterTemp", float32(-1.0), i.logger) telemetry.FloatToStringTransform(waterTemp, out) } @@ -97,22 +105,22 @@ func (i *IRacing) waterTemp(out *telemetry.TelemetryField) { // Adjustments ↓ func (i *IRacing) brakeBias(out *telemetry.TelemetryField) { - bb := getVar(i.SDK.Vars.Vars, "dcBrakeBias", float32(-1.0)) + bb := getVar(i.SDK.Vars.Vars, "dcBrakeBias", float32(-1.0), i.logger) telemetry.FloatToStringTransform(bb, out) } func (i *IRacing) absSetting(out *telemetry.TelemetryField) { - abs := getVar(i.SDK.Vars.Vars, "dcABS", float32(-1.0)) + abs := getVar(i.SDK.Vars.Vars, "dcABS", float32(-1.0), i.logger) telemetry.FloatToUInt8Transform(abs, out) } func (i *IRacing) tcSetting(out *telemetry.TelemetryField) { - tc := getVar(i.SDK.Vars.Vars, "dcTractionControl", float32(-1.0)) + tc := getVar(i.SDK.Vars.Vars, "dcTractionControl", float32(-1.0), i.logger) telemetry.FloatToUInt8Transform(tc, out) } func (i *IRacing) throttleSetting(out *telemetry.TelemetryField) { - throttle := getVar(i.SDK.Vars.Vars, "dcThrottleShape", float32(-1.0)) + throttle := getVar(i.SDK.Vars.Vars, "dcThrottleShape", float32(-1.0), i.logger) telemetry.FloatToUInt8Transform(throttle, out) } @@ -120,7 +128,7 @@ func (i *IRacing) throttleSetting(out *telemetry.TelemetryField) { // Laps ↓ func (i *IRacing) lapTime(out *telemetry.TelemetryField) { - lapTimeInSeconds := getVar(i.SDK.Vars.Vars, "LapLastLapTime", float32(0)) + lapTimeInSeconds := getVar(i.SDK.Vars.Vars, "LapLastLapTime", float32(0), i.logger) if lapTimeInSeconds < 0 { lapTimeInSeconds = 0 @@ -134,7 +142,7 @@ func (i *IRacing) lapTime(out *telemetry.TelemetryField) { } func (i *IRacing) lapNumber(out *telemetry.TelemetryField) { - lapNumber := getVar(i.SDK.Vars.Vars, "Lap", int(0)) + lapNumber := getVar(i.SDK.Vars.Vars, "Lap", int(0), i.logger) telemetry.UInt8Transform(lapNumber, out) } From 1b9a5173b68622c50cd5a5057446523ff367b45c Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Sat, 12 Sep 2026 15:35:01 +0100 Subject: [PATCH 07/41] Updated the function that checks for the sim running and how we stream data --- providers/iracing/iracing.go | 27 ++++++++++++----------- providers/iracing/utils.go | 42 +++++++++++++++++------------------- 2 files changed, 35 insertions(+), 34 deletions(-) diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index 65b5c01..268cd6a 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -126,6 +126,10 @@ func (i *IRacing) stream(ctx context.Context) { i.data.InitialTime = time.Now() go func() { + // Put this into the configuration file + consecutiveTimeouts := 0 + maxTimeouts := 30 + dataEvTimeout := 100 for { // Explicitly intercept cancellation select { @@ -134,17 +138,8 @@ func (i *IRacing) stream(ctx context.Context) { default: } - // TODO: fix this logic - // We start by checking if we do or do not have data available - // if !i.isDataAvailable() { - // i.logger.Info("isDataAvailable check failed. Cancelling stream...") - // i.streamCancel() - // } - - select { - case <-ctx.Done(): - return - case <-i.ticker.C: + if i.SDK.CheckForDataEvent(time.Duration(dataEvTimeout) * time.Millisecond) { + consecutiveTimeouts = 0 i.readData() // Publish data @@ -153,6 +148,15 @@ func (i *IRacing) stream(ctx context.Context) { default: // skip this data, don't allow publishers to lag behind } + } else { + consecutiveTimeouts++ + if consecutiveTimeouts >= maxTimeouts { + i.logger.Info("Telemetry stream stalled") + if i.streamCancel != nil { + i.streamCancel() + } + return + } } } }() @@ -175,7 +179,6 @@ func (i *IRacing) readData() { } // Set up virtual binds - i.logger.Debug("Entering virtual binds loop") for _, vBind := range i.data.VirtualBinds { vBind.Process(i.data) } diff --git a/providers/iracing/utils.go b/providers/iracing/utils.go index ac9d2df..268bd6a 100644 --- a/providers/iracing/utils.go +++ b/providers/iracing/utils.go @@ -1,35 +1,33 @@ package iracing import ( + "log" + "log/slog" + "time" + "github.com/ESilva15/goirsdk" + eventutils "github.com/ESilva15/goirsdk/eventutils" ) func IsRunning() bool { - sdk, err := goirsdk.Init(goirsdk.Options{ - SourceType: goirsdk.SharedMemoryFile, - }) - defer sdk.Close() + irUtils, err := eventutils.Init() if err != nil { - return false + log.Fatalf("Failed to initialize mmaputils: %v", err) + } + defer irUtils.Close() + + // 2. Connect to the OS event (Win32 Event on Windows, POSIX Semaphore on Linux) + if err := irUtils.OpenEvent(goirsdk.IRSDK_DATAVALIDEVENTNAME); err != nil { + log.Fatalf("Failed to open event: %v", err) } - // if sdk.SessionStateInvalid() { - // slog.Debug("state is invalid") - // sessionState, ok := sdk.Vars.Vars["SessionState"] - // if !ok { - // slog.Debug("SessionState not ok") - // return false - // } - // - // state, ok := sessionState.Value.(int) - // if !ok { - // slog.Debug(fmt.Sprintf("can't typecast: %+v", sessionState)) - // return false - // } - // - // slog.Debug(fmt.Sprintf("%d", state)) - // return false - // } + // We now check for some consecutive data events + for range 3 { + if !irUtils.CheckValidDataEvent(1 * time.Second) { + slog.Debug("timed out waiting for DataValidEvent") + return false + } + } return true } From d6362eeeb57109bf9defc243230e152f1f3815b4 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Sat, 12 Sep 2026 18:26:58 +0100 Subject: [PATCH 08/41] remove the fatals from here, but I do need to do error handling there --- providers/iracing/utils.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/providers/iracing/utils.go b/providers/iracing/utils.go index 268bd6a..c8b0de8 100644 --- a/providers/iracing/utils.go +++ b/providers/iracing/utils.go @@ -1,7 +1,6 @@ package iracing import ( - "log" "log/slog" "time" @@ -12,13 +11,14 @@ import ( func IsRunning() bool { irUtils, err := eventutils.Init() if err != nil { - log.Fatalf("Failed to initialize mmaputils: %v", err) + // we need error validation or something here + return false } defer irUtils.Close() - // 2. Connect to the OS event (Win32 Event on Windows, POSIX Semaphore on Linux) if err := irUtils.OpenEvent(goirsdk.IRSDK_DATAVALIDEVENTNAME); err != nil { - log.Fatalf("Failed to open event: %v", err) + // we need error validation or something here + return false } // We now check for some consecutive data events From c1366b010f9281a5eb516c62609c513bb1f2d3aa Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Sat, 12 Sep 2026 18:27:09 +0100 Subject: [PATCH 09/41] remove this very verbose log --- devices/cdashdisplay/display.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/devices/cdashdisplay/display.go b/devices/cdashdisplay/display.go index 433db99..763a926 100644 --- a/devices/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -19,6 +19,7 @@ import ( "gopkg.in/yaml.v3" ) +// TODO: remove this logger. It should be on the device struct var pLogger *slog.Logger func SetLogger(l *slog.Logger) { @@ -377,7 +378,7 @@ func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) { curStr += fmt.Sprintf("%02x ", byte) if byteCount == 8 { - pLogger.Debug(curStr) + // pLogger.Debug(curStr) curStr = "" byteCount = 0 } From dbd4086bf96ba85833302ce1c21a2d14cdc5e901 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Sat, 12 Sep 2026 23:28:15 +0100 Subject: [PATCH 10/41] Provider loop discovery almost finished Provider lookup will lookup on startup, do the healthcheck until the stream starts and also restart on stream closure or provider stall --- Docs/Provider_Discovery.md | 31 +++++++++++++++++++ providers/beamng/beamng.go | 7 +++++ providers/beamng/utils.go | 6 ---- providers/iracing/iracing.go | 18 +++++++++++ providers/iracing/utils.go | 4 --- services/telemetry.go | 60 +++++++++++++++++++++++++++++++----- telemetry/provider.go | 5 ++- tui/tui.go | 2 +- 8 files changed, 114 insertions(+), 19 deletions(-) create mode 100644 Docs/Provider_Discovery.md diff --git a/Docs/Provider_Discovery.md b/Docs/Provider_Discovery.md new file mode 100644 index 0000000..d107f7c --- /dev/null +++ b/Docs/Provider_Discovery.md @@ -0,0 +1,31 @@ +# Provider Discovery +``` +NewControlPanel() + ↓ +go telemService.FindProvider() - has a callback for onFind + | + |iterates over the known providers + | + onFind + ↓ +telemService.SwitchProvider() - activates the found provider + | + |-→ Create a background job while the stream hasn't initiated to listened + | for data, otherwise the connection might die before we start streaming + | ↓ + | go telemService.ProviderMonitor() + ↓ | | + /-→waits--\ if the provider stops we this healthcheck is stopped + \_________/ we clear the provider and once the stream starts + go back to the + ↓ + FindProvider() +``` +The provider discovery routine starts on `tui/tui.go`. +`FindProvider` is called here and it starts a background job. +On successful discovery the background job calls the `SwitchProvider` method +and dies. + +## Provider stalls +A provider stalls once there is no new data. +After stalling diff --git a/providers/beamng/beamng.go b/providers/beamng/beamng.go index d653073..3a7b769 100644 --- a/providers/beamng/beamng.go +++ b/providers/beamng/beamng.go @@ -79,6 +79,13 @@ func NewBeamNGProvider(ip string, port int) (*BeamNG, error) { return provider, nil } +func (b *BeamNG) Close() { +} + +func (b *BeamNG) IsAlive(timeout time.Duration) bool { + return true +} + func (b *BeamNG) StopStream() { if b.streamCancel == nil { return diff --git a/providers/beamng/utils.go b/providers/beamng/utils.go index 98eb459..2854b74 100644 --- a/providers/beamng/utils.go +++ b/providers/beamng/utils.go @@ -31,9 +31,3 @@ func IsRunning() bool { // Think of a better number or something return n >= 80 } - -// Stalled -// TODO: needs to be implemented -func (i *BeamNG) Stalled() bool { - return false -} diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index 268cd6a..333364a 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -108,6 +108,13 @@ func NewIRacingProvider( return provider, nil } +func (i *IRacing) Close() { + // Need to find a way of gracefully closing the channel + // close(i.streamCh) + i.SDK.Close() + i.ticker.Stop() +} + func (i *IRacing) isDataAvailable() bool { // Its offline telemetry, data must be available if i.SDK.File == nil { @@ -126,6 +133,8 @@ func (i *IRacing) stream(ctx context.Context) { i.data.InitialTime = time.Now() go func() { + defer close(i.streamCh) + // Put this into the configuration file consecutiveTimeouts := 0 maxTimeouts := 30 @@ -140,6 +149,7 @@ func (i *IRacing) stream(ctx context.Context) { if i.SDK.CheckForDataEvent(time.Duration(dataEvTimeout) * time.Millisecond) { consecutiveTimeouts = 0 + i.logger.Debug("sending data", "timeouts", consecutiveTimeouts) i.readData() // Publish data @@ -253,3 +263,11 @@ func (i *IRacing) Subscribe(requestFields map[int16]telemetry.FieldID) { i.logger.Debug(fmt.Sprintf("Subscribed: %+v\n", i.data.ActiveBinds)) } + +func (i *IRacing) IsAlive(timeout time.Duration) bool { + if !i.SDK.CheckForDataEvent(timeout) { + return false + } + + return true +} diff --git a/providers/iracing/utils.go b/providers/iracing/utils.go index c8b0de8..b524a80 100644 --- a/providers/iracing/utils.go +++ b/providers/iracing/utils.go @@ -31,7 +31,3 @@ func IsRunning() bool { return true } - -func (i *IRacing) Stalled() bool { - return i.Stalled() -} diff --git a/services/telemetry.go b/services/telemetry.go index f9f8566..c6c44c7 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -25,8 +25,10 @@ type TelemetryService struct { // Output window Messages chan string // Cancel looking for providers - CtxMonitor context.Context - cancelMonitor context.CancelFunc + CtxMonitor context.Context + cancelMonitor context.CancelFunc + CtxHealthcheck context.Context + healthCheckCancel context.CancelFunc } func NewTelemetryService(logger *slog.Logger, devServo *DeviceService) *TelemetryService { @@ -43,15 +45,51 @@ func NewTelemetryService(logger *slog.Logger, devServo *DeviceService) *Telemetr return newService } -func (t *TelemetryService) OnFindProvider(prov providers.Provider) { +func (t *TelemetryService) ProviderMonitor(ctx context.Context) { + ticker := time.NewTicker(2 * time.Second) + defer ticker.Stop() + + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + slog.Debug("checking if provider is still running") + if !t.activeProvider.IsAlive(500 * time.Millisecond) { + slog.Debug("provider healthcheck failed") + t.dropActiveProvider() + t.onProviderHealthCheckFailed() + return + } + } + } +} + +func (t *TelemetryService) onProviderHealthCheckFailed() { + // Just restart the whole lookup process + go t.FindProvider(t.CtxMonitor) +} + +func (t *TelemetryService) onFindProvider(prov providers.Provider) { + // Attach to the provider + t.logger.Info("found provider for " + prov.Name) t.SwitchProvider(prov.NewProvider(t.logger)) - t.logger.Debug("Found provider for " + prov.Name) + + // Create a routine to poll this provider while we wait to start the stream or pause it + t.CtxHealthcheck, t.healthCheckCancel = context.WithCancel(context.Background()) + go t.ProviderMonitor(t.CtxHealthcheck) +} + +func (t *TelemetryService) onProviderStopsMidStream() { + // clear the current provider + t.logger.Info("cleaning dropped provider and restarting lookup service") + t.dropActiveProvider() + go t.FindProvider(t.CtxMonitor) } // TODO: add some way of retriggering this. Currently it should: // start monitoring on startup -> find provider -> stop monitoring (when game closes for example) -func (t *TelemetryService) FindProvider(ctx context.Context, callback func(providers.Provider), -) { +func (t *TelemetryService) FindProvider(ctx context.Context) { ticker := time.NewTicker(2 * time.Second) defer ticker.Stop() @@ -64,7 +102,7 @@ func (t *TelemetryService) FindProvider(ctx context.Context, callback func(provi for _, prov := range providers.Providers { t.logger.Debug("checking provider: " + prov.Name) if prov.IsRunning() { - callback(prov) + t.onFindProvider(prov) return } t.logger.Debug(" wasn't read") @@ -95,6 +133,8 @@ func (t *TelemetryService) multiplexData(ctx context.Context, dataCh <-chan tele return case data, ok := <-dataCh: if !ok { + t.logger.Debug("something happened on the provider - stream closed") + t.onProviderStopsMidStream() return } @@ -118,6 +158,8 @@ func (t *TelemetryService) dropActiveProvider() { } t.activeProvider.StopStream() + t.activeProvider.Close() + t.activeProvider = nil } func (t *TelemetryService) SubscribeListener(id string, bufferSize int) <-chan telem.TelemetryData { @@ -160,6 +202,10 @@ func (t *TelemetryService) StartStream() { slog.Debug("there's no active provider. not starting the stream") return } + + // Stop the provider healthcheck + t.healthCheckCancel() + simInCh, _ := t.activeProvider.Stream() // TODO: the provider needs to be able to tell the data has stopped // so we can restart the provider lookup routine diff --git a/telemetry/provider.go b/telemetry/provider.go index ff3faca..e2cfeb5 100644 --- a/telemetry/provider.go +++ b/telemetry/provider.go @@ -1,9 +1,12 @@ // Package telemetry is our interface with our data sources package telemetry +import "time" + type TelemetryProvider interface { StopStream() Stream() (<-chan TelemetryData, error) Subscribe(map[int16]FieldID) - Stalled() bool // Return true if no fresh data is coming + IsAlive(time.Duration) bool + Close() } diff --git a/tui/tui.go b/tui/tui.go index 68feb50..374d21e 100644 --- a/tui/tui.go +++ b/tui/tui.go @@ -31,7 +31,7 @@ func NewControlPanel(logger *slog.Logger) *ControlPanel { panic("failed to create the telemetry service") } - go telemService.FindProvider(telemService.CtxMonitor, telemService.OnFindProvider) + go telemService.FindProvider(telemService.CtxMonitor) return &ControlPanel{ Controller: baseController, From 59fa825da16fefa484e0ef15d23d4ff38cdb09b3 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Sun, 13 Sep 2026 22:53:51 +0100 Subject: [PATCH 11/41] removing some unecessary logs --- providers/iracing/utils.go | 3 +-- services/telemetry.go | 3 ++- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/providers/iracing/utils.go b/providers/iracing/utils.go index b524a80..7c6b756 100644 --- a/providers/iracing/utils.go +++ b/providers/iracing/utils.go @@ -1,7 +1,6 @@ package iracing import ( - "log/slog" "time" "github.com/ESilva15/goirsdk" @@ -24,7 +23,7 @@ func IsRunning() bool { // We now check for some consecutive data events for range 3 { if !irUtils.CheckValidDataEvent(1 * time.Second) { - slog.Debug("timed out waiting for DataValidEvent") + // slog.Debug("Timed out waiting for DataValidEvent") return false } } diff --git a/services/telemetry.go b/services/telemetry.go index c6c44c7..51ec1f2 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -82,6 +82,8 @@ func (t *TelemetryService) onFindProvider(prov providers.Provider) { func (t *TelemetryService) onProviderStopsMidStream() { // clear the current provider + // TODO: now we need to also clear the devices to restart everything, + // if the stream stopped we have to restart the devices and everything t.logger.Info("cleaning dropped provider and restarting lookup service") t.dropActiveProvider() go t.FindProvider(t.CtxMonitor) @@ -105,7 +107,6 @@ func (t *TelemetryService) FindProvider(ctx context.Context) { t.onFindProvider(prov) return } - t.logger.Debug(" wasn't read") } } } From 15b997c22fcf6bbcb4a60bc48af2d9abaf9e11e7 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Sun, 13 Sep 2026 23:05:55 +0100 Subject: [PATCH 12/41] fixed some little UI bugs - We could open the CDashDisplay specific layout before it existed - Crash! - We could open the stream UI before there was a provider- Crash! --- services/devices.go | 8 ++++++++ services/telemetry.go | 8 ++++++++ tui/internal/controllers/device.go | 13 +++++++++++++ 3 files changed, 29 insertions(+) diff --git a/services/devices.go b/services/devices.go index d48870f..9716930 100644 --- a/services/devices.go +++ b/services/devices.go @@ -71,6 +71,14 @@ func (ds *DeviceService) GetDevice(name string) (devices.Device, error) { return val, nil } +func (ds *DeviceService) DeviceExists(name string) bool { + if _, ok := ds.Devices[name]; !ok { + return false + } + + return true +} + func (ds *DeviceService) StartStream() { // NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this var ctx context.Context diff --git a/services/telemetry.go b/services/telemetry.go index 51ec1f2..f35ae24 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -230,3 +230,11 @@ func (t *TelemetryService) StopStream() { t.activeProvider.StopStream() } + +func (t *TelemetryService) HasActiveProvider() bool { + if t.activeProvider == nil { + return false + } + + return true +} diff --git a/tui/internal/controllers/device.go b/tui/internal/controllers/device.go index c0f7648..be1fa58 100644 --- a/tui/internal/controllers/device.go +++ b/tui/internal/controllers/device.go @@ -4,6 +4,7 @@ package controllers import ( "fmt" + "esdi/devices/cdashdisplay" serv "esdi/services" "esdi/tui/internal/views" @@ -65,6 +66,12 @@ func (mc *DeviceController) setDeviceAPIViewEvents() { func (mc *DeviceController) AddDeviceAPIListItems() { mc.DeviceAPIView.DevAPIList. AddItem("layout", "build a layout for CDashDisplay", func() { + // This CDashDisplay specific, only load if we have a CDashDisplay + if !mc.DevService.DeviceExists(cdashdisplay.Name) { + mc.DevService.Messages <- "CDashDisplay it not loaded yet\n" + return + } + // Get the api pages views.AddAndShowPage( mc.DeviceAPIView.DevAPIToolView.Pages, @@ -75,6 +82,12 @@ func (mc *DeviceController) AddDeviceAPIListItems() { }) mc.DeviceAPIView.DevAPIList. AddItem("stream", "stream data to the display", func() { + // If we don't have a CDashDisplay or data source, this should be blocked + if !mc.StreamCtrl.TelemServ.HasActiveProvider() { + mc.StreamCtrl.Messages <- "no active provider present\n" + return + } + views.AddAndShowPage( mc.DeviceAPIView.DevAPIToolView.Pages, "streaming-tool", From ffc03e9e494c384a082ea606319ef08c5fb4b8aa Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Wed, 16 Sep 2026 19:02:20 +0100 Subject: [PATCH 13/41] added the IsAlive check for beamng --- providers/beamng/beamng.go | 20 +++++++++++++++----- providers/beamng/utils.go | 4 ++-- providers/providers.go | 4 ++-- 3 files changed, 19 insertions(+), 9 deletions(-) diff --git a/providers/beamng/beamng.go b/providers/beamng/beamng.go index 3a7b769..2bd2f4d 100644 --- a/providers/beamng/beamng.go +++ b/providers/beamng/beamng.go @@ -17,6 +17,8 @@ import ( // for BeamNG.drive // NOTE: document this please. What is a TelemetryData???? type BeamNG struct { + logger *slog.Logger + SDK *bngsdk.BeamNGSDK // data handling @@ -36,16 +38,22 @@ const ( NAME = "BeamNG.drive" ) -func NewBeamNGProvider(ip string, port int) (*BeamNG, error) { - beam, err := bngsdk.Init(ip, port) +func NewBeamNGProvider(ip string, port int, newLogger *slog.Logger) (*BeamNG, error) { + beam, err := bngsdk.NewBngSDK(bngsdk.Options{ + Logger: newLogger.With("TelemetrySDK", "BeamNG"), + SourceType: bngsdk.UDPData, + ImportUDPAddress: "127.0.0.1", + ImportUDPPort: 4444, + }) if err != nil { return &BeamNG{}, err } provider := &BeamNG{ + logger: newLogger.With("TelemetryProvider", "BeamNG"), streamCh: make(chan telemetry.TelemetryData, 1), data: telemetry.NewTelemetryData(), - SDK: &beam, + SDK: beam, ticker: time.NewTicker(time.Second / 60), } @@ -80,10 +88,12 @@ func NewBeamNGProvider(ip string, port int) (*BeamNG, error) { } func (b *BeamNG) Close() { + b.SDK.Close() } func (b *BeamNG) IsAlive(timeout time.Duration) bool { - return true + _, err := b.SDK.Update() + return err == nil } func (b *BeamNG) StopStream() { @@ -154,7 +164,7 @@ func (b *BeamNG) Subscribe(requestFields map[int16]telemetry.FieldID) { func (b *BeamNG) readData() { slog.Debug("READING THIS DATA") // BUG: getting stuck in here - err := b.SDK.ReadData() + _, err := b.SDK.Update() slog.Debug("THE DATA WAS READ") if err != nil { slog.Error("Error getting data", "error", err) diff --git a/providers/beamng/utils.go b/providers/beamng/utils.go index 2854b74..8918c7c 100644 --- a/providers/beamng/utils.go +++ b/providers/beamng/utils.go @@ -7,8 +7,8 @@ import ( ) func IsRunning() bool { - // The address should be loaded from some type of configuration - addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:4443") + // TODO: The address should be loaded from some type of configuration + addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:4444") if err != nil { return false } diff --git a/providers/providers.go b/providers/providers.go index f38c1b1..a4dc180 100644 --- a/providers/providers.go +++ b/providers/providers.go @@ -42,8 +42,8 @@ func NewLiveIRacingProvider(logger *slog.Logger) telemetry.TelemetryProvider { } func NewBeamNGProvider(logger *slog.Logger) telemetry.TelemetryProvider { - // Get from some kind of config or whatever - provider, _ := beamng.NewBeamNGProvider("127.0.0.1", 4443) + // TODO: Get from some kind of config or whatever + provider, _ := beamng.NewBeamNGProvider("127.0.0.1", 4444, logger) return provider } From 1321977f181de2463ae3001b1ff98809d8ba6745 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Thu, 17 Sep 2026 11:33:10 +0100 Subject: [PATCH 14/41] updated beamng provider for the new SDK --- providers/beamng/beamng.go | 16 +++++++--------- providers/beamng/transforms.go | 26 +++++++++++++------------- providers/providers.go | 10 ++++++++-- 3 files changed, 28 insertions(+), 24 deletions(-) diff --git a/providers/beamng/beamng.go b/providers/beamng/beamng.go index 2bd2f4d..58e245c 100644 --- a/providers/beamng/beamng.go +++ b/providers/beamng/beamng.go @@ -20,6 +20,7 @@ type BeamNG struct { logger *slog.Logger SDK *bngsdk.BeamNGSDK + og *bngsdk.Outgauge // data handling mut sync.Mutex @@ -38,22 +39,18 @@ const ( NAME = "BeamNG.drive" ) -func NewBeamNGProvider(ip string, port int, newLogger *slog.Logger) (*BeamNG, error) { - beam, err := bngsdk.NewBngSDK(bngsdk.Options{ - Logger: newLogger.With("TelemetrySDK", "BeamNG"), - SourceType: bngsdk.UDPData, - ImportUDPAddress: "127.0.0.1", - ImportUDPPort: 4444, - }) +func NewBeamNGProvider(logger *slog.Logger, opts *bngsdk.Options) (*BeamNG, error) { + beam, err := bngsdk.NewBngSDK(*opts) if err != nil { return &BeamNG{}, err } provider := &BeamNG{ - logger: newLogger.With("TelemetryProvider", "BeamNG"), + logger: logger.With("TelemetryProvider", NAME), streamCh: make(chan telemetry.TelemetryData, 1), data: telemetry.NewTelemetryData(), SDK: beam, + og: &bngsdk.Outgauge{}, ticker: time.NewTicker(time.Second / 60), } @@ -164,7 +161,7 @@ func (b *BeamNG) Subscribe(requestFields map[int16]telemetry.FieldID) { func (b *BeamNG) readData() { slog.Debug("READING THIS DATA") // BUG: getting stuck in here - _, err := b.SDK.Update() + ogSnapshot, err := b.SDK.Update() slog.Debug("THE DATA WAS READ") if err != nil { slog.Error("Error getting data", "error", err) @@ -172,6 +169,7 @@ func (b *BeamNG) readData() { } b.mut.Lock() + b.og = ogSnapshot defer b.mut.Unlock() // Read 1 to 1 data diff --git a/providers/beamng/transforms.go b/providers/beamng/transforms.go index ee751b8..e56fba1 100644 --- a/providers/beamng/transforms.go +++ b/providers/beamng/transforms.go @@ -18,34 +18,34 @@ func (b *BeamNG) unused(out *telemetry.TelemetryField) { func (b *BeamNG) updateSpeed(out *telemetry.TelemetryField) { out.Type = telemetry.DataTypeUINT16 - out.Raw = uint64(conv.MsToKph(b.SDK.Data.Speed)) + out.Raw = uint64(conv.MsToKph(b.og.Speed)) } func (b *BeamNG) updateGear(out *telemetry.TelemetryField) { out.Type = telemetry.DataTypeSTRING // NOTE: stupid idea but we can cache these values - out.Str = strconv.Itoa(int(b.SDK.Data.Gear)) + out.Str = strconv.Itoa(int(b.og.Gear)) } func (b *BeamNG) updateRPM(out *telemetry.TelemetryField) { out.Type = telemetry.DataTypeUINT16 - out.Raw = uint64(uint16(b.SDK.Data.RPM)) + out.Raw = uint64(uint16(b.og.RPM)) } func (b *BeamNG) fuelLevel(out *telemetry.TelemetryField) { - telemetry.FloatToStringTransform(b.SDK.Data.Fuel, out) + telemetry.FloatToStringTransform(b.og.Fuel, out) } func (b *BeamNG) oilPressure(out *telemetry.TelemetryField) { - telemetry.FloatToStringTransform(b.SDK.Data.OilPressure, out) + telemetry.FloatToStringTransform(b.og.OilPressure, out) } func (b *BeamNG) oilTemp(out *telemetry.TelemetryField) { - telemetry.FloatToStringTransform(b.SDK.Data.OilTemp, out) + telemetry.FloatToStringTransform(b.og.OilTemp, out) } func (b *BeamNG) engTemp(out *telemetry.TelemetryField) { - telemetry.FloatToStringTransform(b.SDK.Data.EngTemp, out) + telemetry.FloatToStringTransform(b.og.EngTemp, out) } // NOTE: find how to empty this @@ -54,7 +54,7 @@ func (b *BeamNG) pitSpeedLimiter(out *telemetry.TelemetryField) { func (b *BeamNG) leftIndicator(out *telemetry.TelemetryField) { chr := ' ' - if b.SDK.LeftIndicator() { + if b.og.LeftIndicator() { chr = '<' } @@ -64,7 +64,7 @@ func (b *BeamNG) leftIndicator(out *telemetry.TelemetryField) { func (b *BeamNG) rightIndicator(out *telemetry.TelemetryField) { chr := ' ' - if b.SDK.RightIndicator() { + if b.og.RightIndicator() { chr = '>' } @@ -74,7 +74,7 @@ func (b *BeamNG) rightIndicator(out *telemetry.TelemetryField) { func (b *BeamNG) absLight(out *telemetry.TelemetryField) { chr := ' ' - if b.SDK.ABS() { + if b.og.ABS() { chr = 'A' } @@ -84,7 +84,7 @@ func (b *BeamNG) absLight(out *telemetry.TelemetryField) { func (b *BeamNG) handbrakeLight(out *telemetry.TelemetryField) { chr := ' ' - if b.SDK.Handbrake() { + if b.og.Handbrake() { chr = 'P' } @@ -94,7 +94,7 @@ func (b *BeamNG) handbrakeLight(out *telemetry.TelemetryField) { func (b *BeamNG) tcLight(out *telemetry.TelemetryField) { chr := ' ' - if b.SDK.TractionControl() { + if b.og.TractionControl() { chr = 'T' } @@ -104,7 +104,7 @@ func (b *BeamNG) tcLight(out *telemetry.TelemetryField) { func (b *BeamNG) batteryLight(out *telemetry.TelemetryField) { chr := ' ' - if b.SDK.BatteryLight() { + if b.og.BatteryLight() { chr = 'B' } diff --git a/providers/providers.go b/providers/providers.go index a4dc180..00f0f08 100644 --- a/providers/providers.go +++ b/providers/providers.go @@ -8,6 +8,7 @@ import ( "esdi/providers/iracing" "esdi/telemetry" + bngsdk "github.com/ESilva15/gobngsdk" "github.com/ESilva15/goirsdk" ) @@ -42,8 +43,13 @@ func NewLiveIRacingProvider(logger *slog.Logger) telemetry.TelemetryProvider { } func NewBeamNGProvider(logger *slog.Logger) telemetry.TelemetryProvider { - // TODO: Get from some kind of config or whatever - provider, _ := beamng.NewBeamNGProvider("127.0.0.1", 4444, logger) + // TODO: these should come from some kind of config + provider, _ := beamng.NewBeamNGProvider(logger, &bngsdk.Options{ + Logger: logger.With("TelemetryProvider", beamng.NAME), + SourceType: bngsdk.UDPData, + ImportUDPAddress: "127.0.0.1", + ImportUDPPort: 4444, + }) return provider } From a6ab64117c5c29b7410afa72fc7266844aa96566 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Thu, 17 Sep 2026 22:55:17 +0100 Subject: [PATCH 15/41] this is a doozy - device auto discovery and handling The main goal was to decouple more things We got devices being looked for in the background and the stream view is like a device now too --- Docs/Peripheral_Discovery.md | 1 + devices/cdashdisplay/info.go | 22 ++++- devices/device.go | 61 +++++++++++- devices/uidevice/device.go | 53 +++++++++++ peripheral/peripheral.go | 10 +- providers/beamng/beamng.go | 4 + providers/iracing/iracing.go | 4 + providers/providers.go | 22 +++-- services/devices.go | 94 ++++++++++++++----- services/telemetry.go | 37 ++++++-- telemetry/data.go | 2 +- telemetry/provider.go | 1 + .../controllers/cdashdisplay_layout.go | 42 ++++----- .../cdashdisplay_layout_moveTool.go | 12 +-- tui/internal/controllers/device.go | 2 +- tui/internal/controllers/streaming.go | 69 +++++++------- tui/tui.go | 2 +- 17 files changed, 327 insertions(+), 111 deletions(-) create mode 100644 Docs/Peripheral_Discovery.md create mode 100644 devices/uidevice/device.go diff --git a/Docs/Peripheral_Discovery.md b/Docs/Peripheral_Discovery.md new file mode 100644 index 0000000..e3d041b --- /dev/null +++ b/Docs/Peripheral_Discovery.md @@ -0,0 +1 @@ +# Peripheral Discovery diff --git a/devices/cdashdisplay/info.go b/devices/cdashdisplay/info.go index ecd930a..14cbbe4 100644 --- a/devices/cdashdisplay/info.go +++ b/devices/cdashdisplay/info.go @@ -1,9 +1,27 @@ package cdashdisplay -import "esdi/peripheral/devices" +import ( + "esdi/peripheral/devices" + "esdi/telemetry" +) // TODO: I believe we don't need the #esdi/peripheral/devices thing anymore const ( ID = devices.CDashDisplayDevID - Name = devices.CDashDisplayDevName + NAME = devices.CDashDisplayDevName ) + +func (cds *CDashDisplay) Name() string { + return NAME +} + +func (cds *CDashDisplay) RequiredFields() map[int16]telemetry.FieldID { + fields := make(map[int16]telemetry.FieldID, len(cds.State.Layout.Windows)) + + for _, w := range cds.State.Layout.Windows { + fieldID, _ := telemetry.GetFieldID(w.UIData.TelemetryField) + fields[w.UIData.IDX] = fieldID + } + + return fields +} diff --git a/devices/device.go b/devices/device.go index c7baab1..6c85b4f 100644 --- a/devices/device.go +++ b/devices/device.go @@ -1,9 +1,60 @@ -// Package devices simply defines what a device should have -// and some utils if necessary +// Package devices is a peripheral factory package devices -import "esdi/telemetry" +import ( + "errors" -type Device interface { - SendData(*telemetry.TelemetryData) + "esdi/devices/cdashdisplay" + "esdi/devices/uidevice" + "esdi/peripheral" +) + +type Device struct { + Name string + Discover func() (peripheral.Peripheral, error) +} + +var List map[string]Device = map[string]Device{ + uidevice.NAME: { + Name: uidevice.NAME, + Discover: DiscoverUIDevice, + }, + cdashdisplay.NAME: { + Name: cdashdisplay.NAME, + Discover: DiscoverCDashDisplay, + }, +} + +func DiscoverUIDevice() (peripheral.Peripheral, error) { + uidev, err := uidevice.NewUIDevice() + if err != nil { + return nil, err + } + + return uidev, nil +} + +func DiscoverCDashDisplay() (peripheral.Peripheral, error) { + // // Find CDashDisplay + // { + // ds.Messages <- "looking for " + cdashdisplay.Name + "...\n" + // ds.Logger.Info("Looking for " + cdashdisplay.Name) + // + // cdashdisplay.SetLogger(ds.Logger.With("[device]", cdashdisplay.Name)) + // + // // Create a cdashdisplay + // display, err := cdashdisplay.Discover() + // if err == nil { + // ds.Devices[cdashdisplay.Name] = display + // ds.Logger.Info("found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name) + // ds.Messages <- "found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name + "\n" + // return + // } + // + // ds.Logger.Info("didn't find " + cdashdisplay.Name) + // ds.Messages <- "didn't find " + cdashdisplay.Name + "\n" + // // No CDashDisplay available for one reason or another, so we don't set the + // // key + // } + return nil, errors.New("not implemented yet") } diff --git a/devices/uidevice/device.go b/devices/uidevice/device.go new file mode 100644 index 0000000..d228982 --- /dev/null +++ b/devices/uidevice/device.go @@ -0,0 +1,53 @@ +package uidevice + +import ( + "esdi/peripheral" + "esdi/telemetry" +) + +type UIDevice struct { + dataChan chan telemetry.TelemetryData +} + +const NAME = "UIView" + +func NewUIDevice() (peripheral.Peripheral, error) { + return &UIDevice{ + dataChan: make(chan telemetry.TelemetryData, 1), + }, nil +} + +func (uid *UIDevice) SendData(data *telemetry.TelemetryData) { + if data == nil { + return + } + + select { + case uid.dataChan <- *data: + default: + // Drop frame if buffer is full + } +} + +func (uid *UIDevice) Name() string { + return NAME +} + +func (uid *UIDevice) DataChannel() <-chan telemetry.TelemetryData { + return uid.dataChan +} + +func (uid *UIDevice) RequiredFields() map[int16]telemetry.FieldID { + subscribeTo := []telemetry.FieldID{ + telemetry.Speed, + telemetry.Gear, + telemetry.RPM, + } + + fields := make(map[int16]telemetry.FieldID, len(subscribeTo)) + for k, field := range subscribeTo { + fields[int16(k)] = field + } + + return fields +} diff --git a/peripheral/peripheral.go b/peripheral/peripheral.go index e9d6f25..bdb035d 100644 --- a/peripheral/peripheral.go +++ b/peripheral/peripheral.go @@ -2,9 +2,11 @@ package peripheral import ( - "esdi/peripheral/devices" "fmt" "path/filepath" + + "esdi/peripheral/devices" + "esdi/telemetry" ) type PeripheralType string @@ -13,6 +15,12 @@ const ( DisplayPeripheral PeripheralType = "display" ) +type Peripheral interface { + Name() string + SendData(*telemetry.TelemetryData) + RequiredFields() map[int16]telemetry.FieldID +} + type PeripheralDeviceClerk struct { // mu sync.RWMutex Devices map[uint8]*PeripheralDevice diff --git a/providers/beamng/beamng.go b/providers/beamng/beamng.go index 58e245c..70e90ed 100644 --- a/providers/beamng/beamng.go +++ b/providers/beamng/beamng.go @@ -88,6 +88,10 @@ func (b *BeamNG) Close() { b.SDK.Close() } +func (b *BeamNG) Name() string { + return NAME +} + func (b *BeamNG) IsAlive(timeout time.Duration) bool { _, err := b.SDK.Update() return err == nil diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index 333364a..2c57f6e 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -264,6 +264,10 @@ func (i *IRacing) Subscribe(requestFields map[int16]telemetry.FieldID) { i.logger.Debug(fmt.Sprintf("Subscribed: %+v\n", i.data.ActiveBinds)) } +func (i *IRacing) Name() string { + return NAME +} + func (i *IRacing) IsAlive(timeout time.Duration) bool { if !i.SDK.CheckForDataEvent(timeout) { return false diff --git a/providers/providers.go b/providers/providers.go index 00f0f08..a10e23d 100644 --- a/providers/providers.go +++ b/providers/providers.go @@ -16,7 +16,7 @@ import ( // the selected provider by its name type Provider struct { Name string - NewProvider func(*slog.Logger) telemetry.TelemetryProvider + NewProvider func(*slog.Logger) (telemetry.TelemetryProvider, error) IsRunning func() bool // To check if this provider is up and running } @@ -33,23 +33,31 @@ var Providers = map[string]Provider{ }, } -func NewLiveIRacingProvider(logger *slog.Logger) telemetry.TelemetryProvider { - provider, _ := iracing.NewIRacingProvider(logger, goirsdk.Options{ +func NewLiveIRacingProvider(logger *slog.Logger) (telemetry.TelemetryProvider, error) { + provider, err := iracing.NewIRacingProvider(logger, goirsdk.Options{ Logger: logger, SourceType: goirsdk.SharedMemoryFile, }) + if err != nil { + logger.Error("failed to create iRacing provider", "err", err) + return nil, err + } - return provider + return provider, nil } -func NewBeamNGProvider(logger *slog.Logger) telemetry.TelemetryProvider { +func NewBeamNGProvider(logger *slog.Logger) (telemetry.TelemetryProvider, error) { // TODO: these should come from some kind of config - provider, _ := beamng.NewBeamNGProvider(logger, &bngsdk.Options{ + provider, err := beamng.NewBeamNGProvider(logger, &bngsdk.Options{ Logger: logger.With("TelemetryProvider", beamng.NAME), SourceType: bngsdk.UDPData, ImportUDPAddress: "127.0.0.1", ImportUDPPort: 4444, }) + if err != nil { + logger.Error("failed to create BeamNG provider", "err", err) + return nil, err + } - return provider + return provider, nil } diff --git a/services/devices.go b/services/devices.go index 9716930..c1119ff 100644 --- a/services/devices.go +++ b/services/devices.go @@ -2,23 +2,32 @@ package services import ( "context" + "errors" "fmt" "log/slog" + "sync" "sync/atomic" + "time" "esdi/devices" - "esdi/devices/cdashdisplay" + "esdi/peripheral" "esdi/telemetry" ) +var ErrPeripheralAlreadyRegistered = errors.New("peripheral is already registered") + // DeviceService will handle sending the data from the telemetry service to the // actual devices // NOTE: create a virtual device and make it be the output window or something so // we can just add it as a device or whatever instead of being a custom made thing // that would be pretty cool I think type DeviceService struct { - Logger *slog.Logger - Devices map[string]devices.Device + Logger *slog.Logger + // Device discovery + mu sync.RWMutex + ctxDiscovery context.Context + ctxDiscoveryCancel context.CancelFunc + Devices map[string]peripheral.Peripheral // Strem handling streamCancel context.CancelFunc TelemCh <-chan telemetry.TelemetryData @@ -28,41 +37,75 @@ type DeviceService struct { func NewDeviceService(logger *slog.Logger) *DeviceService { sharedChannel := make(chan string, 10) - return &DeviceService{ - Devices: make(map[string]devices.Device), + + dev := &DeviceService{ + Devices: make(map[string]peripheral.Peripheral), Logger: logger, Messages: sharedChannel, } + + // Start the routine that looks for devices - should always be running in the background + // Create a routine to poll this provider while we wait to start the stream or pause it + dev.ctxDiscovery, dev.ctxDiscoveryCancel = context.WithCancel(context.Background()) + go dev.FindDevices() + + return dev } func (ds *DeviceService) FindDevices() { // Need to define a list of devices to search for // For now lets just try to find our cdashdisplay - will think about the rest later + ticker := time.NewTicker(2 * time.Second) + defer ticker.Stop() - // Find CDashDisplay - { - ds.Messages <- "looking for " + cdashdisplay.Name + "...\n" - ds.Logger.Info("Looking for " + cdashdisplay.Name) - - cdashdisplay.SetLogger(ds.Logger.With("[device]", cdashdisplay.Name)) - - // Create a cdashdisplay - display, err := cdashdisplay.Discover() - if err == nil { - ds.Devices[cdashdisplay.Name] = display - ds.Logger.Info("found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name) - ds.Messages <- "found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name + "\n" + for { + select { + case <-ds.ctxDiscovery.Done(): + // If requested to cancel we cancel background discovery return - } + case <-ticker.C: + for pName, peripheral := range devices.List { + if ds.DeviceExists(pName) { + // We already discovered this device + continue + } - ds.Logger.Info("didn't find " + cdashdisplay.Name) - ds.Messages <- "didn't find " + cdashdisplay.Name + "\n" - // No CDashDisplay available for one reason or another, so we don't set the - // key + ds.Logger.Debug("looking for device", "name", pName) + dev, err := peripheral.Discover() + if err != nil { + ds.Logger.Debug("didn't find device", "name", pName) + continue + } + + // Register the device we just found + ds.RegisterDevice(dev) + } + } } } -func (ds *DeviceService) GetDevice(name string) (devices.Device, error) { +// func (ds *DeviceService) SubscribeFields() error { +// for _, dev := range ds.Devices { +// fields := dev.RequiredFields() +// } +// +// return nil +// } + +func (ds *DeviceService) RegisterDevice(dev peripheral.Peripheral) error { + ds.mu.Lock() + defer ds.mu.Unlock() + + if ds.DeviceExists(dev.Name()) { + return ErrPeripheralAlreadyRegistered + } + + ds.Devices[dev.Name()] = dev + + return nil +} + +func (ds *DeviceService) GetDevice(name string) (peripheral.Peripheral, error) { val, ok := ds.Devices[name] if !ok { return nil, fmt.Errorf("device `%s` couldn't be found", name) @@ -122,9 +165,12 @@ func (ds *DeviceService) transmit(ctx context.Context) { // TODO: make a copy of the data and send that copy instead of keeping // the data locked + ds.mu.RLock() for _, dev := range ds.Devices { dev.SendData(&data) } + ds.mu.RUnlock() + isSending.Store(false) } } diff --git a/services/telemetry.go b/services/telemetry.go index f35ae24..9dd7c53 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -54,9 +54,9 @@ func (t *TelemetryService) ProviderMonitor(ctx context.Context) { case <-ctx.Done(): return case <-ticker.C: - slog.Debug("checking if provider is still running") + slog.Info("checking if provider is still running") if !t.activeProvider.IsAlive(500 * time.Millisecond) { - slog.Debug("provider healthcheck failed") + slog.Warn("provider healthcheck failed") t.dropActiveProvider() t.onProviderHealthCheckFailed() return @@ -70,10 +70,14 @@ func (t *TelemetryService) onProviderHealthCheckFailed() { go t.FindProvider(t.CtxMonitor) } -func (t *TelemetryService) onFindProvider(prov providers.Provider) { +func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) { // Attach to the provider - t.logger.Info("found provider for " + prov.Name) - t.SwitchProvider(prov.NewProvider(t.logger)) + t.logger.Info("found provider for " + prov.Name()) + err := t.SwitchProvider(prov) + if err != nil { + t.logger.Error("failed to switch to provider onFindProvider", "err", err) + return + } // Create a routine to poll this provider while we wait to start the stream or pause it t.CtxHealthcheck, t.healthCheckCancel = context.WithCancel(context.Background()) @@ -102,9 +106,15 @@ func (t *TelemetryService) FindProvider(ctx context.Context) { return case <-ticker.C: for _, prov := range providers.Providers { - t.logger.Debug("checking provider: " + prov.Name) - if prov.IsRunning() { - t.onFindProvider(prov) + // t.logger.Debug("checking provider: " + prov.Name) + provider, err := prov.NewProvider(t.logger) + if err != nil { + // Its not running + continue + } + + if provider.IsAlive(500 * time.Millisecond) { + t.onFindProvider(provider) return } } @@ -141,6 +151,7 @@ func (t *TelemetryService) multiplexData(ctx context.Context, dataCh <-chan tele t.mut.RLock() for _, ch := range t.listeners { + // t.logger.Debug("sending data to listener", "listener", key, "data", data) select { case ch <- data: // Sends data to the subscriber @@ -191,8 +202,14 @@ func (t *TelemetryService) UnsubscribeListener(id string) { } } -func (t *TelemetryService) SubscribeToFields(fields map[int16]telem.FieldID) { - t.activeProvider.Subscribe(fields) +func (t *TelemetryService) SubscribeToFields() { + // _ = t.devService.SubscribeFields() + // TODO: we need to find a way of requesting devices to send all subscribed fields + // instead of going through the devices on DevService here + for _, dev := range t.devService.Devices { + fields := dev.RequiredFields() + t.activeProvider.Subscribe(fields) + } } func (t *TelemetryService) StartStream() { diff --git a/telemetry/data.go b/telemetry/data.go index 158e815..c4f5ae0 100644 --- a/telemetry/data.go +++ b/telemetry/data.go @@ -135,7 +135,7 @@ func (tf *TelemetryField) String() string { return "NaN" } -type FieldID uint16 +type FieldID = uint16 // We use FirstField to start the count on the fields the user can select // the first three will be for internal use diff --git a/telemetry/provider.go b/telemetry/provider.go index e2cfeb5..93a405a 100644 --- a/telemetry/provider.go +++ b/telemetry/provider.go @@ -8,5 +8,6 @@ type TelemetryProvider interface { Stream() (<-chan TelemetryData, error) Subscribe(map[int16]FieldID) IsAlive(time.Duration) bool + Name() string Close() } diff --git a/tui/internal/controllers/cdashdisplay_layout.go b/tui/internal/controllers/cdashdisplay_layout.go index da21306..6400b47 100644 --- a/tui/internal/controllers/cdashdisplay_layout.go +++ b/tui/internal/controllers/cdashdisplay_layout.go @@ -211,14 +211,14 @@ func (lc *LayoutController) createWindow() { } // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) if err != nil { - lc.Messages <- "failed to get " + cdashdisplay.Name + lc.Messages <- "failed to get " + cdashdisplay.NAME return } display, ok := displayIF.(*cdashdisplay.CDashDisplay) if !ok { - lc.Messages <- "failed to acquire " + cdashdisplay.Name + lc.Messages <- "failed to acquire " + cdashdisplay.NAME return } // --- @@ -321,14 +321,14 @@ func (lc *LayoutController) newWindowAction() { func (lc *LayoutController) updateWindowAction(win *cdashdisplay.DesktopUIWindow) { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) if err != nil { - lc.Messages <- "failed to get " + cdashdisplay.Name + lc.Messages <- "failed to get " + cdashdisplay.NAME return } display, ok := displayIF.(*cdashdisplay.CDashDisplay) if !ok { - lc.Messages <- "failed to acquire " + cdashdisplay.Name + lc.Messages <- "failed to acquire " + cdashdisplay.NAME return } // --- @@ -347,14 +347,14 @@ func (lc *LayoutController) displayLoadedLayouts() { lc.Logger.Debug("We want to view our layout!") // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) if err != nil { - lc.Messages <- "failed to get " + cdashdisplay.Name + lc.Messages <- "failed to get " + cdashdisplay.NAME return } display, ok := displayIF.(*cdashdisplay.CDashDisplay) if !ok { - lc.Messages <- "failed to acquire " + cdashdisplay.Name + lc.Messages <- "failed to acquire " + cdashdisplay.NAME return } // --- @@ -392,14 +392,14 @@ func (lc *LayoutController) getCurrentTreeNodeModel() (*tview.TreeNode, int16, e func (lc *LayoutController) loadLayout() { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) if err != nil { - lc.Messages <- "failed to get " + cdashdisplay.Name + lc.Messages <- "failed to get " + cdashdisplay.NAME return } display, ok := displayIF.(*cdashdisplay.CDashDisplay) if !ok { - lc.Messages <- "failed to acquire " + cdashdisplay.Name + lc.Messages <- "failed to acquire " + cdashdisplay.NAME return } // --- @@ -416,14 +416,14 @@ func (lc *LayoutController) loadLayout() { func (lc *LayoutController) unloadLayout() { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) if err != nil { - lc.Messages <- "failed to get " + cdashdisplay.Name + lc.Messages <- "failed to get " + cdashdisplay.NAME return } display, ok := displayIF.(*cdashdisplay.CDashDisplay) if !ok { - lc.Messages <- "failed to acquire " + cdashdisplay.Name + lc.Messages <- "failed to acquire " + cdashdisplay.NAME return } // --- @@ -437,14 +437,14 @@ func (lc *LayoutController) unloadLayout() { func (lc *LayoutController) saveLayout() { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) if err != nil { - lc.Messages <- "failed to get " + cdashdisplay.Name + lc.Messages <- "failed to get " + cdashdisplay.NAME return } display, ok := displayIF.(*cdashdisplay.CDashDisplay) if !ok { - lc.Messages <- "failed to acquire " + cdashdisplay.Name + lc.Messages <- "failed to acquire " + cdashdisplay.NAME return } // --- @@ -470,14 +470,14 @@ func (lc *LayoutController) deleteWindow() { wID := curNode.GetReference().(int16) // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) if err != nil { - lc.Messages <- "failed to get " + cdashdisplay.Name + lc.Messages <- "failed to get " + cdashdisplay.NAME return } display, ok := displayIF.(*cdashdisplay.CDashDisplay) if !ok { - lc.Messages <- "failed to acquire " + cdashdisplay.Name + lc.Messages <- "failed to acquire " + cdashdisplay.NAME return } // --- diff --git a/tui/internal/controllers/cdashdisplay_layout_moveTool.go b/tui/internal/controllers/cdashdisplay_layout_moveTool.go index d363a58..ba31690 100644 --- a/tui/internal/controllers/cdashdisplay_layout_moveTool.go +++ b/tui/internal/controllers/cdashdisplay_layout_moveTool.go @@ -52,14 +52,14 @@ func (lc *LayoutController) handleMovementCapture(idx int16, } // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) if err != nil { - lc.Messages <- "failed to get " + cdashdisplay.Name + lc.Messages <- "failed to get " + cdashdisplay.NAME return nil } display, ok := displayIF.(*cdashdisplay.CDashDisplay) if !ok { - lc.Messages <- "failed to acquire " + cdashdisplay.Name + lc.Messages <- "failed to acquire " + cdashdisplay.NAME return nil } // --- @@ -86,14 +86,14 @@ func (lc *LayoutController) handleResizeCapture(idx int16, } // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.Name) + displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) if err != nil { - lc.Messages <- "failed to get " + cdashdisplay.Name + lc.Messages <- "failed to get " + cdashdisplay.NAME return nil } display, ok := displayIF.(*cdashdisplay.CDashDisplay) if !ok { - lc.Messages <- "failed to acquire " + cdashdisplay.Name + lc.Messages <- "failed to acquire " + cdashdisplay.NAME return nil } // --- diff --git a/tui/internal/controllers/device.go b/tui/internal/controllers/device.go index be1fa58..22c3e73 100644 --- a/tui/internal/controllers/device.go +++ b/tui/internal/controllers/device.go @@ -67,7 +67,7 @@ func (mc *DeviceController) AddDeviceAPIListItems() { mc.DeviceAPIView.DevAPIList. AddItem("layout", "build a layout for CDashDisplay", func() { // This CDashDisplay specific, only load if we have a CDashDisplay - if !mc.DevService.DeviceExists(cdashdisplay.Name) { + if !mc.DevService.DeviceExists(cdashdisplay.NAME) { mc.DevService.Messages <- "CDashDisplay it not loaded yet\n" return } diff --git a/tui/internal/controllers/streaming.go b/tui/internal/controllers/streaming.go index 0edfd28..cad0299 100644 --- a/tui/internal/controllers/streaming.go +++ b/tui/internal/controllers/streaming.go @@ -6,7 +6,7 @@ import ( "sync/atomic" "esdi/config" - "esdi/devices/cdashdisplay" + "esdi/devices/uidevice" "esdi/providers" "esdi/services" "esdi/telemetry" @@ -56,15 +56,15 @@ func NewStreamingCtrl( } ctrl.registerHooks() - ctrl.subscribeListeners() - go ctrl.listenToUIStream() + // ctrl.subscribeListeners() return ctrl } -func (sc *StreamingCtrl) subscribeListeners() { - sc.TelemetryCh = sc.TelemServ.SubscribeListener("UI", 1) -} +// func (sc *StreamingCtrl) subscribeListeners() { +// // Here I will set a UIDevice +// sc.TelemetryCh = sc.TelemServ.SubscribeListener("UI", 1) +// } func (sc *StreamingCtrl) registerHooks() { sc.StreamView.Options.Form.SetInputCapture(func(ev *tcell.EventKey) *tcell.EventKey { @@ -109,16 +109,21 @@ func (sc *StreamingCtrl) StartStop() { // stream is not running, we have to start it now // NOTE: // Subscribe the only existing device - needs to be discovered by now - slog.Debug("setting the data stream for cdash") - sc.Service.SetTelemetryChannel(sc.TelemServ.SubscribeListener("cdash", 1)) + slog.Debug("setting the data stream for device servie") + sc.Service.SetTelemetryChannel(sc.TelemServ.SubscribeListener("DeviceService", 1)) - slog.Debug("starting to stream data again") + dev, err := sc.Service.GetDevice(uidevice.NAME) + if err == nil { + if uiDev, ok := dev.(*uidevice.UIDevice); ok { + sc.TelemetryCh = uiDev.DataChannel() + go sc.listenToUIStream() + } + } + + slog.Debug("starting services") sc.Service.StartStream() - - slog.Debug("starting the stream") sc.TelemServ.StartStream() - slog.Debug("setting local control variables") sc.isRunning = true slog.Debug("starting stream") @@ -157,28 +162,23 @@ func (sc *StreamingCtrl) updateStream() { // so we can get away with using a map for convenience here func (sc *StreamingCtrl) SetInternalState() { // Acquire the cdashdisplay - displayIF, err := sc.Service.GetDevice(cdashdisplay.Name) - if err != nil { - sc.Messages <- "failed to get " + cdashdisplay.Name - return - } - display, ok := displayIF.(*cdashdisplay.CDashDisplay) - if !ok { - sc.Messages <- "failed to acquire " + cdashdisplay.Name - return - } + // displayIF, err := sc.Service.GetDevice(cdashdisplay.NAME) + // if err != nil { + // sc.Messages <- "failed to get " + cdashdisplay.NAME + // return + // } + // display, ok := displayIF.(*cdashdisplay.CDashDisplay) + // if !ok { + // sc.Messages <- "failed to acquire " + cdashdisplay.NAME + // return + // } // --- - fields := make(map[int16]telemetry.FieldID, len(display.State.Layout.Windows)) + sc.TelemServ.SubscribeToFields() - for _, w := range display.State.Layout.Windows { - fieldID, _ := telemetry.GetFieldID(w.UIData.TelemetryField) - fields[w.UIData.IDX] = fieldID - } - - sc.TelemServ.SubscribeToFields(fields) - - sc.Messages <- fmt.Sprintf("Subscribed Fields: %+v [%d]\n", fields, len(fields)) + // sc.Messages <- fmt.Sprintf("Subscribed Fields: %+v [%d]\n", fields, len(fields)) + // Should I update this? + sc.Messages <- fmt.Sprintf("Subscribed to fields\n") } func (sc *StreamingCtrl) listenToUIStream() { @@ -190,8 +190,13 @@ func (sc *StreamingCtrl) listenToUIStream() { } isDrawing.Store(true) + // sc.Logger.Debug("got data", "data", msg) + + // Capture locally + telemetryMsg := msg + sc.App.QueueUpdateDraw(func() { - sc.StreamView.Visualizer.Update(&msg) + sc.StreamView.Visualizer.Update(&telemetryMsg) isDrawing.Store(false) }) } diff --git a/tui/tui.go b/tui/tui.go index 374d21e..4add4bb 100644 --- a/tui/tui.go +++ b/tui/tui.go @@ -24,7 +24,7 @@ func NewControlPanel(logger *slog.Logger) *ControlPanel { } // NOTE: create our device service here - devService := services.NewDeviceService(logger) + devService := services.NewDeviceService(logger.With("service", "DeviceService")) telemService := services.NewTelemetryService(logger, devService) if telemService == nil { From 1ac4ab1865cc6582d36e0eda9879e84a93c72311 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Thu, 17 Sep 2026 23:08:36 +0100 Subject: [PATCH 16/41] logger fixes on cdashdisplay device implementation --- cmd/liveTelemetry.go | 5 +---- cmd/offlineTelemetry.go | 5 ++--- devices/cdashdisplay/connect.go | 20 +++++++++-------- devices/cdashdisplay/display.go | 31 +++++++++++---------------- devices/cdashdisplay/layoutManager.go | 13 ++++++----- devices/device.go | 31 ++++++--------------------- 6 files changed, 41 insertions(+), 64 deletions(-) diff --git a/cmd/liveTelemetry.go b/cmd/liveTelemetry.go index 103c911..fd95b07 100644 --- a/cmd/liveTelemetry.go +++ b/cmd/liveTelemetry.go @@ -1,20 +1,17 @@ package cmd import ( - "esdi/logger" esdi "esdi/oldEsdi" "github.com/spf13/cobra" ) func liveTelemetryCmdAction(cmd *cobra.Command, args []string) { - log := logger.GetInstance() - ddPort, _ := cmd.Flags().GetString("port") outputFile, _ := cmd.Flags().GetString("out") sessionFile, _ := cmd.Flags().GetString("session") - log.Printf("Called `live`:\nPort: '%s'\nOutFile: '%s'\n", ddPort, outputFile) + // log.Printf("Called `live`:\nPort: '%s'\nOutFile: '%s'\n", ddPort, outputFile) esdi.RunLiveTelemetry(ddPort, outputFile, sessionFile) } diff --git a/cmd/offlineTelemetry.go b/cmd/offlineTelemetry.go index fde68c2..0fc6001 100644 --- a/cmd/offlineTelemetry.go +++ b/cmd/offlineTelemetry.go @@ -1,7 +1,6 @@ package cmd import ( - "esdi/logger" esdi "esdi/oldEsdi" // "github.com/ESilva15/goirsdk" @@ -10,14 +9,14 @@ import ( ) func offlineTelemetryCmdAction(cmd *cobra.Command, args []string) { - log := logger.GetInstance() + // log := logger.GetInstance() ddPort, _ := cmd.Flags().GetString("port") inFile, _ := cmd.Flags().GetString("in") outFile, _ := cmd.Flags().GetString("out") sessionFile, _ := cmd.Flags().GetString("session") - log.Printf("Called `offline`:\nPort: '%s'\nSource: '%s'\nOutFile: '%s'\n", ddPort, inFile, outFile) + // log.Printf("Called `offline`:\nPort: '%s'\nSource: '%s'\nOutFile: '%s'\n", ddPort, inFile, outFile) esdi.RunOfflineTelemetry(ddPort, inFile, outFile, sessionFile) } diff --git a/devices/cdashdisplay/connect.go b/devices/cdashdisplay/connect.go index bf899c2..fe65496 100644 --- a/devices/cdashdisplay/connect.go +++ b/devices/cdashdisplay/connect.go @@ -1,10 +1,12 @@ package cdashdisplay import ( + "fmt" + "log/slog" + "time" + "esdi/peripheral/communication" "esdi/peripheral/communication/packets" - "fmt" - "time" "github.com/tarm/serial" portp "go.bug.st/serial" @@ -46,11 +48,11 @@ func findDisplayPort() (*communication.WalkieTalkie, error) { return nil, err } - pLogger.Info(fmt.Sprintf("Looking into %v", ports)) + slog.Info(fmt.Sprintf("Looking into %v", ports)) var wt *communication.WalkieTalkie for _, port := range ports { - pLogger.Info(fmt.Sprintf("Trying port %s", port)) + slog.Info(fmt.Sprintf("Trying port %s", port)) wt = &communication.WalkieTalkie{ Cfg: &serial.Config{ @@ -60,7 +62,7 @@ func findDisplayPort() (*communication.WalkieTalkie, error) { }, } - pLogger.Info(fmt.Sprintf("Started probing port %s", port)) + slog.Info(fmt.Sprintf("Started probing port %s", port)) probeResult := make(chan error, 1) @@ -76,14 +78,14 @@ func findDisplayPort() (*communication.WalkieTalkie, error) { err = fmt.Errorf("probe completely hung/timed out: %s", port) } - pLogger.Info(fmt.Sprintf("Finished probing port %s", port)) + slog.Info(fmt.Sprintf("Finished probing port %s", port)) if err == nil { - pLogger.Info(fmt.Sprintf("Success probing port %s: %+v", port, err)) + slog.Info(fmt.Sprintf("Success probing port %s: %+v", port, err)) break } - pLogger.Info(fmt.Sprintf("wasn't port %s", port)) + slog.Info(fmt.Sprintf("wasn't port %s", port)) wt = nil } @@ -91,6 +93,6 @@ func findDisplayPort() (*communication.WalkieTalkie, error) { return nil, fmt.Errorf("couldn't find cdashdisplay") } - pLogger.Info(fmt.Sprintf("found cdashdisplay on port: %s", wt.Cfg.Name)) + slog.Info(fmt.Sprintf("found cdashdisplay on port: %s", wt.Cfg.Name)) return wt, nil } diff --git a/devices/cdashdisplay/display.go b/devices/cdashdisplay/display.go index 763a926..0c98e8d 100644 --- a/devices/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -19,13 +19,6 @@ import ( "gopkg.in/yaml.v3" ) -// TODO: remove this logger. It should be on the device struct -var pLogger *slog.Logger - -func SetLogger(l *slog.Logger) { - pLogger = l -} - // I have to move this to some kind of configuration place const ( layoutsDir = "./layouts/" @@ -118,11 +111,11 @@ type CDashDisplay struct { } // Connect will try to find and connect to the CDashDisplay -func Discover() (*CDashDisplay, error) { +func NewCDashDisplay() (*CDashDisplay, error) { // Look for the port p, err := findDisplayPort() if err != nil { - pLogger.Info("failed to find cdashdisplay port: %s", err.Error()) + slog.Info("failed to find cdashdisplay port: %s", err.Error()) return nil, err } @@ -150,7 +143,7 @@ func (d *CDashDisplay) CreateWindow(win *DesktopUIWindow) (*DesktopUIWindow, err win.UIData.IDX = wID.ID - pLogger.Info(fmt.Sprintf("Recived ID message: %v", wID)) + slog.Info(fmt.Sprintf("Recived ID message: %v", wID)) d.State.Layout.AddWindow(win) @@ -178,9 +171,9 @@ func (d *CDashDisplay) UpdateWindow(win *DesktopUIWindow) error { // I get it and update it in the controller // I send the pointer here // -> it should be the same pointer then right? - pLogger.Debug(fmt.Sprintf("PreUpdate ID: %p", win)) + slog.Debug(fmt.Sprintf("PreUpdate ID: %p", win)) d.State.Layout.Windows[win.UIData.IDX] = win - pLogger.Debug(fmt.Sprintf("PostUpdate ID: %p", win)) + slog.Debug(fmt.Sprintf("PostUpdate ID: %p", win)) // Yeah, same address as suspected // I can't think about it right now. I'll think about that tomorrow @@ -213,7 +206,7 @@ func (d *CDashDisplay) DestroyWindow(wID int16) error { } func (d *CDashDisplay) updateWindowDimensions(win *UIWindow, packet UpdateDimsPacket) error { - pLogger.Debug(fmt.Sprintf("UPDATE: %v", packet)) + slog.Debug(fmt.Sprintf("UPDATE: %v", packet)) bytes, err := helper.StructToBytes(packet) if err != nil { @@ -227,9 +220,9 @@ func (d *CDashDisplay) updateWindowDimensions(win *UIWindow, packet UpdateDimsPa } // Nothing bad happened afaik - pLogger.Debug(fmt.Sprintf("cur dims: %v", win.Dims)) + slog.Debug(fmt.Sprintf("cur dims: %v", win.Dims)) win.Dims = packet.Dims - pLogger.Debug(fmt.Sprintf("new dims: %v", win.Dims)) + slog.Debug(fmt.Sprintf("new dims: %v", win.Dims)) return nil } @@ -345,18 +338,18 @@ func (d *CDashDisplay) LoadLayout(layoutName string) error { func (d *CDashDisplay) UnloadLayout() error { var err error for _, w := range d.State.Layout.Windows { - pLogger.Debug(fmt.Sprintf("= Removing %d ==============================================", + slog.Debug(fmt.Sprintf("= Removing %d ==============================================", w.UIData.IDX)) err = d.DestroyWindow(w.UIData.IDX) time.Sleep(75 * time.Millisecond) if err != nil { - pLogger.Error(fmt.Sprintf("failed to destroy window: %+v", err)) + slog.Error(fmt.Sprintf("failed to destroy window: %+v", err)) // NOTE: Add a way to handle multiple errors ? return err } - pLogger.Debug(fmt.Sprintf("= Removing %d ==============================================", + slog.Debug(fmt.Sprintf("= Removing %d ==============================================", w.UIData.IDX)) } @@ -378,7 +371,7 @@ func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) { curStr += fmt.Sprintf("%02x ", byte) if byteCount == 8 { - // pLogger.Debug(curStr) + // slog.Debug(curStr) curStr = "" byteCount = 0 } diff --git a/devices/cdashdisplay/layoutManager.go b/devices/cdashdisplay/layoutManager.go index 82a14e0..4701cb7 100644 --- a/devices/cdashdisplay/layoutManager.go +++ b/devices/cdashdisplay/layoutManager.go @@ -1,6 +1,9 @@ package cdashdisplay -import "fmt" +import ( + "fmt" + "log/slog" +) type LayoutTree struct { Windows map[int16]*DesktopUIWindow `yaml:"Windows"` @@ -13,13 +16,13 @@ func NewLayoutTree() *LayoutTree { } func (l *LayoutTree) AddWindow(w *DesktopUIWindow) { - pLogger.Debug(fmt.Sprintf("adding window '%d' - %v", w.UIData.IDX)) + slog.Debug(fmt.Sprintf("adding window '%d' - %v", w.UIData.IDX)) l.Windows[w.UIData.IDX] = w - pLogger.Debug(fmt.Sprintf("new map - %v", l.Windows)) + slog.Debug(fmt.Sprintf("new map - %v", l.Windows)) } func (l *LayoutTree) RemoveWindow(idx int16) { - pLogger.Debug(fmt.Sprintf("removing window '%d'", idx)) + slog.Debug(fmt.Sprintf("removing window '%d'", idx)) delete(l.Windows, idx) - pLogger.Debug(fmt.Sprintf("new map - %v", l.Windows)) + slog.Debug(fmt.Sprintf("new map - %v", l.Windows)) } diff --git a/devices/device.go b/devices/device.go index 6c85b4f..9318cac 100644 --- a/devices/device.go +++ b/devices/device.go @@ -2,8 +2,6 @@ package devices import ( - "errors" - "esdi/devices/cdashdisplay" "esdi/devices/uidevice" "esdi/peripheral" @@ -35,26 +33,11 @@ func DiscoverUIDevice() (peripheral.Peripheral, error) { } func DiscoverCDashDisplay() (peripheral.Peripheral, error) { - // // Find CDashDisplay - // { - // ds.Messages <- "looking for " + cdashdisplay.Name + "...\n" - // ds.Logger.Info("Looking for " + cdashdisplay.Name) - // - // cdashdisplay.SetLogger(ds.Logger.With("[device]", cdashdisplay.Name)) - // - // // Create a cdashdisplay - // display, err := cdashdisplay.Discover() - // if err == nil { - // ds.Devices[cdashdisplay.Name] = display - // ds.Logger.Info("found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name) - // ds.Messages <- "found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name + "\n" - // return - // } - // - // ds.Logger.Info("didn't find " + cdashdisplay.Name) - // ds.Messages <- "didn't find " + cdashdisplay.Name + "\n" - // // No CDashDisplay available for one reason or another, so we don't set the - // // key - // } - return nil, errors.New("not implemented yet") + // Create a cdashdisplay + display, err := cdashdisplay.NewCDashDisplay() + if err != nil { + return nil, err + } + + return display, nil } From dda300ce6b54f3b89afb78efa353de54722e2c9a Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Thu, 17 Sep 2026 23:55:54 +0100 Subject: [PATCH 17/41] decoupled the winIDs from the telemetry data hell yeah, brother! --- devices/cdashdisplay/display.go | 49 ++++++++-- devices/cdashdisplay/transportPackets.go | 77 +++++++++++++++- main.go | 4 +- providers/beamng/beamng.go | 4 +- providers/iracing/iracing.go | 4 +- services/telemetry.go | 2 + telemetry/data.go | 109 ++++++++--------------- telemetry/telemetry.go | 6 +- 8 files changed, 164 insertions(+), 91 deletions(-) diff --git a/devices/cdashdisplay/display.go b/devices/cdashdisplay/display.go index 0c98e8d..dcb6489 100644 --- a/devices/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -8,6 +8,7 @@ import ( "log/slog" "os" "path" + "sync" "time" helper "esdi/helpers" @@ -106,8 +107,10 @@ func NewCDashState() *CDashState { } type CDashDisplay struct { - WT *communication.WalkieTalkie - State *CDashState + WT *communication.WalkieTalkie + State *CDashState + fieldToWindows map[telemetry.FieldID][]int16 + bufPool sync.Pool } // Connect will try to find and connect to the CDashDisplay @@ -120,14 +123,42 @@ func NewCDashDisplay() (*CDashDisplay, error) { } return &CDashDisplay{ - WT: p, - State: NewCDashState(), + WT: p, + State: NewCDashState(), + fieldToWindows: make(map[telemetry.FieldID][]int16), + bufPool: sync.Pool{ + New: func() any { + b := make([]byte, 0, telemetry.MaxFields*8) + return &b + }, + }, }, nil } func (d *CDashDisplay) SendCommand() { } +func (d *CDashDisplay) RegisterFieldMapping(fieldID telemetry.FieldID, winID int16) { + d.fieldToWindows[fieldID] = append(d.fieldToWindows[fieldID], winID) +} + +func (d *CDashDisplay) UnregisterFieldMapping(winID int16) { + for fieldID, windows := range d.fieldToWindows { + updated := windows[:0] + for _, w := range windows { + if w != winID { + updated = append(updated, w) + } + + if len(updated) == 0 { + delete(d.fieldToWindows, fieldID) + } else { + d.fieldToWindows[fieldID] = updated + } + } + } +} + func (d *CDashDisplay) CreateWindow(win *DesktopUIWindow) (*DesktopUIWindow, error) { bytes, err := helper.StructToBytes(win.UIWindow) if err != nil { @@ -146,6 +177,9 @@ func (d *CDashDisplay) CreateWindow(win *DesktopUIWindow) (*DesktopUIWindow, err slog.Info(fmt.Sprintf("Recived ID message: %v", wID)) d.State.Layout.AddWindow(win) + if fieldID, ok := telemetry.GetFieldID(win.UIData.TelemetryField); ok { + d.RegisterFieldMapping(fieldID, win.UIData.IDX) + } return win, nil } @@ -177,6 +211,8 @@ func (d *CDashDisplay) UpdateWindow(win *DesktopUIWindow) error { // Yeah, same address as suspected // I can't think about it right now. I'll think about that tomorrow + // TODO: need to update the field mappings here! + return nil } @@ -199,7 +235,8 @@ func (d *CDashDisplay) DestroyWindow(wID int16) error { return err } - // NODE: add this + // NOTE: add this + d.UnregisterFieldMapping(wID) d.State.Layout.RemoveWindow(wID) return nil @@ -357,7 +394,7 @@ func (d *CDashDisplay) UnloadLayout() error { } func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) { - packet := data.Pack() + packet := d.encodePacket(data) bytes, err := helper.StructToBytes(packet) if err != nil { diff --git a/devices/cdashdisplay/transportPackets.go b/devices/cdashdisplay/transportPackets.go index 811684b..ad85aff 100644 --- a/devices/cdashdisplay/transportPackets.go +++ b/devices/cdashdisplay/transportPackets.go @@ -1,5 +1,11 @@ package cdashdisplay +import ( + "math" + + "esdi/telemetry" +) + // In this file we will place all structs that are 1:1 representation of the // types in the device transport layer -> @@ -65,6 +71,71 @@ type UIWindowUpdatePacket struct { Window UIWindow } -// func getUIWindowDTO(w *DesktopWindowData) *UIWindow { -// -// } +// TODO: this is here because this is the only device I use like this +// once I add another serial device I will move this somewhere else that can +// be reused by all devices but still is decoupled from the telemetry package +func (cds *CDashDisplay) encodePacket(td *telemetry.TelemetryData) []byte { + bufPtr := cds.bufPool.Get().(*[]byte) + buf := (*bufPtr)[:0] + + for fieldID, windowIDs := range cds.fieldToWindows { + if int(fieldID) >= len(td.Values) || len(windowIDs) == 0 { + continue + } + + tf := &td.Values[fieldID] + + for _, winID := range windowIDs { + buf = packField(winID, tf, buf) + } + } + + // We have to copy here because we have to return the buffer + result := make([]byte, len(buf)) + copy(result, buf) + + cds.bufPool.Put(&buf) + + return result +} + +// Pack will pack this current TelemetryField into bytes to send over the wire +// Format: +// 0x00 - Field ID +// 0x00 | +// 0x01 - DataType +// 0x02 - if its a (u)int8 +// or +// 0x02 - if its a (u)int16 - first byte +// 0x02 - if its a (u)int16 - second byte +// or +// 0x02 - str len max is 255 chars +// [0x02] - str +func packField(winID int16, tf *telemetry.TelemetryField, dest []byte) []byte { + // NOTE: maybe we can have a pool of these so we don't have to create them here + // or whatever + dest = append(dest, uint8(winID), uint8(winID>>8)) + dest = append(dest, uint8(tf.Type)) + + switch tf.Type { + case telemetry.DataTypeINT8, telemetry.DataTypeUINT8, telemetry.DataTypeCHAR: + dest = append(dest, uint8(tf.Raw)) + case telemetry.DataTypeINT16, telemetry.DataTypeUINT16: + dest = append(dest, uint8(tf.Raw), uint8(tf.Raw>>8)) + case telemetry.DataTypeINT32, telemetry.DataTypeUINT32: + dest = append(dest, uint8(tf.Raw), uint8(tf.Raw>>8), uint8(tf.Raw>>16), uint8(tf.Raw>>24)) + case telemetry.DataTypeINT64, telemetry.DataTypeUINT64: + dest = append( + dest, uint8(tf.Raw), uint8(tf.Raw>>8), uint8(tf.Raw>>16), + uint8(tf.Raw>>24), uint8(tf.Raw>>32), uint8(tf.Raw>>40), uint8(tf.Raw>>48), + uint8(tf.Raw>>56), + ) + case telemetry.DataTypeSTRING: + l := min(len(tf.Str), math.MaxUint8) + + dest = append(dest, uint8(l)) + dest = append(dest, tf.Str[:l]...) + } + + return dest +} diff --git a/main.go b/main.go index 7507664..f798f9f 100644 --- a/main.go +++ b/main.go @@ -10,7 +10,6 @@ import ( "esdi/cmd" "esdi/config" - "esdi/telemetry" "github.com/arl/statsviz" ) @@ -44,7 +43,7 @@ func initApplication() { } // Setting up some internal data structures - telemetry.Init() + // telemetry.Init() } func setupLogger() error { @@ -56,6 +55,7 @@ func setupLogger() error { logger := slog.New( slog.NewTextHandler(output, &slog.HandlerOptions{ Level: slog.LevelDebug, + // AddSource: true, // NOTE: this may have some performance impacts, disable it for prod }), ) diff --git a/providers/beamng/beamng.go b/providers/beamng/beamng.go index 70e90ed..2f6326f 100644 --- a/providers/beamng/beamng.go +++ b/providers/beamng/beamng.go @@ -125,8 +125,8 @@ func (b *BeamNG) Subscribe(requestFields map[int16]telemetry.FieldID) { // we will add their dependencies and the primitives to a slice pendingBinds := make([]telemetry.FieldID, telemetry.MaxFields) - for winID, id := range requestFields { - b.data.Values[id].IDs = append(b.data.Values[id].IDs, winID) + for _, id := range requestFields { + // b.data.Values[id].IDs = append(b.data.Values[id].IDs, winID) switch id { case telemetry.RPMStateColour: diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index 2c57f6e..9bae148 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -229,8 +229,8 @@ func (i *IRacing) Subscribe(requestFields map[int16]telemetry.FieldID) { // we will add their dependencies and the primitives to a slice pendingBinds := make([]telemetry.FieldID, 0, telemetry.MaxFields) - for winID, id := range requestFields { - i.data.Values[id].IDs = append(i.data.Values[id].IDs, winID) + for _, id := range requestFields { + // i.data.Values[id].IDs = append(i.data.Values[id].IDs, winID) switch id { case telemetry.RPMStateColour: diff --git a/services/telemetry.go b/services/telemetry.go index 9dd7c53..253ec73 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -206,8 +206,10 @@ func (t *TelemetryService) SubscribeToFields() { // _ = t.devService.SubscribeFields() // TODO: we need to find a way of requesting devices to send all subscribed fields // instead of going through the devices on DevService here + // REVAMP for _, dev := range t.devService.Devices { fields := dev.RequiredFields() + t.logger.Debug("requested fields", "fields", fields) t.activeProvider.Subscribe(fields) } } diff --git a/telemetry/data.go b/telemetry/data.go index c4f5ae0..45051f4 100644 --- a/telemetry/data.go +++ b/telemetry/data.go @@ -1,12 +1,18 @@ package telemetry import ( - "math" "strconv" "sync" "time" ) +func init() { + fieldNameToID = make(map[string]FieldID, MaxFields) + for id, name := range FieldNames { + fieldNameToID[name] = FieldID(id) + } +} + // NOTE: allow the user to create custom data things. For example, iRacing provides // multiple surface temps, but I guess the user doesn't want all of them at once. // allow him to make something that allows some data transformation to occur. @@ -64,7 +70,7 @@ const ( // NOTE: we can optimize this via a special command that says a given piece of data // is for multiple targets type TelemetryField struct { - IDs []int16 // Identification for the serial device + // IDs []int16 // Identification for the serial device Type DataType Raw uint64 Str string // Only to be used with DataTypeSTRING @@ -75,49 +81,6 @@ func (tf *TelemetryField) Unused() { tf.Raw = uint64('-') } -// Pack will pack this current TelemetryField into bytes to send over the wire -// Format: -// 0x00 - Field ID -// 0x00 | -// 0x01 - DataType -// 0x02 - if its a (u)int8 -// or -// 0x02 - if its a (u)int16 - first byte -// 0x02 - if its a (u)int16 - second byte -// or -// 0x02 - str len max is 255 chars -// [0x02] - str -func (tf *TelemetryField) Pack(dest []byte) []byte { - // NOTE: maybe we can have a pool of these so we don't have to create them here - // or whatever - for _, id := range tf.IDs { - dest = append(dest, uint8(id), uint8(id>>8)) - dest = append(dest, uint8(tf.Type)) - - switch tf.Type { - case DataTypeINT8, DataTypeUINT8, DataTypeCHAR: - dest = append(dest, uint8(tf.Raw)) - case DataTypeINT16, DataTypeUINT16: - dest = append(dest, uint8(tf.Raw), uint8(tf.Raw>>8)) - case DataTypeINT32, DataTypeUINT32: - dest = append(dest, uint8(tf.Raw), uint8(tf.Raw>>8), uint8(tf.Raw>>16), uint8(tf.Raw>>24)) - case DataTypeINT64, DataTypeUINT64: - dest = append( - dest, uint8(tf.Raw), uint8(tf.Raw>>8), uint8(tf.Raw>>16), - uint8(tf.Raw>>24), uint8(tf.Raw>>32), uint8(tf.Raw>>40), uint8(tf.Raw>>48), - uint8(tf.Raw>>56), - ) - case DataTypeSTRING: - l := min(len(tf.Str), math.MaxUint8) - - dest = append(dest, uint8(l)) - dest = append(dest, tf.Str[:l]...) - } - } - - return dest -} - func (tf *TelemetryField) String() string { switch tf.Type { case DataTypeSTRING: @@ -259,12 +222,12 @@ func GetFieldName(id FieldID) string { var fieldNameToID map[string]FieldID -func initFieldNamesMap() { - fieldNameToID = make(map[string]FieldID, MaxFields) - for id, name := range FieldNames { - fieldNameToID[name] = FieldID(id) - } -} +// func initFieldNamesMap() { +// fieldNameToID = make(map[string]FieldID, MaxFields) +// for id, name := range FieldNames { +// fieldNameToID[name] = FieldID(id) +// } +// } func GetFieldID(name string) (FieldID, bool) { id, ok := fieldNameToID[name] @@ -286,25 +249,25 @@ func NewTelemetryData() *TelemetryData { return &TelemetryData{} } -func (td *TelemetryData) Pack() []byte { - bufPtr := bufferPool.Get().(*[]byte) - buf := (*bufPtr)[:0] - - // for _, bind := range td.ActiveBinds { - // buf = td.Values[bind.ID].Pack(buf) - // } - - for k := range td.Values { - if len(td.Values[k].IDs) > 0 { - buf = td.Values[k].Pack(buf) - } - } - - // We have to copy here because we have to return the buffer - result := make([]byte, len(buf)) - copy(result, buf) - - bufferPool.Put(&buf) - - return result -} +// func (td *TelemetryData) Pack() []byte { +// bufPtr := bufferPool.Get().(*[]byte) +// buf := (*bufPtr)[:0] +// +// // for _, bind := range td.ActiveBinds { +// // buf = td.Values[bind.ID].Pack(buf) +// // } +// +// for k := range td.Values { +// if len(td.Values[k].IDs) > 0 { +// buf = td.Values[k].Pack(buf) +// } +// } +// +// // We have to copy here because we have to return the buffer +// result := make([]byte, len(buf)) +// copy(result, buf) +// +// bufferPool.Put(&buf) +// +// return result +// } diff --git a/telemetry/telemetry.go b/telemetry/telemetry.go index 016e3e1..673b5c3 100644 --- a/telemetry/telemetry.go +++ b/telemetry/telemetry.go @@ -1,5 +1,5 @@ package telemetry -func Init() { - initFieldNamesMap() -} +// func Init() { +// initFieldNamesMap() +// } From c888dc54361fee8678068813e3fba4bf6d4d5457 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 18 Sep 2026 00:05:50 +0100 Subject: [PATCH 18/41] remove commented code and made the subscription be based on a list --- devices/cdashdisplay/info.go | 9 +++++---- devices/uidevice/device.go | 11 ++--------- main.go | 4 ---- peripheral/peripheral.go | 2 +- providers/beamng/beamng.go | 4 +--- providers/iracing/iracing.go | 4 +--- telemetry/data.go | 30 ------------------------------ telemetry/provider.go | 2 +- telemetry/telemetry.go | 4 ---- 9 files changed, 11 insertions(+), 59 deletions(-) diff --git a/devices/cdashdisplay/info.go b/devices/cdashdisplay/info.go index 14cbbe4..1dfb8d2 100644 --- a/devices/cdashdisplay/info.go +++ b/devices/cdashdisplay/info.go @@ -15,12 +15,13 @@ func (cds *CDashDisplay) Name() string { return NAME } -func (cds *CDashDisplay) RequiredFields() map[int16]telemetry.FieldID { - fields := make(map[int16]telemetry.FieldID, len(cds.State.Layout.Windows)) +func (cds *CDashDisplay) RequiredFields() []telemetry.FieldID { + fields := make([]telemetry.FieldID, 0, len(cds.State.Layout.Windows)) for _, w := range cds.State.Layout.Windows { - fieldID, _ := telemetry.GetFieldID(w.UIData.TelemetryField) - fields[w.UIData.IDX] = fieldID + if fieldID, ok := telemetry.GetFieldID(w.UIData.TelemetryField); ok { + fields = append(fields, fieldID) + } } return fields diff --git a/devices/uidevice/device.go b/devices/uidevice/device.go index d228982..c08fd85 100644 --- a/devices/uidevice/device.go +++ b/devices/uidevice/device.go @@ -37,17 +37,10 @@ func (uid *UIDevice) DataChannel() <-chan telemetry.TelemetryData { return uid.dataChan } -func (uid *UIDevice) RequiredFields() map[int16]telemetry.FieldID { - subscribeTo := []telemetry.FieldID{ +func (uid *UIDevice) RequiredFields() []telemetry.FieldID { + return []telemetry.FieldID{ telemetry.Speed, telemetry.Gear, telemetry.RPM, } - - fields := make(map[int16]telemetry.FieldID, len(subscribeTo)) - for k, field := range subscribeTo { - fields[int16(k)] = field - } - - return fields } diff --git a/main.go b/main.go index f798f9f..7a54f13 100644 --- a/main.go +++ b/main.go @@ -41,9 +41,6 @@ func initApplication() { slog.Error(fmt.Sprintf("failed to setup metrics server: %+v", err)) } } - - // Setting up some internal data structures - // telemetry.Init() } func setupLogger() error { @@ -55,7 +52,6 @@ func setupLogger() error { logger := slog.New( slog.NewTextHandler(output, &slog.HandlerOptions{ Level: slog.LevelDebug, - // AddSource: true, // NOTE: this may have some performance impacts, disable it for prod }), ) diff --git a/peripheral/peripheral.go b/peripheral/peripheral.go index bdb035d..f7b31e5 100644 --- a/peripheral/peripheral.go +++ b/peripheral/peripheral.go @@ -18,7 +18,7 @@ const ( type Peripheral interface { Name() string SendData(*telemetry.TelemetryData) - RequiredFields() map[int16]telemetry.FieldID + RequiredFields() []telemetry.FieldID } type PeripheralDeviceClerk struct { diff --git a/providers/beamng/beamng.go b/providers/beamng/beamng.go index 2f6326f..816635d 100644 --- a/providers/beamng/beamng.go +++ b/providers/beamng/beamng.go @@ -115,7 +115,7 @@ func (b *BeamNG) Stream() (<-chan telemetry.TelemetryData, error) { return b.streamCh, nil } -func (b *BeamNG) Subscribe(requestFields map[int16]telemetry.FieldID) { +func (b *BeamNG) Subscribe(requestFields []telemetry.FieldID) { // NOTE: document how the Subscribe funtion works slog.Debug(fmt.Sprintf("Len Req: %d\n", len(requestFields))) @@ -126,8 +126,6 @@ func (b *BeamNG) Subscribe(requestFields map[int16]telemetry.FieldID) { pendingBinds := make([]telemetry.FieldID, telemetry.MaxFields) for _, id := range requestFields { - // b.data.Values[id].IDs = append(b.data.Values[id].IDs, winID) - switch id { case telemetry.RPMStateColour: b.data.VirtualBinds = append(b.data.VirtualBinds, telemetry.NewRPMLights()) diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index 9bae148..9620c3b 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -220,7 +220,7 @@ func (i *IRacing) StopStream() { i.streamCancel = nil } -func (i *IRacing) Subscribe(requestFields map[int16]telemetry.FieldID) { +func (i *IRacing) Subscribe(requestFields []telemetry.FieldID) { i.logger.Debug(fmt.Sprintf("Len Req: %d\n", len(requestFields))) i.data.ActiveBinds = make([]telemetry.BoundField, 0, len(requestFields)) @@ -230,8 +230,6 @@ func (i *IRacing) Subscribe(requestFields map[int16]telemetry.FieldID) { pendingBinds := make([]telemetry.FieldID, 0, telemetry.MaxFields) for _, id := range requestFields { - // i.data.Values[id].IDs = append(i.data.Values[id].IDs, winID) - switch id { case telemetry.RPMStateColour: i.data.VirtualBinds = append(i.data.VirtualBinds, telemetry.NewRPMLights()) diff --git a/telemetry/data.go b/telemetry/data.go index 45051f4..166b17c 100644 --- a/telemetry/data.go +++ b/telemetry/data.go @@ -222,13 +222,6 @@ func GetFieldName(id FieldID) string { var fieldNameToID map[string]FieldID -// func initFieldNamesMap() { -// fieldNameToID = make(map[string]FieldID, MaxFields) -// for id, name := range FieldNames { -// fieldNameToID[name] = FieldID(id) -// } -// } - func GetFieldID(name string) (FieldID, bool) { id, ok := fieldNameToID[name] return id, ok @@ -248,26 +241,3 @@ type TelemetryData struct { func NewTelemetryData() *TelemetryData { return &TelemetryData{} } - -// func (td *TelemetryData) Pack() []byte { -// bufPtr := bufferPool.Get().(*[]byte) -// buf := (*bufPtr)[:0] -// -// // for _, bind := range td.ActiveBinds { -// // buf = td.Values[bind.ID].Pack(buf) -// // } -// -// for k := range td.Values { -// if len(td.Values[k].IDs) > 0 { -// buf = td.Values[k].Pack(buf) -// } -// } -// -// // We have to copy here because we have to return the buffer -// result := make([]byte, len(buf)) -// copy(result, buf) -// -// bufferPool.Put(&buf) -// -// return result -// } diff --git a/telemetry/provider.go b/telemetry/provider.go index 93a405a..43c8370 100644 --- a/telemetry/provider.go +++ b/telemetry/provider.go @@ -6,7 +6,7 @@ import "time" type TelemetryProvider interface { StopStream() Stream() (<-chan TelemetryData, error) - Subscribe(map[int16]FieldID) + Subscribe([]FieldID) IsAlive(time.Duration) bool Name() string Close() diff --git a/telemetry/telemetry.go b/telemetry/telemetry.go index 673b5c3..073f40d 100644 --- a/telemetry/telemetry.go +++ b/telemetry/telemetry.go @@ -1,5 +1 @@ package telemetry - -// func Init() { -// initFieldNamesMap() -// } From bd10d6b4d644103ca77231db78235eca17fe0144 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 18 Sep 2026 00:07:27 +0100 Subject: [PATCH 19/41] subscription fix. should subscribe too fields at once --- services/telemetry.go | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/services/telemetry.go b/services/telemetry.go index 253ec73..d4bb5db 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -7,6 +7,7 @@ import ( "time" "esdi/providers" + "esdi/telemetry" telem "esdi/telemetry" ) @@ -203,15 +204,20 @@ func (t *TelemetryService) UnsubscribeListener(id string) { } func (t *TelemetryService) SubscribeToFields() { - // _ = t.devService.SubscribeFields() - // TODO: we need to find a way of requesting devices to send all subscribed fields - // instead of going through the devices on DevService here - // REVAMP + seen := make(map[telemetry.FieldID]struct{}) + var allFields []telemetry.FieldID + for _, dev := range t.devService.Devices { - fields := dev.RequiredFields() - t.logger.Debug("requested fields", "fields", fields) - t.activeProvider.Subscribe(fields) + for _, field := range dev.RequiredFields() { + if _, exists := seen[field]; !exists { + seen[field] = struct{}{} + allFields = append(allFields, field) + } + } } + + t.logger.Debug("requested fields", "fields", allFields) + t.activeProvider.Subscribe(allFields) } func (t *TelemetryService) StartStream() { From 2d4875fbd0e0f0bd96409e2dd5a57f35f792f535 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 18 Sep 2026 11:07:29 +0100 Subject: [PATCH 20/41] removed log that was just polluting everything --- providers/iracing/iracing.go | 1 - 1 file changed, 1 deletion(-) diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index 9620c3b..8826c4a 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -149,7 +149,6 @@ func (i *IRacing) stream(ctx context.Context) { if i.SDK.CheckForDataEvent(time.Duration(dataEvTimeout) * time.Millisecond) { consecutiveTimeouts = 0 - i.logger.Debug("sending data", "timeouts", consecutiveTimeouts) i.readData() // Publish data From a6683df10b234a36dc98d3f55450301fde49c3f1 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 18 Sep 2026 15:38:17 +0100 Subject: [PATCH 21/41] fixed the start and stop behaviour. it was crashing --- Docs/Streaming_Flow.md | 1 + providers/iracing/iracing.go | 27 +-- services/devices.go | 8 - services/telemetry.go | 228 ++++++++++++++------------ tui/internal/controllers/streaming.go | 35 +--- 5 files changed, 152 insertions(+), 147 deletions(-) create mode 100644 Docs/Streaming_Flow.md diff --git a/Docs/Streaming_Flow.md b/Docs/Streaming_Flow.md new file mode 100644 index 0000000..3a88ed0 --- /dev/null +++ b/Docs/Streaming_Flow.md @@ -0,0 +1 @@ +# Streaming Flow diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index 8826c4a..c792f4f 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -33,7 +33,8 @@ type IRacing struct { ticker *time.Ticker // ticker will keep polling intervals constant // Stream - streamCh chan telemetry.TelemetryData + wg sync.WaitGroup + // streamCh chan telemetry.TelemetryData streamCancel context.CancelFunc } @@ -50,10 +51,10 @@ func NewIRacingProvider( } provider := &IRacing{ - logger: logger, - SDK: sdk, - data: telemetry.NewTelemetryData(), - streamCh: make(chan telemetry.TelemetryData, 1), + logger: logger, + SDK: sdk, + data: telemetry.NewTelemetryData(), + // streamCh: make(chan telemetry.TelemetryData, 1), // NOTE: This is because I stupidly recorded a test IBT file in 240 // TODO: make this configurable from the user side ticker: time.NewTicker(time.Second / 240), @@ -129,11 +130,14 @@ func (i *IRacing) isDataAvailable() bool { return true } -func (i *IRacing) stream(ctx context.Context) { +func (i *IRacing) stream(ctx context.Context) <-chan telemetry.TelemetryData { i.data.InitialTime = time.Now() + outCh := make(chan telemetry.TelemetryData) + i.wg.Add(1) go func() { - defer close(i.streamCh) + defer i.wg.Done() + defer close(outCh) // Put this into the configuration file consecutiveTimeouts := 0 @@ -153,7 +157,7 @@ func (i *IRacing) stream(ctx context.Context) { // Publish data select { - case i.streamCh <- *i.data: + case outCh <- *i.data: default: // skip this data, don't allow publishers to lag behind } @@ -169,6 +173,8 @@ func (i *IRacing) stream(ctx context.Context) { } } }() + + return outCh } func (i *IRacing) readData() { @@ -205,9 +211,9 @@ func (i *IRacing) Stream() (<-chan telemetry.TelemetryData, error) { ctx, i.streamCancel = context.WithCancel(context.Background()) // Start the stream - i.stream(ctx) + ch := i.stream(ctx) - return i.streamCh, nil + return ch, nil } func (i *IRacing) StopStream() { @@ -216,6 +222,7 @@ func (i *IRacing) StopStream() { } i.streamCancel() + i.wg.Wait() i.streamCancel = nil } diff --git a/services/devices.go b/services/devices.go index c1119ff..714025d 100644 --- a/services/devices.go +++ b/services/devices.go @@ -84,14 +84,6 @@ func (ds *DeviceService) FindDevices() { } } -// func (ds *DeviceService) SubscribeFields() error { -// for _, dev := range ds.Devices { -// fields := dev.RequiredFields() -// } -// -// return nil -// } - func (ds *DeviceService) RegisterDevice(dev peripheral.Peripheral) error { ds.mu.Lock() defer ds.mu.Unlock() diff --git a/services/telemetry.go b/services/telemetry.go index d4bb5db..7af4cb4 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -16,6 +16,8 @@ import ( type TelemetryService struct { logger *slog.Logger devService *DeviceService + // Streaming + isStreaming bool // Concurrency protection mut sync.RWMutex activeProvider telem.TelemetryProvider @@ -66,6 +68,92 @@ func (t *TelemetryService) ProviderMonitor(ctx context.Context) { } } +// Listener Control [START] ---------------------------------------------------- + +func (t *TelemetryService) SubscribeListener(id string, bufferSize int) <-chan telem.TelemetryData { + t.mut.Lock() + defer t.mut.Unlock() + + // NOTE: is this truly necessary? + // return the channel if it already exists + if ch, exists := t.listeners[id]; exists { + return ch + } + + ch := make(chan telem.TelemetryData, bufferSize) + t.listeners[id] = ch + + t.logger.Info("New stream subscriber registered", "id", id) + return ch +} + +func (t *TelemetryService) UnsubscribeListener(id string) { + t.mut.Lock() + defer t.mut.Unlock() + + if ch, exists := t.listeners[id]; exists { + close(ch) + delete(t.listeners, id) + t.logger.Info("Stream subscriber removed", "id", id) + } +} + +func (t *TelemetryService) SubscribeToFields() []telem.FieldID { + seen := make(map[telemetry.FieldID]struct{}) + var allFields []telemetry.FieldID + + for _, dev := range t.devService.Devices { + for _, field := range dev.RequiredFields() { + if _, exists := seen[field]; !exists { + seen[field] = struct{}{} + allFields = append(allFields, field) + } + } + } + + t.logger.Debug("requested fields", "fields", allFields) + t.activeProvider.Subscribe(allFields) + + return allFields +} + +// Listener Control [END] ------------------------------------------------------ + +// Provider Control [START] ---------------------------------------------------- + +func (t *TelemetryService) HasActiveProvider() bool { + if t.activeProvider == nil { + return false + } + + return true +} + +func (t *TelemetryService) dropActiveProvider() { + if t.cancelForward != nil { + t.cancelForward() + } + + t.activeProvider.StopStream() + t.activeProvider.Close() + t.activeProvider = nil +} + +func (t *TelemetryService) SwitchProvider(newProvider telem.TelemetryProvider) error { + t.mut.Lock() + defer t.mut.Unlock() + + // Clean up the current to be old provider + if t.activeProvider != nil { + t.dropActiveProvider() + } + + // Assign the new provider + t.activeProvider = newProvider + + return nil +} + func (t *TelemetryService) onProviderHealthCheckFailed() { // Just restart the whole lookup process go t.FindProvider(t.CtxMonitor) @@ -123,19 +211,46 @@ func (t *TelemetryService) FindProvider(ctx context.Context) { } } -func (t *TelemetryService) SwitchProvider(newProvider telem.TelemetryProvider) error { +// Provider Control [END] ------------------------------------------------------ + +// Streaming Control [START] --------------------------------------------------- + +func (t *TelemetryService) StopStream() { t.mut.Lock() defer t.mut.Unlock() - // Clean up the current to be old provider - if t.activeProvider != nil { - t.dropActiveProvider() + if t.cancelForward != nil { + t.cancelForward() + t.cancelForward = nil } - // Assign the new provider - t.activeProvider = newProvider + t.activeProvider.StopStream() + t.isStreaming = false +} - return nil +func (t *TelemetryService) StartStream() { + slog.Debug("Stream started") + + // Start the new stream + if t.activeProvider == nil { + slog.Debug("there's no active provider. not starting the stream") + return + } + + // Stop the provider healthcheck + t.healthCheckCancel() + + simInCh, _ := t.activeProvider.Stream() + // TODO: the provider needs to be able to tell the data has stopped + // so we can restart the provider lookup routine + + // Create the context so we can control the lifecycle + ctx, cancel := context.WithCancel(context.Background()) + t.cancelForward = cancel + + // Multiplex this data + go t.multiplexData(ctx, simInCh) + t.isStreaming = true } func (t *TelemetryService) multiplexData(ctx context.Context, dataCh <-chan telem.TelemetryData) { @@ -165,101 +280,8 @@ func (t *TelemetryService) multiplexData(ctx context.Context, dataCh <-chan tele } } -func (t *TelemetryService) dropActiveProvider() { - if t.cancelForward != nil { - t.cancelForward() - } - - t.activeProvider.StopStream() - t.activeProvider.Close() - t.activeProvider = nil +func (t *TelemetryService) IsStreaming() bool { + return t.isStreaming } -func (t *TelemetryService) SubscribeListener(id string, bufferSize int) <-chan telem.TelemetryData { - t.mut.Lock() - defer t.mut.Unlock() - - // NOTE: is this truly necessary? - // return the channel if it already exists - if ch, exists := t.listeners[id]; exists { - return ch - } - - ch := make(chan telem.TelemetryData, bufferSize) - t.listeners[id] = ch - - t.logger.Info("New stream subscriber registered", "id", id) - return ch -} - -func (t *TelemetryService) UnsubscribeListener(id string) { - t.mut.Lock() - defer t.mut.Unlock() - - if ch, exists := t.listeners[id]; exists { - close(ch) - delete(t.listeners, id) - t.logger.Info("Stream subscriber removed", "id", id) - } -} - -func (t *TelemetryService) SubscribeToFields() { - seen := make(map[telemetry.FieldID]struct{}) - var allFields []telemetry.FieldID - - for _, dev := range t.devService.Devices { - for _, field := range dev.RequiredFields() { - if _, exists := seen[field]; !exists { - seen[field] = struct{}{} - allFields = append(allFields, field) - } - } - } - - t.logger.Debug("requested fields", "fields", allFields) - t.activeProvider.Subscribe(allFields) -} - -func (t *TelemetryService) StartStream() { - slog.Debug("Stream started") - - // Start the new stream - if t.activeProvider == nil { - slog.Debug("there's no active provider. not starting the stream") - return - } - - // Stop the provider healthcheck - t.healthCheckCancel() - - simInCh, _ := t.activeProvider.Stream() - // TODO: the provider needs to be able to tell the data has stopped - // so we can restart the provider lookup routine - - // Create the context so we can control the lifecycle - ctx, cancel := context.WithCancel(context.Background()) - t.cancelForward = cancel - - // Multiplex this data - go t.multiplexData(ctx, simInCh) -} - -func (t *TelemetryService) StopStream() { - t.mut.Lock() - defer t.mut.Unlock() - - if t.cancelForward != nil { - t.cancelForward() - t.cancelForward = nil - } - - t.activeProvider.StopStream() -} - -func (t *TelemetryService) HasActiveProvider() bool { - if t.activeProvider == nil { - return false - } - - return true -} +// Streaming Control [END] ----------------------------------------------------- diff --git a/tui/internal/controllers/streaming.go b/tui/internal/controllers/streaming.go index cad0299..3a05dc5 100644 --- a/tui/internal/controllers/streaming.go +++ b/tui/internal/controllers/streaming.go @@ -18,7 +18,7 @@ import ( type StreamingCtrl struct { *Controller - Service *services.DeviceService + DevService *services.DeviceService StreamView *views.StreamToolView Messages chan string Internal chan string @@ -45,18 +45,16 @@ func NewStreamingCtrl( ctrl := &StreamingCtrl{ Controller: base, - Service: devService, + DevService: devService, TelemServ: serTelem, Messages: make(chan string, 10), Internal: make(chan string, 10), TelemetryCh: make(chan telemetry.TelemetryData, 1), Run: false, StreamView: streamView, - isRunning: false, } ctrl.registerHooks() - // ctrl.subscribeListeners() return ctrl } @@ -96,11 +94,11 @@ func (sc *StreamingCtrl) registerHooks() { } func (sc *StreamingCtrl) StartStop() { - if sc.isRunning { + if sc.TelemServ.IsStreaming() { slog.Info("stopping stream") sc.TelemServ.StopStream() - sc.Service.StopStream() + sc.DevService.StopStream() sc.isRunning = false return @@ -110,9 +108,9 @@ func (sc *StreamingCtrl) StartStop() { // NOTE: // Subscribe the only existing device - needs to be discovered by now slog.Debug("setting the data stream for device servie") - sc.Service.SetTelemetryChannel(sc.TelemServ.SubscribeListener("DeviceService", 1)) + sc.DevService.SetTelemetryChannel(sc.TelemServ.SubscribeListener("DeviceService", 1)) - dev, err := sc.Service.GetDevice(uidevice.NAME) + dev, err := sc.DevService.GetDevice(uidevice.NAME) if err == nil { if uiDev, ok := dev.(*uidevice.UIDevice); ok { sc.TelemetryCh = uiDev.DataChannel() @@ -121,7 +119,7 @@ func (sc *StreamingCtrl) StartStop() { } slog.Debug("starting services") - sc.Service.StartStream() + sc.DevService.StartStream() sc.TelemServ.StartStream() sc.isRunning = true @@ -161,24 +159,11 @@ func (sc *StreamingCtrl) updateStream() { // Performance reasoning: this is not used during the high frequency data transmission // so we can get away with using a map for convenience here func (sc *StreamingCtrl) SetInternalState() { - // Acquire the cdashdisplay - // displayIF, err := sc.Service.GetDevice(cdashdisplay.NAME) - // if err != nil { - // sc.Messages <- "failed to get " + cdashdisplay.NAME - // return - // } - // display, ok := displayIF.(*cdashdisplay.CDashDisplay) - // if !ok { - // sc.Messages <- "failed to acquire " + cdashdisplay.NAME - // return - // } - // --- - - sc.TelemServ.SubscribeToFields() + fields := sc.TelemServ.SubscribeToFields() // sc.Messages <- fmt.Sprintf("Subscribed Fields: %+v [%d]\n", fields, len(fields)) // Should I update this? - sc.Messages <- fmt.Sprintf("Subscribed to fields\n") + sc.Messages <- fmt.Sprintf("Subscribed to fields: %+v", fields) } func (sc *StreamingCtrl) listenToUIStream() { @@ -190,8 +175,6 @@ func (sc *StreamingCtrl) listenToUIStream() { } isDrawing.Store(true) - // sc.Logger.Debug("got data", "data", msg) - // Capture locally telemetryMsg := msg From a2e14ba6a90c1c114a9cec111db556544694d2aa Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 18 Sep 2026 15:42:34 +0100 Subject: [PATCH 22/41] applied the same start-stop scheme to the BeamNG provider --- providers/beamng/beamng.go | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/providers/beamng/beamng.go b/providers/beamng/beamng.go index 816635d..f07b933 100644 --- a/providers/beamng/beamng.go +++ b/providers/beamng/beamng.go @@ -28,7 +28,7 @@ type BeamNG struct { updaters [telemetry.MaxFields]func(*telemetry.TelemetryField) // stream control - streamCh chan telemetry.TelemetryData + wg sync.WaitGroup streamCancel context.CancelFunc // timing @@ -46,12 +46,11 @@ func NewBeamNGProvider(logger *slog.Logger, opts *bngsdk.Options) (*BeamNG, erro } provider := &BeamNG{ - logger: logger.With("TelemetryProvider", NAME), - streamCh: make(chan telemetry.TelemetryData, 1), - data: telemetry.NewTelemetryData(), - SDK: beam, - og: &bngsdk.Outgauge{}, - ticker: time.NewTicker(time.Second / 60), + logger: logger.With("TelemetryProvider", NAME), + data: telemetry.NewTelemetryData(), + SDK: beam, + og: &bngsdk.Outgauge{}, + ticker: time.NewTicker(time.Second / 60), } provider.updaters = [telemetry.MaxFields]func(*telemetry.TelemetryField){ @@ -110,9 +109,9 @@ func (b *BeamNG) Stream() (<-chan telemetry.TelemetryData, error) { ctx, b.streamCancel = context.WithCancel(context.Background()) // Start the stream - b.stream(ctx) + ch := b.stream(ctx) - return b.streamCh, nil + return ch, nil } func (b *BeamNG) Subscribe(requestFields []telemetry.FieldID) { @@ -162,7 +161,6 @@ func (b *BeamNG) Subscribe(requestFields []telemetry.FieldID) { func (b *BeamNG) readData() { slog.Debug("READING THIS DATA") - // BUG: getting stuck in here ogSnapshot, err := b.SDK.Update() slog.Debug("THE DATA WAS READ") if err != nil { @@ -193,10 +191,15 @@ func (b *BeamNG) readData() { b.data.LastDataPoll = time.Now() } -func (b *BeamNG) stream(ctx context.Context) { +func (b *BeamNG) stream(ctx context.Context) <-chan telemetry.TelemetryData { b.data.InitialTime = time.Now() + outCh := make(chan telemetry.TelemetryData) + b.wg.Add(1) go func() { + defer b.wg.Done() + defer close(outCh) + for { // Explicitly intercept cancellation select { @@ -205,8 +208,6 @@ func (b *BeamNG) stream(ctx context.Context) { default: } - // NOTE: add a method to check if there's data available, or make this happen - select { case <-ctx.Done(): return @@ -217,7 +218,7 @@ func (b *BeamNG) stream(ctx context.Context) { // Publish data select { - case b.streamCh <- *b.data: + case outCh <- *b.data: slog.Debug("PUBLISHED DATA") default: // skip this data, don't allow publishers to lag behind @@ -225,4 +226,6 @@ func (b *BeamNG) stream(ctx context.Context) { } } }() + + return outCh } From 174b27004f7a8f0ddfd3f833c2bdf0d96e7dd46f Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 18 Sep 2026 16:37:30 +0100 Subject: [PATCH 23/41] added error returns to the SendData method on the peripheral interface --- devices/cdashdisplay/display.go | 27 ++++++++++++++++++--------- devices/uidevice/device.go | 6 ++++-- peripheral/errors.go | 9 +++++++++ peripheral/peripheral.go | 2 +- services/devices.go | 6 +++++- 5 files changed, 37 insertions(+), 13 deletions(-) create mode 100644 peripheral/errors.go diff --git a/devices/cdashdisplay/display.go b/devices/cdashdisplay/display.go index dcb6489..7175bc2 100644 --- a/devices/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -12,6 +12,7 @@ import ( "time" helper "esdi/helpers" + "esdi/peripheral" "esdi/peripheral/communication" "esdi/peripheral/communication/packets" "esdi/peripheral/types" @@ -107,10 +108,12 @@ func NewCDashState() *CDashState { } type CDashDisplay struct { - WT *communication.WalkieTalkie - State *CDashState - fieldToWindows map[telemetry.FieldID][]int16 - bufPool sync.Pool + WT *communication.WalkieTalkie + State *CDashState + fieldToWindows map[telemetry.FieldID][]int16 + bufPool sync.Pool + failedSends int + FailedSendsConsecutiveLimit int } // Connect will try to find and connect to the CDashDisplay @@ -118,7 +121,7 @@ func NewCDashDisplay() (*CDashDisplay, error) { // Look for the port p, err := findDisplayPort() if err != nil { - slog.Info("failed to find cdashdisplay port: %s", err.Error()) + slog.Info("failed to find cdashdisplay port", "reason", err.Error()) return nil, err } @@ -132,6 +135,8 @@ func NewCDashDisplay() (*CDashDisplay, error) { return &b }, }, + failedSends: 0, + FailedSendsConsecutiveLimit: 5, }, nil } @@ -393,12 +398,12 @@ func (d *CDashDisplay) UnloadLayout() error { return nil } -func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) { +func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) error { packet := d.encodePacket(data) bytes, err := helper.StructToBytes(packet) if err != nil { - return + return peripheral.ErrFailureToPackData } curStr := "" @@ -408,7 +413,6 @@ func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) { curStr += fmt.Sprintf("%02x ", byte) if byteCount == 8 { - // slog.Debug(curStr) curStr = "" byteCount = 0 } @@ -417,6 +421,11 @@ func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) { // var ack packets.AckPacket err = d.WT.SendCommand(sendDataCMDID, bytes, nil) if err != nil && err != io.EOF { - return + if d.failedSends == d.FailedSendsConsecutiveLimit { + return peripheral.ErrDeviceTimedOut + } + d.failedSends++ } + + return nil } diff --git a/devices/uidevice/device.go b/devices/uidevice/device.go index c08fd85..4f0ac2e 100644 --- a/devices/uidevice/device.go +++ b/devices/uidevice/device.go @@ -17,9 +17,9 @@ func NewUIDevice() (peripheral.Peripheral, error) { }, nil } -func (uid *UIDevice) SendData(data *telemetry.TelemetryData) { +func (uid *UIDevice) SendData(data *telemetry.TelemetryData) error { if data == nil { - return + return peripheral.ErrInvalidData } select { @@ -27,6 +27,8 @@ func (uid *UIDevice) SendData(data *telemetry.TelemetryData) { default: // Drop frame if buffer is full } + + return nil } func (uid *UIDevice) Name() string { diff --git a/peripheral/errors.go b/peripheral/errors.go new file mode 100644 index 0000000..c2674ba --- /dev/null +++ b/peripheral/errors.go @@ -0,0 +1,9 @@ +package peripheral + +import "errors" + +var ( + ErrInvalidData = errors.New("invalid data") + ErrDeviceTimedOut = errors.New("device timed out") + ErrFailureToPackData = errors.New("failed to pack received data") +) diff --git a/peripheral/peripheral.go b/peripheral/peripheral.go index f7b31e5..21379af 100644 --- a/peripheral/peripheral.go +++ b/peripheral/peripheral.go @@ -17,7 +17,7 @@ const ( type Peripheral interface { Name() string - SendData(*telemetry.TelemetryData) + SendData(*telemetry.TelemetryData) error RequiredFields() []telemetry.FieldID } diff --git a/services/devices.go b/services/devices.go index 714025d..8ea1a3c 100644 --- a/services/devices.go +++ b/services/devices.go @@ -159,7 +159,11 @@ func (ds *DeviceService) transmit(ctx context.Context) { // the data locked ds.mu.RLock() for _, dev := range ds.Devices { - dev.SendData(&data) + err := dev.SendData(&data) + if err == peripheral.ErrDeviceTimedOut { + // What do we do here? + // TODO: somehow we need to handle reconnection + } } ds.mu.RUnlock() From a5c465a2039d3d11601dfa21cf3f9889f13cb126 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Sun, 20 Sep 2026 15:06:48 +0100 Subject: [PATCH 24/41] has way too many things In short: added the ability to detect when a device has disconnected. From this we have to achieve a way of: - reconnecting the device - re-subscribing to the fields it needs (it should already be subscribed since the ESDI didn't stop tho - but for the sake of it, or in case a device joins later) - start sending data to it (which should be automatic given how we are handling the devices) --- cmd/repl.go | 180 +++++++------- devices/cdashdisplay/display.go | 8 + devices/device.go | 2 +- devices/uidevice/device.go | 8 + peripheral/communication/walkieTalkie.go | 33 +-- peripheral/peripheral.go | 1 + providers/iracing/iracing.go | 4 +- services/devices.go | 102 +++----- services/devices_lookup.go | 222 ++++++++++++++++++ services/telemetry.go | 2 +- .../controllers/cdashdisplay_layout.go | 14 +- .../cdashdisplay_layout_moveTool.go | 4 +- tui/internal/controllers/device.go | 2 +- tui/internal/controllers/streaming.go | 2 +- 14 files changed, 387 insertions(+), 197 deletions(-) create mode 100644 services/devices_lookup.go diff --git a/cmd/repl.go b/cmd/repl.go index 503783e..7467a0e 100644 --- a/cmd/repl.go +++ b/cmd/repl.go @@ -1,103 +1,97 @@ package cmd import ( - "esdi/peripheral" - "fmt" - "strconv" - - repl "github.com/ESilva15/ESgoRepl" - "github.com/spf13/cobra" ) func replCmdAction(cmd *cobra.Command, args []string) { - r := repl.NewREPL(repl.REPLCfg{ - PS1: "\rESDI > ", - }) - - perClerk := peripheral.NewPeripheralDeviceClerk() - - discoverDevicesREPLCmd := repl.Command{ - Name: "discover", - Usage: "discovers connected devices", - Action: func(r *repl.REPL, args []string) error { - err := perClerk.FindDevices() - if err != nil { - return err - } - - return nil - }, - } - - listDevicesREPLCmd := repl.Command{ - Name: "list", - Usage: "lists connected devices", - Action: func(r *repl.REPL, args []string) error { - _ = perClerk.ListDevices() - - return nil - }, - } - - listDeviceAPIREPLCmd := repl.Command{ - Name: "v-api", - Usage: "shows API of a device - pass its ID", - Action: func(r *repl.REPL, args []string) error { - // We should add this to the REPL instead - if len(args) < 1 { - return fmt.Errorf("requires at least on argument") - } - - // First and only argument should be the ID of the device we want to use - targetID, err := strconv.ParseInt(args[0], 10, 0) - if err != nil { - return err - } - - err = perClerk.ListDeviceAPI(uint8(targetID)) - if err != nil { - fmt.Println("failed to view device API: ", err.Error()) - } - - return nil - }, - } - - runDeviceAPIREPLCmd := repl.Command{ - Name: "v-run", - Usage: "runs a funcion of a device - pass its ID and function name", - Action: func(r *repl.REPL, args []string) error { - // We should add this to the REPL instead - if len(args) < 3 { - return fmt.Errorf("requires at least on argument") - } - - // First and only argument should be the ID of the device we want to use - targetID, err := strconv.ParseInt(args[0], 10, 0) - if err != nil { - return err - } - - fnName := args[1] - fnArgs := args[2:] - - err = perClerk.RunDeviceFunction(uint8(targetID), fnName, fnArgs) - if err != nil { - return err - } - - return nil - }, - } - - r.RegisterCMD(discoverDevicesREPLCmd) - r.RegisterCMD(listDevicesREPLCmd) - r.RegisterCMD(listDeviceAPIREPLCmd) - r.RegisterCMD(runDeviceAPIREPLCmd) - - r.Start() - r.Close() + // r := repl.NewREPL(repl.REPLCfg{ + // PS1: "\rESDI > ", + // }) + // + // perClerk := peripheral.NewPeripheralDeviceClerk() + // + // discoverDevicesREPLCmd := repl.Command{ + // Name: "discover", + // Usage: "discovers connected devices", + // Action: func(r *repl.REPL, args []string) error { + // err := perClerk.FindDevices() + // if err != nil { + // return err + // } + // + // return nil + // }, + // } + // + // listDevicesREPLCmd := repl.Command{ + // Name: "list", + // Usage: "lists connected devices", + // Action: func(r *repl.REPL, args []string) error { + // _ = perClerk.ListDevices() + // + // return nil + // }, + // } + // + // listDeviceAPIREPLCmd := repl.Command{ + // Name: "v-api", + // Usage: "shows API of a device - pass its ID", + // Action: func(r *repl.REPL, args []string) error { + // // We should add this to the REPL instead + // if len(args) < 1 { + // return fmt.Errorf("requires at least on argument") + // } + // + // // First and only argument should be the ID of the device we want to use + // targetID, err := strconv.ParseInt(args[0], 10, 0) + // if err != nil { + // return err + // } + // + // err = perClerk.ListDeviceAPI(uint8(targetID)) + // if err != nil { + // fmt.Println("failed to view device API: ", err.Error()) + // } + // + // return nil + // }, + // } + // + // runDeviceAPIREPLCmd := repl.Command{ + // Name: "v-run", + // Usage: "runs a funcion of a device - pass its ID and function name", + // Action: func(r *repl.REPL, args []string) error { + // // We should add this to the REPL instead + // if len(args) < 3 { + // return fmt.Errorf("requires at least on argument") + // } + // + // // First and only argument should be the ID of the device we want to use + // targetID, err := strconv.ParseInt(args[0], 10, 0) + // if err != nil { + // return err + // } + // + // fnName := args[1] + // fnArgs := args[2:] + // + // err = perClerk.RunDeviceFunction(uint8(targetID), fnName, fnArgs) + // if err != nil { + // return err + // } + // + // return nil + // }, + // } + // + // r.RegisterCMD(discoverDevicesREPLCmd) + // r.RegisterCMD(listDevicesREPLCmd) + // r.RegisterCMD(listDeviceAPIREPLCmd) + // r.RegisterCMD(runDeviceAPIREPLCmd) + // + // r.Start() + // r.Close() } // removeLabelCmd represents the removeLabel command diff --git a/devices/cdashdisplay/display.go b/devices/cdashdisplay/display.go index 7175bc2..267c86d 100644 --- a/devices/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -140,6 +140,14 @@ func NewCDashDisplay() (*CDashDisplay, error) { }, nil } +func (cds *CDashDisplay) Close() error { + // if cds.WT != nil { + // cds.Close() + // } + + return nil +} + func (d *CDashDisplay) SendCommand() { } diff --git a/devices/device.go b/devices/device.go index 9318cac..84ab486 100644 --- a/devices/device.go +++ b/devices/device.go @@ -12,7 +12,7 @@ type Device struct { Discover func() (peripheral.Peripheral, error) } -var List map[string]Device = map[string]Device{ +var List map[string]*Device = map[string]*Device{ uidevice.NAME: { Name: uidevice.NAME, Discover: DiscoverUIDevice, diff --git a/devices/uidevice/device.go b/devices/uidevice/device.go index 4f0ac2e..763f759 100644 --- a/devices/uidevice/device.go +++ b/devices/uidevice/device.go @@ -17,6 +17,14 @@ func NewUIDevice() (peripheral.Peripheral, error) { }, nil } +func (uid *UIDevice) Close() error { + if uid.dataChan != nil { + close(uid.dataChan) + } + + return nil +} + func (uid *UIDevice) SendData(data *telemetry.TelemetryData) error { if data == nil { return peripheral.ErrInvalidData diff --git a/peripheral/communication/walkieTalkie.go b/peripheral/communication/walkieTalkie.go index e5503b6..fde5936 100644 --- a/peripheral/communication/walkieTalkie.go +++ b/peripheral/communication/walkieTalkie.go @@ -108,6 +108,15 @@ func (wt *WalkieTalkie) sendPacket(cmd types.Command, data any) error { return err } + // slog.Debug("# START ########################################################") + // slog.Debug(fmt.Sprintf("StartMarker: %02x", constvar.StartOfText)) + // slog.Debug(fmt.Sprintf("CMD: %02x", cmd)) + // slog.Debug(fmt.Sprintf("Len: %d", len(payload))) + // slog.Debug(fmt.Sprintf("Payload: %v", payload)) + // slog.Debug(fmt.Sprintf("CRC: %v", CRC8(payload))) + // slog.Debug(fmt.Sprintf("EndMarker: %02x", constvar.EndOfText)) + // slog.Debug("-") + packet := CMDDataPacket{ StartMarker: constvar.StartOfText, CMD: cmd, @@ -119,7 +128,9 @@ func (wt *WalkieTalkie) sendPacket(cmd types.Command, data any) error { // Send the payload serializedPacket := packet.Serialize() - // fmt.Fprintf(os.Stderr, "%+v", serializedPacket) + + // slog.Debug("Serialized packet", "packet", packet) + // slog.Debug("# END ##########################################################") _, err = wt.Serial.Write(serializedPacket) if err != nil { @@ -176,21 +187,11 @@ func (wt *WalkieTalkie) readPacket(resp packets.Packet) error { // return nil // } -func (wt *WalkieTalkie) SendCommand(cmd types.Command, payload any, - responseBody packets.Packet) error { - // Prepare the header - // header := header{ - // StartByte: constvar.StartOfText, - // CMD: cmd, - // EndByte: constvar.EndOfText, - // } - - // Send the header - // err := wt.sendHeader(&header) - // if err != nil { - // return err - // } - +func (wt *WalkieTalkie) SendCommand( + cmd types.Command, + payload any, + responseBody packets.Packet, +) error { // Send the body err := wt.sendPacket(cmd, payload) if err != nil { diff --git a/peripheral/peripheral.go b/peripheral/peripheral.go index 21379af..ed667a7 100644 --- a/peripheral/peripheral.go +++ b/peripheral/peripheral.go @@ -19,6 +19,7 @@ type Peripheral interface { Name() string SendData(*telemetry.TelemetryData) error RequiredFields() []telemetry.FieldID + Close() error } type PeripheralDeviceClerk struct { diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index c792f4f..9701f6f 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -54,10 +54,8 @@ func NewIRacingProvider( logger: logger, SDK: sdk, data: telemetry.NewTelemetryData(), - // streamCh: make(chan telemetry.TelemetryData, 1), - // NOTE: This is because I stupidly recorded a test IBT file in 240 // TODO: make this configurable from the user side - ticker: time.NewTicker(time.Second / 240), + ticker: time.NewTicker(time.Second / 60), } provider.updaters = [telemetry.MaxFields]func(*telemetry.TelemetryField){ diff --git a/services/devices.go b/services/devices.go index 8ea1a3c..214208a 100644 --- a/services/devices.go +++ b/services/devices.go @@ -2,32 +2,21 @@ package services import ( "context" - "errors" - "fmt" "log/slog" - "sync" "sync/atomic" - "time" "esdi/devices" "esdi/peripheral" "esdi/telemetry" ) -var ErrPeripheralAlreadyRegistered = errors.New("peripheral is already registered") - -// DeviceService will handle sending the data from the telemetry service to the -// actual devices -// NOTE: create a virtual device and make it be the output window or something so -// we can just add it as a device or whatever instead of being a custom made thing -// that would be pretty cool I think +// DeviceService is the API for the peripherals type DeviceService struct { Logger *slog.Logger // Device discovery - mu sync.RWMutex + PSS *PeripheralStateStore // Store to track peripheral state ctxDiscovery context.Context ctxDiscoveryCancel context.CancelFunc - Devices map[string]peripheral.Peripheral // Strem handling streamCancel context.CancelFunc TelemCh <-chan telemetry.TelemetryData @@ -39,7 +28,7 @@ func NewDeviceService(logger *slog.Logger) *DeviceService { sharedChannel := make(chan string, 10) dev := &DeviceService{ - Devices: make(map[string]peripheral.Peripheral), + PSS: NewPeripheralStateStore(logger.With("Service", "PeripheralStateStore"), devices.List), Logger: logger, Messages: sharedChannel, } @@ -52,68 +41,33 @@ func NewDeviceService(logger *slog.Logger) *DeviceService { return dev } -func (ds *DeviceService) FindDevices() { - // Need to define a list of devices to search for - // For now lets just try to find our cdashdisplay - will think about the rest later - ticker := time.NewTicker(2 * time.Second) - defer ticker.Stop() +// Getters [START] ------------------------------------------------------------- +func (ds *DeviceService) GetDevices() []peripheral.Peripheral { + snapshot := ds.PSS.GetStates() + peripherals := make([]peripheral.Peripheral, 0, len(snapshot)) - for { - select { - case <-ds.ctxDiscovery.Done(): - // If requested to cancel we cancel background discovery - return - case <-ticker.C: - for pName, peripheral := range devices.List { - if ds.DeviceExists(pName) { - // We already discovered this device - continue - } - - ds.Logger.Debug("looking for device", "name", pName) - dev, err := peripheral.Discover() - if err != nil { - ds.Logger.Debug("didn't find device", "name", pName) - continue - } - - // Register the device we just found - ds.RegisterDevice(dev) - } + for _, state := range snapshot { + if state.State != DeviceIsConnected { + continue } - } -} - -func (ds *DeviceService) RegisterDevice(dev peripheral.Peripheral) error { - ds.mu.Lock() - defer ds.mu.Unlock() - - if ds.DeviceExists(dev.Name()) { - return ErrPeripheralAlreadyRegistered + peripherals = append(peripherals, state.Peripheral) } - ds.Devices[dev.Name()] = dev - - return nil + return peripherals } -func (ds *DeviceService) GetDevice(name string) (peripheral.Peripheral, error) { - val, ok := ds.Devices[name] - if !ok { - return nil, fmt.Errorf("device `%s` couldn't be found", name) - } - - return val, nil +func (ds *DeviceService) GetPeripheral(pname string) (peripheral.Peripheral, error) { + return ds.PSS.GetPeripheral(pname) } -func (ds *DeviceService) DeviceExists(name string) bool { - if _, ok := ds.Devices[name]; !ok { - return false - } - - return true +func (ds *DeviceService) PeripheralExists(pname string) bool { + _, err := ds.PSS.GetPeripheral(pname) + return err == nil } +// Getters [END] --------------------------------------------------------------- + +// Actions [START] ------------------------------------------------------------- func (ds *DeviceService) StartStream() { // NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this var ctx context.Context @@ -136,6 +90,8 @@ func (ds *DeviceService) SetTelemetryChannel(ch <-chan telemetry.TelemetryData) ds.TelemCh = ch } +// Actions [END] --------------------------------------------------------------- + // transmit will send the data to the devices themselves func (ds *DeviceService) transmit(ctx context.Context) { var isSending atomic.Bool @@ -157,15 +113,17 @@ func (ds *DeviceService) transmit(ctx context.Context) { // TODO: make a copy of the data and send that copy instead of keeping // the data locked - ds.mu.RLock() - for _, dev := range ds.Devices { - err := dev.SendData(&data) + for _, dev := range ds.PSS.GetStates() { + if dev.State != DeviceIsConnected { + continue + } + + err := dev.Peripheral.SendData(&data) + if err == peripheral.ErrDeviceTimedOut { - // What do we do here? - // TODO: somehow we need to handle reconnection + ds.onDeviceTimedOut(dev.device.Name) } } - ds.mu.RUnlock() isSending.Store(false) } diff --git a/services/devices_lookup.go b/services/devices_lookup.go new file mode 100644 index 0000000..98e7655 --- /dev/null +++ b/services/devices_lookup.go @@ -0,0 +1,222 @@ +package services + +import ( + "errors" + "log/slog" + "maps" + "sync" + "time" + + "esdi/devices" + "esdi/peripheral" +) + +var ( + ErrPeripheralAlreadyRegistered = errors.New("peripheral is already registered") + ErrNoSuchDevice = errors.New("device doesn't exist") + ErrDeviceIsNotConnected = errors.New("device isn't connected") +) + +type DeviceState = uint8 + +const ( + DeviceTimedOut uint8 = iota + DeviceIsConnected + DeviceIsDisconnected + DeviceReconnected +) + +type PeripheralState struct { + device *devices.Device + Peripheral peripheral.Peripheral + State DeviceState +} + +func NewPeripheralState( + dev *devices.Device, + peripheral peripheral.Peripheral, + state DeviceState, +) *PeripheralState { + perState := PeripheralState{ + device: dev, + Peripheral: peripheral, + State: state, + } + + return &perState +} + +type PeripheralStateStore struct { + Logger *slog.Logger + mu sync.RWMutex + store map[string]*PeripheralState +} + +func NewPeripheralStateStore( + nLogger *slog.Logger, + devList map[string]*devices.Device, +) *PeripheralStateStore { + store := PeripheralStateStore{ + Logger: nLogger, + store: make(map[string]*PeripheralState), + } + + for _, dev := range devList { + store.AddDevice(dev) + } + + return &store +} + +func (pss *PeripheralStateStore) GetStates() map[string]*PeripheralState { + pss.mu.RLock() + defer pss.mu.RUnlock() + + return maps.Clone(pss.store) +} + +func (pss *PeripheralStateStore) GetState(pname string) (*PeripheralState, error) { + if !pss.DeviceExists(pname) { + return nil, ErrNoSuchDevice + } + + pss.mu.RLock() + defer pss.mu.RUnlock() + return pss.store[pname], nil +} + +func (pss *PeripheralStateStore) GetPeripheral(pname string) (peripheral.Peripheral, error) { + state, err := pss.GetState(pname) + if err != nil { + return nil, err + } + + if state.State != DeviceIsConnected { + return nil, ErrDeviceIsNotConnected + } + + return state.Peripheral, nil +} + +// AddDevice adds a new device for tracking +func (pss *PeripheralStateStore) AddDevice(dev *devices.Device) error { + if pss.DeviceExists(dev.Name) { + return ErrPeripheralAlreadyRegistered + } + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[dev.Name] = NewPeripheralState(dev, nil, DeviceIsDisconnected) + + return nil +} + +// DeviceExists returns whether the store is already tracking `pname` +func (pss *PeripheralStateStore) DeviceExists(pname string) bool { + pss.mu.RLock() + defer pss.mu.RUnlock() + + if _, ok := pss.store[pname]; ok { + return true + } + + return false +} + +// DeleteDevice deletes `pname` from tracking +func (pss *PeripheralStateStore) DeleteDevice(pname string) error { + if !pss.DeviceExists(pname) { + return ErrNoSuchDevice + } + + pss.mu.Lock() + defer pss.mu.Unlock() + + delete(pss.store, pname) + + return nil +} + +// "Events" [START] ------------------------------------------------------------ +func (ds *DeviceService) onDeviceTimedOut(pname string) { + // We need to deregister the device + ds.PSS.setDeviceTimedOut(pname) +} + +// "Events" [END] -------------------------------------------------------------- + +// Device State Handling [START] ----------------------------------------------- +func (pss *PeripheralStateStore) setDeviceConnected(pname string, per peripheral.Peripheral) { + pss.Logger.Info("found device", "device", pname) + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].Peripheral = per + pss.store[pname].State = DeviceIsConnected +} + +func (pss *PeripheralStateStore) setDeviceTimedOut(pname string) { + pss.Logger.Info("device timed out", "device", pname) + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].Peripheral = nil + pss.store[pname].State = DeviceTimedOut +} + +func (pss *PeripheralStateStore) setDeviceReconnected(pname string, per peripheral.Peripheral) { + pss.Logger.Info("device reconnecting", "device", pname) + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].Peripheral = per + pss.store[pname].State = DeviceReconnected +} + +// Device State Handling [END] ------------------------------------------------- + +// Device Handling [START] ----------------------------------------------------- +func (pss *PeripheralStateStore) HandleDeviceState() { + peripherals := pss.GetStates() + + for pName, pState := range peripherals { + switch pState.State { + case DeviceIsDisconnected: + pss.Logger.Debug("looking for device", "name", pName) + dev, err := pState.device.Discover() + if err != nil { + continue + } + + // Register the device we just found + pss.setDeviceConnected(pName, dev) + case DeviceIsConnected: + // Need to check if its streaming, if its not streaming than we have to do a healthcheck + pss.Logger.Debug("Device is connected. Normal", "device", pName) + case DeviceReconnected: + // If the device has reconnected we need to reset the device and then set it as connected + pss.Logger.Debug("Device has reconnected. Clearing up state", "device", pName) + case DeviceTimedOut: + // If the device has timed out we need to re-discover it or something + pss.Logger.Debug("Device is timed out. Attempting to recconect", "device", pName) + } + } +} + +// Device Handling [END] ------------------------------------------------------- + +// FindDevices is a routine that goes over the devices in the PeripheralStateStore +// and handles their state accordingly +func (ds *DeviceService) FindDevices() { + ticker := time.NewTicker(2 * time.Second) + defer ticker.Stop() + + for { + select { + case <-ds.ctxDiscovery.Done(): + return + case <-ticker.C: + ds.PSS.HandleDeviceState() + } + } +} diff --git a/services/telemetry.go b/services/telemetry.go index 7af4cb4..674be83 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -102,7 +102,7 @@ func (t *TelemetryService) SubscribeToFields() []telem.FieldID { seen := make(map[telemetry.FieldID]struct{}) var allFields []telemetry.FieldID - for _, dev := range t.devService.Devices { + for _, dev := range t.devService.GetDevices() { for _, field := range dev.RequiredFields() { if _, exists := seen[field]; !exists { seen[field] = struct{}{} diff --git a/tui/internal/controllers/cdashdisplay_layout.go b/tui/internal/controllers/cdashdisplay_layout.go index 6400b47..f90f6a7 100644 --- a/tui/internal/controllers/cdashdisplay_layout.go +++ b/tui/internal/controllers/cdashdisplay_layout.go @@ -211,7 +211,7 @@ func (lc *LayoutController) createWindow() { } // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -321,7 +321,7 @@ func (lc *LayoutController) newWindowAction() { func (lc *LayoutController) updateWindowAction(win *cdashdisplay.DesktopUIWindow) { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -347,7 +347,7 @@ func (lc *LayoutController) displayLoadedLayouts() { lc.Logger.Debug("We want to view our layout!") // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -392,7 +392,7 @@ func (lc *LayoutController) getCurrentTreeNodeModel() (*tview.TreeNode, int16, e func (lc *LayoutController) loadLayout() { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -416,7 +416,7 @@ func (lc *LayoutController) loadLayout() { func (lc *LayoutController) unloadLayout() { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -437,7 +437,7 @@ func (lc *LayoutController) unloadLayout() { func (lc *LayoutController) saveLayout() { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -470,7 +470,7 @@ func (lc *LayoutController) deleteWindow() { wID := curNode.GetReference().(int16) // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return diff --git a/tui/internal/controllers/cdashdisplay_layout_moveTool.go b/tui/internal/controllers/cdashdisplay_layout_moveTool.go index ba31690..87487bf 100644 --- a/tui/internal/controllers/cdashdisplay_layout_moveTool.go +++ b/tui/internal/controllers/cdashdisplay_layout_moveTool.go @@ -52,7 +52,7 @@ func (lc *LayoutController) handleMovementCapture(idx int16, } // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return nil @@ -86,7 +86,7 @@ func (lc *LayoutController) handleResizeCapture(idx int16, } // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return nil diff --git a/tui/internal/controllers/device.go b/tui/internal/controllers/device.go index 22c3e73..f0f86a3 100644 --- a/tui/internal/controllers/device.go +++ b/tui/internal/controllers/device.go @@ -67,7 +67,7 @@ func (mc *DeviceController) AddDeviceAPIListItems() { mc.DeviceAPIView.DevAPIList. AddItem("layout", "build a layout for CDashDisplay", func() { // This CDashDisplay specific, only load if we have a CDashDisplay - if !mc.DevService.DeviceExists(cdashdisplay.NAME) { + if !mc.DevService.PeripheralExists(cdashdisplay.NAME) { mc.DevService.Messages <- "CDashDisplay it not loaded yet\n" return } diff --git a/tui/internal/controllers/streaming.go b/tui/internal/controllers/streaming.go index 3a05dc5..9778602 100644 --- a/tui/internal/controllers/streaming.go +++ b/tui/internal/controllers/streaming.go @@ -110,7 +110,7 @@ func (sc *StreamingCtrl) StartStop() { slog.Debug("setting the data stream for device servie") sc.DevService.SetTelemetryChannel(sc.TelemServ.SubscribeListener("DeviceService", 1)) - dev, err := sc.DevService.GetDevice(uidevice.NAME) + dev, err := sc.DevService.GetPeripheral(uidevice.NAME) if err == nil { if uiDev, ok := dev.(*uidevice.UIDevice); ok { sc.TelemetryCh = uiDev.DataChannel() From 5d5b7bfdc3511aa4def4a1993d726e550ff585b3 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Sun, 20 Sep 2026 21:44:15 +0100 Subject: [PATCH 25/41] working on the peripheral state handling --- devices/cdashdisplay/display.go | 9 +++ devices/device.go | 31 +++++++-- devices/uidevice/device.go | 4 ++ peripheral/peripheral.go | 1 + services/devices_lookup.go | 67 +++++++++++++++++-- .../controllers/cdashdisplay_layout.go | 4 +- 6 files changed, 107 insertions(+), 9 deletions(-) diff --git a/devices/cdashdisplay/display.go b/devices/cdashdisplay/display.go index 267c86d..7c2bd94 100644 --- a/devices/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -437,3 +437,12 @@ func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) error { return nil } + +func (cds *CDashDisplay) Setup() error { + err := cds.LoadLayout("layout.yaml") + if err != nil { + return err + } + + return nil +} diff --git a/devices/device.go b/devices/device.go index 84ab486..33db928 100644 --- a/devices/device.go +++ b/devices/device.go @@ -2,28 +2,33 @@ package devices import ( + "errors" + "esdi/devices/cdashdisplay" "esdi/devices/uidevice" "esdi/peripheral" ) +var ErrInvalidDevice = errors.New("invalid device") + type Device struct { Name string Discover func() (peripheral.Peripheral, error) + // DefaultSetup func(peripheral.Peripheral) error } var List map[string]*Device = map[string]*Device{ uidevice.NAME: { Name: uidevice.NAME, - Discover: DiscoverUIDevice, + Discover: UIDeviceDiscover, }, cdashdisplay.NAME: { Name: cdashdisplay.NAME, - Discover: DiscoverCDashDisplay, + Discover: CDashDisplayDiscover, }, } -func DiscoverUIDevice() (peripheral.Peripheral, error) { +func UIDeviceDiscover() (peripheral.Peripheral, error) { uidev, err := uidevice.NewUIDevice() if err != nil { return nil, err @@ -32,7 +37,11 @@ func DiscoverUIDevice() (peripheral.Peripheral, error) { return uidev, nil } -func DiscoverCDashDisplay() (peripheral.Peripheral, error) { +// func UIDeviceSetup(peripheral peripheral.Peripheral) error { +// return nil +// } + +func CDashDisplayDiscover() (peripheral.Peripheral, error) { // Create a cdashdisplay display, err := cdashdisplay.NewCDashDisplay() if err != nil { @@ -41,3 +50,17 @@ func DiscoverCDashDisplay() (peripheral.Peripheral, error) { return display, nil } + +// func CDashDisplaySetup(peripheral peripheral.Peripheral) error { +// cdash, ok := peripheral.(*cdashdisplay.CDashDisplay) +// if !ok { +// return ErrInvalidDevice +// } +// +// err := cdash.LoadLayout("layout.yaml") +// if err != nil { +// return err +// } +// +// return nil +// } diff --git a/devices/uidevice/device.go b/devices/uidevice/device.go index 763f759..4b0b0cd 100644 --- a/devices/uidevice/device.go +++ b/devices/uidevice/device.go @@ -25,6 +25,10 @@ func (uid *UIDevice) Close() error { return nil } +func (uid *UIDevice) Setup() error { + return nil +} + func (uid *UIDevice) SendData(data *telemetry.TelemetryData) error { if data == nil { return peripheral.ErrInvalidData diff --git a/peripheral/peripheral.go b/peripheral/peripheral.go index ed667a7..0984667 100644 --- a/peripheral/peripheral.go +++ b/peripheral/peripheral.go @@ -17,6 +17,7 @@ const ( type Peripheral interface { Name() string + Setup() error SendData(*telemetry.TelemetryData) error RequiredFields() []telemetry.FieldID Close() error diff --git a/services/devices_lookup.go b/services/devices_lookup.go index 98e7655..6968784 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -15,6 +15,7 @@ var ( ErrPeripheralAlreadyRegistered = errors.New("peripheral is already registered") ErrNoSuchDevice = errors.New("device doesn't exist") ErrDeviceIsNotConnected = errors.New("device isn't connected") + ErrFailedToSetupPeripheral = errors.New("peripheral setup failed") ) type DeviceState = uint8 @@ -176,6 +177,56 @@ func (pss *PeripheralStateStore) setDeviceReconnected(pname string, per peripher // Device State Handling [END] ------------------------------------------------- // Device Handling [START] ----------------------------------------------------- +func (pss *PeripheralStateStore) discoverPeripheral( + pname string, + onDiscovery func(pName string, peripheral peripheral.Peripheral), +) error { + state, err := pss.GetState(pname) + if err != nil { + pss.Logger.Error("Can't reconnect device", "device", pname, "error", err) + return err + } + + dev, err := state.device.Discover() + if err != nil { + return err + } + + // Register the device we just found + onDiscovery(pname, dev) + + return nil +} + +func (pss *PeripheralStateStore) handleDeviceTimedOut(pname string) error { + err := pss.discoverPeripheral(pname, pss.setDeviceReconnected) + if err != nil { + // Log something + return err + } + + return nil +} + +func (pss *PeripheralStateStore) handleDeviceReconnected(pname string) error { + // The device has reconnected, but we must set its state again + state, err := pss.GetState(pname) + if err != nil { + return err + } + + err = state.Peripheral.Setup() + if err != nil { + pss.Logger.Error("failed to setup peripheral", "peripheral", pname, "error", err) + return ErrFailedToSetupPeripheral + } + + // Around here I believe I need to swap the states so the peripheral is setup + pss.setDeviceConnected(pname, state.Peripheral) + + return nil +} + func (pss *PeripheralStateStore) HandleDeviceState() { peripherals := pss.GetStates() @@ -183,22 +234,30 @@ func (pss *PeripheralStateStore) HandleDeviceState() { switch pState.State { case DeviceIsDisconnected: pss.Logger.Debug("looking for device", "name", pName) - dev, err := pState.device.Discover() + err := pss.discoverPeripheral(pName, pss.setDeviceConnected) if err != nil { + // Log something continue } - - // Register the device we just found - pss.setDeviceConnected(pName, dev) case DeviceIsConnected: // Need to check if its streaming, if its not streaming than we have to do a healthcheck pss.Logger.Debug("Device is connected. Normal", "device", pName) case DeviceReconnected: // If the device has reconnected we need to reset the device and then set it as connected pss.Logger.Debug("Device has reconnected. Clearing up state", "device", pName) + err := pss.handleDeviceReconnected(pName) + if err != nil { + pss.Logger.Error("device reconnection handler failed", "error", err) + continue + } case DeviceTimedOut: // If the device has timed out we need to re-discover it or something pss.Logger.Debug("Device is timed out. Attempting to recconect", "device", pName) + err := pss.handleDeviceTimedOut(pName) + if err != nil { + pss.Logger.Error("device timing out handler failed", "error", err) + continue + } } } } diff --git a/tui/internal/controllers/cdashdisplay_layout.go b/tui/internal/controllers/cdashdisplay_layout.go index f90f6a7..a1a12b6 100644 --- a/tui/internal/controllers/cdashdisplay_layout.go +++ b/tui/internal/controllers/cdashdisplay_layout.go @@ -35,6 +35,7 @@ func NewLayoutController(base *Controller, service *services.DeviceService) *Lay DevService: service, MoveToolState: &windowManipState{Mode: moveMode}, // SelectedLayout: "beamng.yaml", + // TODO: this can't be here - the service/peripheral needs to know about it SelectedLayout: "layout.yaml", } @@ -404,7 +405,8 @@ func (lc *LayoutController) loadLayout() { } // --- - // We would get the layout path from somewhere but for nots its layout.yaml + // TODO: This can happen here, but we need to address how the layout is gotten + // THE UI SHOULD SET STATE IN THE SERVICES ONLY err = display.LoadLayout(lc.SelectedLayout) if err != nil { lc.Messages <- "failed to load layout: " + err.Error() From 263d3c29a36f46da6025f7c2c656c5b2c47f0804 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Mon, 21 Sep 2026 11:45:10 +0100 Subject: [PATCH 26/41] services decoupling --- devices/cdashdisplay/events.go | 9 ++++++ devices/uidevice/events.go | 9 ++++++ peripheral/peripheral.go | 2 ++ services/devices.go | 12 ++++---- services/devices_events.go | 1 + services/devices_lookup.go | 11 +++++-- services/services.go | 32 +++++++++++++++++++++ services/telemetry.go | 40 ++++++-------------------- services/telemetry_events.go | 41 +++++++++++++++++++++++++++ tui/internal/controllers/device.go | 21 +++++++------- tui/internal/controllers/streaming.go | 5 ---- tui/tui.go | 14 ++++----- 12 files changed, 134 insertions(+), 63 deletions(-) create mode 100644 devices/cdashdisplay/events.go create mode 100644 devices/uidevice/events.go create mode 100644 services/devices_events.go create mode 100644 services/telemetry_events.go diff --git a/devices/cdashdisplay/events.go b/devices/cdashdisplay/events.go new file mode 100644 index 0000000..365e32b --- /dev/null +++ b/devices/cdashdisplay/events.go @@ -0,0 +1,9 @@ +package cdashdisplay + +func (cds *CDashDisplay) OnLoad() error { + return nil +} + +func (cds *CDashDisplay) OnTelemetryProviderFound() error { + return nil +} diff --git a/devices/uidevice/events.go b/devices/uidevice/events.go new file mode 100644 index 0000000..f43b2a4 --- /dev/null +++ b/devices/uidevice/events.go @@ -0,0 +1,9 @@ +package uidevice + +func (uid *UIDevice) OnLoad() error { + return nil +} + +func (uid *UIDevice) OnTelemetryProviderFound() error { + return nil +} diff --git a/peripheral/peripheral.go b/peripheral/peripheral.go index 0984667..fc918ee 100644 --- a/peripheral/peripheral.go +++ b/peripheral/peripheral.go @@ -20,6 +20,8 @@ type Peripheral interface { Setup() error SendData(*telemetry.TelemetryData) error RequiredFields() []telemetry.FieldID + OnLoad() error + OnTelemetryProviderFound() error Close() error } diff --git a/services/devices.go b/services/devices.go index 214208a..8219254 100644 --- a/services/devices.go +++ b/services/devices.go @@ -22,15 +22,17 @@ type DeviceService struct { TelemCh <-chan telemetry.TelemetryData // Output Messages chan string + // Callbacks + OnTelemetryProviderDiscovered func() } -func NewDeviceService(logger *slog.Logger) *DeviceService { - sharedChannel := make(chan string, 10) - +func NewDeviceService(logger *slog.Logger, msg chan string) *DeviceService { dev := &DeviceService{ - PSS: NewPeripheralStateStore(logger.With("Service", "PeripheralStateStore"), devices.List), + PSS: NewPeripheralStateStore( + logger.With("Service", "PeripheralStateStore"), devices.List, msg, + ), Logger: logger, - Messages: sharedChannel, + Messages: msg, } // Start the routine that looks for devices - should always be running in the background diff --git a/services/devices_events.go b/services/devices_events.go new file mode 100644 index 0000000..5e568ea --- /dev/null +++ b/services/devices_events.go @@ -0,0 +1 @@ +package services diff --git a/services/devices_lookup.go b/services/devices_lookup.go index 6968784..febabd1 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -2,6 +2,7 @@ package services import ( "errors" + "fmt" "log/slog" "maps" "sync" @@ -51,15 +52,19 @@ type PeripheralStateStore struct { Logger *slog.Logger mu sync.RWMutex store map[string]*PeripheralState + // Messaging for UI and stuff + Messages chan string } func NewPeripheralStateStore( nLogger *slog.Logger, devList map[string]*devices.Device, + msg chan string, ) *PeripheralStateStore { store := PeripheralStateStore{ - Logger: nLogger, - store: make(map[string]*PeripheralState), + Logger: nLogger, + store: make(map[string]*PeripheralState), + Messages: msg, } for _, dev := range devList { @@ -154,6 +159,8 @@ func (pss *PeripheralStateStore) setDeviceConnected(pname string, per peripheral defer pss.mu.Unlock() pss.store[pname].Peripheral = per pss.store[pname].State = DeviceIsConnected + + pss.Messages <- fmt.Sprintf("Device successfuly connected: %s\n", pname) } func (pss *PeripheralStateStore) setDeviceTimedOut(pname string) { diff --git a/services/services.go b/services/services.go index bb02e66..d76cb62 100644 --- a/services/services.go +++ b/services/services.go @@ -1,2 +1,34 @@ // Package services interacts with the other libraries required for this UI package services + +import ( + "errors" + "log/slog" +) + +type Orchestrator struct { + DeviceService *DeviceService + TelemetryService *TelemetryService + Messages chan string +} + +func NewOrchestrator(logger *slog.Logger) (*Orchestrator, error) { + msg := make(chan string, 10) + + devService := NewDeviceService(logger.With("service", "DeviceService"), msg) + + telemService := NewTelemetryService(logger.With("service", "TelemetryService"), devService, msg) + if telemService == nil { + return nil, errors.New("failed to create telemetry service") + } + + go telemService.FindProvider(telemService.CtxMonitor) + + // Need to setup the callbacks on the services + + return &Orchestrator{ + DeviceService: devService, + TelemetryService: telemService, + Messages: msg, + }, nil +} diff --git a/services/telemetry.go b/services/telemetry.go index 674be83..679a85b 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -32,16 +32,21 @@ type TelemetryService struct { cancelMonitor context.CancelFunc CtxHealthcheck context.Context healthCheckCancel context.CancelFunc + // Callbacks + OnDevicesDiscovered func() } -func NewTelemetryService(logger *slog.Logger, devServo *DeviceService) *TelemetryService { - sharedChannel := make(chan string, 10) +func NewTelemetryService( + logger *slog.Logger, + devServo *DeviceService, + msg chan string, +) *TelemetryService { newService := &TelemetryService{ logger: logger, isConnected: false, devService: devServo, listeners: make(map[string]chan telem.TelemetryData), - Messages: sharedChannel, + Messages: msg, } newService.CtxMonitor, newService.cancelMonitor = context.WithCancel(context.Background()) @@ -59,6 +64,7 @@ func (t *TelemetryService) ProviderMonitor(ctx context.Context) { case <-ticker.C: slog.Info("checking if provider is still running") if !t.activeProvider.IsAlive(500 * time.Millisecond) { + t.Messages <- "Healthcheck on provider failing. Dropping provider.\n" slog.Warn("provider healthcheck failed") t.dropActiveProvider() t.onProviderHealthCheckFailed() @@ -154,34 +160,6 @@ func (t *TelemetryService) SwitchProvider(newProvider telem.TelemetryProvider) e return nil } -func (t *TelemetryService) onProviderHealthCheckFailed() { - // Just restart the whole lookup process - go t.FindProvider(t.CtxMonitor) -} - -func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) { - // Attach to the provider - t.logger.Info("found provider for " + prov.Name()) - err := t.SwitchProvider(prov) - if err != nil { - t.logger.Error("failed to switch to provider onFindProvider", "err", err) - return - } - - // Create a routine to poll this provider while we wait to start the stream or pause it - t.CtxHealthcheck, t.healthCheckCancel = context.WithCancel(context.Background()) - go t.ProviderMonitor(t.CtxHealthcheck) -} - -func (t *TelemetryService) onProviderStopsMidStream() { - // clear the current provider - // TODO: now we need to also clear the devices to restart everything, - // if the stream stopped we have to restart the devices and everything - t.logger.Info("cleaning dropped provider and restarting lookup service") - t.dropActiveProvider() - go t.FindProvider(t.CtxMonitor) -} - // TODO: add some way of retriggering this. Currently it should: // start monitoring on startup -> find provider -> stop monitoring (when game closes for example) func (t *TelemetryService) FindProvider(ctx context.Context) { diff --git a/services/telemetry_events.go b/services/telemetry_events.go new file mode 100644 index 0000000..0899855 --- /dev/null +++ b/services/telemetry_events.go @@ -0,0 +1,41 @@ +package services + +import ( + "context" + "fmt" + + telem "esdi/telemetry" +) + +func (t *TelemetryService) onProviderHealthCheckFailed() { + // Just restart the whole lookup process + go t.FindProvider(t.CtxMonitor) +} + +func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) { + // Attach to the provider + t.logger.Info("found provider for " + prov.Name()) + t.Messages <- fmt.Sprintf("Found provider \"%s\"\n", prov.Name()) + err := t.SwitchProvider(prov) + if err != nil { + t.Messages <- fmt.Sprintf("Failed to switch to provider: %+v\n", err.Error()) + t.logger.Error("failed to switch to provider onFindProvider", "err", err) + return + } + + // Start the healthcheck on our provider so we can drop it if it stops + t.CtxHealthcheck, t.healthCheckCancel = context.WithCancel(context.Background()) + go t.ProviderMonitor(t.CtxHealthcheck) + + // Tell the devices service we got a provider +} + +func (t *TelemetryService) onProviderStopsMidStream() { + // clear the current provider + // TODO: now we need to also clear the devices to restart everything, + // if the stream stopped we have to restart the devices and everything + t.Messages <- "Telemetry provider stopped mid stream\n" + t.logger.Info("cleaning dropped provider and restarting lookup service") + t.dropActiveProvider() + go t.FindProvider(t.CtxMonitor) +} diff --git a/tui/internal/controllers/device.go b/tui/internal/controllers/device.go index f0f86a3..9d3d653 100644 --- a/tui/internal/controllers/device.go +++ b/tui/internal/controllers/device.go @@ -16,19 +16,18 @@ type DeviceController struct { DeviceAPIView *views.DeviceAPIView LayoutCtrl *LayoutController StreamCtrl *StreamingCtrl - DevService *serv.DeviceService + Orchestrator *serv.Orchestrator } func NewDeviceController( base *Controller, - devService *serv.DeviceService, - telemService *serv.TelemetryService, + orchestrator *serv.Orchestrator, ) *DeviceController { mc := &DeviceController{ - Controller: base, - LayoutCtrl: NewLayoutController(base, devService), - DevService: devService, - StreamCtrl: NewStreamingCtrl(base, devService, telemService), + Controller: base, + LayoutCtrl: NewLayoutController(base, orchestrator.DeviceService), + Orchestrator: orchestrator, + StreamCtrl: NewStreamingCtrl(base, orchestrator.DeviceService, orchestrator.TelemetryService), } return mc @@ -57,7 +56,7 @@ func (mc *DeviceController) setDeviceAPIViewEvents() { SetInputCapture(func(ev *tcell.EventKey) *tcell.EventKey { switch ev.Rune() { case 'r': - go mc.DevService.FindDevices() + go mc.Orchestrator.DeviceService.FindDevices() } return ev }) @@ -67,8 +66,8 @@ func (mc *DeviceController) AddDeviceAPIListItems() { mc.DeviceAPIView.DevAPIList. AddItem("layout", "build a layout for CDashDisplay", func() { // This CDashDisplay specific, only load if we have a CDashDisplay - if !mc.DevService.PeripheralExists(cdashdisplay.NAME) { - mc.DevService.Messages <- "CDashDisplay it not loaded yet\n" + if !mc.Orchestrator.DeviceService.PeripheralExists(cdashdisplay.NAME) { + mc.Orchestrator.DeviceService.Messages <- "CDashDisplay it not loaded yet\n" return } @@ -116,7 +115,7 @@ func (mc *DeviceController) injectControllerCallbacks() { func (mc *DeviceController) injectChannels() { go func() { - for msg := range mc.DevService.Messages { + for msg := range mc.Orchestrator.Messages { mc.PrintToOutputWindow(msg) } }() diff --git a/tui/internal/controllers/streaming.go b/tui/internal/controllers/streaming.go index 9778602..cb3f211 100644 --- a/tui/internal/controllers/streaming.go +++ b/tui/internal/controllers/streaming.go @@ -59,11 +59,6 @@ func NewStreamingCtrl( return ctrl } -// func (sc *StreamingCtrl) subscribeListeners() { -// // Here I will set a UIDevice -// sc.TelemetryCh = sc.TelemServ.SubscribeListener("UI", 1) -// } - func (sc *StreamingCtrl) registerHooks() { sc.StreamView.Options.Form.SetInputCapture(func(ev *tcell.EventKey) *tcell.EventKey { switch ev.Key() { diff --git a/tui/tui.go b/tui/tui.go index 4add4bb..a1c1f3b 100644 --- a/tui/tui.go +++ b/tui/tui.go @@ -23,19 +23,15 @@ func NewControlPanel(logger *slog.Logger) *ControlPanel { App: tview.NewApplication(), } - // NOTE: create our device service here - devService := services.NewDeviceService(logger.With("service", "DeviceService")) - - telemService := services.NewTelemetryService(logger, devService) - if telemService == nil { - panic("failed to create the telemetry service") + orchestrator, err := services.NewOrchestrator(logger) + if err != nil { + // TODO: no panic here + panic("failed to create services orchestrator") } - go telemService.FindProvider(telemService.CtxMonitor) - return &ControlPanel{ Controller: baseController, - DeviceController: controllers.NewDeviceController(baseController, devService, telemService), + DeviceController: controllers.NewDeviceController(baseController, orchestrator), } } From 6ff4cc3014811b353b72bfa318a62ee52f9193bd Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Mon, 21 Sep 2026 15:26:57 +0100 Subject: [PATCH 27/41] added a central constants package so we don't have to pull a provider if all we need is its name --- constants/constants.go | 6 ++++++ providers/beamng/beamng.go | 3 ++- providers/iracing/iracing.go | 3 ++- 3 files changed, 10 insertions(+), 2 deletions(-) create mode 100644 constants/constants.go diff --git a/constants/constants.go b/constants/constants.go new file mode 100644 index 0000000..b5d3305 --- /dev/null +++ b/constants/constants.go @@ -0,0 +1,6 @@ +package constants + +const ( + IRacingProviderName = "iRacing" + BeamNGProviderName = "BeamNG.drive" +) diff --git a/providers/beamng/beamng.go b/providers/beamng/beamng.go index f07b933..7e371cc 100644 --- a/providers/beamng/beamng.go +++ b/providers/beamng/beamng.go @@ -8,6 +8,7 @@ import ( "sync" "time" + "esdi/constants" "esdi/telemetry" bngsdk "github.com/ESilva15/gobngsdk" @@ -36,7 +37,7 @@ type BeamNG struct { } const ( - NAME = "BeamNG.drive" + NAME = constants.BeamNGProviderName ) func NewBeamNGProvider(logger *slog.Logger, opts *bngsdk.Options) (*BeamNG, error) { diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index 9701f6f..d271ea6 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -10,13 +10,14 @@ import ( "sync" "time" + "esdi/constants" "esdi/telemetry" "github.com/ESilva15/goirsdk" ) const ( - NAME = "iRacing" + NAME = constants.IRacingProviderName ) // IRacing is our iRacing telemetry data provider - its a TelemetryProvider interface From b364931c807577afc7d75cc5dfe9c33503af6e49 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Mon, 21 Sep 2026 15:27:42 +0100 Subject: [PATCH 28/41] automatic setup for devices Its not close to being done and still need to work out the flows due to who arrives first: telemetry or the peripheral? --- devices/cdashdisplay/display.go | 23 ++++++++++++++- devices/uidevice/device.go | 2 +- peripheral/peripheral.go | 2 +- services/devices.go | 51 ++++++++++++++++++++++++++++++++- services/devices_lookup.go | 29 +++++++++++++++++-- services/services.go | 10 +++++-- services/telemetry.go | 31 ++++++++++++++++---- services/telemetry_events.go | 1 + 8 files changed, 134 insertions(+), 15 deletions(-) diff --git a/devices/cdashdisplay/display.go b/devices/cdashdisplay/display.go index 7c2bd94..b8e2d07 100644 --- a/devices/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -11,6 +11,7 @@ import ( "sync" "time" + "esdi/constants" helper "esdi/helpers" "esdi/peripheral" "esdi/peripheral/communication" @@ -438,7 +439,7 @@ func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) error { return nil } -func (cds *CDashDisplay) Setup() error { +func (cds *CDashDisplay) setupForIracing() error { err := cds.LoadLayout("layout.yaml") if err != nil { return err @@ -446,3 +447,23 @@ func (cds *CDashDisplay) Setup() error { return nil } + +func (cds *CDashDisplay) setupForBeamNG() error { + err := cds.LoadLayout("beamng.yaml") + if err != nil { + return err + } + + return nil +} + +func (cds *CDashDisplay) Setup(provider string) error { + switch provider { + case constants.IRacingProviderName: + return cds.setupForIracing() + case constants.BeamNGProviderName: + return cds.setupForBeamNG() + default: + return fmt.Errorf("unknown provider: %s", provider) + } +} diff --git a/devices/uidevice/device.go b/devices/uidevice/device.go index 4b0b0cd..c97d493 100644 --- a/devices/uidevice/device.go +++ b/devices/uidevice/device.go @@ -25,7 +25,7 @@ func (uid *UIDevice) Close() error { return nil } -func (uid *UIDevice) Setup() error { +func (uid *UIDevice) Setup(provider string) error { return nil } diff --git a/peripheral/peripheral.go b/peripheral/peripheral.go index fc918ee..56cf08d 100644 --- a/peripheral/peripheral.go +++ b/peripheral/peripheral.go @@ -17,7 +17,7 @@ const ( type Peripheral interface { Name() string - Setup() error + Setup(string) error SendData(*telemetry.TelemetryData) error RequiredFields() []telemetry.FieldID OnLoad() error diff --git a/services/devices.go b/services/devices.go index 8219254..4513d01 100644 --- a/services/devices.go +++ b/services/devices.go @@ -2,6 +2,7 @@ package services import ( "context" + "fmt" "log/slog" "sync/atomic" @@ -23,7 +24,9 @@ type DeviceService struct { // Output Messages chan string // Callbacks - OnTelemetryProviderDiscovered func() + OnPeripheralFound func(string) + // Telemetry service data fetchers + telemetryProvider func() (string, error) } func NewDeviceService(logger *slog.Logger, msg chan string) *DeviceService { @@ -40,6 +43,9 @@ func NewDeviceService(logger *slog.Logger, msg chan string) *DeviceService { dev.ctxDiscovery, dev.ctxDiscoveryCancel = context.WithCancel(context.Background()) go dev.FindDevices() + // Set the callbacks for PSS + dev.PSS.OnDeviceFound = dev.deviceFound + return dev } @@ -131,3 +137,46 @@ func (ds *DeviceService) transmit(ctx context.Context) { } } } + +func (ds *DeviceService) deviceFound(pname string) { + ds.OnPeripheralFound(pname) +} + +// Callbacks [START] ----------------------------------------------------------- + +// ProviderFoundCallback should be called once the telemetry service finds a provider +// Here we need to setup our devices. Some devices might have different settings for +// different sims +func (ds *DeviceService) ProviderFoundCallback(name string) { + ds.Messages <- "Device services got triggered by a provider being found\n" + for _, peripheral := range ds.PSS.GetStates() { + // ds.Messages <- fmt.Sprintf("dev: %s, SETUP: %t, STATE: %d\n", + // peripheral.device.Name, peripheral.Setup, peripheral.State) + if peripheral.State != DeviceIsConnected || peripheral.Setup { + continue + } + + // The device is connected and still needs to run the setup + ds.Messages <- fmt.Sprintf("device '%s' needs to be setup\n", peripheral.device.Name) + + provider, err := ds.telemetryProvider() + if err != nil { + // Can't setup anything + continue + } + + err = peripheral.Peripheral.Setup(provider) + if err != nil { + // TODO: log do something + continue + } + + err = ds.PSS.UpdatePeripheralSetupState(peripheral.device.Name, true) + if err != nil { + // TODO: log do something + continue + } + } +} + +// Callbacks [END] ------------------------------------------------------------- diff --git a/services/devices_lookup.go b/services/devices_lookup.go index febabd1..1b8442a 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -32,6 +32,7 @@ type PeripheralState struct { device *devices.Device Peripheral peripheral.Peripheral State DeviceState + Setup bool } func NewPeripheralState( @@ -43,6 +44,7 @@ func NewPeripheralState( device: dev, Peripheral: peripheral, State: state, + Setup: false, } return &perState @@ -54,6 +56,8 @@ type PeripheralStateStore struct { store map[string]*PeripheralState // Messaging for UI and stuff Messages chan string + // Callbacks + OnDeviceFound func(string) } func NewPeripheralStateStore( @@ -117,6 +121,18 @@ func (pss *PeripheralStateStore) AddDevice(dev *devices.Device) error { return nil } +func (pss *PeripheralStateStore) UpdatePeripheralSetupState(pname string, nState bool) error { + if !pss.DeviceExists(pname) { + return ErrNoSuchDevice + } + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].Setup = nState + + return nil +} + // DeviceExists returns whether the store is already tracking `pname` func (pss *PeripheralStateStore) DeviceExists(pname string) bool { pss.mu.RLock() @@ -156,11 +172,12 @@ func (pss *PeripheralStateStore) setDeviceConnected(pname string, per peripheral pss.Logger.Info("found device", "device", pname) pss.mu.Lock() - defer pss.mu.Unlock() pss.store[pname].Peripheral = per pss.store[pname].State = DeviceIsConnected + pss.mu.Unlock() pss.Messages <- fmt.Sprintf("Device successfuly connected: %s\n", pname) + pss.OnDeviceFound(pname) } func (pss *PeripheralStateStore) setDeviceTimedOut(pname string) { @@ -222,7 +239,6 @@ func (pss *PeripheralStateStore) handleDeviceReconnected(pname string) error { return err } - err = state.Peripheral.Setup() if err != nil { pss.Logger.Error("failed to setup peripheral", "peripheral", pname, "error", err) return ErrFailedToSetupPeripheral @@ -234,6 +250,12 @@ func (pss *PeripheralStateStore) handleDeviceReconnected(pname string) error { return nil } +// handleDeviceConnected will handle the device setup after it connects +func (pss *PeripheralStateStore) handleDeviceConnected(pname string) error { + // We need to query wheter we have a telemetry provider running or not + return nil +} + func (pss *PeripheralStateStore) HandleDeviceState() { peripherals := pss.GetStates() @@ -249,6 +271,7 @@ func (pss *PeripheralStateStore) HandleDeviceState() { case DeviceIsConnected: // Need to check if its streaming, if its not streaming than we have to do a healthcheck pss.Logger.Debug("Device is connected. Normal", "device", pName) + pss.handleDeviceConnected(pName) case DeviceReconnected: // If the device has reconnected we need to reset the device and then set it as connected pss.Logger.Debug("Device has reconnected. Clearing up state", "device", pName) @@ -274,7 +297,7 @@ func (pss *PeripheralStateStore) HandleDeviceState() { // FindDevices is a routine that goes over the devices in the PeripheralStateStore // and handles their state accordingly func (ds *DeviceService) FindDevices() { - ticker := time.NewTicker(2 * time.Second) + ticker := time.NewTicker(1 * time.Second) defer ticker.Stop() for { diff --git a/services/services.go b/services/services.go index d76cb62..5abcf8f 100644 --- a/services/services.go +++ b/services/services.go @@ -17,14 +17,20 @@ func NewOrchestrator(logger *slog.Logger) (*Orchestrator, error) { devService := NewDeviceService(logger.With("service", "DeviceService"), msg) - telemService := NewTelemetryService(logger.With("service", "TelemetryService"), devService, msg) + telemService := NewTelemetryService(logger.With("service", "TelemetryService"), msg) if telemService == nil { return nil, errors.New("failed to create telemetry service") } go telemService.FindProvider(telemService.CtxMonitor) - // Need to setup the callbacks on the services + // Setup device service callbacks + devService.OnPeripheralFound = telemService.PeripheralFoundCallback + devService.telemetryProvider = telemService.GetTelemetryProviderName + + // Setup telemetry service callbacks + telemService.OnProviderFound = devService.ProviderFoundCallback + telemService.peripheralProvider = devService.GetDevices return &Orchestrator{ DeviceService: devService, diff --git a/services/telemetry.go b/services/telemetry.go index 679a85b..fa50c3b 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -2,20 +2,23 @@ package services import ( "context" + "errors" "log/slog" "sync" "time" + "esdi/peripheral" "esdi/providers" "esdi/telemetry" telem "esdi/telemetry" ) +var ErrNoActiveProviderAvailable = errors.New("no active provider available") + // TelemetryService will be our base struct to handle telemetry data // It should hook to a data sink and handle it like iRacing, BeamNG, AC and so on type TelemetryService struct { - logger *slog.Logger - devService *DeviceService + logger *slog.Logger // Streaming isStreaming bool // Concurrency protection @@ -33,18 +36,18 @@ type TelemetryService struct { CtxHealthcheck context.Context healthCheckCancel context.CancelFunc // Callbacks - OnDevicesDiscovered func() + OnProviderFound func(string) + // Devices data request + peripheralProvider func() []peripheral.Peripheral } func NewTelemetryService( logger *slog.Logger, - devServo *DeviceService, msg chan string, ) *TelemetryService { newService := &TelemetryService{ logger: logger, isConnected: false, - devService: devServo, listeners: make(map[string]chan telem.TelemetryData), Messages: msg, } @@ -74,6 +77,14 @@ func (t *TelemetryService) ProviderMonitor(ctx context.Context) { } } +func (t *TelemetryService) GetTelemetryProviderName() (string, error) { + if t.activeProvider == nil { + return "", ErrNoActiveProviderAvailable + } + + return t.activeProvider.Name(), nil +} + // Listener Control [START] ---------------------------------------------------- func (t *TelemetryService) SubscribeListener(id string, bufferSize int) <-chan telem.TelemetryData { @@ -108,7 +119,7 @@ func (t *TelemetryService) SubscribeToFields() []telem.FieldID { seen := make(map[telemetry.FieldID]struct{}) var allFields []telemetry.FieldID - for _, dev := range t.devService.GetDevices() { + for _, dev := range t.peripheralProvider() { for _, field := range dev.RequiredFields() { if _, exists := seen[field]; !exists { seen[field] = struct{}{} @@ -263,3 +274,11 @@ func (t *TelemetryService) IsStreaming() bool { } // Streaming Control [END] ----------------------------------------------------- + +// Callbacks [START] ----------------------------------------------------------- + +func (t *TelemetryService) PeripheralFoundCallback(pname string) { + t.Messages <- "Telemetry service callback for peripheral found called\n" +} + +// Callbacks [END] ------------------------------------------------------------- diff --git a/services/telemetry_events.go b/services/telemetry_events.go index 0899855..f42b3ab 100644 --- a/services/telemetry_events.go +++ b/services/telemetry_events.go @@ -28,6 +28,7 @@ func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) { go t.ProviderMonitor(t.CtxHealthcheck) // Tell the devices service we got a provider + t.OnProviderFound(prov.Name()) } func (t *TelemetryService) onProviderStopsMidStream() { From d10c6997f4c6cb07fe2737b981f1cf798f4eb7c4 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Mon, 21 Sep 2026 15:55:31 +0100 Subject: [PATCH 29/41] clean up a bit the logic of how we get to know whether the telemetry started on devices lookup --- services/devices.go | 49 ++++++------------------------------ services/devices_lookup.go | 47 +++++++++++++++++++++++++++------- services/services.go | 2 -- services/telemetry.go | 5 ---- services/telemetry_events.go | 3 --- 5 files changed, 45 insertions(+), 61 deletions(-) diff --git a/services/devices.go b/services/devices.go index 4513d01..c162469 100644 --- a/services/devices.go +++ b/services/devices.go @@ -2,7 +2,6 @@ package services import ( "context" - "fmt" "log/slog" "sync/atomic" @@ -24,7 +23,6 @@ type DeviceService struct { // Output Messages chan string // Callbacks - OnPeripheralFound func(string) // Telemetry service data fetchers telemetryProvider func() (string, error) } @@ -44,12 +42,18 @@ func NewDeviceService(logger *slog.Logger, msg chan string) *DeviceService { go dev.FindDevices() // Set the callbacks for PSS - dev.PSS.OnDeviceFound = dev.deviceFound + dev.PSS.telemetryProvider = dev.getTelemetryProvider return dev } // Getters [START] ------------------------------------------------------------- +// This function is currently only being used by PSS, we may have to find a better +// pattern for this +func (ds *DeviceService) getTelemetryProvider() (string, error) { + return ds.telemetryProvider() +} + func (ds *DeviceService) GetDevices() []peripheral.Peripheral { snapshot := ds.PSS.GetStates() peripherals := make([]peripheral.Peripheral, 0, len(snapshot)) @@ -138,45 +142,6 @@ func (ds *DeviceService) transmit(ctx context.Context) { } } -func (ds *DeviceService) deviceFound(pname string) { - ds.OnPeripheralFound(pname) -} - // Callbacks [START] ----------------------------------------------------------- -// ProviderFoundCallback should be called once the telemetry service finds a provider -// Here we need to setup our devices. Some devices might have different settings for -// different sims -func (ds *DeviceService) ProviderFoundCallback(name string) { - ds.Messages <- "Device services got triggered by a provider being found\n" - for _, peripheral := range ds.PSS.GetStates() { - // ds.Messages <- fmt.Sprintf("dev: %s, SETUP: %t, STATE: %d\n", - // peripheral.device.Name, peripheral.Setup, peripheral.State) - if peripheral.State != DeviceIsConnected || peripheral.Setup { - continue - } - - // The device is connected and still needs to run the setup - ds.Messages <- fmt.Sprintf("device '%s' needs to be setup\n", peripheral.device.Name) - - provider, err := ds.telemetryProvider() - if err != nil { - // Can't setup anything - continue - } - - err = peripheral.Peripheral.Setup(provider) - if err != nil { - // TODO: log do something - continue - } - - err = ds.PSS.UpdatePeripheralSetupState(peripheral.device.Name, true) - if err != nil { - // TODO: log do something - continue - } - } -} - // Callbacks [END] ------------------------------------------------------------- diff --git a/services/devices_lookup.go b/services/devices_lookup.go index 1b8442a..03ec598 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -57,7 +57,7 @@ type PeripheralStateStore struct { // Messaging for UI and stuff Messages chan string // Callbacks - OnDeviceFound func(string) + telemetryProvider func() (string, error) } func NewPeripheralStateStore( @@ -177,7 +177,7 @@ func (pss *PeripheralStateStore) setDeviceConnected(pname string, per peripheral pss.mu.Unlock() pss.Messages <- fmt.Sprintf("Device successfuly connected: %s\n", pname) - pss.OnDeviceFound(pname) + // pss.OnDeviceFound(pname) } func (pss *PeripheralStateStore) setDeviceTimedOut(pname string) { @@ -239,20 +239,49 @@ func (pss *PeripheralStateStore) handleDeviceReconnected(pname string) error { return err } - if err != nil { - pss.Logger.Error("failed to setup peripheral", "peripheral", pname, "error", err) - return ErrFailedToSetupPeripheral - } - - // Around here I believe I need to swap the states so the peripheral is setup + // Update the peripheral state pss.setDeviceConnected(pname, state.Peripheral) + pss.UpdatePeripheralSetupState(pname, false) return nil } // handleDeviceConnected will handle the device setup after it connects +// NOTE: should this be a state after Connected? +// Connected -> Unconfigured -> Configured I believe this would work nicely +// THIS IS A TODO ↑↑↑↑↑↑ func (pss *PeripheralStateStore) handleDeviceConnected(pname string) error { - // We need to query wheter we have a telemetry provider running or not + // Things to do once the device is connected + // 1. Setup + state, err := pss.GetState(pname) + if err != nil { + // We need to log something here or something + return err + } + + if !state.Setup { + err = pss.setupPeripheral(state) + } + + return nil +} + +func (pss *PeripheralStateStore) setupPeripheral(state *PeripheralState) error { + provider, err := pss.telemetryProvider() + if err != nil { + return err + } + + err = state.Peripheral.Setup(provider) + if err != nil { + return err + } + + err = pss.UpdatePeripheralSetupState(state.device.Name, true) + if err != nil { + return err + } + return nil } diff --git a/services/services.go b/services/services.go index 5abcf8f..18aff69 100644 --- a/services/services.go +++ b/services/services.go @@ -25,11 +25,9 @@ func NewOrchestrator(logger *slog.Logger) (*Orchestrator, error) { go telemService.FindProvider(telemService.CtxMonitor) // Setup device service callbacks - devService.OnPeripheralFound = telemService.PeripheralFoundCallback devService.telemetryProvider = telemService.GetTelemetryProviderName // Setup telemetry service callbacks - telemService.OnProviderFound = devService.ProviderFoundCallback telemService.peripheralProvider = devService.GetDevices return &Orchestrator{ diff --git a/services/telemetry.go b/services/telemetry.go index fa50c3b..7ca2112 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -36,7 +36,6 @@ type TelemetryService struct { CtxHealthcheck context.Context healthCheckCancel context.CancelFunc // Callbacks - OnProviderFound func(string) // Devices data request peripheralProvider func() []peripheral.Peripheral } @@ -277,8 +276,4 @@ func (t *TelemetryService) IsStreaming() bool { // Callbacks [START] ----------------------------------------------------------- -func (t *TelemetryService) PeripheralFoundCallback(pname string) { - t.Messages <- "Telemetry service callback for peripheral found called\n" -} - // Callbacks [END] ------------------------------------------------------------- diff --git a/services/telemetry_events.go b/services/telemetry_events.go index f42b3ab..6774a63 100644 --- a/services/telemetry_events.go +++ b/services/telemetry_events.go @@ -26,9 +26,6 @@ func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) { // Start the healthcheck on our provider so we can drop it if it stops t.CtxHealthcheck, t.healthCheckCancel = context.WithCancel(context.Background()) go t.ProviderMonitor(t.CtxHealthcheck) - - // Tell the devices service we got a provider - t.OnProviderFound(prov.Name()) } func (t *TelemetryService) onProviderStopsMidStream() { From 91f33c79edecc9450e689f2e53d9d0c03bbc4ea3 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Mon, 21 Sep 2026 16:07:00 +0100 Subject: [PATCH 30/41] refactored the peripheral configuration loop --- services/devices_lookup.go | 75 +++++++++++++++++++++----------------- 1 file changed, 42 insertions(+), 33 deletions(-) diff --git a/services/devices_lookup.go b/services/devices_lookup.go index 03ec598..4cefb1e 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -24,6 +24,8 @@ type DeviceState = uint8 const ( DeviceTimedOut uint8 = iota DeviceIsConnected + DeviceIsUnconfigured + DeviceIsConfigured DeviceIsDisconnected DeviceReconnected ) @@ -32,7 +34,6 @@ type PeripheralState struct { device *devices.Device Peripheral peripheral.Peripheral State DeviceState - Setup bool } func NewPeripheralState( @@ -44,7 +45,6 @@ func NewPeripheralState( device: dev, Peripheral: peripheral, State: state, - Setup: false, } return &perState @@ -121,18 +121,6 @@ func (pss *PeripheralStateStore) AddDevice(dev *devices.Device) error { return nil } -func (pss *PeripheralStateStore) UpdatePeripheralSetupState(pname string, nState bool) error { - if !pss.DeviceExists(pname) { - return ErrNoSuchDevice - } - - pss.mu.Lock() - defer pss.mu.Unlock() - pss.store[pname].Setup = nState - - return nil -} - // DeviceExists returns whether the store is already tracking `pname` func (pss *PeripheralStateStore) DeviceExists(pname string) bool { pss.mu.RLock() @@ -177,7 +165,6 @@ func (pss *PeripheralStateStore) setDeviceConnected(pname string, per peripheral pss.mu.Unlock() pss.Messages <- fmt.Sprintf("Device successfuly connected: %s\n", pname) - // pss.OnDeviceFound(pname) } func (pss *PeripheralStateStore) setDeviceTimedOut(pname string) { @@ -198,6 +185,22 @@ func (pss *PeripheralStateStore) setDeviceReconnected(pname string, per peripher pss.store[pname].State = DeviceReconnected } +func (pss *PeripheralStateStore) setDeviceUnconfigured(pname string) { + pss.Logger.Info("device is connected but not configured", "device", pname) + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].State = DeviceIsUnconfigured +} + +func (pss *PeripheralStateStore) setDeviceConfigured(pname string) { + pss.Logger.Info("device is configured and ready for data", "device", pname) + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].State = DeviceIsConfigured +} + // Device State Handling [END] ------------------------------------------------- // Device Handling [START] ----------------------------------------------------- @@ -241,7 +244,6 @@ func (pss *PeripheralStateStore) handleDeviceReconnected(pname string) error { // Update the peripheral state pss.setDeviceConnected(pname, state.Peripheral) - pss.UpdatePeripheralSetupState(pname, false) return nil } @@ -251,22 +253,17 @@ func (pss *PeripheralStateStore) handleDeviceReconnected(pname string) error { // Connected -> Unconfigured -> Configured I believe this would work nicely // THIS IS A TODO ↑↑↑↑↑↑ func (pss *PeripheralStateStore) handleDeviceConnected(pname string) error { - // Things to do once the device is connected - // 1. Setup - state, err := pss.GetState(pname) - if err != nil { - // We need to log something here or something - return err - } - - if !state.Setup { - err = pss.setupPeripheral(state) - } - + pss.setDeviceUnconfigured(pname) return nil } -func (pss *PeripheralStateStore) setupPeripheral(state *PeripheralState) error { +func (pss *PeripheralStateStore) handleDeviceIsUnconfigured(pname string) error { + // Here we need to configure our device. If no error occurs its configured! + state, err := pss.GetState(pname) + if err != nil { + return err + } + provider, err := pss.telemetryProvider() if err != nil { return err @@ -277,14 +274,16 @@ func (pss *PeripheralStateStore) setupPeripheral(state *PeripheralState) error { return err } - err = pss.UpdatePeripheralSetupState(state.device.Name, true) - if err != nil { - return err - } + pss.setDeviceConfigured(pname) return nil } +func (pss *PeripheralStateStore) handleDeviceIsConfigured(pname string) error { + // Nothing to do - this method shouldn't even exist then + return nil +} + func (pss *PeripheralStateStore) HandleDeviceState() { peripherals := pss.GetStates() @@ -301,6 +300,16 @@ func (pss *PeripheralStateStore) HandleDeviceState() { // Need to check if its streaming, if its not streaming than we have to do a healthcheck pss.Logger.Debug("Device is connected. Normal", "device", pName) pss.handleDeviceConnected(pName) + case DeviceIsUnconfigured: + pss.Logger.Debug("Device is still being configured.", "device", pName) + err := pss.handleDeviceIsUnconfigured(pName) + if err != nil { + // Something is not adding up, it should be logged somewhere... SYKE + continue + } + case DeviceIsConfigured: + // Nothing to do here + continue case DeviceReconnected: // If the device has reconnected we need to reset the device and then set it as connected pss.Logger.Debug("Device has reconnected. Clearing up state", "device", pName) From 009609da93e55a43fe2c9d02c370869f0c7017c6 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Mon, 21 Sep 2026 16:50:55 +0100 Subject: [PATCH 31/41] fix after implementing new changes to PSS. streaming was broken --- services/devices.go | 4 ++-- services/devices_lookup.go | 6 +++--- tui/internal/controllers/streaming.go | 5 +---- 3 files changed, 6 insertions(+), 9 deletions(-) diff --git a/services/devices.go b/services/devices.go index c162469..8b52d2d 100644 --- a/services/devices.go +++ b/services/devices.go @@ -59,7 +59,7 @@ func (ds *DeviceService) GetDevices() []peripheral.Peripheral { peripherals := make([]peripheral.Peripheral, 0, len(snapshot)) for _, state := range snapshot { - if state.State != DeviceIsConnected { + if state.State < DeviceIsConnected { continue } peripherals = append(peripherals, state.Peripheral) @@ -126,7 +126,7 @@ func (ds *DeviceService) transmit(ctx context.Context) { // TODO: make a copy of the data and send that copy instead of keeping // the data locked for _, dev := range ds.PSS.GetStates() { - if dev.State != DeviceIsConnected { + if dev.State != DeviceIsConfigured { continue } diff --git a/services/devices_lookup.go b/services/devices_lookup.go index 4cefb1e..99cf69b 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -23,11 +23,11 @@ type DeviceState = uint8 const ( DeviceTimedOut uint8 = iota + DeviceIsDisconnected + DeviceReconnected DeviceIsConnected DeviceIsUnconfigured DeviceIsConfigured - DeviceIsDisconnected - DeviceReconnected ) type PeripheralState struct { @@ -101,7 +101,7 @@ func (pss *PeripheralStateStore) GetPeripheral(pname string) (peripheral.Periphe return nil, err } - if state.State != DeviceIsConnected { + if state.State < DeviceIsConnected { return nil, ErrDeviceIsNotConnected } diff --git a/tui/internal/controllers/streaming.go b/tui/internal/controllers/streaming.go index cb3f211..4fd57c1 100644 --- a/tui/internal/controllers/streaming.go +++ b/tui/internal/controllers/streaming.go @@ -155,10 +155,7 @@ func (sc *StreamingCtrl) updateStream() { // so we can get away with using a map for convenience here func (sc *StreamingCtrl) SetInternalState() { fields := sc.TelemServ.SubscribeToFields() - - // sc.Messages <- fmt.Sprintf("Subscribed Fields: %+v [%d]\n", fields, len(fields)) - // Should I update this? - sc.Messages <- fmt.Sprintf("Subscribed to fields: %+v", fields) + sc.Messages <- fmt.Sprintf("Subscribed to fields: %+v\n", fields) } func (sc *StreamingCtrl) listenToUIStream() { From 82972c96651e412af24110cc48d52480045ddc3d Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Tue, 22 Sep 2026 16:21:50 +0100 Subject: [PATCH 32/41] Added healthchecks, and maybe got a bit lost --- devices/cdashdisplay/connect.go | 2 +- devices/cdashdisplay/display.go | 34 +-- devices/cdashdisplay/info.go | 12 ++ devices/cdashdisplay/setup.go | 36 ++++ devices/uidevice/device.go | 4 + peripheral/communication/communication.go | 1 + .../packets/newWindowIDPakcket.go | 19 ++ peripheral/communication/walkieTalkie.go | 9 +- peripheral/peripheral.go | 1 + services/devices.go | 4 +- services/devices_lookup.go | 203 ++++++++++++++---- 11 files changed, 241 insertions(+), 84 deletions(-) create mode 100644 devices/cdashdisplay/setup.go diff --git a/devices/cdashdisplay/connect.go b/devices/cdashdisplay/connect.go index fe65496..bdec694 100644 --- a/devices/cdashdisplay/connect.go +++ b/devices/cdashdisplay/connect.go @@ -73,7 +73,7 @@ func findDisplayPort() (*communication.WalkieTalkie, error) { select { case err = <-probeResult: // Probe completed normally (could be success or error) - case <-time.After(2 * time.Second): + case <-time.After(1000 * time.Millisecond): // Hard timeout reached err = fmt.Errorf("probe completely hung/timed out: %s", port) } diff --git a/devices/cdashdisplay/display.go b/devices/cdashdisplay/display.go index b8e2d07..4314ec1 100644 --- a/devices/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -11,7 +11,6 @@ import ( "sync" "time" - "esdi/constants" helper "esdi/helpers" "esdi/peripheral" "esdi/peripheral/communication" @@ -34,6 +33,7 @@ const ( updateWindowCMDID types.Command = 6 // Change this to a move cmd instead sendDataCMDID types.Command = 7 newLayoutCMDID types.Command = 8 + healthCheckCMDID types.Command = 9 ) const ( @@ -149,9 +149,6 @@ func (cds *CDashDisplay) Close() error { return nil } -func (d *CDashDisplay) SendCommand() { -} - func (d *CDashDisplay) RegisterFieldMapping(fieldID telemetry.FieldID, winID int16) { d.fieldToWindows[fieldID] = append(d.fieldToWindows[fieldID], winID) } @@ -438,32 +435,3 @@ func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) error { return nil } - -func (cds *CDashDisplay) setupForIracing() error { - err := cds.LoadLayout("layout.yaml") - if err != nil { - return err - } - - return nil -} - -func (cds *CDashDisplay) setupForBeamNG() error { - err := cds.LoadLayout("beamng.yaml") - if err != nil { - return err - } - - return nil -} - -func (cds *CDashDisplay) Setup(provider string) error { - switch provider { - case constants.IRacingProviderName: - return cds.setupForIracing() - case constants.BeamNGProviderName: - return cds.setupForBeamNG() - default: - return fmt.Errorf("unknown provider: %s", provider) - } -} diff --git a/devices/cdashdisplay/info.go b/devices/cdashdisplay/info.go index 1dfb8d2..68b7bb1 100644 --- a/devices/cdashdisplay/info.go +++ b/devices/cdashdisplay/info.go @@ -1,6 +1,7 @@ package cdashdisplay import ( + "esdi/peripheral/communication/packets" "esdi/peripheral/devices" "esdi/telemetry" ) @@ -26,3 +27,14 @@ func (cds *CDashDisplay) RequiredFields() []telemetry.FieldID { return fields } + +func (cds *CDashDisplay) HealthCheck() bool { + // Send the command + var health packets.HealthCheck + err := cds.WT.SendCommand(healthCheckCMDID, []byte{0x01, 0x02, 0x03, 0x04}, &health) + if err != nil { + return false + } + + return true +} diff --git a/devices/cdashdisplay/setup.go b/devices/cdashdisplay/setup.go new file mode 100644 index 0000000..0afd001 --- /dev/null +++ b/devices/cdashdisplay/setup.go @@ -0,0 +1,36 @@ +package cdashdisplay + +import ( + "fmt" + + "esdi/constants" +) + +func (cds *CDashDisplay) setupForIracing() error { + err := cds.LoadLayout("layout.yaml") + if err != nil { + return err + } + + return nil +} + +func (cds *CDashDisplay) setupForBeamNG() error { + err := cds.LoadLayout("beamng.yaml") + if err != nil { + return err + } + + return nil +} + +func (cds *CDashDisplay) Setup(provider string) error { + switch provider { + case constants.IRacingProviderName: + return cds.setupForIracing() + case constants.BeamNGProviderName: + return cds.setupForBeamNG() + default: + return fmt.Errorf("unknown provider: %s", provider) + } +} diff --git a/devices/uidevice/device.go b/devices/uidevice/device.go index c97d493..c32032d 100644 --- a/devices/uidevice/device.go +++ b/devices/uidevice/device.go @@ -58,3 +58,7 @@ func (uid *UIDevice) RequiredFields() []telemetry.FieldID { telemetry.RPM, } } + +func (uid *UIDevice) HealthCheck() bool { + return true +} diff --git a/peripheral/communication/communication.go b/peripheral/communication/communication.go index bf7393b..729f95e 100644 --- a/peripheral/communication/communication.go +++ b/peripheral/communication/communication.go @@ -17,6 +17,7 @@ const ( CmdAckID types.Command = 2 CmdCreateWindow types.Command = 3 CmdDestroyWindow types.Command = 4 + CmdHealthCheck types.Command = 9 ) var crc8Table = [256]byte{ diff --git a/peripheral/communication/packets/newWindowIDPakcket.go b/peripheral/communication/packets/newWindowIDPakcket.go index baef6c1..346b0c9 100644 --- a/peripheral/communication/packets/newWindowIDPakcket.go +++ b/peripheral/communication/packets/newWindowIDPakcket.go @@ -18,3 +18,22 @@ func (pkt *NewWindowID) Validate() bool { return true } + +type HealthCheck struct { + StartMarker byte + Response byte + EndMarker byte +} + +func (pkt *HealthCheck) Validate() bool { + if pkt.StartMarker != constvar.StartOfText || + pkt.EndMarker != constvar.EndOfText { + return false + } + + if pkt.Response != 0x06 { + return false + } + + return true +} diff --git a/peripheral/communication/walkieTalkie.go b/peripheral/communication/walkieTalkie.go index fde5936..e2b4c0a 100644 --- a/peripheral/communication/walkieTalkie.go +++ b/peripheral/communication/walkieTalkie.go @@ -26,8 +26,7 @@ func (wt *WalkieTalkie) ReadFramedData(size int, packet any) error { b := make([]byte, 1) _, err := wt.Serial.Read(b) if err != nil { - // fmt.Fprintf(os.Stderr, "dev read: %s\n", err.Error()) - return err + return fmt.Errorf("error reading incoming: %+v, err:", b, err) } if b[0] == constvar.StartOfText { @@ -44,9 +43,11 @@ func (wt *WalkieTalkie) ReadFramedData(size int, packet any) error { reader := bytes.NewReader(buf) err = binary.Read(reader, binary.LittleEndian, packet) if err != nil { - return err + return fmt.Errorf("error parsing incoming: %+v, err:", buf, err) } + wt.Serial.Flush() + return nil } @@ -137,6 +138,8 @@ func (wt *WalkieTalkie) sendPacket(cmd types.Command, data any) error { return err } + wt.Serial.Flush() + return nil } diff --git a/peripheral/peripheral.go b/peripheral/peripheral.go index 56cf08d..2ea1170 100644 --- a/peripheral/peripheral.go +++ b/peripheral/peripheral.go @@ -18,6 +18,7 @@ const ( type Peripheral interface { Name() string Setup(string) error + HealthCheck() bool SendData(*telemetry.TelemetryData) error RequiredFields() []telemetry.FieldID OnLoad() error diff --git a/services/devices.go b/services/devices.go index 8b52d2d..c688821 100644 --- a/services/devices.go +++ b/services/devices.go @@ -85,6 +85,8 @@ func (ds *DeviceService) StartStream() { var ctx context.Context ctx, ds.streamCancel = context.WithCancel(context.Background()) + ds.PSS.OnStartStream() + go ds.transmit(ctx) } @@ -126,7 +128,7 @@ func (ds *DeviceService) transmit(ctx context.Context) { // TODO: make a copy of the data and send that copy instead of keeping // the data locked for _, dev := range ds.PSS.GetStates() { - if dev.State != DeviceIsConfigured { + if dev.State != DeviceIsStreaming { continue } diff --git a/services/devices_lookup.go b/services/devices_lookup.go index 99cf69b..3203dbc 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -25,11 +25,39 @@ const ( DeviceTimedOut uint8 = iota DeviceIsDisconnected DeviceReconnected + DeviceIsDiscovering DeviceIsConnected DeviceIsUnconfigured + DeviceIsConfiguring DeviceIsConfigured + DeviceIsStreaming ) +func DeviceStateToStr(state DeviceState) string { + switch state { + case DeviceTimedOut: + return "DeviceTimedOut" + case DeviceIsDisconnected: + return "DeviceIsDisconnected" + case DeviceReconnected: + return "DeviceReconnected" + case DeviceIsDiscovering: + return "DeviceIsDiscovering" + case DeviceIsConnected: + return "DeviceIsConnected" + case DeviceIsUnconfigured: + return "DeviceIsUnconfigured" + case DeviceIsConfiguring: + return "DeviceIsConfiguring" + case DeviceIsConfigured: + return "DeviceIsConfigured" + case DeviceIsStreaming: + return "DeviceIsStreaming" + default: + return "UnknownState" + } +} + type PeripheralState struct { device *devices.Device Peripheral peripheral.Peripheral @@ -149,13 +177,32 @@ func (pss *PeripheralStateStore) DeleteDevice(pname string) error { // "Events" [START] ------------------------------------------------------------ func (ds *DeviceService) onDeviceTimedOut(pname string) { - // We need to deregister the device ds.PSS.setDeviceTimedOut(pname) } +func (pss *PeripheralStateStore) OnStartStream() { + for _, state := range pss.GetStates() { + if state.State == DeviceIsConfigured { + pss.setDeviceIsStreaming(state.device.Name) + } + } +} + // "Events" [END] -------------------------------------------------------------- // Device State Handling [START] ----------------------------------------------- +func (pss *PeripheralStateStore) setDeviceDisconnected(pname string) { + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].State = DeviceIsDisconnected +} + +func (pss *PeripheralStateStore) setDeviceIsDiscovering(pname string) { + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].State = DeviceIsDiscovering +} + func (pss *PeripheralStateStore) setDeviceConnected(pname string, per peripheral.Peripheral) { pss.Logger.Info("found device", "device", pname) @@ -193,6 +240,14 @@ func (pss *PeripheralStateStore) setDeviceUnconfigured(pname string) { pss.store[pname].State = DeviceIsUnconfigured } +func (pss *PeripheralStateStore) setDeviceIsConfiguring(pname string) { + pss.Logger.Info("device is configuring for new provider", "device", pname) + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].State = DeviceIsConfiguring +} + func (pss *PeripheralStateStore) setDeviceConfigured(pname string) { pss.Logger.Info("device is configured and ready for data", "device", pname) @@ -201,37 +256,76 @@ func (pss *PeripheralStateStore) setDeviceConfigured(pname string) { pss.store[pname].State = DeviceIsConfigured } +func (pss *PeripheralStateStore) setDeviceIsStreaming(pname string) { + pss.Logger.Info("device is configured and ready for data", "device", pname) + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].State = DeviceIsStreaming +} + // Device State Handling [END] ------------------------------------------------- // Device Handling [START] ----------------------------------------------------- func (pss *PeripheralStateStore) discoverPeripheral( pname string, - onDiscovery func(pName string, peripheral peripheral.Peripheral), -) error { - state, err := pss.GetState(pname) - if err != nil { - pss.Logger.Error("Can't reconnect device", "device", pname, "error", err) - return err - } + onDiscovery func(string, peripheral.Peripheral), + onFailure func(string), +) { + pss.Logger.Debug("looking for device", "name", pname) + pss.setDeviceIsDiscovering(pname) + pss.Messages <- "Discovering " + pname + "\n" - dev, err := state.device.Discover() - if err != nil { - return err - } + go func() { + state, err := pss.GetState(pname) + if err != nil { + pss.Logger.Error("Can't reconnect device", "device", pname, "error", err) + onFailure(pname) + return + } - // Register the device we just found - onDiscovery(pname, dev) + dev, err := state.device.Discover() + if err != nil { + onFailure(pname) + return + } - return nil + // Register the device we just found + onDiscovery(pname, dev) + }() +} + +func (pss *PeripheralStateStore) configurePeripheral( + pname string, + onSuccess func(string), + onFailure func(string), +) { + go func() { + state, err := pss.GetState(pname) + if err != nil { + onFailure(pname) + return + } + + provider, err := pss.telemetryProvider() + if err != nil { + onFailure(pname) + return + } + + err = state.Peripheral.Setup(provider) + if err != nil { + onFailure(pname) + return + } + + onSuccess(pname) + pss.setDeviceConfigured(pname) + }() } func (pss *PeripheralStateStore) handleDeviceTimedOut(pname string) error { - err := pss.discoverPeripheral(pname, pss.setDeviceReconnected) - if err != nil { - // Log something - return err - } - + pss.discoverPeripheral(pname, pss.setDeviceReconnected, pss.setDeviceTimedOut) return nil } @@ -259,57 +353,58 @@ func (pss *PeripheralStateStore) handleDeviceConnected(pname string) error { func (pss *PeripheralStateStore) handleDeviceIsUnconfigured(pname string) error { // Here we need to configure our device. If no error occurs its configured! - state, err := pss.GetState(pname) + _, err := pss.telemetryProvider() if err != nil { return err } - provider, err := pss.telemetryProvider() - if err != nil { - return err - } - - err = state.Peripheral.Setup(provider) - if err != nil { - return err - } - - pss.setDeviceConfigured(pname) + pss.setDeviceIsConfiguring(pname) + pss.configurePeripheral(pname, pss.setDeviceConfigured, pss.setDeviceUnconfigured) return nil } func (pss *PeripheralStateStore) handleDeviceIsConfigured(pname string) error { - // Nothing to do - this method shouldn't even exist then + // Here we have to check wheter we are streaming or not. If we aren't streaming + // then we ought to do a healthcheck on the peripheral return nil } +func (pss *PeripheralStateStore) performHealthCheck(pname string, state *PeripheralState) bool { + healthStatus := state.Peripheral.HealthCheck() + if !healthStatus { + pss.Messages <- "peripheral " + pname + " failed healthcheck" + pss.setDeviceTimedOut(pname) + return false + } + + return true +} + func (pss *PeripheralStateStore) HandleDeviceState() { peripherals := pss.GetStates() for pName, pState := range peripherals { switch pState.State { case DeviceIsDisconnected: - pss.Logger.Debug("looking for device", "name", pName) - err := pss.discoverPeripheral(pName, pss.setDeviceConnected) - if err != nil { - // Log something - continue - } + pss.discoverPeripheral(pName, pss.setDeviceConnected, pss.setDeviceDisconnected) + case DeviceIsDiscovering: + // We need to set a device into discovery mode so we won't retrigger discoveries + // and pool them up case DeviceIsConnected: // Need to check if its streaming, if its not streaming than we have to do a healthcheck pss.Logger.Debug("Device is connected. Normal", "device", pName) pss.handleDeviceConnected(pName) case DeviceIsUnconfigured: pss.Logger.Debug("Device is still being configured.", "device", pName) - err := pss.handleDeviceIsUnconfigured(pName) - if err != nil { - // Something is not adding up, it should be logged somewhere... SYKE - continue - } + pss.handleDeviceIsUnconfigured(pName) + case DeviceIsConfiguring: + // Do nothing configuration is happening in the background case DeviceIsConfigured: // Nothing to do here - continue + pss.handleDeviceIsConfigured(pName) + case DeviceIsStreaming: + // case DeviceReconnected: // If the device has reconnected we need to reset the device and then set it as connected pss.Logger.Debug("Device has reconnected. Clearing up state", "device", pName) @@ -327,6 +422,22 @@ func (pss *PeripheralStateStore) HandleDeviceState() { continue } } + + updatedState, err := pss.GetState(pName) + if err != nil { + // TODO: log something useful here + continue + } + if updatedState.State == DeviceIsConnected || + updatedState.State == DeviceIsUnconfigured || + updatedState.State == DeviceIsConfigured { + pss.Messages <- fmt.Sprintf( + "Performing healthcheck. STATE: %s\n", + DeviceStateToStr(updatedState.State), + ) + pss.performHealthCheck(pName, updatedState) + } + } } From 636f20df7712518f5a5e10f32e4e31a43d2f3ebd Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Tue, 22 Sep 2026 16:27:44 +0100 Subject: [PATCH 33/41] delete this dead code --- peripheral/communication/walkieTalkie.go | 29 ------------------------ 1 file changed, 29 deletions(-) diff --git a/peripheral/communication/walkieTalkie.go b/peripheral/communication/walkieTalkie.go index e2b4c0a..a751f73 100644 --- a/peripheral/communication/walkieTalkie.go +++ b/peripheral/communication/walkieTalkie.go @@ -161,35 +161,6 @@ func (wt *WalkieTalkie) readPacket(resp packets.Packet) error { return nil } -// func (wt *WalkieTalkie) sendHeader(h *header) error { -// err := wt.sendPacket(h) -// if err != nil { -// return err -// } -// -// // var ack packets.AckPacket -// // err = wt.readPacket(&ack) -// // if err != nil { -// // return err -// // } -// -// return nil -// } - -// func (wt *WalkieTalkie) sendBody(payload any, resp packets.Packet) error { -// err := wt.sendPacket(payload) -// if err != nil { -// return err -// } -// -// // err = wt.readPacket(resp) -// // if err != nil { -// // return err -// // } -// -// return nil -// } - func (wt *WalkieTalkie) SendCommand( cmd types.Command, payload any, From df1e3c26fa44e131f284ba62e2da9d3c152baed6 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Tue, 22 Sep 2026 17:07:53 +0100 Subject: [PATCH 34/41] reconnects are slightly improved I don't really like the reset thing with the delay. I need to implement something better later on --- devices/cdashdisplay/display.go | 12 ++++++++++++ devices/cdashdisplay/setup.go | 8 ++++++++ services/devices_lookup.go | 28 ++++++++++++++++++++++++---- 3 files changed, 44 insertions(+), 4 deletions(-) diff --git a/devices/cdashdisplay/display.go b/devices/cdashdisplay/display.go index 4314ec1..51b84a0 100644 --- a/devices/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -34,6 +34,7 @@ const ( sendDataCMDID types.Command = 7 newLayoutCMDID types.Command = 8 healthCheckCMDID types.Command = 9 + resetCMDID types.Command = 10 ) const ( @@ -404,6 +405,17 @@ func (d *CDashDisplay) UnloadLayout() error { return nil } +func (cds *CDashDisplay) reset() error { + err := cds.WT.SendCommand(resetCMDID, []byte{0x01, 0x02, 0x03, 0x04}, nil) + if err != nil { + return err + } + + time.Sleep(3000 * time.Millisecond) + + return nil +} + func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) error { packet := d.encodePacket(data) diff --git a/devices/cdashdisplay/setup.go b/devices/cdashdisplay/setup.go index 0afd001..74117f4 100644 --- a/devices/cdashdisplay/setup.go +++ b/devices/cdashdisplay/setup.go @@ -25,6 +25,14 @@ func (cds *CDashDisplay) setupForBeamNG() error { } func (cds *CDashDisplay) Setup(provider string) error { + // Doesn't matter which one we are picking, we need to reset the CDashDisplay + // first - we will improve this setup behaviour later on with an Update to + // change it without dropping connection or some shit + err := cds.reset() + if err != nil { + return err + } + switch provider { case constants.IRacingProviderName: return cds.setupForIracing() diff --git a/services/devices_lookup.go b/services/devices_lookup.go index 3203dbc..499b8ea 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -86,6 +86,8 @@ type PeripheralStateStore struct { Messages chan string // Callbacks telemetryProvider func() (string, error) + // Internal State + isStreaming bool } func NewPeripheralStateStore( @@ -175,12 +177,22 @@ func (pss *PeripheralStateStore) DeleteDevice(pname string) error { return nil } +func (pss *PeripheralStateStore) GetStreamingState() bool { + pss.mu.RLock() + defer pss.mu.RUnlock() + return pss.isStreaming +} + // "Events" [START] ------------------------------------------------------------ func (ds *DeviceService) onDeviceTimedOut(pname string) { ds.PSS.setDeviceTimedOut(pname) } func (pss *PeripheralStateStore) OnStartStream() { + pss.mu.Lock() + pss.isStreaming = true + pss.mu.Unlock() + for _, state := range pss.GetStates() { if state.State == DeviceIsConfigured { pss.setDeviceIsStreaming(state.device.Name) @@ -188,6 +200,12 @@ func (pss *PeripheralStateStore) OnStartStream() { } } +func (pss *PeripheralStateStore) OnStopStream() { + pss.mu.Lock() + pss.isStreaming = false + pss.mu.Unlock() +} + // "Events" [END] -------------------------------------------------------------- // Device State Handling [START] ----------------------------------------------- @@ -325,6 +343,7 @@ func (pss *PeripheralStateStore) configurePeripheral( } func (pss *PeripheralStateStore) handleDeviceTimedOut(pname string) error { + pss.Messages <- "device " + pname + " timed out\n" pss.discoverPeripheral(pname, pss.setDeviceReconnected, pss.setDeviceTimedOut) return nil } @@ -367,6 +386,11 @@ func (pss *PeripheralStateStore) handleDeviceIsUnconfigured(pname string) error func (pss *PeripheralStateStore) handleDeviceIsConfigured(pname string) error { // Here we have to check wheter we are streaming or not. If we aren't streaming // then we ought to do a healthcheck on the peripheral + if pss.GetStreamingState() { + pss.Messages <- "returning device " + pname + " into streaming\n" + pss.setDeviceIsStreaming(pname) + } + return nil } @@ -431,10 +455,6 @@ func (pss *PeripheralStateStore) HandleDeviceState() { if updatedState.State == DeviceIsConnected || updatedState.State == DeviceIsUnconfigured || updatedState.State == DeviceIsConfigured { - pss.Messages <- fmt.Sprintf( - "Performing healthcheck. STATE: %s\n", - DeviceStateToStr(updatedState.State), - ) pss.performHealthCheck(pName, updatedState) } From a519cf473ecd25f469c453bbbce6ca5aca25edbf Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Wed, 23 Sep 2026 13:40:31 +0100 Subject: [PATCH 35/41] peripheral can connect mid stream and start go into streaming immidiately --- services/devices.go | 32 +++++++++++++++++++++++++-- services/devices_lookup.go | 13 +++++++++-- services/services.go | 3 ++- services/telemetry.go | 24 ++++++-------------- tui/internal/controllers/device.go | 2 +- tui/internal/controllers/streaming.go | 4 ++-- 6 files changed, 53 insertions(+), 25 deletions(-) diff --git a/services/devices.go b/services/devices.go index c688821..8448d90 100644 --- a/services/devices.go +++ b/services/devices.go @@ -2,6 +2,7 @@ package services import ( "context" + "fmt" "log/slog" "sync/atomic" @@ -24,7 +25,8 @@ type DeviceService struct { Messages chan string // Callbacks // Telemetry service data fetchers - telemetryProvider func() (string, error) + telemetryProvider func() (string, error) + triggerFieldSubscription func() []telemetry.FieldID } func NewDeviceService(logger *slog.Logger, msg chan string) *DeviceService { @@ -43,6 +45,7 @@ func NewDeviceService(logger *slog.Logger, msg chan string) *DeviceService { // Set the callbacks for PSS dev.PSS.telemetryProvider = dev.getTelemetryProvider + dev.PSS.onPeripheralConfigured = dev.peripheralConfigured return dev } @@ -59,7 +62,7 @@ func (ds *DeviceService) GetDevices() []peripheral.Peripheral { peripherals := make([]peripheral.Peripheral, 0, len(snapshot)) for _, state := range snapshot { - if state.State < DeviceIsConnected { + if state.State < DeviceIsConfigured { continue } peripherals = append(peripherals, state.Peripheral) @@ -77,6 +80,24 @@ func (ds *DeviceService) PeripheralExists(pname string) bool { return err == nil } +func (ds *DeviceService) GetRequiredFields() []telemetry.FieldID { + // NOTE: this can be optimized, not that it matters at this stage, but if + // it runs while telemetry is running we want it optimized I guess + seen := make(map[telemetry.FieldID]struct{}) + var allFields []telemetry.FieldID + + for _, dev := range ds.GetDevices() { + for _, field := range dev.RequiredFields() { + if _, exists := seen[field]; !exists { + seen[field] = struct{}{} + allFields = append(allFields, field) + } + } + } + + return allFields +} + // Getters [END] --------------------------------------------------------------- // Actions [START] ------------------------------------------------------------- @@ -95,6 +116,8 @@ func (ds *DeviceService) StopStream() { return } + ds.PSS.OnStopStream() + ds.streamCancel() ds.streamCancel = nil } @@ -145,5 +168,10 @@ func (ds *DeviceService) transmit(ctx context.Context) { } // Callbacks [START] ----------------------------------------------------------- +func (ds *DeviceService) peripheralConfigured(pname string) { + // We need to retrigger field subscription here + fields := ds.triggerFieldSubscription() + ds.Messages <- fmt.Sprintf("subscribed to fields: %+v\n", fields) +} // Callbacks [END] ------------------------------------------------------------- diff --git a/services/devices_lookup.go b/services/devices_lookup.go index 499b8ea..3c46eeb 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -85,7 +85,8 @@ type PeripheralStateStore struct { // Messaging for UI and stuff Messages chan string // Callbacks - telemetryProvider func() (string, error) + telemetryProvider func() (string, error) + onPeripheralConfigured func(string) // Internal State isStreaming bool } @@ -204,6 +205,12 @@ func (pss *PeripheralStateStore) OnStopStream() { pss.mu.Lock() pss.isStreaming = false pss.mu.Unlock() + + for _, state := range pss.GetStates() { + if state.State == DeviceIsStreaming { + pss.setDeviceConfigured(state.device.Name) + } + } } // "Events" [END] -------------------------------------------------------------- @@ -270,8 +277,10 @@ func (pss *PeripheralStateStore) setDeviceConfigured(pname string) { pss.Logger.Info("device is configured and ready for data", "device", pname) pss.mu.Lock() - defer pss.mu.Unlock() pss.store[pname].State = DeviceIsConfigured + pss.mu.Unlock() + + pss.onPeripheralConfigured(pname) } func (pss *PeripheralStateStore) setDeviceIsStreaming(pname string) { diff --git a/services/services.go b/services/services.go index 18aff69..d8f1ec7 100644 --- a/services/services.go +++ b/services/services.go @@ -26,9 +26,10 @@ func NewOrchestrator(logger *slog.Logger) (*Orchestrator, error) { // Setup device service callbacks devService.telemetryProvider = telemService.GetTelemetryProviderName + devService.triggerFieldSubscription = telemService.SubscribeToAllFields // Setup telemetry service callbacks - telemService.peripheralProvider = devService.GetDevices + telemService.getRequiredFields = devService.GetRequiredFields return &Orchestrator{ DeviceService: devService, diff --git a/services/telemetry.go b/services/telemetry.go index 7ca2112..2f9983d 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -7,7 +7,6 @@ import ( "sync" "time" - "esdi/peripheral" "esdi/providers" "esdi/telemetry" telem "esdi/telemetry" @@ -37,7 +36,8 @@ type TelemetryService struct { healthCheckCancel context.CancelFunc // Callbacks // Devices data request - peripheralProvider func() []peripheral.Peripheral + // peripheralProvider func() []peripheral.Peripheral + getRequiredFields func() []telemetry.FieldID } func NewTelemetryService( @@ -114,23 +114,13 @@ func (t *TelemetryService) UnsubscribeListener(id string) { } } -func (t *TelemetryService) SubscribeToFields() []telem.FieldID { - seen := make(map[telemetry.FieldID]struct{}) - var allFields []telemetry.FieldID +func (t *TelemetryService) SubscribeToAllFields() []telem.FieldID { + fields := t.getRequiredFields() - for _, dev := range t.peripheralProvider() { - for _, field := range dev.RequiredFields() { - if _, exists := seen[field]; !exists { - seen[field] = struct{}{} - allFields = append(allFields, field) - } - } - } + t.logger.Debug("requested fields", "fields", fields) + t.activeProvider.Subscribe(fields) - t.logger.Debug("requested fields", "fields", allFields) - t.activeProvider.Subscribe(allFields) - - return allFields + return fields } // Listener Control [END] ------------------------------------------------------ diff --git a/tui/internal/controllers/device.go b/tui/internal/controllers/device.go index 9d3d653..86f67c7 100644 --- a/tui/internal/controllers/device.go +++ b/tui/internal/controllers/device.go @@ -93,7 +93,7 @@ func (mc *DeviceController) AddDeviceAPIListItems() { mc.StreamCtrl.StreamView.Flex, ) - mc.StreamCtrl.SetInternalState() + // mc.StreamCtrl.SetInternalState() mc.App.SetFocus(mc.StreamCtrl.StreamView.Options.Form) }) diff --git a/tui/internal/controllers/streaming.go b/tui/internal/controllers/streaming.go index 4fd57c1..8f40005 100644 --- a/tui/internal/controllers/streaming.go +++ b/tui/internal/controllers/streaming.go @@ -154,8 +154,8 @@ func (sc *StreamingCtrl) updateStream() { // Performance reasoning: this is not used during the high frequency data transmission // so we can get away with using a map for convenience here func (sc *StreamingCtrl) SetInternalState() { - fields := sc.TelemServ.SubscribeToFields() - sc.Messages <- fmt.Sprintf("Subscribed to fields: %+v\n", fields) + // fields := sc.TelemServ.SubscribeToAllFields() + // sc.Messages <- fmt.Sprintf("Subscribed to fields: %+v\n", fields) } func (sc *StreamingCtrl) listenToUIStream() { From 2952528a605408fb91927e0cc370fbec561d6408 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Wed, 23 Sep 2026 17:41:06 +0100 Subject: [PATCH 36/41] partial subscriptions not really partial. they just happen per peripheral now --- constants/constants.go | 7 +++ providers/beamng/beamng.go | 92 +++++++++++++++++++++++------------- providers/iracing/iracing.go | 88 +++++++++++++++++++++------------- services/devices.go | 26 ++-------- services/devices_lookup.go | 15 ++++-- services/services.go | 4 +- services/telemetry.go | 10 ++-- telemetry/data.go | 17 +++---- telemetry/fuel_calculator.go | 6 +++ telemetry/provider.go | 2 +- telemetry/rpm_lights.go | 6 +++ telemetry/virtual_field.go | 9 ++++ 12 files changed, 172 insertions(+), 110 deletions(-) create mode 100644 telemetry/virtual_field.go diff --git a/constants/constants.go b/constants/constants.go index b5d3305..7eb152c 100644 --- a/constants/constants.go +++ b/constants/constants.go @@ -1,6 +1,13 @@ package constants +// Provider Names const ( IRacingProviderName = "iRacing" BeamNGProviderName = "BeamNG.drive" ) + +// Virtual Field Names +const ( + FuelCalculatorName = "FuelCalculator" + RPMLightsName = "RPMLights" +) diff --git a/providers/beamng/beamng.go b/providers/beamng/beamng.go index 7e371cc..f8abeb2 100644 --- a/providers/beamng/beamng.go +++ b/providers/beamng/beamng.go @@ -28,6 +28,9 @@ type BeamNG struct { data *telemetry.TelemetryData updaters [telemetry.MaxFields]func(*telemetry.TelemetryField) + // Field Subscription management + boundFields map[telemetry.FieldID]bool + // stream control wg sync.WaitGroup streamCancel context.CancelFunc @@ -51,7 +54,9 @@ func NewBeamNGProvider(logger *slog.Logger, opts *bngsdk.Options) (*BeamNG, erro data: telemetry.NewTelemetryData(), SDK: beam, og: &bngsdk.Outgauge{}, - ticker: time.NewTicker(time.Second / 60), + // Field subscription management + boundFields: make(map[telemetry.FieldID]bool, telemetry.MaxFields), + ticker: time.NewTicker(time.Second / 60), } provider.updaters = [telemetry.MaxFields]func(*telemetry.TelemetryField){ @@ -115,47 +120,68 @@ func (b *BeamNG) Stream() (<-chan telemetry.TelemetryData, error) { return ch, nil } -func (b *BeamNG) Subscribe(requestFields []telemetry.FieldID) { - // NOTE: document how the Subscribe funtion works - slog.Debug(fmt.Sprintf("Len Req: %d\n", len(requestFields))) +// TODO: this function is exactly the same in BeamNG drive now, and I reckon it will be the same +// In plenty other things. I should make it TelemetryData method +func (i *BeamNG) subscribe(fields []telemetry.FieldID) []string { + newSubscriptions := make([]string, 0, telemetry.MaxFields) - b.data.ActiveBinds = make([]telemetry.BoundField, 0, len(requestFields)) + i.mut.Lock() + defer i.mut.Unlock() - // First we must add the virtual fields - // we will add their dependencies and the primitives to a slice - pendingBinds := make([]telemetry.FieldID, telemetry.MaxFields) - - for _, id := range requestFields { - switch id { - case telemetry.RPMStateColour: - b.data.VirtualBinds = append(b.data.VirtualBinds, telemetry.NewRPMLights()) - case telemetry.FCCurrentLap: - b.data.VirtualBinds = append(b.data.VirtualBinds, - telemetry.NewFuelCalculator(slog.Default().WithGroup("FUEL CALC"))) - default: - // primitive telemetry field - pendingBinds = append(pendingBinds, id) - } - } - - boundCheck := make(map[telemetry.FieldID]bool) - - // Now that we know all the fields we need to bind we follow the binding procedure - for _, id := range pendingBinds { - // Check if we already bound this FieldID - if boundCheck[id] { + for _, id := range fields { + if i.boundFields[id] { continue } - binding := telemetry.BoundField{ + i.data.ActiveBinds[id] = telemetry.BoundField{ ID: id, } - - b.data.ActiveBinds = append(b.data.ActiveBinds, binding) - boundCheck[id] = true + i.boundFields[id] = true + newSubscriptions = append(newSubscriptions, telemetry.FieldNames[id]) } - slog.Debug(fmt.Sprintf("Subscribed: %+v\n", b.data.ActiveBinds)) + // unsubscribe from fields we many not need anymore + for key, bound := range i.boundFields { + if _, ok := i.data.ActiveBinds[key]; bound && !ok { + delete(i.data.ActiveBinds, key) + i.boundFields[key] = false + } + } + + return newSubscriptions +} + +func (b *BeamNG) Subscribe(requestFields []telemetry.FieldID) []string { + // NOTE: document how the Subscribe funtion works + slog.Debug(fmt.Sprintf("Len Req: %d\n", len(requestFields))) + + // First we must add the virtual fields + // we will add their dependencies and the primitives to a slice + toBind := make([]telemetry.FieldID, telemetry.MaxFields) + + b.mut.Lock() + for _, id := range requestFields { + switch id { + case telemetry.RPMStateColour: + rpmLights := telemetry.NewRPMLights() + b.data.VirtualBinds[rpmLights.Name()] = rpmLights + toBind = append(toBind, rpmLights.EnsureSubscribed()...) + case telemetry.FCCurrentLap: + fuelCalc := telemetry.NewFuelCalculator(b.logger.WithGroup("FUEL CALC")) + b.data.VirtualBinds[fuelCalc.Name()] = fuelCalc + toBind = append(toBind, fuelCalc.EnsureSubscribed()...) + default: + // primitive telemetry field + toBind = append(toBind, id) + } + } + b.mut.Unlock() + + newSubs := b.subscribe(toBind) + + slog.Debug(fmt.Sprintf("Subscribed: %+v\n", toBind)) + + return newSubs } // Internal diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index d271ea6..bcf9c93 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -29,13 +29,14 @@ type IRacing struct { mut sync.Mutex data *telemetry.TelemetryData updaters [telemetry.MaxFields]func(*telemetry.TelemetryField) + // Field Subscription management + boundFields map[telemetry.FieldID]bool // Timing information ticker *time.Ticker // ticker will keep polling intervals constant // Stream - wg sync.WaitGroup - // streamCh chan telemetry.TelemetryData + wg sync.WaitGroup streamCancel context.CancelFunc } @@ -55,6 +56,8 @@ func NewIRacingProvider( logger: logger, SDK: sdk, data: telemetry.NewTelemetryData(), + // Field subscription management + boundFields: make(map[telemetry.FieldID]bool, telemetry.MaxFields), // TODO: make this configurable from the user side ticker: time.NewTicker(time.Second / 60), } @@ -225,46 +228,67 @@ func (i *IRacing) StopStream() { i.streamCancel = nil } -func (i *IRacing) Subscribe(requestFields []telemetry.FieldID) { - i.logger.Debug(fmt.Sprintf("Len Req: %d\n", len(requestFields))) +// TODO: this function is exactly the same in BeamNG drive now, and I reckon it will be the same +// In plenty other things. I should make it TelemetryData method +func (i *IRacing) subscribe(fields []telemetry.FieldID) []string { + newSubscriptions := make([]string, 0, telemetry.MaxFields) - i.data.ActiveBinds = make([]telemetry.BoundField, 0, len(requestFields)) + i.mut.Lock() + defer i.mut.Unlock() - // First we must add the virtual fields - // we will add their dependencies and the primitives to a slice - pendingBinds := make([]telemetry.FieldID, 0, telemetry.MaxFields) - - for _, id := range requestFields { - switch id { - case telemetry.RPMStateColour: - i.data.VirtualBinds = append(i.data.VirtualBinds, telemetry.NewRPMLights()) - case telemetry.FCCurrentLap: - i.data.VirtualBinds = append(i.data.VirtualBinds, - telemetry.NewFuelCalculator(i.logger.WithGroup("FUEL CALC"))) - default: - // primitive telemetry field - pendingBinds = append(pendingBinds, id) - } - } - - boundCheck := make(map[telemetry.FieldID]bool) - - // Now that we know all the fields we need to bind we follow the binding procedure - for _, id := range pendingBinds { - // Check if we already bound this FieldID - if boundCheck[id] { + for _, id := range fields { + if i.boundFields[id] { continue } - binding := telemetry.BoundField{ + i.data.ActiveBinds[id] = telemetry.BoundField{ ID: id, } - - i.data.ActiveBinds = append(i.data.ActiveBinds, binding) - boundCheck[id] = true + i.boundFields[id] = true + newSubscriptions = append(newSubscriptions, telemetry.FieldNames[id]) } + // unsubscribe from fields we many not need anymore + for key, bound := range i.boundFields { + if _, ok := i.data.ActiveBinds[key]; bound && !ok { + delete(i.data.ActiveBinds, key) + i.boundFields[key] = false + } + } + + return newSubscriptions +} + +func (i *IRacing) Subscribe(requestFields []telemetry.FieldID) []string { + i.logger.Debug(fmt.Sprintf("Len Req: %d\n", len(requestFields))) + + // First we must add the virtual fields + // we will add their dependencies and the primitives to a slice + toBind := make([]telemetry.FieldID, 0, telemetry.MaxFields) + + i.mut.Lock() + for _, id := range requestFields { + switch id { + case telemetry.RPMStateColour: + rpmLights := telemetry.NewRPMLights() + i.data.VirtualBinds[rpmLights.Name()] = rpmLights + toBind = append(toBind, rpmLights.EnsureSubscribed()...) + case telemetry.FCCurrentLap: + fuelCalc := telemetry.NewFuelCalculator(i.logger.WithGroup("FUEL CALC")) + i.data.VirtualBinds[fuelCalc.Name()] = fuelCalc + toBind = append(toBind, fuelCalc.EnsureSubscribed()...) + default: + // primitive telemetry field + toBind = append(toBind, id) + } + } + i.mut.Unlock() + + newSubs := i.subscribe(toBind) + i.logger.Debug(fmt.Sprintf("Subscribed: %+v\n", i.data.ActiveBinds)) + + return newSubs } func (i *IRacing) Name() string { diff --git a/services/devices.go b/services/devices.go index 8448d90..8bb2c49 100644 --- a/services/devices.go +++ b/services/devices.go @@ -26,7 +26,7 @@ type DeviceService struct { // Callbacks // Telemetry service data fetchers telemetryProvider func() (string, error) - triggerFieldSubscription func() []telemetry.FieldID + triggerFieldSubscription func([]telemetry.FieldID) []string } func NewDeviceService(logger *slog.Logger, msg chan string) *DeviceService { @@ -80,24 +80,6 @@ func (ds *DeviceService) PeripheralExists(pname string) bool { return err == nil } -func (ds *DeviceService) GetRequiredFields() []telemetry.FieldID { - // NOTE: this can be optimized, not that it matters at this stage, but if - // it runs while telemetry is running we want it optimized I guess - seen := make(map[telemetry.FieldID]struct{}) - var allFields []telemetry.FieldID - - for _, dev := range ds.GetDevices() { - for _, field := range dev.RequiredFields() { - if _, exists := seen[field]; !exists { - seen[field] = struct{}{} - allFields = append(allFields, field) - } - } - } - - return allFields -} - // Getters [END] --------------------------------------------------------------- // Actions [START] ------------------------------------------------------------- @@ -168,10 +150,10 @@ func (ds *DeviceService) transmit(ctx context.Context) { } // Callbacks [START] ----------------------------------------------------------- -func (ds *DeviceService) peripheralConfigured(pname string) { +func (ds *DeviceService) peripheralConfigured(pname string, fields []telemetry.FieldID) { // We need to retrigger field subscription here - fields := ds.triggerFieldSubscription() - ds.Messages <- fmt.Sprintf("subscribed to fields: %+v\n", fields) + subscribedTo := ds.triggerFieldSubscription(fields) + ds.Messages <- fmt.Sprintf("subscribed to fields: %q\n", subscribedTo) } // Callbacks [END] ------------------------------------------------------------- diff --git a/services/devices_lookup.go b/services/devices_lookup.go index 3c46eeb..788e553 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -10,6 +10,7 @@ import ( "esdi/devices" "esdi/peripheral" + "esdi/telemetry" ) var ( @@ -86,7 +87,7 @@ type PeripheralStateStore struct { Messages chan string // Callbacks telemetryProvider func() (string, error) - onPeripheralConfigured func(string) + onPeripheralConfigured func(string, []telemetry.FieldID) // Internal State isStreaming bool } @@ -184,6 +185,15 @@ func (pss *PeripheralStateStore) GetStreamingState() bool { return pss.isStreaming } +func (pss *PeripheralStateStore) GetPeripheralFields(pname string) []telemetry.FieldID { + per, err := pss.GetState(pname) + if err != nil { + return nil + } + + return per.Peripheral.RequiredFields() +} + // "Events" [START] ------------------------------------------------------------ func (ds *DeviceService) onDeviceTimedOut(pname string) { ds.PSS.setDeviceTimedOut(pname) @@ -280,7 +290,7 @@ func (pss *PeripheralStateStore) setDeviceConfigured(pname string) { pss.store[pname].State = DeviceIsConfigured pss.mu.Unlock() - pss.onPeripheralConfigured(pname) + pss.onPeripheralConfigured(pname, pss.GetPeripheralFields(pname)) } func (pss *PeripheralStateStore) setDeviceIsStreaming(pname string) { @@ -347,7 +357,6 @@ func (pss *PeripheralStateStore) configurePeripheral( } onSuccess(pname) - pss.setDeviceConfigured(pname) }() } diff --git a/services/services.go b/services/services.go index d8f1ec7..f8960fc 100644 --- a/services/services.go +++ b/services/services.go @@ -26,10 +26,10 @@ func NewOrchestrator(logger *slog.Logger) (*Orchestrator, error) { // Setup device service callbacks devService.telemetryProvider = telemService.GetTelemetryProviderName - devService.triggerFieldSubscription = telemService.SubscribeToAllFields + devService.triggerFieldSubscription = telemService.SubscribeToFields // Setup telemetry service callbacks - telemService.getRequiredFields = devService.GetRequiredFields + // telemService.getRequiredFields = devService.GetRequiredFields return &Orchestrator{ DeviceService: devService, diff --git a/services/telemetry.go b/services/telemetry.go index 2f9983d..e05e177 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -37,7 +37,7 @@ type TelemetryService struct { // Callbacks // Devices data request // peripheralProvider func() []peripheral.Peripheral - getRequiredFields func() []telemetry.FieldID + // getRequiredFields func() []telemetry.FieldID } func NewTelemetryService( @@ -114,13 +114,11 @@ func (t *TelemetryService) UnsubscribeListener(id string) { } } -func (t *TelemetryService) SubscribeToAllFields() []telem.FieldID { - fields := t.getRequiredFields() - +func (t *TelemetryService) SubscribeToFields(fields []telemetry.FieldID) []string { t.logger.Debug("requested fields", "fields", fields) - t.activeProvider.Subscribe(fields) + subscribed := t.activeProvider.Subscribe(fields) - return fields + return subscribed } // Listener Control [END] ------------------------------------------------------ diff --git a/telemetry/data.go b/telemetry/data.go index 166b17c..52d8dda 100644 --- a/telemetry/data.go +++ b/telemetry/data.go @@ -23,13 +23,6 @@ type FieldMapper struct { Transform func(any) uint64 } -// VirtualField will derive data from telemetry primitives -// So fuel per lap predictions, compound gauge lights and so on -type VirtualField interface { - Process(td *TelemetryData) - EnsureSubscribed() []FieldID -} - // NOTE: Update the iracing SDK to write data to the same map ALWAYS, then // I can bind that address and read directly from there on the transform @@ -228,16 +221,18 @@ func GetFieldID(name string) (FieldID, bool) { } // TelemetryData is -// I need to find a way of having the values be per window or some other type TelemetryData struct { Values [MaxFields]TelemetryField - ActiveBinds []BoundField - VirtualBinds []VirtualField + ActiveBinds map[FieldID]BoundField + VirtualBinds map[string]VirtualField InitialTime time.Time PenultimateDataPoll time.Time LastDataPoll time.Time } func NewTelemetryData() *TelemetryData { - return &TelemetryData{} + return &TelemetryData{ + ActiveBinds: make(map[FieldID]BoundField, MaxFields), + VirtualBinds: make(map[string]VirtualField), + } } diff --git a/telemetry/fuel_calculator.go b/telemetry/fuel_calculator.go index 548bbc8..f7a8b83 100644 --- a/telemetry/fuel_calculator.go +++ b/telemetry/fuel_calculator.go @@ -5,6 +5,8 @@ import ( "log/slog" "strconv" "sync" + + "esdi/constants" ) // NOTE: for managing fuel consumption and predictions we need to filter out @@ -264,3 +266,7 @@ func (fc *FuelCalculator) resetHistory() { func (fc *FuelCalculator) EnsureSubscribed() []FieldID { return []FieldID{FuelLevel, LapNumber} } + +func (fc *FuelCalculator) Name() string { + return constants.FuelCalculatorName +} diff --git a/telemetry/provider.go b/telemetry/provider.go index 43c8370..3d86c4c 100644 --- a/telemetry/provider.go +++ b/telemetry/provider.go @@ -6,7 +6,7 @@ import "time" type TelemetryProvider interface { StopStream() Stream() (<-chan TelemetryData, error) - Subscribe([]FieldID) + Subscribe([]FieldID) []string IsAlive(time.Duration) bool Name() string Close() diff --git a/telemetry/rpm_lights.go b/telemetry/rpm_lights.go index 16d4ae1..efca00e 100644 --- a/telemetry/rpm_lights.go +++ b/telemetry/rpm_lights.go @@ -1,5 +1,7 @@ package telemetry +import "esdi/constants" + type RPMLights struct { State string } @@ -28,3 +30,7 @@ func (rl *RPMLights) Process(td *TelemetryData) { func (rl *RPMLights) EnsureSubscribed() []FieldID { return []FieldID{RPM} } + +func (rl *RPMLights) Name() string { + return constants.RPMLightsName +} diff --git a/telemetry/virtual_field.go b/telemetry/virtual_field.go new file mode 100644 index 0000000..cfde6f7 --- /dev/null +++ b/telemetry/virtual_field.go @@ -0,0 +1,9 @@ +package telemetry + +// VirtualField will derive data from telemetry primitives +// So fuel per lap predictions, compound gauge lights and so on +type VirtualField interface { + Name() string + Process(td *TelemetryData) + EnsureSubscribed() []FieldID +} From d677c66a223b83c417946db94cc4dffa74feb7a4 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 25 Sep 2026 11:06:33 +0100 Subject: [PATCH 37/41] automated stream start May return the user ability of stopping and starting but its really what we want --- services/devices.go | 7 ++++++- services/devices_lookup.go | 12 ++++++++++++ services/services.go | 2 +- services/telemetry.go | 13 +++++++------ services/telemetry_events.go | 4 ++++ tui/internal/controllers/streaming.go | 26 ++------------------------ 6 files changed, 32 insertions(+), 32 deletions(-) diff --git a/services/devices.go b/services/devices.go index 8bb2c49..875b6fb 100644 --- a/services/devices.go +++ b/services/devices.go @@ -83,14 +83,17 @@ func (ds *DeviceService) PeripheralExists(pname string) bool { // Getters [END] --------------------------------------------------------------- // Actions [START] ------------------------------------------------------------- -func (ds *DeviceService) StartStream() { +func (ds *DeviceService) StartStream(ch <-chan telemetry.TelemetryData) { // NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this + ds.SetTelemetryChannel(ch) + var ctx context.Context ctx, ds.streamCancel = context.WithCancel(context.Background()) ds.PSS.OnStartStream() go ds.transmit(ctx) + ds.Messages <- "Device service started stream\n" } func (ds *DeviceService) StopStream() { @@ -154,6 +157,8 @@ func (ds *DeviceService) peripheralConfigured(pname string, fields []telemetry.F // We need to retrigger field subscription here subscribedTo := ds.triggerFieldSubscription(fields) ds.Messages <- fmt.Sprintf("subscribed to fields: %q\n", subscribedTo) + + ds.PSS.OnStartStreamPeripheral(pname) } // Callbacks [END] ------------------------------------------------------------- diff --git a/services/devices_lookup.go b/services/devices_lookup.go index 788e553..0034e09 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -211,6 +211,17 @@ func (pss *PeripheralStateStore) OnStartStream() { } } +func (pss *PeripheralStateStore) OnStartStreamPeripheral(pname string) { + state, err := pss.GetState(pname) + if err != nil { + return + } + + if state.State == DeviceIsConfigured { + pss.setDeviceIsStreaming(pname) + } +} + func (pss *PeripheralStateStore) OnStopStream() { pss.mu.Lock() pss.isStreaming = false @@ -349,6 +360,7 @@ func (pss *PeripheralStateStore) configurePeripheral( onFailure(pname) return } + pss.Messages <- fmt.Sprintf("Configuring peripheral for provider: %s\n", provider) err = state.Peripheral.Setup(provider) if err != nil { diff --git a/services/services.go b/services/services.go index f8960fc..8356ddf 100644 --- a/services/services.go +++ b/services/services.go @@ -29,7 +29,7 @@ func NewOrchestrator(logger *slog.Logger) (*Orchestrator, error) { devService.triggerFieldSubscription = telemService.SubscribeToFields // Setup telemetry service callbacks - // telemService.getRequiredFields = devService.GetRequiredFields + telemService.startedStreaming = devService.StartStream return &Orchestrator{ DeviceService: devService, diff --git a/services/telemetry.go b/services/telemetry.go index e05e177..9be6a4d 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -35,6 +35,7 @@ type TelemetryService struct { CtxHealthcheck context.Context healthCheckCancel context.CancelFunc // Callbacks + startedStreaming func(ch <-chan telemetry.TelemetryData) // Devices data request // peripheralProvider func() []peripheral.Peripheral // getRequiredFields func() []telemetry.FieldID @@ -204,21 +205,17 @@ func (t *TelemetryService) StopStream() { t.isStreaming = false } -func (t *TelemetryService) StartStream() { - slog.Debug("Stream started") - +func (t *TelemetryService) StartStream() <-chan telemetry.TelemetryData { // Start the new stream if t.activeProvider == nil { slog.Debug("there's no active provider. not starting the stream") - return + return nil } // Stop the provider healthcheck t.healthCheckCancel() simInCh, _ := t.activeProvider.Stream() - // TODO: the provider needs to be able to tell the data has stopped - // so we can restart the provider lookup routine // Create the context so we can control the lifecycle ctx, cancel := context.WithCancel(context.Background()) @@ -227,6 +224,10 @@ func (t *TelemetryService) StartStream() { // Multiplex this data go t.multiplexData(ctx, simInCh) t.isStreaming = true + + t.Messages <- "Provider has started streaming data\n" + + return simInCh } func (t *TelemetryService) multiplexData(ctx context.Context, dataCh <-chan telem.TelemetryData) { diff --git a/services/telemetry_events.go b/services/telemetry_events.go index 6774a63..603903d 100644 --- a/services/telemetry_events.go +++ b/services/telemetry_events.go @@ -16,6 +16,7 @@ func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) { // Attach to the provider t.logger.Info("found provider for " + prov.Name()) t.Messages <- fmt.Sprintf("Found provider \"%s\"\n", prov.Name()) + err := t.SwitchProvider(prov) if err != nil { t.Messages <- fmt.Sprintf("Failed to switch to provider: %+v\n", err.Error()) @@ -26,6 +27,9 @@ func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) { // Start the healthcheck on our provider so we can drop it if it stops t.CtxHealthcheck, t.healthCheckCancel = context.WithCancel(context.Background()) go t.ProviderMonitor(t.CtxHealthcheck) + + ch := t.StartStream() + t.startedStreaming(ch) } func (t *TelemetryService) onProviderStopsMidStream() { diff --git a/tui/internal/controllers/streaming.go b/tui/internal/controllers/streaming.go index 8f40005..1fc6d0b 100644 --- a/tui/internal/controllers/streaming.go +++ b/tui/internal/controllers/streaming.go @@ -88,23 +88,9 @@ func (sc *StreamingCtrl) registerHooks() { } } +// TODO: this isn't the startstop method/action anymore. It should show up the stream +// visualizer - TODO: add metrics to the visualizer too, instead of just data func (sc *StreamingCtrl) StartStop() { - if sc.TelemServ.IsStreaming() { - slog.Info("stopping stream") - - sc.TelemServ.StopStream() - sc.DevService.StopStream() - - sc.isRunning = false - return - } - - // stream is not running, we have to start it now - // NOTE: - // Subscribe the only existing device - needs to be discovered by now - slog.Debug("setting the data stream for device servie") - sc.DevService.SetTelemetryChannel(sc.TelemServ.SubscribeListener("DeviceService", 1)) - dev, err := sc.DevService.GetPeripheral(uidevice.NAME) if err == nil { if uiDev, ok := dev.(*uidevice.UIDevice); ok { @@ -112,14 +98,6 @@ func (sc *StreamingCtrl) StartStop() { go sc.listenToUIStream() } } - - slog.Debug("starting services") - sc.DevService.StartStream() - sc.TelemServ.StartStream() - - sc.isRunning = true - - slog.Debug("starting stream") } func (sc *StreamingCtrl) parseStreamUpdateForm(form *views.StreamOptionsView) (*models.StreamOptions, error) { From 584d13e1fd4feae28118c1f453ecf6f0960c89ab Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 25 Sep 2026 14:47:41 +0100 Subject: [PATCH 38/41] removed unecessary logs from the providers and also implemented the connection dropped into beamng This needs to be reworked tho. There's lots of code thats used both in BeamNG and iRacing. I believe other providers will have the same issue --- providers/beamng/beamng.go | 23 +++++++++++------------ providers/iracing/iracing.go | 4 ++-- 2 files changed, 13 insertions(+), 14 deletions(-) diff --git a/providers/beamng/beamng.go b/providers/beamng/beamng.go index f8abeb2..7c46a57 100644 --- a/providers/beamng/beamng.go +++ b/providers/beamng/beamng.go @@ -186,13 +186,11 @@ func (b *BeamNG) Subscribe(requestFields []telemetry.FieldID) []string { // Internal -func (b *BeamNG) readData() { - slog.Debug("READING THIS DATA") +func (b *BeamNG) readData() error { ogSnapshot, err := b.SDK.Update() - slog.Debug("THE DATA WAS READ") if err != nil { slog.Error("Error getting data", "error", err) - return + return err } b.mut.Lock() @@ -200,22 +198,20 @@ func (b *BeamNG) readData() { defer b.mut.Unlock() // Read 1 to 1 data - slog.Debug("Reading normal data binds") for _, bind := range b.data.ActiveBinds { - slog.Debug("Current bind: ", "id", bind.ID) b.updaters[bind.ID](&b.data.Values[bind.ID]) } // Set up virtual binds - slog.Debug("Entering virtual binds loop") for _, vBind := range b.data.VirtualBinds { // NOTE: delete the logs here, they are really bad - slog.Debug("Processing virtual binds") vBind.Process(b.data) } b.data.PenultimateDataPoll = b.data.LastDataPoll b.data.LastDataPoll = time.Now() + + return nil } func (b *BeamNG) stream(ctx context.Context) <-chan telemetry.TelemetryData { @@ -239,14 +235,17 @@ func (b *BeamNG) stream(ctx context.Context) <-chan telemetry.TelemetryData { case <-ctx.Done(): return case <-b.ticker.C: - slog.Debug("READING DATA") - b.readData() - slog.Debug("READ DATA") + err := b.readData() + if err != nil { + if b.streamCancel != nil { + b.streamCancel() + } + } // Publish data select { case outCh <- *b.data: - slog.Debug("PUBLISHED DATA") + // Successfuly read and sent data default: // skip this data, don't allow publishers to lag behind } diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index bcf9c93..c8c90d3 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -143,8 +143,8 @@ func (i *IRacing) stream(ctx context.Context) <-chan telemetry.TelemetryData { // Put this into the configuration file consecutiveTimeouts := 0 - maxTimeouts := 30 - dataEvTimeout := 100 + maxTimeouts := 10 + dataEvTimeout := 30 for { // Explicitly intercept cancellation select { From 48b10afbba332e95e73d9564ba858456e891c62a Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 25 Sep 2026 14:48:29 +0100 Subject: [PATCH 39/41] devices and providers can now drop mid stream and then reconnect without impact --- devices/cdashdisplay/display.go | 7 +++++++ services/devices_events.go | 5 +++++ services/devices_lookup.go | 4 ++-- services/services.go | 1 + services/telemetry.go | 4 +++- services/telemetry_events.go | 6 ++++++ 6 files changed, 24 insertions(+), 3 deletions(-) diff --git a/devices/cdashdisplay/display.go b/devices/cdashdisplay/display.go index 51b84a0..9294d10 100644 --- a/devices/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -405,6 +405,11 @@ func (d *CDashDisplay) UnloadLayout() error { return nil } +func (cds *CDashDisplay) resetState() { + cds.fieldToWindows = make(map[telemetry.FieldID][]int16) + cds.State.Layout = NewLayoutTree() +} + func (cds *CDashDisplay) reset() error { err := cds.WT.SendCommand(resetCMDID, []byte{0x01, 0x02, 0x03, 0x04}, nil) if err != nil { @@ -413,6 +418,8 @@ func (cds *CDashDisplay) reset() error { time.Sleep(3000 * time.Millisecond) + cds.resetState() + return nil } diff --git a/services/devices_events.go b/services/devices_events.go index 5e568ea..bd45330 100644 --- a/services/devices_events.go +++ b/services/devices_events.go @@ -1 +1,6 @@ package services + +func (ds *DeviceService) OnStoppedMidStream() { + // Need to make every device be unconfigured + ds.StopStream() +} diff --git a/services/devices_lookup.go b/services/devices_lookup.go index 0034e09..b53da2e 100644 --- a/services/devices_lookup.go +++ b/services/devices_lookup.go @@ -228,8 +228,8 @@ func (pss *PeripheralStateStore) OnStopStream() { pss.mu.Unlock() for _, state := range pss.GetStates() { - if state.State == DeviceIsStreaming { - pss.setDeviceConfigured(state.device.Name) + if state.State > DeviceIsConfigured { + pss.setDeviceUnconfigured(state.device.Name) } } } diff --git a/services/services.go b/services/services.go index 8356ddf..7686f6a 100644 --- a/services/services.go +++ b/services/services.go @@ -30,6 +30,7 @@ func NewOrchestrator(logger *slog.Logger) (*Orchestrator, error) { // Setup telemetry service callbacks telemService.startedStreaming = devService.StartStream + telemService.providerStoppedMidStream = devService.OnStoppedMidStream return &Orchestrator{ DeviceService: devService, diff --git a/services/telemetry.go b/services/telemetry.go index 9be6a4d..f449ce6 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -35,7 +35,8 @@ type TelemetryService struct { CtxHealthcheck context.Context healthCheckCancel context.CancelFunc // Callbacks - startedStreaming func(ch <-chan telemetry.TelemetryData) + startedStreaming func(ch <-chan telemetry.TelemetryData) + providerStoppedMidStream func() // Devices data request // peripheralProvider func() []peripheral.Peripheral // getRequiredFields func() []telemetry.FieldID @@ -139,6 +140,7 @@ func (t *TelemetryService) dropActiveProvider() { t.cancelForward() } + // NOTE: can we move the stop stream into the provider Close() method? t.activeProvider.StopStream() t.activeProvider.Close() t.activeProvider = nil diff --git a/services/telemetry_events.go b/services/telemetry_events.go index 603903d..8416f21 100644 --- a/services/telemetry_events.go +++ b/services/telemetry_events.go @@ -30,6 +30,8 @@ func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) { ch := t.StartStream() t.startedStreaming(ch) + + t.Messages <- "provider switch completed" } func (t *TelemetryService) onProviderStopsMidStream() { @@ -38,6 +40,10 @@ func (t *TelemetryService) onProviderStopsMidStream() { // if the stream stopped we have to restart the devices and everything t.Messages <- "Telemetry provider stopped mid stream\n" t.logger.Info("cleaning dropped provider and restarting lookup service") + t.dropActiveProvider() go t.FindProvider(t.CtxMonitor) + + // Tell the devices service that we lost the thing + t.providerStoppedMidStream() } From db30d9146d6bc04b6218dbf5ee1c3d0c70517dd8 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 25 Sep 2026 15:24:18 +0100 Subject: [PATCH 40/41] correct the go.mod --- go.mod | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/go.mod b/go.mod index 6dbcbdb..c54d480 100644 --- a/go.mod +++ b/go.mod @@ -1,11 +1,11 @@ module esdi -go 1.27.0 +go 1.26.0 require ( github.com/ESilva15/ESgoRepl v0.1.0 - github.com/ESilva15/gobngsdk v1.1.3 - github.com/ESilva15/goirsdk v0.3.0 + github.com/ESilva15/gobngsdk v1.2.0 + github.com/ESilva15/goirsdk v0.3.8 github.com/arl/statsviz v0.8.0 github.com/gdamore/tcell/v2 v2.8.1 github.com/rivo/tview v0.42.0 From d102a45bee6a84a9136d25e7b656b1f35e570440 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 25 Sep 2026 18:36:21 +0100 Subject: [PATCH 41/41] update the versions of the dependencies --- go.mod | 3 +-- go.sum | 10 ++++------ 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/go.mod b/go.mod index c54d480..d0b387a 100644 --- a/go.mod +++ b/go.mod @@ -3,9 +3,8 @@ module esdi go 1.26.0 require ( - github.com/ESilva15/ESgoRepl v0.1.0 github.com/ESilva15/gobngsdk v1.2.0 - github.com/ESilva15/goirsdk v0.3.8 + github.com/ESilva15/goirsdk v0.3.9 github.com/arl/statsviz v0.8.0 github.com/gdamore/tcell/v2 v2.8.1 github.com/rivo/tview v0.42.0 diff --git a/go.sum b/go.sum index 1ed480f..d61c20c 100644 --- a/go.sum +++ b/go.sum @@ -1,9 +1,7 @@ -github.com/ESilva15/ESgoRepl v0.1.0 h1:hOVcRBfdP8Yw1kLr2tFoM3SetV7vxFswKjzfAtq8UgM= -github.com/ESilva15/ESgoRepl v0.1.0/go.mod h1:O2JQMyEgHy0zf9UvzvLNvp2w95T2uazc3torrzRmG9Y= -github.com/ESilva15/gobngsdk v1.1.3 h1:CFaz2KjHKnBLrQuEN1QHOd1761cWM/rmTwLpSLrgbe4= -github.com/ESilva15/gobngsdk v1.1.3/go.mod h1:cKLaZRgM0tGGXDvosaSjHnxeyC5Y6rg7zCLqEUJnOzw= -github.com/ESilva15/goirsdk v0.3.0 h1:6D95Avq7chikGHwEUKh7Y/HaLHOWQ75Qxaz8oMDSfrw= -github.com/ESilva15/goirsdk v0.3.0/go.mod h1:5borQbw+L4fe9b58JFHRHZwrzz0sMVAteuYbRnFOc0Q= +github.com/ESilva15/gobngsdk v1.2.0 h1:jX2ByFaIHnjCdPmrj1JiqCoNRLyu4vqIXC7++EUOCK4= +github.com/ESilva15/gobngsdk v1.2.0/go.mod h1:cKLaZRgM0tGGXDvosaSjHnxeyC5Y6rg7zCLqEUJnOzw= +github.com/ESilva15/goirsdk v0.3.9 h1:p+C7JtTTlo75Tq+CMH4bL70rItSLIotkXcHx+mCgSuc= +github.com/ESilva15/goirsdk v0.3.9/go.mod h1:5borQbw+L4fe9b58JFHRHZwrzz0sMVAteuYbRnFOc0Q= github.com/arl/statsviz v0.8.0 h1:O6GjjVxEDxcByAucOSl29HaGYLXsuwA3ujJw8H9E7/U= github.com/arl/statsviz v0.8.0/go.mod h1:XlrbiT7xYT03xaW9JMMfD8KFUhBOESJwfyNJu83PbB0= github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=