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/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/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/cdashdisplay/transportPackets.go b/cdashdisplay/transportPackets.go deleted file mode 100644 index 811684b..0000000 --- a/cdashdisplay/transportPackets.go +++ /dev/null @@ -1,70 +0,0 @@ -package cdashdisplay - -// In this file we will place all structs that are 1:1 representation of the -// types in the device transport layer -> - -const ( - ShowIDFalse uint8 = 0 - ShowIDTrue uint8 = 1 -) - -const ( - WinTypeBASE uint8 = iota - WinTypeBAR - WinTypeSTRING - WinTypeTABLE -) - -var WinTYPES = []string{"BASE", "BAR", "STRING", "TABLE"} - -type UIDimensions struct { - X0 uint16 `yaml:"X0"` - Y0 uint16 `yaml:"Y0"` - Width uint16 `yaml:"Width"` - Height uint16 `yaml:"Height"` -} - -type UIDecorations struct { - BGColour uint16 `yaml:"BGColour"` - FGColour uint16 `yaml:"FGColour"` - TitleColour uint16 `yaml:"TitleColour"` - BorderColour uint16 `yaml:"BorderColour"` - TitleSize uint8 `yaml:"TitleSize"` - TextSize uint8 `yaml:"TextSize"` - HasBorder uint8 `yaml:"HasBorder"` - Padding uint8 `yaml:"Padding"` -} - -// NOTE: we can't use FString32 for this - too many bytes -// NOTE: use a bit flags for this options instead -type UIWindowOpts struct { - ShowID uint8 `yaml:"ShowID"` - WinType uint8 `yaml:"WinType"` - PreviewValue FString32 `yaml:"PreviewValue"` -} - -type UIWindow struct { - Dims UIDimensions `yaml:"Dims"` - Decor UIDecorations `yaml:"Decor"` - Opts UIWindowOpts `yaml:"Opts"` - Title FString32 `yaml:"Title"` -} - -type DesktopUIWindow struct { - UIWindow - UIData DesktopUIData -} - -type DesktopUIData struct { - IDX int16 `yaml:"WID"` - TelemetryField string `yaml:"TelemetryField"` -} - -type UIWindowUpdatePacket struct { - WinID int16 - Window UIWindow -} - -// func getUIWindowDTO(w *DesktopWindowData) *UIWindow { -// -// } 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/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/constants/constants.go b/constants/constants.go new file mode 100644 index 0000000..7eb152c --- /dev/null +++ b/constants/constants.go @@ -0,0 +1,13 @@ +package constants + +// Provider Names +const ( + IRacingProviderName = "iRacing" + BeamNGProviderName = "BeamNG.drive" +) + +// Virtual Field Names +const ( + FuelCalculatorName = "FuelCalculator" + RPMLightsName = "RPMLights" +) diff --git a/cdashdisplay/connect.go b/devices/cdashdisplay/connect.go similarity index 76% rename from cdashdisplay/connect.go rename to devices/cdashdisplay/connect.go index bf899c2..bdec694 100644 --- a/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) @@ -71,19 +73,19 @@ 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) } - 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/cdashdisplay/display.go b/devices/cdashdisplay/display.go similarity index 70% rename from cdashdisplay/display.go rename to devices/cdashdisplay/display.go index 9f33c14..9294d10 100644 --- a/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -8,9 +8,11 @@ import ( "log/slog" "os" "path" + "sync" "time" helper "esdi/helpers" + "esdi/peripheral" "esdi/peripheral/communication" "esdi/peripheral/communication/packets" "esdi/peripheral/types" @@ -19,12 +21,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/" @@ -37,6 +33,8 @@ const ( updateWindowCMDID types.Command = 6 // Change this to a move cmd instead sendDataCMDID types.Command = 7 newLayoutCMDID types.Command = 8 + healthCheckCMDID types.Command = 9 + resetCMDID types.Command = 10 ) const ( @@ -112,25 +110,65 @@ func NewCDashState() *CDashState { } type CDashDisplay struct { - WT *communication.WalkieTalkie - State *CDashState + 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 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", "reason", err.Error()) return nil, err } 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 + }, + }, + failedSends: 0, + FailedSendsConsecutiveLimit: 5, }, nil } -func (d *CDashDisplay) SendCommand() { +func (cds *CDashDisplay) Close() error { + // if cds.WT != nil { + // cds.Close() + // } + + return nil +} + +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) { @@ -148,9 +186,12 @@ 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) + if fieldID, ok := telemetry.GetFieldID(win.UIData.TelemetryField); ok { + d.RegisterFieldMapping(fieldID, win.UIData.IDX) + } return win, nil } @@ -176,12 +217,14 @@ 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 + // TODO: need to update the field mappings here! + return nil } @@ -204,14 +247,15 @@ 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 } 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 +269,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,30 +387,48 @@ 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)) } return nil } -func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) { - packet := data.Pack() +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 { + return err + } + + time.Sleep(3000 * time.Millisecond) + + cds.resetState() + + return nil +} + +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 := "" @@ -376,7 +438,6 @@ func (d *CDashDisplay) SendData(data *telemetry.TelemetryData) { curStr += fmt.Sprintf("%02x ", byte) if byteCount == 8 { - pLogger.Debug(curStr) curStr = "" byteCount = 0 } @@ -385,6 +446,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/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/cdashdisplay/info.go b/devices/cdashdisplay/info.go new file mode 100644 index 0000000..68b7bb1 --- /dev/null +++ b/devices/cdashdisplay/info.go @@ -0,0 +1,40 @@ +package cdashdisplay + +import ( + "esdi/peripheral/communication/packets" + "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() []telemetry.FieldID { + fields := make([]telemetry.FieldID, 0, len(cds.State.Layout.Windows)) + + for _, w := range cds.State.Layout.Windows { + if fieldID, ok := telemetry.GetFieldID(w.UIData.TelemetryField); ok { + fields = append(fields, 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/cdashdisplay/layoutManager.go b/devices/cdashdisplay/layoutManager.go similarity index 59% rename from cdashdisplay/layoutManager.go rename to devices/cdashdisplay/layoutManager.go index 82a14e0..4701cb7 100644 --- a/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/cdashdisplay/setup.go b/devices/cdashdisplay/setup.go new file mode 100644 index 0000000..74117f4 --- /dev/null +++ b/devices/cdashdisplay/setup.go @@ -0,0 +1,44 @@ +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 { + // 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() + case constants.BeamNGProviderName: + return cds.setupForBeamNG() + default: + return fmt.Errorf("unknown provider: %s", provider) + } +} diff --git a/devices/cdashdisplay/transportPackets.go b/devices/cdashdisplay/transportPackets.go new file mode 100644 index 0000000..ad85aff --- /dev/null +++ b/devices/cdashdisplay/transportPackets.go @@ -0,0 +1,141 @@ +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 -> + +const ( + ShowIDFalse uint8 = 0 + ShowIDTrue uint8 = 1 +) + +const ( + WinTypeBASE uint8 = iota + WinTypeBAR + WinTypeSTRING + WinTypeTABLE +) + +var WinTYPES = []string{"BASE", "BAR", "STRING", "TABLE"} + +type UIDimensions struct { + X0 uint16 `yaml:"X0"` + Y0 uint16 `yaml:"Y0"` + Width uint16 `yaml:"Width"` + Height uint16 `yaml:"Height"` +} + +type UIDecorations struct { + BGColour uint16 `yaml:"BGColour"` + FGColour uint16 `yaml:"FGColour"` + TitleColour uint16 `yaml:"TitleColour"` + BorderColour uint16 `yaml:"BorderColour"` + TitleSize uint8 `yaml:"TitleSize"` + TextSize uint8 `yaml:"TextSize"` + HasBorder uint8 `yaml:"HasBorder"` + Padding uint8 `yaml:"Padding"` +} + +// NOTE: we can't use FString32 for this - too many bytes +// NOTE: use a bit flags for this options instead +type UIWindowOpts struct { + ShowID uint8 `yaml:"ShowID"` + WinType uint8 `yaml:"WinType"` + PreviewValue FString32 `yaml:"PreviewValue"` +} + +type UIWindow struct { + Dims UIDimensions `yaml:"Dims"` + Decor UIDecorations `yaml:"Decor"` + Opts UIWindowOpts `yaml:"Opts"` + Title FString32 `yaml:"Title"` +} + +type DesktopUIWindow struct { + UIWindow + UIData DesktopUIData +} + +type DesktopUIData struct { + IDX int16 `yaml:"WID"` + TelemetryField string `yaml:"TelemetryField"` +} + +type UIWindowUpdatePacket struct { + WinID int16 + Window 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/devices/device.go b/devices/device.go new file mode 100644 index 0000000..33db928 --- /dev/null +++ b/devices/device.go @@ -0,0 +1,66 @@ +// Package devices is a peripheral factory +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: UIDeviceDiscover, + }, + cdashdisplay.NAME: { + Name: cdashdisplay.NAME, + Discover: CDashDisplayDiscover, + }, +} + +func UIDeviceDiscover() (peripheral.Peripheral, error) { + uidev, err := uidevice.NewUIDevice() + if err != nil { + return nil, err + } + + return uidev, nil +} + +// func UIDeviceSetup(peripheral peripheral.Peripheral) error { +// return nil +// } + +func CDashDisplayDiscover() (peripheral.Peripheral, error) { + // Create a cdashdisplay + display, err := cdashdisplay.NewCDashDisplay() + if err != nil { + return nil, err + } + + 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 new file mode 100644 index 0000000..c32032d --- /dev/null +++ b/devices/uidevice/device.go @@ -0,0 +1,64 @@ +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) Close() error { + if uid.dataChan != nil { + close(uid.dataChan) + } + + return nil +} + +func (uid *UIDevice) Setup(provider string) error { + return nil +} + +func (uid *UIDevice) SendData(data *telemetry.TelemetryData) error { + if data == nil { + return peripheral.ErrInvalidData + } + + select { + case uid.dataChan <- *data: + default: + // Drop frame if buffer is full + } + + return nil +} + +func (uid *UIDevice) Name() string { + return NAME +} + +func (uid *UIDevice) DataChannel() <-chan telemetry.TelemetryData { + return uid.dataChan +} + +func (uid *UIDevice) RequiredFields() []telemetry.FieldID { + return []telemetry.FieldID{ + telemetry.Speed, + telemetry.Gear, + telemetry.RPM, + } +} + +func (uid *UIDevice) HealthCheck() bool { + return true +} 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/go.mod b/go.mod index 3d4d8fd..d0b387a 100644 --- a/go.mod +++ b/go.mod @@ -1,11 +1,10 @@ module esdi -go 1.25.5 +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.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= diff --git a/main.go b/main.go index 7507664..7a54f13 100644 --- a/main.go +++ b/main.go @@ -10,7 +10,6 @@ import ( "esdi/cmd" "esdi/config" - "esdi/telemetry" "github.com/arl/statsviz" ) @@ -42,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 { 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 e5503b6..a751f73 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 } @@ -108,6 +109,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,13 +129,17 @@ 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 { return err } + wt.Serial.Flush() + return nil } @@ -147,50 +161,11 @@ 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, - 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/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/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 e9d6f25..2ea1170 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,17 @@ const ( DisplayPeripheral PeripheralType = "display" ) +type Peripheral interface { + Name() string + Setup(string) error + HealthCheck() bool + SendData(*telemetry.TelemetryData) error + RequiredFields() []telemetry.FieldID + OnLoad() error + OnTelemetryProviderFound() error + Close() error +} + type PeripheralDeviceClerk struct { // mu sync.RWMutex Devices map[uint8]*PeripheralDevice diff --git a/providers/beamng/beamng.go b/providers/beamng/beamng.go index d653073..7c46a57 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" @@ -17,15 +18,21 @@ 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 data *telemetry.TelemetryData updaters [telemetry.MaxFields]func(*telemetry.TelemetryField) + // Field Subscription management + boundFields map[telemetry.FieldID]bool + // stream control - streamCh chan telemetry.TelemetryData + wg sync.WaitGroup streamCancel context.CancelFunc // timing @@ -33,20 +40,23 @@ type BeamNG struct { } const ( - NAME = "BeamNG.drive" + NAME = constants.BeamNGProviderName ) -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{ - streamCh: make(chan telemetry.TelemetryData, 1), - data: telemetry.NewTelemetryData(), - SDK: &beam, - ticker: time.NewTicker(time.Second / 60), + logger: logger.With("TelemetryProvider", NAME), + data: telemetry.NewTelemetryData(), + SDK: beam, + og: &bngsdk.Outgauge{}, + // Field subscription management + boundFields: make(map[telemetry.FieldID]bool, telemetry.MaxFields), + ticker: time.NewTicker(time.Second / 60), } provider.updaters = [telemetry.MaxFields]func(*telemetry.TelemetryField){ @@ -79,6 +89,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 @@ -92,94 +115,114 @@ 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 map[int16]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 winID, 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()) - 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 -func (b *BeamNG) readData() { - slog.Debug("READING THIS DATA") - // BUG: getting stuck in here - err := b.SDK.ReadData() - slog.Debug("THE DATA WAS READ") +func (b *BeamNG) readData() error { + ogSnapshot, err := b.SDK.Update() if err != nil { slog.Error("Error getting data", "error", err) - return + return err } b.mut.Lock() + b.og = ogSnapshot 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) { +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 { @@ -188,24 +231,27 @@ 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 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 b.streamCh <- *b.data: - slog.Debug("PUBLISHED DATA") + case outCh <- *b.data: + // Successfuly read and sent data default: // skip this data, don't allow publishers to lag behind } } } }() + + return outCh } 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/beamng/utils.go b/providers/beamng/utils.go new file mode 100644 index 0000000..8918c7c --- /dev/null +++ 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 +} 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..c8c90d3 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -7,18 +7,17 @@ import ( "context" "fmt" "log/slog" - "strconv" "sync" "time" - conv "esdi/conversions" + "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 @@ -30,12 +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 - streamCh chan telemetry.TelemetryData + wg sync.WaitGroup streamCancel context.CancelFunc } @@ -52,65 +53,130 @@ func NewIRacingProvider( } provider := &IRacing{ - 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 - ticker: time.NewTicker(time.Second / 240), + 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), } - // 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) { +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 i.wg.Done() + defer close(outCh) + + // Put this into the configuration file + consecutiveTimeouts := 0 + maxTimeouts := 10 + dataEvTimeout := 30 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.readData() // Publish data select { - case i.streamCh <- *i.data: + case outCh <- *i.data: 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 + } } } }() + + return outCh } func (i *IRacing) readData() { @@ -124,18 +190,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) } @@ -152,9 +213,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() { @@ -163,138 +224,81 @@ func (i *IRacing) StopStream() { } i.streamCancel() + i.wg.Wait() i.streamCancel = nil } -func (i *IRacing) Subscribe(requestFields map[int16]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() + + for _, id := range fields { + if i.boundFields[id] { + continue + } + + i.data.ActiveBinds[id] = telemetry.BoundField{ + ID: id, + } + 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 - pendingBinds := make([]telemetry.FieldID, telemetry.MaxFields) - - for winID, id := range requestFields { - i.data.Values[id].IDs = append(i.data.Values[id].IDs, winID) + toBind := make([]telemetry.FieldID, 0, telemetry.MaxFields) + i.mut.Lock() + for _, id := range requestFields { switch id { case telemetry.RPMStateColour: - i.data.VirtualBinds = append(i.data.VirtualBinds, telemetry.NewRPMLights()) + rpmLights := telemetry.NewRPMLights() + i.data.VirtualBinds[rpmLights.Name()] = rpmLights + toBind = append(toBind, rpmLights.EnsureSubscribed()...) case telemetry.FCCurrentLap: - i.data.VirtualBinds = append(i.data.VirtualBinds, - telemetry.NewFuelCalculator(i.logger.WithGroup("FUEL CALC"))) + fuelCalc := telemetry.NewFuelCalculator(i.logger.WithGroup("FUEL CALC")) + i.data.VirtualBinds[fuelCalc.Name()] = fuelCalc + toBind = append(toBind, fuelCalc.EnsureSubscribed()...) default: // primitive telemetry field - pendingBinds = append(pendingBinds, id) + toBind = append(toBind, id) } } + i.mut.Unlock() - 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] { - 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 - } - - i.data.ActiveBinds = append(i.data.ActiveBinds, binding) - boundCheck[id] = true - } + newSubs := i.subscribe(toBind) i.logger.Debug(fmt.Sprintf("Subscribed: %+v\n", i.data.ActiveBinds)) + + return newSubs +} + +func (i *IRacing) Name() string { + return NAME +} + +func (i *IRacing) IsAlive(timeout time.Duration) bool { + if !i.SDK.CheckForDataEvent(timeout) { + return false + } + + return true } diff --git a/providers/iracing/transforms.go b/providers/iracing/transforms.go index e3e64a4..1e202c3 100644 --- a/providers/iracing/transforms.go +++ b/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 ↑ diff --git a/providers/iracing/utils.go b/providers/iracing/utils.go new file mode 100644 index 0000000..7c6b756 --- /dev/null +++ b/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 +} diff --git a/providers/providers.go b/providers/providers.go index e95e079..a10e23d 100644 --- a/providers/providers.go +++ b/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 } diff --git a/services/cdashdisplay.go b/services/cdashdisplay.go deleted file mode 100644 index 0821075..0000000 --- a/services/cdashdisplay.go +++ /dev/null @@ -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) - } - } -} 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..875b6fb --- /dev/null +++ b/services/devices.go @@ -0,0 +1,164 @@ +package services + +import ( + "context" + "fmt" + "log/slog" + "sync/atomic" + + "esdi/devices" + "esdi/peripheral" + "esdi/telemetry" +) + +// DeviceService is the API for the peripherals +type DeviceService struct { + Logger *slog.Logger + // Device discovery + PSS *PeripheralStateStore // Store to track peripheral state + ctxDiscovery context.Context + ctxDiscoveryCancel context.CancelFunc + // Strem handling + streamCancel context.CancelFunc + TelemCh <-chan telemetry.TelemetryData + // Output + Messages chan string + // Callbacks + // Telemetry service data fetchers + telemetryProvider func() (string, error) + triggerFieldSubscription func([]telemetry.FieldID) []string +} + +func NewDeviceService(logger *slog.Logger, msg chan string) *DeviceService { + dev := &DeviceService{ + PSS: NewPeripheralStateStore( + logger.With("Service", "PeripheralStateStore"), devices.List, msg, + ), + Logger: logger, + Messages: msg, + } + + // 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() + + // Set the callbacks for PSS + dev.PSS.telemetryProvider = dev.getTelemetryProvider + dev.PSS.onPeripheralConfigured = dev.peripheralConfigured + + 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)) + + for _, state := range snapshot { + if state.State < DeviceIsConfigured { + continue + } + peripherals = append(peripherals, state.Peripheral) + } + + return peripherals +} + +func (ds *DeviceService) GetPeripheral(pname string) (peripheral.Peripheral, error) { + return ds.PSS.GetPeripheral(pname) +} + +func (ds *DeviceService) PeripheralExists(pname string) bool { + _, err := ds.PSS.GetPeripheral(pname) + return err == nil +} + +// Getters [END] --------------------------------------------------------------- + +// Actions [START] ------------------------------------------------------------- +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() { + if ds.streamCancel == nil { + return + } + + ds.PSS.OnStopStream() + + ds.streamCancel() + ds.streamCancel = nil +} + +// SetTelemetryChannel sets the TelemCh to the passed channel +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 + + 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.PSS.GetStates() { + if dev.State != DeviceIsStreaming { + continue + } + + err := dev.Peripheral.SendData(&data) + + if err == peripheral.ErrDeviceTimedOut { + ds.onDeviceTimedOut(dev.device.Name) + } + } + + isSending.Store(false) + } + } +} + +// Callbacks [START] ----------------------------------------------------------- +func (ds *DeviceService) peripheralConfigured(pname string, fields []telemetry.FieldID) { + // 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_events.go b/services/devices_events.go new file mode 100644 index 0000000..bd45330 --- /dev/null +++ b/services/devices_events.go @@ -0,0 +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 new file mode 100644 index 0000000..b53da2e --- /dev/null +++ b/services/devices_lookup.go @@ -0,0 +1,510 @@ +package services + +import ( + "errors" + "fmt" + "log/slog" + "maps" + "sync" + "time" + + "esdi/devices" + "esdi/peripheral" + "esdi/telemetry" +) + +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 + +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 + 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 + // Messaging for UI and stuff + Messages chan string + // Callbacks + telemetryProvider func() (string, error) + onPeripheralConfigured func(string, []telemetry.FieldID) + // Internal State + isStreaming bool +} + +func NewPeripheralStateStore( + nLogger *slog.Logger, + devList map[string]*devices.Device, + msg chan string, +) *PeripheralStateStore { + store := PeripheralStateStore{ + Logger: nLogger, + store: make(map[string]*PeripheralState), + Messages: msg, + } + + 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 +} + +func (pss *PeripheralStateStore) GetStreamingState() bool { + pss.mu.RLock() + defer pss.mu.RUnlock() + 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) +} + +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) + } + } +} + +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 + pss.mu.Unlock() + + for _, state := range pss.GetStates() { + if state.State > DeviceIsConfigured { + pss.setDeviceUnconfigured(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) + + pss.mu.Lock() + pss.store[pname].Peripheral = per + pss.store[pname].State = DeviceIsConnected + pss.mu.Unlock() + + pss.Messages <- fmt.Sprintf("Device successfuly connected: %s\n", pname) +} + +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 +} + +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) 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) + + pss.mu.Lock() + pss.store[pname].State = DeviceIsConfigured + pss.mu.Unlock() + + pss.onPeripheralConfigured(pname, pss.GetPeripheralFields(pname)) +} + +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(string, peripheral.Peripheral), + onFailure func(string), +) { + pss.Logger.Debug("looking for device", "name", pname) + pss.setDeviceIsDiscovering(pname) + pss.Messages <- "Discovering " + pname + "\n" + + go func() { + state, err := pss.GetState(pname) + if err != nil { + pss.Logger.Error("Can't reconnect device", "device", pname, "error", err) + onFailure(pname) + return + } + + dev, err := state.device.Discover() + if err != nil { + onFailure(pname) + return + } + + // 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 + } + pss.Messages <- fmt.Sprintf("Configuring peripheral for provider: %s\n", provider) + + err = state.Peripheral.Setup(provider) + if err != nil { + onFailure(pname) + return + } + + onSuccess(pname) + }() +} + +func (pss *PeripheralStateStore) handleDeviceTimedOut(pname string) error { + pss.Messages <- "device " + pname + " timed out\n" + pss.discoverPeripheral(pname, pss.setDeviceReconnected, pss.setDeviceTimedOut) + 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 + } + + // Update the peripheral state + pss.setDeviceConnected(pname, state.Peripheral) + + 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 { + pss.setDeviceUnconfigured(pname) + return nil +} + +func (pss *PeripheralStateStore) handleDeviceIsUnconfigured(pname string) error { + // Here we need to configure our device. If no error occurs its configured! + _, err := pss.telemetryProvider() + if err != nil { + return err + } + + pss.setDeviceIsConfiguring(pname) + pss.configurePeripheral(pname, pss.setDeviceConfigured, pss.setDeviceUnconfigured) + + return nil +} + +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 +} + +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.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) + pss.handleDeviceIsUnconfigured(pName) + case DeviceIsConfiguring: + // Do nothing configuration is happening in the background + case DeviceIsConfigured: + // Nothing to do here + 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) + 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 + } + } + + 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.performHealthCheck(pName, updatedState) + } + + } +} + +// 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(1 * time.Second) + defer ticker.Stop() + + for { + select { + case <-ds.ctxDiscovery.Done(): + return + case <-ticker.C: + ds.PSS.HandleDeviceState() + } + } +} diff --git a/services/services.go b/services/services.go index bb02e66..7686f6a 100644 --- a/services/services.go +++ b/services/services.go @@ -1,2 +1,40 @@ // 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"), msg) + if telemService == nil { + return nil, errors.New("failed to create telemetry service") + } + + go telemService.FindProvider(telemService.CtxMonitor) + + // Setup device service callbacks + devService.telemetryProvider = telemService.GetTelemetryProviderName + devService.triggerFieldSubscription = telemService.SubscribeToFields + + // Setup telemetry service callbacks + telemService.startedStreaming = devService.StartStream + telemService.providerStoppedMidStream = devService.OnStoppedMidStream + + return &Orchestrator{ + DeviceService: devService, + TelemetryService: telemService, + Messages: msg, + }, nil +} diff --git a/services/telemetry.go b/services/telemetry.go index b2b5b5f..f449ce6 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -2,94 +2,92 @@ package services import ( "context" + "errors" "log/slog" "sync" + "time" "esdi/providers" + "esdi/telemetry" telem "esdi/telemetry" - - "github.com/ESilva15/goirsdk" ) +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 - cdash *CDashService + // Streaming + isStreaming bool // 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 + // Callbacks + startedStreaming func(ch <-chan telemetry.TelemetryData) + providerStoppedMidStream func() + // Devices data request + // peripheralProvider func() []peripheral.Peripheral + // getRequiredFields func() []telemetry.FieldID } -func NewTelemetryService(logger *slog.Logger, cdash *CDashService) *TelemetryService { +func NewTelemetryService( + logger *slog.Logger, + msg chan string, +) *TelemetryService { newService := &TelemetryService{ - logger: logger, - cdash: cdash, - listeners: make(map[string]chan telem.TelemetryData), + logger: logger, + isConnected: false, + listeners: make(map[string]chan telem.TelemetryData), + Messages: msg, } - - // 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) SwitchProvider(newProvider telem.TelemetryProvider) error { - t.mut.Lock() - defer t.mut.Unlock() +func (t *TelemetryService) ProviderMonitor(ctx context.Context) { + ticker := time.NewTicker(2 * time.Second) + defer ticker.Stop() - // Clean up the current to be old provider - if t.ativeProvider != nil { - t.dropActiveProvider() - } - - // Assign the new provider - t.ativeProvider = newProvider - - return nil -} - -func (t *TelemetryService) multiplexData(ctx context.Context, dataCh <-chan telem.TelemetryData) { for { select { case <-ctx.Done(): return - case data, ok := <-dataCh: - if !ok { + 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() return } - - t.mut.RLock() - for _, ch := range t.listeners { - select { - case ch <- data: - // Sends data to the subscriber - default: - // Subscriber is full, we just skip ahead. Maybe find a how to add metrics here - } - } - t.mut.RUnlock() } } } -func (t *TelemetryService) dropActiveProvider() { - if t.cancelForward != nil { - t.cancelForward() +func (t *TelemetryService) GetTelemetryProviderName() (string, error) { + if t.activeProvider == nil { + return "", ErrNoActiveProviderAvailable } - t.ativeProvider.StopStream() + return t.activeProvider.Name(), nil } +// Listener Control [START] ---------------------------------------------------- + func (t *TelemetryService) SubscribeListener(id string, bufferSize int) <-chan telem.TelemetryData { t.mut.Lock() defer t.mut.Unlock() @@ -118,27 +116,84 @@ func (t *TelemetryService) UnsubscribeListener(id string) { } } -func (t *TelemetryService) SubscribeToFields(fields map[int16]telem.FieldID) { - t.ativeProvider.Subscribe(fields) +func (t *TelemetryService) SubscribeToFields(fields []telemetry.FieldID) []string { + t.logger.Debug("requested fields", "fields", fields) + subscribed := t.activeProvider.Subscribe(fields) + + return subscribed } -func (t *TelemetryService) StartStream() { - slog.Debug("Stream started") +// Listener Control [END] ------------------------------------------------------ - // Start the new stream - simInCh, _ := t.ativeProvider.Stream() - // if err != nil { - // // NOTE - // } +// Provider Control [START] ---------------------------------------------------- - // Create the context so we can control the lifecycle - ctx, cancel := context.WithCancel(context.Background()) - t.cancelForward = cancel +func (t *TelemetryService) HasActiveProvider() bool { + if t.activeProvider == nil { + return false + } - // Multiplex this data - go t.multiplexData(ctx, simInCh) + return true } +func (t *TelemetryService) dropActiveProvider() { + if t.cancelForward != nil { + t.cancelForward() + } + + // NOTE: can we move the stop stream into the provider Close() method? + 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 +} + +// 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 + } + } + } + } +} + +// Provider Control [END] ------------------------------------------------------ + +// Streaming Control [START] --------------------------------------------------- + func (t *TelemetryService) StopStream() { t.mut.Lock() defer t.mut.Unlock() @@ -148,5 +203,68 @@ func (t *TelemetryService) StopStream() { t.cancelForward = nil } - t.ativeProvider.StopStream() + t.activeProvider.StopStream() + t.isStreaming = false } + +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 nil + } + + // Stop the provider healthcheck + t.healthCheckCancel() + + simInCh, _ := t.activeProvider.Stream() + + // 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 + + t.Messages <- "Provider has started streaming data\n" + + return simInCh +} + +func (t *TelemetryService) multiplexData(ctx context.Context, dataCh <-chan telem.TelemetryData) { + for { + select { + case <-ctx.Done(): + 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 + default: + // Subscriber is full, we just skip ahead. Maybe find a how to add metrics here + } + } + t.mut.RUnlock() + } + } +} + +func (t *TelemetryService) IsStreaming() bool { + return t.isStreaming +} + +// Streaming Control [END] ----------------------------------------------------- + +// Callbacks [START] ----------------------------------------------------------- + +// Callbacks [END] ------------------------------------------------------------- diff --git a/services/telemetry_events.go b/services/telemetry_events.go new file mode 100644 index 0000000..8416f21 --- /dev/null +++ b/services/telemetry_events.go @@ -0,0 +1,49 @@ +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) + + ch := t.StartStream() + t.startedStreaming(ch) + + t.Messages <- "provider switch completed" +} + +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) + + // Tell the devices service that we lost the thing + t.providerStoppedMidStream() +} 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..52d8dda 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. @@ -17,24 +23,14 @@ 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 // 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{ @@ -67,7 +63,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 @@ -78,48 +74,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: @@ -137,7 +91,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 @@ -261,52 +215,24 @@ 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 } // 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{} -} - -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) - } + return &TelemetryData{ + ActiveBinds: make(map[FieldID]BoundField, MaxFields), + VirtualBinds: make(map[string]VirtualField), } - - // 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/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 2aea6be..3d86c4c 100644 --- a/telemetry/provider.go +++ b/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) + 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/telemetry.go b/telemetry/telemetry.go index 016e3e1..073f40d 100644 --- a/telemetry/telemetry.go +++ b/telemetry/telemetry.go @@ -1,5 +1 @@ package telemetry - -func Init() { - initFieldNamesMap() -} 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 +} diff --git a/tui/internal/controllers/layout.go b/tui/internal/controllers/cdashdisplay_layout.go similarity index 81% rename from tui/internal/controllers/layout.go rename to tui/internal/controllers/cdashdisplay_layout.go index a2b3a3d..a1a12b6 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(), @@ -32,6 +35,7 @@ func NewLayoutController(base *Controller, service *services.CDashService) *Layo 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", } @@ -207,7 +211,20 @@ func (lc *LayoutController) createWindow() { return } - window, err = lc.DevService.CreateWindow(window) + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetPeripheral(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 +321,20 @@ func (lc *LayoutController) newWindowAction() { } func (lc *LayoutController) updateWindowAction(win *cdashdisplay.DesktopUIWindow) { - err := lc.DevService.UpdateWindow(win) + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetPeripheral(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 +347,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.GetPeripheral(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 +392,22 @@ func (lc *LayoutController) getCurrentTreeNodeModel() (*tview.TreeNode, int16, e } func (lc *LayoutController) loadLayout() { - // We would get the layout path from somewhere but for nots its layout.yaml - err := lc.DevService.LoadLayout(lc.SelectedLayout) + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetPeripheral(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 + } + // --- + + // 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() return @@ -360,7 +417,20 @@ func (lc *LayoutController) loadLayout() { } func (lc *LayoutController) unloadLayout() { - err := lc.DevService.UnloadLayout() + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetPeripheral(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 +438,20 @@ func (lc *LayoutController) unloadLayout() { } func (lc *LayoutController) saveLayout() { - err := lc.DevService.SaveLayout(lc.SelectedLayout) + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetPeripheral(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 +471,21 @@ func (lc *LayoutController) deleteWindow() { } wID := curNode.GetReference().(int16) + // Acquire the cdashdisplay + displayIF, err := lc.DevService.GetPeripheral(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..87487bf 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.GetPeripheral(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.GetPeripheral(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..86f67c7 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" @@ -15,19 +16,18 @@ type DeviceController struct { DeviceAPIView *views.DeviceAPIView LayoutCtrl *LayoutController StreamCtrl *StreamingCtrl - DevService *serv.CDashService + Orchestrator *serv.Orchestrator } func NewDeviceController( base *Controller, - devService *serv.CDashService, - 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 @@ -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.Orchestrator.DeviceService.FindDevices() } return ev }) @@ -65,6 +65,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.Orchestrator.DeviceService.PeripheralExists(cdashdisplay.NAME) { + mc.Orchestrator.DeviceService.Messages <- "CDashDisplay it not loaded yet\n" + return + } + // Get the api pages views.AddAndShowPage( mc.DeviceAPIView.DevAPIToolView.Pages, @@ -75,12 +81,19 @@ 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, ) - mc.StreamCtrl.SetInternalState() + // mc.StreamCtrl.SetInternalState() mc.App.SetFocus(mc.StreamCtrl.StreamView.Options.Form) }) @@ -102,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 a743de3..1fc6d0b 100644 --- a/tui/internal/controllers/streaming.go +++ b/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 + DevService *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,27 +45,20 @@ func NewStreamingCtrl( ctrl := &StreamingCtrl{ Controller: base, - Service: serCDash, + 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() - go ctrl.listenToUIStream() return ctrl } -func (sc *StreamingCtrl) subscribeListeners() { - 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() { @@ -94,33 +88,16 @@ 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.isRunning { - slog.Info("stopping stream") - - sc.TelemServ.StopStream() - sc.Service.StopStream() - - sc.isRunning = false - return + dev, err := sc.DevService.GetPeripheral(uidevice.NAME) + if err == nil { + if uiDev, ok := dev.(*uidevice.UIDevice); ok { + sc.TelemetryCh = uiDev.DataChannel() + go sc.listenToUIStream() + } } - - // 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("starting to stream data again") - sc.Service.StartStream() - - slog.Debug("starting the stream") - sc.TelemServ.StartStream() - - slog.Debug("setting local control variables") - sc.isRunning = true - - slog.Debug("starting stream") } func (sc *StreamingCtrl) parseStreamUpdateForm(form *views.StreamOptionsView) (*models.StreamOptions, error) { @@ -155,16 +132,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 := make(map[int16]telemetry.FieldID, len(sc.Service.CDash.State.Layout.Windows)) - - for _, w := range sc.Service.CDash.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)) + // fields := sc.TelemServ.SubscribeToAllFields() + // sc.Messages <- fmt.Sprintf("Subscribed to fields: %+v\n", fields) } func (sc *StreamingCtrl) listenToUIStream() { @@ -176,8 +145,11 @@ func (sc *StreamingCtrl) listenToUIStream() { } isDrawing.Store(true) + // 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/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..a1c1f3b 100644 --- a/tui/tui.go +++ b/tui/tui.go @@ -23,15 +23,15 @@ func NewControlPanel(logger *slog.Logger) *ControlPanel { App: tview.NewApplication(), } - devService := services.NewCDashService(logger) - 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") } return &ControlPanel{ Controller: baseController, - DeviceController: controllers.NewDeviceController(baseController, devService, telemService), + DeviceController: controllers.NewDeviceController(baseController, orchestrator), } }