Robert Gray

Codemasters F1 201x (lastest incarnation is F1 2012) does not come with utilities that allow you analyse your telemetry.  This is disappointing to a many long time F1 game players.  Even Geoff Crammands’ Grand Prix series came with the ability to analyse many different data points, including: wheelspin at each of the four corners of the car, speed, brake input, throttle input, gear, time, ground clearance, and more.   I think Codemasters response when asked why this was not included was because it was a more advanced feature and wouldn’t be popular with the majority of the gamers (the game is available on PC, Xbox, and PS3).

Fortunately for those who are interested in really “Living the life”, Codemasters has exposed a telemetry data point via UDP.  By creating a UDP ‘server’ (though it’s only a UDP endpoint) the game can connect to, we can receive the telemetry published by F1 2012.  I recently spent a bit of time analysing this stream to help with building my realtime telemetry app for the F1 2012 game ( see here )

Before receiving the data we need to reconfigure F1 2012 to point to our end point.  This is done by modifying the “hardware_settings_config.xml” file found in your My Documents folder subpath ./My Games/FormulaOne2012/hardwaresettings/. Open the file and change the line

to be

You can set ip and port to the correct values for wherever your UDP end point will be listening for a connection.

The packet F1 2011 puts out through this contains the following fields in order.  All fields are float datatype (in C#)

Detecting new laps

From what I can tell, the following can be used to determine which lap the driver is on.

The Source

To read the data from UDP point in C# you can use the following

// This method runs continously in the data collection thread.  It
// waits to receive UDP packets from the game, converts them and writes
// them to the shared struct variable.
private void FetchData()
{
    while (true)
    {
        // Get the data (this will block until we get a packet)
        Byte[] receiveBytes = udpSocket.Receive(ref senderIP);

        // Lock access to the shared struct
        syncMutex.WaitOne();

        // Convert the bytes received to the shared struct
        latestData = PacketUtilities.ConvertToPacket(receiveBytes);
        manager.AddPacket(latestData);
        
        // Release the lock again
        syncMutex.ReleaseMutex();
    }
}

public static class PacketUtilities
{
    // Helper method to convert the bytes received from the UDP packet into the
    // struct variable format.
    public static TelemetryPacket ConvertToPacket(byte[] bytes)
    {
        // Marshal the byte array into the telemetryPacket structure
        GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
        var stuff = (TelemetryPacket)Marshal.PtrToStructure(
            handle.AddrOfPinnedObject(), typeof(TelemetryPacket));
        handle.Free();
        return stuff;
    }
}

My TelemetryPacket class is the following. For my particular application (F1Speed) I only need to store certain fields.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Xml.Serialization;

namespace F1Speed.Core
{
    [Serializable]
    public struct TelemetryPacket : ISerializable
    {
        public TelemetryPacket(SerializationInfo info, StreamingContext context)
        {
            Time = info.GetValue<float>("Time");
            LapTime = info.GetValue<float>("LapTime");
            LapDistance = info.GetValue<float>("LapDistance");
            Distance = info.GetValue<float>("Distance");
            Speed = info.GetValue<float>("Speed");
            Lap = info.GetValue<float>("Lap");
            X = 0;
            Y = 0;
            Z = 0;
            XV = 0;
            YV = 0;
            ZV = 0;
            XR = 0;
            YR = 0;
            ZR = 0;
            XD = 0;
            YD = 0;
            ZD = 0;
            SuspensionPositionRearLeft = 0;
            SuspensionPositionRearRight = 0;
            SuspensionPositionFrontLeft = 0;
            SuspensionPositionFrontRight = 0;
            SuspensionVelocitoyRearLeft = 0;
            SuspensionVelocitoyRearRight = 0;
            SuspensionVelocitoyFrontLeft = 0;
            SuspensionVelocitoyFrontRight = 0;
            WheelSpeedBackLeft = 0;
            WheelSpeedBackRight = 0;
            WheelSpeedFrontLeft = 0;
            WheelSpeedFrontRight = 0;
            Throttle = 0;
            Steer = 0;
            Brake = 0;
            Clutch = 0;
            Gear = 0;
            GForceLatitudinal = 0;
            GForceLongitudinal = 0;
            EngineRevs = 0;

        }

        public float Time;
        public float LapTime;
        public float LapDistance;
        public float Distance;
        [XmlIgnore]
        public float X;
        [XmlIgnore]
        public float Y;
        [XmlIgnore]
        public float Z;        
        public float Speed;
        [XmlIgnore]
        public float XV;
        [XmlIgnore]
        public float YV;
        [XmlIgnore]
        public float ZV;
        [XmlIgnore]
        public float XR;
        [XmlIgnore]
        public float YR;
        [XmlIgnore]
        public float ZR;
        [XmlIgnore]
        public float XD;
        [XmlIgnore]
        public float YD;
        [XmlIgnore]
        public float ZD;
        [XmlIgnore]
        public float SuspensionPositionRearLeft;
        [XmlIgnore]
        public float SuspensionPositionRearRight;
        [XmlIgnore]
        public float SuspensionPositionFrontLeft;
        [XmlIgnore]
        public float SuspensionPositionFrontRight;
        [XmlIgnore]
        public float SuspensionVelocitoyRearLeft;
        [XmlIgnore]
        public float SuspensionVelocitoyRearRight;
        [XmlIgnore]
        public float SuspensionVelocitoyFrontLeft;
        [XmlIgnore]
        public float SuspensionVelocitoyFrontRight;
        [XmlIgnore]
        public float WheelSpeedBackLeft;
        [XmlIgnore]
        public float WheelSpeedBackRight;
        [XmlIgnore]        
        public float WheelSpeedFrontLeft;
        [XmlIgnore]
        public float WheelSpeedFrontRight;
        [XmlIgnore]
        public float Throttle;
        [XmlIgnore]
        public float Steer;
        [XmlIgnore]
        public float Brake;
        [XmlIgnore]
        public float Clutch;
        [XmlIgnore]
        public float Gear;
        [XmlIgnore]
        public float GForceLatitudinal;
        [XmlIgnore]
        public float GForceLongitudinal;        
        public float Lap;
        [XmlIgnore]
        public float EngineRevs;
        [XmlIgnore]
        public float SpeedInKmPerHour
        {
            get { return Speed*3.60f;  }
        }

        public override string ToString()
        {
            return "Lap: " + Lap + ", " +
                   "Time: " + Time + ", " +
                   "LapTime: " + LapTime + ", " +
                   "LapDistance: " + LapDistance + ", " +
                   "Distance: " + Distance + ", " +                   
                   "Speed: " + Speed;
        }        

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("Time", Time);
            info.AddValue("LapTime", LapTime);
            info.AddValue("LapDistance", LapDistance);
            info.AddValue("Distance", Distance);
            info.AddValue("Speed", Speed);
            info.AddValue("Lap", Lap);       
         }        
    }
}

The current project source for F1Speed is available on bitbucket https://bitbucket.org/robgray/f1speed/ If you want the latest source, always consult bitbucket.