Eduardo Silva

goirsdk - GitHub Repo

SDK in Go for the popular racing simulator iRacing's telemetry "API" (It's just a SHM file).
It has the following capabilites:

Read live data (live session or replay)
Read data from a .ibt file
Export data to a .ibt file which, unlike the native telemetry export function, gives the ability of looking at live data only variables during an offline analysis

It should run on Linux, MacOS and Windows. With the caveat that live sessions only happen on Windows (that I know about), therefore Linux and MacOS can only read data from telemetry files.

Roadmap

[X] Read live telemetry (from a live session or replay)
[X] Read data from a stored .ibt file
[X] Allow to export the data to an .ibt file
[X] Allow to export the session info data to a .yaml file
[ ] Make sure variables with multiple counts are correctly parsed and stored
[ ] Correctly support and implement the bitFields data
[ ] Add the message broadcasting system
[ ] Explore a more convenient API for fetching the data for the SDK user
[ ] Change the pattern in which the data is fetched from the telemetry and how it is exported into .ibt files

Usage

The SDK instance is created by calling goirsdk.Init(Reader, exportTelem, exportYAML).

Reader is a variable that implements the interface:
type Reader interface { io.Reader io.ReaderAt io.ReadCloser }

To read data from a .ibt file, the user should pass the *os.File of it, and to read live telemetry the user should pass nil

exportTelem should be an empty string if the user doesn't want to export the data, otherwise pass a string with the path for the destination telemetry file
exportYAML is just like the exportTelem but for the session info yaml data

Example


package main

import (
	"fmt"
	"log"
	"os"
	"time"

	"github.com/ESilva15/goirsdk"
)

func msToKph(v float32) int {
	return int((3600 * v) / 1000)
}

func main() {
	// Open the data source file
	file, err := os.Open("/path/to/ibtFile")
	if err != nil {
		log.Fatalf("Failed to open IBT file: %v", err)
	}

	// Instantiate our iRacing SDK instance
	irsdk, err := goirsdk.Init(file, "", "")
	if err != nil {
		log.Fatalf("Failed to create iRacing interface: %v", err)
	}
	defer irsdk.Close()

	// Set up a loop to iterate our data
	mainLoopTicker := time.NewTicker(time.Second / 60)
	defer mainLoopTicker.Stop()

	for {
		// Update the data that the SDK is holding with the next tick
		_, err := irsdk.Update(100 * time.Millisecond)
		if err != nil {
			log.Printf("could not update data: %v", err)
			continue
		}

		// Vehicle Movement data gathered from the names we can find on the
		// telemetry_docs.pdf file
		// - I wish to make this less verbose if possible
		if _, ok := irsdk.Vars.Vars["Gear"]; !ok {
			log.Fatal("Field `Gear` doesn't exist")
		}

		if _, ok := irsdk.Vars.Vars["RPM"]; !ok {
			log.Fatal("Field `RPM` doesn't exist")
		}

		if _, ok := irsdk.Vars.Vars["Speed"]; !ok {
			log.Fatal("Field `Speed` doesn't exist")
		}

		gear := int32(irsdk.Vars.Vars["Gear"].Value.(int))
		rpm := int32(irsdk.Vars.Vars["RPM"].Value.(float32))
		speed := int32(msToKph(irsdk.Vars.Vars["Speed"].Value.(float32)))

		fmt.Printf("\033[?25l\033[2J\033[H")
		fmt.Printf("Gear: %d, RPM: %d, Speed: %d", gear, rpm, speed)

		<-mainLoopTicker.C
	}
}

SharedMem

I vendored in the code from hidez8891/shm since the repo has been archived. Also took the opportunity to update some of its code.