logger fixes on cdashdisplay device implementation

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

@@ -0,0 +1 @@
+# Peripheral Discovery

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

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)
 }

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)
 }

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
 }

devices/cdashdisplay/display.go

@@ -19,12 +19,6 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-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/"
@@ -116,11 +110,12 @@ type CDashDisplay struct {
 	State *CDashState
 }
 
+// Connect will try to find and connect to the CDashDisplay
 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
 	}
 
@@ -148,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)
 
@@ -176,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
 
@@ -211,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 {
@@ -225,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
 }
@@ -343,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))
 	}
 
@@ -376,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
 		}

devices/cdashdisplay/info.go

@@ -0,0 +1,27 @@
+package cdashdisplay
+
+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
+)
+
+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
+}

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))
 }

devices/device.go

@@ -0,0 +1,43 @@
+// Package devices is a peripheral factory
+package devices
+
+import (
+	"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) {
+	// Create a cdashdisplay
+	display, err := cdashdisplay.NewCDashDisplay()
+	if err != nil {
+		return nil, err
+	}
+
+	return display, nil
+}

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
+}

go.mod

@@ -1,6 +1,6 @@
 module esdi
 
-go 1.25.5
+go 1.27.0
 
 require (
 	github.com/ESilva15/ESgoRepl v0.1.0

logger/logger.go

@@ -1,22 +0,0 @@
-package logger
-
-import (
-	"log"
-	"os"
-	"sync"
-)
-
-var l *log.Logger
-var once sync.Once
-
-func createLogger() {
-  l = log.New(os.Stdout, "[esdi] ", log.LstdFlags | log.Lshortfile)
-}
-
-func GetInstance() *log.Logger {
-	once.Do(func() {
-    createLogger() 
-	})
-
-  return l
-}

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

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

providers/beamng/beamng.go

@@ -17,7 +17,10 @@ import (
 // for BeamNG.drive
 // NOTE: document this please. What is a TelemetryData????
 type BeamNG struct {
+	logger *slog.Logger
+
 	SDK *bngsdk.BeamNGSDK
+	og  *bngsdk.Outgauge
 
 	// data handling
 	mut      sync.Mutex
@@ -36,16 +39,18 @@ const (
 	NAME = "BeamNG.drive"
 )
 
-func NewBeamNGProvider(ip string, port int) (*BeamNG, error) {
-	beam, err := bngsdk.Init(ip, port)
+func NewBeamNGProvider(logger *slog.Logger, opts *bngsdk.Options) (*BeamNG, error) {
+	beam, err := bngsdk.NewBngSDK(*opts)
 	if err != nil {
 		return &BeamNG{}, err
 	}
 
 	provider := &BeamNG{
+		logger:   logger.With("TelemetryProvider", NAME),
 		streamCh: make(chan telemetry.TelemetryData, 1),
 		data:     telemetry.NewTelemetryData(),
-		SDK:      &beam,
+		SDK:      beam,
+		og:       &bngsdk.Outgauge{},
 		ticker:   time.NewTicker(time.Second / 60),
 	}
 
@@ -79,6 +84,19 @@ func NewBeamNGProvider(ip string, port int) (*BeamNG, error) {
 	return provider, nil
 }
 
+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
+}
+
 func (b *BeamNG) StopStream() {
 	if b.streamCancel == nil {
 		return
@@ -147,7 +165,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()
+	ogSnapshot, err := b.SDK.Update()
 	slog.Debug("THE DATA WAS READ")
 	if err != nil {
 		slog.Error("Error getting data", "error", err)
@@ -155,6 +173,7 @@ func (b *BeamNG) readData() {
 	}
 
 	b.mut.Lock()
+	b.og = ogSnapshot
 	defer b.mut.Unlock()
 
 	// Read 1 to 1 data

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'
 	}
 

providers/beamng/utils.go

@@ -0,0 +1,33 @@
+package beamng
+
+import (
+	"log/slog"
+	"net"
+	"time"
+)
+
+func IsRunning() bool {
+	// 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
+	}
+
+	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
+}

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",
+// }

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,49 +55,101 @@ 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) 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 {
-		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) {
 	i.data.InitialTime = time.Now()
 
 	go func() {
+		defer close(i.streamCh)
+
+		// Put this into the configuration file
+		consecutiveTimeouts := 0
+		maxTimeouts := 30
+		dataEvTimeout := 100
 		for {
-			// Explicitly intercpt cancellation
+			// Explicitly intercept cancellation
 			select {
 			case <-ctx.Done():
 				return
 			default:
 			}
 
-			// We start by checking if we do or do not have data available
-			if !i.isDataAvailable() {
-				continue
-			}
-
-			select {
-			case <-ctx.Done():
-				return
-			case <-i.ticker.C:
+			if i.SDK.CheckForDataEvent(time.Duration(dataEvTimeout) * time.Millisecond) {
+				consecutiveTimeouts = 0
+				i.logger.Debug("sending data", "timeouts", consecutiveTimeouts)
 				i.readData()
 
 				// Publish data
@@ -108,6 +158,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
+				}
 			}
 		}
 	}()
@@ -124,18 +183,13 @@ 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 +227,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 +253,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)
@@ -298,3 +263,15 @@ 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
+	}
+
+	return true
+}

providers/iracing/transforms.go

@@ -1,17 +1,134 @@
 package iracing
 
 import (
+	"log/slog"
 	"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,
+	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
+	}
+
+	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), 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", int(0), i.logger)
+
+	out.Type = telemetry.DataTypeCHAR
+
+	switch {
+	case gear == 0:
+		out.Raw = uint64('N')
+	case gear == -1:
+		out.Raw = uint64('R')
+	case gear > 0:
+		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), 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), i.logger)
+	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), i.logger)
+	telemetry.FloatToStringTransform(oilPress, out)
+}
+
+func (i *IRacing) oilTemp(out *telemetry.TelemetryField) {
+	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), i.logger)
+	telemetry.FloatToStringTransform(waterTemp, out)
+}
+
+// EngineData ↑
+
+// Adjustments ↓
+func (i *IRacing) brakeBias(out *telemetry.TelemetryField) {
+	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), i.logger)
+	telemetry.FloatToUInt8Transform(abs, out)
+}
+
+func (i *IRacing) tcSetting(out *telemetry.TelemetryField) {
+	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), i.logger)
+	telemetry.FloatToUInt8Transform(throttle, out)
+}
+
+// Adjustments ↑
+
+// Laps ↓
+func (i *IRacing) lapTime(out *telemetry.TelemetryField) {
+	lapTimeInSeconds := getVar(i.SDK.Vars.Vars, "LapLastLapTime", float32(0), i.logger)
 
 	if lapTimeInSeconds < 0 {
 		lapTimeInSeconds = 0
@@ -24,11 +141,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), i.logger)
+	telemetry.UInt8Transform(lapNumber, out)
 }
+
+// Laps ↑

providers/iracing/utils.go

@@ -0,0 +1,32 @@
+package iracing
+
+import (
+	"time"
+
+	"github.com/ESilva15/goirsdk"
+	eventutils "github.com/ESilva15/goirsdk/eventutils"
+)
+
+func IsRunning() bool {
+	irUtils, err := eventutils.Init()
+	if err != nil {
+		// we need error validation or something here
+		return false
+	}
+	defer irUtils.Close()
+
+	if err := irUtils.OpenEvent(goirsdk.IRSDK_DATAVALIDEVENTNAME); err != nil {
+		// we need error validation or something here
+		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
+}

providers/providers.go

@@ -8,34 +8,56 @@ import (
 	"esdi/providers/iracing"
 	"esdi/telemetry"
 
+	bngsdk "github.com/ESilva15/gobngsdk"
 	"github.com/ESilva15/goirsdk"
 )
 
 // 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, error)
+	IsRunning   func() bool // To check if this provider is up and running
 }
 
 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 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(ip string, port int) telemetry.TelemetryProvider {
-	provider, _ := beamng.NewBeamNGProvider(ip, port)
+func NewBeamNGProvider(logger *slog.Logger) (telemetry.TelemetryProvider, error) {
+	// TODO: these should come from some kind of config
+	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
 }

services/cdashdisplay.go

@@ -1,148 +0,0 @@
-package services
-
-import (
-	"context"
-	"fmt"
-	"log/slog"
-	"sync/atomic"
-
-	"esdi/cdashdisplay"
-	helper "esdi/helpers"
-	"esdi/peripheral"
-	"esdi/telemetry"
-)
-
-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 (cds *CDashService) FindDevice() {
-	cds.Messages <- "looking for cdash display...\n"
-	cds.Logger.Info("Looking for CDashDisplay")
-
-	cdashdisplay.SetLogger(cds.Logger.With("[device]", "cdashdisplay"))
-
-	display, err := cdashdisplay.NewCDashDisplay()
-	if err != nil {
-		cds.Logger.Info("didn't find cdashdisplay")
-		cds.Messages <- "didn't find cdash display\n"
-		return
-	}
-
-	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
-}
-
-// 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)
-		}
-	}
-}

services/device.go

@@ -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 {
-}

services/devices.go

@@ -0,0 +1,177 @@
+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
+type DeviceService struct {
+	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
+	// Output
+	Messages chan string
+}
+
+func NewDeviceService(logger *slog.Logger) *DeviceService {
+	sharedChannel := make(chan string, 10)
+
+	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()
+
+	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)
+			}
+		}
+	}
+}
+
+// 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)
+	}
+
+	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
+	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
+			ds.mu.RLock()
+			for _, dev := range ds.Devices {
+				dev.SendData(&data)
+			}
+			ds.mu.RUnlock()
+
+			isSending.Store(false)
+		}
+	}
+}

services/telemetry.go

@@ -4,56 +4,135 @@ 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
 // 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
+	mut            sync.RWMutex
+	activeProvider 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
+	CtxHealthcheck    context.Context
+	healthCheckCancel context.CancelFunc
 }
 
-func NewTelemetryService(logger *slog.Logger, cdash *CDashService) *TelemetryService {
+func NewTelemetryService(logger *slog.Logger, devServo *DeviceService) *TelemetryService {
+	sharedChannel := make(chan string, 10)
 	newService := &TelemetryService{
-		logger:    logger,
-		cdash:     cdash,
-		listeners: make(map[string]chan telem.TelemetryData),
+		logger:      logger,
+		isConnected: false,
+		devService:  devServo,
+		listeners:   make(map[string]chan telem.TelemetryData),
+		Messages:    sharedChannel,
 	}
-
-	// 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) ProviderMonitor(ctx context.Context) {
+	ticker := time.NewTicker(2 * time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			slog.Info("checking if provider is still running")
+			if !t.activeProvider.IsAlive(500 * time.Millisecond) {
+				slog.Warn("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 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) {
+	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)
+				provider, err := prov.NewProvider(t.logger)
+				if err != nil {
+					// Its not running
+					continue
+				}
+
+				if provider.IsAlive(500 * time.Millisecond) {
+					t.onFindProvider(provider)
+					return
+				}
+			}
+		}
+	}
+}
+
 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.ativeProvider != nil {
+	if t.activeProvider != nil {
 		t.dropActiveProvider()
 	}
 
 	// Assign the new provider
-	t.ativeProvider = newProvider
+	t.activeProvider = newProvider
 
 	return nil
 }
@@ -65,11 +144,14 @@ 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
 			}
 
 			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
@@ -87,7 +169,9 @@ func (t *TelemetryService) dropActiveProvider() {
 		t.cancelForward()
 	}
 
-	t.ativeProvider.StopStream()
+	t.activeProvider.StopStream()
+	t.activeProvider.Close()
+	t.activeProvider = nil
 }
 
 func (t *TelemetryService) SubscribeListener(id string, bufferSize int) <-chan telem.TelemetryData {
@@ -118,18 +202,31 @@ func (t *TelemetryService) UnsubscribeListener(id string) {
 	}
 }
 
-func (t *TelemetryService) SubscribeToFields(fields map[int16]telem.FieldID) {
-	t.ativeProvider.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() {
 	slog.Debug("Stream started")
 
 	// Start the new stream
-	simInCh, _ := t.ativeProvider.Stream()
-	// if err != nil {
-	// 	// NOTE
-	// }
+	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())
@@ -148,5 +245,13 @@ func (t *TelemetryService) StopStream() {
 		t.cancelForward = nil
 	}
 
-	t.ativeProvider.StopStream()
+	t.activeProvider.StopStream()
+}
+
+func (t *TelemetryService) HasActiveProvider() bool {
+	if t.activeProvider == nil {
+		return false
+	}
+
+	return true
 }

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)
 }

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),
 			)
@@ -137,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

telemetry/provider.go

@@ -1,8 +1,13 @@
 // 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)
+	IsAlive(time.Duration) bool
+	Name() string
+	Close()
 }

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

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

tui/internal/controllers/device.go

@@ -4,6 +4,7 @@ package controllers
 import (
 	"fmt"
 
+	"esdi/devices/cdashdisplay"
 	serv "esdi/services"
 	"esdi/tui/internal/views"
 
@@ -15,12 +16,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 +57,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
 		})
@@ -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,7 +82,14 @@ func (mc *DeviceController) AddDeviceAPIListItems() {
 		})
 	mc.DeviceAPIView.DevAPIList.
 		AddItem("stream", "stream data to the display", func() {
-			views.AddAndShowPage(mc.DeviceAPIView.DevAPIToolView.Pages,
+			// 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",
 				mc.StreamCtrl.StreamView.Flex,
 			)

tui/internal/controllers/streaming.go

@@ -6,6 +6,7 @@ import (
 	"sync/atomic"
 
 	"esdi/config"
+	"esdi/devices/uidevice"
 	"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),
@@ -55,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 {
@@ -108,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")
@@ -155,16 +161,24 @@ 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 {
-		fieldID, _ := telemetry.GetFieldID(w.UIData.TelemetryField)
-		fields[w.UIData.IDX] = fieldID
-	}
+	sc.TelemServ.SubscribeToFields()
 
-	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() {
@@ -176,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)
 		})
 	}

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"

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"

tui/tui.go

@@ -23,12 +23,16 @@ func NewControlPanel(logger *slog.Logger) *ControlPanel {
 		App:    tview.NewApplication(),
 	}
 
-	devService := services.NewCDashService(logger)
+	// 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")
 	}
 
+	go telemService.FindProvider(telemService.CtxMonitor)
+
 	return &ControlPanel{
 		Controller:       baseController,
 		DeviceController: controllers.NewDeviceController(baseController, devService, telemService),