Author SHA1 Message Date
esilva d13ffe7821 Merge pull request 'chore: readme updated' (#21) from docs into master
Reviewed-on: #21
2026-11-08 23:19:22 +00:00
esilva 5da82a6ec3 chore: readme updated
chore: small changes
2026-11-08 23:18:01 +00:00
esilva 2fd6f6abb6 Merge pull request 'Auto detect devices' (#19) from auto-detect-devices into master
Reviewed-on: #19
2026-09-25 18:37:22 +01:00
esilva d102a45bee update the versions of the dependencies 2026-09-25 18:36:21 +01:00
esilva db30d9146d correct the go.mod 2026-09-25 15:24:18 +01:00
esilva 481b746aef Merge pull request 'Start streaming automatically' (#18) from start-streaming-automatically into auto-detect-devices
Reviewed-on: #18
2026-09-25 14:53:02 +01:00
esilva 48b10afbba devices and providers can now drop mid stream and then reconnect without impact 2026-09-25 14:48:29 +01:00
esilva 584d13e1fd removed unecessary logs from the providers and also implemented the connection dropped into beamng
This needs to be reworked tho. There's lots of code thats used both in
BeamNG and iRacing. I believe other providers will have the same issue
2026-09-25 14:47:41 +01:00
esilva d677c66a22 automated stream start
May return the user ability of stopping and starting but its really
what we want
2026-09-25 11:06:33 +01:00
esilva d14649d80c Merge pull request 'Mid stream peripheral connection' (#16) from mid-stream-peripheral-connection into auto-detect-devices
Reviewed-on: #16
2026-09-23 17:42:18 +01:00
14 changed files with 106 additions and 83 deletions
+31 -25
View File
@@ -8,47 +8,54 @@ available peripheral: [CDashDisplay](https://github.com/ESilva15/CDashDisplay).
If anyone finds this project useful for anything at all it would be pretty cool.
My main goal is to learn and have some fun.
Currently it can read from a `.ibt` file or live telemetry from iRacing.
It can only be ran from the terminal:
`go run . offline -p <port> -i <ibt-file>`
## Usage
To launch the software, compile (TBD) or just run it with: `go run . tui`
You should see something like this:
![example output in the terminal](./images/terminal_output.png)
The current behaviour is very opaque.
or to view the live data:
`go run . live -p <port>`
What is happening in the background is the software looks up for the configured
devices and for available telemetry providers.
Once it finds a device, in this case the CDashDisplay, it will try to configure
it against the available telemetry provider.
After configuring it it will automatically start streaming data from the
telemetry provider into the CDashDisplay.
Using the `arrows` you can navigate to the `stream` item on the list and then
go to the update button and press `s` to see the output on the terminal.
I upgraded the backend significantly and there's plenty of work to be done on
the frontend. I know its quite bad right now.
## Compatibility:
Games implemented so far:
- [iRacing](https://www.iracing.com/) using the [goirsdk](https://github.com/ESilva15/goirsdk)
- [BeamNG.drive](https://www.beamng.com/game/) using the [gobngsdk](https://github.com/ESilva15/gobngsdk)
Peripherals:
- [CDashDisplay](https://github.com/ESilva15/CDashDisplay)
<!-- Games being implemented: -->
<!-- - [BeamNG.drive](https://www.beamng.com/game/) using the [gobngsdk](https://github.com/ESilva15/gobngsdk) -->
<!---->
<!-- Games to be implemented: -->
<!-- - [Assetto Corsa](https://assettocorsa.gg/) -->
## Roadmap
- [X] Implement the interface for a data source
- [ ] Configuration of the peripherals via ESDI
- [ ] Detection of the display
- [ ] LapTime Calculator
- [ ] A very long list useful stuff like flags, position, more info about
other drivers, track conditions and so on so forth
- [ ] Telemetry analysis tool
- [ ] Better user interface
## Development
### Mockservers
To mock [BeamNG.drive](https://www.beamng.com/game/), I built
[BeaMNGMockOg](https://github.com/ESilva15/BeamNGMockOg) (should have though longer
about the name).
You create a recording by launching the BeamNG and then launching the mockserver with:
`BeamNGMockOg record -a 127.0.0.1 -p 4443 -o output.bin`.
I'm using a mockserver developed by myself that pretty much mimicks the telemetry
output from the actual simulators. It uses the SDKs I developed to do so with the
added bonus of being able to run the project on Linux and mainly develop it.
Just go to [TelemetryMockserver on GitHub](https://github.com/ESilva15/TelemetryMockserver) and follow
the instructions there.
To replay the recording:
`BeamNGMockOg replay [--loop] -a 127.0.0.1 -p 4443 -i input.bin`
### Troubleshooting
#### Can't see BeamNG data coming through
@@ -74,4 +81,3 @@ pprof:
## Shameless begging
Hey, doesn't hurt to try, its free either way:
[Buy me a coffee!](buymeacoffee.com/ESilva_15)
+7
View File
@@ -405,6 +405,11 @@ func (d *CDashDisplay) UnloadLayout() error {
return nil
}
func (cds *CDashDisplay) resetState() {
cds.fieldToWindows = make(map[telemetry.FieldID][]int16)
cds.State.Layout = NewLayoutTree()
}
func (cds *CDashDisplay) reset() error {
err := cds.WT.SendCommand(resetCMDID, []byte{0x01, 0x02, 0x03, 0x04}, nil)
if err != nil {
@@ -413,6 +418,8 @@ func (cds *CDashDisplay) reset() error {
time.Sleep(3000 * time.Millisecond)
cds.resetState()
return nil
}
+3 -4
View File
@@ -1,11 +1,10 @@
module esdi
go 1.27.0
go 1.26.0
require (
github.com/ESilva15/ESgoRepl v0.1.0
github.com/ESilva15/gobngsdk v1.1.3
github.com/ESilva15/goirsdk v0.3.0
github.com/ESilva15/gobngsdk v1.2.0
github.com/ESilva15/goirsdk v0.3.9
github.com/arl/statsviz v0.8.0
github.com/gdamore/tcell/v2 v2.8.1
github.com/rivo/tview v0.42.0
+4 -6
View File
@@ -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=
Binary file not shown.

Before

Width:  |  Height:  |  Size: 64 KiB

After

Width:  |  Height:  |  Size: 113 KiB

+11 -12
View File
@@ -186,13 +186,11 @@ func (b *BeamNG) Subscribe(requestFields []telemetry.FieldID) []string {
// Internal
func (b *BeamNG) readData() {
slog.Debug("READING THIS DATA")
func (b *BeamNG) readData() error {
ogSnapshot, err := b.SDK.Update()
slog.Debug("THE DATA WAS READ")
if err != nil {
slog.Error("Error getting data", "error", err)
return
return err
}
b.mut.Lock()
@@ -200,22 +198,20 @@ func (b *BeamNG) readData() {
defer b.mut.Unlock()
// Read 1 to 1 data
slog.Debug("Reading normal data binds")
for _, bind := range b.data.ActiveBinds {
slog.Debug("Current bind: ", "id", bind.ID)
b.updaters[bind.ID](&b.data.Values[bind.ID])
}
// Set up virtual binds
slog.Debug("Entering virtual binds loop")
for _, vBind := range b.data.VirtualBinds {
// NOTE: delete the logs here, they are really bad
slog.Debug("Processing virtual binds")
vBind.Process(b.data)
}
b.data.PenultimateDataPoll = b.data.LastDataPoll
b.data.LastDataPoll = time.Now()
return nil
}
func (b *BeamNG) stream(ctx context.Context) <-chan telemetry.TelemetryData {
@@ -239,14 +235,17 @@ func (b *BeamNG) stream(ctx context.Context) <-chan telemetry.TelemetryData {
case <-ctx.Done():
return
case <-b.ticker.C:
slog.Debug("READING DATA")
b.readData()
slog.Debug("READ DATA")
err := b.readData()
if err != nil {
if b.streamCancel != nil {
b.streamCancel()
}
}
// Publish data
select {
case outCh <- *b.data:
slog.Debug("PUBLISHED DATA")
// Successfuly read and sent data
default:
// skip this data, don't allow publishers to lag behind
}
+2 -2
View File
@@ -143,8 +143,8 @@ func (i *IRacing) stream(ctx context.Context) <-chan telemetry.TelemetryData {
// Put this into the configuration file
consecutiveTimeouts := 0
maxTimeouts := 30
dataEvTimeout := 100
maxTimeouts := 10
dataEvTimeout := 30
for {
// Explicitly intercept cancellation
select {
+6 -1
View File
@@ -83,14 +83,17 @@ func (ds *DeviceService) PeripheralExists(pname string) bool {
// Getters [END] ---------------------------------------------------------------
// Actions [START] -------------------------------------------------------------
func (ds *DeviceService) StartStream() {
func (ds *DeviceService) StartStream(ch <-chan telemetry.TelemetryData) {
// NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this
ds.SetTelemetryChannel(ch)
var ctx context.Context
ctx, ds.streamCancel = context.WithCancel(context.Background())
ds.PSS.OnStartStream()
go ds.transmit(ctx)
ds.Messages <- "Device service started stream\n"
}
func (ds *DeviceService) StopStream() {
@@ -154,6 +157,8 @@ func (ds *DeviceService) peripheralConfigured(pname string, fields []telemetry.F
// We need to retrigger field subscription here
subscribedTo := ds.triggerFieldSubscription(fields)
ds.Messages <- fmt.Sprintf("subscribed to fields: %q\n", subscribedTo)
ds.PSS.OnStartStreamPeripheral(pname)
}
// Callbacks [END] -------------------------------------------------------------
+5
View File
@@ -1 +1,6 @@
package services
func (ds *DeviceService) OnStoppedMidStream() {
// Need to make every device be unconfigured
ds.StopStream()
}
+14 -2
View File
@@ -211,14 +211,25 @@ func (pss *PeripheralStateStore) OnStartStream() {
}
}
func (pss *PeripheralStateStore) OnStartStreamPeripheral(pname string) {
state, err := pss.GetState(pname)
if err != nil {
return
}
if state.State == DeviceIsConfigured {
pss.setDeviceIsStreaming(pname)
}
}
func (pss *PeripheralStateStore) OnStopStream() {
pss.mu.Lock()
pss.isStreaming = false
pss.mu.Unlock()
for _, state := range pss.GetStates() {
if state.State == DeviceIsStreaming {
pss.setDeviceConfigured(state.device.Name)
if state.State > DeviceIsConfigured {
pss.setDeviceUnconfigured(state.device.Name)
}
}
}
@@ -349,6 +360,7 @@ func (pss *PeripheralStateStore) configurePeripheral(
onFailure(pname)
return
}
pss.Messages <- fmt.Sprintf("Configuring peripheral for provider: %s\n", provider)
err = state.Peripheral.Setup(provider)
if err != nil {
+2 -1
View File
@@ -29,7 +29,8 @@ func NewOrchestrator(logger *slog.Logger) (*Orchestrator, error) {
devService.triggerFieldSubscription = telemService.SubscribeToFields
// Setup telemetry service callbacks
// telemService.getRequiredFields = devService.GetRequiredFields
telemService.startedStreaming = devService.StartStream
telemService.providerStoppedMidStream = devService.OnStoppedMidStream
return &Orchestrator{
DeviceService: devService,
+9 -6
View File
@@ -35,6 +35,8 @@ type TelemetryService struct {
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
@@ -138,6 +140,7 @@ func (t *TelemetryService) dropActiveProvider() {
t.cancelForward()
}
// NOTE: can we move the stop stream into the provider Close() method?
t.activeProvider.StopStream()
t.activeProvider.Close()
t.activeProvider = nil
@@ -204,21 +207,17 @@ func (t *TelemetryService) StopStream() {
t.isStreaming = false
}
func (t *TelemetryService) StartStream() {
slog.Debug("Stream started")
func (t *TelemetryService) StartStream() <-chan telemetry.TelemetryData {
// Start the new stream
if t.activeProvider == nil {
slog.Debug("there's no active provider. not starting the stream")
return
return nil
}
// Stop the provider healthcheck
t.healthCheckCancel()
simInCh, _ := t.activeProvider.Stream()
// TODO: the provider needs to be able to tell the data has stopped
// so we can restart the provider lookup routine
// Create the context so we can control the lifecycle
ctx, cancel := context.WithCancel(context.Background())
@@ -227,6 +226,10 @@ func (t *TelemetryService) StartStream() {
// Multiplex this data
go t.multiplexData(ctx, simInCh)
t.isStreaming = true
t.Messages <- "Provider has started streaming data\n"
return simInCh
}
func (t *TelemetryService) multiplexData(ctx context.Context, dataCh <-chan telem.TelemetryData) {
+10
View File
@@ -16,6 +16,7 @@ func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) {
// Attach to the provider
t.logger.Info("found provider for " + prov.Name())
t.Messages <- fmt.Sprintf("Found provider \"%s\"\n", prov.Name())
err := t.SwitchProvider(prov)
if err != nil {
t.Messages <- fmt.Sprintf("Failed to switch to provider: %+v\n", err.Error())
@@ -26,6 +27,11 @@ func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) {
// Start the healthcheck on our provider so we can drop it if it stops
t.CtxHealthcheck, t.healthCheckCancel = context.WithCancel(context.Background())
go t.ProviderMonitor(t.CtxHealthcheck)
ch := t.StartStream()
t.startedStreaming(ch)
t.Messages <- "provider switch completed"
}
func (t *TelemetryService) onProviderStopsMidStream() {
@@ -34,6 +40,10 @@ func (t *TelemetryService) onProviderStopsMidStream() {
// if the stream stopped we have to restart the devices and everything
t.Messages <- "Telemetry provider stopped mid stream\n"
t.logger.Info("cleaning dropped provider and restarting lookup service")
t.dropActiveProvider()
go t.FindProvider(t.CtxMonitor)
// Tell the devices service that we lost the thing
t.providerStoppedMidStream()
}
+2 -24
View File
@@ -88,23 +88,9 @@ func (sc *StreamingCtrl) registerHooks() {
}
}
// TODO: this isn't the startstop method/action anymore. It should show up the stream
// visualizer - TODO: add metrics to the visualizer too, instead of just data
func (sc *StreamingCtrl) StartStop() {
if sc.TelemServ.IsStreaming() {
slog.Info("stopping stream")
sc.TelemServ.StopStream()
sc.DevService.StopStream()
sc.isRunning = false
return
}
// stream is not running, we have to start it now
// NOTE:
// Subscribe the only existing device - needs to be discovered by now
slog.Debug("setting the data stream for device servie")
sc.DevService.SetTelemetryChannel(sc.TelemServ.SubscribeListener("DeviceService", 1))
dev, err := sc.DevService.GetPeripheral(uidevice.NAME)
if err == nil {
if uiDev, ok := dev.(*uidevice.UIDevice); ok {
@@ -112,14 +98,6 @@ func (sc *StreamingCtrl) StartStop() {
go sc.listenToUIStream()
}
}
slog.Debug("starting services")
sc.DevService.StartStream()
sc.TelemServ.StartStream()
sc.isRunning = true
slog.Debug("starting stream")
}
func (sc *StreamingCtrl) parseStreamUpdateForm(form *views.StreamOptionsView) (*models.StreamOptions, error) {