move saving of tyre diameter config to when we still know the car and sim info

src/monocoque/devices/hapticeffect.c

@@ -204,51 +204,68 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
     wheelslip[2] = 0;
     wheelslip[3] = 0;
 
-    slogt("wheel vibration calculation with wheel config set to %i configchecked %i configfile %s car %s sim %i", useconfig, *configcheck, configfile, simdata->car, simdata->simexe);
-
-    switch (effecttype)
+    int sim_slip_ratio =0;
+    for (int i = 0; i < 4; i++)
     {
-        case (EFFECT_TYRESLIP):
-        case (EFFECT_TYRELOCK):
-        case (EFFECT_ABSBRAKES):
+        sim_slip_ratio = abs(simdata->tyreslipratio[i]);
+    }
+
+    if(sim_slip_ratio == 0)
+    {
+        slogt("wheel vibration calculation with wheel config set to %i configchecked %i configfile %s car %s sim %i", useconfig, *configcheck, configfile, simdata->car, simdata->simexe);
+
+        switch (effecttype)
+        {
+            case (EFFECT_TYRESLIP):
+            case (EFFECT_TYRELOCK):
+            case (EFFECT_ABSBRAKES):
 
 
-            if(hasTyreDiameter(simdata)==true)
-            {
-                double Speedms = kmhtoms * simdata->velocity;
-                slogt("attempting wheel slip calculation");
-                if (Speedms > minspeedinms)
+                if(hasTyreDiameter(simdata)==true)
                 {
-                    for(int i = 0; i < 4; i++)
+                    double Speedms = kmhtoms * simdata->velocity;
+                    slogt("attempting wheel slip calculation");
+                    if (Speedms > minspeedinms)
                     {
-                        wheelslip[i] = (Speedms - simdata->tyrediameter[i] * simdata->tyreRPS[i] / 2) / Speedms;
+                        for(int i = 0; i < 4; i++)
+                        {
+                            wheelslip[i] = (Speedms - simdata->tyrediameter[i] * simdata->tyreRPS[i] / 2) / Speedms;
+                        }
                     }
-                }
-                else
-                {
-                    for(int i = 0; i < 4; i++)
+                    else
                     {
-                        wheelslip[i] = 0;
+                        for(int i = 0; i < 4; i++)
+                        {
+                            wheelslip[i] = 0;
+                        }
                     }
+                    slogt("wheelslip values are %f %f %f %f", wheelslip[0], wheelslip[1], wheelslip[2], wheelslip[3]);
+                    slogt("velocities (x,y,z) are %f %f %f", simdata->Xvelocity, simdata->Yvelocity, simdata->Zvelocity);
                 }
-                slogt("wheelslip values are %f %f %f %f", wheelslip[0], wheelslip[1], wheelslip[2], wheelslip[3]);
-                slogt("velocities (x,y,z) are %f %f %f", simdata->Xvelocity, simdata->Yvelocity, simdata->Zvelocity);
-            }
-            break;
-        case EFFECT_SUSPENSION:
-            break;
-        default:
-            slogd("Unknown effect type");
+                break;
+            case EFFECT_SUSPENSION:
+                break;
+            default:
+                slogd("Unknown effect type");
+        }
+        if(simdata->Yvelocity <= 0)
+        {
+            return 0;
+        }
+        if(simdata->Zvelocity > 1 || simdata->Zvelocity < -1)
+        {
+            return 0;
+        }
+    }
+    else
+    {
+        for (int i = 0; i < 4; i++)
+        {
+            wheelslip[i] = simdata->tyreslipratio[i];
+        }
+        slogt("wheelslip values from sim are %f %f %f %f", wheelslip[0], wheelslip[1], wheelslip[2], wheelslip[3]);
     }
 
-    if(simdata->Yvelocity <= 0)
-    {
-        return 0;
-    }
-    if(simdata->Zvelocity > 1 || simdata->Zvelocity < -1)
-    {
-        return 0;
-    }
 
     switch (effecttype)
     {

src/monocoque/devices/serialdevice.c

@@ -219,7 +219,7 @@ int serial_wheel_free(SimDevice* this)
     return 0;
 }
 
-int serialdev_init(SerialDevice* serialdevice, DeviceSettings* ds)
+int serialdev_init(SerialDevice* serialdevice, DeviceSettings* ds, SimInfo* siminfo)
 {
     slogi("initializing serial device on port %s to %i...", ds->serialdevsettings.portdev, ds->serialdevsettings.baud);
     int error = 0;
@@ -276,7 +276,7 @@ static const vtable arduino_simwind_vtable = { &arduino_simwind_update, &seriald
 static const vtable arduino_simhaptic_vtable = { &arduino_simhaptic_update, &serialdev_free };
 static const vtable serialwheel_vtable = { &serial_wheel_update, &serial_wheel_free };
 
-SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
+SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms, SimInfo* siminfo) {
 
     SerialDevice* this = (SerialDevice*) malloc(sizeof(SerialDevice));
 
@@ -285,6 +285,7 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
     this->m.derived = this;
     this->m.vtable = &serial_simdevice_vtable;
     this->type = SERIALDEV_ARDUINO;
+    int error = 0;
 
     slogt("Attempting to configure arduino device with subtype: %i", ds->dev_subtype);
     switch (ds->dev_subtype) {
@@ -325,6 +326,10 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
             slogi("Initializing custom arduino device.");
             break;
         case (SIMDEVTYPE_SERIALHAPTIC):
+            if(siminfo->SimSupportsHapticEffects == false)
+            {
+                error = MONOCOQUE_ERROR_UNSUPPORTED_SIM_FEATURE;
+            }
             this->devicetype = ARDUINODEV__HAPTIC;
             this->m.vtable = &arduino_simhaptic_vtable;
             this->u.simhapticdata.motor1 = 0;
@@ -359,7 +364,7 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
             }
     }
 
-    if(this->devicetype == ARDUINODEV__HAPTIC)
+    if(this->devicetype == ARDUINODEV__HAPTIC && error == 0)
     {
         this->m.hapticeffect.threshold = ds->threshold;
         this->m.hapticeffect.effecttype = ds->effect_type;
@@ -370,10 +375,15 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
         this->m.hapticeffect.tyrediameterconfig = ms->tyre_diameter_config;
     }
 
-    int error = serialdev_init(this, ds);
-
-    if (error < 0)
+    if(error == 0)
     {
+        slogi("Starting serial device initialization");
+        error = serialdev_init(this, ds, siminfo);
+    }
+
+    if (error != 0)
+    {
+        slogw("Did not initialize usb device due to error code %i", error);
         free(this);
         return NULL;
     }

src/monocoque/devices/simdevice.c

@@ -24,9 +24,9 @@ int devupdate(SimDevice* this, SimData* simdata)
     return 0;
 }
 
-int devinit(SimDevice* simdevices, int numdevices, DeviceSettings* ds, MonocoqueSettings* ms)
+int devinit(SimDevice* simdevices, SimInfo* siminfo, int numdevices, DeviceSettings* ds, MonocoqueSettings* ms)
 {
-    slogi("initializing simdevices...");
+    slogi("initializing simdevices for simapi %i...", siminfo->simulatorapi);
     int devices = 0;
 
     for (int j = 0; j < numdevices; j++)
@@ -34,7 +34,7 @@ int devinit(SimDevice* simdevices, int numdevices, DeviceSettings* ds, Monocoque
         simdevices[j].initialized = false;
 
         if (ds[j].dev_type == SIMDEV_USB) {
-            USBDevice* sim = new_usb_device(&ds[j], ms);
+            USBDevice* sim = new_usb_device(&ds[j], ms, siminfo);
             if (sim != NULL)
             {
                 simdevices[j] = sim->m;
@@ -56,7 +56,7 @@ int devinit(SimDevice* simdevices, int numdevices, DeviceSettings* ds, Monocoque
             }
             else
             {
-                SoundDevice* sim = new_sound_device(&ds[j], ms);
+                SoundDevice* sim = new_sound_device(&ds[j], ms, siminfo);
                 if (sim != NULL)
                 {
 
@@ -75,7 +75,7 @@ int devinit(SimDevice* simdevices, int numdevices, DeviceSettings* ds, Monocoque
 
         if (ds[j].dev_type == SIMDEV_SERIAL) {
 
-            SerialDevice* sim = new_serial_device(&ds[j], ms);
+            SerialDevice* sim = new_serial_device(&ds[j], ms, siminfo);
             if (sim != NULL)
             {
                 simdevices[j] = sim->m;

src/monocoque/devices/simdevice.h

@@ -82,7 +82,7 @@ int arduino_simwind_update(SimDevice* this, SimData* simdata);
 int arduino_simhaptic_update(SimDevice* this, SimData* simdata);
 int serialdev_free(SimDevice* this);
 
-SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms);
+SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms, SimInfo* siminfo);
 
 /********* USB HID Devices *****/
 typedef enum
@@ -112,7 +112,7 @@ USBDevice;
 int usbdev_update(SimDevice* this, SimData* simdata);
 int usbdev_free(SimDevice* this);
 
-USBDevice* new_usb_device(DeviceSettings* ds, MonocoqueSettings* ms);
+USBDevice* new_usb_device(DeviceSettings* ds, MonocoqueSettings* ms, SimInfo* siminfo);
 
 
 /********* Sound Devices *****/
@@ -137,7 +137,7 @@ int sounddev_gearshift_update(SimDevice* this, SimData* simdata);
 int sounddev_tyreslip_update(SimDevice* this, SimData* simdata);
 int sounddev_free(SimDevice* this);
 
-SoundDevice* new_sound_device(DeviceSettings* ds, MonocoqueSettings* ms);
+SoundDevice* new_sound_device(DeviceSettings* ds, MonocoqueSettings* ms, SimInfo* siminfo);
 
 /***** Generic Methods *********/
 
@@ -145,7 +145,7 @@ int update(SimDevice* simdevice, SimData* simdata);
 
 int devupdate(SimDevice* simdevice, SimData* simdata);
 
-int devinit(SimDevice* simdevices, int numdevices, DeviceSettings* ds, MonocoqueSettings* ms);
+int devinit(SimDevice* simdevices, SimInfo* siminfo, int numdevices, DeviceSettings* ds, MonocoqueSettings* ms);
 
 int devfree(SimDevice* simdevices, int numdevices);
 

src/monocoque/devices/sounddevice.c

@@ -231,88 +231,112 @@ static const vtable tyrelock_sound_simdevice_vtable = { &sounddev_tyrelock_updat
 static const vtable absbrakes_sound_simdevice_vtable = { &sounddev_absbrakes_update, &sounddev_free };
 static const vtable suspension_sound_simdevice_vtable = { &sounddev_suspension_update, &sounddev_free };
 
-SoundDevice* new_sound_device(DeviceSettings* ds, MonocoqueSettings* ms) {
+SoundDevice* new_sound_device(DeviceSettings* ds, MonocoqueSettings* ms, SimInfo* siminfo) {
 
     SoundDevice* this = (SoundDevice*) malloc(sizeof(SoundDevice));
 
     this->m.update = &update;
     this->m.free = &simdevfree;
     this->m.derived = this;
+    int error = 0;
 
-    slogt("Attempting to configure sound device with subtype: %i", ds->effect_type);
-    switch (ds->effect_type) {
-        case (EFFECT_ENGINERPM):
-            this->m.hapticeffect.effecttype = EFFECT_ENGINERPM;
-            this->m.vtable = &engine_sound_simdevice_vtable;
-            slogi("Initializing sound device for engine vibrations.");
-            break;
-        case (EFFECT_GEARSHIFT):
-            this->m.hapticeffect.effecttype = EFFECT_GEARSHIFT;
-            this->m.vtable = &gear_sound_simdevice_vtable;
-            slogi("Initializing sound device for gear shift vibrations.");
-            break;
+    switch (ds->effect_type)
+    {
         case (EFFECT_TYRESLIP):
-            this->m.hapticeffect.effecttype = EFFECT_TYRESLIP;
-            this->m.hapticeffect.threshold = ds->threshold;
-
-            this->m.hapticeffect.threshold = ds->threshold;
-            slogt("Haptic effect: %i %i", this->m.hapticeffect.effecttype, ds->effect_type);
-            this->m.hapticeffect.tyre = ds->tyre;
-            this->m.hapticeffect.useconfig = ms->useconfig;
-            this->m.hapticeffect.configcheck = &ms->configcheck;
-            this->m.hapticeffect.tyrediameterconfig = ms->tyre_diameter_config;
-
-            this->m.vtable = &tyreslip_sound_simdevice_vtable;
-            slogi("Initializing sound device for tyre slip vibrations.");
-            break;
         case (EFFECT_TYRELOCK):
-            this->m.hapticeffect.effecttype = EFFECT_TYRELOCK;
-            this->m.hapticeffect.threshold = ds->threshold;
-
-            this->m.hapticeffect.threshold = ds->threshold;
-            slogt("Haptic effect: %i %i", this->m.hapticeffect.effecttype, ds->effect_type);
-            this->m.hapticeffect.tyre = ds->tyre;
-            this->m.hapticeffect.useconfig = ms->useconfig;
-            this->m.hapticeffect.configcheck = &ms->configcheck;
-            this->m.hapticeffect.tyrediameterconfig = ms->tyre_diameter_config;
-
-            this->m.vtable = &tyrelock_sound_simdevice_vtable;
-            slogi("Initializing sound device for tyre slip vibrations.");
-            break;
         case (EFFECT_ABSBRAKES):
-            this->m.hapticeffect.effecttype = EFFECT_ABSBRAKES;
-            this->m.hapticeffect.threshold = ds->threshold;
-
-            this->m.hapticeffect.threshold = ds->threshold;
-            slogt("Haptic effect: %i %i", this->m.hapticeffect.effecttype, ds->effect_type);
-            this->m.hapticeffect.tyre = ds->tyre;
-            this->m.hapticeffect.useconfig = ms->useconfig;
-            this->m.hapticeffect.configcheck = &ms->configcheck;
-            this->m.hapticeffect.tyrediameterconfig = ms->tyre_diameter_config;
-
-            this->m.vtable = &absbrakes_sound_simdevice_vtable;
-            slogi("Initializing sound device for abs vibrations.");
-            break;
-
         case (EFFECT_SUSPENSION):
-            this->m.hapticeffect.effecttype = EFFECT_SUSPENSION;
-            this->m.hapticeffect.threshold = ds->threshold;
-
-            this->m.hapticeffect.threshold = ds->threshold;
-            slogt("Haptic effect: %i %i on tyre %i", this->m.hapticeffect.effecttype, ds->effect_type, ds->tyre);
-            this->m.hapticeffect.tyre = ds->tyre;
-            this->m.hapticeffect.useconfig = ms->useconfig;
-            this->m.hapticeffect.configcheck = &ms->configcheck;
-            this->m.hapticeffect.tyrediameterconfig = ms->tyre_diameter_config;
-
-            this->m.vtable = &suspension_sound_simdevice_vtable;
-            slogi("Initializing sound device for suspension vibrations.");
-            break;
+            if(siminfo->SimSupportsHapticEffects == false)
+            {
+                slogw("Skipping sound effect setup because sim does not support haptic effects");
+                error = MONOCOQUE_ERROR_UNSUPPORTED_SIM_FEATURE;
+            }
+        defaut:
+            error = 0;
     }
 
-    slogt("Attempting to use sound device %s", ds->sounddevsettings.dev);
 
-    int error = sounddev_init(this, ds->sounddevsettings.dev, ds->tyre, ds->sounddevsettings);
+    if(error == 0)
+    {
+        slogt("Attempting to configure sound device with subtype: %i", ds->effect_type);
+        switch (ds->effect_type)
+        {
+            case (EFFECT_ENGINERPM):
+                this->m.hapticeffect.effecttype = EFFECT_ENGINERPM;
+                this->m.vtable = &engine_sound_simdevice_vtable;
+                slogi("Initializing sound device for engine vibrations.");
+                break;
+            case (EFFECT_GEARSHIFT):
+                this->m.hapticeffect.effecttype = EFFECT_GEARSHIFT;
+                this->m.vtable = &gear_sound_simdevice_vtable;
+                slogi("Initializing sound device for gear shift vibrations.");
+                break;
+            case (EFFECT_TYRESLIP):
+                this->m.hapticeffect.effecttype = EFFECT_TYRESLIP;
+                this->m.hapticeffect.threshold = ds->threshold;
+
+                this->m.hapticeffect.threshold = ds->threshold;
+                slogt("Haptic effect: %i %i", this->m.hapticeffect.effecttype, ds->effect_type);
+                this->m.hapticeffect.tyre = ds->tyre;
+                this->m.hapticeffect.useconfig = ms->useconfig;
+                this->m.hapticeffect.configcheck = &ms->configcheck;
+                this->m.hapticeffect.tyrediameterconfig = ms->tyre_diameter_config;
+
+                this->m.vtable = &tyreslip_sound_simdevice_vtable;
+                slogi("Initializing sound device for tyre slip vibrations.");
+                break;
+            case (EFFECT_TYRELOCK):
+                this->m.hapticeffect.effecttype = EFFECT_TYRELOCK;
+                this->m.hapticeffect.threshold = ds->threshold;
+
+                this->m.hapticeffect.threshold = ds->threshold;
+                slogt("Haptic effect: %i %i", this->m.hapticeffect.effecttype, ds->effect_type);
+                this->m.hapticeffect.tyre = ds->tyre;
+                this->m.hapticeffect.useconfig = ms->useconfig;
+                this->m.hapticeffect.configcheck = &ms->configcheck;
+                this->m.hapticeffect.tyrediameterconfig = ms->tyre_diameter_config;
+
+                this->m.vtable = &tyrelock_sound_simdevice_vtable;
+                slogi("Initializing sound device for tyre slip vibrations.");
+                break;
+            case (EFFECT_ABSBRAKES):
+                this->m.hapticeffect.effecttype = EFFECT_ABSBRAKES;
+                this->m.hapticeffect.threshold = ds->threshold;
+
+                this->m.hapticeffect.threshold = ds->threshold;
+                slogt("Haptic effect: %i %i", this->m.hapticeffect.effecttype, ds->effect_type);
+                this->m.hapticeffect.tyre = ds->tyre;
+                this->m.hapticeffect.useconfig = ms->useconfig;
+                this->m.hapticeffect.configcheck = &ms->configcheck;
+                this->m.hapticeffect.tyrediameterconfig = ms->tyre_diameter_config;
+
+                this->m.vtable = &absbrakes_sound_simdevice_vtable;
+                slogi("Initializing sound device for abs vibrations.");
+                break;
+
+            case (EFFECT_SUSPENSION):
+                this->m.hapticeffect.effecttype = EFFECT_SUSPENSION;
+                this->m.hapticeffect.threshold = ds->threshold;
+
+                this->m.hapticeffect.threshold = ds->threshold;
+                slogt("Haptic effect: %i %i on tyre %i", this->m.hapticeffect.effecttype, ds->effect_type, ds->tyre);
+                this->m.hapticeffect.tyre = ds->tyre;
+                this->m.hapticeffect.useconfig = ms->useconfig;
+                this->m.hapticeffect.configcheck = &ms->configcheck;
+                this->m.hapticeffect.tyrediameterconfig = ms->tyre_diameter_config;
+
+                this->m.vtable = &suspension_sound_simdevice_vtable;
+                slogi("Initializing sound device for suspension vibrations.");
+                break;
+        }
+    }
+
+    if(error == 0)
+    {
+        slogt("Attempting to use sound device %s", ds->sounddevsettings.dev);
+        error = sounddev_init(this, ds->sounddevsettings.dev, ds->tyre, ds->sounddevsettings);
+    }
+
     if (error != 0)
     {
         free(this);

src/monocoque/devices/usbdevice.c

@@ -54,7 +54,7 @@ int usbdev_free(SimDevice* this)
     return 0;
 }
 
-int usbdev_init(USBDevice* usbdevice, DeviceSettings* ds)
+int usbdev_init(USBDevice* usbdevice, DeviceSettings* ds, SimInfo* siminfo)
 {
     slogi("initializing usb device...");
     int error = 0;
@@ -70,7 +70,7 @@ int usbdev_init(USBDevice* usbdevice, DeviceSettings* ds)
             error = wheeldev_init(usbdevice, ds);
             break;
         case USBDEV_GENERICHAPTIC :
-            error = usbhapticdev_init(&usbdevice->u.hapticdevice, ds);
+            error = usbhapticdev_init(&usbdevice->u.hapticdevice, ds, siminfo);
             break;
     }
 
@@ -79,7 +79,7 @@ int usbdev_init(USBDevice* usbdevice, DeviceSettings* ds)
 
 static const vtable usb_simdevice_vtable = { &usbdev_update, &usbdev_free };
 
-USBDevice* new_usb_device(DeviceSettings* ds, MonocoqueSettings* ms) {
+USBDevice* new_usb_device(DeviceSettings* ds, MonocoqueSettings* ms, SimInfo* siminfo) {
 
     USBDevice* this = (USBDevice*) malloc(sizeof(USBDevice));
 
@@ -112,10 +112,11 @@ USBDevice* new_usb_device(DeviceSettings* ds, MonocoqueSettings* ms) {
         this->type = USBDEV_GENERICHAPTIC;
     }
 
-    int error = usbdev_init(this, ds);
+    int error = usbdev_init(this, ds, siminfo);
 
     if (error != 0)
     {
+        slogw("Did not initialize usb device due to error code %i", error);
         free(this);
         return NULL;
     }

src/monocoque/devices/usbhapticdevice.c

@@ -67,8 +67,14 @@ int usbhapticdev_free(USBGenericHapticDevice* usbhapticdevice)
     return 0;
 }
 
-int usbhapticdev_init(USBGenericHapticDevice* usbhapticdevice, DeviceSettings* ds)
+int usbhapticdev_init(USBGenericHapticDevice* usbhapticdevice, DeviceSettings* ds, SimInfo* siminfo)
 {
+    if(siminfo->SimSupportsHapticEffects == false)
+    {
+        slogi("This sim does not support haptic effects");
+        return MONOCOQUE_ERROR_UNSUPPORTED_SIM_FEATURE;
+    }
+
     int error = 0;
     usbhapticdevice->state = 0;
     usbhapticdevice->value0 = ds->usbdevsettings.value0;

src/monocoque/devices/usbhapticdevice.h

@@ -31,7 +31,7 @@ USBGenericHapticDevice;
 
 
 int usbhapticdev_update(USBGenericHapticDevice* hapticdevice, SimData* simdata, int tyre, int useconfig, int* configcheck, char* configfile);
-int usbhapticdev_init(USBGenericHapticDevice* hapticdevice, DeviceSettings* ds);
+int usbhapticdev_init(USBGenericHapticDevice* hapticdevice, DeviceSettings* ds, SimInfo* siminfo);
 int usbhapticdev_free(USBGenericHapticDevice* hapticdevice);
 
 #endif

src/monocoque/gameloop/gameloop.c

@@ -29,6 +29,7 @@ uv_idle_t idler;
 uv_timer_t datachecktimer;
 uv_timer_t showstatstimer;
 uv_timer_t datamaptimer;
+uv_timer_t tyrediametertimer;
 uv_udp_t recv_socket;
 
 bool doui = false;
@@ -37,6 +38,7 @@ int appstate = 0;
 void shmdatamapcallback(uv_timer_t* handle);
 void showstatscallback(uv_timer_t* handle);
 void datacheckcallback(uv_timer_t* handle);
+void tyrediametercheckcallback(uv_timer_t* handle);
 void startdatalogger(MonocoqueSettings* ms, loop_data* l);
 
 static void close_walk_cb(uv_handle_t* handle, void* arg)
@@ -225,26 +227,67 @@ void devicetimercallback(uv_timer_t* handle)
     SimData* simdata = f->simdata;
     SimDevice* device = f->simdevice;
     device->update(device, simdata);
+}
+
+
+void tyrediametercheckcallback(uv_timer_t* handle)
+{
+    void* b = uv_handle_get_data((uv_handle_t*) handle);
+    device_loop_data* f = (device_loop_data*) b;
+    SimData* simdata = f->simdata;
+
+    if(simdata->car != NULL || simdata->car[0] != 0)
+    {
+        slogi("car is %s", simdata->car);
+        // check for saved tyre diameter in config file
+        // if not saved version exists get tyre diameter and save it
+        // use config check variable to track if the config check has been performed
+        // avoid many opens of the same file
+        int error = 0;
+        if(hasTyreDiameter(simdata)==false && f->ms->configcheck == 0)
+        {
+            slogi("attempting load of tyre diameter config");
+            error = loadtyreconfig(simdata, f->ms->tyre_diameter_config, true);
+            f->ms->configcheck = 1;
+        }
+
+        if(hasTyreDiameter(simdata)==false)
+        {
+            slogt("could not find tyre diameter in config file, attempting to calculate new");
+            getTyreDiameter(simdata);
+            // if this successfully calculates data the diameters will be saved to the file after the
+            // sim stops actively mapping data
+        }
+    }
+    if(hasTyreDiameter(simdata)==true)
+    {
+        int a = loadtyreconfig(simdata, f->ms->tyre_diameter_config, false);
+        if(a < 0)
+        {
+            slogi("saving new tyre diameter config for car %s");
+            savetyreconfig(simdata, f->ms->tyre_diameter_config);
+        }
+        uv_timer_stop(handle);
+    }
 
 }
 
 void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
 {
-
     if (doui == true)
     {
-        slogi("looking for ui config %s pass 1", ms->config_str);
-        int confignum = getconfigtouse2(ms->config_str, simdata->car, f->sim);
+        slogi("looking for ui config %s pass 1 simapi %i", ms->config_str, f->siminfo.simulatorapi);
+        int confignum = getconfigtouse2(ms->config_str, simdata->car, f->siminfo.simulatorapi);
         slogi("first pass finished");
         if(confignum == -1)
         {
             slogi("looking for ui config %s pass 2", ms->config_str);
-            confignum = getconfigtouse1(ms->config_str, simdata->car, f->sim);
+            confignum = getconfigtouse1(ms->config_str, simdata->car, f->siminfo.simulatorapi);
         }
         if(confignum == -1)
         {
             slogi("looking for ui config %s pass 3", ms->config_str);
-            confignum = getconfigtouse(ms->config_str, simdata->car, f->sim);
+            confignum = getconfigtouse(ms->config_str, simdata->car, f->siminfo.simulatorapi);
         }
 
         int configureddevices;
@@ -259,7 +302,8 @@ void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
         }
 
         f->simdevices = malloc(f->numdevices * sizeof(SimDevice));
-        int initdevices = devinit(f->simdevices, configureddevices, ds, ms);
+        int initdevices = devinit(f->simdevices, &f->siminfo, configureddevices, ds, ms);
+        slogi("initialized %i devices", initdevices);
 
         for( int i = 0; i < configureddevices; i++)
         {
@@ -271,6 +315,7 @@ void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
         SimDevice* devices = f->simdevices;
         f->device_timers = (uv_timer_t*) (malloc(uv_handle_size(UV_TIMER) * numdevices));
         f->device_batons = (device_loop_data*) (malloc(sizeof(device_loop_data) * numdevices));
+        f->started_tyre_calc_thread = false;
 
         for (int x = 0; x < numdevices; x++)
         {
@@ -285,10 +330,26 @@ void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
                 int interval = 1000/devices[x].fps;
                 uv_timer_start(dt, devicetimercallback, 0, interval);
                 slogi("starting device type %i at id at %i fps: %i (%i ms ticks)", devices[x].type, x, devices[x].fps, interval);
-            }
-            else
-            {
-                slogw("skipped id %i", x);
+               
+                SimInfo siminfo = f->siminfo;
+                if(f->started_tyre_calc_thread == false)
+                {
+                        if(devices[x].hapticeffect.effecttype == EFFECT_TYRELOCK || devices[x].hapticeffect.effecttype == EFFECT_TYRESLIP || devices[x].hapticeffect.effecttype == EFFECT_ABSBRAKES)
+                        {
+                            if(siminfo.SimCalculatesTyreDiameter == false && siminfo.SimSupportsHapticEffects == true && siminfo.SimCalculatesSlipRatio == false && f->ms->useconfig == 1 && f->ms->tyre_diameter_config != NULL)
+                            {
+                                slogi("Starting thread to calculate tyre diameters and save to config file");
+                                f->started_tyre_calc_thread = true;
+
+                                f->tyrebaton = (device_loop_data*) malloc(sizeof(device_loop_data));
+                                f->tyrebaton->simdata = simdata;
+                                f->tyrebaton->ms = f->ms;
+
+                                uv_handle_set_data((uv_handle_t*) &tyrediametertimer, (void*) f->tyrebaton);
+                                uv_timer_start(&tyrediametertimer, tyrediametercheckcallback, 0, 1000);
+                            }
+                        }
+                }
             }
         }
 
@@ -296,43 +357,6 @@ void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
         uv_timer_start(&showstatstimer, showstatscallback, 0, 100);
         doui = false;
     }
-    else
-    {
-        //showstats(simdata);
-        //SimDevice* devices = f->simdevices;
-        //int numdevices = f->numdevices;
-        //for (int x = 0; x < numdevices; x++)
-        //{
-        //    if (devices[x].initialized == true && devices[x].type == 2)
-        //    {
-        //        devices[x].update(&devices[x], simdata);
-        //    }
-        //}
-
-        if(f->ms->useconfig == 1 && f->ms->tyre_diameter_config != NULL)
-        {
-            if(simdata->car != NULL || simdata->car[0] != 0)
-            {
-                // check for saved tyre diameter in config file
-                // if not saved version exists get tyre diameter and save it
-                // use config check variable to track if the config check has been performed
-                // avoid many opens of the same file
-                int error = 0;
-                if(hasTyreDiameter(simdata)==false && f->ms->configcheck == 0)
-                {
-                    slogi("attempting load of tyre diameter config");
-                    error = loadtyreconfig(simdata, f->ms->tyre_diameter_config, true);
-                    f->ms->configcheck = 1;
-                }
-
-                if(hasTyreDiameter(simdata)==false)
-                {
-                    slogt("could not find tyre diameter in config file, attempting to calculate new");
-                    getTyreDiameter(simdata);
-                }
-            }
-        }
-    }
 }
 
 void showstatscallback(uv_timer_t* handle)
@@ -364,16 +388,12 @@ void releaseloop(loop_data* f, SimData* simdata, SimMap* simmap)
             //    uv_close((uv_handle_t*)&recv_socket, NULL);
             //}
             slogi("releasing devices, please wait");
-            
+
             //attempt tyre diameter saving
-            if(hasTyreDiameter(simdata) == true)
+            uv_timer_stop(&tyrediametertimer);
+            if(f->started_tyre_calc_thread == true)
             {
-                int a = loadtyreconfig(simdata, f->ms->tyre_diameter_config, false);
-                if(a < 0)
-                {
-                    slogi("saving new tyre diameter config");
-                    savetyreconfig(simdata, f->ms->tyre_diameter_config);
-                }
+                free(f->tyrebaton);
             }
 
             f->uion = false;
@@ -446,11 +466,11 @@ void shmdatamapcallback(uv_timer_t* handle)
     //appstate = 2;
     if (appstate == 2)
     {
-        simapi_datamap(simdata, simmap, f->map, false, NULL);
+        simapi_datamap(simdata, simmap, f->siminfo.mapapi, false, NULL);
         looprun(ms, f, simdata);
     }
 
-    if (f->simstate == false || simdata->simstatus <= 1 || appstate <= 1)
+    if (f->siminfo.isSimOn == false || simdata->simstatus <= 1 || appstate <= 1)
     {
         releaseloop(f, simdata, simmap);
     }
@@ -483,11 +503,11 @@ static void on_udp_recv(uv_udp_t* handle, ssize_t nread, const uv_buf_t* rcvbuf,
 
     if (appstate == 2)
     {
-        simapi_datamap(simdata, simmap, f->map, true, a);
+        simapi_datamap(simdata, simmap, f->siminfo.mapapi, true, a);
         looprun(ms, f, simdata);
     }
 
-    if (f->simstate == false || simdata->simstatus <= 1 || appstate <= 1)
+    if (f->siminfo.isSimOn == false || simdata->simstatus <= 1 || appstate <= 1)
     {
         releaseloop(f, simdata, simmap);
     }
@@ -498,7 +518,7 @@ static void on_udp_recv(uv_udp_t* handle, ssize_t nread, const uv_buf_t* rcvbuf,
 
 int startudp(int port)
 {
-    uv_udp_init(uv_default_loop(), &recv_socket);
+
     struct sockaddr_in recv_addr;
     uv_ip4_addr("0.0.0.0", port, &recv_addr);
     int err = uv_udp_bind(&recv_socket, (const struct sockaddr *) &recv_addr, UV_UDP_REUSEADDR);
@@ -511,7 +531,7 @@ void udpstart(MonocoqueSettings* sms, loop_data* f, SimData* simdata, SimMap* si
 {
     if (appstate == 2)
     {
-        simapi_datamap(simdata, simmap, f->sim, true, NULL);
+        simapi_datamap(simdata, simmap, f->siminfo.simulatorapi, true, NULL);
         if (doui == true)
         {
             looprun(sms, f, simdata);
@@ -528,19 +548,14 @@ void datacheckcallback(uv_timer_t* handle)
 
     if ( appstate == 1 )
     {
-        SimInfo si = simapi_get_sim(simdata, simmap, f->ms->force_udp_mode, startudp, false);
-        //TODO: move all this to a siminfo struct in loop_data
-        f->simstate = si.isSimOn;
-        f->sim = si.simulatorapi;
-        f->map = si.mapapi;
-        f->use_udp = si.SimUsesUDP;
+        f->siminfo = simapi_get_sim(simdata, simmap, f->ms->force_udp_mode, startudp, false);
 
         if(f->ms->force_udp_mode == true)
         {
             f->use_udp = true;
         }
     }
-    if (f->simstate == true && simdata->simstatus >= 2)
+    if (f->siminfo.isSimOn == true && simdata->simstatus >= 2)
     {
         if ( appstate == 1 )
         {
@@ -551,13 +566,12 @@ void datacheckcallback(uv_timer_t* handle)
             simdata->tyrediameter[2] = -1;
             simdata->tyrediameter[3] = -1;
 
-            if(f->use_udp == true)
+            if(f->use_udp == true || f->siminfo.SimUsesUDP == true)
             {
                 slogt("starting udp receive loop");
                 udpstart(f->ms, f, simdata, simmap);
                 uv_udp_recv_start(&recv_socket, on_alloc, on_udp_recv);
                 slogt("udp receive loop started");
-                uv_timer_stop(handle);
             }
             else
             {
@@ -565,12 +579,11 @@ void datacheckcallback(uv_timer_t* handle)
                 slogd("starting telemetry mapping at %i fps (%i ms ticks)", f->ms->fps, interval);
                 uv_timer_start(&datamaptimer, shmdatamapcallback, 2000, interval);
             }
-            //uv_timer_start(&datachecktimer, datacheckcallback, 0, 3000);
         }
         if(appstate == 2)
         {
-            SimInfo si = simapi_get_sim(simdata, simmap, f->ms->force_udp_mode, NULL, false);
-            if(si.isSimOn == false)
+            f->siminfo = simapi_get_sim(simdata, simmap, f->ms->force_udp_mode, NULL, false);
+            if(f->siminfo.isSimOn == false)
             {
                 appstate = 1;
                 releaseloop(f, simdata, simmap);
@@ -638,10 +651,9 @@ int monocoque_mainloop(MonocoqueSettings* ms)
     baton->simmap = simmap;
     baton->simdata = simdata;
     baton->ms = ms;
-    baton->simstate = false;
     baton->uion = false;
     baton->releasing = false;
-    baton->sim = 0;
+    baton->use_udp = false;
     baton->req.data = (void*) baton;
 
     simapi_set_log_info(simapilib_loginfo);
@@ -652,9 +664,12 @@ int monocoque_mainloop(MonocoqueSettings* ms)
     {
         return 1;
     };
+    
+    uv_udp_init(uv_default_loop(), &recv_socket);
     uv_timer_init(uv_default_loop(), &datachecktimer);
     uv_timer_init(uv_default_loop(), &showstatstimer);
     uv_timer_init(uv_default_loop(), &datamaptimer);
+    uv_timer_init(uv_default_loop(), &tyrediametertimer);
     slogd("setting initial app state");
     appstate = 1;
 
@@ -686,6 +701,7 @@ int monocoque_mainloop(MonocoqueSettings* ms)
 
     free(baton);
     free(simdata);
+    free(simmap);
 
     return 0;
 }
@@ -728,7 +744,7 @@ int tester(SimDevice* devices, int numdevices)
     sleep(1);
 
     fprintf(stdout, "Revving rpm from 1000 to 8000 and back\n");
-
+    // TODO: look into this, my serial leds make this hang
     for (int r = 0; r < 8000; r += 3)
     {
         simdata->rpms = 1000 + r;

src/monocoque/gameloop/loopdata.h

@@ -10,27 +10,33 @@
 
 typedef struct device_loop_data
 {
+    // these are all pointers to pointers and freed independently, usually in releaseloop
     uv_work_t req;
     SimData* simdata;
     SimDevice* simdevice;
+    MonocoqueSettings* ms;
+    SimInfo siminfo;
 } device_loop_data;
 
 typedef struct loop_data
 {
     uv_work_t req;
-    SimulatorAPI sim;
-    SimulatorAPI map;
     bool use_udp;
-    bool simstate;
     bool uion;
     bool releasing;
+    bool started_tyre_calc_thread;
     int numdevices;
+    SimInfo siminfo;
+    // monocoque settings is a pointer from monocoque.c and freed there
     MonocoqueSettings* ms;
+    // these are freed at the end of the main gameloop
     SimData* simdata;
     SimMap* simmap;
+    // these all get malloced in looprun and freed in releaseloop
     SimDevice* simdevices;
     uv_timer_t* device_timers;
     device_loop_data* device_batons;
+    device_loop_data* tyrebaton;
 } loop_data;
 
 

src/monocoque/helper/confighelper.h

@@ -109,12 +109,13 @@ MonocoqueGear;
 
 typedef enum
 {
-    MONOCOQUE_ERROR_NONE          = 0,
-    MONOCOQUE_ERROR_UNKNOWN       = 1,
-    MONOCOQUE_ERROR_INVALID_SIM   = 2,
-    MONOCOQUE_ERROR_INVALID_DEV   = 3,
-    MONOCOQUE_ERROR_NODATA        = 4,
-    MONOCOQUE_ERROR_UNKNOWN_DEV   = 5
+    MONOCOQUE_ERROR_NONE                     = 0,
+    MONOCOQUE_ERROR_UNKNOWN                  = 1,
+    MONOCOQUE_ERROR_INVALID_SIM              = 2,
+    MONOCOQUE_ERROR_INVALID_DEV              = 3,
+    MONOCOQUE_ERROR_NODATA                   = 4,
+    MONOCOQUE_ERROR_UNKNOWN_DEV              = 5,
+    MONOCOQUE_ERROR_UNSUPPORTED_SIM_FEATURE  = 6,
 }
 MonocoqueError;
 

src/monocoque/monocoque.c

@@ -193,6 +193,8 @@ int main(int argc, char** argv)
         SimDevice* tachdev = malloc(sizeof(SimDevice));
         tachdev->initialized = false;
         SimData* sdata = malloc(sizeof(SimData));
+        SimInfo* siminfo = malloc(sizeof(SimInfo));
+        simapi_set_faux_siminfo(siminfo);
         DeviceSettings* ds = malloc(sizeof(DeviceSettings));
 
         error = devsetup("USB", "Tachometer", "None", ms, ds, NULL);
@@ -205,7 +207,7 @@ int main(int argc, char** argv)
         {
             int devices = 0;
 
-            devices = devinit(tachdev, 1, ds, ms);
+            devices = devinit(tachdev, siminfo, 1, ds, ms);
             if(devices < 1)
             {
                 error = MONOCOQUE_ERROR_INVALID_DEV;
@@ -288,7 +290,9 @@ int main(int argc, char** argv)
 
             int numdevices = uiloadconfig(ms->config_str, confignum, configureddevices, ms, ds);
             SimDevice* simdevices = malloc(numdevices * sizeof(SimDevice));
-            int initdevices = devinit(simdevices, configureddevices, ds, ms);
+            SimInfo* siminfo = malloc(sizeof(SimInfo));
+            simapi_set_faux_siminfo(siminfo);
+            int initdevices = devinit(simdevices, siminfo, configureddevices, ds, ms);
             for( int i = 0; i < configureddevices; i++)
             {
                 settingsfree(ds[i]);