ESilvaLabs/esdi
1
0
Fork 0
Code Issues 8 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Focused this in iRacing so that I don't need to worry about some stuff for now

Browse Source
This commit is contained in:
esilva
2025-01-26 21:49:51 +00:00
parent c302123070
commit dbea7e7475
7 changed files with 235 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cmdLiveTelemetry.go
+12 -6
View File
@@ -2,8 +2,9 @@ package main
import (
"esdi/logger"
"esdi/sources/iracing"
// "esdi/sources/iracing"
"github.com/ESilva15/goirsdk"
"github.com/spf13/cobra"
)
@@ -21,12 +22,17 @@ func liveTelemetryCmdAction(cmd *cobra.Command, args []string) {
log.Fatalf("Failed to get Desktop Interface: %v", err)
}
irsdk, err := iracing.Init(nil, outputFile, sessionFile)
if err != nil {
log.Fatalf("Failed to create iRacing interface: %v", err)
}
// irsdk, err := iracing.Init(nil, outputFile, sessionFile)
// if err != nil {
// log.Fatalf("Failed to create iRacing interface: %v", err)
// }
esdi.Source = &irsdk
irsdk, err := goirsdk.Init(nil, outputFile, sessionFile)
if err != nil {
log.Fatalf("Failed to create irsdk instance: %v\n", err)
}
esdi.irsdk = irsdk
esdi.telemetry()
}
cmdOfflineTelemetry.go
+9 -4
View File
@@ -4,7 +4,8 @@ import (
"os"
"esdi/logger"
"esdi/sources/iracing"
// "esdi/sources/iracing"
"github.com/ESilva15/goirsdk"
"github.com/spf13/cobra"
)
@@ -29,12 +30,16 @@ func offlineTelemetryCmdAction(cmd *cobra.Command, args []string) {
log.Fatalf("Failed to open IBT file: %v", err)
}
irsdk, err := iracing.Init(file, outFile, sessionFile)
// irsdk, err := iracing.Init(file, outFile, sessionFile)
// if err != nil {
// log.Fatalf("Failed to create iRacing interface: %v", err)
// }
irsdk, err := goirsdk.Init(file, outFile, sessionFile)
if err != nil {
log.Fatalf("Failed to create iRacing interface: %v", err)
log.Fatalf("Failed to create irsdk instance: %v\n", err)
}
esdi.Source = &irsdk
esdi.irsdk = irsdk
esdi.telemetry()
}
esdi.go
+14 -10
View File
@@ -3,13 +3,16 @@ package main
import (
"log"
"github.com/ESilva15/goirsdk"
"github.com/tarm/serial"
)
type ESDI struct {
SerialConfig *serial.Config
SerialConn *serial.Port
Source GameSource
irsdk *goirsdk.IBT
data DataPacket
// Source GameSource
}
func (e *ESDI) Close() {
@@ -20,16 +23,17 @@ func (e *ESDI) Close() {
}
func ESDIInit(port string, baud int) (ESDI, error) {
sConfig := &serial.Config{
Name: port,
Baud: baud,
}
// sConfig := &serial.Config{
// Name: port,
// Baud: baud,
// }
// Open the serial port
sPort, err := serial.OpenPort(sConfig)
if err != nil {
return ESDI{}, err
}
// sPort, err := serial.OpenPort(sConfig)
// if err != nil {
// return ESDI{}, err
// }
return ESDI{sConfig, sPort, nil}, nil
// return ESDI{sConfig, sPort, nil}, nil
return ESDI{nil, nil, nil, DataPacket{}}, nil
}
esdiTelemetry.go
+97 -123
View File
@@ -27,18 +27,18 @@ type DataPacket struct {
RPM int32
LapCount int32
LapDistPct float32
LapTime string // Current lap time
LapDelta string // Delta to selected reference lap
BestLapTime string // Best lap in session
LastLapTime string // Last lap time
LapTime [16]byte // Current lap time
LapDelta [16]byte // Delta to selected reference lap
BestLapTime [16]byte // Best lap in session
LastLapTime [16]byte // Last lap time
FuelPct float32
FuelLiters float32
FuelTotal float32 // This will be calculated and passed in Liters
Position int32
Standings []StandingsLine
}
var (
data DataPacket
lastMessageTime time.Time
mu sync.Mutex
)
@@ -102,7 +102,7 @@ func (e *ESDI) setupSignalHandlers() chan struct{} {
return done
}
func sendData(s *serial.Port, done <-chan struct{}) {
func sendData(e *ESDI, s *serial.Port, done <-chan struct{}) {
ticker := time.NewTicker(time.Millisecond * 25)
defer ticker.Stop()
@@ -114,7 +114,7 @@ func sendData(s *serial.Port, done <-chan struct{}) {
mu.Lock()
var buf bytes.Buffer
err := binary.Write(&buf, binary.LittleEndian, data)
err := binary.Write(&buf, binary.LittleEndian, e.data)
_, err = s.Write(buf.Bytes())
if err != nil {
@@ -128,7 +128,7 @@ func sendData(s *serial.Port, done <-chan struct{}) {
}
}
func printData(done <-chan struct{}) {
func printData(e *ESDI, done <-chan struct{}) {
ticker := time.NewTicker(time.Millisecond * 100)
defer ticker.Stop()
@@ -141,18 +141,24 @@ func printData(done <-chan struct{}) {
buffer.WriteString("\033[?25l\033[2J\033[H")
mu.Lock()
// message := fmt.Sprintf("%d,%d\n", data.Gear-1, data.RPM)
// message := fmt.Sprintf("%d,%d\n", e.data.Gear-1, e.data.RPM)
buffer.WriteString(fmt.Sprintf("Gear: %d, RPM: %d, Speed: %d\n",
data.Gear, data.RPM, data.Speed))
buffer.WriteString(fmt.Sprintf("Fuel: %.2fL/%.2fL [%.2f%%]\n", data.FuelLiters,
data.FuelTotal, data.FuelPct))
buffer.WriteString(fmt.Sprintf("LapTime: %s [%s]\n", data.LapTime,
data.LapDelta))
buffer.WriteString(fmt.Sprintf("Best Lap Time: %s\n", data.BestLapTime))
buffer.WriteString(fmt.Sprintf("Last Lap Time: %s\n", data.LastLapTime))
buffer.WriteString(fmt.Sprintf("Lap: %d [%.2f%%]\n", data.LapCount,
data.LapDistPct))
buffer.WriteString(fmt.Sprintf("Pos: %d\n", data.Position))
e.data.Gear, e.data.RPM, e.data.Speed))
buffer.WriteString(fmt.Sprintf("Fuel: %.2fL/%.2fL [%.2f%%]\n", e.data.FuelLiters,
e.data.FuelTotal, e.data.FuelPct))
buffer.WriteString(fmt.Sprintf("LapTime: %s [%s]\n", e.data.LapTime,
e.data.LapDelta))
buffer.WriteString(fmt.Sprintf("Best Lap Time: %s\n", e.data.BestLapTime))
buffer.WriteString(fmt.Sprintf("Last Lap Time: %s\n", e.data.LastLapTime))
buffer.WriteString(fmt.Sprintf("Lap: %d [%.2f%%]\n", e.data.LapCount,
e.data.LapDistPct))
buffer.WriteString(fmt.Sprintf("Pos: %d\n", e.data.Position))
for p, v := range e.data.Standings {
s := fmt.Sprintf("[%2d] [%2d]%-30s %3d %10f %s\n",
p+1, v.CarIdx, v.DriverName, v.Lap, v.LapPct, lapTimeRepresentation(v.TimeBehind))
buffer.WriteString(s)
}
mu.Unlock()
// buffer.WriteString("\n" + message)
@@ -161,12 +167,78 @@ func printData(done <-chan struct{}) {
}
}
func (e *ESDI) getVehicleData() {
curGear := e.irsdk.Vars.Vars["Gear"].Value
curRPM := e.irsdk.Vars.Vars["RPM"].Value
curSpeed := e.irsdk.Vars.Vars["Speed"].Value
mu.Lock()
e.data.Gear = int32(curGear.(int))
e.data.RPM = int32(curRPM.(float32))
e.data.Speed = int32(msToKph(curSpeed.(float32)))
mu.Unlock()
}
func (e *ESDI) fuelData() {
fLiters := e.irsdk.Vars.Vars["FuelLevel"].Value
fPct := e.irsdk.Vars.Vars["FuelLevelPct"].Value
mu.Lock()
e.data.FuelPct = float32(fPct.(float32)) * 100
e.data.FuelLiters = float32(fLiters.(float32))
e.data.FuelTotal = (100 * e.data.FuelLiters) / e.data.FuelPct
mu.Unlock()
}
func (e *ESDI) lapData() {
currentLap := e.irsdk.Vars.Vars["Lap"].Value
lapDistPct := e.irsdk.Vars.Vars["LapDistPct"].Value
currentLapTime := e.irsdk.Vars.Vars["LapCurrentLapTime"].Value
lapBestLapTime := e.irsdk.Vars.Vars["LapBestLapTime"].Value
lapLastLapTime := e.irsdk.Vars.Vars["LapLastLapTime"].Value
lapDeltaToBestLap := e.irsdk.Vars.Vars["LapDeltaToBestLap"].Value
mu.Lock()
e.data.LapCount = int32(currentLap.(int))
e.data.LapDistPct = float32(lapDistPct.(float32)) * 100
copy(e.data.LapTime[:], string(lapTimeRepresentation(currentLapTime.(float32))))
copy(e.data.LastLapTime[:], string(lapTimeRepresentation(lapLastLapTime.(float32))))
copy(e.data.BestLapTime[:], string(lapTimeRepresentation(lapBestLapTime.(float32))))
copy(e.data.LapDelta[:], string(lapTimeDeltaRepresentation(lapDeltaToBestLap.(float32))))
mu.Unlock()
}
func (e *ESDI) positionData() {
standings := createStandingsTable(e.irsdk)
relativeStandings(e.irsdk, standings, e.irsdk.SessionInfo.DriverInfo.DriverCarIdx)
p := findEntry(standings, func(l StandingsLine) bool {
return l.CarIdx == e.irsdk.SessionInfo.DriverInfo.DriverCarIdx
})
lowerLim := p - 2
upperLim := p + 3
if lowerLim < 0 {
lowerLim = 0
}
if upperLim >= len(standings) {
upperLim = len(standings)
}
standings = standings[lowerLim:upperLim]
mu.Lock()
e.data.Standings = standings
e.data.Position = int32(p)
mu.Unlock()
}
func (e *ESDI) telemetry() {
// Set the handlers
done := e.setupSignalHandlers()
// go sendData(e.SerialConn, done)
go printData(done)
go printData(e, done)
mainLoopTicker := time.NewTicker(time.Second / 60)
defer mainLoopTicker.Stop()
@@ -182,114 +254,16 @@ func (e *ESDI) telemetry() {
var err error
err = e.Source.UpdateData()
_, err = e.irsdk.Update(time.Millisecond * 100)
if err != nil {
fmt.Printf("could not update data: %v", err)
continue
}
// Vehicle Movement data
curGear, err := e.Source.GetData("Gear")
if err != nil {
log.Fatalf("could not get field `Gear`: %v", err)
}
curRPM, err := e.Source.GetData("RPM")
if err != nil {
log.Fatalf("could not get field `RPM`: %v", err)
}
curSpeed, err := e.Source.GetData("Speed")
if err != nil {
log.Fatalf("could not get field `Speed`: %v", err)
}
gear := int32(curGear.(int))
rpm := int32(curRPM.(float32))
speed := int32(msToKph(curSpeed.(float32)))
// Fuel data
fLiters, err := e.Source.GetData("FuelLevel")
if err != nil {
log.Fatalf("could not get field `FuelLevel`: %v", err)
}
fPct, err := e.Source.GetData("FuelLevelPct")
if err != nil {
log.Fatalf("could not get field `FuelLevelPct`: %v", err)
}
fuelPct := float32(fPct.(float32)) * 100
fuelLiters := float32(fLiters.(float32))
totalFuel := (100 * fuelLiters) / fuelPct
// Lap data
currentLap, err := e.Source.GetData("Lap")
if err != nil {
log.Fatalf("could not get field `Lap`: %v", err)
}
lapDistPct, err := e.Source.GetData("LapDistPct")
if err != nil {
log.Fatalf("could not get field `Lap`: %v", err)
}
currentLapTime, err := e.Source.GetData("LapCurrentLapTime")
if err != nil {
log.Fatalf("could not get field `LapCurrentLapTime`: %v", err)
}
lapBestLapTime, err := e.Source.GetData("LapBestLapTime")
if err != nil {
log.Fatalf("could not get field `LapBestLapTime`: %v", err)
}
lapLastLapTime, err := e.Source.GetData("LapLastLapTime")
if err != nil {
log.Fatalf("could not get field `LapBestLapTime`: %v", err)
}
lapDeltaToBestLap, err := e.Source.GetData("LapDeltaToBestLap")
if err != nil {
log.Fatalf("could not get field `LapDeltaToBestLap`: %v", err)
}
lap := int32(currentLap.(int))
lapPct := float32(lapDistPct.(float32)) * 100
lapTime := string(lapTimeRepresentation(currentLapTime.(float32)))
bestLapTime := string(lapTimeRepresentation(lapBestLapTime.(float32)))
lapDelta := string(lapTimeDeltaRepresentation(lapDeltaToBestLap.(float32)))
lastLapTime := string(lapTimeRepresentation(lapLastLapTime.(float32)))
// Standings
standings := createStandingsTable(i, 9, relativeStandings)
positions := i.Vars.Vars["CarIdxPosition"].Value.([]int32)
p := positions[9]
standings = standings[p - 3: p + 2]
fmt.Printf("\033[?25l\033[2J\033[H")
for p, v := range standings {
fmt.Printf("[%2d] [%2d]%-30s %3d %10f %s\n",
p+1, v.CarIdx, v.DriverName, v.Lap, v.LapPct, lapTimeRepresentation(v.TimeBehind))
}
mu.Lock()
data = DataPacket{
Speed: speed,
Gear: gear,
RPM: rpm,
LapCount: lap,
LapDistPct: lapPct,
LapTime: lapTime,
LastLapTime: lastLapTime,
BestLapTime: bestLapTime,
LapDelta: lapDelta,
FuelLiters: fuelLiters,
FuelPct: fuelPct,
FuelTotal: totalFuel,
}
mu.Unlock()
e.getVehicleData()
e.lapData()
e.fuelData()
e.positionData()
}
}
}
examples.go
+62 -62
View File
@@ -1,69 +1,69 @@
package main
import (
"esdi/sources/beamng"
"fmt"
"log"
"strings"
"time"
// "esdi/sources/beamng"
// "fmt"
// "log"
// "strings"
// "time"
)
func beamngExample(esdi ESDI) {
bIF, err := beamng.Init("127.0.0.1", 4444)
if err != nil {
log.Fatalf("Failed to create BeamNG interface: %v", err)
}
esdi.Source = &bIF
lastTime := time.Now().UnixMilli()
lastDataSent := time.Now().UnixMilli()
for {
var err error
var buffer strings.Builder
buffer.WriteString("\033[?25l\033[2J\033[H")
err = esdi.Source.UpdateData()
if err != nil {
fmt.Printf("could not update data: %v", err)
continue
}
curGear, err := esdi.Source.GetData("Gear")
if err != nil {
log.Fatalf("could not get field `Gear`: %v", err)
}
curRPM, err := esdi.Source.GetData("RPM")
if err != nil {
log.Fatalf("could not get field `RPM`: %v", err)
}
gear := int(curGear.(int8))
rpm := int(curRPM.(float32))
buffer.WriteString(fmt.Sprintf("Gear: %d, RPM: %d", gear, rpm))
curTime := time.Now().UnixMilli()
message := fmt.Sprintf("%d,%d\n", gear-1, rpm)
buffer.WriteString("\n" + message)
messageWasSentMark := "N"
if curTime-lastDataSent > 75 {
_, err = esdi.SerialConn.Write([]byte(message))
if err != nil {
log.Printf("Unable to write data: %v", err)
break
}
messageWasSentMark = "Y"
lastDataSent = curTime
}
buffer.WriteString(" -> " + messageWasSentMark)
if curTime-lastTime > 100 {
fmt.Print(buffer.String())
lastTime = curTime
}
}
// bIF, err := beamng.Init("127.0.0.1", 4444)
// if err != nil {
// log.Fatalf("Failed to create BeamNG interface: %v", err)
// }
//
// esdi.Source = &bIF
//
// lastTime := time.Now().UnixMilli()
// lastDataSent := time.Now().UnixMilli()
// for {
// var err error
// var buffer strings.Builder
// buffer.WriteString("\033[?25l\033[2J\033[H")
//
// err = esdi.Source.UpdateData()
// if err != nil {
// fmt.Printf("could not update data: %v", err)
// continue
// }
//
// curGear, err := esdi.Source.GetData("Gear")
// if err != nil {
// log.Fatalf("could not get field `Gear`: %v", err)
// }
//
// curRPM, err := esdi.Source.GetData("RPM")
// if err != nil {
// log.Fatalf("could not get field `RPM`: %v", err)
// }
//
// gear := int(curGear.(int8))
// rpm := int(curRPM.(float32))
//
// buffer.WriteString(fmt.Sprintf("Gear: %d, RPM: %d", gear, rpm))
//
// curTime := time.Now().UnixMilli()
// message := fmt.Sprintf("%d,%d\n", gear-1, rpm)
// buffer.WriteString("\n" + message)
//
// messageWasSentMark := "N"
// if curTime-lastDataSent > 75 {
// _, err = esdi.SerialConn.Write([]byte(message))
// if err != nil {
// log.Printf("Unable to write data: %v", err)
// break
// }
//
// messageWasSentMark = "Y"
// lastDataSent = curTime
// }
//
// buffer.WriteString(" -> " + messageWasSentMark)
// if curTime-lastTime > 100 {
// fmt.Print(buffer.String())
// lastTime = curTime
// }
// }
}
iracingStandings.go
+30 -19
View File
@@ -1,9 +1,9 @@
package main
import (
"fmt"
"sort"
"testing"
"github.com/ESilva15/goirsdk"
)
type StandingsLine struct {
@@ -17,7 +17,18 @@ type StandingsLine struct {
type standingsFilter func([]StandingsLine, []float32, int)
func generalStandings(s []StandingsLine, estTime []float32, id int) {
func generalStandings(i *goirsdk.IBT, s []StandingsLine, id int) {
// We have to sort the racists by their lap count and position on the track
// on the current lap
sort.Slice(s, func(i int, j int) bool {
if s[i].Lap == int32(s[j].Lap) {
return s[i].LapPct > s[j].LapPct
}
return s[i].Lap > s[j].Lap
})
estTime := i.Vars.Vars["CarIdxEstTime"].Value.([]float32)
// This will give the delta to the guy ahead
// P1 0:00:000
// P2 0:01:000 -> 1s from P1
@@ -33,7 +44,16 @@ func generalStandings(s []StandingsLine, estTime []float32, id int) {
}
}
func relativeStandings(s []StandingsLine, estTime []float32, id int) {
func relativeStandings(i *goirsdk.IBT, s []StandingsLine, id int) {
// We sort the racists solely by their position on the track because all
// we want to know is where people are in relation to us
// But we should add a way to diferentatiate lap counts
sort.Slice(s, func(i int, j int) bool {
return s[i].LapPct > s[j].LapPct
})
estTime := i.Vars.Vars["CarIdxEstTime"].Value.([]float32)
// Get the delta to a given carId
for p := range s {
curCarEstimate := estTime[s[p].CarIdx]
@@ -45,8 +65,9 @@ func relativeStandings(s []StandingsLine, estTime []float32, id int) {
}
}
func bestLapTime(i GameSource, id int) float32 {
func bestLapTime(i *goirsdk.IBT, id int) float32 {
best := i.Vars.Vars["LapBestLapTime"].Value.(float32)
if best > 0 {
return best
}
@@ -59,7 +80,7 @@ func bestLapTime(i GameSource, id int) float32 {
// If the filter applied is generalStandings, the carId has to be 0
// We can do some dynamicProgramming on this thing I guess, I still haven't
// though about it much yet tbh
func createStandingsTable(i GameSource, carId int, filter standingsFilter) []StandingsLine {
func createStandingsTable(i *goirsdk.IBT) []StandingsLine {
driversLapDistPct := i.Vars.Vars["CarIdxLapDistPct"].Value.([]float32)
driversEstTime := i.Vars.Vars["CarIdxEstTime"].Value.([]float32)
driversLap := i.Vars.Vars["CarIdxLap"].Value.([]int32)
@@ -86,16 +107,6 @@ func createStandingsTable(i GameSource, carId int, filter standingsFilter) []Sta
}
}
// This will sort our standings by lap and LapPct
sort.Slice(standings, func(i int, j int) bool {
if standings[i].Lap == int32(standings[j].Lap) {
return standings[i].LapPct > standings[j].LapPct
}
return standings[i].Lap > standings[j].Lap
})
filter(standings, driversEstTime, carId)
return standings
}
@@ -106,7 +117,7 @@ func abs(v float32) float32 {
return v
}
func TestStandingsFunctionality(t *testing.T) {
for {
}
func getPlayerPosition(s []StandingsLine, p int) {
}
supporting.go
+11
View File
@@ -0,0 +1,11 @@
package main
func findEntry[T any](s []T, predicate func(T) bool) int {
for i, elem := range s {
if predicate(elem) {
return i
}
}
return -1
}