Files
esdi/providers/iracing/iracing.go
T
esilva 0887fbfd75 simplified a bit how the TelemetryField updaters work
- now we only use one function to update the TelemetryField instead
of having to fetch data and then update it.

Still need to update the iRacing provider to use this pattern. Way
better and creates better units.

Got rid of that stupid long ass switch statement too
2026-07-07 17:52:47 +01:00

311 lines
8.1 KiB
Go

// Package iracing is in the providers and provides telemety to our desktop
// application. It needs to establish a relationship between the desktop data
// structure of our app and the data iRacing provides
package iracing
import (
"context"
"fmt"
"log/slog"
"os"
"strconv"
"sync"
"time"
conv "esdi/conversions"
"esdi/telemetry"
"github.com/ESilva15/goirsdk"
)
const (
NAME = "iRacing"
)
// IRacing is our iRacing telemetry data provider - its a TelemetryProvider interface
type IRacing struct {
logger *slog.Logger
SDK *goirsdk.IBT
// Data Handling
mut sync.Mutex
data *telemetry.TelemetryData
// Timing information
ticker *time.Ticker // ticker will keep polling intervals constant
// Stream
streamCh chan telemetry.TelemetryData
streamCancel context.CancelFunc
}
func NewIRacingProvider(
logger *slog.Logger,
source string,
telemOut string,
yamlOut string,
) (*IRacing, error) {
var err error
// Open the input file if provided - otherwise live telemetry was requested
// Maybe this can be changed so we don't have to run it with these ifs but by configuring our
// provider
var file goirsdk.Reader = nil
if source != "" {
file, err = os.Open(source)
if err != nil {
return &IRacing{}, err
// log.Fatalf("Failed to open IBT file: %v", err)
}
}
sdk, err := goirsdk.Init(file, telemOut, yamlOut)
if err != nil {
logger.Error("failed to open the IRSDK instance")
return &IRacing{}, err
}
return &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),
}, nil
}
func (i *IRacing) isDataAvailable() bool {
// Its offline telemetry, data must be available
if i.SDK.File != nil {
return true
}
// Check if live telemetry is on
if i.SDK.IsConnected() {
return true
}
return false
}
func (i *IRacing) stream(ctx context.Context) {
i.data.InitialTime = time.Now()
go func() {
for {
// Explicitly intercpt 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:
i.readData()
// Publish data
select {
case i.streamCh <- *i.data:
default:
// skip this data, don't allow publishers to lag behind
}
}
}
}()
}
func (i *IRacing) readData() {
i.mut.Lock()
defer i.mut.Unlock()
var err error
_, err = i.SDK.Update(time.Millisecond * 16)
if err != nil {
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])
}
// 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)
}
i.data.PenultimateDataPoll = i.data.LastDataPoll
i.data.LastDataPoll = time.Now()
}
// Telemetry Provider Interface
// Stream returns a channel that we will use to funnel the telemetry data back to the
// UI, which then should broadcast it to the devices
func (i *IRacing) Stream() (<-chan telemetry.TelemetryData, error) {
var ctx context.Context
ctx, i.streamCancel = context.WithCancel(context.Background())
// Start the stream
i.stream(ctx)
return i.streamCh, nil
}
func (i *IRacing) StopStream() {
if i.streamCancel == nil {
return
}
i.streamCancel()
i.streamCancel = nil
}
func (i *IRacing) Subscribe(requestFields map[int16]telemetry.FieldID) {
i.logger.Debug(fmt.Sprintf("Len Req: %d\n", len(requestFields)))
i.data.ActiveBinds = make([]telemetry.BoundField, 0, 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)
switch id {
case telemetry.RPMStateColour:
i.data.VirtualBinds = append(i.data.VirtualBinds, telemetry.NewRPMLights())
case telemetry.FCCurrentLap:
i.data.VirtualBinds = append(i.data.VirtualBinds,
telemetry.NewFuelCalculator(i.logger.WithGroup("FUEL CALC")))
default:
// primitive telemetry field
pendingBinds = append(pendingBinds, id)
}
}
boundCheck := make(map[telemetry.FieldID]bool)
// Now that we know all the fields we need to bind we follow the binding procedure
for _, id := range pendingBinds {
// Check if we already bound this FieldID
if boundCheck[id] {
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
}
i.logger.Debug(fmt.Sprintf("Subscribed: %+v\n", i.data.ActiveBinds))
}