Refactor to provide siminfo to help decide if and how a device can be initialize

- Change curr_frequency from uint32_t to double for precise frequency
  control
- Remove get_closest_frequency() and change phase calculation in engine
  sound to ensure continuous sine curve
- Add RPM revving test

.github/workflows/ci.yaml

@@ -2,20 +2,21 @@ name: Make Packages
 
 on:
   push:
-    branches: [ "master" ]
     tags: [ "*" ]
-  pull_request:
-    branches: [ "master" ]
 
 jobs:
-  build-monocoque:
-    runs-on: ubuntu-latest
+  build-monocoque-debs:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, debian-latest, debian-stable]
+    runs-on: ${{ matrix.os }}
+
 
     permissions:
       contents: write
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v1
     - name: Checkout submodules
       run: git submodule update --init --recursive
     - name: Update apt
@@ -46,11 +47,35 @@ jobs:
         mkdir PKG_SOURCE
         mkdir -p PKG_SOURCE/DEBIAN
         mkdir -p PKG_SOURCE/usr/bin/
-        cp ./tools/distro/debian/dpkg/control ./PKG_SOURCE/DEBIAN/control
+        cp ./tools/distro/debian/dpkg/${{ matrix.os }}/control ./PKG_SOURCE/DEBIAN/control
         cp ./build/monocoque ./PKG_SOURCE/usr/bin/monocoque
-        dpkg-deb --build PKG_SOURCE monocoque.deb
+        dpkg-deb --build PKG_SOURCE monocoque-${{ matrix.os }}.deb
 
     - name: Release the Package
       uses: softprops/action-gh-release@v1
       with:
-        files: monoocoque.deb
+        files: monocoque-${{ matrix.os }}.deb
+
+
+  build-monocoque-rpms:
+    strategy:
+      matrix:
+        os: [fedora-43]
+    runs-on: ${{ matrix.os }}
+    permissions:
+      contents: write
+    steps:
+
+    - name: create rpmbuild dirs
+      run: mkdir -p ~/rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
+    - name: get spec file
+      run: curl -o ~/fedora.spec https://raw.githubusercontent.com/Spacefreak18/monocoque/refs/heads/master/tools/distro/fedora/rpm/fedora.spec
+    - name: run spec file
+      run: rpmbuild -ba ~/fedora.spec
+    - name: rename file
+      run: cp ~/rpmbuild/RPMS/x86_64/monocoque-0.0.5-1.x86_64.rpm $GITHUB_WORKSPACE/monocoque-${{ matrix.os }}.rpm
+    - name: Release the Package
+      uses: softprops/action-gh-release@v1
+      with:
+        files: monocoque-${{ matrix.os }}.rpm
+

README.md

@@ -21,6 +21,10 @@ Cross Platform device manager for driving and flight simulators, for use with co
 - Convincing shaker effects for noise tranducers for wheel slip, wheel lock, and abs, as well as engine rpm and gear shifts.
 - Support for many [wheels and pedals](https://spacefreak18.github.io/simapi/thirdpartydevices) including Clubsport Elite V3, [Logitech G29](https://spacefreak18.github.io/simapi/logitechg29), and Moza R5.
 
+## Adding More Devices
+- If a device isn't already supported, feel free to assist in the reverse engineering process by submitting a pcap or even better working code in a pull request!
+https://santeri.pikarinen.com/pages/usb_hid_reverse_engineering/
+
 ## Quick Install
 
 **One-Line Installation:**

conf/monocoque.config

@@ -26,6 +26,7 @@ configs = (
             modulation   = "frequency";
             frequency    = 17;
             frequencyMax = 37;
+            noise        = 10; // additive noise in Hz
         },
         {
             device       = "Sound";

src/monocoque/devices/hapticeffect.c

@@ -30,11 +30,11 @@ bool hasTyreDiameter(SimData* simdata)
     return true;
 }
 
-int loadtyreconfig(SimData* simdata, char* configfile)
+int loadtyreconfig(SimData* simdata, char* configfile, bool setDiameters)
 {
     config_t cfg;
     config_init(&cfg);
-    config_setting_t* config_cars = NULL;
+    const config_setting_t* config_cars = NULL;
 
     if (!config_read_file(&cfg, configfile))
     {
@@ -53,8 +53,9 @@ int loadtyreconfig(SimData* simdata, char* configfile)
     }
     slogt("parsing diameters config file");
 
-    int cars = config_setting_length(config_cars);
+    const int cars = config_setting_length(config_cars);
 
+    bool foundCar = false;
     int i = 0;
     while (i<cars)
     {
@@ -94,10 +95,15 @@ int loadtyreconfig(SimData* simdata, char* configfile)
                     if (strcicmp(car, simdata->car) == 0 && sim == simdata->simexe)
                     {
                         slogi("found saved car %s with tyre diameters %f %f %f %f", car, tyre0, tyre1, tyre2, tyre3);
-                        simdata->tyrediameter[0] = tyre0;
-                        simdata->tyrediameter[1] = tyre1;
-                        simdata->tyrediameter[2] = tyre2;
-                        simdata->tyrediameter[3] = tyre3;
+                        foundCar = true;
+                        if(setDiameters == true)
+                        {
+                            simdata->tyrediameter[0] = tyre0;
+                            simdata->tyrediameter[1] = tyre1;
+                            simdata->tyrediameter[2] = tyre2;
+                            simdata->tyrediameter[3] = tyre3;
+
+                        }
                         break;
                     }
                 }
@@ -113,7 +119,11 @@ int loadtyreconfig(SimData* simdata, char* configfile)
 
     config_destroy(&cfg);
 
-    return 0;
+    if(foundCar == true)
+    {
+        return i;
+    }
+    return -1;
 }
 
 int savetyreconfig(SimData* simdata, char* configfile)
@@ -194,11 +204,6 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
     wheelslip[2] = 0;
     wheelslip[3] = 0;
 
-    if(simdata->car == NULL || simdata->car[0] == 0)
-    {
-        useconfig = 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)
@@ -207,31 +212,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
         case (EFFECT_TYRELOCK):
         case (EFFECT_ABSBRAKES):
 
-            if(useconfig == 1 && configfile != NULL)
-            {
-                // 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 && *configcheck == 0)
-                {
-                    slogi("attempting load of tyre diameter config");
-                    error = loadtyreconfig(simdata, configfile);
-                    *configcheck = 1;
-                }
 
-                if(hasTyreDiameter(simdata)==false)
-                {
-                    slogt("could not find tyre diameter in config file, attempting to calculate new");
-                    getTyreDiameter(simdata);
-                    if(hasTyreDiameter(simdata)==true)
-                    {
-                        slogi("saving tyre config");
-                        error = savetyreconfig(simdata, configfile);
-                    }
-                }
-            }
             if(hasTyreDiameter(simdata)==true)
             {
                 double Speedms = kmhtoms * simdata->velocity;

src/monocoque/devices/hapticeffect.h

@@ -17,5 +17,9 @@ typedef struct
 HapticEffect;
 
 double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold, int useconfig, int* configcheck, char* configfile);
+bool hasTyreDiameter(SimData* simdata);
+int loadtyreconfig(SimData* simdata, char* configfile, bool setDiameters);
+int savetyreconfig(SimData* simdata, char* configfile);
+void getTyreDiameter(SimData* simdata);
 
 #endif

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/sound.c

@@ -19,10 +19,8 @@ int setupsound()
     slogi("connecting pulseaudio...");
     // Get a mainloop and its context
     mainloop = pa_threaded_mainloop_new();
-    assert(mainloop);
     mainloop_api = pa_threaded_mainloop_get_api(mainloop);
     context = pa_context_new(mainloop_api, "Monocoque");
-    assert(context);
 
     pa_context_set_state_callback(context, &context_state_cb, mainloop);
 
@@ -30,13 +28,12 @@ int setupsound()
     pa_threaded_mainloop_lock(mainloop);
 
     // Start the mainloop
-    assert(pa_threaded_mainloop_start(mainloop) == 0);
-    assert(pa_context_connect(context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) == 0);
+    pa_threaded_mainloop_start(mainloop);
+    pa_context_connect(context, NULL, 0, NULL);
 
     // Wait for the context to be ready
     for(;;) {
         pa_context_state_t context_state = pa_context_get_state(context);
-        assert(PA_CONTEXT_IS_GOOD(context_state));
         if (context_state == PA_CONTEXT_READY) break;
         pa_threaded_mainloop_wait(mainloop);
     }

src/monocoque/devices/sound/usb_generic_shaker.c

@@ -80,7 +80,7 @@ int patestCallbackGearShift(const void*                     inputBuffer,
         data->curr_duration += 1.0 / SAMPLE_RATE;
         if (data->curr_duration >= data->duration) {
             data->curr_duration = 0.0;
-            data->curr_frequency = 0;
+            data->curr_frequency = 0.0;
         }
 
         *out++ = sample;

src/monocoque/devices/sound/usb_generic_shaker_pulse.c

@@ -16,6 +16,15 @@
 #define M_PI  (3.14159265)
 #endif
 
+static double apply_noise(double base_freq, double noise_amount) {
+    if (noise_amount > 0.0) {
+        double r = (double) rand() / RAND_MAX * 2.0 - 1.0;
+        return base_freq + r * noise_amount;
+    } else {
+        return base_freq;
+    }
+}
+
 void gear_sound_stream(pa_stream *s, size_t length, void *userdata) {
 
     SoundData* data = (SoundData*)userdata;
@@ -24,59 +33,75 @@ void gear_sound_stream(pa_stream *s, size_t length, void *userdata) {
 
 
     for (size_t i = 0; i < num_samples; i++) {
-        static double t = 0.0;
-        double sample = 0;
-        if (data->frequency>0)
-        {
-            sample = ((double)data->curr_amplitude/100) * 32767.0 * sin(2.0 * M_PI * data->curr_frequency * data->curr_duration);
-        }
 
+        double sample = 0;
+
+        if (data->curr_frequency>0.0)
+        {
+            double t = data->phase;
+            double a = (double)data->curr_amplitude/100;
+
+            // fade-out 5ms to prevent discontinuity
+            static double fade_out_duration = 0.005;
+
+            double remaining = data->duration - data->curr_duration;
+            if (remaining < fade_out_duration) {
+                a *= remaining / fade_out_duration;
+            }
+
+            sample = a * 32767.0 * sin(2.0 * M_PI * t);
+
+            double f = apply_noise(data->curr_frequency, data->noise);
+
+            t += f / SAMPLE_RATE;
+            if (t >= 1.0) {
+                t -= floor(t);
+            }
+
+            data->phase = t;
+
+            data->curr_duration += 1.0 / SAMPLE_RATE;
+            if (data->curr_duration >= data->duration) {
+                data->curr_duration = 0.0;
+                data->curr_frequency = 0.0;
+                data->phase = 0.0;
+            }
+
+        }
 
         buffer[i] = (int16_t)sample;
 
-        data->curr_duration += 1.0 / SAMPLE_RATE;
-        if (data->curr_duration >= data->duration) {
-            data->curr_duration = 0.0;
-            data->curr_frequency = 0;
-        }
     }
     pa_stream_write(s, buffer, length, NULL, 0LL, PA_SEEK_RELATIVE);
 }
 
-double get_closest_frequency(size_t num_samples, double input_frequency) {
-
-    double samples_per_cycle = SAMPLE_RATE / input_frequency;
-
-    double adjusted_frequency = SAMPLE_RATE / (num_samples / floor(num_samples/samples_per_cycle) );
-
-    return adjusted_frequency;
-}
-
 void engine_sound_stream(pa_stream *s, size_t length, void *userdata) {
 
     SoundData* data = (SoundData*)userdata;
-    double freq = data->curr_frequency;
 
     size_t num_samples = length / sizeof(int16_t);
-    freq = get_closest_frequency( num_samples, freq );
+
     //size_t num_samples = (size_t) (DURATION * SAMPLE_RATE);
     int16_t buffer[num_samples];
 
     //double t = 0;
     for (size_t i = 0; i < num_samples; i++) {
+
         double t = data->phase;
 
-        double sample = ((double)data->curr_amplitude/100) * 32767.0 * sin( 2.0 * M_PI * freq * t );
+        double sample = ((double)data->curr_amplitude/100) * 32767.0 * sin( 2.0 * M_PI * t );
 
         buffer[i] = (int16_t)sample;
 
-        t += 1.0 / SAMPLE_RATE;
-        if (t >= SAMPLE_RATE) {
-            t = 0;
+        double f = apply_noise(data->curr_frequency, data->noise);
+
+        t += f / SAMPLE_RATE;
+        if (t >= 1.0) {
+            t -= floor(t);
         }
+
         data->phase = t;
     }
-    data->phase = round(data->phase);
 
     pa_stream_write(s, buffer, length, NULL, 0LL, PA_SEEK_RELATIVE);
 }
@@ -166,7 +191,7 @@ int usb_generic_shaker_init(SoundDevice* sounddevice, pa_threaded_mainloop* main
     // recommended settings, i.e. server uses sensible values
     pa_buffer_attr buffer_attr;
     buffer_attr.maxlength = (uint32_t) 32767;
-    buffer_attr.tlength = (uint32_t) -1;
+    buffer_attr.tlength = (uint32_t) 2048;
     buffer_attr.prebuf = (uint32_t) -1;
     buffer_attr.minreq = (uint32_t) -1;
 
@@ -182,14 +207,14 @@ int usb_generic_shaker_init(SoundDevice* sounddevice, pa_threaded_mainloop* main
     // for now i'm only supporting playing on one specified channel which is the concept you should build your setups around
     cv.values[pan] = channel_volume;
 
-    assert(pa_stream_connect_playback(stream, devname, &buffer_attr, stream_flags, &cv, NULL) == 0);
+    pa_stream_connect_playback(stream, devname, &buffer_attr, stream_flags, &cv, NULL);
     //pa_stream_connect_playback(stream, devname, &buffer_attr, stream_flags, &cv, NULL);
 
     // Wait for the stream to be ready
     for(;;)
     {
         pa_stream_state_t stream_state = pa_stream_get_state(stream);
-        assert(PA_STREAM_IS_GOOD(stream_state));
+        PA_STREAM_IS_GOOD(stream_state);
         //PA_STREAM_IS_GOOD(stream_state);
         if (stream_state == PA_STREAM_READY) break;
         pa_threaded_mainloop_wait(mainloop);

src/monocoque/devices/sounddevice.c

@@ -26,7 +26,7 @@ int gear_sound_set(SoundDevice* sounddevice, SimData* simdata)
     }
     sounddevice->sounddata.last_gear = simdata->gear;
 
-    slogt("set gear frequency to %i", sounddevice->sounddata.curr_frequency);
+    slogt("set gear frequency to %f", sounddevice->sounddata.curr_frequency);
 }
 
 
@@ -37,9 +37,9 @@ double modulate(SoundDevice* sounddevice, double raw_effect, SoundEffectModulati
     {
         case SOUND_EFFECT_MODULATION_FREQUENCY:
             modulated_effect = ((sounddevice->sounddata.frequencyMax - sounddevice->sounddata.frequency) * raw_effect) + sounddevice->sounddata.frequency;
-            sounddevice->sounddata.curr_frequency = trunc(modulated_effect);
+            sounddevice->sounddata.curr_frequency = modulated_effect;
             sounddevice->sounddata.curr_amplitude = sounddevice->sounddata.amplitude;
-            slogt("set curr frequency to %i from raw effect %f and base frequency %i", sounddevice->sounddata.curr_frequency, raw_effect, sounddevice->sounddata.frequency);
+            slogt("set curr frequency to %f from raw effect %f and base frequency %i", sounddevice->sounddata.curr_frequency, raw_effect, sounddevice->sounddata.frequency);
             break;
         case SOUND_EFFECT_MODULATION_AMPLIFY:
             modulated_effect = ((sounddevice->sounddata.amplitudeMax - sounddevice->sounddata.amplitude) * raw_effect) + sounddevice->sounddata.amplitude;
@@ -80,7 +80,7 @@ int sounddev_tyreslip_update(SimDevice* this, SimData* simdata)
     }
     else
     {
-        sounddevice->sounddata.curr_frequency = 0;
+        sounddevice->sounddata.curr_frequency = 0.0;
         sounddevice->sounddata.curr_amplitude = 0;
         sounddevice->sounddata.curr_duration = 0;
     }
@@ -100,7 +100,7 @@ int sounddev_tyrelock_update(SimDevice* this, SimData* simdata)
     }
     else
     {
-        sounddevice->sounddata.curr_frequency = 0;
+        sounddevice->sounddata.curr_frequency = 0.0;
         sounddevice->sounddata.curr_amplitude = 0;
         sounddevice->sounddata.curr_duration = 0;
     }
@@ -118,7 +118,7 @@ int sounddev_absbrakes_update(SimDevice* this, SimData* simdata)
     }
     else
     {
-        sounddevice->sounddata.curr_frequency = 0;
+        sounddevice->sounddata.curr_frequency = 0.0;
         sounddevice->sounddata.curr_amplitude = 0;
         sounddevice->sounddata.curr_duration = 0;
     }
@@ -138,7 +138,7 @@ int sounddev_suspension_update(SimDevice* this, SimData* simdata)
     }
     else
     {
-        sounddevice->sounddata.curr_frequency = 0;
+        sounddevice->sounddata.curr_frequency = 0.0;
         sounddevice->sounddata.curr_amplitude = 0;
         sounddevice->sounddata.curr_duration = 0;
     }
@@ -177,6 +177,7 @@ int sounddev_init(SoundDevice* sounddevice, const char* devname, MonocoqueTyreId
     slogi("pan is: %i", sds.pan);
     slogi("channels is: %i", sds.channels);
     slogi("duration is: %f", sds.duration);
+    slogi("noise is: %i", sds.noise);
 
 
     sounddevice->modulationType = sds.modulation;
@@ -184,12 +185,13 @@ int sounddev_init(SoundDevice* sounddevice, const char* devname, MonocoqueTyreId
     sounddevice->sounddata.frequencyMax = sds.frequencyMax;
     sounddevice->sounddata.amplitude = sds.amplitude;
     sounddevice->sounddata.amplitudeMax = sds.amplitudeMax;
+    sounddevice->sounddata.noise = (double)sds.noise;
     sounddevice->sounddata.curr_duration = 0;
 
     sounddevice->sounddata.phase = 0;
 
     sounddevice->sounddata.curr_amplitude = 0;
-    sounddevice->sounddata.curr_frequency = 0;
+    sounddevice->sounddata.curr_frequency = 0.0;
 
 
     const char* streamname= "Engine";
@@ -229,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/sounddevice.h

@@ -26,10 +26,11 @@ typedef struct
     uint32_t amplitude;
     uint32_t amplitudeMax;
     double duration;
-    uint32_t curr_frequency;
+    double curr_frequency;
     uint32_t curr_amplitude;
     double curr_duration;
     double phase;
+    double noise;
 }
 SoundData;
 

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

@@ -13,6 +13,7 @@
 #include "loopdata.h"
 #include "../helper/confighelper.h"
 #include "../devices/simdevice.h"
+#include "../devices/hapticeffect.h"
 #include "../simulatorapi/simapi/simapi/simdata.h"
 #include "../simulatorapi/simapi/simapi/simmapper.h"
 #include "../slog/slog.h"
@@ -38,6 +39,15 @@ void showstatscallback(uv_timer_t* handle);
 void datacheckcallback(uv_timer_t* handle);
 void startdatalogger(MonocoqueSettings* ms, loop_data* l);
 
+static void close_walk_cb(uv_handle_t* handle, void* arg)
+{
+    if (!uv_is_closing(handle))
+    {
+        uv_close(handle, NULL);
+    }
+}
+#define ASSERT(expr) expr
+
 int showstats(SimData* simdata)
 {
     printf("\r");
@@ -215,7 +225,6 @@ void devicetimercallback(uv_timer_t* handle)
     SimData* simdata = f->simdata;
     SimDevice* device = f->simdevice;
     device->update(device, simdata);
-
 }
 
 void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
@@ -223,18 +232,18 @@ 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;
@@ -249,7 +258,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++)
         {
@@ -298,6 +308,30 @@ void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
         //        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);
+                }
+            }
+        }
     }
 }
 
@@ -314,14 +348,34 @@ void showstatscallback(uv_timer_t* handle)
 
 void releaseloop(loop_data* f, SimData* simdata, SimMap* simmap)
 {
-
+        slogi("release loop");
         if(f->releasing == false)
         {
             f->releasing = true;
-            uv_udp_recv_stop(&recv_socket);
             uv_timer_stop(&datamaptimer);
             uv_timer_stop(&showstatstimer);
+            if (uv_is_active((uv_handle_t*)&recv_socket))
+            {
+                uv_udp_recv_stop(&recv_socket);
+            }
+            // Close the socket handle so it can be reinitialized with a different port
+            //if (!uv_is_closing((uv_handle_t*)&recv_socket))
+            //{
+            //    uv_close((uv_handle_t*)&recv_socket, NULL);
+            //}
             slogi("releasing devices, please wait");
+
+            //attempt tyre diameter saving
+            if(hasTyreDiameter(simdata) == 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);
+                }
+            }
+
             f->uion = false;
             SimDevice* devices = f->simdevices;
             int numdevices = f->numdevices;
@@ -362,7 +416,7 @@ void releaseloop(loop_data* f, SimData* simdata, SimMap* simmap)
             }
             free(devices);
 
-            int r = simfree(simdata, simmap, f->map);
+            int r = simapi_sim_clear(simdata, simmap, false);
             slogd("simfree returned %i", r);
             f->numdevices = 0;
             slogi("stopped mapping data, press q again to quit");
@@ -371,7 +425,8 @@ void releaseloop(loop_data* f, SimData* simdata, SimMap* simmap)
 
             if(appstate > 0)
             {
-                uv_timer_start(&datachecktimer, datacheckcallback, 3000, 1000);
+                slogi("restarting checking for data...");
+                uv_timer_start(&datachecktimer, datacheckcallback, 0, 1000);
             }
             f->releasing = false;
             if(appstate > 1)
@@ -391,11 +446,11 @@ void shmdatamapcallback(uv_timer_t* handle)
     //appstate = 2;
     if (appstate == 2)
     {
-        simdatamap(simdata, simmap, NULL, 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);
     }
@@ -428,11 +483,11 @@ static void on_udp_recv(uv_udp_t* handle, ssize_t nread, const uv_buf_t* rcvbuf,
 
     if (appstate == 2)
     {
-        simdatamap(simdata, simmap, NULL, 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);
     }
@@ -456,8 +511,7 @@ void udpstart(MonocoqueSettings* sms, loop_data* f, SimData* simdata, SimMap* si
 {
     if (appstate == 2)
     {
-        fprintf(stderr, "udpstart\n");
-        simdatamap(simdata, simmap, NULL, f->sim, true, NULL);
+        simapi_datamap(simdata, simmap, f->siminfo.simulatorapi, true, NULL);
         if (doui == true)
         {
             looprun(sms, f, simdata);
@@ -474,19 +528,14 @@ void datacheckcallback(uv_timer_t* handle)
 
     if ( appstate == 1 )
     {
-        SimInfo si = getSim(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 )
         {
@@ -503,6 +552,7 @@ void datacheckcallback(uv_timer_t* handle)
                 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
             {
@@ -510,12 +560,12 @@ 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_stop(handle);
+            //uv_timer_start(&datachecktimer, datacheckcallback, 0, 3000);
         }
         if(appstate == 2)
         {
-            SimInfo si = getSim(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);
@@ -525,7 +575,7 @@ void datacheckcallback(uv_timer_t* handle)
 
     if (appstate == 0)
     {
-        slogi("stopping checking for data");
+        slogi("stopped checking for data");
         uv_timer_stop(handle);
     }
 }
@@ -550,6 +600,10 @@ void cb(uv_poll_t* handle, int status, int events)
     if (appstate == 0)
     {
         slogi("Monocoque is exiting...");
+        uv_udp_recv_stop(&recv_socket);
+        uv_timer_stop(&datamaptimer);
+        uv_timer_stop(&showstatstimer);
+        // at this point these below should be the only active threads
         uv_timer_stop(&datachecktimer);
         uv_poll_stop(handle);
     }
@@ -561,7 +615,7 @@ int monocoque_mainloop(MonocoqueSettings* ms)
 {
 
     SimData* simdata = malloc(sizeof(SimData));
-    SimMap* simmap = createSimMap();
+    SimMap* simmap = simapi_simmap_create();
 
     struct termios newsettings, canonicalmode;
     tcgetattr(0, &canonicalmode);
@@ -579,48 +633,53 @@ 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;
-    uv_handle_set_data((uv_handle_t*) &datachecktimer, (void*) baton);
-    uv_handle_set_data((uv_handle_t*) &datamaptimer, (void*) baton);
-    uv_handle_set_data((uv_handle_t*) &showstatstimer, (void*) baton);
-    uv_handle_set_data((uv_handle_t*) &recv_socket, (void*) baton);
-    uv_handle_set_data((uv_handle_t*) poll, (void*) baton);
-    appstate = 1;
-    slogd("setting initial app state");
-    uv_timer_init(uv_default_loop(), &datachecktimer);
-    uv_timer_init(uv_default_loop(), &showstatstimer);
-    fprintf(stdout, "Searching for sim data... Press q to quit...\n");
-    uv_timer_start(&datachecktimer, datacheckcallback, 1000, 1000);
-
-    set_simapi_log_info(simapilib_loginfo);
-    set_simapi_log_debug(simapilib_logdebug);
-    set_simapi_log_trace(simapilib_logtrace);
 
+    simapi_set_log_info(simapilib_loginfo);
+    simapi_set_log_debug(simapilib_logdebug);
+    simapi_set_log_trace(simapilib_logtrace);
 
     if (0 != uv_poll_init(uv_default_loop(), poll, 0))
     {
         return 1;
     };
+    uv_timer_init(uv_default_loop(), &datachecktimer);
+    uv_timer_init(uv_default_loop(), &showstatstimer);
+    uv_timer_init(uv_default_loop(), &datamaptimer);
+    slogd("setting initial app state");
+    appstate = 1;
+
+    uv_handle_set_data((uv_handle_t*) &datachecktimer, (void*) baton);
+    uv_handle_set_data((uv_handle_t*) &datamaptimer, (void*) baton);
+    uv_handle_set_data((uv_handle_t*) &showstatstimer, (void*) baton);
+    uv_handle_set_data((uv_handle_t*) &recv_socket, (void*) baton);
+    uv_handle_set_data((uv_handle_t*) poll, (void*) baton);
+
     if (0 != uv_poll_start(poll, UV_READABLE, cb))
     {
         return 2;
     };
+    uv_timer_start(&datachecktimer, datacheckcallback, 1000, 1000);
 
-
-    uv_timer_init(uv_default_loop(), &datamaptimer);
-
+    fprintf(stdout, "Searching for sim data... Press q to quit...\n");
     uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+
+    uv_stop(uv_default_loop());
+    //uv_walk(uv_default_loop(), close_walk_cb, NULL);
+    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+    uv_loop_close(uv_default_loop());
+    uv_library_shutdown();
+    slogi("All threads stopped...");
+
     fprintf(stdout, "\n");
     fflush(stdout);
     tcsetattr(0, TCSANOW, &canonicalmode);
 
     free(baton);
     free(simdata);
-    freesimmap(simmap, false);
 
     return 0;
 }
@@ -660,7 +719,35 @@ int tester(SimDevice* devices, int numdevices)
     simdata->Yvelocity = 100;
     simdata->Zvelocity = 0;
 
-    sleep(3);
+    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;
+        for (int x = 0; x < numdevices; x++)
+        {
+            if (devices[x].initialized == true)
+            {
+                devices[x].update(&devices[x], simdata);
+            }
+        }
+        usleep(1000);
+    }
+
+    for (int r = 0; r < 8000; r += 3)
+    {
+        simdata->rpms = 9000 - r;
+        for (int x = 0; x < numdevices; x++)
+        {
+            if (devices[x].initialized == true)
+            {
+                devices[x].update(&devices[x], simdata);
+            }
+        }
+        usleep(1000);
+    }
 
     fprintf(stdout, "Setting rpms to 1000\n");
     simdata->rpms = 1000;

src/monocoque/gameloop/loopdata.h

@@ -13,18 +13,17 @@ typedef struct device_loop_data
     uv_work_t req;
     SimData* simdata;
     SimDevice* simdevice;
+    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;
     int numdevices;
+    SimInfo siminfo;
     MonocoqueSettings* ms;
     SimData* simdata;
     SimMap* simmap;

src/monocoque/helper/confighelper.c

@@ -747,6 +747,7 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
             ds->sounddevsettings.pan = 0;
             ds->sounddevsettings.channels = 1;
             ds->sounddevsettings.duration = 2.0;
+            ds->sounddevsettings.noise = 0;
             if (ds->effect_type == EFFECT_GEARSHIFT)
             {
                 ds->sounddevsettings.duration = .125;
@@ -762,6 +763,7 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
                 config_setting_lookup_int(device_settings, "pan", &ds->sounddevsettings.pan);
                 config_setting_lookup_int(device_settings, "channels", &ds->sounddevsettings.channels);
                 config_setting_lookup_float(device_settings, "duration", &ds->sounddevsettings.duration);
+                config_setting_lookup_int(device_settings, "noise", &ds->sounddevsettings.noise);
 
                 const char* temp = NULL;
                 int found = 0;

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;
 
@@ -185,6 +186,7 @@ typedef struct
     double duration;
     char* dev;
     SoundEffectModulationType modulation;
+    int noise;
 }
 SoundDeviceSettings;
 

src/monocoque/helper/parameters.c

@@ -67,10 +67,10 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
     struct arg_file* arg_log         = arg_filen("l", "log", "<log_file>", 0, 1, NULL);
     struct arg_str* arg_confdir      = arg_str1(NULL, NULL, "configdir", "<config_dir>");
     struct arg_int* arg_fps          = arg_int0("f", "fps", "fps", "main data refresh rate");
-    struct arg_lit* help             = arg_litn(NULL,"help", 0, 1, "print this help and exit");
+    struct arg_lit* help1            = arg_litn(NULL,"help", 0, 1, "print this help and exit");
     struct arg_lit* vers             = arg_litn(NULL,"version", 0, 1, "print version information and exit");
     struct arg_end* end1             = arg_end(20);
-    void* argtable1[]                = {cmd1,arg_log,arg_conf,arg_fps,arg_udp,arg_audio1,arg_verbosity1,help,vers,end1};
+    void* argtable1[]                = {cmd1,arg_log,arg_conf,arg_fps,arg_udp,arg_audio1,arg_verbosity1,help1,vers,end1};
     int nerrors1;
 
     struct arg_rex* cmd2a            = arg_rex1(NULL, NULL, "config", NULL, REG_ICASE, NULL);
@@ -121,6 +121,14 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
 
     if (nerrors1==0)
     {
+       if (help1->count > 0)
+       {
+           arg_print_errors(stdout,end1,progname);
+           printf("Usage: %s ", progname);
+           arg_print_syntax(stdout,argtable1,"\n");
+           exitcode = E_SUCCESS_AND_EXIT;
+           goto cleanup;
+       }
         p->program_action = A_PLAY;
         p->verbosity_count = arg_verbosity1->count;
 
@@ -154,64 +162,75 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
         }
         exitcode = E_SUCCESS_AND_DO;
     }
-    else
-        if (nerrors2==0)
+    else if (nerrors2==0)
+    {
+        if (help2->count > 0)
         {
-            p->program_action = A_CONFIG_TACH;
-            p->max_revs = arg_max_revs->ival[0];
-            p->granularity = 1;
-            if (arg_granularity->ival[0] > 0 && arg_granularity->ival[0] < 5 && arg_granularity->ival[0] != 3)
-            {
-                p->granularity=arg_granularity->ival[0];
-            }
-            p->save_file = *arg_save->filename;
-            p->verbosity_count = arg_verbosity2->count;
-            exitcode = E_SUCCESS_AND_DO;
-        }
-        else if (nerrors3==0)
-        {
-            p->program_action = A_TEST;
-            p->verbosity_count = arg_verbosity3->count;
-            if (arg_audio2->count > 0)
-            {
-                p->disable_audio = true;
-            }
-            exitcode = E_SUCCESS_AND_DO;
-        }
-        else
-        {
-            if (cmd1->count > 0)
-            {
-                arg_print_errors(stdout,end1,progname);
-                printf("Usage: %s ", progname);
-                arg_print_syntax(stdout,argtable1,"\n");
-            }
-            else
-                if (cmd2a->count > 0)
-                {
-                    arg_print_errors(stdout,end2,progname);
-                    printf("Usage: %s ", progname);
-                    arg_print_syntax(stdout,argtable2,"\n");
-                }
-                else
-                {
-                    if (help->count==0 && vers->count==0)
-                    {
-                        printf("%s: missing <play|config|test> command.\n",progname);
-                        printf("Usage 1: %s ", progname);
-                        arg_print_syntax(stdout,argtable1,"\n");
-                        printf("Usage 2: %s ", progname);
-                        arg_print_syntax(stdout,argtable2,"\n");
-                        printf("Usage 3: %s ", progname);
-                        arg_print_syntax(stdout,argtable3,"\n");
-                    }
-                }
+            arg_print_errors(stdout,end2,progname);
+            printf("Usage: %s ", progname);
+            arg_print_syntax(stdout,argtable2,"\n");
             exitcode = E_SUCCESS_AND_EXIT;
             goto cleanup;
         }
+        p->program_action = A_CONFIG_TACH;
+        p->max_revs = arg_max_revs->ival[0];
+        p->granularity = 1;
+        if (arg_granularity->ival[0] > 0 && arg_granularity->ival[0] < 5 && arg_granularity->ival[0] != 3)
+        {
+            p->granularity=arg_granularity->ival[0];
+        }
+        p->save_file = *arg_save->filename;
+        p->verbosity_count = arg_verbosity2->count;
+        exitcode = E_SUCCESS_AND_DO;
+    }
+    else if (nerrors3==0)
+    {
+        if (help3->count > 0)
+        {
+            arg_print_errors(stdout,end3,progname);
+            printf("Usage: %s ", progname);
+            arg_print_syntax(stdout,argtable3,"\n");
+            exitcode = E_SUCCESS_AND_EXIT;
+            goto cleanup;
+        }
+        p->program_action = A_TEST;
+        p->verbosity_count = arg_verbosity3->count;
+        if (arg_audio2->count > 0)
+        {
+            p->disable_audio = true;
+        }
+        exitcode = E_SUCCESS_AND_DO;
+    }
+    else
+    {
+        // hit this if you typed wrong parameters
+        if (cmd1->count > 0)
+        {
+            arg_print_errors(stdout,end1,progname);
+            printf("Usage: %s ", progname);
+            arg_print_syntax(stdout,argtable1,"\n");
+            exitcode = E_SUCCESS_AND_EXIT;
+            goto cleanup;
+        }
+        if (cmd2a->count > 0)
+        {
+            arg_print_errors(stdout,end2,progname);
+            printf("Usage: %s ", progname);
+            arg_print_syntax(stdout,argtable2,"\n");
+            exitcode = E_SUCCESS_AND_EXIT;
+            goto cleanup;
+        }
+        if (cmd3->count > 0)
+        {
+            arg_print_errors(stdout,end3,progname);
+            printf("Usage: %s ", progname);
+            arg_print_syntax(stdout,argtable3,"\n");
+            exitcode = E_SUCCESS_AND_EXIT;
+            goto cleanup;
+        }
+    }
 
-    // interpret some special cases before we go through trouble of reading the config file
-    if (help->count > 0)
+    if (help0->count > 0 || (cmd3->count == 0 && cmd1->count == 0 && cmd2a->count == 0))
     {
         printf("Usage: %s\n", progname);
         printf("Usage 1: %s ", progname);

src/monocoque/monocoque.c

@@ -173,7 +173,8 @@ int main(int argc, char** argv)
     config_setting_t* config_devices = NULL;
     if (!config_read_file(&cfg, ms->config_str))
     {
-        fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
+        sloge("Issue with monocoque config file: %s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
+        fprintf(stderr, "Issue with monocoque config file: %s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
         config_destroy(&cfg);
         slog_destroy();
         goto cleanup_final;
@@ -192,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);
@@ -204,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;
@@ -287,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]);

src/monocoque/simulatorapi/CMakeLists.txt

@@ -9,6 +9,11 @@ set(simulatorapi_source_files
   simapi/include/dirt2data.h
   simapi/include/scs2data.h
   simapi/include/outgauge.h
+  simapi/include/f12018.h
+  simapi/include/rbrdata.h
+  simapi/include/r3e.h
+  simapi/include/wreckfest2data.h
+  simapi/include/forza.h
   simapi/simmap/basicmap.h
   simapi/simmap/mapacdata.c
   simapi/simmap/mapacdata.h
@@ -18,12 +23,22 @@ set(simulatorapi_source_files
   simapi/simapi/pcars2.h
   simapi/simapi/scs2.h
   simapi/simapi/outgauge.h
+  simapi/simapi/wreckfest2.h
+  simapi/simapi/f1.h
+  simapi/simapi/rbr.h
+  simapi/simapi/forzadef.h
+  simapi/simapi/r3edef.h
   simapi/simapi/mapping/acmapper.c
   simapi/simapi/mapping/rf2mapper.c
+  simapi/simapi/mapping/r3emapper.c
   simapi/simapi/mapping/pcars2mapper.c
   simapi/simapi/mapping/dirt2mapper.c
   simapi/simapi/mapping/scs2mapper.c
   simapi/simapi/mapping/outgaugemapper.c
+  simapi/simapi/mapping/f12018mapper.c
+  simapi/simapi/mapping/rbrmapper.c
+  simapi/simapi/mapping/wreckfest2mapper.c
+  simapi/simapi/mapping/forzamapper.c
   simapi/simapi/getpid.c
   simapi/simapi/getpid.h
 )

tools/distro/debian/dpkg/debian-stable/control

@@ -0,0 +1,8 @@
+Package: monocoque
+Version: 1
+Section: misc
+Priority: optional
+Architecture: amd64
+Maintainer: Paul Jones <paul@spacefreak18.xyz>
+Description: Racing Simulator Device Manager
+Depends: libpulse0,libconfig11,libargtable2-0,liblua5.4-0,libuv1t64,libserialport0,libxml2,libxdg-basedir1,libhidapi-hidraw0

tools/distro/debian/dpkg/ubuntu-latest/control

@@ -0,0 +1,8 @@
+Package: monocoque
+Version: 1
+Section: misc
+Priority: optional
+Architecture: amd64
+Maintainer: Paul Jones <paul@spacefreak18.xyz>
+Description: Racing Simulator Device Manager
+Depends: libpulse0,libconfig9,libargtable2-0,liblua5.4-0,libuv1t64,libserialport0,libxml2,libxdg-basedir1,libhidapi-hidraw0

tools/distro/fedora/rpm/fedora.spec

@@ -0,0 +1,39 @@
+#dnf install pulseaudio-libs-devel argtable-devel libconfig-devel hidapi-devel libserialport-devel lua-devel libuv-devel libxdg-basedir-devel libxml2-devel
+Summary: A device manager for racing sims
+Name: monocoque
+Version: 0.0.5
+Release: 1
+License: GPL
+Group: Applications/Sound
+Source: https://github.com/monocoque
+URL: https://spacefreak18.github.io/simapi
+Distribution: Fedora Linux
+Vendor: spacefreak18
+Packager: Paul Jones <paul@spacefreak18.xyz>
+Requires: pulseaudio-libs argtable libconfig hidapi libserialport libuv libxdg-basedir lua-libs libxml2
+
+%description
+A device manager for Racing sims
+
+%prep
+rm -rf $RPM_BUILD_DIR/monocoque
+rm -rf $RPM_SOURCE_DIR/monocoque
+cd $RPM_SOURCE_DIR
+git clone https://github.com/spacefreak18/monocoque
+cd monocoque
+git submodule update --init --recursive
+cd ..
+cp -r $RPM_SOURCE_DIR/monocoque $RPM_BUILD_DIR/
+
+%build
+cd $RPM_BUILD_DIR/monocoque
+cmake -B build
+cd build
+make
+
+%install
+mkdir -p $RPM_BUILD_ROOT/usr/bin
+cp $RPM_BUILD_DIR/monocoque/build/monocoque $RPM_BUILD_ROOT/usr/bin/monocoque
+
+%files
+/usr/bin/monocoque