267 lines
6.4 KiB
Go
267 lines
6.4 KiB
Go
package esdi
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"io"
|
|
"log"
|
|
|
|
// "encoding/binary"
|
|
"fmt"
|
|
// "log"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
// "github.com/tarm/serial"
|
|
)
|
|
|
|
var (
|
|
initialTime = time.Now()
|
|
lastTime = time.Now()
|
|
paddingStandingsLine = StandingsLine{
|
|
DriverName: createDriverName("---"),
|
|
Lap: 0,
|
|
CarIdx: 0,
|
|
LapPct: 0,
|
|
EstTime: 0,
|
|
TimeBehind: 0,
|
|
}
|
|
iniFuelLvl float32
|
|
fuelLevels map[int]float32
|
|
lastMessageTime time.Time
|
|
mu sync.Mutex
|
|
)
|
|
|
|
const (
|
|
LapTimeFormatStr = "04:05.000"
|
|
RelativeDeltaFormatStr = "04:05.0"
|
|
)
|
|
|
|
func msToKph(v float32) int {
|
|
return int((3600 * v) / 1000)
|
|
}
|
|
|
|
func lapTimeRepresentation(t float32, f string) string {
|
|
if t < 0 {
|
|
t = 0
|
|
}
|
|
|
|
wholeSeconds := int64(t)
|
|
lapTime := time.Unix(wholeSeconds, int64((t-float32(wholeSeconds))*1e9))
|
|
|
|
return lapTime.Format(f)
|
|
}
|
|
|
|
func lapTimeDeltaRepresentation(t float32) string {
|
|
sign := '-'
|
|
if t < 0 {
|
|
sign = '+'
|
|
t = -t
|
|
}
|
|
|
|
// Cap to 99.9 max
|
|
if t > 99.9 {
|
|
t = 99.9
|
|
}
|
|
|
|
if t >= 1 {
|
|
// Round to nearest tenth
|
|
rounded := float32(int(t*10+0.5)) / 10
|
|
return fmt.Sprintf("%c%.1f", sign, rounded)
|
|
}
|
|
|
|
// t < 1: round to nearest tenth and remove leading zero (e.g., "0.1" → ".1")
|
|
rounded := float32(int(t*10+0.5)) / 10
|
|
s := fmt.Sprintf("%.1f", rounded)
|
|
if strings.HasPrefix(s, "0") {
|
|
s = s[1:]
|
|
}
|
|
return fmt.Sprintf("%c%s", sign, s)
|
|
}
|
|
|
|
func resetTerminal() {
|
|
// Show cursor and clear screen
|
|
fmt.Print("\033[?25h\033[2J\033[H")
|
|
}
|
|
|
|
func (e *ESDI) setupSignalHandlers() chan string {
|
|
sigc := make(chan os.Signal, 1)
|
|
signal.Notify(sigc,
|
|
syscall.SIGHUP,
|
|
syscall.SIGINT,
|
|
syscall.SIGTERM,
|
|
syscall.SIGQUIT,
|
|
)
|
|
done := make(chan string)
|
|
|
|
go func() {
|
|
s := <-sigc
|
|
switch s {
|
|
case syscall.SIGTERM, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGHUP:
|
|
resetTerminal()
|
|
fmt.Print("Closing ESDI")
|
|
}
|
|
close(done)
|
|
e.Close()
|
|
}()
|
|
|
|
return done
|
|
}
|
|
|
|
func printData(e *ESDI, done <-chan string) {
|
|
ticker := time.NewTicker(time.Millisecond * 25)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case <-done:
|
|
return
|
|
case <-ticker.C:
|
|
var buffer strings.Builder
|
|
buffer.WriteString("\033[?25l\033[2J\033[H")
|
|
|
|
mu.Lock()
|
|
sessionTimeR := e.irsdk.Vars.Vars["SessionTime"].Value
|
|
sessionTime := float64(sessionTimeR.(float64))
|
|
|
|
currTime := time.Now()
|
|
delta := currTime.Sub(lastTime)
|
|
buffer.WriteString(fmt.Sprintf("[%s]\n", currTime.Format("2006/01/02 15:04:05.000")))
|
|
buffer.WriteString(fmt.Sprintf("Delta: %d [%f]\n\n", delta.Milliseconds(), 1000.0/60.0))
|
|
lastTime = currTime
|
|
|
|
elapsed := currTime.Sub(initialTime)
|
|
softwareElapsed := time.Unix(0, 0).Add(elapsed).Format("04:05.000")
|
|
sessionElapsed := time.Unix(0, 0).
|
|
Add(time.Duration(sessionTime * float64(time.Second))).
|
|
Format("04:05.000")
|
|
|
|
buffer.WriteString(fmt.Sprintf("Elapsed (software): %s\n",
|
|
softwareElapsed))
|
|
buffer.WriteString(fmt.Sprintf("Elapsed (session): %s\n\n",
|
|
sessionElapsed))
|
|
|
|
// buffer.WriteString("Car data:\n")
|
|
buffer.WriteString(fmt.Sprintf("Gear: %d, RPM: %d, Speed: %d\n\n",
|
|
e.dataPacket.Gear, e.dataPacket.RPM, e.dataPacket.Speed))
|
|
buffer.WriteString(fmt.Sprintf("BB: %s\n\n", e.dataPacket.BrakeBias))
|
|
|
|
buffer.WriteString("Fuel data:\n")
|
|
buffer.WriteString(fmt.Sprintf("Fuel Est: %s\n\n", e.dataPacket.FuelEst))
|
|
|
|
buffer.WriteString("Lap data:\n")
|
|
buffer.WriteString(fmt.Sprintf("Delta: [%s] [%f] [%s]\n", e.dataPacket.DeltaToBestLap,
|
|
e.data.LapDeltaFloat, lapTimeDeltaRepresentation(e.data.LapDeltaFloat)))
|
|
buffer.WriteString(fmt.Sprintf("LapTime: %s\n", e.dataPacket.CurrLapTime))
|
|
buffer.WriteString(fmt.Sprintf("Best Lap Time: %s\n", e.dataPacket.BestLapTime))
|
|
buffer.WriteString(fmt.Sprintf("Last Lap Time: %s\n", e.dataPacket.LastLapTime))
|
|
// buffer.WriteString(fmt.Sprintf("LapBestNLapTi: %f\n\n", e.data.LapBestNLapTime))
|
|
|
|
// buffer.WriteString("Position data:\n")
|
|
// buffer.WriteString(fmt.Sprintf("Pos: %d\n", e.dataPacket.Position))
|
|
|
|
for p, v := range e.dataPacket.Standings {
|
|
s := fmt.Sprintf("[%2d] %s %-16s %-16s\n",
|
|
p+1, v.Lap, string(bytes.Trim(v.DriverName[:], "\x00")), v.TimeBehindString)
|
|
buffer.WriteString(s)
|
|
}
|
|
|
|
buffer.WriteString(fmt.Sprintf("Size: %v\n", binary.Size(DataPacket{})))
|
|
buffer.WriteString(fmt.Sprintf("Recv: %d\n", e.data.Recv))
|
|
buffer.WriteString(fmt.Sprintf("Recv Err: %v\n", e.data.ReadError))
|
|
|
|
mu.Unlock()
|
|
|
|
// buffer.WriteString("\n" + message)
|
|
fmt.Print(buffer.String())
|
|
}
|
|
}
|
|
}
|
|
|
|
type DataReq struct {
|
|
Req int8
|
|
}
|
|
|
|
func (e *ESDI) telemetry() {
|
|
// Set the handlers
|
|
done := e.setupSignalHandlers()
|
|
dataError := make(chan string)
|
|
|
|
// Display the data on the terminal periodically
|
|
go printData(e, done)
|
|
|
|
// Maybe create a struct made to calculate the fuel levels
|
|
// -> struct FuelLvlCalculator
|
|
fuelLevels = make(map[int]float32, 256)
|
|
|
|
// We need to add another goroutine here that continuously updates
|
|
// the data
|
|
go readData(e, done)
|
|
|
|
// Add another goroutine that is actually waiting for data requests
|
|
// And gives the signal or sends the data
|
|
// go waitForReq(e, done)
|
|
|
|
// TODO:
|
|
// Add start and end markers to the data frames
|
|
|
|
// This loop will wait for the display to request the data
|
|
total := time.Microsecond * 0
|
|
previousRequest := time.Now()
|
|
nRequests := 0
|
|
for {
|
|
isRunning := true
|
|
select {
|
|
case s := <-done:
|
|
resetTerminal()
|
|
fmt.Println(s)
|
|
isRunning = false
|
|
break
|
|
case s := <-dataError:
|
|
done <- s
|
|
default:
|
|
// Wait for the display to request some data
|
|
var r DataReq
|
|
err := binary.Read(e.SerialConn, binary.LittleEndian, &r)
|
|
e.data.ReadError = err
|
|
if err != nil && err != io.EOF {
|
|
log.Println(err)
|
|
fmt.Println("->", r)
|
|
}
|
|
e.data.Recv = r.Req
|
|
|
|
if r.Req == 5 {
|
|
e.SerialConn.Flush()
|
|
currTime := time.Now()
|
|
if nRequests != 0 {
|
|
total += currTime.Sub(previousRequest)
|
|
}
|
|
previousRequest = currTime
|
|
nRequests += 1
|
|
|
|
var buf bytes.Buffer
|
|
err = binary.Write(&buf, binary.LittleEndian, e.dataPacket)
|
|
|
|
_, err = e.SerialConn.Write(buf.Bytes())
|
|
if err != nil {
|
|
log.Printf("Unable to write data: %v", err)
|
|
break
|
|
}
|
|
e.SerialConn.Flush()
|
|
}
|
|
}
|
|
|
|
if !isRunning {
|
|
break
|
|
}
|
|
}
|
|
|
|
log.Println("Statistics:")
|
|
log.Printf(" Reqs: %d\n", nRequests)
|
|
log.Printf(" Total time: %d (ms)\n", total.Milliseconds())
|
|
log.Printf(" Average req time: %d (ms / request)\n", total.Milliseconds()/int64(nRequests))
|
|
}
|