Jump to content
  • 2

F1 2019 UDP Specification

Question

The F1 series of games support the output of certain game data across UDP connections. This data can be used supply race information to external applications, or to drive certain hardware (e.g. motion platforms, force feedback steering wheels and LED devices).

The following information summarise this data structures so that developers of supporting hardware or software are able to configure these to work correctly with the F1 game.

If you cannot find the information that you require then please contact community@codemasters.com and a member of the dev team will respond to your query as soon as possible.

Packet Information

Packet Types

Each packet can now carry different types of data rather than having one packet which contains everything. A header has been added to each packet as well so that versioning can be tracked and it will be easier for applications to check they are interpreting the incoming data in the correct way. Please note that all values are encoded using Little Endian format. All data is packed.

The following data types are used in the structures:

Type

Description

uint8

Unsigned 8-bit integer

int8

Signed 8-bit integer

uint16

Unsigned 16-bit integer

int16

Signed 16-bit integer

float

Floating point (32-bit)

uint64

Unsigned 64-bit integer

Packet Header

Each packet has the following header:

struct PacketHeader
{
    uint16    m_packetFormat;         // 2019
    uint8     m_gameMajorVersion;     // Game major version - "X.00"
    uint8     m_gameMinorVersion;     // Game minor version - "1.XX"
    uint8     m_packetVersion;        // Version of this packet type, all start from 1
    uint8     m_packetId;             // Identifier for the packet type, see below
    uint64    m_sessionUID;           // Unique identifier for the session
    float     m_sessionTime;          // Session timestamp
    uint      m_frameIdentifier;      // Identifier for the frame the data was retrieved on
    uint8     m_playerCarIndex;       // Index of player's car in the array
};

Packet IDs

The packets IDs are as follows:

Packet Name

Value

Description

Motion

0

Contains all motion data for player’s car – only sent while player is in control

Session

1

Data about the session – track, time left

Lap Data

2

Data about all the lap times of cars in the session

Event

3

Various notable events that happen during a session

Participants

4

List of participants in the session, mostly relevant for multiplayer

Car Setups

5

Packet detailing car setups for cars in the race

Car Telemetry

6

Telemetry data for all cars

Car Status

7

Status data for all cars such as damage

Motion Packet

The motion packet gives physics data for all the cars being driven. There is additional data for the car being driven with the goal of being able to drive a motion platform setup.

N.B. For the normalised vectors below, to convert to float values divide by 32767.0f – 16-bit signed values are used to pack the data and on the assumption that direction values are always between -1.0f and 1.0f.

 

Frequency: Rate as specified in menus

Size: 1343 bytes

Version: 1

struct CarMotionData
{
    float         m_worldPositionX;           // World space X position
    float         m_worldPositionY;           // World space Y position
    float         m_worldPositionZ;           // World space Z position
    float         m_worldVelocityX;           // Velocity in world space X
    float         m_worldVelocityY;           // Velocity in world space Y
    float         m_worldVelocityZ;           // Velocity in world space Z
    int16         m_worldForwardDirX;         // World space forward X direction (normalised)
    int16         m_worldForwardDirY;         // World space forward Y direction (normalised)
    int16         m_worldForwardDirZ;         // World space forward Z direction (normalised)
    int16         m_worldRightDirX;           // World space right X direction (normalised)
    int16         m_worldRightDirY;           // World space right Y direction (normalised)
    int16         m_worldRightDirZ;           // World space right Z direction (normalised)
    float         m_gForceLateral;            // Lateral G-Force component
    float         m_gForceLongitudinal;       // Longitudinal G-Force component
    float         m_gForceVertical;           // Vertical G-Force component
    float         m_yaw;                      // Yaw angle in radians
    float         m_pitch;                    // Pitch angle in radians
    float         m_roll;                     // Roll angle in radians
};

struct PacketMotionData
{
    PacketHeader    m_header;               	// Header

    CarMotionData   m_carMotionData[20];    	// Data for all cars on track

    // Extra player car ONLY data
    float         m_suspensionPosition[4];       // Note: All wheel arrays have the following order:
    float         m_suspensionVelocity[4];       // RL, RR, FL, FR
    float         m_suspensionAcceleration[4];	// RL, RR, FL, FR
    float         m_wheelSpeed[4];           	// Speed of each wheel
    float         m_wheelSlip[4];                // Slip ratio for each wheel
    float         m_localVelocityX;         	// Velocity in local space
    float         m_localVelocityY;         	// Velocity in local space
    float         m_localVelocityZ;         	// Velocity in local space
    float         m_angularVelocityX;		// Angular velocity x-component
    float         m_angularVelocityY;            // Angular velocity y-component
    float         m_angularVelocityZ;            // Angular velocity z-component
    float         m_angularAccelerationX;        // Angular velocity x-component
    float         m_angularAccelerationY;	// Angular velocity y-component
    float         m_angularAccelerationZ;        // Angular velocity z-component
    float         m_frontWheelsAngle;            // Current front wheels angle in radians
};

Session Packet

The session packet includes details about the current session in progress.

 

Frequency: 2 per second

Size: 149 bytes

Version: 1

struct MarshalZone
{
    float  m_zoneStart;   // Fraction (0..1) of way through the lap the marshal zone starts
    int8   m_zoneFlag;    // -1 = invalid/unknown, 0 = none, 1 = green, 2 = blue, 3 = yellow, 4 = red
};

struct PacketSessionData
{
    PacketHeader    m_header;               	// Header

    uint8           m_weather;              	// Weather - 0 = clear, 1 = light cloud, 2 = overcast
                                            	// 3 = light rain, 4 = heavy rain, 5 = storm
    int8	            m_trackTemperature;    	// Track temp. in degrees celsius
    int8	            m_airTemperature;      	// Air temp. in degrees celsius
    uint8           m_totalLaps;           	// Total number of laps in this race
    uint16          m_trackLength;           	// Track length in metres
    uint8           m_sessionType;         	// 0 = unknown, 1 = P1, 2 = P2, 3 = P3, 4 = Short P
                                            	// 5 = Q1, 6 = Q2, 7 = Q3, 8 = Short Q, 9 = OSQ
                                            	// 10 = R, 11 = R2, 12 = Time Trial
    int8            m_trackId;         		// -1 for unknown, 0-21 for tracks, see appendix
    uint8           m_formula;                  	// Formula, 0 = F1 Modern, 1 = F1 Classic, 2 = F2,
// 3 = F1 Generic
    uint16          m_sessionTimeLeft;    	// Time left in session in seconds
    uint16          m_sessionDuration;     	// Session duration in seconds
    uint8           m_pitSpeedLimit;      	// Pit speed limit in kilometres per hour
    uint8           m_gamePaused;                // Whether the game is paused
    uint8           m_isSpectating;        	// Whether the player is spectating
    uint8           m_spectatorCarIndex;  	// Index of the car being spectated
    uint8           m_sliProNativeSupport;	// SLI Pro support, 0 = inactive, 1 = active
    uint8           m_numMarshalZones;         	// Number of marshal zones to follow
    MarshalZone     m_marshalZones[21];         	// List of marshal zones – max 21
    uint8           m_safetyCarStatus;           // 0 = no safety car, 1 = full safety car
                                                 // 2 = virtual safety car
    uint8           m_networkGame;               // 0 = offline, 1 = online
};

Lap Data Packet

The lap data packet gives details of all the cars in the session.

 

Frequency: Rate as specified in menus

Size: 843 bytes

Version: 1

struct LapData
{
    float       m_lastLapTime;	       	// Last lap time in seconds
    float       m_currentLapTime;	// Current time around the lap in seconds
    float       m_bestLapTime;		// Best lap time of the session in seconds
    float       m_sector1Time;		// Sector 1 time in seconds
    float       m_sector2Time;		// Sector 2 time in seconds
    float       m_lapDistance;		// Distance vehicle is around current lap in metres – could
					// be negative if line hasn’t been crossed yet
    float       m_totalDistance;		// Total distance travelled in session in metres – could
					// be negative if line hasn’t been crossed yet
    float       m_safetyCarDelta;        // Delta in seconds for safety car
    uint8       m_carPosition;   	// Car race position
    uint8       m_currentLapNum;		// Current lap number
    uint8       m_pitStatus;            	// 0 = none, 1 = pitting, 2 = in pit area
    uint8       m_sector;               	// 0 = sector1, 1 = sector2, 2 = sector3
    uint8       m_currentLapInvalid;    	// Current lap invalid - 0 = valid, 1 = invalid
    uint8       m_penalties;            	// Accumulated time penalties in seconds to be added
    uint8       m_gridPosition;         	// Grid position the vehicle started the race in
    uint8       m_driverStatus;         	// Status of driver - 0 = in garage, 1 = flying lap
// 2 = in lap, 3 = out lap, 4 = on track
    uint8       m_resultStatus;          // Result status - 0 = invalid, 1 = inactive, 2 = active
// 3 = finished, 4 = disqualified, 5 = not classified
// 6 = retired
};


struct PacketLapData
{
    PacketHeader    m_header;              // Header

    LapData         m_lapData[20];         // Lap data for all cars on track
};

Event Packet

This packet gives details of events that happen during the course of a session.

 

Frequency: When the event occurs

Size: 32 bytes

Version: 1

// The event details packet is different for each type of event.
// Make sure only the correct type is interpreted.
union EventDataDetails
{
    struct
    {
        uint8	vehicleIdx; // Vehicle index of car achieving fastest lap
        float	lapTime;    // Lap time is in seconds
    } FastestLap;

    struct
    {
        uint8   vehicleIdx; // Vehicle index of car retiring
    } Retirement;

    struct
    {
        uint8   vehicleIdx; // Vehicle index of team mate
    } TeamMateInPits;

    struct
    {
        uint8   vehicleIdx; // Vehicle index of the race winner
    } RaceWinner;
};

struct PacketEventData
{
    PacketHeader    	m_header;               // Header
    
uint8           	m_eventStringCode[4];   // Event string code, see below
EventDataDetails	m_eventDetails;         // Event details - should be interpreted differently
// for each type
};

Event String Codes

Event

Code

Description

Session Started

“SSTA”

Sent when the session starts

Session Ended

“SEND”

Sent when the session ends

Fastest Lap

“FTLP”

When a driver achieves the fastest lap

Retirement

“RTMT”

When a driver retires

DRS enabled

“DRSE”

Race control have enabled DRS

DRS disabled

“DRSD”

Race control have disabled DRS

Team mate in pits

“TMPT”

Your team mate has entered the pits

Chequered flag

“CHQF”

The chequered flag has been waved

Race Winner

“RCWN”

The race winner is announced

Participants Packet

This is a list of participants in the race. If the vehicle is controlled by AI, then the name will be the driver name. If this is a multiplayer game, the names will be the Steam Id on PC, or the LAN name if appropriate.

N.B. on Xbox One, the names will always be the driver name, on PS4 the name will be the LAN name if playing a LAN game, otherwise it will be the driver name.

The array should be indexed by vehicle index.

 

Frequency: Every 5 seconds

Size: 1104 bytes

Version: 1

struct ParticipantData
{
    uint8      m_aiControlled;           // Whether the vehicle is AI (1) or Human (0) controlled
    uint8      m_driverId;		// Driver id - see appendix
    uint8      m_teamId;                 // Team id - see appendix
    uint8      m_raceNumber;             // Race number of the car
    uint8      m_nationality;            // Nationality of the driver
    char       m_name[48];               // Name of participant in UTF-8 format – null terminated
					// Will be truncated with … (U+2026) if too long
    uint8      m_yourTelemetry;          // The player's UDP setting, 0 = restricted, 1 = public
};

struct PacketParticipantsData
{
    PacketHeader    m_header;            // Header

    uint8           m_numActiveCars;	// Number of active cars in the data – should match number of
// cars on HUD
    ParticipantData m_participants[20];
};

Car Setups Packet

This packet details the car setups for each vehicle in the session. Note that in multiplayer games, other player cars will appear as blank, you will only be able to see your car setup and AI cars.

 

Frequency: 2 per second

Size: 843 bytes

Version: 1

struct CarSetupData
{
    uint8     m_frontWing;                // Front wing aero
    uint8     m_rearWing;                 // Rear wing aero
    uint8     m_onThrottle;               // Differential adjustment on throttle (percentage)
    uint8     m_offThrottle;              // Differential adjustment off throttle (percentage)
    float     m_frontCamber;              // Front camber angle (suspension geometry)
    float     m_rearCamber;               // Rear camber angle (suspension geometry)
    float     m_frontToe;                 // Front toe angle (suspension geometry)
    float     m_rearToe;                  // Rear toe angle (suspension geometry)
    uint8     m_frontSuspension;          // Front suspension
    uint8     m_rearSuspension;           // Rear suspension
    uint8     m_frontAntiRollBar;         // Front anti-roll bar
    uint8     m_rearAntiRollBar;          // Front anti-roll bar
    uint8     m_frontSuspensionHeight;    // Front ride height
    uint8     m_rearSuspensionHeight;     // Rear ride height
    uint8     m_brakePressure;            // Brake pressure (percentage)
    uint8     m_brakeBias;                // Brake bias (percentage)
    float     m_frontTyrePressure;        // Front tyre pressure (PSI)
    float     m_rearTyrePressure;         // Rear tyre pressure (PSI)
    uint8     m_ballast;                  // Ballast
    float     m_fuelLoad;                 // Fuel load
};

struct PacketCarSetupData
{
    PacketHeader    m_header;            // Header

    CarSetupData    m_carSetups[20];
};

Car Telemetry Packet

This packet details telemetry for all the cars in the race. It details various values that would be recorded on the car such as speed, throttle application, DRS etc.

 

Frequency: Rate as specified in menus

Size: 1347 bytes

Version: 1

struct CarTelemetryData
{
    uint16    m_speed;                    // Speed of car in kilometres per hour
    float     m_throttle;                 // Amount of throttle applied (0.0 to 1.0)
    float     m_steer;                    // Steering (-1.0 (full lock left) to 1.0 (full lock right))
    float     m_brake;                    // Amount of brake applied (0.0 to 1.0)
    uint8     m_clutch;                   // Amount of clutch applied (0 to 100)
    int8      m_gear;                     // Gear selected (1-8, N=0, R=-1)
    uint16    m_engineRPM;                // Engine RPM
    uint8     m_drs;                      // 0 = off, 1 = on
    uint8     m_revLightsPercent;         // Rev lights indicator (percentage)
    uint16    m_brakesTemperature[4];     // Brakes temperature (celsius)
    uint16    m_tyresSurfaceTemperature[4]; // Tyres surface temperature (celsius)
    uint16    m_tyresInnerTemperature[4]; // Tyres inner temperature (celsius)
    uint16    m_engineTemperature;        // Engine temperature (celsius)
    float     m_tyresPressure[4];         // Tyres pressure (PSI)
    uint8     m_surfaceType[4];           // Driving surface, see appendices
};

struct PacketCarTelemetryData
{
    PacketHeader    	m_header;	      // Header

    CarTelemetryData	m_carTelemetryData[20];

    uint32              m_buttonStatus;        // Bit flags specifying which buttons are being pressed
                                               // currently - see appendices
};

Car Status Packet

This packet details car statuses for all the cars in the race. It includes values such as the damage readings on the car.

 

Frequency: Rate as specified in menus

Size: 1143 bytes

Version: 1

struct CarStatusData
{
    uint8       m_tractionControl;          // 0 (off) - 2 (high)
    uint8       m_antiLockBrakes;           // 0 (off) - 1 (on)
    uint8       m_fuelMix;                  // Fuel mix - 0 = lean, 1 = standard, 2 = rich, 3 = max
    uint8       m_frontBrakeBias;           // Front brake bias (percentage)
    uint8       m_pitLimiterStatus;         // Pit limiter status - 0 = off, 1 = on
    float       m_fuelInTank;               // Current fuel mass
float       m_fuelCapacity;             // Fuel capacity
float       m_fuelRemainingLaps;        // Fuel remaining in terms of laps (value on MFD)
    uint16      m_maxRPM;                   // Cars max RPM, point of rev limiter
    uint16      m_idleRPM;                  // Cars idle RPM
    uint8       m_maxGears;                 // Maximum number of gears
    uint8       m_drsAllowed;               // 0 = not allowed, 1 = allowed, -1 = unknown
    uint8       m_tyresWear[4];             // Tyre wear percentage
    uint8       m_actualTyreCompound;	   // F1 Modern - 16 = C5, 17 = C4, 18 = C3, 19 = C2, 20 = C1
   					   // 7 = inter, 8 = wet
   					   // F1 Classic - 9 = dry, 10 = wet
   					   // F2 – 11 = super soft, 12 = soft, 13 = medium, 14 = hard
   					   // 15 = wet
uint8       m_tyreVisualCompound;       // F1 visual (can be different from actual compound)
   // 16 = soft, 17 = medium, 18 = hard, 7 = inter, 8 = wet
   // F1 Classic – same as above
   // F2 – same as above
    uint8       m_tyresDamage[4];           // Tyre damage (percentage)
    uint8       m_frontLeftWingDamage;      // Front left wing damage (percentage)
    uint8       m_frontRightWingDamage;     // Front right wing damage (percentage)
    uint8       m_rearWingDamage;           // Rear wing damage (percentage)
    uint8       m_engineDamage;             // Engine damage (percentage)
    uint8       m_gearBoxDamage;            // Gear box damage (percentage)
    int8        m_vehicleFiaFlags;	   // -1 = invalid/unknown, 0 = none, 1 = green
                                            // 2 = blue, 3 = yellow, 4 = red
    float       m_ersStoreEnergy;           // ERS energy store in Joules
    uint8       m_ersDeployMode;            // ERS deployment mode, 0 = none, 1 = low, 2 = medium
   					   // 3 = high, 4 = overtake, 5 = hotlap
    float       m_ersHarvestedThisLapMGUK;  // ERS energy harvested this lap by MGU-K
    float       m_ersHarvestedThisLapMGUH;  // ERS energy harvested this lap by MGU-H
    float       m_ersDeployedThisLap;       // ERS energy deployed this lap
};

struct PacketCarStatusData
{
    PacketHeader    	m_header;	   // Header

    CarStatusData	m_carStatusData[20];
};

Restricted data (Your Telemetry setting)

There is some data in the UDP that you may not want other players seeing if you are in a multiplayer game. This is controlled by the “Your Telemetry” setting in the Telemetry options. The options are:

  • Restricted (Default) – other players viewing the UDP data will not see values for your car
  • Public – all other players can see all the data for your car

Note: You can always see the data for the car you are driving regardless of the setting.

The following data items are set to zero if the player driving the car in question has their “Your Telemetry” set to “Restricted”:

Car status packet

  • m_fuelInTank
  • m_fuelCapacity
  • m_fuelMix
  • m_fuelRemainingLaps
  • m_frontBrakeBias
  • m_frontLeftWingDamage
  • m_frontRightWingDamage
  • m_rearWingDamage
  • m_engineDamage
  • m_gearBoxDamage
  • m_tyresWear (All four wheels)
  • m_tyresDamage (All four wheels)
  • m_ersDeployMode
  • m_ersStoreEnergy
  • m_ersDeployedThisLap
  • m_ersHarvestedThisLapMGUK
  • m_ersHarvestedThisLapMGUH
  • Thanks 2

Share this post


Link to post
Share on other sites

Recommended Posts

  • 0
Posted (edited)

Hello,

I started a new projet (C#) yesterday but i can't show the participants' names correctly while i used UTF-8 format 😕

packet format = 2019

On 6/20/2019 at 5:29 PM, Faya said:

char m_name[48]; // Name of participant in UTF-8 format – null terminated // Will be truncated with … (U+2026) if too long

and the driverId (from Participant packet, m_participants[X].m_driverId) when i receive it, it's not the same than table here...eKW6ZSy.png

Could someone clarify me ?

PS : sorry for my english.

 

Edited by NoizeGamer
new code

Share this post


Link to post
Share on other sites
  • 0

Can anyone help me please?

Ive been able to read all the basic data but I don't understand how the multi-values work.

Example

m_brakesTemperature[4] is supposed to be a uint16 but I get 32 as the answer when i try to read it: readUInt16LE(43).toString()

Sorry for the noob question. Thank you in advance

Share this post


Link to post
Share on other sites
  • 0
5 hours ago, thetravisty said:

Can anyone help me please?

Ive been able to read all the basic data but I don't understand how the multi-values work.

Example

m_brakesTemperature[4] is supposed to be a uint16 but I get 32 as the answer when i try to read it: readUInt16LE(43).toString()

Sorry for the noob question. Thank you in advance

Welcome to programming, you’ve  picked a tough project to start with but it sounds like you’re going well. Unsigned 16 bit number is a value between 0 and 65535 so 32 isn’t wrong. Also, I’ve noticed that the brake temps seem to come through as 32 at the start of a session so I think if you wait a bit longer you’ll get the full values correctly. In terms of the multi-value aspect, this just means it’s an array of 4 items which starts at 0; so you can access each item by using m_brakesTemperature[0], m_brakesTemperature[1], etc.

Hope this helps.

  • Thanks 1

Share this post


Link to post
Share on other sites
  • 0

@DaveyGravy Thank you for that information. Ive been able to get more data from the packets because of it. Now I need to figure out why the engine temp is always 89....

Im actually an ex-programmer but I mostly worked in .net - I never came across structs and udp during that time.

Share this post


Link to post
Share on other sites
  • 0
On 6/20/2019 at 4:29 PM, Faya said:

Restricted data (Your Telemetry setting)

There is some data in the UDP that you may not want other players seeing if you are in a multiplayer game. This is controlled by the “Your Telemetry” setting in the Telemetry options.

Hi @Faya @Hoo

I have trawled every menu in the game, but cannot find a 'Your Telemetery' setting. I'm running in Windows 7 (directx 11)

The reason I'm looking for it is because I'm getting a strange issue where I'm not feeling any car motion, road bumps, engine revs etc when I'm driving. However, when the computer is driving (e.g. before starting a flying lap in qualifying, or driving out of the pits) everything is working and feels good. I was thinking it could be something to do with this setting, but I cannot find it to set it to Public.

Thanks

Share this post


Link to post
Share on other sites
  • 0

Hi .... I'm playing with data from a OSQ (One shot quali) and struggling to work out a laptime that corresponds with that shown in the game.

As there's no end of lap event and there's no lap 2 data to get the Lastlap data from the best i can work out is that I can use the last recieved LapData packet and try and take a best guess.

So for example I have captured a full laps worth of data and have the last lapdata packet send from the game... when I get the SEND event I know we are complete so i perform the following calculation. Taking the last position in the lap (distance), work out how far it is to the end of the lap (track length from a session packet - lapdistance from the Lapdata packet) ... calculate speed in meters/sec from speed in the telemetry packet and then calculate the time it would take to travel the remaining distance.

Sound logical ?  

The trouble is that the result i'm getting is significantly different to what i see as a game time.

From an example data capture ...   Current Lapdistance of 5895.4595 meters, total tracklength of 5896 meters and current laptime of 96.11017 secs and speed of 242 kph .... 

5896-5895.4595 = 0.5405 meters
242/3.6 (to convert to m/s) = 67.222

0.5403/67.222 = 0.0080405 seconds  (time to travel remaining distance)

Total laptime is  96.1182 

BUT the time reported in the game was 96.136  but that's 0.0177 out from my calculation ......  Is there a better way to calculate this ? Am i missing something ?

Share this post


Link to post
Share on other sites
  • 0
2 hours ago, trenamax said:

Hi @Faya @Hoo

I have trawled every menu in the game, but cannot find a 'Your Telemetery' setting. I'm running in Windows 7 (directx 11)

The reason I'm looking for it is because I'm getting a strange issue where I'm not feeling any car motion, road bumps, engine revs etc when I'm driving. However, when the computer is driving (e.g. before starting a flying lap in qualifying, or driving out of the pits) everything is working and feels good. I was thinking it could be something to do with this setting, but I cannot find it to set it to Public.

Thanks

Hi @trenamax ,

The option is not yet available. It should present in version 1.05 (which is currently in development).

It sounds like the problem you are having relates to the controller settings. There is an option within the Customise Controls menus which allows you turn off controller vibration / force feedback. I think this single options controls all of these effects, so I'd try looking there first to see if that option is enabled.

 

Share this post


Link to post
Share on other sites
  • 0
Posted (edited)
2 hours ago, Hoo said:

Hi @trenamax ,

The option is not yet available. It should present in version 1.05 (which is currently in development).

It sounds like the problem you are having relates to the controller settings. There is an option within the Customise Controls menus which allows you turn off controller vibration / force feedback. I think this single options controls all of these effects, so I'd try looking there first to see if that option is enabled.

 

Thanks @Hoo - I'll await version 1.05 in that case.

I don't think the controller settings are related to my issue, it's a little more involved than that:

I'm talking about the feedback I get through my seat, driven by Simcommander SimVibe (which uses the telemetry output from the game).  Last year SimCommander / SimVibe never adopted the new F1 2018 UDP structure, so I had to write my own UDP converter app for F1 2018, to convert the new structure back to the legacy structure, so I could run the latest UDP structure to drive my F1 wheel replicas which use SliMaxManager and the latest UDP structure, see here:

whilst also running SimVibe with the legacy structure simultaneously (using my converter app and the Sim Race Proxy Server to forward the UDP output from the game to multiple ports)

So I've recently updated my converter app for F1 2019, but yeah I'm seeing this issue where not all the effects are coming through. Strange because the car telemetry packet hasn't changed this year. Interestingly gear shifts are coming through just fine, I can feel the seat move when I shift. But revs, and rumble strips etc are not coming through at all. The seat vibration feels as though the car is idle in the garage. As I mentioned in my original post though, I think when the computer has control it is working. Which is what game me the hunch that maybe it's an issue with the new yourTelemetry feature.

Edited by trenamax

Share this post


Link to post
Share on other sites
  • 0

Hi Guys,

Does anyone used Python to receive UPD data and convert It to struct like the definition on initial post? 

I am receiving data like :

b'\x38\xd3.......' (it's a large Chaim of data), but I didn't know to tranform It in a used data struct.

 

 

Share this post


Link to post
Share on other sites
  • 0
On 6/20/2019 at 11:29 AM, Faya said:

struct CarMotionData {

float m_worldPositionX; // World space X position

float m_worldPositionY; // World space Y position

float m_worldPositionZ; // World space Z position
...

};

For the m_worldPositionX, m_worldPositionY, and m_worldPositionZ variables: what point on the car is that position referring to? Is it the car's center of gravity? The centerpoint of one of the axles? The optical center of the TVPod camera?

 

 

Share this post


Link to post
Share on other sites
  • 0

Bug report:

- still the two last buttons 

0x2000

Left Stick Click

0x4000

Right Stick Click

 

were not send in PC-UDP-stream. Who can confirm?

 

- Multiplayer Names not in PC-UDP-stream; just "Player" - will this be corrected at all? Codemaster: please give a statement. @Faya

Share this post


Link to post
Share on other sites
  • 0

@AndyHamp - if the maths is all correct then I wonder if one of the numbers used for the calculation is frame out, e.g. distance remaining?

Share this post


Link to post
Share on other sites
  • 0

@CanTQuiT - we are reviewing the naming policy, but I don't expect this to come soon. The route we are considering involves players giving explicit consent for other users to have access to key UDP info, so apps should not be build around the assumption that you will have access to player's sensitive data. This is something we can't do.

If you can provide specific use-cases for us to examine, that will help us refine our proposal to something that is both useful to you and compliant with the latest legal guidelines.

 

Share this post


Link to post
Share on other sites
  • 0

@ElectricTurtle - I think this is taken from the centre of the car chassis, which falls just behind the driver's seat:

 WorldPosition.jpg

Share this post


Link to post
Share on other sites
  • 0

Hi everyone,

I am currently writing an app (cross-platform Mac/iOS) that would, among other things, replicate the live gaps we often see on TV between two drivers, which is updated every few seconds instead of every sector. However, this kind of information doesn't seem to be present in the UDP specs, so it must be calculated somehow. I'm looking for the best approach to get the most accurate results possible.

Which data do you think would be most useful to process this? I'm currently thinking about using lap numbers, and distance traveled in the lap so far by the two drivers, then remember each frame in a big array, to compute the time it takes for the second driver to reach the lap distance from the first driver, but I'm not sure this is the best method, nor if it would produce very accurate results.

Anyway, thanks for your ideas!

Share this post


Link to post
Share on other sites
  • 0

@Poulpusyou 're on the right track. It is even enough to store the data in your proposed array only from the first driver like you described and calculate the difference to each driver.

  • Thanks 1

Share this post


Link to post
Share on other sites
  • 0
Posted (edited)

@Hoo Did Codemasters do any changes/updates to the UDP 2019 with patch 1.05?

Edited by GioProductions
extra info

Share this post


Link to post
Share on other sites
  • 0

IS there a way to know when will be the next pit?

 

in the DFU you can see the next probably pit by the strategy , but i can't see anything in the UDP packet for this

 

 

Share this post


Link to post
Share on other sites
  • 0

Why in UDP front tyres are little worn even at the session start? Game shows front tyres wear level about 15% lower than in UDP packets

Share this post


Link to post
Share on other sites
  • 0

Hi ... is anyone noticing something odd about the 3 Gforce values ?   

It seems to me in the data i've been looking at that the values are often zero ..... logically i'd have thought the value would NEVER be zero for all three if the car is in motion... 

Share this post


Link to post
Share on other sites
  • 0
On 7/19/2019 at 8:42 AM, Hoo said:

@AndyHamp - if the maths is all correct then I wonder if one of the numbers used for the calculation is frame out, e.g. distance remaining?

I think the fault is my assumptions about what the calc should be ... if track length is as per my example then if you actually use a track length of 1 meter greater the calculation seems to work ...

From an example data capture ...   Current Lap distance of 5895.4595 meters, total track length of 5896 meters and current laptime of 96.11017 secs and speed of 242 kph .... 

5896 + 1 - 5895.4595 = 1.5405 meters
242/3.6 (to convert to m/s) = 67.222

1.5403/67.222 = 0.022916 seconds  (time to travel remaining distance)

Total laptime is  96.13308

The time reported in the game was 96.136 which is now pretty damned close !

Share this post


Link to post
Share on other sites
  • 0
Posted (edited)

@Hoo,
How can we get the driver names in the MP session? What value does "m_name[48]" get in the MP session? Really the SteamID, as @Faya in the thread from 20.06.20 described in "Participants Packet"? I thank you for an explanation,
clintwood60

Edited by clintwood60

Share this post


Link to post
Share on other sites
  • 0

 

4 hours ago, clintwood60 said:

@Hoo,
How can we get the driver names in the MP session? What value does "m_name[48]" get in the MP session? Really the SteamID, as @Faya in the thread from 20.06.20 described in "Participants Packet"? I thank you for an explanation,
clintwood60

In a MP session, this will return a default value as we do not provide players names in online sessions at the moment. For AI drivers and in offline mode, this will be the driver name.

 

Share this post


Link to post
Share on other sites
  • 0
Posted (edited)

@Hoo

 

I use Sim Dashboard but i see sometimes differences between the damage on the game and Sim Dashboard (with Telemetry data).

 

I tested this with F2 cars and you can see the damage differences on my printscreen and on the App.

Is there something to do about that?

 

Thanks

 

20190706_223708.thumb.jpg.a581fa8a796b4fc17275674d744c8bfe.jpg

Edited by GioProductions
Extra info

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×