Da ich neu bin weiß ich leider nicht, ob das hier im richtigen Bereich ist. Ich bitte um Verständnis.

Ich habe ein Programm geschrieben, welches Daten aus dem Spiel Project Cars ausliest, diese verarbeitet und dann an einen Arduino weiterleitet.
Jetzt habe ich aber das Problem, dass nach dem das Programm eine Weile lief, die Ausgabe verzögert ist. Also kommt die Nachicht erst nach 1-2 Sekunden an.

Könnt ihr mir Tipps geben, wie ich das ganze verhindern kann?

Sorry das ich jetzt den ganzen Code hochgeladen habe, aber ich weiß nicht wo die Bremse ist.

PS: Ich habe die main.cpp geschrieben, die Restlichen habe ich nur inkludiert.

Main\1:

// Used for memory-mapped functionality
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include "tserial.h"
#include "bot_control.h"
#include "sharedmemory.h"
#include <cmath>

// Name of the pCars memory mapped file

#define MAP_OBJECT_NAME "$pcars$"

//Konstanten

const bool debug = true;
const unsigned char maxFPS = 100;
const unsigned char fuelWarn = 10;

char data; //To store the character to send
char lastFlag;

serial comm; //serial is a class type defined in these files, used for referring to the communication device

int main() {

	// Open the memory-mapped file
	HANDLE fileHandle = OpenFileMapping( PAGE_READONLY, FALSE, MAP_OBJECT_NAME );
	if (fileHandle == NULL)
	{
		printf( "Could not open file mapping object (%d).\n", GetLastError() );
		Sleep(2000);
		return 1;
	}

	// Get the data structure
	const SharedMemory* sharedData = (SharedMemory*)MapViewOfFile( fileHandle, PAGE_READONLY, 0, 0, sizeof(SharedMemory) );
	if (sharedData == NULL)
	{
		printf( "Could not map view of file (%d).\n", GetLastError() );

		CloseHandle( fileHandle );
		Sleep(2000);
		return 1;
	}

	// Ensure we're sync'd to the correct data version
	if ( sharedData->mVersion != SHARED_MEMORY_VERSION )
	{
		printf( "Data version mismatch\n");
		Sleep(2000);
		return 1;
	}

	comm.startDevice("COM3", 9600);
	/* “COM 2” refers to the com port in which the USB to SERIAL port is attached. It is shown by right clicking on my computer, then going to properties and then device manager
	9600 is the baud-rate in bits per second */

	//------------------------------------------------------------------------------
	// Datensenden -- Schleife
	//------------------------------------------------------------------------------

	//printf( "ESC TO EXIT\n\n", sharedData->mUnfilteredSteering );

	while (true)
	{
		if(debug)
		{
			printf( "Flag: (%d)\n", sharedData->mHighestFlagColour );
			printf( "RPMMax: (%d)\n", sharedData->mMaxRPM);
			printf( "Data: (%d)\n",data);
			printf( "lastFlag: (%d)\n",lastFlag);
			system("cls");
		}

		if(lastFlag != sharedData->mHighestFlagColour){
			data = sharedData->mHighestFlagColour;
			lastFlag = data;
		}

		comm.send_data(data); //The data is sent through the arduino

		if ( _kbhit() && _getch() == 27 ) // check for escape
		{
			break;
		}

		Sleep(1000 / maxFPS);
	}

	// Cleanup
	UnmapViewOfFile( sharedData );
	CloseHandle( fileHandle );

	comm.stopDevice(); //The device is closed down
	getch();

	return 0;
}

#include "tserial.h"

class serial{

  private:
        // private attributes
		Tserial *com;
  public:

	serial() {

		 }

	bool startDevice(char *port,int speed)
	{
		com = new Tserial();
		if (com!=0)
		{
			if(com->connect(port, speed, spNONE))
				printf("Not Connected...\n");
			else
				printf("Connected..\n");
			return TRUE;
		}
		else
			return FALSE; 
	}

	void stopDevice()
	{
		com->disconnect();
        // ------------------
        delete com;
        com = 0;
	}

	void send_data(unsigned char data)
	{
	//	unsigned char data = 0;

		com->sendChar(data);
		//printf("%c",data);

	}
};

#ifndef TSERIAL_H
#define TSERIAL_H

#include <stdio.h>
#include <windows.h>

enum serial_parity  { spNONE,    spODD, spEVEN };

/* -------------------------------------------------------------------- */
/* -----------------------------  Tserial  ---------------------------- */
/* -------------------------------------------------------------------- */
class Tserial
{
    // -------------------------------------------------------- //
protected:
    char              port[10];                      // port name "com1",...
    int               rate;                          // baudrate
    serial_parity     parityMode;
    HANDLE            serial_handle;                 // ...

    // ++++++++++++++++++++++++++++++++++++++++++++++
    // .................. EXTERNAL VIEW .............
    // ++++++++++++++++++++++++++++++++++++++++++++++
public:
                  Tserial();
                 ~Tserial();
    int           connect          (char *port_arg, int rate_arg,
                                    serial_parity parity_arg);
    void          sendChar         (char c);
    void          sendArray        (char *buffer, int len);
    char          getChar          (void);
    int           getArray         (char *buffer, int len);
    int           getNbrOfBytes    (void);
    void          disconnect       (void);
};
/* -------------------------------------------------------------------- */

#endif TSERIAL_H

#define STRICT
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <process.h>
#include <conio.h>
#include <windows.h>
//#include <stdafx.h>
#include <windows.h>

#include "tserial.h"

/* -------------------------------------------------------------------- */
/* -------------------------    Tserial   ----------------------------- */
/* -------------------------------------------------------------------- */
Tserial::Tserial()
{
    parityMode       = spNONE;
    port[0]          = 0;
    rate             = 0;
    serial_handle    = INVALID_HANDLE_VALUE;
}

/* -------------------------------------------------------------------- */
/* --------------------------    ~Tserial     ------------------------- */
/* -------------------------------------------------------------------- */
Tserial::~Tserial()
{
    if (serial_handle!=INVALID_HANDLE_VALUE)
        CloseHandle(serial_handle);
    serial_handle = INVALID_HANDLE_VALUE;
}
/* -------------------------------------------------------------------- */
/* --------------------------    disconnect   ------------------------- */
/* -------------------------------------------------------------------- */
void Tserial::disconnect(void)
{
    if (serial_handle!=INVALID_HANDLE_VALUE)
        CloseHandle(serial_handle);
    serial_handle = INVALID_HANDLE_VALUE;
}
/* -------------------------------------------------------------------- */
/* --------------------------    connect      ------------------------- */
/* -------------------------------------------------------------------- */
int  Tserial::connect          (char *port_arg, int rate_arg, serial_parity parity_arg)
{
    int erreur;
    DCB  dcb;
    COMMTIMEOUTS cto = { 0, 0, 0, 0, 0 };

    /* --------------------------------------------- */
    if (serial_handle!=INVALID_HANDLE_VALUE)
        CloseHandle(serial_handle);
    serial_handle = INVALID_HANDLE_VALUE;

    erreur = 0;

    if (port_arg!=0)
    {
        strncpy(port, port_arg, 10);
        rate      = rate_arg;
        parityMode= parity_arg;
        memset(&dcb,0,sizeof(dcb));

        /* -------------------------------------------------------------------- */
        // set DCB to configure the serial port
        dcb.DCBlength       = sizeof(dcb);                   

        /* ---------- Serial Port Config ------- */
        dcb.BaudRate        = rate;

        switch(parityMode)
        {
            case spNONE:
                            dcb.Parity      = NOPARITY;
                            dcb.fParity     = 0;
                            break;
            case spEVEN:
                            dcb.Parity      = EVENPARITY;
                            dcb.fParity     = 1;
                            break;
            case spODD:
                            dcb.Parity      = ODDPARITY;
                            dcb.fParity     = 1;
                            break;
        }

        dcb.StopBits        = ONESTOPBIT;
        dcb.ByteSize        = 8;

        dcb.fOutxCtsFlow    = 0;
        dcb.fOutxDsrFlow    = 0;
        dcb.fDtrControl     = DTR_CONTROL_DISABLE;
        dcb.fDsrSensitivity = 0;
        dcb.fRtsControl     = RTS_CONTROL_DISABLE;
        dcb.fOutX           = 0;
        dcb.fInX            = 0;

        /* ----------------- misc parameters ----- */
        dcb.fErrorChar      = 0;
        dcb.fBinary         = 1;
        dcb.fNull           = 0;
        dcb.fAbortOnError   = 0;
        dcb.wReserved       = 0;
        dcb.XonLim          = 2;
        dcb.XoffLim         = 4;
        dcb.XonChar         = 0x13;
        dcb.XoffChar        = 0x19;
        dcb.EvtChar         = 0;

        /* -------------------------------------------------------------------- */
        serial_handle    = CreateFile(port, GENERIC_READ | GENERIC_WRITE,
                               0, NULL, OPEN_EXISTING,NULL,NULL);
                   // opening serial port

        if (serial_handle    != INVALID_HANDLE_VALUE)
        {
            if(!SetCommMask(serial_handle, 0))
                erreur = 1;

            // set timeouts
            if(!SetCommTimeouts(serial_handle,&cto))
                erreur = 2;

            // set DCB
            if(!SetCommState(serial_handle,&dcb))
                erreur = 4;
        }
        else
            erreur = 8;
    }
    else
        erreur = 16;

    /* --------------------------------------------- */
    if (erreur!=0)
    {
        CloseHandle(serial_handle);
        serial_handle = INVALID_HANDLE_VALUE;
    }
    return(erreur);
}

/* -------------------------------------------------------------------- */
/* --------------------------    sendChar     ------------------------- */
/* -------------------------------------------------------------------- */
void Tserial::sendChar(char data)
{
    sendArray(&data, 1);
}

/* -------------------------------------------------------------------- */
/* --------------------------    sendArray    ------------------------- */
/* -------------------------------------------------------------------- */
void Tserial::sendArray(char *buffer, int len)
{
    unsigned long result;

    if (serial_handle!=INVALID_HANDLE_VALUE)
        WriteFile(serial_handle, buffer, len, &result, NULL);
}

/* -------------------------------------------------------------------- */
/* --------------------------    getChar      ------------------------- */
/* -------------------------------------------------------------------- */
char Tserial::getChar(void)
{
    char c;
    getArray(&c, 1);
    return(c);
}

/* -------------------------------------------------------------------- */
/* --------------------------    getArray     ------------------------- */
/* -------------------------------------------------------------------- */
int  Tserial::getArray         (char *buffer, int len)
{
    unsigned long read_nbr;

    read_nbr = 0;
    if (serial_handle!=INVALID_HANDLE_VALUE)
    {
        ReadFile(serial_handle, buffer, len, &read_nbr, NULL);
    }
    return((int) read_nbr);
}
/* -------------------------------------------------------------------- */
/* --------------------------    getNbrOfBytes ------------------------ */
/* -------------------------------------------------------------------- */
int Tserial::getNbrOfBytes    (void)
{
    struct _COMSTAT status;
    int             n;
    unsigned long   etat;

    n = 0;

    if (serial_handle!=INVALID_HANDLE_VALUE)
    {
        ClearCommError(serial_handle, &etat, &status);
        n = status.cbInQue;
    }

    return(n);
}

// *** Types ***

// Header version number to test against
enum
{
  SHARED_MEMORY_VERSION = 5
};

// Maximum allowed length of string
enum
{
  STRING_LENGTH_MAX = 64
};

// Maximum number of general participant information allowed to be stored in memory-mapped file
enum
{
  STORED_PARTICIPANTS_MAX = 64
};

// Tyres
enum 
{
  TYRE_FRONT_LEFT = 0,
  TYRE_FRONT_RIGHT,
  TYRE_REAR_LEFT,
  TYRE_REAR_RIGHT,
  //--------------
  TYRE_MAX
};

// Vector
enum
{
  VEC_X = 0,
  VEC_Y,
  VEC_Z,
  //-------------
  VEC_MAX
};

// (Type#1) GameState (to be used with 'mGameState')
enum
{
  GAME_EXITED = 0,
  GAME_FRONT_END,
  GAME_INGAME_PLAYING,
  GAME_INGAME_PAUSED,
  GAME_INGAME_RESTARTING,
  GAME_INGAME_REPLAY,
  GAME_FRONT_END_REPLAY,
  //-------------
  GAME_MAX
};

// (Type#2) Session state (to be used with 'mSessionState')
enum
{
  SESSION_INVALID = 0,
  SESSION_PRACTICE,
  SESSION_TEST,
  SESSION_QUALIFY,
  SESSION_FORMATION_LAP,
  SESSION_RACE,
  SESSION_TIME_ATTACK,
  //-------------
  SESSION_MAX
};

// (Type#3) RaceState (to be used with 'mRaceState')
enum
{
  RACESTATE_INVALID,
  RACESTATE_NOT_STARTED,
  RACESTATE_RACING,
  RACESTATE_FINISHED,
  RACESTATE_DISQUALIFIED,
  RACESTATE_RETIRED,
  RACESTATE_DNF,
  //-------------
  RACESTATE_MAX
};

// (Type#4) Current Sector (to be used with 'mCurrentSector')
enum
{
  SECTOR_INVALID = 0, 
  SECTOR_START,
  SECTOR_SECTOR1,
  SECTOR_SECTOR2,
  SECTOR_FINISH,
  SECTOR_STOP,
  //-------------
  SECTOR_MAX
};

// (Type#5) Flag Colours (to be used with 'mHighestFlagColour')
enum
{
  FLAG_COLOUR_NONE = 0,       // Not used for actual flags, only for some query functions
  FLAG_COLOUR_GREEN,          // End of danger zone, or race started
  FLAG_COLOUR_BLUE,           // Faster car wants to overtake the participant
  FLAG_COLOUR_WHITE,          // Approaching a slow car
  FLAG_COLOUR_YELLOW,         // Danger on the racing surface itself
  FLAG_COLOUR_DOUBLE_YELLOW,  // Danger that wholly or partly blocks the racing surface
  FLAG_COLOUR_BLACK,          // Participant disqualified
  FLAG_COLOUR_CHEQUERED,      // Chequered flag
  //-------------
  FLAG_COLOUR_MAX
};

// (Type#6) Flag Reason (to be used with 'mHighestFlagReason')
enum
{
  FLAG_REASON_NONE = 0,
  FLAG_REASON_SOLO_CRASH,
  FLAG_REASON_VEHICLE_CRASH,
  FLAG_REASON_VEHICLE_OBSTRUCTION,
  //-------------
  FLAG_REASON_MAX
};

// (Type#7) Pit Mode (to be used with 'mPitMode')
enum
{
  PIT_MODE_NONE = 0,
  PIT_MODE_DRIVING_INTO_PITS,
  PIT_MODE_IN_PIT,
  PIT_MODE_DRIVING_OUT_OF_PITS,
  PIT_MODE_IN_GARAGE,
  //-------------
  PIT_MODE_MAX
};

// (Type#8) Pit Stop Schedule (to be used with 'mPitSchedule')
enum
{
  PIT_SCHEDULE_NONE = 0,        // Nothing scheduled
  PIT_SCHEDULE_STANDARD,        // Used for standard pit sequence
  PIT_SCHEDULE_DRIVE_THROUGH,   // Used for drive-through penalty
  PIT_SCHEDULE_STOP_GO,         // Used for stop-go penalty
  //-------------
  PIT_SCHEDULE_MAX
};

// (Type#9) Car Flags (to be used with 'mCarFlags')
enum
{
  CAR_HEADLIGHT         = (1<<0),
  CAR_ENGINE_ACTIVE     = (1<<1),
  CAR_ENGINE_WARNING    = (1<<2),
  CAR_SPEED_LIMITER     = (1<<3),
  CAR_ABS               = (1<<4),
  CAR_HANDBRAKE         = (1<<5),
};

// (Type#10) Tyre Flags (to be used with 'mTyreFlags')
enum
{
  TYRE_ATTACHED         = (1<<0),
  TYRE_INFLATED         = (1<<1),
  TYRE_IS_ON_GROUND     = (1<<2),
};

// (Type#11) Terrain Materials (to be used with 'mTerrain')
enum
{
  TERRAIN_ROAD = 0,
  TERRAIN_LOW_GRIP_ROAD,
  TERRAIN_BUMPY_ROAD1,
  TERRAIN_BUMPY_ROAD2,
  TERRAIN_BUMPY_ROAD3,
  TERRAIN_MARBLES,
  TERRAIN_GRASSY_BERMS,
  TERRAIN_GRASS,
  TERRAIN_GRAVEL,
  TERRAIN_BUMPY_GRAVEL,
  TERRAIN_RUMBLE_STRIPS,
  TERRAIN_DRAINS,
  TERRAIN_TYREWALLS,
  TERRAIN_CEMENTWALLS,
  TERRAIN_GUARDRAILS,
  TERRAIN_SAND,
  TERRAIN_BUMPY_SAND,
  TERRAIN_DIRT,
  TERRAIN_BUMPY_DIRT,
  TERRAIN_DIRT_ROAD,
  TERRAIN_BUMPY_DIRT_ROAD,
  TERRAIN_PAVEMENT,
  TERRAIN_DIRT_BANK,
  TERRAIN_WOOD,
  TERRAIN_DRY_VERGE,
  TERRAIN_EXIT_RUMBLE_STRIPS,
  TERRAIN_GRASSCRETE,
  TERRAIN_LONG_GRASS,
  TERRAIN_SLOPE_GRASS,
  TERRAIN_COBBLES,
  TERRAIN_SAND_ROAD,
  TERRAIN_BAKED_CLAY,
  TERRAIN_ASTROTURF,
  TERRAIN_SNOWHALF,
  TERRAIN_SNOWFULL,
  TERRAIN_DAMAGED_ROAD1,
  TERRAIN_TRAIN_TRACK_ROAD,
  TERRAIN_BUMPYCOBBLES,
  TERRAIN_ARIES_ONLY,
  TERRAIN_ORION_ONLY,
  TERRAIN_B1RUMBLES,
  TERRAIN_B2RUMBLES,
  TERRAIN_ROUGH_SAND_MEDIUM,
  TERRAIN_ROUGH_SAND_HEAVY,

  //-------------
  TERRAIN_MAX
};

// (Type#12) Crash Damage State  (to be used with 'mCrashState')
enum
{
  CRASH_DAMAGE_NONE = 0,
  CRASH_DAMAGE_OFFTRACK,
  CRASH_DAMAGE_LARGE_PROP,
  CRASH_DAMAGE_SPINNING,
  CRASH_DAMAGE_ROLLING,
  //-------------
  CRASH_MAX
};

// (Type#13) ParticipantInfo struct  (to be used with 'mParticipantInfo')
typedef struct
{
  bool mIsActive;
  char mName[STRING_LENGTH_MAX];                   // [ string ]
  float mWorldPosition[VEC_MAX];                   // [ UNITS = World Space  X  Y  Z ]
  float mCurrentLapDistance;                       // [ UNITS = Metres ]   [ RANGE = 0.0f->... ]    [ UNSET = 0.0f ]
  unsigned int mRacePosition;                      // [ RANGE = 1->... ]   [ UNSET = 0 ]
  unsigned int mLapsCompleted;                     // [ RANGE = 0->... ]   [ UNSET = 0 ]
  unsigned int mCurrentLap;                        // [ RANGE = 0->... ]   [ UNSET = 0 ]
  unsigned int mCurrentSector;                     // [ enum (Type#4) Current Sector ]
} ParticipantInfo;

// *** Shared Memory ***

typedef struct
{
  // Version Number
  unsigned int mVersion;                           // [ RANGE = 0->... ]
  unsigned int mBuildVersionNumber;                // [ RANGE = 0->... ]   [ UNSET = 0 ]

  // Game States
  unsigned int mGameState;                         // [ enum (Type#1) Game state ]
  unsigned int mSessionState;                      // [ enum (Type#2) Session state ]
  unsigned int mRaceState;                         // [ enum (Type#3) Race State ]

  // Participant Info
  int mViewedParticipantIndex;                                  // [ RANGE = 0->STORED_PARTICIPANTS_MAX ]   [ UNSET = -1 ]
  int mNumParticipants;                                         // [ RANGE = 0->STORED_PARTICIPANTS_MAX ]   [ UNSET = -1 ]
  ParticipantInfo mParticipantInfo[STORED_PARTICIPANTS_MAX];    // [ struct (Type#13) ParticipantInfo struct ]

  // Unfiltered Input
  float mUnfilteredThrottle;                        // [ RANGE = 0.0f->1.0f ]
  float mUnfilteredBrake;                           // [ RANGE = 0.0f->1.0f ]
  float mUnfilteredSteering;                        // [ RANGE = -1.0f->1.0f ]
  float mUnfilteredClutch;                          // [ RANGE = 0.0f->1.0f ]

  // Vehicle information
  char mCarName[STRING_LENGTH_MAX];                 // [ string ]
  char mCarClassName[STRING_LENGTH_MAX];            // [ string ]

  // Event information
  unsigned int mLapsInEvent;                        // [ RANGE = 0->... ]   [ UNSET = 0 ]
  char mTrackLocation[STRING_LENGTH_MAX];           // [ string ]
  char mTrackVariation[STRING_LENGTH_MAX];          // [ string ]
  float mTrackLength;                               // [ UNITS = Metres ]   [ RANGE = 0.0f->... ]    [ UNSET = 0.0f ]

  // Timings
  bool mLapInvalidated;                             // [ UNITS = boolean ]   [ RANGE = false->true ]   [ UNSET = false ]
  float mBestLapTime;                               // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mLastLapTime;                               // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = 0.0f ]
  float mCurrentTime;                               // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = 0.0f ]
  float mSplitTimeAhead;                            // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mSplitTimeBehind;                           // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mSplitTime;                                 // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = 0.0f ]
  float mEventTimeRemaining;                        // [ UNITS = milli-seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mPersonalFastestLapTime;                    // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mWorldFastestLapTime;                       // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mCurrentSector1Time;                        // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mCurrentSector2Time;                        // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mCurrentSector3Time;                        // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mFastestSector1Time;                        // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mFastestSector2Time;                        // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mFastestSector3Time;                        // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mPersonalFastestSector1Time;                // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mPersonalFastestSector2Time;                // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mPersonalFastestSector3Time;                // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mWorldFastestSector1Time;                   // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mWorldFastestSector2Time;                   // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  float mWorldFastestSector3Time;                   // [ UNITS = seconds ]   [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]

  // Flags
  unsigned int mHighestFlagColour;                 // [ enum (Type#5) Flag Colour ]
  unsigned int mHighestFlagReason;                 // [ enum (Type#6) Flag Reason ]

  // Pit Info
  unsigned int mPitMode;                           // [ enum (Type#7) Pit Mode ]
  unsigned int mPitSchedule;                       // [ enum (Type#8) Pit Stop Schedule ]

  // Car State
  unsigned int mCarFlags;                          // [ enum (Type#9) Car Flags ]
  float mOilTempCelsius;                           // [ UNITS = Celsius ]   [ UNSET = 0.0f ]
  float mOilPressureKPa;                           // [ UNITS = Kilopascal ]   [ RANGE = 0.0f->... ]   [ UNSET = 0.0f ]
  float mWaterTempCelsius;                         // [ UNITS = Celsius ]   [ UNSET = 0.0f ]
  float mWaterPressureKPa;                         // [ UNITS = Kilopascal ]   [ RANGE = 0.0f->... ]   [ UNSET = 0.0f ]
  float mFuelPressureKPa;                          // [ UNITS = Kilopascal ]   [ RANGE = 0.0f->... ]   [ UNSET = 0.0f ]
  float mFuelLevel;                                // [ RANGE = 0.0f->1.0f ]
  float mFuelCapacity;                             // [ UNITS = Liters ]   [ RANGE = 0.0f->1.0f ]   [ UNSET = 0.0f ]
  float mSpeed;                                    // [ UNITS = Metres per-second ]   [ RANGE = 0.0f->... ]
  float mRpm;                                      // [ UNITS = Revolutions per minute ]   [ RANGE = 0.0f->... ]   [ UNSET = 0.0f ]
  float mMaxRPM;                                   // [ UNITS = Revolutions per minute ]   [ RANGE = 0.0f->... ]   [ UNSET = 0.0f ]
  float mBrake;                                    // [ RANGE = 0.0f->1.0f ]
  float mThrottle;                                 // [ RANGE = 0.0f->1.0f ]
  float mClutch;                                   // [ RANGE = 0.0f->1.0f ]
  float mSteering;                                 // [ RANGE = -1.0f->1.0f ]
  int mGear;                                       // [ RANGE = -1 (Reverse)  0 (Neutral)  1 (Gear 1)  2 (Gear 2)  etc... ]   [ UNSET = 0 (Neutral) ]
  int mNumGears;                                   // [ RANGE = 0->... ]   [ UNSET = -1 ]
  float mOdometerKM;                               // [ RANGE = 0.0f->... ]   [ UNSET = -1.0f ]
  bool mAntiLockActive;                            // [ UNITS = boolean ]   [ RANGE = false->true ]   [ UNSET = false ]
  int mLastOpponentCollisionIndex;                 // [ RANGE = 0->STORED_PARTICIPANTS_MAX ]   [ UNSET = -1 ]
  float mLastOpponentCollisionMagnitude;           // [ RANGE = 0.0f->... ]
  bool mBoostActive;                               // [ UNITS = boolean ]   [ RANGE = false->true ]   [ UNSET = false ]
  float mBoostAmount;                              // [ RANGE = 0.0f->100.0f ] 

  // Motion & Device Related
  float mOrientation[VEC_MAX];                     // [ UNITS = Euler Angles ]
  float mLocalVelocity[VEC_MAX];                   // [ UNITS = Metres per-second ]
  float mWorldVelocity[VEC_MAX];                   // [ UNITS = Metres per-second ]
  float mAngularVelocity[VEC_MAX];                 // [ UNITS = Radians per-second ]
  float mLocalAcceleration[VEC_MAX];               // [ UNITS = Metres per-second ]
  float mWorldAcceleration[VEC_MAX];               // [ UNITS = Metres per-second ]
  float mExtentsCentre[VEC_MAX];                   // [ UNITS = Local Space  X  Y  Z ]

  // Wheels / Tyres
  unsigned int mTyreFlags[TYRE_MAX];               // [ enum (Type#10) Tyre Flags ]
  unsigned int mTerrain[TYRE_MAX];                 // [ enum (Type#11) Terrain Materials ]
  float mTyreY[TYRE_MAX];                          // [ UNITS = Local Space  Y ]
  float mTyreRPS[TYRE_MAX];                        // [ UNITS = Revolutions per second ]
  float mTyreSlipSpeed[TYRE_MAX];                  // [ UNITS = Metres per-second ]
  float mTyreTemp[TYRE_MAX];                       // [ UNITS = Celsius ]   [ UNSET = 0.0f ]
  float mTyreGrip[TYRE_MAX];                       // [ RANGE = 0.0f->1.0f ]
  float mTyreHeightAboveGround[TYRE_MAX];          // [ UNITS = Local Space  Y ]
  float mTyreLateralStiffness[TYRE_MAX];           // [ UNITS = Lateral stiffness coefficient used in tyre deformation ]
  float mTyreWear[TYRE_MAX];                       // [ RANGE = 0.0f->1.0f ]
  float mBrakeDamage[TYRE_MAX];                    // [ RANGE = 0.0f->1.0f ]
  float mSuspensionDamage[TYRE_MAX];               // [ RANGE = 0.0f->1.0f ]
  float mBrakeTempCelsius[TYRE_MAX];               // [ UNITS = Celsius ]
  float mTyreTreadTemp[TYRE_MAX];                  // [ UNITS = Kelvin ]
  float mTyreLayerTemp[TYRE_MAX];                  // [ UNITS = Kelvin ]
  float mTyreCarcassTemp[TYRE_MAX];                // [ UNITS = Kelvin ]
  float mTyreRimTemp[TYRE_MAX];                    // [ UNITS = Kelvin ]
  float mTyreInternalAirTemp[TYRE_MAX];            // [ UNITS = Kelvin ]

  // Car Damage
  unsigned int mCrashState;                        // [ enum (Type#12) Crash Damage State ]
  float mAeroDamage;                               // [ RANGE = 0.0f->1.0f ]
  float mEngineDamage;                             // [ RANGE = 0.0f->1.0f ]

  // Weather
  float mAmbientTemperature;                       // [ UNITS = Celsius ]   [ UNSET = 25.0f ]
  float mTrackTemperature;                         // [ UNITS = Celsius ]   [ UNSET = 30.0f ]
  float mRainDensity;                              // [ UNITS = How much rain will fall ]   [ RANGE = 0.0f->1.0f ]
  float mWindSpeed;                                // [ RANGE = 0.0f->100.0f ]   [ UNSET = 2.0f ]
  float mWindDirectionX;                           // [ UNITS = Normalised Vector X ]
  float mWindDirectionY;                           // [ UNITS = Normalised Vector Y ]
  float mCloudBrightness;                          // [ RANGE = 0.0f->... ]
} SharedMemory;

#endif  // _SHARED_MEMORY_HPP_

Aber allgemein:
Wie man Probleme nachstellbar und nachvollziehbar macht
Lesen, verstehen, dann bessere Frage stellen.

In dem Programm werden Daten aus einem Spiel ausgelesen. Dabei erscheint aber erst ein paar Sekunden nach dem Ingame der Wert erscheint, die Ausgabe über die Konsole:

printf( "Flag: (%d)\n", sharedData->mHighestFlagColour );

Das liegt wahrscheinlich nicht an den Sleeps, da diese nicht so lang sind, sondern diese sind dafür da damit das Skript nicht zu überlasstend wird. An der Überlasstung liegt es nicht da das Skript nur 1 Mb RAM verbraucht.

Sorry, ich weiß nicht wirklich wodurch das Problem entsteht, deshalb habe ich den kompletten Quelltext hinzugefügt.

Dann versuch es einzukreisen! Darum habe ich dir doch den Link gegeben. Niemand durchforstet auf gut Glück tausende Zeilen Code nach einem vage spezifizierten Fehler. Ohne das zugehörige Gegenstück können wir das Programm ja nicht einmal ausprobieren!

In dem Programm werden Daten aus einem Spiel ausgelesen. Dabei erscheint aber erst ein paar Sekunden nach dem Ingame der Wert erscheint, die Ausgabe über die Konsole:

Und was ist mit der Gegenseite? Wie kommen die Daten zu deinem Programm?

So, habe soeben tausende Zeilen Code auf gut Glück nach einem vage spezifizierten Fehler durchforstet.

Bei der Zeit klingt das eher so, als wäre das ein lockerer Waldlauf gewesen

So, habe soeben tausende Zeilen Code auf gut Glück nach einem vage spezifizierten Fehler durchforstet.

Das Problem tritt auf, weil irgendwie die Main-Loop nicht schnell genug durchlaufen werden kann.

EDIT: Jetzt habe ich den Fehler! Das Problem war diese Zeile:

comm.send_data(data);

Diese wurde zu oft (sinnlos) durchlaufen und somit war der Arduino überlasstet.