diff --git a/cmd/repl.go b/cmd/repl.go index 503783e..7467a0e 100644 --- a/cmd/repl.go +++ b/cmd/repl.go @@ -1,103 +1,97 @@ package cmd import ( - "esdi/peripheral" - "fmt" - "strconv" - - repl "github.com/ESilva15/ESgoRepl" - "github.com/spf13/cobra" ) func replCmdAction(cmd *cobra.Command, args []string) { - r := repl.NewREPL(repl.REPLCfg{ - PS1: "\rESDI > ", - }) - - perClerk := peripheral.NewPeripheralDeviceClerk() - - discoverDevicesREPLCmd := repl.Command{ - Name: "discover", - Usage: "discovers connected devices", - Action: func(r *repl.REPL, args []string) error { - err := perClerk.FindDevices() - if err != nil { - return err - } - - return nil - }, - } - - listDevicesREPLCmd := repl.Command{ - Name: "list", - Usage: "lists connected devices", - Action: func(r *repl.REPL, args []string) error { - _ = perClerk.ListDevices() - - return nil - }, - } - - listDeviceAPIREPLCmd := repl.Command{ - Name: "v-api", - Usage: "shows API of a device - pass its ID", - Action: func(r *repl.REPL, args []string) error { - // We should add this to the REPL instead - if len(args) < 1 { - return fmt.Errorf("requires at least on argument") - } - - // First and only argument should be the ID of the device we want to use - targetID, err := strconv.ParseInt(args[0], 10, 0) - if err != nil { - return err - } - - err = perClerk.ListDeviceAPI(uint8(targetID)) - if err != nil { - fmt.Println("failed to view device API: ", err.Error()) - } - - return nil - }, - } - - runDeviceAPIREPLCmd := repl.Command{ - Name: "v-run", - Usage: "runs a funcion of a device - pass its ID and function name", - Action: func(r *repl.REPL, args []string) error { - // We should add this to the REPL instead - if len(args) < 3 { - return fmt.Errorf("requires at least on argument") - } - - // First and only argument should be the ID of the device we want to use - targetID, err := strconv.ParseInt(args[0], 10, 0) - if err != nil { - return err - } - - fnName := args[1] - fnArgs := args[2:] - - err = perClerk.RunDeviceFunction(uint8(targetID), fnName, fnArgs) - if err != nil { - return err - } - - return nil - }, - } - - r.RegisterCMD(discoverDevicesREPLCmd) - r.RegisterCMD(listDevicesREPLCmd) - r.RegisterCMD(listDeviceAPIREPLCmd) - r.RegisterCMD(runDeviceAPIREPLCmd) - - r.Start() - r.Close() + // r := repl.NewREPL(repl.REPLCfg{ + // PS1: "\rESDI > ", + // }) + // + // perClerk := peripheral.NewPeripheralDeviceClerk() + // + // discoverDevicesREPLCmd := repl.Command{ + // Name: "discover", + // Usage: "discovers connected devices", + // Action: func(r *repl.REPL, args []string) error { + // err := perClerk.FindDevices() + // if err != nil { + // return err + // } + // + // return nil + // }, + // } + // + // listDevicesREPLCmd := repl.Command{ + // Name: "list", + // Usage: "lists connected devices", + // Action: func(r *repl.REPL, args []string) error { + // _ = perClerk.ListDevices() + // + // return nil + // }, + // } + // + // listDeviceAPIREPLCmd := repl.Command{ + // Name: "v-api", + // Usage: "shows API of a device - pass its ID", + // Action: func(r *repl.REPL, args []string) error { + // // We should add this to the REPL instead + // if len(args) < 1 { + // return fmt.Errorf("requires at least on argument") + // } + // + // // First and only argument should be the ID of the device we want to use + // targetID, err := strconv.ParseInt(args[0], 10, 0) + // if err != nil { + // return err + // } + // + // err = perClerk.ListDeviceAPI(uint8(targetID)) + // if err != nil { + // fmt.Println("failed to view device API: ", err.Error()) + // } + // + // return nil + // }, + // } + // + // runDeviceAPIREPLCmd := repl.Command{ + // Name: "v-run", + // Usage: "runs a funcion of a device - pass its ID and function name", + // Action: func(r *repl.REPL, args []string) error { + // // We should add this to the REPL instead + // if len(args) < 3 { + // return fmt.Errorf("requires at least on argument") + // } + // + // // First and only argument should be the ID of the device we want to use + // targetID, err := strconv.ParseInt(args[0], 10, 0) + // if err != nil { + // return err + // } + // + // fnName := args[1] + // fnArgs := args[2:] + // + // err = perClerk.RunDeviceFunction(uint8(targetID), fnName, fnArgs) + // if err != nil { + // return err + // } + // + // return nil + // }, + // } + // + // r.RegisterCMD(discoverDevicesREPLCmd) + // r.RegisterCMD(listDevicesREPLCmd) + // r.RegisterCMD(listDeviceAPIREPLCmd) + // r.RegisterCMD(runDeviceAPIREPLCmd) + // + // r.Start() + // r.Close() } // removeLabelCmd represents the removeLabel command diff --git a/devices/cdashdisplay/display.go b/devices/cdashdisplay/display.go index 7175bc2..267c86d 100644 --- a/devices/cdashdisplay/display.go +++ b/devices/cdashdisplay/display.go @@ -140,6 +140,14 @@ func NewCDashDisplay() (*CDashDisplay, error) { }, nil } +func (cds *CDashDisplay) Close() error { + // if cds.WT != nil { + // cds.Close() + // } + + return nil +} + func (d *CDashDisplay) SendCommand() { } diff --git a/devices/device.go b/devices/device.go index 9318cac..84ab486 100644 --- a/devices/device.go +++ b/devices/device.go @@ -12,7 +12,7 @@ type Device struct { Discover func() (peripheral.Peripheral, error) } -var List map[string]Device = map[string]Device{ +var List map[string]*Device = map[string]*Device{ uidevice.NAME: { Name: uidevice.NAME, Discover: DiscoverUIDevice, diff --git a/devices/uidevice/device.go b/devices/uidevice/device.go index 4f0ac2e..763f759 100644 --- a/devices/uidevice/device.go +++ b/devices/uidevice/device.go @@ -17,6 +17,14 @@ func NewUIDevice() (peripheral.Peripheral, error) { }, nil } +func (uid *UIDevice) Close() error { + if uid.dataChan != nil { + close(uid.dataChan) + } + + return nil +} + func (uid *UIDevice) SendData(data *telemetry.TelemetryData) error { if data == nil { return peripheral.ErrInvalidData diff --git a/peripheral/communication/walkieTalkie.go b/peripheral/communication/walkieTalkie.go index e5503b6..fde5936 100644 --- a/peripheral/communication/walkieTalkie.go +++ b/peripheral/communication/walkieTalkie.go @@ -108,6 +108,15 @@ func (wt *WalkieTalkie) sendPacket(cmd types.Command, data any) error { return err } + // slog.Debug("# START ########################################################") + // slog.Debug(fmt.Sprintf("StartMarker: %02x", constvar.StartOfText)) + // slog.Debug(fmt.Sprintf("CMD: %02x", cmd)) + // slog.Debug(fmt.Sprintf("Len: %d", len(payload))) + // slog.Debug(fmt.Sprintf("Payload: %v", payload)) + // slog.Debug(fmt.Sprintf("CRC: %v", CRC8(payload))) + // slog.Debug(fmt.Sprintf("EndMarker: %02x", constvar.EndOfText)) + // slog.Debug("-") + packet := CMDDataPacket{ StartMarker: constvar.StartOfText, CMD: cmd, @@ -119,7 +128,9 @@ func (wt *WalkieTalkie) sendPacket(cmd types.Command, data any) error { // Send the payload serializedPacket := packet.Serialize() - // fmt.Fprintf(os.Stderr, "%+v", serializedPacket) + + // slog.Debug("Serialized packet", "packet", packet) + // slog.Debug("# END ##########################################################") _, err = wt.Serial.Write(serializedPacket) if err != nil { @@ -176,21 +187,11 @@ func (wt *WalkieTalkie) readPacket(resp packets.Packet) error { // return nil // } -func (wt *WalkieTalkie) SendCommand(cmd types.Command, payload any, - responseBody packets.Packet) error { - // Prepare the header - // header := header{ - // StartByte: constvar.StartOfText, - // CMD: cmd, - // EndByte: constvar.EndOfText, - // } - - // Send the header - // err := wt.sendHeader(&header) - // if err != nil { - // return err - // } - +func (wt *WalkieTalkie) SendCommand( + cmd types.Command, + payload any, + responseBody packets.Packet, +) error { // Send the body err := wt.sendPacket(cmd, payload) if err != nil { diff --git a/peripheral/peripheral.go b/peripheral/peripheral.go index 21379af..ed667a7 100644 --- a/peripheral/peripheral.go +++ b/peripheral/peripheral.go @@ -19,6 +19,7 @@ type Peripheral interface { Name() string SendData(*telemetry.TelemetryData) error RequiredFields() []telemetry.FieldID + Close() error } type PeripheralDeviceClerk struct { diff --git a/providers/iracing/iracing.go b/providers/iracing/iracing.go index c792f4f..9701f6f 100644 --- a/providers/iracing/iracing.go +++ b/providers/iracing/iracing.go @@ -54,10 +54,8 @@ func NewIRacingProvider( logger: logger, SDK: sdk, data: telemetry.NewTelemetryData(), - // streamCh: make(chan telemetry.TelemetryData, 1), - // NOTE: This is because I stupidly recorded a test IBT file in 240 // TODO: make this configurable from the user side - ticker: time.NewTicker(time.Second / 240), + ticker: time.NewTicker(time.Second / 60), } provider.updaters = [telemetry.MaxFields]func(*telemetry.TelemetryField){ diff --git a/services/devices.go b/services/devices.go index 8ea1a3c..214208a 100644 --- a/services/devices.go +++ b/services/devices.go @@ -2,32 +2,21 @@ package services import ( "context" - "errors" - "fmt" "log/slog" - "sync" "sync/atomic" - "time" "esdi/devices" "esdi/peripheral" "esdi/telemetry" ) -var ErrPeripheralAlreadyRegistered = errors.New("peripheral is already registered") - -// DeviceService will handle sending the data from the telemetry service to the -// actual devices -// NOTE: create a virtual device and make it be the output window or something so -// we can just add it as a device or whatever instead of being a custom made thing -// that would be pretty cool I think +// DeviceService is the API for the peripherals type DeviceService struct { Logger *slog.Logger // Device discovery - mu sync.RWMutex + PSS *PeripheralStateStore // Store to track peripheral state ctxDiscovery context.Context ctxDiscoveryCancel context.CancelFunc - Devices map[string]peripheral.Peripheral // Strem handling streamCancel context.CancelFunc TelemCh <-chan telemetry.TelemetryData @@ -39,7 +28,7 @@ func NewDeviceService(logger *slog.Logger) *DeviceService { sharedChannel := make(chan string, 10) dev := &DeviceService{ - Devices: make(map[string]peripheral.Peripheral), + PSS: NewPeripheralStateStore(logger.With("Service", "PeripheralStateStore"), devices.List), Logger: logger, Messages: sharedChannel, } @@ -52,68 +41,33 @@ func NewDeviceService(logger *slog.Logger) *DeviceService { return dev } -func (ds *DeviceService) FindDevices() { - // Need to define a list of devices to search for - // For now lets just try to find our cdashdisplay - will think about the rest later - ticker := time.NewTicker(2 * time.Second) - defer ticker.Stop() +// Getters [START] ------------------------------------------------------------- +func (ds *DeviceService) GetDevices() []peripheral.Peripheral { + snapshot := ds.PSS.GetStates() + peripherals := make([]peripheral.Peripheral, 0, len(snapshot)) - for { - select { - case <-ds.ctxDiscovery.Done(): - // If requested to cancel we cancel background discovery - return - case <-ticker.C: - for pName, peripheral := range devices.List { - if ds.DeviceExists(pName) { - // We already discovered this device - continue - } - - ds.Logger.Debug("looking for device", "name", pName) - dev, err := peripheral.Discover() - if err != nil { - ds.Logger.Debug("didn't find device", "name", pName) - continue - } - - // Register the device we just found - ds.RegisterDevice(dev) - } + for _, state := range snapshot { + if state.State != DeviceIsConnected { + continue } - } -} - -func (ds *DeviceService) RegisterDevice(dev peripheral.Peripheral) error { - ds.mu.Lock() - defer ds.mu.Unlock() - - if ds.DeviceExists(dev.Name()) { - return ErrPeripheralAlreadyRegistered + peripherals = append(peripherals, state.Peripheral) } - ds.Devices[dev.Name()] = dev - - return nil + return peripherals } -func (ds *DeviceService) GetDevice(name string) (peripheral.Peripheral, error) { - val, ok := ds.Devices[name] - if !ok { - return nil, fmt.Errorf("device `%s` couldn't be found", name) - } - - return val, nil +func (ds *DeviceService) GetPeripheral(pname string) (peripheral.Peripheral, error) { + return ds.PSS.GetPeripheral(pname) } -func (ds *DeviceService) DeviceExists(name string) bool { - if _, ok := ds.Devices[name]; !ok { - return false - } - - return true +func (ds *DeviceService) PeripheralExists(pname string) bool { + _, err := ds.PSS.GetPeripheral(pname) + return err == nil } +// Getters [END] --------------------------------------------------------------- + +// Actions [START] ------------------------------------------------------------- func (ds *DeviceService) StartStream() { // NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this var ctx context.Context @@ -136,6 +90,8 @@ func (ds *DeviceService) SetTelemetryChannel(ch <-chan telemetry.TelemetryData) ds.TelemCh = ch } +// Actions [END] --------------------------------------------------------------- + // transmit will send the data to the devices themselves func (ds *DeviceService) transmit(ctx context.Context) { var isSending atomic.Bool @@ -157,15 +113,17 @@ func (ds *DeviceService) transmit(ctx context.Context) { // TODO: make a copy of the data and send that copy instead of keeping // the data locked - ds.mu.RLock() - for _, dev := range ds.Devices { - err := dev.SendData(&data) + for _, dev := range ds.PSS.GetStates() { + if dev.State != DeviceIsConnected { + continue + } + + err := dev.Peripheral.SendData(&data) + if err == peripheral.ErrDeviceTimedOut { - // What do we do here? - // TODO: somehow we need to handle reconnection + ds.onDeviceTimedOut(dev.device.Name) } } - ds.mu.RUnlock() isSending.Store(false) } diff --git a/services/devices_lookup.go b/services/devices_lookup.go new file mode 100644 index 0000000..98e7655 --- /dev/null +++ b/services/devices_lookup.go @@ -0,0 +1,222 @@ +package services + +import ( + "errors" + "log/slog" + "maps" + "sync" + "time" + + "esdi/devices" + "esdi/peripheral" +) + +var ( + ErrPeripheralAlreadyRegistered = errors.New("peripheral is already registered") + ErrNoSuchDevice = errors.New("device doesn't exist") + ErrDeviceIsNotConnected = errors.New("device isn't connected") +) + +type DeviceState = uint8 + +const ( + DeviceTimedOut uint8 = iota + DeviceIsConnected + DeviceIsDisconnected + DeviceReconnected +) + +type PeripheralState struct { + device *devices.Device + Peripheral peripheral.Peripheral + State DeviceState +} + +func NewPeripheralState( + dev *devices.Device, + peripheral peripheral.Peripheral, + state DeviceState, +) *PeripheralState { + perState := PeripheralState{ + device: dev, + Peripheral: peripheral, + State: state, + } + + return &perState +} + +type PeripheralStateStore struct { + Logger *slog.Logger + mu sync.RWMutex + store map[string]*PeripheralState +} + +func NewPeripheralStateStore( + nLogger *slog.Logger, + devList map[string]*devices.Device, +) *PeripheralStateStore { + store := PeripheralStateStore{ + Logger: nLogger, + store: make(map[string]*PeripheralState), + } + + for _, dev := range devList { + store.AddDevice(dev) + } + + return &store +} + +func (pss *PeripheralStateStore) GetStates() map[string]*PeripheralState { + pss.mu.RLock() + defer pss.mu.RUnlock() + + return maps.Clone(pss.store) +} + +func (pss *PeripheralStateStore) GetState(pname string) (*PeripheralState, error) { + if !pss.DeviceExists(pname) { + return nil, ErrNoSuchDevice + } + + pss.mu.RLock() + defer pss.mu.RUnlock() + return pss.store[pname], nil +} + +func (pss *PeripheralStateStore) GetPeripheral(pname string) (peripheral.Peripheral, error) { + state, err := pss.GetState(pname) + if err != nil { + return nil, err + } + + if state.State != DeviceIsConnected { + return nil, ErrDeviceIsNotConnected + } + + return state.Peripheral, nil +} + +// AddDevice adds a new device for tracking +func (pss *PeripheralStateStore) AddDevice(dev *devices.Device) error { + if pss.DeviceExists(dev.Name) { + return ErrPeripheralAlreadyRegistered + } + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[dev.Name] = NewPeripheralState(dev, nil, DeviceIsDisconnected) + + return nil +} + +// DeviceExists returns whether the store is already tracking `pname` +func (pss *PeripheralStateStore) DeviceExists(pname string) bool { + pss.mu.RLock() + defer pss.mu.RUnlock() + + if _, ok := pss.store[pname]; ok { + return true + } + + return false +} + +// DeleteDevice deletes `pname` from tracking +func (pss *PeripheralStateStore) DeleteDevice(pname string) error { + if !pss.DeviceExists(pname) { + return ErrNoSuchDevice + } + + pss.mu.Lock() + defer pss.mu.Unlock() + + delete(pss.store, pname) + + return nil +} + +// "Events" [START] ------------------------------------------------------------ +func (ds *DeviceService) onDeviceTimedOut(pname string) { + // We need to deregister the device + ds.PSS.setDeviceTimedOut(pname) +} + +// "Events" [END] -------------------------------------------------------------- + +// Device State Handling [START] ----------------------------------------------- +func (pss *PeripheralStateStore) setDeviceConnected(pname string, per peripheral.Peripheral) { + pss.Logger.Info("found device", "device", pname) + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].Peripheral = per + pss.store[pname].State = DeviceIsConnected +} + +func (pss *PeripheralStateStore) setDeviceTimedOut(pname string) { + pss.Logger.Info("device timed out", "device", pname) + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].Peripheral = nil + pss.store[pname].State = DeviceTimedOut +} + +func (pss *PeripheralStateStore) setDeviceReconnected(pname string, per peripheral.Peripheral) { + pss.Logger.Info("device reconnecting", "device", pname) + + pss.mu.Lock() + defer pss.mu.Unlock() + pss.store[pname].Peripheral = per + pss.store[pname].State = DeviceReconnected +} + +// Device State Handling [END] ------------------------------------------------- + +// Device Handling [START] ----------------------------------------------------- +func (pss *PeripheralStateStore) HandleDeviceState() { + peripherals := pss.GetStates() + + for pName, pState := range peripherals { + switch pState.State { + case DeviceIsDisconnected: + pss.Logger.Debug("looking for device", "name", pName) + dev, err := pState.device.Discover() + if err != nil { + continue + } + + // Register the device we just found + pss.setDeviceConnected(pName, dev) + case DeviceIsConnected: + // Need to check if its streaming, if its not streaming than we have to do a healthcheck + pss.Logger.Debug("Device is connected. Normal", "device", pName) + case DeviceReconnected: + // If the device has reconnected we need to reset the device and then set it as connected + pss.Logger.Debug("Device has reconnected. Clearing up state", "device", pName) + case DeviceTimedOut: + // If the device has timed out we need to re-discover it or something + pss.Logger.Debug("Device is timed out. Attempting to recconect", "device", pName) + } + } +} + +// Device Handling [END] ------------------------------------------------------- + +// FindDevices is a routine that goes over the devices in the PeripheralStateStore +// and handles their state accordingly +func (ds *DeviceService) FindDevices() { + ticker := time.NewTicker(2 * time.Second) + defer ticker.Stop() + + for { + select { + case <-ds.ctxDiscovery.Done(): + return + case <-ticker.C: + ds.PSS.HandleDeviceState() + } + } +} diff --git a/services/telemetry.go b/services/telemetry.go index 7af4cb4..674be83 100644 --- a/services/telemetry.go +++ b/services/telemetry.go @@ -102,7 +102,7 @@ func (t *TelemetryService) SubscribeToFields() []telem.FieldID { seen := make(map[telemetry.FieldID]struct{}) var allFields []telemetry.FieldID - for _, dev := range t.devService.Devices { + for _, dev := range t.devService.GetDevices() { for _, field := range dev.RequiredFields() { if _, exists := seen[field]; !exists { seen[field] = struct{}{} diff --git a/tui/internal/controllers/cdashdisplay_layout.go b/tui/internal/controllers/cdashdisplay_layout.go index 6400b47..f90f6a7 100644 --- a/tui/internal/controllers/cdashdisplay_layout.go +++ b/tui/internal/controllers/cdashdisplay_layout.go @@ -211,7 +211,7 @@ func (lc *LayoutController) createWindow() { } // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -321,7 +321,7 @@ func (lc *LayoutController) newWindowAction() { func (lc *LayoutController) updateWindowAction(win *cdashdisplay.DesktopUIWindow) { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -347,7 +347,7 @@ func (lc *LayoutController) displayLoadedLayouts() { lc.Logger.Debug("We want to view our layout!") // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -392,7 +392,7 @@ func (lc *LayoutController) getCurrentTreeNodeModel() (*tview.TreeNode, int16, e func (lc *LayoutController) loadLayout() { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -416,7 +416,7 @@ func (lc *LayoutController) loadLayout() { func (lc *LayoutController) unloadLayout() { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -437,7 +437,7 @@ func (lc *LayoutController) unloadLayout() { func (lc *LayoutController) saveLayout() { // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return @@ -470,7 +470,7 @@ func (lc *LayoutController) deleteWindow() { wID := curNode.GetReference().(int16) // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return diff --git a/tui/internal/controllers/cdashdisplay_layout_moveTool.go b/tui/internal/controllers/cdashdisplay_layout_moveTool.go index ba31690..87487bf 100644 --- a/tui/internal/controllers/cdashdisplay_layout_moveTool.go +++ b/tui/internal/controllers/cdashdisplay_layout_moveTool.go @@ -52,7 +52,7 @@ func (lc *LayoutController) handleMovementCapture(idx int16, } // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return nil @@ -86,7 +86,7 @@ func (lc *LayoutController) handleResizeCapture(idx int16, } // Acquire the cdashdisplay - displayIF, err := lc.DevService.GetDevice(cdashdisplay.NAME) + displayIF, err := lc.DevService.GetPeripheral(cdashdisplay.NAME) if err != nil { lc.Messages <- "failed to get " + cdashdisplay.NAME return nil diff --git a/tui/internal/controllers/device.go b/tui/internal/controllers/device.go index 22c3e73..f0f86a3 100644 --- a/tui/internal/controllers/device.go +++ b/tui/internal/controllers/device.go @@ -67,7 +67,7 @@ func (mc *DeviceController) AddDeviceAPIListItems() { mc.DeviceAPIView.DevAPIList. AddItem("layout", "build a layout for CDashDisplay", func() { // This CDashDisplay specific, only load if we have a CDashDisplay - if !mc.DevService.DeviceExists(cdashdisplay.NAME) { + if !mc.DevService.PeripheralExists(cdashdisplay.NAME) { mc.DevService.Messages <- "CDashDisplay it not loaded yet\n" return } diff --git a/tui/internal/controllers/streaming.go b/tui/internal/controllers/streaming.go index 3a05dc5..9778602 100644 --- a/tui/internal/controllers/streaming.go +++ b/tui/internal/controllers/streaming.go @@ -110,7 +110,7 @@ func (sc *StreamingCtrl) StartStop() { slog.Debug("setting the data stream for device servie") sc.DevService.SetTelemetryChannel(sc.TelemServ.SubscribeListener("DeviceService", 1)) - dev, err := sc.DevService.GetDevice(uidevice.NAME) + dev, err := sc.DevService.GetPeripheral(uidevice.NAME) if err == nil { if uiDev, ok := dev.(*uidevice.UIDevice); ok { sc.TelemetryCh = uiDev.DataChannel()