fix typo on file type

create rpm build dirs first
fix checkout command
2026-01-12 15:11:58 -05:00 · 2026-01-12 15:08:22 -05:00 · 2026-01-12 15:06:22 -05:00 · 2026-01-12 15:04:37 -05:00 · 2026-01-12 12:00:37 -05:00 · 2026-01-12 11:47:43 -05:00
88 changed files with 7462 additions and 1147 deletions
@@ -0,0 +1,82 @@
+name: Make Packages
+
+on:
+  push:
+    branches: [ "master" ]
+    tags: [ "master" ]
+
+jobs:
+  build-monocoque-debs:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, debian-latest, debian-stable]
+    runs-on: ${{ matrix.os }}
+
+
+    permissions:
+      contents: write
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Checkout submodules
+      run: git submodule update --init --recursive
+    - name: Update apt
+      run: sudo apt update
+    - name: Install Dependencies
+      run: sudo apt install -y libuv1-dev libargtable2-dev libserialport-dev libconfig-dev libhidapi-dev liblua5.4-dev libxdg-basedir-dev libxml2-dev libpulse-dev
+    - name: Set build dir
+      id: strings
+      shell: bash
+      run: |
+        echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT"
+        github_sha_hash=${{ github.sha }}
+        echo "github-sha-short=${github_sha_hash:0:7}" >> $GITHUB_OUTPUT
+
+    - name: Configure CMake
+      run: >
+        cmake -B ${{ steps.strings.outputs.build-output-dir }}
+        -DCMAKE_CXX_COMPILER=g++
+        -DCMAKE_C_COMPILER=gcc
+        -DCMAKE_BUILD_TYPE=Release
+        -S ${{ github.workspace }}
+
+    - name: Build
+      run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config Release
+
+    - name: Copy script files around to stop .github from being added to the package then build the package
+      run: |
+        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 ./build/monocoque ./PKG_SOURCE/usr/bin/monocoque
+        dpkg-deb --build PKG_SOURCE monocoque-${{ matrix.os }}.deb
+
+    - name: Release the Package
+      uses: softprops/action-gh-release@v1
+      with:
+        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 ~/monocoque-${{ matrix.os }}.rpm
+    - name: Release the Package
+      uses: softprops/action-gh-release@v1
+      with:
+        files: monocoque-${{ matrix.os }}.rpm
+
@@ -1,3 +1,5 @@
 /build
 /src/monocoque/tags
 /src/monocoque/simulatorapi/simapi
+
+.vscode
@@ -1,3 +1,4 @@
+# small known issue with argtable2
 {
    argtable arg_parse
    Memcheck:Leak
@@ -1,6 +1,6 @@

 # minimum CMake version required for C++20 support, among other things
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.18)

 # detect if Monocoque is being used as a sub-project of another CMake project
 if(NOT DEFINED PROJECT_NAME)
@@ -20,30 +20,33 @@ set(CMAKE_EXE_LINKER_FLAGS "-Wl,--no-as-needed -ldl")
 set(LIBUSB_INCLUDE_DIR /usr/include/libusb-1.0)
 set(LIBXML_INCLUDE_DIR /usr/include/libxml2)

-FIND_PATH(LIBUSB_INCLUDE_DIR libusb.h
-	HINTS $ENV{LIBUSB_ROOT}
-	PATHS ${PC_LIBUSB_INCLUDEDIR} ${PC_LIBUSB_INCLUDE_DIRS}
-	PATH_SUFFIXES include)
+FIND_PACKAGE(Lua 5.3 REQUIRED)
+set(INCLUDE_DIRS ${LUA_INCLUDE_DIR})
+include_directories(${LUA_INCLUDE_DIR})

-FIND_LIBRARY(LIBUSB_LIBRARY NAMES usb-1.0
-	HINTS $ENV{LIBUSB_ROOT}
-	PATHS ${PC_LIBUSB_LIBDIR} ${PC_LIBUSB_LIBRARY_DIRS}
-	PATH_SUFFIXES lib)
-
-set(HIDAPI_WITH_LIBUSB TRUE) # surely will be used only on Linux
+#FIND_PATH(LIBUSB_INCLUDE_DIR libusb.h
+#	HINTS $ENV{LIBUSB_ROOT}
+#	PATHS ${PC_LIBUSB_INCLUDEDIR} ${PC_LIBUSB_INCLUDE_DIRS}
+#	PATH_SUFFIXES include)
+#
+#FIND_LIBRARY(LIBUSB_LIBRARY NAMES usb-1.0
+#	HINTS $ENV{LIBUSB_ROOT}
+#	PATHS ${PC_LIBUSB_LIBDIR} ${PC_LIBUSB_LIBRARY_DIRS}
+#	PATH_SUFFIXES lib)
+#
+set(HIDAPI_WITH_LIBUSB FALSE) # surely will be used only on Linux
 set(BUILD_SHARED_LIBS TRUE) # HIDAPI as static library on all platforms

 add_executable(monocoque src/monocoque/monocoque.c)
-if(USE_PULSEAUDIO)
-    message("Using pulseaudio backend...")
-    add_compile_definitions(USE_PULSEAUDIO=true)
-    target_link_libraries(monocoque m ${LIBUSB_LIBRARY} hidapi-libusb pulse serialport xml2 argtable2 config gameloop helper devices slog simulatorapi)
-else()
-    message("Using portaudio backend...")
-    target_link_libraries(monocoque m ${LIBUSB_LIBRARY} hidapi-libusb portaudio serialport xml2 argtable2 config gameloop helper devices slog simulatorapi)
-endif()

-target_include_directories(monocoque PUBLIC config ${LIBUSB_INCLUDE_DIR} ${LIBXML_INCLUDE_DIR})
+#if(USE_PULSEAUDIO)
+#else()
+#endif()
+message("Using pulseaudio backend...")
+add_compile_definitions(USE_PULSEAUDIO=true)
+target_link_libraries(monocoque m hidapi-hidraw pulse serialport xml2 argtable2 config gameloop helper devices slog simulatorapi uv xdg-basedir ${LUA_LIBRARY})
+
+target_include_directories(monocoque PUBLIC config ${LIBXML_INCLUDE_DIR})

 add_subdirectory(src/monocoque/gameloop)
 add_subdirectory(src/monocoque/simulatorapi)
@@ -51,31 +54,31 @@ add_subdirectory(src/monocoque/helper)
 add_subdirectory(src/monocoque/devices)
 add_subdirectory(src/monocoque/slog)

-add_executable(listusb tests/testlibusb.c)
-target_include_directories(listusb PUBLIC ${LIBUSB_INCLUDE_DIR})
-target_link_libraries(listusb ${LIBUSB_LIBRARY} portaudio)
-add_test(listusb list-usb-devices listusb)
+#add_executable(listusb tests/testlibusb.c)
+#target_include_directories(listusb PUBLIC)
+#target_link_libraries(listusb portaudio hidapi-hidraw)
+#add_test(listusb list-usb-devices listusb)

-add_executable(testrevburner tests/testrevburner.c)
-target_include_directories(testrevburner PUBLIC ${LIBUSB_INCLUDE_DIR})
-target_link_libraries(testrevburner ${LIBUSB_LIBRARY})
-add_test(testrevburner testrevburner)
-
-add_executable(listsound tests/pa_devs.c)
-target_include_directories(listsound PUBLIC)
-target_link_libraries(listsound m portaudio)
-add_test(list-sound-devices listsound)
-
-add_executable(longsine tests/patest_longsine.c)
-target_include_directories(longsine PUBLIC ${LIBUSB_INCLUDE_DIR} ${LIBXML_INCLUDE_DIR})
-target_link_libraries(longsine ${LIBUSB_LIBRARY} m portaudio)
-add_test(longsine longsine)
-
-add_executable(parserevburnerxml tests/revburnerparsetest.c)
-target_include_directories(parserevburnerxml PUBLIC ${LIBXML_INCLUDE_DIR})
-target_link_libraries(parserevburnerxml ${LIBUSB_LIBRARY} portaudio xml2)
-add_test(parserevburnerxml parserevburnerxml)
+#add_executable(testrevburner tests/testrevburner.c)
+#target_include_directories(testrevburner PUBLIC)
+#target_link_libraries(testrevburner hidapi-hidraw)
+#add_test(testrevburner testrevburner)

+#add_executable(listsound tests/pa_devs.c)
+#target_include_directories(listsound PUBLIC)
+#target_link_libraries(listsound m portaudio)
+#add_test(list-sound-devices listsound)
+#
+#add_executable(longsine tests/patest_longsine.c)
+#target_include_directories(longsine PUBLIC ${LIBXML_INCLUDE_DIR})
+#target_link_libraries(longsine m portaudio)
+#add_test(longsine longsine)
+#
+#add_executable(parserevburnerxml tests/revburnerparsetest.c)
+#target_include_directories(parserevburnerxml PUBLIC ${LIBXML_INCLUDE_DIR})
+#target_link_libraries(parserevburnerxml portaudio xml2)
+#add_test(parserevburnerxml parserevburnerxml)
+#
 add_executable(setmem tests/setmem.c)
 target_include_directories(setmem PUBLIC)
 target_link_libraries(setmem)
@@ -85,17 +88,17 @@ add_executable(getmem tests/getmem.c)
 target_include_directories(getmem PUBLIC)
 target_link_libraries(getmem)
 add_test(getmem getmem)
-
-add_executable(setsimdata tests/setsimdata.c)
-target_include_directories(setsimdata PUBLIC)
-target_link_libraries(setsimdata)
-add_test(setsimdata setsimdata)
-
-add_executable(hidtest tests/hidtest.c)
-target_include_directories(hidtest PUBLIC ${LIBUSB_INCLUDE_DIR})
-target_link_libraries(hidtest ${LIBUSB_LIBRARY} hidapi-libusb)
-add_test(hidtest hidtest)
-
+#
+#add_executable(setsimdata tests/setsimdata.c)
+#target_include_directories(setsimdata PUBLIC)
+#target_link_libraries(setsimdata)
+#add_test(setsimdata setsimdata)
+#
+#add_executable(hidtest tests/hidtest.c)
+#target_include_directories(hidtest PUBLIC)
+#target_link_libraries(hidtest hidapi-hidraw)
+#add_test(hidtest hidtest)
+#
 add_executable(simlighttest tests/simlighttest.c)
 target_include_directories(simlighttest PUBLIC)
 target_link_libraries(simlighttest serialport)
@@ -0,0 +1,39 @@
+# Monocoque User Setup Guide
+
+## Required Packages / Software
+* build [monocoque](https://github.com/Spacefreak18/monocoque) e.g. in `~/monocoque` - follow instructions from repo
+* build [simd](https://github.com/Spacefreak18/simapi/tree/master/simd) e.g. in `~/simapi/simd` - follow instructions from repo
+* build [simshmbridge](https://github.com/spacefreak18/simshmbridge) e.g. in `~/simshmbridge` - follow instructions from repo
+
+## Configure SIMD & Monocoque
+* Create a `simd` Config in `~/.config/simd/simd.config` - [use example](https://github.com/Spacefreak18/simapi/blob/master/simd/conf/simd.config)
+    * no changes required to the example file
+* create Monocoque config in `~/.config/monocque/monocoque.config` - [example](https://github.com/Spacefreak18/monocoque/blob/master/conf/monocoque.config)
+    * Adapt the config to your needs, remove unused entries
+    * [Documentation for Bass Shaker Config](https://spacefreak18.github.io/simapi/shakers)
+    * Test your config as described in the [README](README.md#testing)
+## Steam & Game Config
+### Steam
+* Adapt Steam Launch Commands from [simshbridge](https://github.com/spacefreak18/simshmbridge?tab=readme-ov-file#basic-mapping-examples)
+    * to use with `simd` you need to `SIMD_BRIDGE_EXE` to the launch command like `SIMD_BRIDGE_EXE=~/git/simshmbridge/assets/pcars2bridge.exe %command% & sleep 5 && ~/.steam/steam/steamapps/common/Proton\ 6.3/proton run ~/git/simshmbridge/assets/pcars2bridge.exe`
+
+### Game specific settings
+#### Automobilista 2 (AMS2)
+* In Games like `Automobilista 2` activate the `Shared Memory` Setting and make sure to set the Protocal to `Project CARS 2`. ![System Settings in AMS2](https://static.wixstatic.com/media/910f3b_adabfa94a57944cca33e488972534fdd~mv2.png/v1/fill/w_964,h_374,al_c,q_90,usm_0.66_1.00_0.01,enc_avif,quality_auto/game_setup_ams2_1.png)  <img src="https://docs.simucube.com/Tuner/games/assets/automobilista2_telemetry_2.png" alt="Shared Memory Settings in AMS2" width="65%">
+    * Restart the Game after changing these Settings!
+#### Assetto Corsa & Assetto Corsa Competizione (ACC)
+* Assetto Corsa & ACC do not need any additional settings and should work out of the box
+
+## Run everything, but in the right order
+* first start `simd` like `~/simapi/simd/build/simd --no-daemon -vv`
+    * this will likely fail, so you'll need to add `export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib` or `export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib64` in front of the command like `export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib64 ~/simapi/simd/build/simd --no-daemon -vv`
+* now start `monocoque` like `~/monocoque/build/monocoque play`
+* finally start the Game you want to play from Steam
+
+## Troubleshooting
+
+* make sure `simd` is running and after you start a game, the CLI output confirms the game is detected
+* make sure the bridge application starts e.g. with `ps aux|grep pcars2bridge.exe` before the game starts
+* see if you have the path `/dev/shm/acpmf_physics` (for ACC) and/or `/dev/shm/$pcars2$` for AMS2
+* when `simd` recognizes the game, see if `monocoque` shows `RPM, Gear..` and other Car Metrics once you start a game
+    * if `simd` recognozies the game, but `monocoque` does not show any data, doublecheck the [Game Settings](#steam--game-config) to see if `Shared Memory` is activated
@@ -8,31 +8,67 @@ _  /  / / / /_/ /  / / / /_/ / /__ / /_/ / /_/ // /_/ //  __/
 ```
 Cross Platform device manager for driving and flight simulators, for use with common simulator software titles.

+📚 **Usage Documentation:** [spacefreak18.github.io/simapi/](https://spacefreak18.github.io/simapi/)
+
 ## Features
- Updates at 120 frames per seconds.
+- Updates at 60 frames per seconds.
 - Modular design for support with various titles and devices.
- Supports bass shakers, tachometers, simlights, simwind etc, through usb and arduino serial.
+- Supports bass shakers, tachometers, several wheels and pedals, simlights, simwind etc, through usb and arduino serial.
 - Tachometer support is currently  limited to the Revburner model. Supports existing revburner xml configuration files.
 - Includes utility to configure revburner tachometer
- Can send data to any serial device. So far only tested with arduino. Includes sample arduino sketch for sim lights.
- The support for haptic bass shakers is limited and needs the most work. So far the engine rev is a simple sine wave, which I find convincing. The gear shift event works but not convincing enough for me.
- Choice of Portaudio or Pulseaudio backend.
+- Can send data to any serial device. So far only tested with arduino. and ESP32. Includes sample arduino sketch for sim lights, simwind, and simhaptic effects for motors.
+- Support for custom arduino (or any serial) device, with a [custom lua format](https://spacefreak18.github.io/simapi/serial_custom) for sending data
+- 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.

-## Dependencies
+## Quick Install
+
+**One-Line Installation:**
+```bash
+curl -fsSL https://raw.githubusercontent.com/Spacefreak18/monocoque/master/install.sh | bash
+```
+***AUR Package following git master:***
+```https://aur.archlinux.org/packages/monocoque-git```
+
+**Or download and review first:**
+```bash
+wget https://raw.githubusercontent.com/Spacefreak18/monocoque/master/install.sh
+chmod +x install.sh
+./install.sh
+```
+
+**TUI Manager:**
+After installation, use the interactive manager:
+```bash
+monocoque-manager
+```
+
+**Supported Games**
+[Supported Sims](https://spacefreak18.github.io/simapi/supportedsims)
+***please note on Linux some titles will require a compatibility exe from simshmbridge to be setup. Please follow the linked Documentation
+for installation instructions***
+
+
+## Building
+
+### Dependencies
 - libserialport - arduino serial devices
- hidapi - usb hid devices
- libusb - used by hidapi
+- hidapi - usb hid devices (hidraw)
 - portaudio - sound devices (haptic bass shakers)
- pulseaudio - sound devices (haptic bass shakers)
- libenet - UDP support (not yet implemented)
+- libpulse - sound devices (haptic bass shakers)
+- libuv base event loop
 - libxml2
 - argtable2
 - libconfig
+- xdg-basedir
+- lua
 - [slog](https://github.com/kala13x/slog) (static)
 - [simshmbridge](https://github.com/spacefreak18/simshmbridge) - for sims that need shared memory mapping like AC and Project Cars related.
 - [simapi](https://github.com/spacefreak18/simapi)
+```
+pacman -Syu git cmake pulse-native-provider libxdg-basedir libserialport libconfig libuv argtable hidapi lua
+```

-## Building
 This code depends on the shared memory data headers in the simapi [repo](https://github.com/spacefreak18/simapi). When pulling lastest if the submodule does not download run:
 ```
 git submodule sync --recursive
@@ -46,56 +82,17 @@ cmake ..
 make
 ```

-to use the pulseaudio backend use this cmake command
-```
-cmake -DUSE_PULSEAUDIO=YES ..
-```
-
-## Using Arduino Devices
-
-Currently Monocoque supports simwind and shiftlights through the included arduino sketches which have been tested on Uno boards. The simwind controller requires a Motor shield.
-
-There are included Makefiles for each controller. For now, the makefiles expect the device to be attached at /dev/ttyACM0. So unplug both controllers, and then plug in just the
-controller you're updating to ensure the correct controller is at /dev/ttyACM0.
-
-To compile and upload these sketches, the Makefiles use arduino-cli. Unfortunately it seems some distributions such as debian do not include this in the repositories. If this is
-the case follow the install instructions here:
-```
-https://arduino.github.io/arduino-cli/0.35/installation/
-```
-You may have to download the core libraries, it will prompt you to do so if you do not have them and you go further
-```
-arduino-cli core install arduino:avr
-```
-Then for shiftlights navigate to included shiftlight directory ( be sure only the shiftlight controller is plugged into the machine and is available at /dev/ttyACM0 ) and
-
-```
-arduino-cli lib install FastLED
-make
-```
-Then for simwind navigate to the included simwind directory ( be sure only the simwind controller is plugged into the machine and is available at /dev/ttyACM0 ) and
-```
-ARDUINO_LIBRARY_ENABLE_UNSAFE_INSTALL=true arduino-cli lib install --git-url https://github.com/adafruit/Adafruit_Motor_Shield_V2_Library.git
-ARDUINO_LIBRARY_ENABLE_UNSAFE_INSTALL=true arduino-cli lib install --git-url https://github.com/adafruit/Adafruit_BusIO.git
-make
-```
-
-### Uploading sketch to Arduino Uno
-```
-cd ../src/arduino/{simwind/shiftlights/simhaptic} # Depending on the controller you have.
-make  # Make sure serial connection is the same as on the host pc and it have the right group permission to access the device without root
-```
-
-### SimHaptic Ardunio Motor Connection
- Acc Pedal Motor to be connected to M1 
- Brake Pedal Motor to be connected to M3
-
+## User Setup Guide
+See the dedicated [How To](HOW-TO-USE.md) for detailed instructions to set up and run 'monocoque`

 ## Testing
 ```
 ./monocoque test -vv # Make sure that ~/.config/monocque/monocoque.config only contains the devices you have connected.
 ```

+### Logs file location
+`~/.cache/monocoque/*.log`
+
 ### Static Analysis
 ```
    mkdir build; cd build
@@ -103,18 +100,20 @@ make  # Make sure serial connection is the same as on the host pc and it have th
    cmake -Danalyze=on ..
    make
 ```
+
 ### Valgrind
 ```
    cd build
    valgrind -v --leak-check=full --show-leak-kinds=all --suppressions=../.valgrindrc ./monocoque play
 ```

-### Logs file location
-`~/.cache/monocoque/*.log`
+## Join the Discussion
+[Sim Racing Matrix Space](https://matrix.to/#/#simracing:matrix.org)

 ## ToDo
+ - add frequency cap (low pass filter) to sound haptic effects
+ - add road and kerb sound haptic effects
 - windows port
 - more memory testing
- - move config code around
 - cleanup tests which are basically just copies of the example from their respective projects
 - much, much more
@@ -0,0 +1,29 @@
+-- start led, end led, color
+-- set_led_range_to_color(1, 5, YELLOW);
+
+-- led, color
+-- set_led_to_color(3, ORANGE);
+
+-- current colors
+-- RED
+-- GREEN
+-- BLUE
+-- YELLOW
+-- ORANGE
+
+if simdata.rpm >= simdata.maxrpm-500 then
+    set_led_range_to_color(1, 6, RED)
+elseif simdata.rpm >= 4000 then
+    set_led_range_to_color(1, 4, YELLOW)
+elseif simdata.rpm >= 3000 then
+    set_led_range_to_color(1, 3, GREEN)
+elseif simdata.rpm >= 2000 then
+    set_led_range_to_rgb_color(1, 2, 0, 255, 0)
+    -- set_led_to_rgb_color also available
+elseif simdata.rpm >= 1000 then
+    set_led_to_color(1, GREEN)
+end
+
+
+
+
@@ -0,0 +1,60 @@
+-- configuration
+-- set these accordingly
+right_leds_start = 7
+right_num_leds = 42
+left_leds_start = 49
+left_num_leds = 42
+--
+
+max_radius = 10 -- radius is hardcoded in simapi
+proxcars = simdata.proxcars -- also hard coded in simapi
+
+rightsideset = false
+leftsideset = false
+
+-- right side
+litleds = 0
+i = 1
+while(i <= proxcars and rightsideset == false) do
+    if simdata.pd[i].theta > 40 and simdata.pd[i].theta < 130 then
+        dist = math.abs(90 - simdata.pd[i].theta)
+        perct = (90 - dist)/90
+        litleds = math.ceil(perct * right_num_leds)
+
+        color_perct = simdata.pd[i].radius/10
+        yellow = math.floor(color_perct * 255)
+        local rgb = (255 << 16) | (yellow << 8) | (0 << 0)
+        if simdata.pd[1].theta >= 90 then
+            -- car is behind
+            set_led_range_to_rgb_color(right_leds_start, right_leds_start + litleds, rgb)
+        else
+            set_led_range_to_rgb_color(right_leds_start + (right_num_leds - litleds), right_leds_start + right_num_leds, rgb)
+        end
+        rightsideset = true
+    end
+    i = i + 1
+end
+
+-- left side
+litleds = 0
+i = 1
+while(i <= proxcars and leftsideset == false) do
+    if simdata.pd[i].theta > 230 and simdata.pd[i].theta < 320 then
+        dist = math.abs(270 - simdata.pd[1].theta)
+        perct = (90 - dist)/90
+        litleds = math.ceil(perct * left_num_leds)
+
+        color_perct = simdata.pd[i].radius/10
+        yellow = math.floor(color_perct * 255)
+        local rgb = (255 << 16) | (yellow << 8) | (0 << 0)
+        if simdata.pd[1].theta <= 270 then
+            -- car is behind
+            set_led_range_to_rgb_color(left_leds_start, left_leds_start + litleds, rgb)
+        else
+            set_led_range_to_rgb_color(left_leds_start + (left_num_leds - litleds), left_leds_start + left_num_leds, rgb)
+        end
+        leftsideset = true
+    end
+    i = i + 1
+end
+
@@ -0,0 +1 @@
+Message = simdata.velocity .. ";" .. simdata.gear .. ";" .. simdata.rpm .. ";"
@@ -1,64 +1,243 @@
-devices = ( {   device       = "USB";
-                type         = "Tachometer";
-                devid        = "98FD:83AC";
-                subtype      = "Revburner";
-                granularity  = 2;
-                config       = "~/.config/monocoque/revburner15000.xml"; },
-            {   device       = "Sound";
-                effect       = "Engine";
-                devid        = "alsa_output.usb-Generic_USB2.0_Device_20170726905959-00.analog-stereo";
-                pan          = 1;
-                volume       = 90;
-                frequency    = 27; },
-            {   device       = "Sound";
-                effect       = "Gear"
-                devid        = "alsa_output.usb-Generic_USB2.0_Device_20170726905959-00.analog-stereo";
-                pan          = 1;
-                duration     = .25;
-                volume       = 100;
-                frequency    = 27; },
-            {   device       = "USB";
-                type         = "Haptic";
-                subtype      = "ClubSportElitePedalsV3";
-                effect       = "ABS";
-                tyre         = "ALL";
-                threshold    = 0.05; },
-            {   device       = "USB";
-                type         = "Haptic";
-                subtype      = "ClubSportElitePedalsV3";
-                effect       = "Slip";
-                tyre         = "REARS";
-                threshold    = 0.75; },
-            {   device       = "USB";
-                type         = "Haptic";
-                subtype      = "ClubSportElitePedalsV3";
-                effect       = "Lock";
-                tyre         = "ALL";
-                threshold    = 0.75; },
-            {   device       = "Serial";
-                type         = "SimWind";
-                config       = "None";
-                devpath      = "/dev/ttyACM1"; },
-            {   device       = "Serial";
-                type         = "ShiftLights";
-                config       = "None";
-                devpath      = "/dev/ttyACM0"; },
-            {   device       = "Serial";
-                type         = "Haptic";
-                effect       = "TyreSlip";
-                tyre         = "ALL"; // motor m1 connected to throttle
-                motors       = 0;
-                devpath      = "/dev/ttyACM0"; },
-            {   device       = "Serial";
-                type         = "Haptic";
-                effect       = "TyreLock";
-                tyre         = "ALL"; // motor m3 connected to brake;
-                motors       = 2;
-                devpath      = "/dev/ttyACM0"; },
-            {   device       = "Serial";
-                type         = "Haptic"
-                effect       = "ABS";
-                tyre         = "ALL"; // this will have to be documented, this tells the code to spin both motors
-                motors       = 8;
-                devpath      = "/dev/ttyACM0";}
-          );
+configs = (
+    {
+        sim = "default";
+        // one can also specify sim by using the "short-name" for example "ac". also, "acc", "ace", "ams2", "et", "at" and "rf2"
+        //sim = "ac";
+        car = "default";
+        devices = (
+        {
+            device       = "USB";
+            type         = "Tachometer";
+            devid        = "98FD:83AC";
+            subtype      = "Revburner";
+            granularity  = 2;
+            config       = "~/.config/monocoque/revburner15000.xml";
+        },
+
+        {
+            device       = "Sound";
+            effect       = "Engine";
+            devid        = "alsa_output.pci-0000_0d_00.0.analog-surround-71";
+            pan          = 3;
+            fps          = 60;
+            threshold    = 0.2;
+            channels     = 8;
+            volume       = 70;
+            modulation   = "frequency";
+            frequency    = 17;
+            frequencyMax = 37;
+        },
+        {
+            device       = "Sound";
+            effect       = "Gear"
+            devid        = "alsa_output.pci-0000_0d_00.0.analog-surround-71";
+            pan          = 3;
+            fps          = 60;
+            threshold    = 0.2;
+            channels     = 8;
+            duration     = .6;
+            volume       = 100;
+            frequency    = 15;
+        },
+
+
+
+        {
+            device       = "Sound";
+            effect       = "TyreSlip";
+            tyre         = "RearLeft";
+            devid        = "alsa_output.pci-0000_0d_00.0.analog-surround-71";
+            pan          = 4;
+            channels     = 8;
+            threshold    = 0.2;
+            fps          = 60;
+            volume       = 100;
+            modulation   = "frequency";
+            frequency    = 30;
+            frequencyMax = 37;
+        },
+        {
+            device       = "Sound";
+            effect       = "TyreSlip";
+            tyre         = "RearRight";
+            devid        = "alsa_output.pci-0000_0d_00.0.analog-surround-71";
+            pan          = 5;
+            fps          = 60;
+            channels     = 8;
+            threshold    = 0.2;
+            volume       = 100;
+            modulation   = "frequency";
+            frequency    = 30;
+            frequencyMax = 37;
+        },
+        {
+            device       = "Sound";
+            effect       = "TyreSlip";
+            tyre         = "FrontLeft";
+            devid        = "alsa_output.pci-0000_0d_00.0.analog-surround-71";
+            pan          = 0;
+            channels     = 8;
+            threshold    = 0.2;
+            volume       = 100;
+            modulation   = "frequency";
+            frequency    = 30;
+            frequencyMax = 37;
+        },
+        {
+            device       = "Sound";
+            effect       = "TyreSlip";
+            tyre         = "FrontRight";
+            devid        = "alsa_output.pci-0000_0d_00.0.analog-surround-71";
+            pan          = 1;
+            channels     = 8;
+            threshold    = 0.2;
+            volume       = 100;
+            modulation   = "frequency";
+            frequency    = 30;
+            frequencyMax = 37;
+        },
+
+
+
+        {
+            device       = "Sound";
+            effect       = "TyreLock";
+            tyre         = "RearLeft";
+            devid        = "alsa_output.pci-0000_0d_00.0.analog-surround-71";
+            pan          = 4;
+            channels     = 8;
+            threshold    = 0.2;
+            volume       = 100;
+            modulation   = "frequency";
+            frequency    = 30;
+            frequencyMax = 37;
+        },
+        {
+            device       = "Sound";
+            effect       = "TyreLock";
+            tyre         = "RearRight";
+            devid        = "alsa_output.pci-0000_0d_00.0.analog-surround-71";
+            pan          = 5;
+            channels     = 8;
+            threshold    = 0.2;
+            modulation   = "frequency";
+            volume       = 100;
+            frequency    = 30;
+            frequencyMax = 37;
+        },
+        {
+            device       = "Sound";
+            effect       = "TyreLock";
+            tyre         = "FrontLeft";
+            devid        = "alsa_output.pci-0000_0d_00.0.analog-surround-71";
+            pan          = 0;
+            channels     = 8;
+            threshold    = 0.2;
+            volume       = 100;
+            modulation   = "frequency";
+            frequency    = 30;
+            frequencyMax = 37;
+        },
+        {
+            device       = "Sound";
+            effect       = "TyreLock";
+            tyre         = "FrontRight";
+            devid        = "alsa_output.pci-0000_0d_00.0.analog-surround-71";
+            pan          = 1;
+            channels     = 8;
+            threshold    = 0.2;
+            volume       = 100;
+            modulation   = "frequency";
+            frequency    = 30;
+            frequencyMax = 37;
+        },
+
+        {
+            device       = "USB";
+            type         = "Haptic";
+            subtype      = "CSLELITEV3PEDALS";
+            //devpath      = "/sys/module/hid_fanatec/drivers/hid:fanatec/0003:0EB7:183B.0002/rumble";
+            devpath      = "/sys/module/hid_fanatec/drivers/hid:ftec_csl_elite/0003:0EB7:183B.0002/rumble";
+            effect       = "ABS";
+            tyre         = "ALL";
+            threshold    = 0.2;
+            value0       = 0;
+            value1       = 16776960;
+        },
+        {
+            device       = "USB";
+            type         = "Haptic";
+            subtype      = "CSLELITEV3PEDALS";
+            //devpath      = "/sys/module/hid_fanatec/drivers/hid:fanatec/0003:0EB7:183B.0002/rumble";
+            devpath      = "/sys/module/hid_fanatec/drivers/hid:ftec_csl_elite/0003:0EB7:183B.0002/rumble";
+            effect       = "Slip";
+            tyre         = "ALL";
+            threshold    = 0.2;
+            value0       = 0;
+            value1       = 16711680;
+        },
+        {
+            device       = "USB";
+            type         = "Haptic";
+            subtype      = "CSLELITEV3PEDALS";
+            //devpath      = "/sys/module/hid_fanatec/drivers/hid:fanatec/0003:0EB7:183B.0002/rumble";
+            devpath      = "/sys/module/hid_fanatec/drivers/hid:ftec_csl_elite/0003:0EB7:183B.0002/rumble";
+            effect       = "Lock";
+            tyre         = "ALL";
+            threshold    = 0.2;
+            value0       = 0;
+            value1       = 65280;
+        },
+
+        {
+            device       = "Serial";
+            type         = "Haptic";
+            effect       = "TyreSlip";
+            tyre         = "ALL"; // motor m1 connected to throttle
+            motors       = 0;
+            devpath      = "/dev/ttyACM0";
+        },
+        {
+            device       = "Serial";
+            type         = "Haptic";
+            effect       = "TyreLock";
+            tyre         = "ALL"; // motor m3 connected to brake;
+            motors       = 2;
+            devpath      = "/dev/ttyACM0";
+        },
+        {
+            device       = "Serial";
+            type         = "Haptic"
+            effect       = "ABS";
+            tyre         = "ALL"; // this will have to be documented, this tells the code to spin both motors
+            motors       = 8;
+            devpath      = "/dev/ttyACM0";
+        },
+        {
+            device       = "Serial";
+            type         = "SimWind";
+            config       = "None";
+            baud         = 115200;
+            devpath      = "/dev/simdev1";
+        },
+
+        {
+            device       = "Serial";
+            type         = "SimWind";
+            config       = "None";
+            baud         = 115200;
+            devpath      = "/dev/simdev1";
+        },
+
+        {
+            device       = "Serial";
+            type         = "Simleds";
+            numleds      = 6;
+            startled     = 2;
+            endled       = 5;
+            config       = "~/git/monocoque/conf/rpms_and_radar.lua"
+            baud         = 115200;
+            devpath      = "/dev/simdev0";
+        });
+    }
+);
@@ -0,0 +1,48 @@
+-- from simapi.h
+ --   SIMAPI_FLAG_GREEN            = 0,
+ --   SIMAPI_FLAG_YELLOW           = 1,
+ --   SIMAPI_FLAG_RED              = 2,
+ --   SIMAPI_FLAG_CHEQUERED        = 3,
+ --   SIMAPI_FLAG_BLUE             = 4,
+ --   SIMAPI_FLAG_WHITE            = 5,
+ --   SIMAPI_FLAG_BLACK            = 6,
+ --   SIMAPI_FLAG_BLACK_WHITE      = 7,
+ --   SIMAPI_FLAG_BLACK_ORANGE     = 8,
+ --   SIMAPI_FLAG_ORANGE           = 9
+
+led_clear_all()
+
+if simdata.rpm > 0 and simdata.maxrpm > 0 then
+    rpmmargin = .05*simdata.maxrpm;
+    rpminterval = (simdata.maxrpm-rpmmargin) / 14;
+
+    litleds = 0
+    for i = 1,14 do
+        if simdata.rpm >= (rpminterval * i) then
+            litleds = i;
+        end
+    end
+
+    color = GREEN
+    if litleds > 5 and litleds < 12 then
+        color = YELLOW
+    end
+    if litleds >= 12 then
+        color = RED
+    end
+    set_led_range_to_color(59, 59+litleds, color)
+end
+
+if simdata.playerflag == 0 then
+     set_led_range_to_color(4, 7, GREEN)
+end
+
+
+if simdata.playerflag == 1 then
+     set_led_range_to_color(4, 7, YELLOW)
+end
+
+
+if simdata.playerflag == 4 then
+     set_led_range_to_color(4, 7, BLUE)
+end
@@ -0,0 +1,55 @@
+-- from simapi.h
+ --   SIMAPI_FLAG_GREEN            = 0,
+ --   SIMAPI_FLAG_YELLOW           = 1,
+ --   SIMAPI_FLAG_RED              = 2,
+ --   SIMAPI_FLAG_CHEQUERED        = 3,
+ --   SIMAPI_FLAG_BLUE             = 4,
+ --   SIMAPI_FLAG_WHITE            = 5,
+ --   SIMAPI_FLAG_BLACK            = 6,
+ --   SIMAPI_FLAG_BLACK_WHITE      = 7,
+ --   SIMAPI_FLAG_BLACK_ORANGE     = 8,
+ --   SIMAPI_FLAG_ORANGE           = 9
+
+if simdata.rpm > 0 and simdata.maxrpm > 0 then
+    rpmmargin = .05*simdata.maxrpm;
+    rpminterval = (simdata.maxrpm-rpmmargin) / 6;
+
+    litleds = 0
+    for i = 1,6 do
+        if simdata.rpm >= (rpminterval * i) then
+            litleds = i;
+        end
+    end
+
+    color = GREEN
+    if litleds > 3 and litleds < 6 then
+        color = YELLOW
+    end
+    if litleds >= 6 then
+        color = RED
+    end
+    if litleds >=  6 then
+
+        if simdata.mtick % 2 == 0 then
+            set_led_range_to_color(1, litleds, color)
+        else
+            led_clear_all()
+        end
+    else
+        set_led_range_to_color(1, litleds, color)
+    end
+end
+
+if simdata.playerflag == 0 then
+     set_led_range_to_color(7, 48, GREEN)
+end
+
+
+if simdata.playerflag == 1 then
+     set_led_range_to_color(7, 48, YELLOW)
+end
+
+
+if simdata.playerflag == 4 then
+     set_led_range_to_color(7, 48, BLUE)
+end
@@ -0,0 +1,91 @@
+-- configuration
+-- set these accordingly
+right_leds_start = 7
+right_num_leds = 42
+left_leds_start = 49
+left_num_leds = 42
+--
+
+max_radius = 10 -- radius is hardcoded in simapi
+proxcars = simdata.proxcars -- also hard coded in simapi
+
+rightsideset = false
+leftsideset = false
+
+-- right side
+litleds = 0
+i = 1
+while(i <= proxcars and rightsideset == false) do
+    if simdata.pd[i].theta > 40 and simdata.pd[i].theta < 130 then
+        dist = math.abs(90 - simdata.pd[i].theta)
+        perct = (90 - dist)/90
+        litleds = math.ceil(perct * right_num_leds)
+
+        color_perct = simdata.pd[i].radius/10
+        yellow = math.floor(color_perct * 255)
+        local rgb = (255 << 16) | (yellow << 8) | (0 << 0)
+        if simdata.pd[1].theta >= 90 then
+            -- car is behind
+            set_led_range_to_rgb_color(right_leds_start, right_leds_start + litleds, rgb)
+        else
+            set_led_range_to_rgb_color(right_leds_start + (right_num_leds - litleds), right_leds_start + right_num_leds, rgb)
+        end
+        rightsideset = true
+    end
+    i = i + 1
+end
+
+-- left side
+litleds = 0
+i = 1
+while(i <= proxcars and leftsideset == false) do
+    if simdata.pd[i].theta > 230 and simdata.pd[i].theta < 320 then
+        dist = math.abs(270 - simdata.pd[1].theta)
+        perct = (90 - dist)/90
+        litleds = math.ceil(perct * left_num_leds)
+
+        color_perct = simdata.pd[i].radius/10
+        yellow = math.floor(color_perct * 255)
+        local rgb = (255 << 16) | (yellow << 8) | (0 << 0)
+        if simdata.pd[1].theta <= 270 then
+            -- car is behind
+            set_led_range_to_rgb_color(left_leds_start, left_leds_start + litleds, rgb)
+        else
+            set_led_range_to_rgb_color(left_leds_start + (left_num_leds - litleds), left_leds_start + left_num_leds, rgb)
+        end
+        leftsideset = true
+    end
+    i = i + 1
+end
+
+rpm_leds = 6
+-- rpm stuff
+if simdata.rpm > 0 and simdata.maxrpm > 0 then
+    rpmmargin = .05*simdata.maxrpm;
+    rpminterval = (simdata.maxrpm-rpmmargin) / rpm_leds;
+
+    litleds = 0
+    for i = 1,6 do
+        if simdata.rpm >= (rpminterval * i) then
+            litleds = i;
+        end
+    end
+
+    color = GREEN
+    if litleds > rpm_leds/2 and litleds < rpm_leds then
+        color = YELLOW
+    end
+    if litleds >= rpm_leds then
+        color = RED
+    end
+    if litleds >= rpm_leds then
+
+        if simdata.mtick % 2 == 0 then
+            set_led_range_to_color(1, litleds, color)
+        else
+            led_clear_range(1, rpm_leds)
+        end
+    else
+        set_led_range_to_color(1, litleds, color)
+    end
+end
@@ -0,0 +1,554 @@
+#!/bin/bash
+set -e
+
+# Monocoque Universal Installer
+# Works on: Arch, Debian/Ubuntu, Fedora, and other major distros
+# Version: 1.0.0
+
+SCRIPT_VERSION="1.0.0"
+INSTALL_DIR="${MONOCOQUE_INSTALL_DIR:-${XDG_DATA_HOME:-$HOME/.local/share}/monocoque}"
+CONFIG_DIR="${XDG_CONFIG_HOME:-$HOME/.config}"
+BIN_DIR="${HOME}/.local/bin"
+
+# Color output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Logging functions
+log_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+log_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+log_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+print_header() {
+    echo ""
+    echo "╔══════════════════════════════════════════════════════════════════╗"
+    echo "║          Monocoque Universal Installer v${SCRIPT_VERSION}             ║"
+    echo "╚══════════════════════════════════════════════════════════════════╝"
+    echo ""
+}
+
+# Detect distribution
+detect_distro() {
+    if [ -f /etc/os-release ]; then
+        . /etc/os-release
+        DISTRO=$ID
+        DISTRO_VERSION=$VERSION_ID
+        DISTRO_LIKE=$ID_LIKE
+    elif [ -f /etc/arch-release ]; then
+        DISTRO="arch"
+    else
+        DISTRO="unknown"
+    fi
+    
+    # Normalize Arch-based distributions
+    if [[ "$DISTRO_LIKE" == *"arch"* ]] || [[ "$DISTRO" == "manjaro" ]] || [[ "$DISTRO" == "garuda" ]] || [[ "$DISTRO" == "endeavouros" ]]; then
+        log_info "Detected distribution: $DISTRO (Arch-based)"
+        DISTRO="arch"
+    else
+        log_info "Detected distribution: $DISTRO"
+    fi
+}
+
+# Check if running as root
+check_root() {
+    if [ "$EUID" -eq 0 ]; then
+        log_error "Please do not run this script as root"
+        exit 1
+    fi
+}
+
+# Check for required commands
+check_requirements() {
+    local missing_commands=()
+    
+    for cmd in git cmake make gcc; do
+        if ! command -v $cmd &> /dev/null; then
+            missing_commands+=($cmd)
+        fi
+    done
+    
+    if [ ${#missing_commands[@]} -ne 0 ]; then
+        log_error "Missing required commands: ${missing_commands[*]}"
+        log_info "Please install them first"
+        exit 1
+    fi
+}
+
+# Install dependencies based on distro
+install_dependencies() {
+    log_info "Installing dependencies for $DISTRO..."
+    
+    case $DISTRO in
+        arch|manjaro)
+            local deps="yder libuv argtable libserialport libconfig hidapi lua libxdg-basedir mingw-w64-gcc"
+            
+            # Check if yay is available for AUR
+            if command -v yay &> /dev/null; then
+                log_info "Using yay to check for AUR packages..."
+                echo ""
+                echo "You can install monocoque from AUR instead:"
+                echo "  yay -S simapi-git simd-git monocoque-git"
+                echo ""
+                read -p "Install from AUR? (recommended) [Y/n]: " use_aur
+                
+                if [[ ! $use_aur =~ ^[Nn]$ ]]; then
+                    log_info "Installing from AUR..."
+                    yay -S --needed simapi-git simd-git monocoque-git
+                    
+                    # Still need simshmbridge
+                    log_info "Building simshmbridge (not in AUR)..."
+                    build_simshmbridge_only
+                    
+                    # Setup configs and services
+                    setup_configs
+                    setup_systemd_services
+                    # create_launcher_scripts uses SCRIPT_DIR which is set in main()
+                    create_launcher_scripts
+                    
+                    log_success "Installation complete (AUR method)!"
+                    print_next_steps
+                    exit 0
+                fi
+            fi
+            
+            log_info "Installing build dependencies with pacman..."
+            sudo pacman -S --needed --noconfirm $deps
+            ;;
+            
+        ubuntu|debian|linuxmint|pop)
+            local deps="build-essential git cmake libyder-dev libuv1-dev libargtable2-dev libserialport-dev libconfig-dev libhidapi-dev lua5.3 liblua5.3-dev libxdg-basedir-dev mingw-w64"
+            
+            log_info "Updating package lists..."
+            sudo apt-get update
+            
+            log_info "Installing build dependencies..."
+            sudo apt-get install -y $deps
+            ;;
+            
+        fedora|rhel|centos)
+            local deps="git cmake gcc gcc-c++ yder-devel libuv-devel argtable-devel libserialport-devel libconfig-devel hidapi-devel lua-devel libxdg-basedir-devel mingw64-gcc"
+            
+            log_info "Installing build dependencies..."
+            sudo dnf install -y $deps
+            ;;
+            
+        opensuse*)
+            local deps="git cmake gcc gcc-c++ libyder-devel libuv-devel argtable-devel libserialport-devel libconfig-devel hidapi-devel lua-devel libxdg-basedir-devel mingw64-gcc"
+            
+            log_info "Installing build dependencies..."
+            sudo zypper install -y $deps
+            ;;
+            
+        *)
+            log_error "Unsupported distribution: $DISTRO"
+            log_info "Please install dependencies manually and try again"
+            log_info "Required: git, cmake, gcc, yder, libuv, argtable, libserialport, libconfig, hidapi, lua, libxdg-basedir, mingw-gcc"
+            exit 1
+            ;;
+    esac
+    
+    log_success "Dependencies installed"
+}
+
+# Clone repositories
+clone_repositories() {
+    log_info "Creating installation directory: $INSTALL_DIR"
+    mkdir -p "$INSTALL_DIR"
+    cd "$INSTALL_DIR"
+    
+    # Clone monocoque
+    if [ ! -d "monocoque" ]; then
+        log_info "Cloning monocoque..."
+        git clone https://github.com/Spacefreak18/monocoque.git
+        cd monocoque
+        git submodule sync --recursive
+        git submodule update --init --recursive
+    else
+        log_info "monocoque already cloned, updating..."
+        cd monocoque
+        git pull
+        git submodule sync --recursive
+        git submodule update --init --recursive
+    fi
+    cd "$INSTALL_DIR"
+    
+    # Clone simapi
+    if [ ! -d "simapi" ]; then
+        log_info "Cloning simapi..."
+        git clone https://github.com/Spacefreak18/simapi.git
+    else
+        log_info "simapi already cloned, updating..."
+        cd simapi
+        git pull
+    fi
+    cd "$INSTALL_DIR"
+    
+    # Clone simshmbridge
+    if [ ! -d "simshmbridge" ]; then
+        log_info "Cloning simshmbridge..."
+        git clone https://github.com/spacefreak18/simshmbridge.git
+        cd simshmbridge
+        git submodule sync --recursive
+        git submodule update --init --recursive
+    else
+        log_info "simshmbridge already cloned, updating..."
+        cd simshmbridge
+        git pull
+        git submodule sync --recursive
+        git submodule update --init --recursive
+    fi
+    
+    log_success "Repositories cloned/updated"
+}
+
+# Build simapi
+build_simapi() {
+    log_info "Building simapi..."
+    cd "$INSTALL_DIR/simapi"
+    
+    mkdir -p build
+    cd build
+    cmake ..
+    make -j$(nproc)
+    
+    log_info "Installing simapi library..."
+    sudo make install
+    
+    # Update library cache
+    sudo ldconfig 2>/dev/null || true
+    
+    log_success "simapi built and installed"
+}
+
+# Build simd
+build_simd() {
+    log_info "Building simd..."
+    cd "$INSTALL_DIR/simapi/simd"
+    
+    rm -rf build
+    mkdir -p build
+    cd build
+    cmake ..
+    make -j$(nproc)
+    
+    log_success "simd built"
+}
+
+# Build simshmbridge
+build_simshmbridge() {
+    log_info "Building simshmbridge..."
+    cd "$INSTALL_DIR/simshmbridge"
+    
+    make clean || true
+    make -j$(nproc)
+    
+    log_success "simshmbridge built"
+}
+
+build_simshmbridge_only() {
+    mkdir -p "$INSTALL_DIR"
+    cd "$INSTALL_DIR"
+    
+    if [ ! -d "simshmbridge" ]; then
+        log_info "Cloning simshmbridge..."
+        git clone https://github.com/spacefreak18/simshmbridge.git
+        cd simshmbridge
+        git submodule sync --recursive
+        git submodule update --init --recursive
+    fi
+    
+    build_simshmbridge
+}
+
+# Build monocoque
+build_monocoque() {
+    log_info "Building monocoque..."
+    cd "$INSTALL_DIR/monocoque"
+    
+    mkdir -p build
+    cd build
+    cmake ..
+    make -j$(nproc)
+    
+    log_success "monocoque built"
+}
+
+# Setup configuration files
+setup_configs() {
+    log_info "Setting up configuration files..."
+    
+    # simd config
+    mkdir -p "$CONFIG_DIR/simd"
+    if [ ! -f "$CONFIG_DIR/simd/simd.config" ]; then
+        if [ -f "$INSTALL_DIR/simapi/simd/conf/simd.config" ]; then
+            cp "$INSTALL_DIR/simapi/simd/conf/simd.config" "$CONFIG_DIR/simd/simd.config"
+            log_success "Created simd config"
+        fi
+    else
+        log_info "simd config already exists, skipping"
+    fi
+    
+    # monocoque config
+    mkdir -p "$CONFIG_DIR/monocoque"
+    if [ ! -f "$CONFIG_DIR/monocoque/monocoque.config" ]; then
+        cat > "$CONFIG_DIR/monocoque/monocoque.config" << 'EOF'
+configs = (
+    {
+        sim = "default";
+        car = "default";
+        devices = (
+        // Add your devices here
+        // Example: Serial device (ESP32/Arduino)
+        /*
+        {
+            device       = "Serial";
+            type         = "Custom";
+            config       = "None";
+            baud         = 115200;
+            devpath      = "/dev/ttyUSB0";
+        },
+        */
+        
+        // Example: Bass shaker
+        /*
+        {
+            device       = "Sound";
+            effect       = "Engine";
+            devid        = "alsa_output.your_device_here";
+            pan          = 0;
+            fps          = 60;
+            threshold    = 0.2;
+            channels     = 2;
+            volume       = 70;
+            modulation   = "frequency";
+            frequency    = 17;
+            frequencyMax = 37;
+        },
+        */
+        );
+    }
+);
+EOF
+        log_success "Created monocoque config"
+    else
+        log_info "monocoque config already exists, skipping"
+    fi
+}
+
+# Create launcher scripts
+create_launcher_scripts() {
+    log_info "Creating launcher scripts in $BIN_DIR..."
+    mkdir -p "$BIN_DIR"
+    
+    # Find simd binary location
+    local SIMD_BIN=""
+    if [ -f "$INSTALL_DIR/simapi/simd/build/simd" ]; then
+        SIMD_BIN="$INSTALL_DIR/simapi/simd/build/simd"
+    elif command -v simd &> /dev/null; then
+        SIMD_BIN=$(which simd)
+    fi
+    
+    # Find monocoque binary location
+    local MONOCOQUE_BIN=""
+    if [ -f "$INSTALL_DIR/monocoque/build/monocoque" ]; then
+        MONOCOQUE_BIN="$INSTALL_DIR/monocoque/build/monocoque"
+    elif command -v monocoque &> /dev/null; then
+        MONOCOQUE_BIN=$(which monocoque)
+    fi
+    
+    # start-simd script
+    cat > "$BIN_DIR/start-simd" << EOF
+#!/bin/bash
+export LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:/usr/local/lib:/usr/local/lib64
+exec $SIMD_BIN -vv "\$@"
+EOF
+    chmod +x "$BIN_DIR/start-simd"
+    
+    # start-monocoque script
+    cat > "$BIN_DIR/start-monocoque" << EOF
+#!/bin/bash
+exec $MONOCOQUE_BIN play "\$@"
+EOF
+    chmod +x "$BIN_DIR/start-monocoque"
+    
+    # test-monocoque script
+    cat > "$BIN_DIR/test-monocoque" << EOF
+#!/bin/bash
+exec $MONOCOQUE_BIN test -vv "\$@"
+EOF
+    chmod +x "$BIN_DIR/test-monocoque"
+    
+    # monocoque-manager TUI
+    log_info "Looking for monocoque-manager to install..."
+    local MANAGER_INSTALLED=false
+    
+    # Use the SCRIPT_DIR exported from main()
+    # Try multiple locations
+    local SEARCH_PATHS=(
+        "$SCRIPT_DIR/monocoque-manager"
+        "$SCRIPT_DIR/tools/monocoque-manager"
+    )
+    
+    for MANAGER_PATH in "${SEARCH_PATHS[@]}"; do
+        log_info "Checking: $MANAGER_PATH"
+        if [ -f "$MANAGER_PATH" ]; then
+            log_info "Found monocoque-manager at: $MANAGER_PATH"
+            cp "$MANAGER_PATH" "$BIN_DIR/monocoque-manager"
+            chmod +x "$BIN_DIR/monocoque-manager"
+            log_success "✓ Installed monocoque-manager TUI to $BIN_DIR/monocoque-manager"
+            MANAGER_INSTALLED=true
+            break
+        fi
+    done
+    
+    if [ "$MANAGER_INSTALLED" = false ]; then
+        log_error "monocoque-manager not found!"
+        log_warn "Searched in: ${SEARCH_PATHS[*]}"
+        log_warn "SCRIPT_DIR was: $SCRIPT_DIR"
+        log_info "Please copy it manually: cp $SCRIPT_DIR/monocoque-manager ~/.local/bin/"
+    fi
+    
+    # Check if BIN_DIR is in PATH
+    if [[ ":$PATH:" != *":$BIN_DIR:"* ]]; then
+        log_warn "$BIN_DIR is not in your PATH"
+        log_info "Add this to your shell config:"
+        echo "    # For bash/zsh:"
+        echo "    export PATH=\"\$HOME/.local/bin:\$PATH\""
+        echo ""
+        echo "    # For fish:"
+        echo "    fish_add_path ~/.local/bin"
+    fi
+    
+    log_success "Launcher scripts created"
+}
+
+# Setup systemd user services
+setup_systemd_services() {
+    local SYSTEMD_DIR="$HOME/.config/systemd/user"
+    mkdir -p "$SYSTEMD_DIR"
+    
+    log_info "Creating systemd service files..."
+    
+    # Find binary locations
+    local SIMD_BIN=""
+    if [ -f "$INSTALL_DIR/simapi/simd/build/simd" ]; then
+        SIMD_BIN="$INSTALL_DIR/simapi/simd/build/simd"
+    elif command -v simd &> /dev/null; then
+        SIMD_BIN=$(which simd)
+    fi
+    
+    # simd service
+    cat > "$SYSTEMD_DIR/simd.service" << EOF
+[Unit]
+Description=Sim Telemetry Daemon
+Documentation=https://spacefreak18.github.io/simapi/
+After=network.target
+
+[Service]
+Type=simple
+Environment="LD_LIBRARY_PATH=/usr/local/lib:/usr/local/lib64"
+ExecStart=$SIMD_BIN
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+EOF
+    
+    log_success "systemd services created"
+    log_info "To enable auto-start on boot:"
+    echo "    systemctl --user enable simd.service"
+    echo "    systemctl --user start simd.service"
+}
+
+# Print next steps
+print_next_steps() {
+    echo ""
+    echo "╔══════════════════════════════════════════════════════════════════╗"
+    echo "║                    Installation Complete!                        ║"
+    echo "╚══════════════════════════════════════════════════════════════════╝"
+    echo ""
+    log_success "Monocoque and all components are installed!"
+    echo ""
+    echo "📁 Installation location: $INSTALL_DIR"
+    echo "⚙️  Configuration: $CONFIG_DIR/simd and $CONFIG_DIR/monocoque"
+    echo "🚀 Launcher scripts: $BIN_DIR"
+    echo ""
+    echo "Next steps:"
+    echo ""
+    echo "1️⃣  Configure your games (REQUIRED!)"
+    echo "   See: https://github.com/Spacefreak18/monocoque/blob/master/HOW-TO-USE.md"
+    echo ""
+    echo "2️⃣  Start the services:"
+    echo "   Terminal 1: start-simd"
+    echo "   Terminal 2: start-monocoque"
+    echo ""
+    echo "   OR enable auto-start:"
+    echo "   systemctl --user enable --now simd.service"
+    echo ""
+    echo "3️⃣  Configure your devices:"
+    echo "   Edit: $CONFIG_DIR/monocoque/monocoque.config"
+    echo ""
+    echo "4️⃣  Test your setup:"
+    echo "   test-monocoque"
+    echo ""
+    echo "🎮 Supported games:"
+    echo "   • Assetto Corsa / ACC"
+    echo "   • Automobilista 2"
+    echo "   • Project Cars 2"
+    echo "   • RFactor 2"
+    echo "   • Euro/American Truck Simulator"
+    echo ""
+    echo "📚 Documentation: https://spacefreak18.github.io/simapi/"
+    echo ""
+}
+
+# Main installation flow
+main() {
+    # Save the directory where this script is located
+    SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+    export SCRIPT_DIR
+    
+    print_header
+    
+    check_root
+    detect_distro
+    check_requirements
+    
+    log_info "Starting installation..."
+    echo ""
+    
+    install_dependencies
+    clone_repositories
+    
+    log_info "Building components (this may take a few minutes)..."
+    build_simapi
+    build_simd
+    build_monocoque
+    build_simshmbridge
+    
+    setup_configs
+    create_launcher_scripts
+    setup_systemd_services
+    
+    print_next_steps
+}
+
+# Run main function
+main "$@"
+
@@ -0,0 +1,166 @@
+# Makefile for Arduino based scketches
+#
+# Copyright 2020 Valerio Di Giampietro http://va.ler.io v@ler.io
+# MIT License - see License.txt file
+#
+# This Makefile uses the arduino-cli, the Arduino command line interface
+# and has been designed and tested to run on Linux, not on Windows.
+# Probably it will run on a Mac, but it has not been tested.
+#
+# Please note that:
+#
+#   1. each sketch must reside in his own folder with this Makefile
+#
+#   2. the main make targets are:
+#      - all     compiles and upload
+#      - compile compiles only
+#      - upload  upload via serial port, compile if the binary file is
+#                not available
+#      - ota     upload Over The Air, automatically find the device
+#                IP address using the IOT_NAME (device hostname)
+#      - clean   clean the build directory
+#      - find    find OTA updatable devices on the local subnet
+#      - requirements it the file "requirements.txt" exists it will
+#                     install the libraries listed in this file
+#
+#      default is "all"
+#
+#   3. it gets the name of the sketch using the wildcard make command;
+#      the name is *.ino; this means that you must have ONLY a file
+#      with .ino extension, otherwise this makefile will break.  This
+#      also means that you can use this Makefile, almost unmodified,
+#      for any sketch as long as you keep a single .ino file in each
+#      folder
+#
+#   4. you can split your project in multiple files, if you wish,
+#      using a single .ino file and multiple .h files, that you can
+#      include in the .ino file with an '#include "myfile.h"'
+#      directive
+#
+# Optionally some environment variables can be set:
+#
+#   FQBN        Fully Qualified Board Name; if not set in the environment
+#               it will be assigned a value in this makefile
+#
+#   SERIAL_DEV  Serial device to upload the sketch; if not set in the
+#               environment it will be assigned:
+#               /dev/ttyUSB0   if it exists, or
+#               /dev/ttyACM0   if it exists, or
+#               unknown
+#
+#   IOT_NAME    Name of the IOT device; if not set in the environment
+#               it will be assigned a value in this makefile. This is
+#               very useful for OTA update, the device will be searched
+#               on the local subnet using this name
+#
+#   OTA_PORT    Port used by OTA update; if not set in the environment
+#               it will be assigned the default value of 8266 in this
+#               makefile
+#
+#   OTA_PASS    Password used for OTA update; if not set in the environment
+#               it will be assigned the default value of an empty string
+#
+#   V           verbose flag; can be 0 (quiet) or 1 (verbose); if not set
+#               in the environment it will be assigned a default value
+#               in this makefile
+
+
+MAKE_DIR   := $(PWD)
+#
+# ----- setup wor Wemos D1 mini -----
+#FQBN       ?= esp8266:esp8266:d1_mini
+#IOT_NAME   ?= esp8266-meteo
+#OTA_PORT   ?= 8266
+#OTA_PASS   ?=
+# ----- setup for Arduino Uno
+FQBN        ?= arduino:avr:uno
+# ----- ---------------------
+V          ?= 0
+VFLAG      =
+
+ifeq "$(V)" "1"
+VFLAG      =-v
+endif
+
+ifndef SERIAL_DEV
+  ifneq (,$(wildcard /dev/ttyUSB0))
+    SERIAL_DEV = /dev/ttyUSB0
+  else ifneq (,$(wildcard /dev/ttyACM0))
+    SERIAL_DEV = /dev/ttyACM0
+  else
+    SERIAL_DEV = unknown
+  endif
+endif
+
+BUILD_DIR  := $(subst :,.,build/$(FQBN))
+
+SRC        := $(wildcard *.ino)
+HDRS       := $(wildcard *.h)
+BIN        := $(BUILD_DIR)/$(SRC).bin
+ELF        := $(BUILD_DIR)/$(SRC).elf
+
+$(info FQBN       is [${FQBN}])
+$(info IOT_NAME   is [${IOT_NAME}])
+$(info OTA_PORT   is [${OTA_PORT}])
+$(info OTA_PASS   is [${OTA_PASS}])
+$(info V          is [${V}])
+$(info VFLAG      is [${VFLAG}])
+$(info MAKE_DIR   is [${MAKE_DIR}])
+$(info BUILD_DIR  is [${BUILD_DIR}])
+$(info SRC        is [${SRC}])
+$(info HDRS       is [${HDRS}])
+$(info BIN        is [${BIN}])
+$(info SERIAL_DEV is [${SERIAL_DEV}])
+
+all: $(ELF) upload
+.PHONY: all
+
+compile: $(ELF)
+.PHONY: compile
+
+$(ELF): $(SRC) $(HDRS)
+	arduino-cli compile -b $(FQBN) $(VFLAG)
+	@if which arduino-manifest.pl; \
+	then echo "---> Generating manifest.txt"; \
+	arduino-manifest.pl -b $(FQBN) $(SRC) $(HDRS) > manifest.txt; \
+	else echo "---> If you want to generate manifest.txt, listing used libraries and their versions,"; \
+	echo "---> please install arduino-manifest, see https://github.com/digiampietro/arduino-manifest"; \
+	fi
+
+upload:
+	@if [ ! -c $(SERIAL_DEV) ] ; \
+	then echo "---> ERROR: Serial Device not available, please set the SERIAL_DEV environment variable" ; \
+	else echo "---> Uploading sketch\n"; \
+	arduino-cli upload -b $(FQBN) -p $(SERIAL_DEV) $(VFLAG); \
+	fi
+
+ota:
+	@PLAT_PATH=`arduino-cli compile -b $(FQBN) --show-properties | grep '^runtime.platform.path' | awk -F= '{print $$2}'` ; \
+	   PY_PATH=`arduino-cli compile -b $(FQBN) --show-properties | grep '^runtime.tools.python3.path' | awk -F= '{print $$2}'` ; \
+	IOT_IP=`avahi-browse _arduino._tcp --resolve --parsable --terminate|grep -i ';$(IOT_NAME);'|grep ';$(OTA_PORT);'| awk -F\; '{print $$8}'|head -1`; \
+	BINFILE=$(wildcard $(BUILD_DIR)/$(SRC)*bin); \
+	echo "PLAT_PATH  is [$$PLAT_PATH]" ; \
+	echo "PY_PATH:   is [$$PY_PATH]"  ; \
+	echo "IOT_IP:    is [$$IOT_IP]"   ; \
+	echo "BINFILE:   is [$$BINFILE]"  ; \
+	if [ "$$IOT_IP" = "" ] ; \
+	then echo "Unable to find device IP. Check that the IOT_NAME environment variable is correctly set. Use 'make find' to search devices"; \
+	else echo "---> Uploading Over The Air"; \
+	$$PY_PATH/python3 $$PLAT_PATH/tools/espota.py -i $$IOT_IP -p $(OTA_PORT) --auth=$(OTA_PASS) -f $$BINFILE ;\
+	fi
+
+clean:
+	@echo "---> Cleaning the build directory"
+	rm -rf build
+
+find:
+	avahi-browse _arduino._tcp --resolve --parsable --terminate
+
+requirements:
+	@if [ -e requirements.txt ]; \
+	then while read -r i ; do echo ; \
+	  echo "---> Installing " '"'$$i'"' ; \
+	  arduino-cli lib install "$$i" ; \
+	done < requirements.txt ; \
+	else echo "---> MISSING requirements.txt file"; \
+	fi
@@ -0,0 +1,30 @@
+// Called when starting the arduino (setup method in main sketch)
+void setup() {
+    Serial.begin(115200);
+}
+
+// Called when new data is coming from computer
+void read() 
+{
+  if(Serial.available())
+  {
+    int speed = Serial.readStringUntil(';').toInt();
+    int gear = Serial.readStringUntil(';').toInt();
+    int rpms = Serial.readStringUntil(';').toInt();
+    //Serial.println("speed: " + String(speed) + " " + "gear: " + String(gear) + " " + "rpms: " + String(rpms));
+  }
+}
+
+// Called once per arduino loop, timing can't be predicted, 
+// but it's called between each command sent to the arduino
+void loop() {
+  read();
+}
+
+// Called once between each byte read on arduino,
+// THIS IS A CRITICAL PATH :
+// AVOID ANY TIME CONSUMING ROUTINES !!!
+// PREFER READ OR LOOP METHOS AS MUCH AS POSSIBLE
+// AVOID ANY INTERRUPTS DISABLE (serial data would be lost!!!)
+void idle() {
+}
@@ -6,20 +6,21 @@

 typedef struct
 {
-    unsigned char color_1_red;
-    unsigned char color_1_green;
-    unsigned char color_1_blue;
-    unsigned char color_2_red;
-    unsigned char color_2_green;
-    unsigned char color_2_blue;
-    unsigned char color_3_red;
-    unsigned char color_3_green;
-    unsigned char color_3_blue;
-    unsigned char space_1;
-    unsigned char space_2;
-    unsigned char space_3;
-    uint32_t maxrpm;
-    uint32_t rpm;
+    uint8_t litleds;
+    //unsigned char color_1_red;
+    //unsigned char color_1_green;
+    //unsigned char color_1_blue;
+    //unsigned char color_2_red;
+    //unsigned char color_2_green;
+    //unsigned char color_2_blue;
+    //unsigned char color_3_red;
+    //unsigned char color_3_green;
+    //unsigned char color_3_blue;
+    //unsigned char space_1;
+    //unsigned char space_2;
+    //unsigned char space_3;
+    //uint32_t maxrpm;
+    //uint32_t rpm;
 }
 ShiftLightsData;

@@ -6,16 +6,17 @@
 #define LED_PIN     7
 #define NUM_LEDS    6
 #define BRIGHTNESS  40
+#define STARTLED    1

-#define COLOR1A 0
+#define COLOR1R 0
+#define COLOR1G 255
 #define COLOR1B 0
-#define COLOR1C 255
-#define COLOR2A 0
-#define COLOR2B 255
-#define COLOR2C 0
-#define COLOR3A 255
+#define COLOR2R 255
+#define COLOR2G 255
+#define COLOR2B 0
+#define COLOR3R 255
+#define COLOR3G 0
 #define COLOR3B 0
-#define COLOR3C 0

 CRGB leds[NUM_LEDS];
 ShiftLightsData sd;
@@ -23,12 +24,12 @@ int maxrpm = 0;
 int rpm = 0;
 int numlights = NUM_LEDS;
 int pin = LED_PIN;
-int lights[6];
+int lights[NUM_LEDS];


 void setup()
 {
-    Serial.begin(9600);
+    Serial.begin(115200);
    FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
    FastLED.setMaxPowerInVoltsAndMilliamps(5, 500);
    FastLED.setBrightness(BRIGHTNESS);
@@ -39,62 +40,45 @@ void setup()
    }
    FastLED.clear();

-    sd.rpm = 0;
-    sd.maxrpm = 6500;
+    sd.litleds = 0;
+    //sd.rpm = 0;
+    //sd.maxrpm = 6500;
 }

 void loop()
 {
    int l = 0;
+    int lit = sd.litleds;
    char buff[SIMDATA_SIZE];

    if (Serial.available() >= SIMDATA_SIZE)
    {
        Serial.readBytes(buff, SIMDATA_SIZE);
        memcpy(&sd, &buff, SIMDATA_SIZE);
-        rpm = sd.rpm;
-        maxrpm = sd.maxrpm;
-    }
-
-    while (l < numlights)
-    {
-        lights[l] = 0;
-        l++;
-    }
-    l = -1;
-    int rpmlights = 0;
-    while (rpm > rpmlights)
-    {
-        if (l>=0)
-        {
-            lights[l] = 1;
-        }
-        l++;
-        rpmlights = rpmlights + (((maxrpm-250)/numlights));
+        lit = sd.litleds;
    }

    l = 0;
    FastLED.clear();
-    while (l < numlights)
+    while (l < lit)
    {
-
        if (l >= numlights / 2)
        {
-            leds[l] = CRGB ( COLOR1A, COLOR1B, COLOR1C);
+            leds[l+STARTLED-1] = CRGB ( COLOR2R, COLOR2G, COLOR2B);
        }
        if (l < numlights / 2)
        {
-            leds[l] = CRGB ( COLOR2A, COLOR2B, COLOR2C);
+            leds[l+STARTLED-1] = CRGB ( COLOR1R, COLOR1G, COLOR1B);
        }
        if (l == numlights - 1)
        {
-            leds[l] = CRGB ( COLOR3A, COLOR3B, COLOR3C);
+            leds[l+STARTLED-1] = CRGB ( COLOR3R, COLOR3G, COLOR3B);
        }
-        if (lights[l] <= 0)
-        {
-            leds[l] = CRGB ( 0, 0, 0);
-        }
-        FastLED.show();
+        //if (lights[l] <= 0)
+        //{
+        //    leds[l] = CRGB ( 0, 0, 0);
+        //}
        l++;
    }
+    FastLED.show();
 }
@@ -6,14 +6,14 @@

 typedef struct
 {
-    uint32_t motor1;
-    uint32_t effect1;
-    uint32_t motor2;
-    uint32_t effect2;
-    uint32_t motor3;
-    uint32_t effect3;
-    uint32_t motor4;
-    uint32_t effect4;
+    uint8_t motor1;
+    uint8_t effect1;
+    uint8_t motor2;
+    uint8_t effect2;
+    uint8_t motor3;
+    uint8_t effect3;
+    uint8_t motor4;
+    uint8_t effect4;
 }
 SimHapticData;

@@ -22,7 +22,7 @@ int effect3 = 0;
 int effect4 = 0;

 void setup() {
-    Serial.begin(9600);
+    Serial.begin(115200);
    if (!AFMS.begin()) {
        Serial.println("Could not find Motor Shield. Check wiring.");
        while (1);
@@ -6,8 +6,8 @@

 typedef struct
 {
-    uint32_t velocity;
-    float fanpower;
+    uint8_t velocity;
+    uint8_t fanpower;
 }
 SimWindData;

@@ -14,7 +14,7 @@ SimWindData sd;
 int velocity = 0;

 void setup() {
-    Serial.begin(9600);
+    Serial.begin(115200);
    if (!AFMS.begin()) {
        Serial.println("Could not find Motor Shield. Check wiring.");
        while (1);
@@ -37,11 +37,7 @@ void loop() {
        memcpy(&sd, &buff, BYTE_SIZE);
        velocity = sd.velocity;
    }
-    int v = ceil(velocity * KPHTOMPH);
-    if (v >= 255)
-    {
-      v = 255;
-    }
-    myMotor1->setSpeed(v*FANPOWER);
-    myMotor2->setSpeed(v*FANPOWER);
+
+    myMotor1->setSpeed(velocity*FANPOWER);
+    myMotor2->setSpeed(velocity*FANPOWER);
 }
@@ -7,8 +7,12 @@ set(devices_source_files
  sounddevice.c
  serialdevice.h
  serialdevice.c
+  serialadapter.h
+  serialadapter.c
  tachdevice.h
  tachdevice.c
+  wheeldevice.h
+  wheeldevice.c
  usbhapticdevice.h
  usbhapticdevice.c
  hapticeffect.h
@@ -19,11 +23,25 @@ set(devices_source_files
  usb/revburner.c
  usb/cslelitev3.h
  usb/cslelitev3.c
-  sound/usb_generic_shaker.h
-  sound/usb_generic_shaker.c
+  usb/simagicp1000.h
+  usb/simagicp1000.c
+  usb/wheels/logitechg29.h
+  usb/wheels/logitechg29.c
+  usb/wheels/cammusc5.h
+  usb/wheels/cammusc5.c
+  usb/wheels/cammusc12.h
+  usb/wheels/cammusc12.c
+  usb/wheels/gtneo.h
+  usb/wheels/gtneo.c
  sound/usb_generic_shaker_pulse.c
  serial/arduino.h
  serial/arduino.c
+  serial/arduinoledlua.h
+  serial/arduinoledlua.c
+  serial/moza.h
+  serial/moza.c
+  serial/moza_new.h
+  serial/moza_new.c
 )

 include_directories("." "usb" "sound" "serial")
@@ -3,12 +3,12 @@
 #include <stdlib.h>
 #include <string.h>
 #include <fcntl.h>
-#include <jansson.h>
 #include <math.h>

 #include "usbhapticdevice.h"
 #include "../../helper/confighelper.h"
 #include "../../simulatorapi/simapi/simapi/simdata.h"
+#include "../../simulatorapi/simapi/simapi/simmapper.h"
 #include "../../slog/slog.h"

 #define kmhtoms      0.277778
@@ -21,7 +21,7 @@

 bool hasTyreDiameter(SimData* simdata)
 {
-    if (simdata->tyrediameter[0] == -1 || simdata->tyrediameter[1] == -1 || simdata->tyrediameter[2] == -1 || simdata->tyrediameter[3] == -1)
+    if (simdata->tyrediameter[0] <= 0 || simdata->tyrediameter[1] <= 0 || simdata->tyrediameter[2] <= 0 || simdata->tyrediameter[3] <= 0)
    {
        slogt("failed to find tyre diameter data");
        return false;
@@ -45,136 +45,78 @@ int loadtyreconfig(SimData* simdata, char* configfile)

    config_cars = config_lookup(&cfg, "cars");

+    if(config_cars == NULL)
+    {
+        slogd("diameters config file corrupted");
+        config_destroy(&cfg);
+        return 1;
+    }
+    slogt("parsing diameters config file");
+
    int cars = config_setting_length(config_cars);
+
    int i = 0;
    while (i<cars)
    {
        DeviceSettings settings;

        config_setting_t* config_car = config_setting_get_elem(config_cars, i);
-        const char* car;
-        double tyre0;
-        double tyre1;
-        double tyre2;
-        double tyre3;
-        config_setting_lookup_string(config_car, "car", &car);
-        config_setting_lookup_float(config_car, "tyre0", &tyre0);
-        config_setting_lookup_float(config_car, "tyre1", &tyre1);
-        config_setting_lookup_float(config_car, "tyre2", &tyre2);
-        config_setting_lookup_float(config_car, "tyre3", &tyre3);
-
-        if(simdata->car != NULL)
+        if(config_car != NULL)
        {
-            if (strcicmp(car, simdata->car) == 0)
+            const char* car;
+            const char* simstr;
+            int sim = 0;
+            double tyre0;
+            double tyre1;
+            double tyre2;
+            double tyre3;
+            config_setting_lookup_string(config_car, "car", &car);
+            config_setting_lookup_float(config_car, "tyre0", &tyre0);
+            config_setting_lookup_float(config_car, "tyre1", &tyre1);
+            config_setting_lookup_float(config_car, "tyre2", &tyre2);
+            config_setting_lookup_float(config_car, "tyre3", &tyre3);
+            int found = config_setting_lookup_int(config_car, "sim", &sim);
+            //if(found == CONFIG_FALSE)
+            //{
+            //    int found = config_setting_lookup_int(config_car, "sim", &sim);
+            //}
+            //else
+            //{
+            //    sim = simapi_strtogame(simstr);
+            //}
+
+
+            if(simdata->car != NULL && car != NULL)
            {
-                simdata->tyrediameter[0] = tyre0;
-                simdata->tyrediameter[1] = tyre1;
-                simdata->tyrediameter[2] = tyre2;
-                simdata->tyrediameter[3] = tyre3;
-                break;
+                if(simdata->car[0] != '\0' && car[0] != '\0')
+                {
+                    slogt("%s %s %i %i", simdata->car, car, simdata->simexe, sim);
+                    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;
+                        break;
+                    }
+                }
            }
        }
+        else
+        {
+            slogw("Possible corruption in config file on entry %i attempting to continue", i+1);
+        }
        i++;
    }

+
    config_destroy(&cfg);

    return 0;
 }

-//void loadtyreconfig(SimData* simdata, char* configfile)
-//{
-//    json_t *root;
-//    json_error_t error;
-//
-//    root = json_load_file(configfile, 0, NULL);
-//
-//    if(!root)
-//    {
-//        slogw("could not open config file for tyre diameters");
-//        return;
-//    }
-//
-//    if(!json_is_object(root))
-//    {
-//        slogw("Malformed content (1) in tyre diameters config");
-//        json_decref(root);
-//        return;
-//    }
-//
-//    json_t* cararray = json_object_get(root, "cars");
-//    if(!json_is_array(cararray))
-//    {
-//        slogw("Malformed content (2) in tyre diameters config");
-//        json_decref(root);
-//        json_decref(cararray);
-//        return;
-//    }
-//
-//    for(int i = 0; i < json_array_size(cararray); i++)
-//    {
-//        json_t *data, *sha, *commit, *message;
-//        const char *message_text;
-//
-//        data = json_array_get(cararray, i);
-//        if(!json_is_object(data))
-//        {
-//            slogw("Malformed content (3) in tyre diameters config");
-//            break;
-//        }
-//        json_t* jcar = json_object_get(data, "car");
-//
-//        if(!json_is_string(jcar))
-//        {
-//            slogw("Malformed content (4) in tyre diameters config");
-//
-//            json_decref(data);
-//            json_decref(jcar);
-//            break;
-//        }
-//        const char* car = json_string_value(jcar);
-//
-//        json_t* jtyre0 = json_object_get(data, "tyre0");
-//        json_t* jtyre1 = json_object_get(data, "tyre1");
-//        json_t* jtyre2 = json_object_get(data, "tyre2");
-//        json_t* jtyre3 = json_object_get(data, "tyre3");
-//
-//        double diameter0 = json_real_value(jtyre0);
-//        double diameter1 = json_real_value(jtyre1);
-//        double diameter2 = json_real_value(jtyre2);
-//        double diameter3 = json_real_value(jtyre3);
-//
-//        slogt("car is: %s", car);
-//        slogt("diameter 0 is %f", diameter0);
-//        slogt("diameter 1 is %f", diameter1);
-//        slogt("diameter 2 is %f", diameter2);
-//        slogt("diameter 3 is %f", diameter3);
-//
-//        json_decref(data);
-//        json_decref(jcar);
-//        json_decref(jtyre0);
-//        json_decref(jtyre1);
-//        json_decref(jtyre2);
-//        json_decref(jtyre3);
-//
-//        if(simdata->car != NULL)
-//        {
-//            if (strcicmp(car, simdata->car) == 0)
-//            {
-//                simdata->tyrediameter[0] = diameter0;
-//                simdata->tyrediameter[1] = diameter1;
-//                simdata->tyrediameter[2] = diameter2;
-//                simdata->tyrediameter[3] = diameter3;
-//                break;
-//            }
-//        }
-//    }
-//
-//    json_decref(root);
-//    json_decref(cararray);
-//}
-
-void savetyreconfig(SimData* simdata, char* configfile)
+int savetyreconfig(SimData* simdata, char* configfile)
 {
    config_t cfg;
    config_setting_t* root;
@@ -195,10 +137,13 @@ void savetyreconfig(SimData* simdata, char* configfile)
        array = config_lookup(&cfg, "cars");
    }

+    // TODO add check to not add same car-sim combination twice
    carobject = config_setting_add(array, "cars", CONFIG_TYPE_GROUP);

    setting = config_setting_add(carobject, "car", CONFIG_TYPE_STRING);
    config_setting_set_string(setting, simdata->car);
+    setting = config_setting_add(carobject, "sim", CONFIG_TYPE_INT64);
+    config_setting_set_int64(setting, simdata->simexe);
    setting = config_setting_add(carobject, "tyre0", CONFIG_TYPE_FLOAT);
    config_setting_set_float(setting, simdata->tyrediameter[0]);
    setting = config_setting_add(carobject, "tyre1", CONFIG_TYPE_FLOAT);
@@ -215,65 +160,20 @@ void savetyreconfig(SimData* simdata, char* configfile)
      config_destroy(&cfg);
    }

-    slogi("New configuration successfully written to: %s\n", configfile);
+    slogi("New configuration successfully written to: %s for sim %i, car %s\n", configfile, simdata->simexe, simdata->car);

    config_destroy(&cfg);
-}

-//void savetyreconfig(SimData* simdata, char* configfile)
-//{
-//
-//    json_t* object = json_object();
-//    json_t* array = json_array();
-//    json_t* car = json_string(simdata->car);
-//    json_t* tyre0 = json_real(simdata->tyrediameter[0]);
-//    json_t* tyre1 = json_real(simdata->tyrediameter[1]);
-//    json_t* tyre2 = json_real(simdata->tyrediameter[2]);
-//    json_t* tyre3 = json_real(simdata->tyrediameter[3]);
-//    json_object_set_new(object, "car", car);
-//    json_object_set_new(object, "tyre0", tyre0);
-//    json_object_set_new(object, "tyre1", tyre1);
-//    json_object_set_new(object, "tyre2", tyre2);
-//    json_object_set_new(object, "tyre3", tyre3);
-//
-//    json_array_append(array, object);
-//
-//    json_t* file = json_load_file(configfile, 0, NULL);
-//
-//    if(!file)
-//    {
-//        slogw("could not open config file for tyre diameters");
-//        return;
-//    }
-//
-//    if(!json_is_object(file))
-//    {
-//        json_object_set_new(file, "cars", array);
-//    }
-//    else
-//    {
-//        json_t* cararray = json_object_get(file, "cars");
-//        json_array_append(cararray, array);
-//    }
-//
-//    json_dump_file(file, configfile, 0);
-//
-//    json_decref(tyre0);
-//    json_decref(tyre1);
-//    json_decref(tyre2);
-//    json_decref(tyre3);
-//    json_decref(car);
-//    json_decref(object);
-//    json_decref(array);
-//}
+    return 0;
+}

 void getTyreDiameter(SimData* simdata)
 {
    if(simdata->velocity > minvelocity && simdata->brake <= maxbrake && simdata->gas <= maxthrottle)
    {
-        if (simdata->velocityX/simdata->velocity < maxXvelocity)
+        double Speedms = kmhtoms * simdata->velocity;
+        if (simdata->Xvelocity/Speedms < maxXvelocity)
        {
-            double Speedms = kmhtoms * simdata->velocity;
            for(int i = 0; i < 4; i++)
            {
                simdata->tyrediameter[i] = Speedms / simdata->tyreRPS[i] * 2;
@@ -294,31 +194,41 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
    wheelslip[2] = 0;
    wheelslip[3] = 0;

-    slogt("wheel vibration calculation");
+    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)
    {
        case (EFFECT_TYRESLIP):
        case (EFFECT_TYRELOCK):
        case (EFFECT_ABSBRAKES):
-            if(hasTyreDiameter(simdata)==false)
+
+            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
-                if(useconfig == 1 && configfile != NULL && *configcheck == 0)
+                int error = 0;
+                if(hasTyreDiameter(simdata)==false && *configcheck == 0)
                {
-                    int error = loadtyreconfig(simdata, configfile);
+                    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(useconfig == 1 && hasTyreDiameter(simdata)==true)
+                    if(hasTyreDiameter(simdata)==true)
                    {
-                        savetyreconfig(simdata, configfile);
+                        slogi("saving tyre config");
+                        error = savetyreconfig(simdata, configfile);
                    }
                }
            }
@@ -340,23 +250,35 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                        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);
            }
            break;
+        case EFFECT_SUSPENSION:
+            break;
        default:
-            slogt("Unknown effect type");
+            slogd("Unknown effect type");
+    }
+
+    if(simdata->Yvelocity <= 0)
+    {
+        return 0;
+    }
+    if(simdata->Zvelocity > 1 || simdata->Zvelocity < -1)
+    {
+        return 0;
    }

    switch (effecttype)
    {
        case (EFFECT_TYRESLIP):

-
            if (tyre == FRONTLEFT || tyre == FRONTS || tyre == ALLFOUR)
            {
                if(wheelslip[0] < -threshold)
                {
                    play += fabs(wheelslip[0]) - fabs(threshold);
+                    slogt("slip is %f", play);
                }
            }
            if (tyre == FRONTRIGHT || tyre == FRONTS || tyre == ALLFOUR)
@@ -364,6 +286,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                if(wheelslip[1] < -threshold)
                {
                    play += fabs(wheelslip[1]) - fabs(threshold);
+                    slogt("slip is %f", play);
                }
            }
            if (tyre == REARLEFT || tyre == REARS || tyre == ALLFOUR)
@@ -371,6 +294,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                if(wheelslip[2] < -threshold)
                {
                    play += fabs(wheelslip[2]) - fabs(threshold);
+                    slogt("slip is %f", play);
                }
            }
            if (tyre == REARRIGHT || tyre == REARS || tyre == ALLFOUR)
@@ -378,17 +302,18 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                if(wheelslip[3] < -threshold)
                {
                    play += fabs(wheelslip[3]) - fabs(threshold);
+                    slogt("slip is %f", play);
                }
            }
-
-
            break;
+
        case (EFFECT_TYRELOCK):
            if (tyre == FRONTLEFT || tyre == FRONTS || tyre == ALLFOUR)
            {
                if(wheelslip[0] > threshold)
                {
                    play += wheelslip[0] - threshold;
+                    slogt("lock is %f", play);
                }
            }
            if (tyre == FRONTRIGHT || tyre == FRONTS || tyre == ALLFOUR)
@@ -396,6 +321,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                if(wheelslip[1] > threshold)
                {
                    play += wheelslip[1] - threshold;
+                    slogt("lock is %f", play);
                }
            }
            if (tyre == REARLEFT || tyre == REARS || tyre == ALLFOUR)
@@ -403,6 +329,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                if(wheelslip[2] > threshold)
                {
                    play += wheelslip[2] - threshold;
+                    slogt("lock is %f", play);
                }
            }
            if (tyre == REARRIGHT || tyre == REARS || tyre == ALLFOUR)
@@ -410,6 +337,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                if(wheelslip[3] > threshold)
                {
                    play += wheelslip[3] - threshold;
+                    slogt("lock is %f", play);
                }
            }

@@ -421,6 +349,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                if(wheelslip[0] > threshold)
                {
                    play += wheelslip[0] - threshold;
+                    slogt("abs is %f", play);
                }
            }
            if (tyre == FRONTRIGHT || tyre == FRONTS || tyre == ALLFOUR)
@@ -428,6 +357,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                if(wheelslip[1] > threshold)
                {
                    play += wheelslip[1] - threshold;
+                    slogt("abs is %f", play);
                }
            }
            if (tyre == REARLEFT || tyre == REARS || tyre == ALLFOUR)
@@ -435,6 +365,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                if(wheelslip[2] > threshold)
                {
                    play += wheelslip[2] - threshold;
+                    slogt("abs is %f", play);
                }
            }
            if (tyre == REARRIGHT || tyre == REARS || tyre == ALLFOUR)
@@ -442,6 +373,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                if(wheelslip[3] > threshold)
                {
                    play += wheelslip[3] - threshold;
+                    slogt("abs is %f", play);
                }
            }
            if(simdata->abs <= 0)
@@ -449,6 +381,42 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                play = 0;
            }
            break;
+
+        case (EFFECT_SUSPENSION):
+
+            if (tyre == FRONTLEFT || tyre == FRONTS || tyre == ALLFOUR)
+            {
+                if(simdata->suspension[0] > threshold)
+                {
+                    play += simdata->suspension[0] - threshold;
+                    slogt("suspension is %f", play);
+                }
+            }
+            if (tyre == FRONTRIGHT || tyre == FRONTS || tyre == ALLFOUR)
+            {
+                if(simdata->suspension[1] > threshold)
+                {
+                    play += simdata->suspension[1] - threshold;
+                    slogt("suspension is %f", play);
+                }
+            }
+            if (tyre == REARLEFT || tyre == REARS || tyre == ALLFOUR)
+            {
+                if(simdata->suspension[2] > threshold)
+                {
+                    play += simdata->suspension[2] - threshold;
+                    slogt("suspension is %f", play);
+                }
+            }
+            if (tyre == REARRIGHT || tyre == REARS || tyre == ALLFOUR)
+            {
+                if(simdata->suspension[3] > threshold)
+                {
+                    play += simdata->suspension[3] - threshold;
+                    slogt("suspension is %f", play);
+                }
+            }
+            break;
    }

    return play;
@@ -2,105 +2,429 @@
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
+#include <math.h>

 #include "arduino.h"
+#include "arduinoledlua.h"
+#include "../serialadapter.h"
 #include "../../slog/slog.h"

-#define arduino_timeout 5000
+#define arduino_timeout 9000

-int arduino_update(SerialDevice* serialdevice, void* data, size_t size)
+int arduino_check(enum sp_return result)
 {
-    int result = 1;
-    if (serialdevice->port)
-    {
-        slogt("copying %i bytes to arduino device", size);
-        result = check(sp_blocking_write(serialdevice->port, data, size, arduino_timeout));
-    }
-
-    return result;
-}
-
-//int arduino_shiftlights_update(SerialDevice* serialdevice, SimData* simdata)
-//{
-//    int result = 1;
-//    if (serialdevice->port)
-//    {
-//        result = check(sp_blocking_write(serialdevice->port, simdata, sizeof(SimData), arduino_timeout));
-//    }
-//
-//    return result;
-//}
-//
-//int arduino_simwind_update(SerialDevice* serialdevice, SimData* simdata)
-//{
-//    int result = 1;
-//    if (serialdevice->port)
-//    {
-//        result = check(sp_blocking_write(serialdevice->port, simdata, sizeof(SimData), arduino_timeout));
-//    }
-//
-//    return result;
-//}
-
-int arduino_init(SerialDevice* serialdevice, const char* portdev)
-{
-    slogi("initializing arduino serial device...");
-    int error = 0;
-    char* port_name = strdup(portdev);
-
-    slogd("Looking for port %s.\n", port_name);
-    error = check(sp_get_port_by_name(port_name, &serialdevice->port));
-    if (error != 0)
-    {
-        return error;
-    }
-
-    slogd("Opening port.\n");
-    check(sp_open(serialdevice->port, SP_MODE_READ_WRITE));
-
-    slogd("Setting port to 9600 8N1, no flow control.\n");
-    check(sp_set_baudrate(serialdevice->port, 9600));
-    check(sp_set_bits(serialdevice->port, 8));
-    check(sp_set_parity(serialdevice->port, SP_PARITY_NONE));
-    check(sp_set_stopbits(serialdevice->port, 1));
-    check(sp_set_flowcontrol(serialdevice->port, SP_FLOWCONTROL_NONE));
-
-    free(port_name);
-    slogd("Successfully setup arduino serial device...");
-    return 0;
-}
-
-int arduino_free(SerialDevice* serialdevice)
-{
-    check(sp_close(serialdevice->port));
-    sp_free_port(serialdevice->port);
-}
-
-int check(enum sp_return result)
-{
-    /* For this example we'll just exit on any error by calling abort(). */
    char* error_message;

    switch (result)
    {
        case SP_ERR_ARG:
-            //printf("Error: Invalid argument.\n");
            return 1;
-        //abort();
        case SP_ERR_FAIL:
            error_message = sp_last_error_message();
-            printf("Error: Failed: %s\n", error_message);
+            sloge("error: serial write failed: %s", error_message);
            sp_free_error_message(error_message);
-            abort();
        case SP_ERR_SUPP:
            printf("Error: Not supported.\n");
-            abort();
        case SP_ERR_MEM:
            printf("Error: Couldn't allocate memory.\n");
-            abort();
        case SP_OK:
        default:
            return result;
    }
 }

+int arduino_update(SerialDevice* serialdevice, void* data, size_t size)
+{
+    int result = 1;
+    slogt("copying %i bytes to arduino device", size);
+    result = monocoque_serial_write(serialdevice->id, data, size, arduino_timeout);
+
+    return result;
+}
+
+// the input event waiting and flushing is the right way to do this
+// most of the time i'm just "bit blasting" and the only receiving
+// happens initially to get the number of lights
+int GetNumberOfLeds(SerialDevice* serialdevice, int* numlights)
+
+{
+    int count = 0;
+    int bytesWaiting;
+    char buf[256];
+    int retval = 0;
+    int i;
+
+    //sp_flush(port, SP_BUF_INPUT);
+
+    while (count < 4)
+    {
+        slogi("Attempting to retrieve num lights from port...");
+
+        size_t bufsize1 = 11;
+        size_t recv_bufsize1 = 5;
+        char recv_buf1[recv_bufsize1];
+        char bytes1[bufsize1];
+
+        for(int j = 0; j < bufsize1; j++)
+        {
+            bytes1[j] = 0x00;
+        }
+        bytes1[0] = 0xff;
+        bytes1[1] = 0xff;
+        bytes1[2] = 0xff;
+        bytes1[3] = 0xff;
+        bytes1[4] = 0xff;
+        bytes1[5] = 0xff;
+        bytes1[6] = 0x6c;
+        bytes1[7] = 0x65;
+        bytes1[8] = 0x64;
+        bytes1[9] = 0x73;
+        bytes1[10] = 0x63;
+
+        int result = 0;
+        unsigned int timeout = 6000;
+        slogd("Sending message to get num lights");
+        monocoque_wait_for_event(serialdevice->id, 6);
+
+        result = monocoque_serial_write(serialdevice->id, &bytes1, bufsize1, arduino_timeout);
+
+
+        monocoque_wait_for_event(serialdevice->id, 5);
+        bytesWaiting = monocoque_input_wait(serialdevice->id);
+        if (bytesWaiting > 0)
+        {
+            memset(buf, 0, sizeof(buf));
+            retval = monocoque_serial_read_block(serialdevice->id, buf, sizeof(buf)-1, 10);
+            if (retval < 0)
+            {
+                retval = -1;
+                break;
+            }
+            else
+            {
+                for(i=0; i<retval; i++)
+                {
+                    if (buf[i] == 13)
+                    {
+                        count++;
+                    }
+                }
+                int ret = atoi(buf);
+                *numlights = ret;
+                return retval;
+            }
+        }
+        else
+            if (bytesWaiting < 0)
+            {
+                sloge("Error getting bytes available from serial port: %d", bytesWaiting);
+                retval = -1;
+                break;
+            }
+        retval = 0;
+    }
+    return retval;
+}
+
+int arduino_init(SerialDevice* serialdevice, const char* portdev)
+{
+    serialdevice->id = monocoque_serial_open(serialdevice, portdev);
+    return serialdevice->id;
+}
+
+
+
+int arduino_custom_init(SerialDevice* serialdevice, const char* portdev, const char* luafile, bool uselights)
+{
+    serialdevice->id = monocoque_serial_open(serialdevice, portdev);
+
+
+    int numlights = 0;
+
+    monocoque_serial_device serialdev = monocoque_serial_devices[serialdevice->id];
+    int error = 0;
+    if(uselights == true)
+    {
+        error = GetNumberOfLeds(serialdevice, &numlights);
+        slogi("numlights is %i\n", numlights);
+        // close, error and free if numlights is 0
+        serialdevice->numleds = numlights;
+    }
+
+    if(luafile == NULL)
+    {
+        return serialdevice->id;
+    }
+
+
+    slogi("LUA config specified for this device... initializing...");
+
+    lua_State* L = luaL_newstate();
+    luaL_openlibs(L);
+
+    int top=lua_gettop(L);
+    int status = luaL_loadfile(L, luafile);
+
+    if (status) {
+        /* If something went wrong, error message is at the top of */
+        /* the stack */
+        fprintf(stderr, "Couldn't load file: %s\n", lua_tostring(L, -1));
+        lua_close(serialdevice->m.L);
+        return -1;
+        exit(1);
+    }
+    lua_setglobal(L,"myFunc");
+
+    serialdevice->m.L = L;
+
+    slogi("LUA config setup successful.");
+    
+    return serialdevice->id;
+}
+
+
+int arduino_simled_update(SerialDevice* serialdevice, SimData* simdata)
+{
+    int result = 1;
+
+    int total_leds = serialdevice->numleds;
+    size_t bufsize = (total_leds * 3) + 14;
+    char bytes[bufsize];
+    int endled = serialdevice->endled;
+    int startled = serialdevice->startled;
+    if(endled == 0)
+    {
+        endled = total_leds;
+    }
+    int num_avail_leds = endled - startled + 1;
+    int rpm = simdata->rpms;
+    int maxrpm = simdata->maxrpm;
+    int litleds = 0;
+    if(rpm > 0 && maxrpm > 0)
+    {
+        int rpmmargin = ceil(.05*maxrpm);
+        int rpminterval = (maxrpm-rpmmargin) / (num_avail_leds);
+
+
+        for (int l = 1; l <= (num_avail_leds); l++)
+        {
+            if(rpm >= (rpminterval * l))
+            {
+                litleds = l;
+            }
+        }
+
+
+
+        for(int j = 0; j < bufsize; j++)
+        {
+            bytes[j] = 0x00;
+        }
+        bytes[0] = 0xff;
+        bytes[1] = 0xff;
+        bytes[2] = 0xff;
+        bytes[3] = 0xff;
+        bytes[4] = 0xff;
+        bytes[5] = 0xff;
+        bytes[6] = 0x73;
+        bytes[7] = 0x6c;
+        bytes[8] = 0x65;
+        bytes[9] = 0x64;
+        bytes[10] = 0x73;
+        bytes[bufsize-1] = 0xfd;
+        bytes[bufsize-2] = 0xfe;
+        bytes[bufsize-3] = 0xff;
+
+        for(int i = 0; i < litleds; i++)
+        {
+            if(i < ((num_avail_leds) / 2))
+            {
+                //green
+                bytes[11 + ((i + startled - 1) * 3) + 1] = 0xff;
+            }
+            else
+            {
+                if(i < num_avail_leds - 1)
+                {
+                    //yellow
+                    bytes[11 + ((i + startled - 1) * 3) + 0] = 0xff;
+                    bytes[11 + ((i + startled - 1) * 3) + 1] = 0xff;
+                }
+            }
+            if(i == num_avail_leds - 1)
+            {
+                //red
+                bytes[11 + ((i + startled - 1) * 3) + 0] = 0xff;
+            }
+        }
+    }
+
+    slogt("Updating arduino device lights to %i", litleds);
+    // we can add configs to set all the colors
+    size_t size = sizeof(bytes);
+
+    result = monocoque_serial_write(serialdevice->id, &bytes, size, arduino_timeout);
+
+    return result;
+}
+
+int arduino_customled_update(SerialDevice* serialdevice, SimData* simdata)
+{
+    int result = 1;
+
+    int total_leds = serialdevice->numleds;
+    size_t bufsize = (total_leds * 3) + 14;
+    char ledbytes[total_leds * 3];
+    char bytes[bufsize];
+
+    for(int j = 0; j < bufsize; j++)
+    {
+        bytes[j] = 0x00;
+    }
+    for(int j = 0; j < total_leds * 3; j++)
+    {
+        ledbytes[j] = 0x00;
+    }
+    bytes[0] = 0xff;
+    bytes[1] = 0xff;
+    bytes[2] = 0xff;
+    bytes[3] = 0xff;
+    bytes[4] = 0xff;
+    bytes[5] = 0xff;
+    bytes[6] = 0x73;
+    bytes[7] = 0x6c;
+    bytes[8] = 0x65;
+    bytes[9] = 0x64;
+    bytes[10] = 0x73;
+    bytes[bufsize-1] = 0xfd;
+    bytes[bufsize-2] = 0xfe;
+    bytes[bufsize-3] = 0xff;
+
+
+    lua_State* L = serialdevice->m.L;
+
+    lua_pushstring(L, "buff");
+    lua_pushlightuserdata(L, &ledbytes);
+    lua_settable(L, LUA_REGISTRYINDEX);
+
+    simdata_to_lua(L, simdata);
+    lua_setglobal(L, "simdata");
+
+    lua_pushinteger(L, total_leds);
+    lua_setglobal(L, "TotalLeds");
+
+    lua_register(L, "set_led_to_color", set_led_to_color);
+    lua_register(L, "set_led_range_to_color", set_led_range_to_color);
+    lua_register(L, "set_led_to_rgb_color", set_led_to_rgb_color);
+    lua_register(L, "set_led_range_to_rgb_color", set_led_range_to_rgb_color);
+    lua_register(L, "led_clear_all", led_clear_all);
+    lua_register(L, "led_clear_range", led_clear_all);
+
+    lua_pushinteger(L, LUALEDCOLOR_RED);
+    lua_setglobal(L, "RED");
+    lua_pushinteger(L, LUALEDCOLOR_GREEN);
+    lua_setglobal(L, "GREEN");
+    lua_pushinteger(L, LUALEDCOLOR_BLUE);
+    lua_setglobal(L, "BLUE");
+    lua_pushinteger(L, LUALEDCOLOR_YELLOW);
+    lua_setglobal(L, "YELLOW");
+    lua_pushinteger(L, LUALEDCOLOR_ORANGE);
+    lua_setglobal(L, "ORANGE");
+
+    lua_getglobal(L,"myFunc");
+    if (lua_pcall(L, 0, 0, 0) != LUA_OK)
+    {
+        fprintf(stderr, "Error calling Lua script: %s\n", lua_tostring(L, -1));
+    }
+
+    for(int i = 0; i < total_leds; i++)
+    {
+        bytes[11 + (i * 3) + 0] = ledbytes[(i * 3) + 0];
+        bytes[11 + (i * 3) + 1] = ledbytes[(i * 3) + 1];
+        bytes[11 + (i * 3) + 2] = ledbytes[(i * 3) + 2];
+    }
+
+    size_t size = sizeof(bytes);
+    result = arduino_update(serialdevice, &bytes, size);
+
+    slogt("custom led wrote %i bytes", result);
+
+    return result;
+}
+
+int arduino_customled_free(SerialDevice* serialdevice, bool lua)
+{
+    size_t bufsize = (serialdevice->numleds * 3) + 14;
+    char bytes[bufsize];
+    int endled = serialdevice->endled;
+    int startled = serialdevice->startled;
+    if(endled == 0)
+
+    for(int j = 0; j < bufsize; j++)
+    {
+        bytes[j] = 0x00;
+    }
+    bytes[0] = 0xff;
+    bytes[1] = 0xff;
+    bytes[2] = 0xff;
+    bytes[3] = 0xff;
+    bytes[4] = 0xff;
+    bytes[5] = 0xff;
+    bytes[6] = 0x73;
+    bytes[7] = 0x6c;
+    bytes[8] = 0x65;
+    bytes[9] = 0x64;
+    bytes[10] = 0x73;
+    bytes[bufsize-1] = 0xfd;
+    bytes[bufsize-2] = 0xfe;
+    bytes[bufsize-3] = 0xff;
+
+    for(int i = 0; i < serialdevice->numleds; i++)
+    {
+        bytes[11 + (i * 3) + 0] = 0x00;
+        bytes[11 + (i * 3) + 1] = 0x00;
+        bytes[11 + (i * 3) + 2] = 0x00;
+    }
+    size_t size = sizeof(bytes);
+
+    int result = monocoque_serial_write_block(serialdevice->id, &bytes, size, arduino_timeout);
+
+    if(lua == false)
+    {
+        return result;
+    }
+
+
+    lua_close(serialdevice->m.L);
+
+    return result;
+}
+
+int arduino_custom_update(SerialDevice* serialdevice, SimData* simdata)
+{
+    size_t bufsize = 14;
+    char bytes[bufsize];
+    lua_State* L = serialdevice->m.L;
+
+    simdata_to_lua(L, simdata);
+    lua_setglobal(L, "simdata");
+
+    lua_getglobal(L,"myFunc");
+    if (lua_pcall(L, 0, 0, 0) != LUA_OK)
+    {
+        fprintf(stderr, "Error calling Lua script: %s\n", lua_tostring(L, -1));
+    }
+
+    lua_getglobal(L, "Message");
+    int result = 0;
+    if (lua_isstring(L, -1)) {
+        const char *msg = lua_tostring(L, -1);
+        size_t size = strlen(msg);
+        result = arduino_update(serialdevice, (void*) msg, size);
+        slogt("custom arduino wrote message %s of %i bytes", msg, result);
+    }
+
+    // Clean up
+    lua_pop(L, 1);
+    return result;
+}
@@ -5,9 +5,13 @@
 #include "../serialdevice.h"


+int arduino_simled_update(SerialDevice* serialdevice, SimData* simdata);
 int arduino_update(SerialDevice* serialdevice, void* data, size_t size);
+int arduino_custom_init(SerialDevice* serialdevice, const char* portdev, const char* luafile, bool useleds);
+int arduino_customled_update(SerialDevice* serialdevice, SimData* simdata);
+int arduino_custom_update(SerialDevice* serialdevice, SimData* simdata);
 int arduino_init(SerialDevice* serialdevice,  const char* portdev);
 int arduino_free(SerialDevice* serialdevice);
-int check(enum sp_return result);
+int arduino_customled_free(SerialDevice* serialdevice, bool lua);

 #endif
@@ -0,0 +1,397 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <sys/time.h>
+
+#include "arduinoledlua.h"
+#include "arduino.h"
+
+#include "../../slog/slog.h"
+
+long long ledTimeInMilliseconds(void) {
+    struct timeval tv;
+
+    gettimeofday(&tv,NULL);
+    return (((long long)tv.tv_sec)*1000)+(tv.tv_usec/1000);
+}
+
+
+int simdata_to_lua(lua_State *L, SimData* simdata) {
+
+    // make the time up now if we are running in test mode
+    if(simdata->mtick == 0)
+    {
+        simdata->mtick = ledTimeInMilliseconds();
+    }
+
+    lua_newtable(L);
+
+    lua_pushstring(L, simdata->gearc);
+    lua_setfield(L, -2, "gearc");
+
+    lua_pushinteger(L, simdata->playerflag);
+    lua_setfield(L, -2, "playerflag");
+
+    lua_pushinteger(L, simdata->rpms);
+    lua_setfield(L, -2, "rpm");
+    
+    lua_pushinteger(L, simdata->gear);
+    lua_setfield(L, -2, "gear");
+    
+    lua_pushinteger(L, simdata->velocity);
+    lua_setfield(L, -2, "velocity");
+
+    lua_pushinteger(L, simdata->mtick);
+    lua_setfield(L, -2, "mtick");
+
+    lua_pushinteger(L, simdata->maxrpm);
+    lua_setfield(L, -2, "maxrpm");
+
+    lua_pushinteger(L, PROXCARS);
+    lua_setfield(L, -2, "proxcars");
+
+    lua_newtable(L);
+    for(int i = 0; i < PROXCARS; i++)
+    {
+        lua_newtable(L);
+        lua_pushinteger(L, simdata->pd[i].radius);
+        lua_setfield(L, -2, "radius");
+        lua_pushinteger(L, simdata->pd[i].theta);
+        lua_setfield(L, -2, "theta");
+        lua_rawseti(L, -2, i+1);
+    }
+    lua_setfield(L, -2, "pd");
+
+    return 0; // Return the table to Lua
+}
+
+uint8_t get_color_rgb_value(int color, int rgb)
+{
+    switch (color)
+    {
+        case LUALEDCOLOR_RED:
+            switch (rgb)
+            {
+                case 0:
+                    return 255;
+                case 1:
+                    return 0;
+                case 2:
+                    return 0;
+            }
+        case LUALEDCOLOR_GREEN:
+            switch (rgb)
+            {
+                case 0:
+                    return 0;
+                case 1:
+                    return 255;
+                case 2:
+                    return 0;
+            }
+        case LUALEDCOLOR_BLUE:
+            switch (rgb)
+            {
+                case 0:
+                    return 0;
+                case 1:
+                    return 0;
+                case 2:
+                    return 255;
+            }
+        case LUALEDCOLOR_YELLOW:
+            switch (rgb)
+            {
+                case 0:
+                    return 255;
+                case 1:
+                    return 255;
+                case 2:
+                    return 0;
+            }
+        case LUALEDCOLOR_ORANGE:
+            switch (rgb)
+            {
+                case 0:
+                    return 255;
+                case 1:
+                    return 165;
+                case 2:
+                    return 0;
+            }
+        default:
+            return 0;
+    }
+}
+
+int set_led_range_to_color(lua_State *L)
+{
+
+    slogt("lua called c function set_led_range_to_color");
+
+    int range_start = lua_tonumber(L, 1);
+    int range_end = lua_tonumber(L, 2);
+    int color = lua_tonumber(L, 3);
+
+    slogd("lua range start is %i", range_start);
+    slogd("lua range end is %i", range_end);
+    slogd("lua color is %i", color);
+
+    range_start = range_start - 1;
+
+    lua_getglobal(L, "TotalLeds");
+    int numlights = 0;
+    if (lua_isnumber(L, -1))
+    {
+        numlights = lua_tonumber(L, -1);
+    }
+    slogd("num leds is %i", numlights);
+
+    if(range_end > numlights)
+    {
+        range_end = numlights;
+    }
+
+    if(range_end == 0)
+    {
+        slogt("Invalid range, doing nothing");
+        return 1;
+    }
+
+    lua_pushstring(L, "buff");
+    lua_gettable(L, LUA_REGISTRYINDEX);
+    char* bytes = lua_touserdata(L, -1);
+
+    slogt("first byte of buff is x%02x", bytes[0]);
+
+    uint8_t color0 = get_color_rgb_value(color, 0);
+    uint8_t color1 = get_color_rgb_value(color, 1);
+    uint8_t color2 = get_color_rgb_value(color, 2);
+
+    for( int i = range_start; i < range_end; i++)
+    {
+        bytes[(i * 3) + 0] = color0;
+        bytes[(i * 3) + 1] = color1;
+        bytes[(i * 3) + 2] = color2;
+    }
+
+}
+
+int set_led_range_to_rgb_color(lua_State *L)
+{
+
+    slogt("lua called c function set_led_range_to_rgb_color");
+
+    int range_start = lua_tonumber(L, 1);
+    int range_end = lua_tonumber(L, 2);
+    int color = lua_tonumber(L, 3);
+
+    uint8_t color0 = (color >> 16) & 0xff;
+    uint8_t color1 = (color >> 8) & 0xff;
+    uint8_t color2 = (color >> 0) & 0xff;
+    //int color0 = lua_tonumber(L, 3);
+    //int color1 = lua_tonumber(L, 4);
+    //int color2 = lua_tonumber(L, 5);
+
+    slogd("lua range start is %i", range_start);
+    slogd("lua range end is %i", range_end);
+    slogd("lua color0 is %i", color0);
+    slogd("lua color1 is %i", color1);
+    slogd("lua color2 is %i", color2);
+
+    range_start = range_start - 1;
+
+    lua_getglobal(L, "TotalLeds");
+    int numlights = 0;
+    if (lua_isnumber(L, -1))
+    {
+        numlights = lua_tonumber(L, -1);
+    }
+    slogd("num leds is %i", numlights);
+
+    if(range_end > numlights)
+    {
+        range_end = numlights;
+    }
+
+    if(range_end == 0)
+    {
+        return 1;
+    }
+
+    lua_pushstring(L, "buff");
+    lua_gettable(L, LUA_REGISTRYINDEX);
+    char* bytes = lua_touserdata(L, -1);
+
+    slogt("first byte of buff is x%02x", bytes[0]);
+
+    for( int i = range_start; i < range_end; i++)
+    {
+        bytes[(i * 3) + 0] = color0;
+        bytes[(i * 3) + 1] = color1;
+        bytes[(i * 3) + 2] = color2;
+    }
+
+}
+
+int set_led_to_color(lua_State *L)
+{
+    slogt("lua called c function set_led_to_rgb_color");
+
+    int led = lua_tonumber(L, 1);
+    int color = lua_tonumber(L, 2);
+
+    slogd("lua led is %i", led);
+    slogd("lua color is %i", color);
+
+    led = led - 1;
+
+    lua_getglobal(L, "TotalLeds");
+    int numlights = 0;
+    if (lua_isnumber(L, -1))
+    {
+        numlights = lua_tonumber(L, -1);
+    }
+    slogd("num leds is %i", numlights);
+
+    if(led > numlights)
+    {
+        return 1;
+    }
+
+    lua_pushstring(L, "buff");
+    lua_gettable(L, LUA_REGISTRYINDEX);
+    char* bytes = lua_touserdata(L, -1);
+
+    slogt("first byte of buff is x%02x", bytes[0]);
+
+    uint8_t color0 = get_color_rgb_value(color, 0);
+    uint8_t color1 = get_color_rgb_value(color, 1);
+    uint8_t color2 = get_color_rgb_value(color, 2);
+
+    bytes[(led * 3) + 0] = color0;
+    bytes[(led * 3) + 1] = color1;
+    bytes[(led * 3) + 2] = color2;
+
+}
+
+
+int set_led_to_rgb_color(lua_State *L)
+{
+    slogt("lua called c function set_led_to_rgb_color");
+
+    int led = lua_tonumber(L, 1);
+    int color = lua_tonumber(L, 2);
+
+    uint8_t color0 = (color >> 16) & 0xff;
+    uint8_t color1 = (color >> 8) & 0xff;
+    uint8_t color2 = (color >> 0) & 0xff;
+
+    slogd("lua led is %i", led);
+    slogd("lua color0 is %i", color0);
+    slogd("lua color1 is %i", color1);
+    slogd("lua color2 is %i", color2);
+
+    led = led - 1;
+
+    lua_getglobal(L, "TotalLeds");
+    int numlights = 0;
+    if (lua_isnumber(L, -1))
+    {
+        numlights = lua_tonumber(L, -1);
+    }
+    slogd("num leds is %i", numlights);
+
+    if(led > numlights)
+    {
+        return 1;
+    }
+
+    lua_pushstring(L, "buff");
+    lua_gettable(L, LUA_REGISTRYINDEX);
+    char* bytes = lua_touserdata(L, -1);
+
+    slogt("first byte of buff is x%02x", bytes[0]);
+
+    bytes[(led * 3) + 0] = color0;
+    bytes[(led * 3) + 1] = color1;
+    bytes[(led * 3) + 2] = color2;
+
+}
+
+
+int led_clear_all(lua_State *L)
+{
+
+    slogt("lua called c function led_clear_all");
+
+    lua_getglobal(L, "TotalLeds");
+    int numlights = 0;
+    if (lua_isnumber(L, -1))
+    {
+        numlights = lua_tonumber(L, -1);
+    }
+    slogd("num leds is %i", numlights);
+
+    lua_pushstring(L, "buff");
+    lua_gettable(L, LUA_REGISTRYINDEX);
+    char* bytes = lua_touserdata(L, -1);
+
+    slogt("first byte of buff is x%02x", bytes[0]);
+
+    for( int i = 0; i < numlights; i++)
+    {
+        bytes[(i * 3) + 0] = 0x00;
+        bytes[(i * 3) + 1] = 0x00;
+        bytes[(i * 3) + 2] = 0x00;
+    }
+
+}
+
+int led_clear_range(lua_State *L)
+{
+
+    slogt("lua called c function led_clear_range");
+
+    int range_start = lua_tonumber(L, 1);
+    int range_end = lua_tonumber(L, 2);
+
+    slogd("lua range start is %i", range_start);
+    slogd("lua range end is %i", range_end);
+
+    range_start = range_start - 1;
+
+    lua_getglobal(L, "TotalLeds");
+    int numlights = 0;
+    if (lua_isnumber(L, -1))
+    {
+        numlights = lua_tonumber(L, -1);
+    }
+    slogd("num leds is %i", numlights);
+
+    if(range_end > numlights)
+    {
+        range_end = numlights;
+    }
+
+    if(range_end == 0)
+    {
+        return 1;
+    }
+
+    lua_pushstring(L, "buff");
+    lua_gettable(L, LUA_REGISTRYINDEX);
+    char* bytes = lua_touserdata(L, -1);
+
+    slogt("first byte of buff is x%02x", bytes[0]);
+
+    for( int i = 0; i < numlights; i++)
+    {
+        bytes[(i * 3) + 0] = 0x00;
+        bytes[(i * 3) + 1] = 0x00;
+        bytes[(i * 3) + 2] = 0x00;
+    }
+
+}
@@ -0,0 +1,26 @@
+#ifndef _ARDUINOLEDLUA_H
+#define _ARDUINOLEDLUA_H
+
+#include "lua.h"
+#include "lauxlib.h"
+#include "lualib.h"
+
+#include "../../simulatorapi/simapi/simapi/simdata.h"
+
+typedef enum {
+    LUALEDCOLOR_RED = 1,
+    LUALEDCOLOR_GREEN,
+    LUALEDCOLOR_BLUE,
+    LUALEDCOLOR_YELLOW,
+    LUALEDCOLOR_ORANGE,
+} LUALEDColor;
+
+int simdata_to_lua(lua_State *L, SimData* simdata);
+int set_led_range_to_color(lua_State *L);
+int set_led_to_color(lua_State *L);
+int set_led_range_to_rgb_color(lua_State *L);
+int set_led_to_rgb_color(lua_State *L);
+int led_clear_all(lua_State *L);
+int led_clear_range(lua_State *L);
+
+#endif
@@ -0,0 +1,89 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+#include <hidapi/hidapi.h>
+
+#include "moza.h"
+#include "../serialadapter.h"
+#include "../../slog/slog.h"
+
+#define MOZA_TIMEOUT 1000
+#define MOZA_SERIAL_TEMPLATE {0x7e, 0x06, 0x41, 0x13, 0xfd, 0xde, 0x0, 0x0, 0x0, 0x0, 0x0}
+#define MOZA_NUM_AVAILABLE_LEDS 10
+#define MOZA_BLINKING_BIT 7
+#define MOZA_PAYLOAD_SIZE 11
+#define MOZA_MAGIC_VALUE 0x0d
+#define BIT(nr) (1UL << (nr))
+
+unsigned char moza_checksum(unsigned char *data, unsigned short size)
+{
+    unsigned int ret = MOZA_MAGIC_VALUE;
+    for (unsigned short i = 0; i < size; i++)
+    {
+        ret += data[i];
+    }
+
+    return ret % 0x100;
+}
+
+int moza_update(SerialDevice* serialdevice, unsigned short rpm, unsigned short maxrpm)
+{
+    unsigned char bytes[] = MOZA_SERIAL_TEMPLATE;
+    unsigned short size = MOZA_PAYLOAD_SIZE;
+    float perctflt = ((float)rpm/(float)maxrpm)*100;
+    int perct = round(perctflt);
+
+    if (perct >= 10)
+        bytes[9] |= BIT(0);
+
+    if (perct >= 20)
+        bytes[9] |= BIT(1);
+
+    if (perct >= 30)
+        bytes[9] |= BIT(2);
+
+    if (perct >= 40)
+        bytes[9] |= BIT(3);
+
+    if (perct >= 50)
+        bytes[9] |= BIT(4);
+
+    if (perct >= 60)
+        bytes[9] |= BIT(5);
+
+    if (perct >= 70)
+        bytes[9] |= BIT(6);
+
+    if (perct >= 80)
+        bytes[9] |= BIT(7);
+
+    if (perct >= 90)
+        bytes[8] |= BIT(0);
+
+    if (perct >= 92)
+        bytes[8] |= BIT(1);
+
+    // blinking
+    if (perct >= 94)
+        bytes[8] |= BIT(MOZA_BLINKING_BIT);
+
+    bytes[10] = moza_checksum(bytes, size);
+
+    int result = 1;
+    if (serialdevice->port)
+    {
+        slogd("copying %i bytes to moza device", MOZA_PAYLOAD_SIZE);
+        slogt("writing bytes %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x from rpm %i maxrpm %i", bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7], bytes[8], bytes[9], bytes[10], rpm, maxrpm);
+        result = monocoque_serial_write(serialdevice->id, bytes, size, MOZA_TIMEOUT);
+    }
+
+    return result;
+}
+
+int moza_init(SerialDevice* serialdevice, const char* portdev)
+{
+    serialdevice->id = monocoque_serial_open(serialdevice, portdev);
+    return serialdevice->id;
+}
@@ -0,0 +1,11 @@
+#ifndef _MOZA_H
+#define _MOZA_H
+
+#include "../serialdevice.h"
+#include "../simdevice.h"
+
+int moza_update(SerialDevice* serialdevice, unsigned short rpm, unsigned short maxrpm);
+int moza_init(SerialDevice* serialdevice, const char* portdev);
+unsigned char moza_checksum(unsigned char *data, unsigned short size);
+
+#endif
@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+#include <hidapi/hidapi.h>
+
+#include "moza.h"
+#include "moza_new.h"
+#include "../serialadapter.h"
+#include "../../slog/slog.h"
+
+#define MOZA_TIMEOUT 1000
+#define MOZA_MAGIC_VALUE 0x0d
+#define MOZA_RPM_MASK_TEMPLATE {0x7e, 0x06, 0x3f, 0x17, 0x1a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}
+#define MOZA_RPM_MASK_PAYLOAD_SIZE 11
+#define MOZA_RPM_COLOR_PAYLOAD_1 {0x7e, 0x16, 0x3f, 0x17, 0x19, 0, 0, 0, 0xff, 0, 1, 0, 0xff, 0, 2, 0, 0xff, 0, 3, 0xff, 0x7f, 0, 4, 0xff, 0x7f, 0, 0}
+#define MOZA_RPM_COLOR_PAYLOAD_2 {0x7e, 0x16, 0x3f, 0x17, 0x19, 0, 5, 0xff, 0x7f, 0, 6, 0xff, 0x7f, 0, 7, 0xff, 0, 0, 8, 0xff, 0, 0, 9, 0xff, 0, 0, 0}
+#define MOZA_BTN_COLOR_PAYLOAD_1 {0x7e, 0x16, 0x3f, 0x17, 0x19, 1, 0, 0xff, 0, 0, 1, 0xff, 0, 0, 2, 0xff, 0, 0, 3, 0xff, 0, 0, 4, 0xff, 0, 0, 0}
+#define MOZA_BTN_COLOR_PAYLOAD_2 {0x7e, 0x16, 0x3f, 0x17, 0x19, 1, 5, 0xff, 0, 0, 6, 0xff, 0, 0, 7, 0xff, 0, 0, 8, 0xff, 0, 0, 9, 0xff, 0, 0, 0}
+#define MOZA_COLOR_PAYLOAD_SIZE 27
+#define BIT(nr) (1UL << (nr))
+
+int moza_new_update(SerialDevice* serialdevice, SimData* simData)
+{
+    unsigned char bytes[] = MOZA_RPM_MASK_TEMPLATE;
+    int size = MOZA_RPM_MASK_PAYLOAD_SIZE;
+    float perctflt = ((float)simData->rpms/(float)simData->maxrpm)*100;
+    int perct = round(perctflt);
+    if (perct >= 98 && (simData->mtick >> 7) & 1 == 1) perct = 0;
+
+    if (perct >= 75)
+        bytes[6] |= BIT(0);
+
+    if (perct >= 79)
+        bytes[6] |= BIT(1);
+
+    if (perct >= 82)
+        bytes[6] |= BIT(2);
+
+    if (perct >= 85)
+        bytes[6] |= BIT(3);
+
+    if (perct >= 87)
+        bytes[6] |= BIT(4);
+
+    if (perct >= 88)
+        bytes[6] |= BIT(5);
+
+    if (perct >= 89)
+        bytes[6] |= BIT(6);
+
+    if (perct >= 90)
+        bytes[6] |= BIT(7);
+
+    if (perct >= 92)
+        bytes[7] |= BIT(0);
+
+    if (perct >= 94)
+        bytes[7] |= BIT(1);
+
+    bytes[10] = moza_checksum(bytes, size);
+
+    int result = 1;
+    if (serialdevice->port)
+    {
+        slogd("copying %i bytes to moza device", MOZA_RPM_MASK_PAYLOAD_SIZE);
+        slogt("writing bytes %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x from rpm %i maxrpm %i", bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7], bytes[8], bytes[9], bytes[10], simData->rpms, simData->maxrpm);
+        result = monocoque_serial_write(serialdevice->id, bytes, size, MOZA_TIMEOUT);
+    }
+
+    return result;
+}
+
+int moza_new_init(SerialDevice* serialdevice, const char* portdev)
+{
+    serialdevice->id = monocoque_serial_open(serialdevice, portdev);
+    if (serialdevice->id == -1) return serialdevice->id;
+
+    unsigned char p1[] = MOZA_RPM_COLOR_PAYLOAD_1;
+    unsigned char p2[] = MOZA_RPM_COLOR_PAYLOAD_2;
+    unsigned char p3[] = MOZA_BTN_COLOR_PAYLOAD_1;
+    unsigned char p4[] = MOZA_BTN_COLOR_PAYLOAD_2;
+
+    p1[MOZA_COLOR_PAYLOAD_SIZE-1] = moza_checksum(p1, MOZA_COLOR_PAYLOAD_SIZE);
+    p2[MOZA_COLOR_PAYLOAD_SIZE-1] = moza_checksum(p2, MOZA_COLOR_PAYLOAD_SIZE);
+    p3[MOZA_COLOR_PAYLOAD_SIZE-1] = moza_checksum(p3, MOZA_COLOR_PAYLOAD_SIZE);
+    p4[MOZA_COLOR_PAYLOAD_SIZE-1] = moza_checksum(p4, MOZA_COLOR_PAYLOAD_SIZE);
+
+    monocoque_serial_write(serialdevice->id, p1, MOZA_COLOR_PAYLOAD_SIZE, MOZA_TIMEOUT);
+    monocoque_serial_write(serialdevice->id, p2, MOZA_COLOR_PAYLOAD_SIZE, MOZA_TIMEOUT);
+    monocoque_serial_write(serialdevice->id, p3, MOZA_COLOR_PAYLOAD_SIZE, MOZA_TIMEOUT);
+    monocoque_serial_write(serialdevice->id, p4, MOZA_COLOR_PAYLOAD_SIZE, MOZA_TIMEOUT);
+
+    return serialdevice->id;
+}
@@ -0,0 +1,10 @@
+#ifndef _MOZA_NEW_H
+#define _MOZA_NEW_H
+
+#include "../serialdevice.h"
+#include "../simdevice.h"
+
+int moza_new_update(SerialDevice* serialdevice, SimData* simData);
+int moza_new_init(SerialDevice* serialdevice, const char* portdev);
+
+#endif
@@ -0,0 +1,286 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "serialadapter.h"
+#include "../slog/slog.h"
+
+int msastrcicmp(char const *a, char const *b)
+{
+    for (;; a++, b++) {
+        int d = tolower((unsigned char)*a) - tolower((unsigned char)*b);
+        if (d != 0 || !*a)
+            return d;
+    }
+}
+
+int check(enum sp_return result)
+{
+    char* error_message;
+
+    switch (result)
+    {
+        case SP_ERR_ARG:
+            return 1;
+        case SP_ERR_FAIL:
+            error_message = sp_last_error_message();
+            sloge("error: serial write failed: %s", error_message);
+            sp_free_error_message(error_message);
+        case SP_ERR_SUPP:
+            printf("Error: Not supported.\n");
+        case SP_ERR_MEM:
+            printf("Error: Couldn't allocate memory.\n");
+        case SP_OK:
+        default:
+            return result;
+    }
+}
+
+int monocoque_serial_free(SerialDevice* serialdevice)
+{
+    monocoque_serial_device monocoque_serial_dev = monocoque_serial_devices[serialdevice->id];
+
+    if(monocoque_serial_dev.open == true)
+    {
+        while(monocoque_serial_dev.busy == true)
+        {
+            slogt("hopefully this doesn't happen long");
+            continue;
+        }
+
+        monocoque_serial_devices[serialdevice->id].busy = true;
+        monocoque_serial_devices[serialdevice->id].refs--;
+
+        if(monocoque_serial_devices[serialdevice->id].refs == 0)
+        {
+            slogd("freeing physical device %s", monocoque_serial_devices[serialdevice->id].portname);
+            sp_close(monocoque_serial_devices[serialdevice->id].port);
+            sp_free_port(monocoque_serial_devices[serialdevice->id].port);
+            free(monocoque_serial_devices[serialdevice->id].portname);
+
+            monocoque_serial_devices[serialdevice->id].port = NULL;
+            monocoque_serial_devices[serialdevice->id].portname = NULL;
+            monocoque_serial_devices[serialdevice->id].busy = false;
+            monocoque_serial_devices[serialdevice->id].open = false;
+            monocoque_serial_devices[serialdevice->id].openfail = false;
+        }
+        else
+        {
+            monocoque_serial_devices[serialdevice->id].busy = false;
+        }
+
+    }
+}
+
+
+int monocoque_wait_for_event(uint8_t serialdevicenum, int event)
+{
+
+    slogt("serial device id %i", serialdevicenum);
+    monocoque_serial_device monocoque_serial_dev = monocoque_serial_devices[serialdevicenum];
+
+    int retval;
+    struct sp_event_set* eventSet = NULL;
+
+    retval = sp_new_event_set(&eventSet);
+    if (retval == SP_OK)
+    {
+        retval = sp_add_port_events(eventSet, monocoque_serial_dev.port, event);
+        if (retval == SP_OK)
+        {
+            slogd("set event on port");
+            retval = sp_wait(eventSet, 5000);
+        }
+        else
+        {
+            sloge("Unable to add events to port.");
+            retval = -1;
+        }
+    }
+    else
+    {
+        sloge("Unable to create new event set.");
+        retval = -1;
+    }
+    sp_free_event_set(eventSet);
+
+    return retval;
+}
+
+int monocoque_input_wait(uint8_t serialdevicenum)
+{
+    monocoque_serial_device monocoque_serial_dev = monocoque_serial_devices[serialdevicenum];
+    return sp_input_waiting(monocoque_serial_dev.port);
+}
+
+int monocoque_serial_write(uint8_t serialdevicenum, void* data, size_t size, int timeout)
+{
+    slogt("serial device id %i", serialdevicenum);
+    monocoque_serial_device monocoque_serial_dev = monocoque_serial_devices[serialdevicenum];
+
+    slogt("port name: %s, busy %i, open %i, openfail %i", monocoque_serial_dev.portname, monocoque_serial_dev.busy, monocoque_serial_dev.open, monocoque_serial_dev.busy);
+
+    if(monocoque_serial_dev.port == NULL)
+    {
+        sloge("port is null");
+    }
+
+    int result = -1;
+    if(monocoque_serial_dev.busy == false && monocoque_serial_dev.open == true)
+    {
+        monocoque_serial_dev.busy = true;
+        result = sp_blocking_write(monocoque_serial_dev.port, data, size, timeout);
+    }
+    else
+    {
+        slogw("serial device data update ignored due to busy or lost device");
+        result = -1;
+    }
+    slogt("write result is %i", result);
+    monocoque_serial_dev.busy = false;
+    return result;
+}
+
+int monocoque_serial_write_block(uint8_t serialdevicenum, void* data, size_t size, int timeout)
+{
+    slogt("serial device id %i", serialdevicenum);
+    monocoque_serial_device monocoque_serial_dev = monocoque_serial_devices[serialdevicenum];
+
+    slogt("port name: %s, busy %i, open %i, openfail %i", monocoque_serial_dev.portname, monocoque_serial_dev.busy, monocoque_serial_dev.open, monocoque_serial_dev.busy);
+
+    if(monocoque_serial_dev.port == NULL)
+    {
+        sloge("port is null");
+    }
+
+    int result = -1;
+    if(monocoque_serial_dev.open == true)
+    {
+        while(monocoque_serial_dev.busy == true)
+        {
+            slogt("hopefully this doesn't happen long");
+            continue;
+        }
+
+        monocoque_serial_dev.busy = true;
+        result = sp_blocking_write(monocoque_serial_dev.port, data, size, timeout);
+        slogi("actually performed write");
+    }
+
+    monocoque_serial_dev.busy = false;
+    return result;
+}
+
+int monocoque_serial_read_block(uint8_t serialdevicenum, void* data, size_t size, int timeout)
+{
+    slogt("serial device id %i", serialdevicenum);
+    monocoque_serial_device monocoque_serial_dev = monocoque_serial_devices[serialdevicenum];
+
+    slogt("port name: %s, busy %i, open %i, openfail %i", monocoque_serial_dev.portname, monocoque_serial_dev.busy, monocoque_serial_dev.open, monocoque_serial_dev.busy);
+
+    if(monocoque_serial_dev.port == NULL)
+    {
+        sloge("port is null");
+    }
+
+    int result = -1;
+    if(monocoque_serial_dev.open == true)
+    {
+        while(monocoque_serial_dev.busy == true)
+        {
+            slogt("hopefully this doesn't happen long");
+            continue;
+        }
+
+        monocoque_serial_dev.busy = true;
+        result = sp_blocking_read(monocoque_serial_dev.port, data, size, timeout);
+        slogi("actually performed read");
+    }
+
+    monocoque_serial_dev.busy = false;
+    return result;
+}
+
+int monocoque_serial_open(SerialDevice* serialdevice, const char* portdev)
+{
+    int serial_device_num = -1;
+    bool notfound = true;
+    slogi("looking to open physical serialdevice %s", portdev);
+    for(int i = 0; i < 10; i++)
+    {
+        if(monocoque_serial_devices[i].open == true && monocoque_serial_devices[i].openfail == false)
+        {
+            if(msastrcicmp(monocoque_serial_devices[i].portname, portdev) == 0)
+            {
+                notfound = false;
+                serial_device_num = i;
+                monocoque_serial_devices[i].refs++;
+                slogd("found exisiting handle to serial device %s", portdev);
+            }
+        }
+    }
+
+    if(notfound == true)
+    {
+        slogd("no existing connections found, looking to create new");
+        int i = -1;
+        bool avail = false;
+        while(avail == false)
+        {
+            i++;
+            if(monocoque_serial_devices[i].open == false && monocoque_serial_devices[i].openfail == false)
+            {
+                avail = true;
+                break;
+            }
+        }
+
+
+        slogi("opening physical serial device...");
+        int error = 0;
+        char* port_name = strdup(portdev);
+        monocoque_serial_devices[i].portname = strdup(port_name);
+
+        struct sp_port* sp;
+        slogd("Looking for port %s", port_name);
+        error = check(sp_get_port_by_name(port_name, &sp));
+        if (error != 0)
+        {
+            sloge("Error opening serial port");
+            free(port_name);
+            free(monocoque_serial_devices[i].portname);
+            monocoque_serial_devices[i].portname = NULL;
+            monocoque_serial_devices[i].open = false;
+            monocoque_serial_devices[i].openfail = false;
+            return -1;
+        }
+
+        slogd("Opening port");
+        check(sp_open(sp, SP_MODE_READ | SP_MODE_WRITE));
+
+        slogd("Setting port to %i 8N1, no flow control", serialdevice->baudrate);
+        check(sp_set_baudrate(sp, serialdevice->baudrate));
+        check(sp_set_bits(sp, 8));
+        check(sp_set_parity(sp, SP_PARITY_NONE));
+        check(sp_set_stopbits(sp, 1));
+        check(sp_set_flowcontrol(sp, SP_FLOWCONTROL_NONE));
+
+        check(sp_set_rts(sp, 1));
+        check(sp_set_dtr(sp, 1));
+
+        monocoque_serial_devices[i].port = sp;
+
+        monocoque_serial_devices[i].open = true;
+        monocoque_serial_devices[i].openfail = false;
+        monocoque_serial_devices[i].busy = false;
+        monocoque_serial_devices[i].refs++;
+
+        serial_device_num = i;
+
+        free(port_name);
+        slogd("Successfully setup monocoque serial device...");
+    }
+
+    return serial_device_num;
+}
@@ -0,0 +1,31 @@
+#ifndef _SERIALADAPTER_H
+#define _SERIALADAPTER_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <libserialport.h>
+
+#include "simdevice.h"
+
+typedef struct
+{
+    char* portname;
+    struct sp_port* port;
+    uint8_t refs;
+    bool open;
+    bool openfail;
+    bool busy;
+}
+monocoque_serial_device;
+
+static monocoque_serial_device monocoque_serial_devices[20];
+
+int monocoque_input_wait(uint8_t serialdevicenum);
+int monocoque_wait_for_event(uint8_t serialdevicenum, int event);
+int monocoque_serial_write(uint8_t serialdevicenum, void* data, size_t size, int timeout);
+int monocoque_serial_write_block(uint8_t serialdevicenum, void* data, size_t size, int timeout);
+int monocoque_serial_read_block(uint8_t serialdevicenum, void* data, size_t size, int timeout);
+int monocoque_serial_open(SerialDevice* serialdevice, const char* port);
+int monocoque_serial_free(SerialDevice* serialdevice);
+
+#endif
@@ -6,19 +6,68 @@

 #include "simdevice.h"
 #include "serialdevice.h"
+#include "serialadapter.h"
 #include "hapticeffect.h"
 #include "serial/arduino.h"
+#include "serial/moza.h"
+#include "serial/moza_new.h"
 #include "../helper/parameters.h"
 #include "../simulatorapi/simapi/simapi/simdata.h"
 #include "../slog/slog.h"

+#define KPHTOMPH .621317
+
+int serial_wheel_update(SimDevice* this, SimData* simdata)
+{
+    SerialDevice* serialdevice = (void *) this->derived;
+
+    switch (serialdevice->devicetype) {
+      case SIMDEVSUBTYPE_MOZA_NEW:
+        moza_new_update(serialdevice, simdata);
+        break;
+
+      case SIMDEVSUBTYPE_MOZAR5:
+      default:
+        moza_update(serialdevice, simdata->rpms, simdata->maxrpm);
+        break;
+    }
+
+    return 0;
+}
+
 int serialdev_update(SimDevice* this, SimData* simdata)
 {
    SerialDevice* serialdevice = (void *) this->derived;

-
-
    arduino_update(serialdevice, simdata, sizeof(SimData));
+
+    return 0;
+}
+
+int arduino_custom_updater(SimDevice* this, SimData* simdata)
+{
+    SerialDevice* serialdevice = (void *) this->derived;
+
+    arduino_custom_update(serialdevice, simdata);
+
+    return 0;
+}
+
+int arduino_customled_updater(SimDevice* this, SimData* simdata)
+{
+    SerialDevice* serialdevice = (void *) this->derived;
+
+    arduino_customled_update(serialdevice, simdata);
+
+    return 0;
+}
+
+int arduino_simled_updater(SimDevice* this, SimData* simdata)
+{
+    SerialDevice* serialdevice = (void *) this->derived;
+
+    arduino_simled_update(serialdevice, simdata);
+
    return 0;
 }

@@ -28,9 +77,28 @@ int arduino_shiftlights_update(SimDevice* this, SimData* simdata)
    int result = 1;


-    serialdevice->u.shiftlightsdata.maxrpm = simdata->maxrpm;
-    serialdevice->u.shiftlightsdata.rpm = simdata->rpms;
-    slogt("Updating arduino device rpms to %i", serialdevice->u.shiftlightsdata.rpm);
+    int num_avail_leds = serialdevice->numlights;
+    int rpm = simdata->rpms;
+    int maxrpm = simdata->maxrpm;
+    int litleds = 0;
+    if(rpm > 0 && maxrpm > 0)
+    {
+        int rpmmargin = ceil(.05*maxrpm);
+        int rpminterval = (maxrpm-rpmmargin) / (num_avail_leds);
+
+
+        for (int l = 1; l <= (num_avail_leds); l++)
+        {
+            if(rpm >= (rpminterval * l))
+            {
+                litleds = l;
+            }
+        }
+    }
+
+    serialdevice->u.shiftlightsdata.litleds = litleds;
+    //serialdevice->u.shiftlightsdata.rpm = simdata->rpms;
+    slogt("Updating arduino device lights to %i", serialdevice->u.shiftlightsdata.litleds);
    // we can add configs to set all the colors
    // i can move the size to the initialization since it should not change
    size_t size = sizeof(ShiftLightsData);
@@ -39,15 +107,19 @@ int arduino_shiftlights_update(SimDevice* this, SimData* simdata)
    return result;
 }

+
+
 int arduino_simwind_update(SimDevice* this, SimData* simdata)
 {
    SerialDevice* serialdevice = (void *) this->derived;
    int result = 1;

-    serialdevice->u.simwinddata.velocity = simdata->velocity;
+    // sending over as mph, when you consider 255mph to be a reasonable upper limit
+    serialdevice->u.simwinddata.velocity = ceil(simdata->velocity*KPHTOMPH);
+
    slogt("Updating arduino device speed to %i", serialdevice->u.simwinddata.velocity);
    // this can be added to the config, all config dependent can be added to init
-    serialdevice->u.simwinddata.fanpower = 0.6;
+    serialdevice->u.simwinddata.fanpower = (int)0.6 * 255;
    size_t size = sizeof(SimWindData);

    arduino_update(serialdevice, &serialdevice->u.simwinddata, size);
@@ -81,13 +153,13 @@ int arduino_simhaptic_update(SimDevice* this, SimData* simdata)
        {
            serialdevice->u.simhapticdata.effect1 = effectspeed;
            serialdevice->u.simhapticdata.motor1 = 1;
-            slogt("Updating arduino haptic device speed motor speed %i on motor %i from original effect %f", serialdevice->u.simhapticdata.effect1, serialdevice->motorsposition, rplay);
+            slogt("Updating arduino haptic device with effect type %i speed motor speed %i on motor %i from original effect %f with ampfactor %f", this->hapticeffect.effecttype, serialdevice->u.simhapticdata.effect3, serialdevice->motorsposition, rplay, serialdevice->ampfactor);
        }
        if (motor == 2 || motor == 6 || motor == 8 || motor == 9 || motor == 10 || motor == 11 || motor == 12 || motor == 14)
        {
            serialdevice->u.simhapticdata.effect3 = effectspeed;
            serialdevice->u.simhapticdata.motor3 = 1;
-            slogt("Updating arduino haptic device speed motor speed %i on motor %i from original effect %f", serialdevice->u.simhapticdata.effect3, serialdevice->motorsposition, rplay);
+            slogt("Updating arduino haptic device with effect type %i speed motor speed %i on motor %i from original effect %f with ampfactor %f", this->hapticeffect.effecttype, serialdevice->u.simhapticdata.effect3, serialdevice->motorsposition, rplay, serialdevice->ampfactor);
        }
        serialdevice->state = play;
    }
@@ -95,7 +167,6 @@ int arduino_simhaptic_update(SimDevice* this, SimData* simdata)
    size_t size = sizeof(SimHapticData);

    arduino_update(serialdevice, &serialdevice->u.simhapticdata, size);
-
    return result;
 }

@@ -103,31 +174,107 @@ int serialdev_free(SimDevice* this)
 {
    SerialDevice* serialdevice = (void *) this->derived;

-    arduino_free(serialdevice);
+    switch (serialdevice->devicetype) {
+        case (ARDUINODEV__HAPTIC):
+
+            serialdevice->u.simhapticdata.effect1 = 0;
+            serialdevice->u.simhapticdata.motor1 = 1;
+            serialdevice->u.simhapticdata.effect2 = 0;
+            serialdevice->u.simhapticdata.motor2 = 1;
+            serialdevice->u.simhapticdata.effect3 = 0;
+            serialdevice->u.simhapticdata.motor3 = 1;
+            serialdevice->u.simhapticdata.effect4 = 0;
+            serialdevice->u.simhapticdata.motor4 = 1;
+            serialdevice->state = 0;
+
+            size_t size = sizeof(SimHapticData);
+            monocoque_serial_write_block(serialdevice->id, &serialdevice->u.simhapticdata, size, 9000);
+            slogi("set zero to arduino device");
+            break;
+        case ARDUINODEV__SIMLED__CUSTOM:
+            //arduino_customled_free(serialdevice, true);
+            free(serialdevice->m.device_specific_config_file);
+            break;
+        case ARDUINODEV__SIMLED:
+            arduino_customled_free(serialdevice, false);
+            break;
+    }
+
+
+    monocoque_serial_free(serialdevice);

    free(serialdevice);
+
    return 0;
 }

-int serialdev_init(SerialDevice* serialdevice, const char* portdev, int motorsposition)
+int serial_wheel_free(SimDevice* this)
 {
-    slogi("initializing serial device...");
+    SerialDevice* serialdevice = (void *) this->derived;
+
+    monocoque_serial_free(serialdevice);
+
+    free(serialdevice);
+
+    return 0;
+}
+
+int serialdev_init(SerialDevice* serialdevice, DeviceSettings* ds)
+{
+    slogi("initializing serial device on port %s to %i...", ds->serialdevsettings.portdev, ds->serialdevsettings.baud);
    int error = 0;

-    serialdevice->type = SERIALDEV_UNKNOWN;
-    serialdevice->type = SERIALDEV_ARDUINO;

-    serialdevice->motorsposition = motorsposition;
+    serialdevice->motorsposition = ds->serialdevsettings.motorsposition;
+    serialdevice->baudrate = ds->serialdevsettings.baud;
+
+    switch (serialdevice->devicetype)
+    {
+        case SERIALDEV__MOZAR5:
+            // the wheel stuff assumed it was a usb
+            //error = wheeldev_init(&serialdevice->u.wheeldevice, ds);
+            // maybe this call a more generic serial wheel init first
+            error = moza_init(serialdevice, ds->serialdevsettings.portdev);
+            break;
+        case SERIALDEV__MOZA_NEW:
+            error = moza_new_init(serialdevice, ds->serialdevsettings.portdev);
+            break;
+        case ARDUINODEV__SIMLED__CUSTOM:
+            serialdevice->m.device_specific_config_file = strdup(ds->specific_config_file);
+            error = arduino_custom_init(serialdevice, ds->serialdevsettings.portdev, serialdevice->m.device_specific_config_file, true);
+            if(error < 0)
+            {
+                free(serialdevice->m.device_specific_config_file);
+            }
+            break;
+        case ARDUINODEV__CUSTOM:
+            serialdevice->m.device_specific_config_file = strdup(ds->specific_config_file);
+            error = arduino_custom_init(serialdevice, ds->serialdevsettings.portdev, serialdevice->m.device_specific_config_file, false);
+            if(error < 0)
+            {
+                free(serialdevice->m.device_specific_config_file);
+            }
+            break;
+        case ARDUINODEV__SIMLED:
+            error = arduino_custom_init(serialdevice, ds->serialdevsettings.portdev, NULL, false);
+            break;
+        default:
+            error = arduino_init(serialdevice, ds->serialdevsettings.portdev);
+            break;
+    }

-    error = arduino_init(serialdevice, portdev);

    return error;
 }

 static const vtable serial_simdevice_vtable = { &serialdev_update, &serialdev_free };
 static const vtable arduino_shiftlights_vtable = { &arduino_shiftlights_update, &serialdev_free };
+static const vtable arduino_simled_vtable = { &arduino_simled_updater, &serialdev_free };
+static const vtable arduino_custom_vtable = { &arduino_custom_updater, &serialdev_free };
+static const vtable arduino_simled_custom_vtable = { &arduino_customled_updater, &serialdev_free };
 static const vtable arduino_simwind_vtable = { &arduino_simwind_update, &serialdev_free };
 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) {

@@ -137,19 +284,46 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
    this->m.free = &simdevfree;
    this->m.derived = this;
    this->m.vtable = &serial_simdevice_vtable;
+    this->type = SERIALDEV_ARDUINO;

    slogt("Attempting to configure arduino device with subtype: %i", ds->dev_subtype);
    switch (ds->dev_subtype) {
        case (SIMDEVTYPE_SHIFTLIGHTS):
            this->devicetype = ARDUINODEV__SHIFTLIGHTS;
+            this->numlights = ds->serialdevsettings.numlights;
            this->m.vtable = &arduino_shiftlights_vtable;
            slogi("Initializing arduino device for shiftlights.");
            break;
+        case (SIMDEVTYPE_SIMLED):
+
+            if(ds->has_config == true)
+            {
+                this->devicetype = ARDUINODEV__SIMLED__CUSTOM;
+                this->startled = ds->serialdevsettings.startled;
+                this->endled = ds->serialdevsettings.endled;
+                this->m.vtable = &arduino_simled_custom_vtable;
+                slogi("Initializing arduino device for custom simled.");
+            }
+            else
+            {
+                this->devicetype = ARDUINODEV__SIMLED;
+                this->numleds = ds->serialdevsettings.numleds;
+                this->startled = ds->serialdevsettings.startled;
+                this->endled = ds->serialdevsettings.endled;
+                this->m.vtable = &arduino_simled_vtable;
+                slogi("Initializing arduino device for simled.");
+            }
+            break;
        case (SIMDEVTYPE_SIMWIND):
            this->devicetype = ARDUINODEV__SIMWIND;
            this->m.vtable = &arduino_simwind_vtable;
            slogi("Initializing arduino devices for sim wind.");
            break;
+        case (SIMDEVTYPE_ARDUINOCUSTOM):
+            this->devicetype = ARDUINODEV__CUSTOM;
+            this->m.vtable = &arduino_custom_vtable;
+            slogi("Initializing custom arduino device.");
+            break;
        case (SIMDEVTYPE_SERIALHAPTIC):
            this->devicetype = ARDUINODEV__HAPTIC;
            this->m.vtable = &arduino_simhaptic_vtable;
@@ -165,6 +339,24 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
            this->ampfactor = ds->serialdevsettings.ampfactor;
            slogi("Initializing arduino device for haptic effects.");
            break;
+        case (SIMDEVTYPE_SERIALWHEEL):
+            this->type = SERIALDEV_WHEEL;
+
+            switch (ds->dev_subsubtype) {
+
+                case SIMDEVSUBTYPE_MOZA_NEW:
+                  slogi("Initializing new firmware Moza serial wheel device.");
+                  this->devicetype = SERIALDEV__MOZA_NEW;
+                  this->m.vtable = &serialwheel_vtable;
+                  break;
+                case SIMDEVSUBTYPE_MOZAR5:
+                default:
+                  //move this stuff to wheeldevice or it's own serial wheel device module
+                  slogi("Initializing Moza serial wheel device.");
+                  this->devicetype = SERIALDEV__MOZAR5;
+                  this->m.vtable = &serialwheel_vtable;
+                  break;
+            }
    }

    if(this->devicetype == ARDUINODEV__HAPTIC)
@@ -178,9 +370,9 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
        this->m.hapticeffect.tyrediameterconfig = ms->tyre_diameter_config;
    }

-    int error = serialdev_init(this, ds->serialdevsettings.portdev, ds->serialdevsettings.motorsposition);
+    int error = serialdev_init(this, ds);

-    if (error != 0)
+    if (error < 0)
    {
        free(this);
        return NULL;
@@ -2,12 +2,18 @@
 #define _SERIALDEVICE_H

 #include <libserialport.h>
+#include "wheeldevice.h"

 typedef enum
 {
-    ARDUINODEV__SHIFTLIGHTS   = 0,
-    ARDUINODEV__SIMWIND       = 1,
-    ARDUINODEV__HAPTIC        = 2,
+    ARDUINODEV__SHIFTLIGHTS           = 0,
+    ARDUINODEV__SIMWIND               = 1,
+    ARDUINODEV__HAPTIC                = 2,
+    SERIALDEV__MOZAR5                 = 3,
+    ARDUINODEV__SIMLED                = 4,
+    ARDUINODEV__SIMLED__CUSTOM        = 5,
+    ARDUINODEV__CUSTOM                = 6,
+    SERIALDEV__MOZA_NEW               = 7
 }
 SerialDeviceType;

@@ -40,6 +40,7 @@ int devinit(SimDevice* simdevices, int numdevices, DeviceSettings* ds, Monocoque
                simdevices[j] = sim->m;
                simdevices[j].initialized = true;
                simdevices[j].type = SIMDEV_USB;
+                simdevices[j].fps = ds[j].fps;
                devices++;
            }
            else
@@ -49,19 +50,26 @@ int devinit(SimDevice* simdevices, int numdevices, DeviceSettings* ds, Monocoque
        }

        if (ds[j].dev_type == SIMDEV_SOUND) {
-
-            SoundDevice* sim = new_sound_device(&ds[j], ms);
-            if (sim != NULL)
+            if(ms->disable_audio == true)
            {
-
-                simdevices[j] = sim->m;
-                simdevices[j].initialized = true;
-                simdevices[j].type = SIMDEV_SOUND;
-                devices++;
+                slogi("skipping configured sound device due to disable_audio being specified...");
            }
            else
            {
-                slogw("Could not initialize Sound Device");
+                SoundDevice* sim = new_sound_device(&ds[j], ms);
+                if (sim != NULL)
+                {
+
+                    simdevices[j] = sim->m;
+                    simdevices[j].initialized = true;
+                    simdevices[j].type = SIMDEV_SOUND;
+                    simdevices[j].fps = ds[j].fps;
+                    devices++;
+                }
+                else
+                {
+                    slogw("Could not initialize Sound Device");
+                }
            }
        }

@@ -73,6 +81,7 @@ int devinit(SimDevice* simdevices, int numdevices, DeviceSettings* ds, Monocoque
                simdevices[j] = sim->m;
                simdevices[j].initialized = true;
                simdevices[j].type = SIMDEV_SERIAL;
+                simdevices[j].fps = ds[j].fps;
                devices++;

            }
@@ -2,11 +2,16 @@
 #define _SIMDEVICE_H

 #include <stdbool.h>
+#include <hidapi/hidapi.h>
+
+#include "lua.h"

 #include "usbdevice.h"
 #include "sounddevice.h"
 #include "serialdevice.h"
+
 #include "hapticeffect.h"
+
 #include "../helper/confighelper.h"
 #include "../simulatorapi/simapi/simapi/simdata.h"

@@ -23,7 +28,10 @@ struct SimDevice
    int (*free)(SimDevice*);
    void* derived;
    int id;
+    int fps;
    bool initialized;
+    lua_State* L;
+    char* device_specific_config_file;
    DeviceType type;
    HapticEffect hapticeffect;
 };
@@ -37,7 +45,8 @@ typedef struct {
 typedef enum
 {
    SERIALDEV_UNKNOWN       = 0,
-    SERIALDEV_ARDUINO       = 1
+    SERIALDEV_ARDUINO       = 1,
+    SERIALDEV_WHEEL         = 2,
 }
 SerialType;

@@ -47,9 +56,15 @@ typedef struct
    int id;
    SerialType type;
    struct sp_port* port;
+
    SerialDeviceType devicetype;
    // move these two they only apply to the haptic device
    int motorsposition;
+    int numlights;
+    int numleds;
+    int startled;
+    int endled;
+    int baudrate;
    double ampfactor;
    double state;
    union
@@ -57,6 +72,7 @@ typedef struct
        SimWindData simwinddata;
        SimHapticData simhapticdata;
        ShiftLightsData shiftlightsdata;
+        WheelDevice wheeldevice;
    } u;
 }
 SerialDevice;
@@ -73,7 +89,8 @@ typedef enum
 {
    USBDEV_UNKNOWN       = 0,
    USBDEV_TACHOMETER    = 1,
-    USBDEV_GENERICHAPTIC = 2
+    USBDEV_GENERICHAPTIC = 2,
+    USBDEV_WHEEL         = 3
 }
 USBType;

@@ -81,10 +98,12 @@ typedef struct
 {
    SimDevice m;
    int id;
+    hid_device* handle;
    USBType type;
    union
    {
        TachDevice tachdevice;
+        WheelDevice wheeldevice;
        USBGenericHapticDevice hapticdevice;
    } u;
 }
@@ -101,15 +120,15 @@ typedef struct
 {
    SimDevice m;
    int id;
-    SoundType type;
    int configcheck;
+    SoundEffectModulationType modulationType;
    SoundData sounddata;
-#ifdef USE_PULSEAUDIO
+//#ifdef USE_PULSEAUDIO
    pa_stream *stream;
-#else
-    PaStreamParameters outputParameters;
-    PaStream* stream;
-#endif
+//#else
+    //PaStreamParameters outputParameters;
+    //PaStream* stream;
+//#endif
 }
 SoundDevice;

@@ -132,4 +151,16 @@ int devfree(SimDevice* simdevices, int numdevices);

 int simdevfree(SimDevice* this);

+
+/****** USB SubTypes ****************/
+int wheeldev_update(USBDevice* usbdevice, SimData* simdata);
+int wheeldev_init(USBDevice* usbdevice, DeviceSettings* ds);
+int wheeldev_free(USBDevice* usbdevice);
+
+int tachdev_update(USBDevice* tachdevice, SimData* simdata);
+int tachdev_init(USBDevice* tachdevice, DeviceSettings* ds);
+int tachdev_free(USBDevice* tachdevice);
+
+
+
 #endif
@@ -2,8 +2,6 @@

 #include "../slog/slog.h"

-#ifdef USE_PULSEAUDIO
-
 pa_threaded_mainloop* mainloop;
 pa_context* context;

@@ -43,37 +41,40 @@ int setupsound()
        pa_threaded_mainloop_wait(mainloop);
    }

+    pa_threaded_mainloop_unlock(mainloop);
    slogi("successfully connected pulseaudio...");
-    return 1;
+    return 0;
 }

-
 int freesound()
 {
+    if (mainloop) {
+        pa_threaded_mainloop_lock(mainloop);
+    }
+
    if (context)
+    {
        pa_context_unref(context);
+        slogt("freed pulseaudio context");
+    }

    if (mainloop) {
        pa_signal_done();
+        pa_threaded_mainloop_unlock(mainloop);
        pa_threaded_mainloop_free(mainloop);
    }

-}
-
-#else
-
-int setupsound()
-{
-
-
-
-    slogi("connecting portaudio...");
+    return 0;
 }


-int freesound()
-{
-
-}
-
-#endif
+//int setupsound()
+//{
+//    slogi("connecting portaudio...");
+//}
+//
+//
+//int freesound()
+//{
+//
+//}
@@ -3,11 +3,12 @@

 #include "../simdevice.h"

-#ifdef USE_PULSEAUDIO
-int usb_generic_shaker_init(SoundDevice* sounddevice, pa_threaded_mainloop* mainloop, pa_context* context, const char* devname, int volume, int pan, const char* streamname);
-#else
-int usb_generic_shaker_init(SoundDevice* sounddevice);
-#endif
-int usb_generic_shaker_free(SoundDevice* sounddevice);
+//#ifdef USE_PULSEAUDIO
+int usb_generic_shaker_init(SoundDevice* sounddevice, pa_threaded_mainloop* mainloop, pa_context* context, const char* devname, int volume, int pan, int channels, const char* streamname);
+int usb_generic_shaker_free(SoundDevice* sounddevice, pa_threaded_mainloop* mainloop);
+//#else
+//int usb_generic_shaker_init(SoundDevice* sounddevice);
+//int usb_generic_shaker_free(SoundDevice* sounddevice);
+//#endif

 #endif
@@ -1,25 +1,21 @@
-#ifdef USE_PULSEAUDIO
-
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
 #include <unistd.h>


-
 #include "usb_generic_shaker.h"
 #include "../sounddevice.h"

 #define FORMAT PA_SAMPLE_S16LE
-#define SAMPLE_RATE   (48000)
-#define AMPLITUDE .5
-#define DURATION 4.0
+#define SAMPLE_RATE   (44100)
+#define AMPLITUDE 1
+#define DURATION 1.0

 #ifndef M_PI
 #define M_PI  (3.14159265)
 #endif

-
 void gear_sound_stream(pa_stream *s, size_t length, void *userdata) {

    SoundData* data = (SoundData*)userdata;
@@ -32,7 +28,7 @@ void gear_sound_stream(pa_stream *s, size_t length, void *userdata) {
        double sample = 0;
        if (data->frequency>0)
        {
-            sample = AMPLITUDE * 32767.0 * sin(2.0 * M_PI * data->curr_frequency * data->curr_duration);
+            sample = ((double)data->curr_amplitude/100) * 32767.0 * sin(2.0 * M_PI * data->curr_frequency * data->curr_duration);
        }


@@ -47,27 +43,46 @@ void gear_sound_stream(pa_stream *s, size_t length, void *userdata) {
    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++) {
-        static double t = 0.0;
-        double sample = AMPLITUDE * 32767.0 * sin(2.0 * M_PI * data->curr_frequency * t);
+        double t = data->phase;

+        double sample = ((double)data->curr_amplitude/100) * 32767.0 * sin( 2.0 * M_PI * freq * t );

        buffer[i] = (int16_t)sample;

        t += 1.0 / SAMPLE_RATE;
-        if (t >= DURATION) {
-            t = 0.0;
+        if (t >= SAMPLE_RATE) {
+            t = 0;
        }
+        data->phase = t;
    }
+    data->phase = round(data->phase);
+
    pa_stream_write(s, buffer, length, NULL, 0LL, PA_SEEK_RELATIVE);
 }

+
+
 void stream_success_cb(pa_stream *stream, int success, void *userdata) {
    return;
 }
@@ -76,42 +91,69 @@ void stream_state_cb(pa_stream *s, void *mainloop) {
    pa_threaded_mainloop_signal(mainloop, 0);
 }

-int usb_generic_shaker_free(SoundDevice* sounddevice)
+
+int usb_generic_shaker_free(SoundDevice* sounddevice, pa_threaded_mainloop* mainloop)
 {
+    if(!mainloop)
+    {
+        // if this happens we are in trouble
+        return 1;
+    }
+
+    pa_threaded_mainloop_lock(mainloop);
+
    int err = 0;
-    //err = Pa_CloseStream( sounddevice->stream );
-    //if( err != paNoError )
-    //{
-    //    err = Pa_Terminate();
-    //}
    if (sounddevice->stream)
    {
+        pa_stream_disconnect(sounddevice->stream);
        pa_stream_unref(sounddevice->stream);
-        pa_xfree(sounddevice->stream);
+        // why is this wrong
+
+
    }
+
+    pa_threaded_mainloop_unlock(mainloop);
+
    return err;
 }

-int usb_generic_shaker_init(SoundDevice* sounddevice, pa_threaded_mainloop* mainloop, pa_context* context, const char* devname, int volume, int pan, const char* streamname)
+int usb_generic_shaker_init(SoundDevice* sounddevice, pa_threaded_mainloop* mainloop, pa_context* context, const char* devname, int volume, int pan, int channels, const char* streamname)
 {
+    pa_threaded_mainloop_lock(mainloop);
    pa_stream *stream;

    // Create a playback stream
    pa_sample_spec sample_specifications;
    sample_specifications.format = FORMAT;
    sample_specifications.rate = SAMPLE_RATE;
-    sample_specifications.channels = 2;
+    sample_specifications.channels = channels;


    pa_channel_map channel_map;
-    pa_channel_map_init_stereo(&channel_map);
-    pa_channel_map_parse(&channel_map, "front-left,front-right");
+    pa_channel_map_init_auto(&channel_map, channels, PA_CHANNEL_MAP_DEFAULT);
+    //pa_channel_map_init_stereo(&channel_map);

+    // not sure about what to do here
+    if(channels == 2)
+    {
+        pa_channel_map_parse(&channel_map, "front-left,front-right");
+    }
+    if(channels == 4)
+    {
+        pa_channel_map_parse(&channel_map, "front-left,front-right,rear-left,rear-right");
+    }
+    if(channels == 6)
+    {
+        pa_channel_map_parse(&channel_map, "front-left,front-right,front-center,lfe,rear-left,rear-right");
+    }
+    if(channels == 8)
+    {
+        pa_channel_map_parse(&channel_map, "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right");
+    }

    stream = pa_stream_new(context, streamname, &sample_specifications, &channel_map);
    pa_stream_set_state_callback(stream, stream_state_cb, mainloop);

-
    if (sounddevice->m.hapticeffect.effecttype == EFFECT_GEARSHIFT)
    {
        pa_stream_set_write_callback(stream, gear_sound_stream, &sounddevice->sounddata);
@@ -129,35 +171,36 @@ int usb_generic_shaker_init(SoundDevice* sounddevice, pa_threaded_mainloop* main
    buffer_attr.minreq = (uint32_t) -1;

    pa_cvolume cv;
-    uint16_t pvolume =  ceil(((double) volume/100.0d)*65535);
-    // Settings copied as per the chromium browser source
+    pa_cvolume_mute(&cv, channels);
+
+    pa_volume_t channel_volume = PA_CLAMP_VOLUME((pa_volume_t)((volume/100.d)*PA_VOLUME_NORM));

    pa_stream_flags_t stream_flags;
    stream_flags = PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_NOT_MONOTONIC | PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_ADJUST_LATENCY | PA_STREAM_START_CORKED;

-    // Connect stream to the default audio output sink
-    pa_cvolume_set(&cv, sample_specifications.channels, pvolume);

-    pa_cvolume_set_balance(&cv, &channel_map, pan);
+    // 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);

    // Wait for the stream to be ready
-    for(;;) {
+    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);
        if (stream_state == PA_STREAM_READY) break;
        pa_threaded_mainloop_wait(mainloop);
    }


-    //pa_threaded_mainloop_unlock(mainloop);

    // Uncork the stream so it will start playing
    pa_stream_cork(stream, 0, stream_success_cb, mainloop);

    sounddevice->stream = stream;
+    pa_threaded_mainloop_unlock(mainloop);
    return 0;
 }
-
-#endif
@@ -4,6 +4,7 @@

 #include <stdio.h>
 #include <unistd.h>
+#include <math.h>

 #include "sound.h"
 #include "simdevice.h"
@@ -20,11 +21,40 @@ int gear_sound_set(SoundDevice* sounddevice, SimData* simdata)
    {
        //sounddevice->sounddata.gear_sound_data = 3.14;
        sounddevice->sounddata.curr_frequency = sounddevice->sounddata.frequency;
+        sounddevice->sounddata.curr_amplitude = sounddevice->sounddata.amplitude;
        sounddevice->sounddata.curr_duration = 0;
    }
    sounddevice->sounddata.last_gear = simdata->gear;

-    slogt("set gear frequency to %i", sounddevice->sounddata.frequency);
+    slogt("set gear frequency to %i", sounddevice->sounddata.curr_frequency);
+}
+
+
+double modulate(SoundDevice* sounddevice, double raw_effect, SoundEffectModulationType modulation)
+{
+    double modulated_effect = raw_effect;
+    switch (modulation)
+    {
+        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_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);
+            break;
+        case SOUND_EFFECT_MODULATION_AMPLIFY:
+            modulated_effect = ((sounddevice->sounddata.amplitudeMax - sounddevice->sounddata.amplitude) * raw_effect) + sounddevice->sounddata.amplitude;
+            sounddevice->sounddata.curr_amplitude = modulated_effect;
+            sounddevice->sounddata.curr_frequency = sounddevice->sounddata.frequency;
+            slogt("set curr amplitude to %i from raw effect %f and base amplitude %i", sounddevice->sounddata.curr_amplitude, raw_effect, sounddevice->sounddata.amplitude);
+            break;
+        case SOUND_EFFECT_MODULATION_NONE:
+        default:
+            sounddevice->sounddata.curr_frequency = sounddevice->sounddata.frequency;
+            sounddevice->sounddata.curr_amplitude = sounddevice->sounddata.amplitude;
+            break;
+    }
+
+    return modulated_effect;
 }

 // we could make a vtable for these different effects too
@@ -32,44 +62,46 @@ int sounddev_engine_update(SimDevice* this, SimData* simdata)
 {
    SoundDevice* sounddevice = (void *) this->derived;

-    sounddevice->sounddata.curr_frequency = simdata->rpms/60;
-    //sounddevice->sounddata.table_size = 48000/(sounddevice->sounddata.frequency);
-
-    slogt("set engine frequency to %i", sounddevice->sounddata.frequency);
+    double effect = ((double)simdata->rpms/60)/((double)simdata->maxrpm/60);
+    slogt("Set base effect of %f from rpms of %i", effect, simdata->rpms);
+    modulate(sounddevice, effect, sounddevice->modulationType);
 }

 int sounddev_tyreslip_update(SimDevice* this, SimData* simdata)
 {
    SoundDevice* sounddevice = (void *) this->derived;

-    int play = slipeffect(simdata, this->hapticeffect.effecttype, this->hapticeffect.tyre, this->hapticeffect.threshold, this->hapticeffect.useconfig, this->hapticeffect.configcheck, this->hapticeffect.tyrediameterconfig);
+    double effect = slipeffect(simdata, this->hapticeffect.effecttype, this->hapticeffect.tyre, this->hapticeffect.threshold, this->hapticeffect.useconfig, this->hapticeffect.configcheck, this->hapticeffect.tyrediameterconfig);
+    slogt("Updating sound device frequency from original tyre slip effect %f", effect);

-    if (play > 0)
+    if (effect > 0)
    {
-        sounddevice->sounddata.curr_frequency = sounddevice->sounddata.frequency * play;
-        sounddevice->sounddata.curr_duration = sounddevice->sounddata.duration;
+        modulate(sounddevice, effect, sounddevice->modulationType);
    }
    else
    {
        sounddevice->sounddata.curr_frequency = 0;
+        sounddevice->sounddata.curr_amplitude = 0;
        sounddevice->sounddata.curr_duration = 0;
    }
+
 }

 int sounddev_tyrelock_update(SimDevice* this, SimData* simdata)
 {
    SoundDevice* sounddevice = (void *) this->derived;

-    int play = slipeffect(simdata, this->hapticeffect.effecttype, this->hapticeffect.tyre, this->hapticeffect.threshold, this->hapticeffect.useconfig, this->hapticeffect.configcheck, this->hapticeffect.tyrediameterconfig);
+    double play = slipeffect(simdata, this->hapticeffect.effecttype, this->hapticeffect.tyre, this->hapticeffect.threshold, this->hapticeffect.useconfig, this->hapticeffect.configcheck, this->hapticeffect.tyrediameterconfig);
+    slogt("Updating sound device frequency from original tyre lock effect %f", play);

    if (play > 0)
    {
-        sounddevice->sounddata.curr_frequency = sounddevice->sounddata.frequency * play;
-        sounddevice->sounddata.curr_duration = sounddevice->sounddata.duration;
+        modulate(sounddevice, play, sounddevice->modulationType);
    }
    else
    {
        sounddevice->sounddata.curr_frequency = 0;
+        sounddevice->sounddata.curr_amplitude = 0;
        sounddevice->sounddata.curr_duration = 0;
    }
 }
@@ -77,19 +109,42 @@ int sounddev_tyrelock_update(SimDevice* this, SimData* simdata)
 int sounddev_absbrakes_update(SimDevice* this, SimData* simdata)
 {
    SoundDevice* sounddevice = (void *) this->derived;
+    double play = slipeffect(simdata, this->hapticeffect.effecttype, this->hapticeffect.tyre, this->hapticeffect.threshold, this->hapticeffect.useconfig, this->hapticeffect.configcheck, this->hapticeffect.tyrediameterconfig);
+    slogt("Updating sound device frequency from original abs effect %f", play);

-    if (simdata->abs > 0)
+    if (play > 0)
    {
-        sounddevice->sounddata.curr_frequency = sounddevice->sounddata.frequency;
-        sounddevice->sounddata.curr_duration = sounddevice->sounddata.duration;
+        modulate(sounddevice, play, sounddevice->modulationType);
    }
    else
    {
        sounddevice->sounddata.curr_frequency = 0;
+        sounddevice->sounddata.curr_amplitude = 0;
        sounddevice->sounddata.curr_duration = 0;
    }
 }

+int sounddev_suspension_update(SimDevice* this, SimData* simdata)
+{
+    SoundDevice* sounddevice = (void *) this->derived;
+
+    double effect = slipeffect(simdata, this->hapticeffect.effecttype, this->hapticeffect.tyre, this->hapticeffect.threshold, this->hapticeffect.useconfig, this->hapticeffect.configcheck, this->hapticeffect.tyrediameterconfig);
+    effect = effect * 10;
+    slogt("Updating sound device output from original suspension travel effect %f", effect);
+
+    if (effect > 0)
+    {
+        effect = modulate(sounddevice, effect, sounddevice->modulationType);
+    }
+    else
+    {
+        sounddevice->sounddata.curr_frequency = 0;
+        sounddevice->sounddata.curr_amplitude = 0;
+        sounddevice->sounddata.curr_duration = 0;
+    }
+
+}
+
 int sounddev_gearshift_update(SimDevice* this, SimData* simdata)
 {
    SoundDevice* sounddevice = (void *) this->derived;
@@ -97,78 +152,74 @@ int sounddev_gearshift_update(SimDevice* this, SimData* simdata)
    gear_sound_set(sounddevice, simdata);
 }

+
 int sounddev_free(SimDevice* this)
 {
    SoundDevice* sounddevice = (void *) this->derived;

-    //figure out why this is causing problems
-    //usb_generic_shaker_free(sounddevice);
-
+    usb_generic_shaker_free(sounddevice, mainloop);
    free(sounddevice);

    return 0;
 }

-int sounddev_init(SoundDevice* sounddevice, const char* devname, int volume, int frequency, int pan, double duration, double threshold)
+int sounddev_init(SoundDevice* sounddevice, const char* devname, MonocoqueTyreIdentifier tyre, SoundDeviceSettings sds)
 {
    slogi("initializing standalone sound device...");


-    slogi("volume is: %i", volume);
-    slogi("frequency is: %i", frequency);
-    slogi("pan is: %i", pan);
-    slogi("duration is: %f", duration);
+    slogi("volume is: %i", sds.volume);
+    slogi("Modulation type: %i", sds.modulation);
+    slogi("frequency is: %i", sds.frequency);
+    slogi("frequency Max is: %i", sds.frequencyMax);
+    slogi("amplitude is: %i", sds.amplitude);
+    slogi("amplitude Max is: %i", sds.amplitudeMax);
+    slogi("pan is: %i", sds.pan);
+    slogi("channels is: %i", sds.channels);
+    slogi("duration is: %f", sds.duration);


-    sounddevice->sounddata.frequency = frequency;
-    //sounddevice->sounddata.pitch = 1;
-    //sounddevice->sounddata.pitch = 261.626;
-    //sounddevice->sounddata.amp = 32;
-    //sounddevice->sounddata.left_phase = sounddevice->sounddata.right_phase = 0;
-    //sounddevice->sounddata.table_size = 48000/(100/60);
-    sounddevice->sounddata.curr_frequency = 100/60;
+    sounddevice->modulationType = sds.modulation;
+    sounddevice->sounddata.frequency = sds.frequency;
+    sounddevice->sounddata.frequencyMax = sds.frequencyMax;
+    sounddevice->sounddata.amplitude = sds.amplitude;
+    sounddevice->sounddata.amplitudeMax = sds.amplitudeMax;
+    sounddevice->sounddata.curr_duration = 0;

+    sounddevice->sounddata.phase = 0;
+
+    sounddevice->sounddata.curr_amplitude = 0;
+    sounddevice->sounddata.curr_frequency = 0;


    const char* streamname= "Engine";
    switch (sounddevice->m.hapticeffect.effecttype) {
        case (EFFECT_GEARSHIFT):
-
            sounddevice->sounddata.last_gear = 0;
-            //sounddevice->sounddata.pitch = 500;
-            //sounddevice->sounddata.amp = 128;
-            //sounddevice->sounddata.left_phase = sounddevice->sounddata.right_phase = 0;
-            //sounddevice->sounddata.table_size = 48000/(1);
-            sounddevice->sounddata.duration = duration;
-            sounddevice->sounddata.curr_duration = duration;
+            sounddevice->sounddata.duration = sds.duration;
            streamname = "Gear";
            break;
        case (EFFECT_TYRESLIP):
-            sounddevice->sounddata.duration = duration;
-            sounddevice->sounddata.curr_duration = duration;
            streamname = "TyreSlip";
            break;
        case (EFFECT_TYRELOCK):
-            sounddevice->sounddata.duration = duration;
-            sounddevice->sounddata.curr_duration = duration;
            streamname = "TyreLock";
            break;
        case (EFFECT_ABSBRAKES):
-            sounddevice->sounddata.duration = duration;
-            sounddevice->sounddata.curr_duration = duration;
            streamname = "ABS";
            break;
+        case (EFFECT_SUSPENSION):
+            streamname = "Suspension";
+            break;
+        case (EFFECT_ENGINERPM):
+        default:
+            streamname = "Engine";
+            break;
    }

-#ifdef USE_PULSEAUDIO

-
-    //pa_threaded_mainloop* mainloop;
-    //pa_context* context;
-    usb_generic_shaker_init(sounddevice, mainloop, context, devname, volume, pan, streamname);
-#else
-    usb_generic_shaker_init(sounddevice);
-#endif
+    usb_generic_shaker_init(sounddevice, mainloop, context, devname, sds.volume, sds.pan, sds.channels, streamname);
+    //usb_generic_shaker_init(sounddevice);
 }

 static const vtable engine_sound_simdevice_vtable = { &sounddev_engine_update, &sounddev_free };
@@ -176,6 +227,7 @@ static const vtable gear_sound_simdevice_vtable = { &sounddev_gearshift_update,
 static const vtable tyreslip_sound_simdevice_vtable = { &sounddev_tyreslip_update, &sounddev_free };
 static const vtable tyrelock_sound_simdevice_vtable = { &sounddev_tyrelock_update, &sounddev_free };
 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) {

@@ -200,26 +252,65 @@ SoundDevice* new_sound_device(DeviceSettings* ds, MonocoqueSettings* ms) {
        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;
    }

-    slogt("Attempting to use device %s", ds->sounddevsettings.dev);
+    slogt("Attempting to use sound device %s", ds->sounddevsettings.dev);

-    int error = sounddev_init(this, ds->sounddevsettings.dev, ds->sounddevsettings.volume, ds->sounddevsettings.frequency, ds->sounddevsettings.pan, ds->sounddevsettings.duration, ds->threshold);
+    int error = sounddev_init(this, ds->sounddevsettings.dev, ds->tyre, ds->sounddevsettings);
    if (error != 0)
    {
        free(this);
@@ -228,4 +319,3 @@ SoundDevice* new_sound_device(DeviceSettings* ds, MonocoqueSettings* ms) {

    return this;
 }
-
@@ -1,28 +1,35 @@
 #ifndef _SOUNDDEVICE_H
 #define _SOUNDDEVICE_H

-#ifdef USE_PULSEAUDIO
+//#ifdef USE_PULSEAUDIO
 #include <pulse/pulseaudio.h>
-#else
-#include "portaudio.h"
-#endif
+//#else
+//#include "portaudio.h"
+//#endif
+

 typedef enum
 {
-    SOUNDDEV_UNKNOWN       = 0,
-    SOUNDDEV_SHAKER        = 1
+    SOUND_EFFECT_MODULATION_NONE            = 0,
+    SOUND_EFFECT_MODULATION_FREQUENCY       = 1,
+    SOUND_EFFECT_MODULATION_AMPLIFY         = 2,
 }
-SoundType;
+SoundEffectModulationType;

 #define MAX_TABLE_SIZE   (6000)
 typedef struct
 {
-    int last_gear;
+    uint8_t last_gear;
    int volume;
-    int frequency;
+    uint32_t frequency;
+    uint32_t frequencyMax;
+    uint32_t amplitude;
+    uint32_t amplitudeMax;
    double duration;
-    int curr_frequency;
+    uint32_t curr_frequency;
+    uint32_t curr_amplitude;
    double curr_duration;
+    double phase;
 }
 SoundData;

@@ -2,14 +2,16 @@
 #include <stdlib.h>
 #include <string.h>

-#include "tachdevice.h"
-#include "revburner.h"
-#include "../../helper/confighelper.h"
-#include "../../simulatorapi/simapi/simapi/simdata.h"
-#include "../../slog/slog.h"
+//#include "tachdevice.h"
+#include "simdevice.h"
+#include "usb/revburner.h"
+#include "../helper/confighelper.h"
+#include "../simulatorapi/simapi/simapi/simdata.h"
+#include "../slog/slog.h"

-int tachdev_update(TachDevice* tachdevice, SimData* simdata)
+int tachdev_update(USBDevice* usbdevice, SimData* simdata)
 {
+    TachDevice* tachdevice = &usbdevice->u.tachdevice;
    // current plan is to just use the revburner xml format for other possible tachometer devices
    // with that assumption this same logic is assumed the same for other tachometer devices
    // the only difference then being in communication to the physical device
@@ -43,30 +45,33 @@ int tachdev_update(TachDevice* tachdevice, SimData* simdata)
                }
            }
            slogt("Settings tachometer pulses to %i", pulses);
-            revburner_update(tachdevice, pulses);
+            revburner_update(usbdevice, pulses);
            break;
    }

    return 0;
 }

-int tachdev_free(TachDevice* tachdevice)
+int tachdev_free(USBDevice* usbdevice)
 {
+    TachDevice* tachdevice = &usbdevice->u.tachdevice;
    switch ( tachdevice->type )
    {
        case TACHDEV_UNKNOWN :
        case TACHDEV_REVBURNER :
-            revburner_update(tachdevice, 0);
-            revburner_free(tachdevice);
+            revburner_update(usbdevice, 0);
+            revburner_free(usbdevice);
            break;
    }

    return 0;
 }

-int tachdev_init(TachDevice* tachdevice, DeviceSettings* ds)
+int tachdev_init(USBDevice* usbdevice, DeviceSettings* ds)
 {
    slogi("initializing tachometer device...");
+
+    TachDevice* tachdevice = &usbdevice->u.tachdevice;
    int error = 0;
    // detection of tach device model
    tachdevice->type = TACHDEV_UNKNOWN;
@@ -74,7 +79,7 @@ int tachdev_init(TachDevice* tachdevice, DeviceSettings* ds)

    tachdevice->tachsettings = ds->tachsettings;

-    error = revburner_init(tachdevice);
+    error = revburner_init(usbdevice);

    return error;
 }
@@ -1,7 +1,7 @@
 #ifndef _TACHDEVICE_H
 #define _TACHDEVICE_H

-#include <hidapi/hidapi.h>
+
 #include "../helper/confighelper.h"
 #include "../simulatorapi/simapi/simapi/simdata.h"

@@ -19,13 +19,10 @@ typedef struct
    int id;
    TachType type;
    bool use_pulses;
-    hid_device* handle;
    TachometerSettings tachsettings;
 }
 TachDevice;

-int tachdev_update(TachDevice* tachdevice, SimData* simdata);
-int tachdev_init(TachDevice* tachdevice, DeviceSettings* ds);
-int tachdev_free(TachDevice* tachdevice);
+

 #endif
@@ -8,7 +8,7 @@
 #include "../../helper/confighelper.h"
 #include "../slog/slog.h"

-const char* SYSFSRUMBLEPATH = "/sys/module/hid_fanatec/drivers/hid:ftec_csl_elite/0003:0EB7:183B.*/rumble";
+const char* SYSFSRUMBLEPATH = "/sys/module/hid_fanatec/drivers/hid:f*/0003:0EB7:183B.*/rumble";


 int cslelitev3_update(USBGenericHapticDevice* usbhapticdevice, int effecttype, int play)
@@ -34,8 +34,8 @@ int cslelitev3_update(USBGenericHapticDevice* usbhapticdevice, int effecttype, i
    }


-    fprintf(usbhapticdevice->handle, "%i\n", value);
-    fflush(usbhapticdevice->handle);
+    fprintf(usbhapticdevice->filehandle, "%i\n", value);
+    fflush(usbhapticdevice->filehandle);

    return res;
 }
@@ -46,8 +46,8 @@ int cslelitev3_free(USBGenericHapticDevice* usbhapticdevice)

    free(usbhapticdevice->dev);

-    fflush(usbhapticdevice->handle);
-    fclose(usbhapticdevice->handle);
+    fflush(usbhapticdevice->filehandle);
+    fclose(usbhapticdevice->filehandle);

    return res;
 }
@@ -91,9 +91,9 @@ int cslelitev3_init(USBGenericHapticDevice* usbhapticdevice)
        return res;
    }

-    usbhapticdevice->handle = fopen(usbhapticdevice->dev, "w");
+    usbhapticdevice->filehandle = fopen(usbhapticdevice->dev, "w");

-    if (!usbhapticdevice->handle)
+    if (!usbhapticdevice->filehandle)
    {
        sloge("Could not open pedal device...");
        return res;
@@ -2,19 +2,19 @@

 #include <hidapi/hidapi.h>

-#include "tachdevice.h"
-#include "../slog/slog.h"
+#include "../simdevice.h"
+#include "../../slog/slog.h"

-const int buf_size = 65;
+const size_t REVBURNER_BUFSIZE = 8;


-int revburner_update(TachDevice* tachdevice, int pulses)
+int revburner_update(USBDevice* tachdevice, int pulses)
 {

    int res = 0;

-    unsigned char bytes[buf_size];
-    for (int x = 0; x < buf_size; x++)
+    unsigned char bytes[REVBURNER_BUFSIZE];
+    for (int x = 0; x < REVBURNER_BUFSIZE; x++)
    {
        bytes[x] = 0x00;
    }
@@ -27,7 +27,7 @@ int revburner_update(TachDevice* tachdevice, int pulses)

    if (tachdevice->handle)
    {
-        res = hid_write(tachdevice->handle, bytes, buf_size);
+        res = hid_write(tachdevice->handle, bytes, REVBURNER_BUFSIZE);
    }
    else
    {
@@ -37,7 +37,7 @@ int revburner_update(TachDevice* tachdevice, int pulses)
    return res;
 }

-int revburner_free(TachDevice* tachdevice)
+int revburner_free(USBDevice* tachdevice)
 {
    int res = 0;

@@ -47,7 +47,7 @@ int revburner_free(TachDevice* tachdevice)
    return res;
 }

-int revburner_init(TachDevice* tachdevice)
+int revburner_init(USBDevice* tachdevice)
 {
    slogi("initializing revburner tachometer...");
    //tachdevice->update_tachometer = revburner_device_update;
@@ -64,6 +64,6 @@ int revburner_init(TachDevice* tachdevice)
        res = hid_exit();
        return 1;
    }
-    slogd("Found RevBurner Tachometer...");
+    slogd("Found RevBurner Tachometer handle %i...", tachdevice->handle);
    return res;
 }
@@ -1,8 +1,10 @@
 #ifndef _REVBURNER_H
 #define _REVBURNER_H

-int revburner_update(TachDevice* tachdevice, int pulses);
-int revburner_init(TachDevice* tachdevice);
-int revburner_free(TachDevice* tachdevice);
+#include "../simdevice.h"
+
+int revburner_update(USBDevice* tachdevice, int pulses);
+int revburner_init(USBDevice* tachdevice);
+int revburner_free(USBDevice* tachdevice);

 #endif
@@ -0,0 +1,136 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <hidapi/hidapi.h>
+
+#include "usbhapticdevice.h"
+
+#include "../../helper/confighelper.h"
+#include "../slog/slog.h"
+
+#define SIMAGIC_VENDOR_ID          0x0483
+#define SIMAGIC_PRODUCT_ID_P1000   0x0525
+
+const size_t SIMAGIC_P1000_BUFSIZE = 49;
+const char* SIMAGICP1000DEVSTRING = "SIMAGIC P1000 Pedals";
+
+int senddevreport(USBGenericHapticDevice* usbhapticdevice, unsigned char* buf, size_t bufsize)
+{
+    int res = 0;
+    if (usbhapticdevice->handle)
+    {
+        res = hid_send_feature_report(usbhapticdevice->handle, buf, SIMAGIC_P1000_BUFSIZE);
+        slogd("sent %i bytes to %s", bufsize, SIMAGICP1000DEVSTRING);
+        slogt("sent bytes %02x %02x %02x %02x %02x %02x %02x", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
+    }
+    else
+    {
+        slogd("no handle");
+    }
+    return res != bufsize;
+}
+
+int simagicp1000_update(USBGenericHapticDevice* usbhapticdevice, int effecttype, int play)
+{
+
+    int res = 0;
+    int value = 0;
+
+    unsigned char bytes[SIMAGIC_P1000_BUFSIZE];
+    for (int x = 0; x < SIMAGIC_P1000_BUFSIZE; x++)
+    {
+        bytes[x] = 0x00;
+    }
+
+    if (play > 0)
+    {
+        bytes[0] = 241;
+        bytes[1] = 0xEC;
+        // we can add config settings for these values
+        bytes[3] = 0x01;
+        bytes[4] = 0x0A;
+        bytes[5] = 0xFF;
+        switch (effecttype)
+        {
+            case (EFFECT_TYRESLIP):
+                bytes[2] = 0x02;
+                senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
+                break;
+            case (EFFECT_TYRELOCK):
+                bytes[2] = 0x01;
+                senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
+                break;
+            case (EFFECT_ABSBRAKES):
+                bytes[2] = 0x02;
+                senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
+                bytes[2] = 0x01;
+                senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
+                break;
+        }
+    }
+    else
+    {
+        bytes[0] = 241;
+        bytes[2] = 0x01;
+        senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
+        bytes[2] = 0x02;
+        senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
+    }
+
+    return res;
+}
+
+int simagicp1000_free(USBGenericHapticDevice* usbhapticdevice)
+{
+    int res = 0;
+
+    hid_close(usbhapticdevice->handle);
+    res = hid_exit();
+
+    return res;
+
+    return res;
+}
+
+int simagicp1000_init(USBGenericHapticDevice* usbhapticdevice)
+{
+    slogi("initializing %s...", SIMAGICP1000DEVSTRING);
+
+    int res = 0;
+
+    res = hid_init();
+
+    usbhapticdevice->handle = hid_open(SIMAGIC_VENDOR_ID, SIMAGIC_PRODUCT_ID_P1000, NULL);
+
+    if (!usbhapticdevice->handle)
+    {
+        sloge("Could not find attached %s", SIMAGICP1000DEVSTRING);
+        res = hid_exit();
+        return 1;
+    }
+    else
+    {
+        unsigned char bytes[SIMAGIC_P1000_BUFSIZE];
+        for (int x = 0; x < SIMAGIC_P1000_BUFSIZE; x++)
+        {
+            bytes[x] = 0x00;
+        }
+        bytes[0] = 241;
+        bytes[1] = 0xF1;
+        bytes[2] = 0x17;
+        bytes[3] = 0x00;
+        bytes[4] = 0x00;
+        bytes[5] = 0x00;
+        bytes[6] = 0x01;
+        bytes[7] = 0x02;
+        res = senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
+        slogd("Initialization returned %i", res);
+        if(res != 0)
+        {
+            slogw("Problem with initialization of %s", SIMAGICP1000DEVSTRING);
+        }
+    }
+
+    slogd("Found %s...", SIMAGICP1000DEVSTRING);
+    return res;
+}
@@ -0,0 +1,8 @@
+#ifndef _SIMAGICP1000_H
+#define _SIMAGICP1000_H
+
+int simagicp1000_update(USBGenericHapticDevice* usbhapticdevice, int effecttype, int play);
+int simagicp1000_init(USBGenericHapticDevice* usbhapticdevice);
+int simagicp1000_free(USBGenericHapticDevice* usbhapticdevice);
+
+#endif
@@ -0,0 +1,231 @@
+#include <stdio.h>
+#include <math.h>
+
+#include <hidapi/hidapi.h>
+
+#include "cammusc12.h"
+#include "../../serial/arduinoledlua.h"
+#include "../../../slog/slog.h"
+
+const int cammusc12_hidupdate_buf_size = 16;
+const int cammusc12_hidledupdate_buf_size = 7;
+
+const int cammusc12_total_leds = 23;
+
+int cammusc12_update(USBDevice* usbdevice, int maxrpm, int rpm, int gear, int velocity)
+{
+
+    int res = 0;
+
+    unsigned char bytes[cammusc12_hidupdate_buf_size];
+
+    for (int x = 0; x < cammusc12_hidupdate_buf_size; x++)
+    {
+        bytes[x] = 0x00;
+    }
+    // byte 1 must be fc it seems
+    bytes[0] = 0xFA;
+    bytes[1] = 0xFB;
+    bytes[2] = 0xD4;
+
+    int perct = 0;
+    if(rpm > 0 && maxrpm > 0)
+    {
+        double rpmperct = (double) rpm / (double) maxrpm;
+        perct = trunc(nearbyint( rpmperct * 100 ));
+    }
+    bytes[3] = perct;
+
+    // bytes 2 and 3 are a 16 bit velocity
+    if ( velocity > 0 )
+    {
+        bytes[5] = (velocity >> 8) & 0xFF;
+        bytes[4] = velocity & 0xFF;
+    }
+
+    // byte 4 is gear
+    bytes[6] = gear-1;
+
+
+    if (usbdevice->handle)
+    {
+        slogt("writing bytes x%02xx%02xx%02xx%02xx%02xx%02xx%02x from rpm %i velocity %i gear %i", bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], rpm, velocity, gear);
+        res = hid_write(usbdevice->handle, bytes, cammusc12_hidupdate_buf_size);
+    }
+    else
+    {
+        slogd("no handle");
+    }
+
+    return res;
+}
+
+int cammusc12_free(USBDevice* wheeldevice)
+{
+    int res = 0;
+
+    hid_close(wheeldevice->handle);
+    res = hid_exit();
+
+    if(wheeldevice->u.wheeldevice.useLua == true)
+    {
+        slogt("closing lua");
+        lua_close(wheeldevice->m.L);
+    }
+
+    return res;
+}
+
+int cammusc12_init_(USBDevice* wheeldevice)
+{
+    slogi("initializing cammus c12 wheel...");
+
+    int res = 0;
+
+    res = hid_init();
+
+    wheeldevice->handle = hid_open(0x3416, 0x1023, NULL);
+
+    if (!wheeldevice->handle)
+    {
+        sloge("Could not find attached Cammus C12 Wheel");
+        res = hid_exit();
+        return 1;
+    }
+    slogd("Found Cammus C12 Wheel...");
+    return res;
+}
+
+int cammusc12_init(USBDevice* wheeldevice, const char* luafile)
+{
+
+    wheeldevice->u.wheeldevice.useLua = false;
+    int res = cammusc12_init_(wheeldevice);
+
+    if(!wheeldevice->handle)
+    {
+        return 1;
+    }
+
+    if(luafile == NULL)
+    {
+        return res;
+    }
+    slogt("Using lua file for cammus c12 device");
+
+    lua_State* L = luaL_newstate();
+    luaL_openlibs(L);
+
+    //int top=lua_gettop(L);
+    int status = luaL_loadfile(L, luafile);
+
+    if (status) {
+        /* If something went wrong, error message is at the top of */
+        /* the stack */
+        sloge("There is an issue with your lua script");
+        fprintf(stderr, "Couldn't load file: %s\n", lua_tostring(L, -1));
+        lua_close(L);
+        return -1;
+        //exit(1);
+    }
+
+    wheeldevice->u.wheeldevice.useLua = true;
+    lua_setglobal(L,"myFunc");
+
+    wheeldevice->m.L = L;
+
+    return res;
+}
+
+
+int cammusc12_customled_update(USBDevice* usbdevice, SimData* simdata)
+{
+    int result = 1;
+
+
+    size_t bufsize = (cammusc12_total_leds * 3);
+    char ledbytes[bufsize];
+    for(int x = 0; x < bufsize; x++)
+    {
+        ledbytes[x] = 0x00;
+    }
+
+    lua_State* L = usbdevice->m.L;
+
+    lua_pushstring(L, "buff");
+    lua_pushlightuserdata(L, &ledbytes);
+    lua_settable(L, LUA_REGISTRYINDEX);
+
+    simdata_to_lua(L, simdata);
+    lua_setglobal(L, "simdata");
+
+    lua_pushinteger(L, cammusc12_total_leds);
+    lua_setglobal(L, "TotalLeds");
+
+    lua_register(L, "set_led_to_color", set_led_to_color);
+    lua_register(L, "set_led_range_to_color", set_led_range_to_color);
+    lua_register(L, "set_led_to_rgb_color", set_led_to_rgb_color);
+    lua_register(L, "set_led_range_to_rgb_color", set_led_range_to_rgb_color);
+    lua_register(L, "led_clear_all", led_clear_all);
+
+    lua_pushinteger(L, LUALEDCOLOR_RED);
+    lua_setglobal(L, "RED");
+    lua_pushinteger(L, LUALEDCOLOR_GREEN);
+    lua_setglobal(L, "GREEN");
+    lua_pushinteger(L, LUALEDCOLOR_BLUE);
+    lua_setglobal(L, "BLUE");
+    lua_pushinteger(L, LUALEDCOLOR_YELLOW);
+    lua_setglobal(L, "YELLOW");
+    lua_pushinteger(L, LUALEDCOLOR_ORANGE);
+    lua_setglobal(L, "ORANGE");
+
+    lua_getglobal(L,"myFunc");
+    if (lua_pcall(L, 0, 0, 0) != LUA_OK)
+    {
+        fprintf(stderr, "Error calling Lua script: %s\n", lua_tostring(L, -1));
+    }
+
+    int res = 0;
+
+    unsigned char bytes[cammusc12_hidledupdate_buf_size];
+    for(int x = 0; x < cammusc12_hidledupdate_buf_size; x++)
+    {
+        bytes[x] = 0x00;
+    }
+    bytes[0] = 0xFA;
+    bytes[1] = 0xFB;
+    bytes[2] = 0x02;
+
+    for(int i = 0; i < cammusc12_total_leds; i++)
+    {
+        if(i >= 15) // make this a setting
+        {
+            for (int x = 3; x < cammusc12_hidledupdate_buf_size; x++)
+            {
+                bytes[x] = 0x00;
+            }
+            uint8_t led = i+1;
+            uint8_t red = ledbytes[(i * 3) + 0];
+            uint8_t green = ledbytes[(i * 3) + 1];
+            uint8_t blue = ledbytes[(i * 3) + 2];
+
+            bytes[3] = led;
+            bytes[4] = red;
+            bytes[5] = green;
+            bytes[6] = blue;
+
+
+            if (usbdevice->handle)
+            {
+                res = hid_write(usbdevice->handle, bytes, cammusc12_hidupdate_buf_size);
+                slogt("writing bytes x%02xx%02xx%02xx%02xx%02xx%02xx%02x from red %i green %i blue %i", bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], red, green, blue);
+            }
+            else
+            {
+                slogd("no handle");
+            }
+        }
+    }
+
+    return res;
+}
@@ -0,0 +1,13 @@
+#ifndef _CAMMUSC12_H
+#define _CAMMUSC12_H
+
+#include "../../wheeldevice.h"
+
+#include "../../simdevice.h"
+
+int cammusc12_update(USBDevice* wheeldevice, int maxrpm, int rpm, int gear, int velocity);
+int cammusc12_customled_update(USBDevice* usbdevice, SimData* simdata);
+int cammusc12_init(USBDevice* wheeldevice, const char* luafile);
+int cammusc12_free(USBDevice* wheeldevice);
+
+#endif
@@ -0,0 +1,99 @@
+#include <stdio.h>
+#include <math.h>
+
+#include <hidapi/hidapi.h>
+
+#include "cammusc5.h"
+#include "../../../slog/slog.h"
+
+const int cammusc5_hidupdate_buf_size = 14;
+const int num_avail_leds = 9;
+
+int cammusc5_update(USBDevice* usbdevice, int maxrpm, int rpm, int gear, int velocity)
+{
+
+    int res = 0;
+
+    unsigned char bytes[cammusc5_hidupdate_buf_size];
+
+    for (int x = 0; x < cammusc5_hidupdate_buf_size; x++)
+    {
+        bytes[x] = 0x00;
+    }
+    // byte 1 must be fc it seems
+    bytes[0] = 0xFC;
+
+
+    // byte 2 is number of lit leds, assuming 9 available leds,
+    // if we send 10, all leds will blink singling a gear change
+    // attempting to build in a margin before the maxrpm is achieved
+    int litleds = 0;
+
+    if(rpm > 0 && maxrpm > 0)
+    {
+        int rpmmargin = ceil(.05*maxrpm);
+        int rpminterval = (maxrpm-rpmmargin) / (num_avail_leds+1);
+
+
+        for (int l = 1; l <= (num_avail_leds+1); l++)
+        {
+            if(rpm >= (rpminterval * l))
+            {
+                litleds = l;
+            }
+        }
+    }
+    bytes[1] = litleds;
+
+    // bytes 2 and 3 are a 16 bit velocity
+    if ( velocity > 0 )
+    {
+        bytes[2] = (velocity >> 8) & 0xFF;
+        bytes[3] = velocity & 0xFF;
+    }
+
+    // byte 4 is gear
+    bytes[4] = gear-1;
+
+    slogt("writing bytes x%02xx%02xx%02xx%02xx%02x from rpm %i velocity %i gear %i", bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], rpm, velocity, gear);
+    if (usbdevice->handle)
+    {
+        res = hid_write(usbdevice->handle, bytes, cammusc5_hidupdate_buf_size);
+    }
+    else
+    {
+        slogd("no handle");
+    }
+
+    return res;
+}
+
+int cammusc5_free(USBDevice* usbdevice)
+{
+    int res = 0;
+
+    hid_close(usbdevice->handle);
+    res = hid_exit();
+
+    return res;
+}
+
+int cammusc5_init(USBDevice* usbdevice)
+{
+    slogi("initializing cammus c5 wheel...");
+
+    int res = 0;
+
+    res = hid_init();
+
+    usbdevice->handle = hid_open(0x3416, 0x1021, NULL);
+
+    if (!usbdevice->handle)
+    {
+        sloge("Could not find attached Cammus C5 Wheel");
+        res = hid_exit();
+        return 1;
+    }
+    slogd("Found Cammus C5 Wheel...");
+    return res;
+}
@@ -0,0 +1,10 @@
+#ifndef _CAMMUSC5_H
+#define _CAMMUSC5_H
+
+#include "../../simdevice.h"
+
+int cammusc5_update(USBDevice* wheeldevice, int maxrpm, int rpm, int gear, int velocity);
+int cammusc5_init(USBDevice* wheeldevice);
+int cammusc5_free(USBDevice* wheeldevice);
+
+#endif
@@ -0,0 +1,225 @@
+#include <stdio.h>
+#include <math.h>
+#include <unistd.h>
+#include <hidapi/hidapi.h>
+
+#include "gtneo.h"
+#include <string.h>
+#include "../../../slog/slog.h"
+#include "../../serial/arduinoledlua.h"
+
+// Simagic allows setting any led, therefore LED index should be defined.
+struct LED {
+    uint8_t index;
+    uint8_t red;
+    uint8_t green;
+    uint8_t blue;
+};
+
+// Simagic is using SEND_FEATURE_REPORT
+// ReportID is 240 (0xf0)
+// Data length is 64 bytes
+// Prefix is 00 00 00 00 00
+// Then we have some descriptor. I had 0xEC and 0x03.
+// Then: length of LED array
+// Then: number of LED in hex
+//       RGB value for that LED
+
+
+void prepare_device(hid_device *device) {
+    uint8_t prepare_report[SIMAGIC_MAX_PAYLOAD_SIZE] = {0};
+    prepare_report[0] = 0x00;
+    prepare_report[1] = 0x00;
+    prepare_report[2] = 0x00;
+    prepare_report[3] = 0x00;
+    prepare_report[4] = 0x00;
+    prepare_report[5] = SIMAGIC_LED_DESCRIPTOR_LED_CONTROL;
+    prepare_report[6] = SIMAGIC_LED_DESCRIPTOR_PREPARE_LEDS;
+    prepare_report[7] = 0x01;
+
+    uint8_t report_id_with_data[SIMAGIC_MAX_PAYLOAD_SIZE] = {SIMAGIC_LED_REPORT_ID}; // Report ID at the start
+    memcpy(&report_id_with_data[1], prepare_report, SIMAGIC_MAX_PAYLOAD_SIZE-1);
+
+    // Send the HID feature report
+    int res = hid_send_feature_report(device, report_id_with_data, sizeof(report_id_with_data));
+    if (res < 0) {
+        fprintf(stderr, "Failed to send HID feature report\n");
+    }
+}
+
+/*
+    Arbitrary function for sending out leds to simagic. 
+    Inputs: 
+        device: hid_device handle
+        leds: array of the struct LED
+        led_count: count of leds in leds array
+*/
+int send_leds(hid_device *device, struct LED* leds, size_t led_count) {
+    uint8_t descriptor[2] = {SIMAGIC_LED_DESCRIPTOR_LED_CONTROL, SIMAGIC_LED_DESCRIPTOR_SET_LEDS};
+
+    prepare_device(device);
+    int result = 0;
+    size_t led_i = 0;
+    while (led_i < led_count) {
+        size_t chunk_length = (SIMAGIC_MAX_PAYLOAD_SIZE -1-9) / 4;  // 1 for reportid, 9 bytes for header, rest for LED data (each LED is 4 bytes)
+        size_t chunk_size = chunk_length * 4;
+
+        uint8_t report[SIMAGIC_MAX_PAYLOAD_SIZE] = {0}; // SIMAGIC_MAX_PAYLOAD_SIZE bytes per report
+        memcpy(report, (uint8_t[]){0x00, 0x00, 0x00, 0x00, 0x00}, 5);  // Set the prefix (5 bytes)
+
+        memcpy(&report[5], descriptor, 2);  // Set the descriptor (2 bytes)
+
+        // Fill in the LED data
+        for (size_t i = 0; i < chunk_length && led_i + i < led_count; ++i) {
+            memcpy(&report[8+i*4], &leds[led_i+i], 4);
+            report[7]++; // Set the LED array length for this chunk
+        }
+
+        uint8_t report_id_with_data[SIMAGIC_MAX_PAYLOAD_SIZE] = {SIMAGIC_LED_REPORT_ID};
+        memcpy(&report_id_with_data[1], report, SIMAGIC_MAX_PAYLOAD_SIZE-1);
+
+        // Send the HID feature report
+        int res = hid_send_feature_report(device, report_id_with_data, sizeof(report_id_with_data));
+        if (res < 0) {
+            fprintf(stderr, "Failed to send HID feature report chunk\n");
+            return -1;
+        }
+        result += res;
+
+        // Move to the next chunk of LEDs
+        led_i += chunk_length;
+    }
+    return result;
+}
+
+
+// default simpro profile:
+// 97: b b b b b b b b b b b b b b b //flashing
+// 93: b b b b b b b b b b b b b b b //flashing
+// 90: g g g g g g g g g y y y w w w
+// 88: g g g g g g g g g y y y
+// 85: g g g g g g g g g
+// 83: g g g g g g g
+// 78: g g g g g
+// 75: g g g
+// 70: g
+// less: empty (000000)
+// Telemetry LEDs are 58-72
+
+
+int simagic_gtneo_customled_update(USBDevice* usbdevice, SimData* simdata) 
+{
+    int res = 1;
+
+    size_t led_count = GT_NEO_LEDS_TOTAL-GT_NEO_LEDS_TELEMETRY_START; // Expose whole LED array
+    size_t bufsize = (led_count * 3);
+    char ledbytes[bufsize];
+    for(int x = 0; x < bufsize; x++)
+        ledbytes[x] = 0x00;
+
+    lua_State* L = usbdevice->m.L;
+
+    lua_pushstring(L, "buff");
+    lua_pushlightuserdata(L, &ledbytes);
+    lua_settable(L, LUA_REGISTRYINDEX);
+
+    simdata_to_lua(L, simdata);
+    lua_setglobal(L, "simdata");
+
+    lua_pushinteger(L, led_count);
+    lua_setglobal(L, "TotalLeds");
+
+    lua_register(L, "set_led_to_color", set_led_to_color);
+    lua_register(L, "set_led_range_to_color", set_led_range_to_color);
+    lua_register(L, "set_led_to_rgb_color", set_led_to_rgb_color);
+    lua_register(L, "set_led_range_to_rgb_color", set_led_range_to_rgb_color);
+    lua_register(L, "led_clear_all", led_clear_all);
+
+    lua_pushinteger(L, LUALEDCOLOR_RED);
+    lua_setglobal(L, "RED");
+    lua_pushinteger(L, LUALEDCOLOR_GREEN);
+    lua_setglobal(L, "GREEN");
+    lua_pushinteger(L, LUALEDCOLOR_BLUE);
+    lua_setglobal(L, "BLUE");
+    lua_pushinteger(L, LUALEDCOLOR_YELLOW);
+    lua_setglobal(L, "YELLOW");
+    lua_pushinteger(L, LUALEDCOLOR_ORANGE);
+    lua_setglobal(L, "ORANGE");
+
+    lua_getglobal(L,"myFunc");
+    if (lua_pcall(L, 0, 0, 0) != LUA_OK)
+    {
+        fprintf(stderr, "Error calling Lua script: %s\n", lua_tostring(L, -1));
+    }
+
+    // ledbytes is an array of leds. We need to copy colours to our struct LED and call 'send_leds'
+    struct LED teleleds[led_count];
+
+    for (int i = 0; i < led_count; i++) {
+        teleleds[i] = (struct LED){GT_NEO_LEDS_TELEMETRY_START+i, 0x00, 0x00, 0x00};
+        teleleds[i].red = ledbytes[(i * 3) + 0]; 
+        teleleds[i].green = ledbytes[(i * 3) + 1]; 
+        teleleds[i].blue = ledbytes[(i * 3) + 2]; 
+    }
+
+    res = send_leds(usbdevice->handle, teleleds, led_count);
+    return res;
+}
+
+
+int simagic_gtneo_init(USBDevice* wheeldevice, const char* luafile)
+{
+    wheeldevice->u.wheeldevice.useLua = false;
+
+    slogi("initializing Simagic GT Neo wheel...");
+
+    int res = 0;
+
+    res = hid_init();
+
+    wheeldevice->handle = hid_open(SIMAGIC_GTNEO_VENDORID, SIMAGIC_GTNEO_PRODUCTID, NULL);
+
+    if (!wheeldevice->handle)
+    {
+        sloge("Could not find attached GT Neo Wheel");
+        res = hid_exit();
+        return 1;
+    }
+    slogd("Found Simagic GT Neo Wheel...");
+
+    slogt("Using lua file");
+
+    lua_State* L = luaL_newstate();
+    luaL_openlibs(L);
+
+    //int top=lua_gettop(L);
+    int status = luaL_loadfile(L, luafile);
+
+    if (status) {
+        /* If something went wrong, error message is at the top of */
+        /* the stack */
+        sloge("There is an issue with your lua script");
+        fprintf(stderr, "Couldn't load file: %s\n", lua_tostring(L, -1));
+        lua_close(L);
+        return -1;
+        //exit(1);
+    }
+
+    wheeldevice->u.wheeldevice.useLua = true;
+    lua_setglobal(L,"myFunc");
+
+    wheeldevice->m.L = L;
+
+    return res;
+}
+
+
+int simagic_gtneo_free(USBDevice* wheeldevice)
+{
+    int res = 0;
+
+    hid_close(wheeldevice->handle);
+    res = hid_exit();
+
+    return res;
+}
@@ -0,0 +1,26 @@
+#ifndef _GTNEO_H
+#define _GTNEO_H
+
+#include "../../wheeldevice.h"
+#include "../../simdevice.h"
+
+#define SIMAGIC_GTNEO_VENDORID 0x3670
+#define SIMAGIC_GTNEO_PRODUCTID 0x0805
+
+#define SIMAGIC_MAX_PAYLOAD_SIZE 64
+#define SIMAGIC_LED_REPORT_ID 0xf0 // LED control report id?
+
+#define SIMAGIC_LED_DESCRIPTOR_LED_CONTROL 0xEC // LED control?
+#define SIMAGIC_LED_DESCRIPTOR_PREPARE_LEDS 0x02 //probably something like 'prepare led canvas'
+#define SIMAGIC_LED_DESCRIPTOR_SET_LEDS 0x03 //probably 'set temporare leds'
+
+// expose whole LED array to the lua.
+// Telemetry leds are 58-72
+#define GT_NEO_LEDS_TELEMETRY_START 0
+#define GT_NEO_LEDS_TOTAL 73
+
+int simagic_gtneo_init(USBDevice* wheeldevice, const char* luafile);
+int simagic_gtneo_free(USBDevice* wheeldevice);
+int simagic_gtneo_customled_update(USBDevice* usbdevice, SimData* simdata);
+
+#endif
@@ -0,0 +1,98 @@
+#include <stdio.h>
+#include <math.h>
+
+#include <hidapi/hidapi.h>
+
+#include "logitechg29.h"
+#include "../../../slog/slog.h"
+
+const int logitechg29_hidupdate_buf_size = 7;
+
+int logitechg29_update(USBDevice* usbdevice, int maxrpm, int rpm, int gear, int velocity)
+{
+
+    int res = 0;
+
+    uint8_t leds = 0;
+
+    float percent = 0;
+    if(maxrpm > 0)
+    {
+        percent = (float) rpm / (float) maxrpm;
+
+        if (percent > .84)
+        {
+            leds = 0b11111;
+        }
+        else if (percent > .69)
+        {
+            leds = 0b1111;
+        }
+        else if (percent > .39)
+        {
+            leds = 0b111;
+        }
+        else if (percent > .19)
+        {
+            leds = 0b11;
+        }
+        else if (percent > .4)
+        {
+            leds = 0b1;
+        }
+        else
+        {
+            leds = 0b0;
+        }
+    }
+    uint8_t bytes[7] = {
+        0xF8,
+        0x12,
+        leds,
+        0x00,
+        0x00,
+        0x00,
+        0x01
+    };
+
+    slogt("writing bytes x%02xx%02xx%02xx%02xx%02x from rpm %i", bytes[0], bytes[1], bytes[2], bytes[3], bytes[6], rpm);
+    if (usbdevice->handle)
+    {
+        res = hid_write(usbdevice->handle, bytes, logitechg29_hidupdate_buf_size);
+    }
+    else
+    {
+        slogd("no handle");
+    }
+
+    return res;
+}
+
+int logitechg29_free(USBDevice* usbdevice)
+{
+    int res = 0;
+
+    hid_close(usbdevice->handle);
+    res = hid_exit();
+
+    return res;
+}
+
+int logitechg29_init(USBDevice* usbdevice)
+{
+    slogi("initializing Logitech G29 wheel...");
+
+    int res = 0;
+
+    res = hid_init();
+    usbdevice->handle = hid_open(0x046D, 0xC24F, NULL);
+
+    if (!usbdevice->handle)
+    {
+        sloge("Could not find attached Logitech G29 Wheel");
+        res = hid_exit();
+        return 1;
+    }
+    slogd("Found Logitech G29 Wheel...");
+    return res;
+}
@@ -0,0 +1,10 @@
+#ifndef _LOGITECHG29_H
+#define _LOGITECHG29_H
+
+#include "../../simdevice.h"
+
+int logitechg29_update(USBDevice* wheeldevice, int maxrpm, int rpm, int gear, int velocity);
+int logitechg29_init(USBDevice* wheeldevice);
+int logitechg29_free(USBDevice* wheeldevice);
+
+#endif
@@ -17,7 +17,10 @@ int usbdev_update(SimDevice* this, SimData* simdata)
    {
        case USBDEV_UNKNOWN :
        case USBDEV_TACHOMETER :
-            tachdev_update(&usbdevice->u.tachdevice, simdata);
+            tachdev_update(usbdevice, simdata);
+            break;
+        case USBDEV_WHEEL :
+            wheeldev_update(usbdevice, simdata);
            break;
        case USBDEV_GENERICHAPTIC :
            usbhapticdev_update(&usbdevice->u.hapticdevice, simdata, this->hapticeffect.tyre, this->hapticeffect.useconfig, this->hapticeffect.configcheck, this->hapticeffect.tyrediameterconfig);
@@ -36,7 +39,10 @@ int usbdev_free(SimDevice* this)
    {
        case USBDEV_UNKNOWN :
        case USBDEV_TACHOMETER :
-            tachdev_free(&usbdevice->u.tachdevice);
+            tachdev_free(usbdevice);
+            break;
+        case USBDEV_WHEEL :
+            wheeldev_free(usbdevice);
            break;
        case USBDEV_GENERICHAPTIC :
            usbhapticdev_free(&usbdevice->u.hapticdevice);
@@ -58,7 +64,10 @@ int usbdev_init(USBDevice* usbdevice, DeviceSettings* ds)
    {
        case USBDEV_UNKNOWN :
        case USBDEV_TACHOMETER :
-            error = tachdev_init(&usbdevice->u.tachdevice, ds);
+            error = tachdev_init(usbdevice, ds);
+            break;
+        case USBDEV_WHEEL :
+            error = wheeldev_init(usbdevice, ds);
            break;
        case USBDEV_GENERICHAPTIC :
            error = usbhapticdev_init(&usbdevice->u.hapticdevice, ds);
@@ -81,8 +90,17 @@ USBDevice* new_usb_device(DeviceSettings* ds, MonocoqueSettings* ms) {



-
+    // TODO: turn this into a switch when we get more devices
    this->type = USBDEV_TACHOMETER;
+    if(ds->dev_subtype == SIMDEVTYPE_USBWHEEL)
+    {
+        this->type = USBDEV_WHEEL;
+    }
+
+
+    // really generic haptic isn't and shouldn't be it's own type
+    // it's an attribute that is added to a device via composition
+    // same if that haptic device is a serial device
    if (ds->dev_subtype == SIMDEVTYPE_USBHAPTIC)
    {
        this->m.hapticeffect.threshold = ds->threshold;
@@ -2,6 +2,7 @@
 #define _USBDEVICE_H

 #include "tachdevice.h"
+#include "wheeldevice.h"
 #include "usbhapticdevice.h"

 #endif
@@ -6,6 +6,8 @@
 #include "usbhapticdevice.h"
 #include "hapticeffect.h"
 #include "usb/cslelitev3.h"
+#include "usb/simagicp1000.h"
+
 #include "../../helper/confighelper.h"
 #include "../../simulatorapi/simapi/simapi/simdata.h"
 #include "../../slog/slog.h"
@@ -15,18 +17,34 @@ int usbhapticdev_update(USBGenericHapticDevice* usbhapticdevice, SimData* simdat
 {

    double play = slipeffect(simdata, usbhapticdevice->effecttype, tyre, usbhapticdevice->threshold, useconfig, configcheck, configfile);
-    
+
    if (play != usbhapticdevice->state)
    {
        int rplay = 0;
        if(play > 0)
        {
            rplay = 1;
-            cslelitev3_update(usbhapticdevice, usbhapticdevice->effecttype, rplay);
+            switch ( usbhapticdevice->type )
+            {
+                case USBHAPTIC_CSLELITEV3PEDALS:
+                    cslelitev3_update(usbhapticdevice, usbhapticdevice->effecttype, rplay);
+                    break;
+                case USBHAPTIC_SIMAGICP1000PEDALS:
+                    simagicp1000_update(usbhapticdevice, usbhapticdevice->effecttype, rplay);
+                    break;
+            }
        }
        else
        {
-            cslelitev3_update(usbhapticdevice, usbhapticdevice->effecttype, rplay);
+            switch ( usbhapticdevice->type )
+            {
+                case USBHAPTIC_CSLELITEV3PEDALS:
+                    cslelitev3_update(usbhapticdevice, usbhapticdevice->effecttype, rplay);
+                    break;
+                case USBHAPTIC_SIMAGICP1000PEDALS:
+                    simagicp1000_update(usbhapticdevice, usbhapticdevice->effecttype, rplay);
+                    break;
+            }
        }
        usbhapticdevice->state = play;
    }
@@ -36,7 +54,16 @@ int usbhapticdev_update(USBGenericHapticDevice* usbhapticdevice, SimData* simdat
 int usbhapticdev_free(USBGenericHapticDevice* usbhapticdevice)
 {
    slogt("closing usb haptic device");
-    cslelitev3_free(usbhapticdevice);
+    switch ( usbhapticdevice->type )
+    {
+        case USBHAPTIC_CSLELITEV3PEDALS:
+            cslelitev3_free(usbhapticdevice);
+            break;
+        case USBHAPTIC_SIMAGICP1000PEDALS:
+            simagicp1000_free(usbhapticdevice);
+            break;
+    }
+
    return 0;
 }

@@ -65,14 +92,17 @@ int usbhapticdev_init(USBGenericHapticDevice* usbhapticdevice, DeviceSettings* d

    slogi("initializing standalone usb haptic device...");
    // detection of usb device model
-    usbhapticdevice->type = HAPTIC_UNKNOWN;
-    usbhapticdevice->type = HAPTIC_CSLELITEV3;
-    error = cslelitev3_init(usbhapticdevice);
-
-    if(usbhapticdevice->handle == 0)
-    {
-        error = MONOCOQUE_ERROR_INVALID_DEV;
-        return error;
+    switch (ds->dev_subsubtype) {
+        case (SIMDEVSUBTYPE_SIMAGICP1000PEDALS):
+            usbhapticdevice->type = USBHAPTIC_SIMAGICP1000PEDALS;
+            error = simagicp1000_init(usbhapticdevice);
+            break;
+        case (SIMDEVSUBTYPE_CSLELITEV3PEDALS):
+            usbhapticdevice->type = USBHAPTIC_CSLELITEV3PEDALS;
+            error = cslelitev3_init(usbhapticdevice);
+            break;
+        default:
+            slogw("Possibly unknown device");
    }

    return error;
@@ -8,8 +8,9 @@

 typedef enum
 {
-    HAPTIC_UNKNOWN        = 0,
-    HAPTIC_CSLELITEV3     = 1
+    USBHAPTIC_UNKNOWN                  = 0,
+    USBHAPTIC_CSLELITEV3PEDALS         = 1,
+    USBHAPTIC_SIMAGICP1000PEDALS       = 2
 }
 HapticType;

@@ -22,7 +23,8 @@ typedef struct
    int value0;
    int value1;
    VibrationEffectType effecttype;
-    FILE* handle;
+    FILE* filehandle;
+    hid_device* handle;
    char* dev;
 }
 USBGenericHapticDevice;
@@ -0,0 +1,151 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "usb/wheels/logitechg29.h"
+#include "usb/wheels/cammusc5.h"
+#include "usb/wheels/cammusc12.h"
+#include "usb/wheels/gtneo.h"
+#include "serial/moza.h"
+
+#include "simdevice.h"
+#include "../helper/confighelper.h"
+#include "../simulatorapi/simapi/simapi/simdata.h"
+#include "../slog/slog.h"
+
+int wheeldev_update(USBDevice* usbdevice, SimData* simdata)
+{
+    WheelDevice* wheeldevice = &usbdevice->u.wheeldevice;
+    switch ( wheeldevice->type )
+    {
+        case WHEELDEV_UNKNOWN :
+        case WHEELDEV_CAMMUSC5 :
+            cammusc5_update(usbdevice, simdata->maxrpm, simdata->rpms, simdata->gear, simdata->velocity);
+            break;
+        case WHEELDEV_LOGITECHG29 :
+            logitechg29_update(usbdevice, simdata->maxrpm, simdata->rpms, simdata->gear, simdata->velocity);
+            break;
+        case WHEELDEV_CAMMUSC12 :
+            if(usbdevice->u.wheeldevice.useLua == true)
+            {
+                cammusc12_customled_update(usbdevice, simdata);
+            }
+            else
+            {
+                cammusc12_update(usbdevice, simdata->maxrpm, simdata->rpms, simdata->gear, simdata->velocity);
+            }
+            break;
+        case WHEELDEV_SIMAGICGTNEO :
+            if(usbdevice->u.wheeldevice.useLua == true)
+            {
+                simagic_gtneo_customled_update(usbdevice, simdata);
+            }
+            else
+            {
+                sloge("GT Neo requires config file");
+            }
+            break;    
+    }
+
+    return 0;
+}
+
+int wheeldev_free(USBDevice* usbdevice)
+{
+    WheelDevice* wheeldevice = &usbdevice->u.wheeldevice;
+    slogt("wheel device free");
+    switch ( wheeldevice->type )
+    {
+        case WHEELDEV_UNKNOWN :
+        case WHEELDEV_CAMMUSC5 :
+            cammusc5_update(usbdevice, 0, 0, 0, 0);
+            cammusc5_free(usbdevice);
+            break;
+        case WHEELDEV_LOGITECHG29 :
+            logitechg29_update(usbdevice, 0, 0, 0, 0);
+            logitechg29_free(usbdevice);
+            break;
+        case WHEELDEV_CAMMUSC12 :
+            cammusc12_free(usbdevice);
+            if(wheeldevice->useLua == true)
+            {
+                free(usbdevice->m.device_specific_config_file);
+            }
+            break;
+    }
+
+    return 0;
+}
+
+int wheeldev_init(USBDevice* usbdevice, DeviceSettings* ds)
+{
+    slogi("initializing wheel device...");
+    int error = 0;
+    // detection of wheel model
+    WheelDevice* wheeldevice = &usbdevice->u.wheeldevice;
+    switch (ds->dev_subsubtype) {
+
+        case SIMDEVSUBTYPE_CAMMUSC5:
+            wheeldevice->type = WHEELDEV_CAMMUSC5;
+            slogi("Attempting to initialize cammus C5");
+            error = cammusc5_init(usbdevice);
+            break;
+        case SIMDEVSUBTYPE_LOGITECH_G29:
+            wheeldevice->type = WHEELDEV_LOGITECHG29;
+            slogi("Attempting to initialize Logitech G29");
+            error = logitechg29_init(usbdevice);
+            break;
+        case SIMDEVSUBTYPE_CAMMUSC12:
+            wheeldevice->type = WHEELDEV_CAMMUSC12;
+            slogi("Attempting to initialize cammus C12");
+
+            if(ds->has_config == true)
+            {
+                usbdevice->m.device_specific_config_file = strdup(ds->specific_config_file);
+                error = cammusc12_init(usbdevice, usbdevice->m.device_specific_config_file);
+                if(error != 0)
+                {
+                    if(usbdevice->m.device_specific_config_file != NULL)
+                    {
+                        free(usbdevice->m.device_specific_config_file);
+                    }
+                }
+            }
+            else
+            {
+                error = cammusc12_init(usbdevice, NULL);
+            }
+            break;
+        case SIMDEVSUBTYPE_SIMAGICGTNEO:
+            wheeldevice->type = WHEELDEV_SIMAGICGTNEO;
+            slogi("Attempting to initialize Simagic GT Neo");
+
+            if(ds->has_config == true)
+            {
+                usbdevice->m.device_specific_config_file = strdup(ds->specific_config_file);
+                error = simagic_gtneo_init(usbdevice, usbdevice->m.device_specific_config_file);
+                if(error != 0)
+                {
+                    if(usbdevice->m.device_specific_config_file != NULL)
+                    {
+                        free(usbdevice->m.device_specific_config_file);
+                    }
+                }
+            }
+            else
+            {
+                sloge("Simagic GT Neo requires lua config file to function");
+                error = -1;
+            }
+            break;
+        default:
+            wheeldevice->type = WHEELDEV_UNKNOWN;
+            slogw("Unknown cammus wheel detected, trying C5");
+            error = cammusc5_init(usbdevice);
+            break;
+    }
+
+
+
+    return error;
+}
@@ -0,0 +1,30 @@
+#ifndef _WHEELDEVICE_H
+#define _WHEELDEVICE_H
+
+#include "../helper/confighelper.h"
+#include "../simulatorapi/simapi/simapi/simdata.h"
+
+//typedef int (*tachdev_update)(int revs);
+
+typedef enum
+{
+    WHEELDEV_UNKNOWN       = 0,
+    WHEELDEV_CAMMUSC5      = 1,
+    WHEELDEV_CAMMUSC12     = 2,
+    WHEELDEV_MOZAR5        = 3,
+    WHEELDEV_SIMAGICGTNEO  = 4,
+    WHEELDEV_LOGITECHG29   = 5
+}
+WheelType;
+
+typedef struct
+{
+    int id;
+    WheelType type;
+    bool useLua;
+    char* port;
+}
+WheelDevice;
+
+
+#endif
@@ -3,6 +3,7 @@ set(gameloop_source_files
  gameloop.h
  tachconfig.c
  tachconfig.h
+  loopdata.h
 )

 set(LIBXML_INCLUDE_DIR /usr/include/libxml2)
@@ -7,9 +7,10 @@
 #include <poll.h>
 #include <termios.h>
 #include <signal.h>
+#include <uv.h>

 #include "gameloop.h"
-#include "../helper/parameters.h"
+#include "loopdata.h"
 #include "../helper/confighelper.h"
 #include "../devices/simdevice.h"
 #include "../simulatorapi/simapi/simapi/simdata.h"
@@ -22,15 +23,20 @@ bool go = false;
 bool go2 = false;
 struct sigaction act;

-void sighandler(int signum, siginfo_t* info, void* ptr)
-{
-    sloge("caught signal");
-    go = false;
-    go2 = false;
-    //gfx_clear(pixels, pixels_len);
-    //gfx_swapbuffers();
-    //gfx_close();
-}
+
+uv_idle_t idler;
+uv_timer_t datachecktimer;
+uv_timer_t showstatstimer;
+uv_timer_t datamaptimer;
+uv_udp_t recv_socket;
+
+bool doui = false;
+int appstate = 0;
+
+void shmdatamapcallback(uv_timer_t* handle);
+void showstatscallback(uv_timer_t* handle);
+void datacheckcallback(uv_timer_t* handle);
+void startdatalogger(MonocoqueSettings* ms, loop_data* l);

 int showstats(SimData* simdata)
 {
@@ -181,74 +187,381 @@ int showstats(SimData* simdata)
    fflush(stdout);
 }

-
-int clilooper(SimDevice* devices, int numdevices, Parameters* p, SimData* simdata, SimMap* simmap)
+void simapilib_loginfo(char* message)
 {
-    struct pollfd mypoll = { STDIN_FILENO, POLLIN|POLLPRI };
-    double update_rate = DEFAULT_UPDATE_RATE;
-    char ch;
-    int t=0;
-    int s=0;
-    go2 = true;
-    while (go2 == true && simdata->simstatus > 1)
+    slogi(message);
+}
+
+void simapilib_logdebug(char* message)
+{
+    slogd(message);
+}
+
+void simapilib_logtrace(char* message)
+{
+    slog_display(SLOG_TRACE, 1, message);
+}
+
+void on_timer_close_complete(uv_handle_t* handle)
+{
+    free(handle);
+}
+
+
+void devicetimercallback(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;
+    SimDevice* device = f->simdevice;
+    device->update(device, simdata);
+
+}
+
+void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
+{
+
+    if (doui == true)
    {
-        simdatamap(simdata, simmap, p->sim);
-        showstats(simdata);
-        t++;
-        s++;
-        if(simdata->rpms<100)
+        slogi("looking for ui config %s pass 1", ms->config_str);
+        int confignum = getconfigtouse2(ms->config_str, simdata->car, f->sim);
+        slogi("first pass finished");
+        if(confignum == -1)
        {
-            simdata->rpms=100;
+            slogi("looking for ui config %s pass 2", ms->config_str);
+            confignum = getconfigtouse1(ms->config_str, simdata->car, f->sim);
        }
+        if(confignum == -1)
+        {
+            slogi("looking for ui config %s pass 3", ms->config_str);
+            confignum = getconfigtouse(ms->config_str, simdata->car, f->sim);
+        }
+
+        int configureddevices;
+        configcheck(ms->config_str, confignum, &configureddevices);
+        DeviceSettings* ds = malloc(configureddevices * sizeof(DeviceSettings));
+        slogd("loading confignum %i, with %i devices.", confignum, configureddevices);
+        f->numdevices = uiloadconfig(ms->config_str, confignum, configureddevices, ms, ds);
+
+        if(ms->useconfig == 1)
+        {
+            ms->configcheck = 0;
+        }
+
+        f->simdevices = malloc(f->numdevices * sizeof(SimDevice));
+        int initdevices = devinit(f->simdevices, configureddevices, ds, ms);
+
+        for( int i = 0; i < configureddevices; i++)
+        {
+            settingsfree(ds[i]);
+        }
+        free(ds);
+
+        int numdevices = f->numdevices;
+        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));

        for (int x = 0; x < numdevices; x++)
        {
            if (devices[x].initialized == true)
            {
-                devices[x].update(&devices[x], simdata);
+                device_loop_data* dld = &f->device_batons[x];
+                dld->simdevice = &devices[x];
+                dld->simdata = simdata;
+                uv_timer_t* dt = &f->device_timers[x];
+                uv_timer_init(uv_default_loop(), dt);
+                uv_handle_set_data((uv_handle_t*) dt, (void*) dld);
+                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);
            }
        }

-    	if( poll(&mypoll, 1, 1000.0/update_rate) )
-    	{
-    	    scanf("%c", &ch);
-    	    if(ch == 'q')
-    	    {
-    	        go2 = false;
-    	    }
-    	}
+
+        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);
+        //    }
+        //}
+    }
+}
+
+void showstatscallback(uv_timer_t* handle)
+{
+    void* b = uv_handle_get_data((uv_handle_t*) handle);
+    loop_data* f = (loop_data*) b;
+    SimData* simdata = f->simdata;
+    if(appstate == 2)
+    {
+        showstats(simdata);
+    }
+}
+
+void releaseloop(loop_data* f, SimData* simdata, SimMap* simmap)
+{
+
+        if(f->releasing == false)
+        {
+            f->releasing = true;
+            uv_udp_recv_stop(&recv_socket);
+            uv_timer_stop(&datamaptimer);
+            uv_timer_stop(&showstatstimer);
+            slogi("releasing devices, please wait");
+            f->uion = false;
+            SimDevice* devices = f->simdevices;
+            int numdevices = f->numdevices;
+
+            // help things spin down
+            simdata->simstatus = 0;
+            simdata->rpms = 0;
+            simdata->velocity = 0;
+
+            for (int x = 0; x < numdevices; x++)
+            {
+                if (devices[x].initialized == true)
+                {
+                    uv_timer_t* dt = &f->device_timers[x];
+                    slogt("attempting device timer stop and release");
+                    slogt("timer active status %i", uv_is_active((uv_handle_t*) dt));
+                    uv_timer_stop(dt);
+                    //uv_close((uv_handle_t*) dt, on_timer_close_complete);
+                }
+            }
+            free(f->device_batons);
+            free(f->device_timers);
+            slogt("stopped device timers");
+            for (int x = 0; x < numdevices; x++)
+            {
+                if (devices[x].initialized == true)
+                {
+                    devices[x].update(&devices[x], simdata);
+                }
+            }
+            sleep(1);
+            for (int x = 0; x < numdevices; x++)
+            {
+                if (devices[x].initialized == true)
+                {
+                    devices[x].free(&devices[x]);
+                }
+            }
+            free(devices);
+
+            int r = simfree(simdata, simmap, f->map);
+            slogd("simfree returned %i", r);
+            f->numdevices = 0;
+            slogi("stopped mapping data, press q again to quit");
+            //stopui(ms->ui_type, f);
+            // free loop data
+
+            if(appstate > 0)
+            {
+                uv_timer_start(&datachecktimer, datacheckcallback, 3000, 1000);
+            }
+            f->releasing = false;
+            if(appstate > 1)
+            {
+                appstate = 1;
+            }
+        }
+}
+
+void shmdatamapcallback(uv_timer_t* handle)
+{
+    void* b = uv_handle_get_data((uv_handle_t*) handle);
+    loop_data* f = (loop_data*) b;
+    SimData* simdata = f->simdata;
+    SimMap* simmap = f->simmap;
+    MonocoqueSettings* ms = f->ms;
+    //appstate = 2;
+    if (appstate == 2)
+    {
+        simdatamap(simdata, simmap, NULL, f->map, false, NULL);
+        looprun(ms, f, simdata);
    }

-    simdata->velocity = 0;
-    simdata->rpms = 100;
-    for (int x = 0; x < numdevices; x++)
+    if (f->simstate == false || simdata->simstatus <= 1 || appstate <= 1)
    {
-        if (devices[x].initialized == true)
+        releaseloop(f, simdata, simmap);
+    }
+}
+
+void on_alloc(uv_handle_t* client, size_t suggested_size, uv_buf_t* buf) {
+    buf->base = malloc(suggested_size);
+    buf->len = suggested_size;
+    bzero(buf->base, suggested_size);
+    slogt("udp malloc:%lu %p\n",buf->len,buf->base);
+}
+
+static void on_udp_recv(uv_udp_t* handle, ssize_t nread, const uv_buf_t* rcvbuf, const struct sockaddr* addr, unsigned flags) {
+    if (nread > 0) {
+        slogt("udp data received");
+    }
+    if (nread <= 0) {
+        free(rcvbuf->base);
+        return;
+    }
+
+    char* a;
+    a = rcvbuf->base;
+
+    void* b = uv_handle_get_data((uv_handle_t*) handle);
+    loop_data* f = (loop_data*) b;
+    SimData* simdata = f->simdata;
+    SimMap* simmap = f->simmap;
+    MonocoqueSettings* ms = f->ms;
+
+    if (appstate == 2)
+    {
+        simdatamap(simdata, simmap, NULL, f->map, true, a);
+        looprun(ms, f, simdata);
+    }
+
+    if (f->simstate == false || simdata->simstatus <= 1 || appstate <= 1)
+    {
+        releaseloop(f, simdata, simmap);
+    }
+
+    slogt("udp free  :%lu %p\n",rcvbuf->len,rcvbuf->base);
+    free(rcvbuf->base);
+}
+
+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);
+
+    slogt("initial udp error is %i", err);
+    return err;
+}
+
+void udpstart(MonocoqueSettings* sms, loop_data* f, SimData* simdata, SimMap* simmap)
+{
+    if (appstate == 2)
+    {
+        fprintf(stderr, "udpstart\n");
+        simdatamap(simdata, simmap, NULL, f->sim, true, NULL);
+        if (doui == true)
        {
-            devices[x].update(&devices[x], simdata);
+            looprun(sms, f, simdata);
+        }
+    }
+}
+
+void datacheckcallback(uv_timer_t* handle)
+{
+    void* b = uv_handle_get_data((uv_handle_t*) handle);
+    loop_data* f = (loop_data*) b;
+    SimData* simdata = f->simdata;
+    SimMap* simmap = f->simmap;
+
+    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;
+
+        if(f->ms->force_udp_mode == true)
+        {
+            f->use_udp = true;
+        }
+    }
+    if (f->simstate == true && simdata->simstatus >= 2)
+    {
+        if ( appstate == 1 )
+        {
+            appstate++;
+            doui = true;
+            simdata->tyrediameter[0] = -1;
+            simdata->tyrediameter[1] = -1;
+            simdata->tyrediameter[2] = -1;
+            simdata->tyrediameter[3] = -1;
+
+            if(f->use_udp == 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");
+            }
+            else
+            {
+                int interval = 1000 / f->ms->fps;
+                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);
+        }
+        if(appstate == 2)
+        {
+            SimInfo si = getSim(simdata, simmap, f->ms->force_udp_mode, NULL, false);
+            if(si.isSimOn == false)
+            {
+                appstate = 1;
+                releaseloop(f, simdata, simmap);
+            }
        }
    }

-    fprintf(stdout, "\n");
-
-    return 0;
+    if (appstate == 0)
+    {
+        slogi("stopping checking for data");
+        uv_timer_stop(handle);
+    }
 }

-int looper(SimDevice* devices, int numdevices, Parameters* p)
+void cb(uv_poll_t* handle, int status, int events)
+{
+    void* b = uv_handle_get_data((uv_handle_t*) handle);
+    loop_data* f = (loop_data*) b;
+    char ch;
+    scanf("%c", &ch);
+    if (ch == 'q')
+    {
+        if(f->releasing == false && doui == false)
+        {
+            appstate--;
+            fprintf(stdout, "\nUser requested stop appstate is now %i\n", appstate);
+            fflush(stdout);
+            slogi("User requested stop appstate is now %i", appstate);
+        }
+    }
+
+    if (appstate == 0)
+    {
+        slogi("Monocoque is exiting...");
+        uv_timer_stop(&datachecktimer);
+        uv_poll_stop(handle);
+    }
+}
+
+
+
+int monocoque_mainloop(MonocoqueSettings* ms)
 {
-    memset(&act, 0, sizeof(act));
-    act.sa_sigaction = sighandler;
-    act.sa_flags = SA_SIGINFO;
-    sigaction(SIGTERM, &act, NULL);
-    sigaction(SIGINT, &act, NULL);
-    sigaction(SIGTSTP, &act, NULL);

    SimData* simdata = malloc(sizeof(SimData));
-    SimMap* simmap = malloc(sizeof(SimMap));
-    simdata->tyrediameter[0] = -1;
-    simdata->tyrediameter[1] = -1;
-    simdata->tyrediameter[2] = -1;
-    simdata->tyrediameter[3] = -1;
+    SimMap* simmap = createSimMap();

    struct termios newsettings, canonicalmode;
    tcgetattr(0, &canonicalmode);
@@ -260,57 +573,54 @@ int looper(SimDevice* devices, int numdevices, Parameters* p)
    char ch;
    struct pollfd mypoll = { STDIN_FILENO, POLLIN|POLLPRI };

+    uv_poll_t* poll = (uv_poll_t*) malloc(uv_handle_size(UV_POLL));
+
+    loop_data* baton = (loop_data*) malloc(sizeof(loop_data));
+    baton->simmap = simmap;
+    baton->simdata = simdata;
+    baton->ms = ms;
+    baton->simstate = false;
+    baton->uion = false;
+    baton->releasing = false;
+    baton->sim = 0;
+    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");
-    p->simon = false;
-    double update_rate = SIM_CHECK_RATE;
-    go = true;
-    while (go == true)
+    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);
+
+
+    if (0 != uv_poll_init(uv_default_loop(), poll, 0))
    {
-        p->simon = false;
-        getSim(simdata, simmap, &p->simon, &p->sim);
-
-        if (p->simon == true && simdata->simstatus > 1)
-        {
-            slogi("preparing game loop with %i devices...", numdevices);
+        return 1;
+    };
+    if (0 != uv_poll_start(poll, UV_READABLE, cb))
+    {
+        return 2;
+    };


-            slogi("sending initial data to devices");
-            simdata->velocity = 16;
-            simdata->rpms = 100;
-            for (int x = 0; x < numdevices; x++)
-            {
-                devices[x].update(&devices[x], simdata);
-            }
-            sleep(3);
-
-            clilooper(devices, numdevices, p, simdata, simmap);
-        }
-        if (p->simon == true)
-        {
-            p->simon = false;
-            fprintf(stdout, "Searching for sim data... Press q again to quit...\n");
-            sleep(2);
-        }
-
-        if (poll(&mypoll, 1, 1000.0/update_rate) )
-        {
-            if (go != false )
-            {
-                scanf("%c", &ch);
-                if(ch == 'q')
-                {
-                    go = false;
-                }
-            }
-        }
-    }
+    uv_timer_init(uv_default_loop(), &datamaptimer);

+    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
    fprintf(stdout, "\n");
    fflush(stdout);
    tcsetattr(0, TCSANOW, &canonicalmode);

+    free(baton);
    free(simdata);
-    free(simmap);
+    freesimmap(simmap, false);

    return 0;
 }
@@ -330,7 +640,14 @@ int tester(SimDevice* devices, int numdevices)
    tcsetattr(0, TCSANOW, &newsettings);

    fprintf(stdout, "\n");
-    simdata->gear = 0;
+    simdata->car[0] = 'C';
+    simdata->car[1] = 'A';
+    simdata->car[2] = 'R';
+    simdata->car[3] = '\0';
+
+    simdata->gear = SIMAPI_GEAR_NEUTRAL;
+    simdata->gearc[0] = 0x4e;
+    simdata->gearc[1] = 0;
    simdata->velocity = 16;
    simdata->rpms = 100;
    simdata->maxrpm = 8000;
@@ -339,6 +656,9 @@ int tester(SimDevice* devices, int numdevices)
    simdata->tyrediameter[1] = -1;
    simdata->tyrediameter[2] = -1;
    simdata->tyrediameter[3] = -1;
+    simdata->Xvelocity = 0;
+    simdata->Yvelocity = 100;
+    simdata->Zvelocity = 0;

    sleep(3);

@@ -353,8 +673,12 @@ int tester(SimDevice* devices, int numdevices)
    }
    sleep(3);

+    fprintf(stdout, "Green Flag!\n");
+    simdata->playerflag = SIMAPI_FLAG_GREEN;
+
    fprintf(stdout, "Shifting into first gear\n");
-    simdata->gear = 2;
+    simdata->gear = SIMAPI_GEAR_FIRST;
+    simdata->gearc[0] = 0x31;
    for (int x = 0; x < numdevices; x++)
    {
        if (devices[x].initialized == true)
@@ -376,14 +700,15 @@ int tester(SimDevice* devices, int numdevices)
    sleep(3);

    fprintf(stdout, "testing wheel spin\n");
+    simdata->velocity = 15;
+    simdata->tyreRPS[0] = 50;
+    simdata->tyreRPS[1] = 50;
+    simdata->tyreRPS[2] = 50;
+    simdata->tyreRPS[3] = 50;
    simdata->tyrediameter[0] = 0.638636385206394;
    simdata->tyrediameter[1] = 0.633384434597093;
    simdata->tyrediameter[2] = 0.710475735564615;
    simdata->tyrediameter[3] = 0.710475735564615;
-    simdata->tyreRPS[0] = 103;
-    simdata->tyreRPS[1] = 103;
-    simdata->tyreRPS[2] = 103;
-    simdata->tyreRPS[3] = 103;
    for (int x = 0; x < numdevices; x++)
    {
        if (devices[x].initialized == true)
@@ -394,11 +719,11 @@ int tester(SimDevice* devices, int numdevices)
    sleep(3);

    fprintf(stdout, "Testing wheel Lock\n");
-    simdata->tyreRPS[0] = 50;
-    simdata->tyreRPS[1] = 50;
-    simdata->tyreRPS[2] = 50;
-    simdata->tyreRPS[3] = 50;
-    simdata->velocity = 100;
+    simdata->tyreRPS[0] = 25;
+    simdata->tyreRPS[1] = 25;
+    simdata->tyreRPS[2] = 25;
+    simdata->tyreRPS[3] = 25;
+    simdata->velocity = 150;
    for (int x = 0; x < numdevices; x++)
    {
        if (devices[x].initialized == true)
@@ -418,7 +743,8 @@ int tester(SimDevice* devices, int numdevices)
    simdata->tyrediameter[2] = -1;
    simdata->tyrediameter[3] = -1;
    simdata->abs = 0;
-    simdata->gear = 3;
+    simdata->gear = SIMAPI_GEAR_SECOND;
+    simdata->gearc[0] = 0x32;
    for (int x = 0; x < numdevices; x++)
    {
        if (devices[x].initialized == true)
@@ -432,11 +758,11 @@ int tester(SimDevice* devices, int numdevices)
    simdata->tyreRPS[0] = 50;
    simdata->tyreRPS[1] = 50;
    simdata->tyreRPS[2] = 50;
+    simdata->tyreRPS[3] = 50;
    simdata->tyrediameter[0] = 0.638636385206394;
    simdata->tyrediameter[1] = 0.633384434597093;
    simdata->tyrediameter[2] = 0.710475735564615;
    simdata->tyrediameter[3] = 0.710475735564615;
-    simdata->tyreRPS[3] = 50;
    simdata->abs = .11;
    for (int x = 0; x < numdevices; x++)
    {
@@ -467,8 +793,12 @@ int tester(SimDevice* devices, int numdevices)
    }
    sleep(3);

+    fprintf(stdout, "Yellow Flag!\n");
+    simdata->playerflag = SIMAPI_FLAG_YELLOW;
+
    fprintf(stdout, "Shifting into third gear\n");
-    simdata->gear = 4;
+    simdata->gear = SIMAPI_GEAR_THIRD;
+    simdata->gearc[0] = 0x33;
    for (int x = 0; x < numdevices; x++)
    {
        if (devices[x].initialized == true)
@@ -489,6 +819,9 @@ int tester(SimDevice* devices, int numdevices)
    }
    sleep(3);

+    fprintf(stdout, "Blue Flag!\n");
+    simdata->playerflag = SIMAPI_FLAG_BLUE;
+
    fprintf(stdout, "Setting rpms to 4000\n");
    simdata->rpms = 4000;
    for (int x = 0; x < numdevices; x++)
@@ -501,7 +834,8 @@ int tester(SimDevice* devices, int numdevices)
    sleep(3);

    fprintf(stdout, "Shifting into fourth gear\n");
-    simdata->gear = 5;
+    simdata->gear = SIMAPI_GEAR_FOURTH;
+    simdata->gearc[0] = 0x34;
    for (int x = 0; x < numdevices; x++)
    {
        if (devices[x].initialized == true)
@@ -522,8 +856,8 @@ int tester(SimDevice* devices, int numdevices)
    }
    sleep(3);

-    fprintf(stdout, "Setting rpms to 8000\n");
-    simdata->rpms = 8000;
+    fprintf(stdout, "Setting rpms to 7000\n");
+    simdata->rpms = 7000;
    for (int x = 0; x < numdevices; x++)
    {
        if (devices[x].initialized == true)
@@ -533,8 +867,34 @@ int tester(SimDevice* devices, int numdevices)
    }
    sleep(3);

+    fprintf(stdout, "Red Flag!\n");
+    simdata->playerflag = SIMAPI_FLAG_RED;
+
+    fprintf(stdout, "Setting rpms to 8000\n");
+    simdata->rpms = 8000;
+    for (int x = 0; x < numdevices; x++)
+    {
+        if (devices[x].initialized == true)
+        {
+            devices[x].update(&devices[x], simdata);
+        }
+    }
+    for(int x = 0; x < 100; x++)
+    {
+        for (int x = 0; x < numdevices; x++)
+        {
+            if (devices[x].initialized == true)
+            {
+                devices[x].update(&devices[x], simdata);
+            }
+        }
+    }
+    sleep(3);
+
    simdata->velocity = 0;
    simdata->rpms = 100;
+    simdata->gear = SIMAPI_GEAR_NEUTRAL;
+    simdata->gearc[0] = 0x4e;
    for (int x = 0; x < numdevices; x++)
    {
        if (devices[x].initialized == true)
@@ -3,3 +3,5 @@

 int tester(SimDevice* devices, int numdevices);
 int looper(SimDevice* devices, int numdevices, Parameters* p);
+
+int monocoque_mainloop(MonocoqueSettings* ms);
@@ -0,0 +1,38 @@
+#ifndef _LOOPDATA_H
+#define _LOOPDATA_H
+
+#include <uv.h>
+#include "../helper/parameters.h"
+#include "../helper/confighelper.h"
+#include "../devices/simdevice.h"
+#include "../simulatorapi/simapi/simapi/simdata.h"
+#include "../simulatorapi/simapi/simapi/simmapper.h"
+
+typedef struct device_loop_data
+{
+    uv_work_t req;
+    SimData* simdata;
+    SimDevice* simdevice;
+} 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;
+    MonocoqueSettings* ms;
+    SimData* simdata;
+    SimMap* simmap;
+    SimDevice* simdevices;
+    uv_timer_t* device_timers;
+    device_loop_data* device_batons;
+} loop_data;
+
+
+
+#endif
@@ -10,10 +10,15 @@
 #include <libxml/tree.h>

 #include "confighelper.h"
+#include "dirhelper.h"

 #include "../slog/slog.h"
 #include "parameters.h"

+
+
+#include "../simulatorapi/simapi/simapi/simmapper.h"
+
 #include <pulse/pulseaudio.h>

 int strcicmp(char const *a, char const *b)
@@ -25,34 +30,6 @@ int strcicmp(char const *a, char const *b)
    }
 }

-
-int strtogame(const char* game, MonocoqueSettings* ms)
-{
-    slogd("Checking for %s in list of supported simulators.", game);
-    if (strcicmp(game, "ac") == 0)
-    {
-        slogd("Setting simulator to Assetto Corsa");
-        ms->sim_name = SIMULATOR_ASSETTO_CORSA;
-    }
-    else if (strcicmp(game, "rf2") == 0)
-    {
-        slogd("Setting simulator to RFactor 2");
-        ms->sim_name = SIMULATOR_RFACTOR2;
-    }
-    else
-        if (strcicmp(game, "test") == 0)
-        {
-            slogd("Setting simulator to Test Data");
-            ms->sim_name = SIMULATOR_SIMAPI_TEST;
-        }
-        else
-        {
-            slogi("%s does not appear to be a supported simulator.", game);
-            return MONOCOQUE_ERROR_INVALID_SIM;
-        }
-    return MONOCOQUE_ERROR_NONE;
-}
-
 int strtoeffecttype(const char* effect, DeviceSettings* ds)
 {
    ds->is_valid = false;
@@ -67,6 +44,11 @@ int strtoeffecttype(const char* effect, DeviceSettings* ds)
        ds->is_valid = true;
        ds->effect_type = EFFECT_GEARSHIFT;
    }
+    if (strcicmp(effect, "Suspension") == 0)
+    {
+        ds->is_valid = true;
+        ds->effect_type = EFFECT_SUSPENSION;
+    }
    if (strcicmp(effect, "ABS") == 0)
    {
        ds->is_valid = true;
@@ -95,6 +77,66 @@ int strtoeffecttype(const char* effect, DeviceSettings* ds)
    return MONOCOQUE_ERROR_NONE;
 }

+int strtodevsubsubtype(const char* device_subsubtype, DeviceSettings* ds)
+{
+    ds->dev_subsubtype = SIMDEVSUBTYPE_UNKNOWN;
+
+
+    bool devfound = false;
+    if (strcicmp(device_subsubtype, "CammusC5") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_CAMMUSC5;
+        devfound = true;
+    }
+    if (strcicmp(device_subsubtype, "CammusC12") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_CAMMUSC12;
+        devfound = true;
+    }
+    if (strcicmp(device_subsubtype, "MozaNew") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_MOZA_NEW;
+        devfound = true;
+    }
+    if (strcicmp(device_subsubtype, "MozaR5") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_MOZAR5;
+        devfound = true;
+    }
+    if (strcicmp(device_subsubtype, "LogitechG29") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_LOGITECH_G29;
+        devfound = true;
+    }
+    if (strcicmp(device_subsubtype, "MozaR8") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_MOZAR5;
+        devfound = true;
+    }
+    if (strcicmp(device_subsubtype, "CSLELITEV3PEDALS") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_CSLELITEV3PEDALS;
+        devfound = true;
+    }
+    if (strcicmp(device_subsubtype, "SIMAGICP1000PEDALS") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_SIMAGICP1000PEDALS;
+        devfound = true;
+    }
+    if (strcicmp(device_subsubtype, "SIMAGICGTNEO") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_SIMAGICGTNEO;
+        devfound = true;
+    }
+
+    if(devfound == false)
+    {
+        slogw("%s does not appear to be a valid device sub sub type, but attempting to continue with other devices", device_subsubtype);
+        return MONOCOQUE_ERROR_INVALID_DEV;
+    }
+    return MONOCOQUE_ERROR_NONE;
+}
+
 int strtodevsubtype(const char* device_subtype, DeviceSettings* ds, int simdev)
 {
    ds->is_valid = false;
@@ -107,6 +149,11 @@ int strtodevsubtype(const char* device_subtype, DeviceSettings* ds, int simdev)
                ds->dev_subtype = SIMDEVTYPE_TACHOMETER;
                break;
            }
+            if (strcicmp(device_subtype, "Wheel") == 0 || strcicmp(device_subtype, "UsbWheel") == 0)
+            {
+                ds->dev_subtype = SIMDEVTYPE_USBWHEEL;
+                break;
+            }
            if (strcicmp(device_subtype, "UsbHaptic") == 0 || strcicmp(device_subtype, "Haptic") == 0)
            {
                ds->dev_subtype = SIMDEVTYPE_USBHAPTIC;
@@ -118,6 +165,16 @@ int strtodevsubtype(const char* device_subtype, DeviceSettings* ds, int simdev)
                ds->dev_subtype = SIMDEVTYPE_SHIFTLIGHTS;
                break;
            }
+            if (strcicmp(device_subtype, "Simleds") == 0)
+            {
+                ds->dev_subtype = SIMDEVTYPE_SIMLED;
+                break;
+            }
+            if (strcicmp(device_subtype, "ArduinoCustom") == 0 || strcicmp(device_subtype, "Custom") == 0)
+            {
+                ds->dev_subtype = SIMDEVTYPE_ARDUINOCUSTOM;
+                break;
+            }
            if (strcicmp(device_subtype, "SimWind") == 0)
            {
                ds->dev_subtype = SIMDEVTYPE_SIMWIND;
@@ -129,6 +186,11 @@ int strtodevsubtype(const char* device_subtype, DeviceSettings* ds, int simdev)
                ds->dev_subtype = SIMDEVTYPE_SERIALHAPTIC;
                break;
            }
+            if (strcicmp(device_subtype, "Wheel") == 0)
+            {
+                ds->dev_subtype = SIMDEVTYPE_SERIALWHEEL;
+                break;
+            }
        case SIMDEV_SOUND:
            ds->is_valid = true;
            break;
@@ -171,7 +233,252 @@ int strtodev(const char* device_type, const char* device_subtype, DeviceSettings
    return MONOCOQUE_ERROR_NONE;
 }

-int loadtachconfig(const char* config_file, DeviceSettings* ds)
+int getsimfromconfig(config_setting_t* c)
+{
+    int sim = 0;
+    const char* simstr = NULL;
+    int found = config_setting_lookup_string(c, "sim", &simstr);
+    if(found == 0)
+    {
+        int found = config_setting_lookup_int(c, "sim", &sim);
+    }
+    else
+    {
+        sim = simapi_strtogame(simstr);
+    }
+    return sim;
+}
+
+int getNumberOfConfigs(const char* config_file_str)
+{
+    config_t cfg;
+    config_init(&cfg);
+    if (!config_read_file(&cfg, config_file_str))
+    {
+        fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
+        return -1;
+    }
+    config_setting_t* config = NULL;
+    config_setting_t* config_widgets = NULL;
+    config = config_lookup(&cfg, "configs");
+    int configs = config_setting_length(config);
+
+    config_destroy(&cfg);
+    return configs;
+}
+
+int getconfigtouse2(const char* config_file_str, char* car, int sim)
+{
+    slogt("inside first pass");
+    config_t cfg;
+    config_init(&cfg);
+    if (!config_read_file(&cfg, config_file_str))
+    {
+        sloge("config read error on pass 1");
+        fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
+        config_destroy(&cfg);
+        return -1;
+    }
+
+    slogt("config validates");
+    config_setting_t* config = NULL;
+    config_setting_t* config_widgets = NULL;
+    config = config_lookup(&cfg, "configs");
+    int configs = config_setting_length(config);
+
+    const char* temp;
+    config_setting_t* config_config = NULL;
+    int j = 0;
+    if ( configs == 1 )
+    {
+        config_destroy(&cfg);
+        return -1;
+    }
+    int confignum = -1;
+    slogt("Multiple configs found");
+    for (j = 0; j < configs; j++)
+    {
+        config_config = config_setting_get_elem(config, j);
+
+        int found = 0;
+        int csim = 0;
+        slogt("sim is %i", sim);
+        csim = getsimfromconfig(config_config);
+        if (csim != sim)
+        {
+            slogt("rejected config %i", j);
+            continue;
+        }
+
+        slogt("checking if car is matched %i", j);
+        temp = NULL;
+        found = config_setting_lookup_string(config_config, "car", &temp);
+        slogt("config car is %s found is %i", temp, found);
+        if(temp != NULL && found > 0 && car > 0 && car != NULL)
+        {
+            slogt("checking against sim car of %s", car);
+            if(strcicmp(temp, car) == 0)
+            {
+                confignum = j;
+            }
+        }
+        if(confignum>=0)
+        {
+            break;
+        }
+    }
+
+    config_destroy(&cfg);
+    return confignum;
+}
+
+int getconfigtouse1(const char* config_file_str, char* car, int sim)
+{
+    config_t cfg;
+    config_init(&cfg);
+    if (!config_read_file(&cfg, config_file_str))
+    {
+        fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
+        config_destroy(&cfg);
+        return -1;
+    }
+    config_setting_t* config = NULL;
+    config_setting_t* config_widgets = NULL;
+    config = config_lookup(&cfg, "configs");
+    int configs = config_setting_length(config);
+
+    const char* temp;
+    config_setting_t* config_config = NULL;
+    int j = 0;
+    if ( configs == 1 )
+    {
+        config_destroy(&cfg);
+        return -1;
+    }
+    int confignum = -1;
+    slogt("Multiple configs found");
+    for (j = 0; j < configs; j++)
+    {
+        config_config = config_setting_get_elem(config, j);
+
+        int found = 0;
+        int csim = 0;
+        slogt("sim is %i", sim);
+        csim = getsimfromconfig(config_config);
+        if (csim != sim)
+        {
+            slogt("rejected config %i", j);
+            continue;
+        }
+
+        slogt("checking if car is matched %i", j);
+        temp = NULL;
+        found = config_setting_lookup_string(config_config, "car", &temp);
+        slogt("config car is %s found is %i", temp, found);
+        if(temp != NULL && found > 0 && car > 0 && car != NULL)
+        {
+            slogt("checking against sim car of %s", car);
+            if(strcicmp(temp, car) == 0)
+            {
+                confignum = j;
+            }
+            if(strcicmp("default", temp) == 0)
+            {
+                slogt("matched default car");
+                confignum = j;
+            }
+        }
+        else
+        {
+            slogt("assuming default car");
+            confignum = j;
+        }
+        slogt("bomb");
+        if(confignum>=0)
+        {
+            break;
+        }
+    }
+
+    config_destroy(&cfg);
+    return confignum;
+}
+
+int getconfigtouse(const char* config_file_str, char* car, int sim)
+{
+    config_t cfg;
+    config_init(&cfg);
+    if (!config_read_file(&cfg, config_file_str))
+    {
+        fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
+        config_destroy(&cfg);
+        return -1;
+    }
+
+    config_setting_t* config = NULL;
+    config_setting_t* config_widgets = NULL;
+    config = config_lookup(&cfg, "configs");
+    int configs = config_setting_length(config);
+
+    const char* temp;
+    config_setting_t* config_config = NULL;
+    int j = 0;
+    if ( configs == 1 )
+    {
+        config_destroy(&cfg);
+        return 0;
+    }
+    int confignum = 0;
+    slogt("Multiple configs found");
+    for (j = 0; j < configs; j++)
+    {
+        config_config = config_setting_get_elem(config, j);
+
+        int found = 0;
+        int csim = 0;
+        slogt("sim is %i", sim);
+        csim = getsimfromconfig(config_config);
+        if (csim != sim && csim != 0)
+        {
+            slogt("rejected config %i", j);
+            continue;
+        }
+
+        slogt("checking if car is matched %i", j);
+        temp = NULL;
+        found = config_setting_lookup_string(config_config, "car", &temp);
+        slogt("config car is %s found is %i", temp, found);
+        if(temp != NULL && found > 0 && car > 0 && car != NULL)
+        {
+            slogt("checking against sim car of %s", car);
+            if(strcicmp(temp, car) == 0)
+            {
+                confignum = j;
+            }
+            if(strcicmp("default", temp) == 0)
+            {
+                slogt("matched default car");
+                confignum = j;
+            }
+        }
+        else
+        {
+            slogt("assuming default car");
+            confignum = j;
+        }
+        slogt("bomb");
+        if(confignum<configs-1)
+        {
+            break;
+        }
+    }
+
+    config_destroy(&cfg);
+    return confignum;
+}
+
+
+int loadtachconfig(char* config_file, DeviceSettings* ds)
 {


@@ -268,9 +575,9 @@ int gettyre(config_setting_t* device_settings, DeviceSettings* ds) {

    const char* temp;
    int found = config_setting_lookup_string(device_settings, "tyre", &temp);
-    
+
    ds->tyre = ALLFOUR;
-    
+
    if (strcicmp(temp, "FRONTS") == 0)
    {
        ds->tyre = FRONTS;
@@ -298,15 +605,66 @@ int gettyre(config_setting_t* device_settings, DeviceSettings* ds) {

 }

-int loadconfig(const char* config_file, DeviceSettings* ds)
+static int load_device_specific_config(const char* config_file, DeviceSettings* ds)
 {
+
+    ds->has_config = false;
+    if(config_file == NULL)
+    {
+        slogt("config set to none");
+    }
+    else
+    {
+        ds->has_config = true;
+
+        if(strcicmp(config_file, "none") == 0)
+        {
+            ds->has_config = false;
+            ds->specific_config_file = NULL;
+        }
+        else
+        {
+            ds->specific_config_file = strdup(config_file);
+            ds->specific_config_file = expand_tilde(ds->specific_config_file);
+            slogt("will try to load config file at %s", ds->specific_config_file);
+        }
+    }
+
+    // in the case of the revburner tachometer, we can parse once and store
    if (ds->dev_subtype == SIMDEVTYPE_TACHOMETER)
    {
-        return loadtachconfig(config_file, ds);
+        if(ds->has_config == false)
+        {
+            slogw("Tachometer must have a device specific config file!");
+            return 1;
+        }
+        loadtachconfig(ds->specific_config_file, ds);
    }
    return 0;
 }

+int configcheck(const char* config_file_str, int confignum, int* devices)
+{
+    slogt("ui config check");
+    config_t cfg;
+    config_init(&cfg);
+    if (!config_read_file(&cfg, config_file_str))
+    {
+        fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
+    }
+
+    config_setting_t* config = NULL;
+    config = config_lookup(&cfg, "configs");
+    config_setting_t* selectedconfig = config_setting_get_elem(config, confignum);
+    slogt("selected num %i", confignum);
+    config_setting_t* config_devices = NULL;
+    config_devices = config_setting_lookup(selectedconfig, "devices");
+    *devices = config_setting_length(config_devices);
+    config_destroy(&cfg);
+    return 0;
+    //return cfg;
+}
+
 int devsetup(const char* device_type, const char* device_subtype, const char* config_file, MonocoqueSettings* ms, DeviceSettings* ds, config_setting_t* device_settings)
 {
    int error = MONOCOQUE_ERROR_NONE;
@@ -322,7 +680,7 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co

    if (ms->program_action == A_PLAY || ms->program_action == A_TEST)
    {
-        error = loadconfig(config_file, ds);
+        error = load_device_specific_config(config_file, ds);
    }
    if (error != MONOCOQUE_ERROR_NONE)
    {
@@ -330,6 +688,8 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
    }


+    ds->fps = 60;
+    config_setting_lookup_int(device_settings, "fps", &ds->fps);

    if (ds->dev_subtype == SIMDEVTYPE_TACHOMETER)
    {
@@ -350,9 +710,17 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
        }
    }

-    if (ds->dev_subtype == SIMDEVTYPE_USBHAPTIC)
+    if (ds->dev_subtype == SIMDEVTYPE_USBHAPTIC || ds->dev_subtype == SIMDEVTYPE_USBWHEEL)
    {
        // logic for different devices
+        int b = 0;
+
+        const char* temp;
+        int found = config_setting_lookup_string(device_settings, "subtype", &temp);
+        if(temp != NULL && found > 0)
+        {
+            b = strtodevsubsubtype(temp, ds);
+        }
    }

    if (ds->dev_subtype == SIMDEVTYPE_USBHAPTIC || ds->dev_type == SIMDEV_SOUND || ds->dev_subtype == SIMDEVTYPE_SERIALHAPTIC)
@@ -361,7 +729,7 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
        const char* effect;
        config_setting_lookup_string(device_settings, "effect", &effect);
        strtoeffecttype(effect, ds);
-        if (ds->effect_type == EFFECT_TYRESLIP || ds->effect_type == EFFECT_TYRELOCK || ds->effect_type == EFFECT_ABSBRAKES)
+        if (ds->effect_type == EFFECT_TYRESLIP || ds->effect_type == EFFECT_TYRELOCK || ds->effect_type == EFFECT_ABSBRAKES || ds->effect_type == EFFECT_SUSPENSION )
        {
            gettyre(device_settings, ds);
            ds->threshold = 0;
@@ -371,11 +739,13 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
        if (ds->dev_type == SIMDEV_SOUND)
        {
            slogi("reading configured sound device settings");
-            ds->sounddevsettings.frequency = -1;
-            ds->sounddevsettings.volume = -1;
-            ds->sounddevsettings.lowbound_frequency = -1;
-            ds->sounddevsettings.upperbound_frequency = -1;
+            ds->sounddevsettings.frequency = 0;
+            ds->sounddevsettings.frequencyMax = 0;
+            ds->sounddevsettings.amplitude = 50;
+            ds->sounddevsettings.amplitudeMax = 50;
+            ds->sounddevsettings.volume = 0;
            ds->sounddevsettings.pan = 0;
+            ds->sounddevsettings.channels = 1;
            ds->sounddevsettings.duration = 2.0;
            if (ds->effect_type == EFFECT_GEARSHIFT)
            {
@@ -386,29 +756,77 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co

                config_setting_lookup_int(device_settings, "volume", &ds->sounddevsettings.volume);
                config_setting_lookup_int(device_settings, "frequency", &ds->sounddevsettings.frequency);
+                config_setting_lookup_int(device_settings, "frequencyMax", &ds->sounddevsettings.frequencyMax);
+                config_setting_lookup_int(device_settings, "amplitude", &ds->sounddevsettings.amplitude);
+                config_setting_lookup_int(device_settings, "amplitudeMax", &ds->sounddevsettings.amplitudeMax);
                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);

-                const char* temp;
+                const char* temp = NULL;
                int found = 0;
                found = config_setting_lookup_string(device_settings, "devid", &temp);
-                if (found == 0)
+                if (found == CONFIG_FALSE)
                {
                    ds->sounddevsettings.dev = NULL;
                }
                else
                {
-                    ds->sounddevsettings.dev = strdup(temp);
+                    if(temp != NULL)
+                    {
+                        ds->sounddevsettings.dev = strdup(temp);
+                    }
+                }
+
+
+                found = config_setting_lookup_string(device_settings, "modulation", &temp);
+                ds->sounddevsettings.modulation = SOUND_EFFECT_MODULATION_NONE;
+                if (found == 0)
+                {
+                    ds->sounddevsettings.modulation = SOUND_EFFECT_MODULATION_NONE;
+                    slogd("Effect modulation not found, set to none");
+                }
+                else
+                {
+                    if(strcicmp(temp, "FREQUENCY") == 0)
+                    {
+                        ds->sounddevsettings.modulation = SOUND_EFFECT_MODULATION_FREQUENCY;
+                        if(ds->sounddevsettings.frequencyMax == 0 || ds->sounddevsettings.frequencyMax < ds->sounddevsettings.frequency)
+                        {
+                            ds->sounddevsettings.modulation = SOUND_EFFECT_MODULATION_NONE;
+                            slogw("Falling back to no frequency modulation since frequencyMax is either not set or set below target frequency");
+                        }
+                        else
+                        {
+                            slogi("Effect modulation found, set to FREQUENCY");
+                        }
+                    }
+                    else if(strcicmp(temp, "AMPLIFY") == 0)
+                    {
+                        ds->sounddevsettings.modulation = SOUND_EFFECT_MODULATION_AMPLIFY;
+                        slogi("Effect modulation found, set to AMPLIFY");
+                    }
+                    else
+                    {
+                        slogw("%s is not a valid modulation type, falling back to no effect modulation");
+                        ds->sounddevsettings.modulation = SOUND_EFFECT_MODULATION_NONE;
+                    }
                }
            }
        }
    }

-    if (ds->dev_subtype == SIMDEVTYPE_SIMWIND || ds->dev_subtype == SIMDEVTYPE_SHIFTLIGHTS || ds->dev_subtype == SIMDEVTYPE_SERIALHAPTIC)
+    if (ds->dev_type == SIMDEV_SERIAL)
    {
        if (device_settings != NULL)
        {
            const char* temp;
+            int found = config_setting_lookup_string(device_settings, "subtype", &temp);
+            if(temp != NULL && found > 0)
+            {
+              strtodevsubsubtype(temp, ds);
+            }
+
            config_setting_lookup_string(device_settings, "devpath", &temp);
            ds->serialdevsettings.portdev = strdup(temp);

@@ -416,35 +834,116 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
            config_setting_lookup_int(device_settings, "motors", &motorposition);
            ds->serialdevsettings.motorsposition = motorposition;

+            int numlights = 6;
+            config_setting_lookup_int(device_settings, "numlights", &numlights);
+            ds->serialdevsettings.numlights = numlights;
+
+            int numleds = 6;
+            config_setting_lookup_int(device_settings, "numleds", &numleds);
+            ds->serialdevsettings.numleds = numleds;
+
+            int startled = 1;
+            config_setting_lookup_int(device_settings, "startled", &startled);
+            ds->serialdevsettings.startled = startled;
+
+            int endled = 1;
+            config_setting_lookup_int(device_settings, "endled", &endled);
+            ds->serialdevsettings.endled = endled;
+
+            int baud = 9600;
+            config_setting_lookup_int(device_settings, "baud", &baud);
+            ds->serialdevsettings.baud = baud;
+
            double ampfactor = 1.0;
            ds->serialdevsettings.ampfactor = 1.0;
-            int found = config_setting_lookup_float(device_settings, "ampfactor", &ampfactor);
-            if(found == 0)
-            {
-                ds->serialdevsettings.ampfactor = 1.0;
-            }
-            else
-            {
-                ds->serialdevsettings.ampfactor = ampfactor;
-                slogt("Set ampflication factor for motors to %f", ampfactor);
-            }
+            found = config_setting_lookup_float(device_settings, "ampfactor", &ampfactor);
+            ds->serialdevsettings.ampfactor = ampfactor;
+
+            slogt("set port baud rate to %i, ampfactor %f", baud, ampfactor);
+
        }

    }

+
    return error;
 }

+int uiloadconfig(const char* config_file_str, int confignum, int configureddevices, MonocoqueSettings* ms, DeviceSettings* ds)
+{
+    int numdevices = 0;
+    config_t cfg;
+    config_init(&cfg);
+    if (!config_read_file(&cfg, config_file_str))
+    {
+        fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
+    }
+    else
+    {
+        slogi("Parsing config file");
+
+        config_setting_t* config = NULL;
+        config = config_lookup(&cfg, "configs");
+        config_setting_t* selectedconfig = config_setting_get_elem(config, confignum);
+        config_setting_t* config_devices = NULL;
+        config_devices = config_setting_lookup(selectedconfig, "devices");
+
+        int i = 0;
+
+        int error = MONOCOQUE_ERROR_NONE;
+        while (i<configureddevices)
+        {
+            error = MONOCOQUE_ERROR_NONE;
+            DeviceSettings settings;
+
+            config_setting_t* config_device = config_setting_get_elem(config_devices, i);
+            const char* device_type = NULL;
+            const char* device_subtype = NULL;
+            const char* device_config_file = NULL;
+            int found = 0;
+            config_setting_lookup_string(config_device, "device", &device_type);
+            config_setting_lookup_string(config_device, "type", &device_subtype);
+            found = config_setting_lookup_string(config_device, "config", &device_config_file);
+
+            slogt("device type: %s", device_type);
+            slogt("device sub type: %s", device_subtype);
+            if(found == CONFIG_FALSE)
+            {
+                device_config_file = NULL;
+            }
+            else
+            {
+                slogt("device config file: %s", device_config_file);
+            }
+            if (error == MONOCOQUE_ERROR_NONE)
+            {
+                error = devsetup(device_type, device_subtype, device_config_file, ms, &settings, config_device);
+            }
+            if (error == MONOCOQUE_ERROR_NONE)
+            {
+                numdevices++;
+            }
+            ds[i] = settings;
+
+            i++;
+
+        }
+    }
+
+
+    config_destroy(&cfg);
+
+    return numdevices;
+}
+
 int settingsfree(DeviceSettings ds)
 {
-
-    if (ds.dev_subtype == SIMDEVTYPE_SIMWIND || ds.dev_subtype == SIMDEVTYPE_SHIFTLIGHTS)
+    if (ds.dev_type == SIMDEV_SERIAL)
    {
        if (ds.serialdevsettings.portdev != NULL)
        {
            free(ds.serialdevsettings.portdev);
        }
-
    }
    if (ds.dev_type == SIMDEV_SOUND)
    {
@@ -454,5 +953,30 @@ int settingsfree(DeviceSettings ds)
        }
    }

+    if(ds.has_config && ds.specific_config_file != NULL)
+    {
+        free(ds.specific_config_file);
+    }
+
    return 0;
 }
+
+int monocoquesettingsfree(MonocoqueSettings* ms)
+{
+    if(ms->tyre_diameter_config != NULL)
+    {
+        free(ms->tyre_diameter_config);
+    }
+    if(ms->config_str != NULL)
+    {
+        free(ms->config_str);
+    }
+    if(ms->log_filename_str != NULL)
+    {
+        free(ms->log_filename_str);
+    }
+    if(ms->log_dirname_str != NULL)
+    {
+        free(ms->log_dirname_str);
+    }
+}
@@ -9,6 +9,8 @@

 #include "parameters.h"

+#include "../devices/sounddevice.h"
+
 typedef enum
 {
    SIMDEV_UNKNOWN    = 0,
@@ -25,10 +27,28 @@ typedef enum
    SIMDEVTYPE_USBHAPTIC         = 2,
    SIMDEVTYPE_SHIFTLIGHTS       = 3,
    SIMDEVTYPE_SIMWIND           = 4,
-    SIMDEVTYPE_SERIALHAPTIC      = 5
+    SIMDEVTYPE_SERIALHAPTIC      = 5,
+    SIMDEVTYPE_USBWHEEL          = 6,
+    SIMDEVTYPE_SERIALWHEEL       = 7,
+    SIMDEVTYPE_SIMLED            = 8,
+    SIMDEVTYPE_ARDUINOCUSTOM     = 9
 }
 DeviceSubType;

+typedef enum
+{
+    SIMDEVSUBTYPE_UNKNOWN                 = 0,
+    SIMDEVSUBTYPE_CAMMUSC5                = 1,
+    SIMDEVSUBTYPE_CAMMUSC12               = 2,
+    SIMDEVSUBTYPE_MOZAR5                  = 3,
+    SIMDEVSUBTYPE_CSLELITEV3PEDALS        = 4,
+    SIMDEVSUBTYPE_SIMAGICP1000PEDALS      = 5,
+    SIMDEVSUBTYPE_SIMAGICGTNEO            = 6,
+    SIMDEVSUBTYPE_MOZA_NEW                = 7,
+    SIMDEVSUBTYPE_LOGITECH_G29            = 8
+}
+DeviceSubSubType;
+

 typedef enum
 {
@@ -47,7 +67,8 @@ typedef enum
    EFFECT_GEARSHIFT   = 1,
    EFFECT_ABSBRAKES   = 2,
    EFFECT_TYRESLIP    = 3,
-    EFFECT_TYRELOCK    = 4
+    EFFECT_TYRELOCK    = 4,
+    EFFECT_SUSPENSION  = 5
 }
 VibrationEffectType;

@@ -71,6 +92,21 @@ typedef enum
 }
 MotorPosition;

+typedef enum
+{
+    MONOCOQUE_GEAR_REVERSE = 0,
+    MONOCOQUE_GEAR_NEUTRAL = 1,
+    MONOCOQUE_GEAR_ONE     = 2,
+    MONOCOQUE_GEAR_TWO     = 3,
+    MONOCOQUE_GEAR_THREE   = 4,
+    MONOCOQUE_GEAR_FOUR    = 5,
+    MONOCOQUE_GEAR_FIVE    = 6,
+    MONOCOQUE_GEAR_SIX     = 7,
+    MONOCOQUE_GEAR_SEVEN   = 8,
+    MONOCOQUE_GEAR_EIGHT   = 9,
+}
+MonocoqueGear;
+
 typedef enum
 {
    MONOCOQUE_ERROR_NONE          = 0,
@@ -97,10 +133,17 @@ MonocoqueTyreIdentifier;
 typedef struct
 {
    ProgramAction program_action;
-    Simulator sim_name;
+    SimulatorAPI sim_name;
    int configcheck;
    int useconfig;
+    int verbosity_count;
+    int fps;
+    bool  force_udp_mode;
+    bool  disable_audio;
    char* tyre_diameter_config;
+    char* config_str;
+    char* log_filename_str;
+    char* log_dirname_str;
 }
 MonocoqueSettings;

@@ -117,20 +160,31 @@ TachometerSettings;
 typedef struct
 {
    char* portdev;
+
    MotorPosition motorsposition;
+    int numlights;
+    int numleds;
+    int startled;
+    int endled;
    float ampfactor;
+    int baud;
 }
 SerialDeviceSettings;

 typedef struct
 {
-    int frequency;
-    int volume;
+    uint32_t frequency;
+    uint32_t volume;
    int lowbound_frequency;
    int upperbound_frequency;
+    uint32_t frequencyMax;
+    uint32_t amplitudeMax;
+    uint32_t amplitude;
    int pan;
+    int channels;
    double duration;
    char* dev;
+    SoundEffectModulationType modulation;
 }
 SoundDeviceSettings;

@@ -145,19 +199,22 @@ USBDeviceSettings;
 typedef struct
 {
    bool is_valid;
+    int fps;
    DeviceType dev_type;
    DeviceSubType dev_subtype;
+    DeviceSubSubType dev_subsubtype;
    // to get really fancy move the effect information to it's own structure that would be a member of
    // any device settings member structure that can carry an effect
    VibrationEffectType effect_type;
    MonocoqueTyreIdentifier tyre;
    double threshold;
+    bool has_config;
+    char* specific_config_file;
    // union?
    TachometerSettings tachsettings;
    SerialDeviceSettings serialdevsettings;
    SoundDeviceSettings sounddevsettings;
    USBDeviceSettings usbdevsettings;
-
 }
 DeviceSettings;

@@ -167,6 +224,17 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co

 int settingsfree(DeviceSettings ds);

+int monocoquesettingsfree(MonocoqueSettings* ms);
+
 int strcicmp(char const *a, char const *b);

+int getconfigtouse2(const char* config_file_str, char* car, int sim);
+int getconfigtouse1(const char* config_file_str, char* car, int sim);
+int getconfigtouse(const char* config_file_str, char* car, int sim);
+
+int configcheck(const char* config_file_str, int confignum, int* devices);
+
+int uiloadconfig(const char* config_file_str, int confignum, int configureddevices, MonocoqueSettings* ms, DeviceSettings* ds);
+
+int getNumberOfConfigs(const char* config_file_str);
 #endif
@@ -13,24 +13,47 @@

 #include <string.h>

+void create_dir(char* dir)
+{
+    struct stat st = {0};
+    if (stat(dir, &st) == -1)
+    {
+        mkdir(dir, 0700);
+    }
+}
+
+void create_xdg_dir(const char* dir)
+{
+    struct stat st = {0};
+    if (stat(dir, &st) == -1)
+    {
+        mkdir(dir, 0700);
+    }
+}
+
+char* create_user_dir(char* home_dir_str, const char* dirtype, const char* programname)
+{
+    // +3 for slashes
+    size_t ss = (4 + strlen(home_dir_str) + strlen(dirtype) + strlen(programname));
+    char* config_dir_str = malloc(ss);
+
+    snprintf (config_dir_str, ss, "%s/%s/%s/", home_dir_str, dirtype, programname);
+
+    create_dir(config_dir_str);
+    return config_dir_str;
+}
+
 char* gethome()
 {
    char* homedir = getenv("HOME");
    return homedir;

-    if (homedir != NULL)
-    {
-        printf("Home dir in enviroment");
-        printf("%s\n", homedir);
-    }
-
    uid_t uid = getuid();
    struct passwd* pw = getpwuid(uid);

    if (pw == NULL)
    {
-        printf("Failed\n");
-        exit(EXIT_FAILURE);
+        return NULL;
    }

    return pw->pw_dir;
@@ -175,28 +198,94 @@ void restrict_folders_to_cache(char* path, int cachesize)

 }

-bool does_directory_exist(char* path, char* dirname)
+bool does_directory_exist(char* path)
 {
-    struct dirent* de;
-    DIR* dr = opendir(path);
-
-    if (dr == NULL)
+    DIR* dir = opendir(path);
+    if (dir)
    {
-        printf("Could not open current directory");
+        // Directory exists
+        closedir(dir);
+        return true;
+    }
+    else
+    {
+        // Directory does not exist or cannot be opened
        return false;
    }
-
-    // Refer http://pubs.opengroup.org/onlinepubs/7990989775/xsh/readdir.html
-    bool answer = false;
-    while ((de = readdir(dr)) != NULL)
-    {
-        if (strcmp(dirname,de->d_name) == 0)
-        {
-            answer = true;
-        }
-    }
-
-    closedir(dr);
-    return answer;
 }

+bool does_file_exist(const char* file)
+{
+    if (file == NULL)
+    {
+        return false;
+    }
+#if defined(OS_WIN)
+#if defined(WIN_API)
+    // if you want the WinAPI, versus CRT
+    if (strnlen(file, MAX_PATH+1) > MAX_PATH)
+    {
+        // ... throw error here or ...
+        return false;
+    }
+    DWORD res = GetFileAttributesA(file);
+    return (res != INVALID_FILE_ATTRIBUTES &&
+            !(res& FILE_ATTRIBUTE_DIRECTORY));
+#else
+    // Use Win CRT
+    struct stat fi;
+    if (_stat(file, &fi) == 0)
+    {
+#if defined(S_ISSOCK)
+        // sockets come back as a 'file' on some systems
+        // so make sure it's not a socket or directory
+        // (in other words, make sure it's an actual file)
+        return !(S_ISDIR(fi.st_mode)) &&
+               !(S_ISSOCK(fi.st_mode));
+#else
+        return !(S_ISDIR(fi.st_mode));
+#endif
+    }
+    return false;
+#endif
+#else
+    struct stat fi;
+    if (stat(file, &fi) == 0)
+    {
+#if defined(S_ISSOCK)
+        return !(S_ISDIR(fi.st_mode)) &&
+               !(S_ISSOCK(fi.st_mode));
+#else
+        return !(S_ISDIR(fi.st_mode));
+#endif
+    }
+    return false;
+#endif
+}
+
+char* expand_tilde(char* path) {
+    if (path[0] != '~') {
+        return path;
+    }
+
+    const char* home_dir = getenv("HOME");
+    if (!home_dir) {
+        return path;
+    }
+
+    size_t expanded_size = strlen(home_dir) + strlen(path);
+    char* expanded_path = (char*)malloc(expanded_size + 1);
+
+    if (!expanded_path) {
+        return path;
+    }
+
+    strcpy(expanded_path, home_dir);
+    strcat(expanded_path, path + 1);
+
+    if (path) {
+        free(path);
+    }
+
+    return expanded_path;
+}
@@ -3,10 +3,15 @@

 #include <stdbool.h>

+void create_dir(char* dir);
+void create_xdg_dir(const char* dir);
+char* create_user_dir(char* home_dir_str, const char* dirtype, const char* programpath);
 char* gethome();
 char* str2md5(const char* str, int length);
-bool does_directory_exist(char* path, char* dirname);
+bool does_directory_exist(char* path);
 void restrict_folders_to_cache(char* path, int cachesize);
 void delete_dir(char* path);
+bool does_file_exist(const char* file);
+char* expand_tilde(char* path);

 #endif
@@ -2,12 +2,39 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <libgen.h>

 #include <libconfig.h>

 #include <argtable2.h>
 #include <regex.h>

+int freeparams(Parameters* p)
+{
+
+    if(p->config_dirpath != NULL)
+    {
+        free(p->config_dirpath);
+    }
+    if(p->config_filepath != NULL)
+    {
+        free(p->config_filepath);
+    }
+    if(p->log_filename_str != NULL)
+    {
+        free(p->log_filename_str);
+    }
+    if(p->log_fullfilename_str != NULL)
+    {
+        free(p->log_fullfilename_str);
+    }
+    if(p->log_dirname_str != NULL)
+    {
+        free(p->log_dirname_str);
+    }
+    return 0;
+}
+
 ConfigError getParameters(int argc, char** argv, Parameters* p)
 {

@@ -17,6 +44,14 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
    p->program_action      = 0;
    p->max_revs            = 0;
    p->verbosity_count     = 0;
+    p->fps                 = 60;
+
+    p->disable_audio       = false;
+    p->udp                 = false;
+
+    p->user_specified_config_file = false;
+    p->user_specified_log_file = false;
+    p->user_specified_config_dir = false;

    // setup argument handling structures
    const char* progname = "monocoque";
@@ -26,11 +61,16 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
    struct arg_lit* arg_verbosity3   = arg_litn("v","verbose", 0, 2, "increase logging verbosity");

    struct arg_rex* cmd1             = arg_rex1(NULL, NULL, "play", NULL, REG_ICASE, NULL);
-    struct arg_str* arg_sim          = arg_strn("s", "sim", "<gamename>", 0, 1, NULL);
+    struct arg_lit* arg_udp          = arg_lit0("d", "udp", "force udp mode for sims which support it");
+    struct arg_lit* arg_audio1       = arg_lit0("a", "disable_audio", "force disable of audio devices");
+    struct arg_file* arg_conf        = arg_file0("c", "uiconf", "<config_file>", NULL);
+    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* vers             = arg_litn(NULL,"version", 0, 1, "print version information and exit");
    struct arg_end* end1             = arg_end(20);
-    void* argtable1[]                = {cmd1,arg_sim,arg_verbosity1,help,vers,end1};
+    void* argtable1[]                = {cmd1,arg_log,arg_conf,arg_fps,arg_udp,arg_audio1,arg_verbosity1,help,vers,end1};
    int nerrors1;

    struct arg_rex* cmd2a            = arg_rex1(NULL, NULL, "config", NULL, REG_ICASE, NULL);
@@ -45,10 +85,11 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
    int nerrors2;

    struct arg_rex* cmd3             = arg_rex1(NULL, NULL, "test", NULL, REG_ICASE, NULL);
+    struct arg_lit* arg_audio2       = arg_lit0("a", "disable_audio", "force disable of audio devices");
    struct arg_lit* help3            = arg_litn(NULL,"help", 0, 1, "print this help and exit");
    struct arg_lit* vers3            = arg_litn(NULL,"version", 0, 1, "print version information and exit");
    struct arg_end* end3             = arg_end(20);
-    void* argtable3[]                = {cmd3,arg_verbosity3,help3,vers3,end3};
+    void* argtable3[]                = {cmd3,arg_verbosity3,arg_audio2,help3,vers3,end3};
    int nerrors3;

    struct arg_lit*  help0           = arg_lit0(NULL,"help",     "print this help and exit");
@@ -73,8 +114,6 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
        goto cleanup;
    }

-    arg_granularity->ival[0] = 1;
-
    nerrors0 = arg_parse(argc,argv,argtable0);
    nerrors1 = arg_parse(argc,argv,argtable1);
    nerrors2 = arg_parse(argc,argv,argtable2);
@@ -83,8 +122,36 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
    if (nerrors1==0)
    {
        p->program_action = A_PLAY;
-        p->sim_string = arg_sim->sval[0];
        p->verbosity_count = arg_verbosity1->count;
+
+        if(arg_conf->count > 0)
+        {
+            p->config_filepath = strdup(arg_conf->filename[0]);
+            p->user_specified_config_file = true;
+        }
+        if (arg_udp->count > 0)
+        {
+            p->udp = true;
+        }
+        if (arg_audio1->count > 0)
+        {
+            p->disable_audio = true;
+        }
+        if(arg_fps->count > 0)
+        {
+            p->fps = arg_fps->ival[0];
+        }
+        if(arg_log->count > 0)
+        {
+            char* filename = strdup(arg_log->filename[0]);
+            p->log_fullfilename_str = strdup(arg_log->filename[0]);
+            p->log_filename_str = strdup(arg_log->basename[0]);
+            char* dname;
+            dname = dirname(filename);
+            p->log_dirname_str = strdup(dname);
+            p->user_specified_log_file = true;
+            free(filename);
+        }
        exitcode = E_SUCCESS_AND_DO;
    }
    else
@@ -105,6 +172,10 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
        {
            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
@@ -168,5 +239,4 @@ cleanup:
    arg_freetable(argtable2,sizeof(argtable2)/sizeof(argtable2[0]));
    arg_freetable(argtable3,sizeof(argtable3)/sizeof(argtable3[0]));
    return exitcode;
-
 }
@@ -9,12 +9,25 @@ typedef struct
    int   program_action;
    const char* sim_string;
    const char* save_file;
+    int fps;
    int max_revs;
    int granularity;
    int verbosity_count;

-    Simulator sim;
+    SimulatorAPI sim;
    bool simon;
+    bool  udp;
+    bool disable_audio;
+
+    char* config_filepath;
+    char* config_dirpath;
+    bool user_specified_config_file;
+    bool user_specified_config_dir;
+    bool user_specified_log_file;
+
+    char* log_filename_str;
+    char* log_fullfilename_str;
+    char* log_dirname_str;
 }
 Parameters;

@@ -35,6 +48,7 @@ typedef enum
 }
 ConfigError;

+int freeparams(Parameters* p);
 ConfigError getParameters(int argc, char** argv, Parameters* p);

 struct _errordesc
@@ -2,8 +2,9 @@
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <string.h>
-
+#include <basedir_fs.h>
 #include <libconfig.h>
+
 #include "gameloop/gameloop.h"
 #include "gameloop/tachconfig.h"
 #include "devices/simdevice.h"
@@ -14,27 +15,7 @@
 #include "simulatorapi/simapi/simapi/simdata.h"
 #include "slog/slog.h"

-
-int create_dir(char* dir)
-{
-    struct stat st = {0};
-    if (stat(dir, &st) == -1)
-    {
-        mkdir(dir, 0700);
-    }
-}
-
-char* create_user_dir(char* dirtype)
-{
-    char* home_dir_str = gethome();
-    char* config_dir_str = ( char* ) malloc(1 + strlen(home_dir_str) + strlen(dirtype) + strlen("monocoque/"));
-    strcpy(config_dir_str, home_dir_str);
-    strcat(config_dir_str, dirtype);
-    strcat(config_dir_str, "monocoque");
-
-    create_dir(config_dir_str);
-    free(config_dir_str);
-}
+#define PROGRAM_NAME "monocoque"

 void display_banner()
 {
@@ -45,42 +26,119 @@ void display_banner()
    printf("/_/  /_/  \\____/ /_/ |_/  \\____/ \\____/  \\____/ \\___\\_\\\\____/  /_____/   \n");
 }

+void SetSettingsFromParameters(Parameters* p, MonocoqueSettings* ms, char* configdir_str, char* cachedir_str)
+{
+
+    if(p->user_specified_config_file == true && does_file_exist(p->config_filepath))
+    {
+        ms->config_str = strdup(p->config_filepath);
+    }
+    else
+    {
+        if(p->user_specified_config_dir == true && does_directory_exist(p->config_dirpath))
+        {
+            asprintf(&ms->config_str, "%s/%s", p->config_dirpath, "monocoque.config");
+        }
+        else
+        {
+            asprintf(&ms->config_str, "%s%s", configdir_str, "monocoque.config");
+        }
+    }
+
+    if(p->user_specified_log_file == true && does_file_exist(p->log_fullfilename_str))
+    {
+        ms->log_dirname_str = strdup(p->log_dirname_str);
+        ms->log_filename_str = strdup(p->log_filename_str);
+    }
+    else
+    {
+        ms->log_dirname_str = strdup(cachedir_str);
+        ms->log_filename_str = strdup("monocoque.log");
+    }
+
+    ms->fps = p->fps;
+
+    ms->verbosity_count = p->verbosity_count;
+    ms->program_action = A_TEST;
+    if (p->program_action == A_PLAY)
+    {
+        ms->program_action = A_PLAY;
+    }
+    if (p->program_action == A_CONFIG_TACH)
+    {
+        ms->program_action = A_CONFIG_TACH;
+    }
+
+    ms->force_udp_mode = false;
+    ms->disable_audio = p->disable_audio;
+}
+
 int main(int argc, char** argv)
 {
    display_banner();

-    Parameters* p = malloc(sizeof(Parameters));
+    char* home_dir_str = gethome();
+    if(home_dir_str == NULL)
+    {
+        fprintf(stderr, "You need a home directory");
+        return 0;
+    }
+    Parameters* p = NULL;
+    p = malloc(sizeof(Parameters));
    MonocoqueSettings* ms = malloc(sizeof(MonocoqueSettings));;

    ConfigError ppe = getParameters(argc, argv, p);
-    if (ppe == E_SUCCESS_AND_EXIT)
+    if (ppe == E_SUCCESS_AND_EXIT || ppe == E_SOMETHING_BAD)
    {
+        printf("invalid parameters\n");
        goto cleanup_final;
    }
-    ms->program_action = p->program_action;

-    char* home_dir_str = gethome();
-    create_user_dir("/.config/");
-    create_user_dir("/.cache/");
-    char* config_file_str = ( char* ) malloc(1 + strlen(home_dir_str) + strlen("/.config/") + strlen("monocoque/monocoque.config"));
-    size_t diameters_file_sz = 1 + strlen(home_dir_str) + strlen("/.config/") + strlen("monocoque/diameters.config");
-    char* diameters_file_str = ( char* ) malloc(1 + strlen(home_dir_str) + strlen("/.config/") + strlen("monocoque/diameters.json"));
-    snprintf(diameters_file_str, diameters_file_sz, "%s/.config/monocoque/diameters.config", home_dir_str);
+    xdgHandle xdg;
+    if(!xdgInitHandle(&xdg))
+    {
+        fprintf(stderr, "Function xdgInitHandle() failed, is $HOME unset?\n");
+        goto cleanup_final;
+    }

-    char* cache_dir_str = ( char* ) malloc(1 + strlen(home_dir_str) + strlen("/.cache/monocoque/"));
-    strcpy(config_file_str, home_dir_str);
-    strcat(config_file_str, "/.config/");
-    strcpy(cache_dir_str, home_dir_str);
-    strcat(cache_dir_str, "/.cache/monocoque/");
-    strcat(config_file_str, "monocoque/monocoque.config");
+    const char* config_home_str = xdgConfigHome(&xdg);
+    const char* cache_home_str = xdgCacheHome(&xdg);

+    char* cachedir_str = NULL;
+    char* configdir_str = NULL;

+    if(p->user_specified_config_file == false && p->user_specified_config_dir == false)
+    {
+        create_xdg_dir(config_home_str);
+        configdir_str = create_user_dir(home_dir_str, ".config", PROGRAM_NAME);
+    }
+    if(p->user_specified_log_file == false)
+    {
+        create_xdg_dir(cache_home_str);
+        cachedir_str = create_user_dir(home_dir_str, ".cache", PROGRAM_NAME);
+    }
+
+    fprintf(stderr, "applying settings\n");
+    SetSettingsFromParameters(p, ms, configdir_str, cachedir_str);
+
+    if(cachedir_str != NULL)
+    {
+      free(cachedir_str);
+    }
+    if(configdir_str != NULL)
+    {
+      free(configdir_str);
+    }
+    fprintf(stderr, "settings applied\n");
+
+  
+    slog_init("monocoque", SLOG_FLAGS_ALL, 1);
    slog_config_t slgCfg;
    slog_config_get(&slgCfg);
    slgCfg.eColorFormat = SLOG_COLORING_TAG;
    slgCfg.eDateControl = SLOG_TIME_ONLY;
-    strcpy(slgCfg.sFileName, "monocoque.log");
-    strcpy(slgCfg.sFilePath, cache_dir_str);
+    strcpy(slgCfg.sFileName, ms->log_filename_str);
+    strcpy(slgCfg.sFilePath, ms->log_dirname_str);
    slgCfg.nTraceTid = 0;
    slgCfg.nToScreen = 1;
    slgCfg.nUseHeap = 0;
@@ -88,40 +146,51 @@ int main(int argc, char** argv)
    slgCfg.nFlush = 0;
    slgCfg.nFlags = SLOG_FLAGS_ALL;
    slog_config_set(&slgCfg);
-    if (p->verbosity_count < 2)
+    if (ms->verbosity_count < 2)
    {
        slog_disable(SLOG_TRACE);
    }
-    if (p->verbosity_count < 1)
+    if (ms->verbosity_count < 1)
    {
        slog_disable(SLOG_DEBUG);
    }
+    xdgWipeHandle(&xdg);

+    slogi("checking for diameters config");
+    char* diameters_file_str;
+    asprintf(&diameters_file_str, "%s/.config/monocoque/diameters.config", home_dir_str);
    ms->tyre_diameter_config = strdup(diameters_file_str);
-    ms->useconfig = 1;
-    ms->configcheck = 0;
    free(diameters_file_str);

-    slogi("Loading configuration file: %s", config_file_str);
+    ms->useconfig = 0;
+    ms->configcheck = 0;
+
+
+    slogi("Testing monocoque config file: %s", ms->config_str);
+    slogd("using diameters file %s %i", ms->tyre_diameter_config, ms->configcheck);
    config_t cfg;
    config_init(&cfg);
    config_setting_t* config_devices = NULL;
-    if (!config_read_file(&cfg, config_file_str))
+    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));
+        config_destroy(&cfg);
+        slog_destroy();
+        goto cleanup_final;
    }
    else
    {
-        slogi("Openend monocoque configuration file");
-        config_devices = config_lookup(&cfg, "devices");
+        slogi("Opened and validated monocoque configuration file");
    }
-    free(config_file_str);
-    free(cache_dir_str);
+    config_destroy(&cfg);

-    if (p->program_action == A_CONFIG_TACH)
+
+
+    if (ms->program_action == A_CONFIG_TACH)
    {
        int error = 0;
        SimDevice* tachdev = malloc(sizeof(SimDevice));
+        tachdev->initialized = false;
        SimData* sdata = malloc(sizeof(SimData));
        DeviceSettings* ds = malloc(sizeof(DeviceSettings));

@@ -134,6 +203,7 @@ int main(int argc, char** argv)
        else
        {
            int devices = 0;
+
            devices = devinit(tachdev, 1, ds, ms);
            if(devices < 1)
            {
@@ -165,65 +235,25 @@ int main(int argc, char** argv)
    {

        int error = 0;
-
-        int configureddevices = config_setting_length(config_devices);
-        int numdevices = 0;
-        DeviceSettings ds[configureddevices];
-        slogi("found %i devices in configuration", configureddevices);
-        int i = 0;
        error = MONOCOQUE_ERROR_NONE;
-        while (i<configureddevices)
-        {
-            DeviceSettings settings;
-
-            config_setting_t* config_device = config_setting_get_elem(config_devices, i);
-            const char* device_type;
-            const char* device_subtype;
-            const char* device_config_file;
-            config_setting_lookup_string(config_device, "device", &device_type);
-            config_setting_lookup_string(config_device, "type", &device_subtype);
-            config_setting_lookup_string(config_device, "config", &device_config_file);
-
-            //slogt("device type: %s", device_type);
-            //slogt("device sub type: %s", device_subtype);
-            //slogt("device config file: %s", device_config_file);
-            if (error == MONOCOQUE_ERROR_NONE)
-            {
-                error = devsetup(device_type, device_subtype, device_config_file, ms, &settings, config_device);
-            }
-            if (error == MONOCOQUE_ERROR_NONE)
-            {
-                numdevices++;
-            }
-            ds[i] = settings;
-
-            i++;
-
-        }
-
-        i = 0;
-        int j = 0;
-        error = MONOCOQUE_ERROR_NONE;
-
-        setupsound();
-        SimDevice* devices = malloc(numdevices * sizeof(SimDevice));
-        int initdevices = devinit(devices, configureddevices, ds, ms);
+        //setupsound();
        bool pulseaudio = false;

-        if (p->program_action == A_PLAY)
+        if (ms->program_action == A_PLAY)
        {
+            ms->useconfig = 1;
            slogi("running monocoque in gameloop mode..");
-            //error = strtogame(p->sim_string, ms);
-            //if (error != MONOCOQUE_ERROR_NONE)
-            //{
-            //    goto cleanup_final;
-            //}
-#ifdef USE_PULSEAUDIO
-            pa_threaded_mainloop_unlock(mainloop);
+//#ifdef USE_PULSEAUDIO
+            //pa_threaded_mainloop_unlock(mainloop);
            pulseaudio = true;
-#endif
+//#endif

-            error = looper(devices, numdevices, p);
+            if(ms->disable_audio == false)
+            {
+                setupsound();
+            }
+            //error = looper(devices, numdevices, p);
+            error = monocoque_mainloop(ms);
            if (error == MONOCOQUE_ERROR_NONE)
            {
                slogi("Game loop exited succesfully with error code: %i", error);
@@ -232,17 +262,38 @@ int main(int argc, char** argv)
            {
                sloge("Game loop exited with error code: %i", error);
            }
+            if(ms->disable_audio == false)
+            {
+                freesound();
+            }
        }
        else
        {
            slogi("running monocoque in test mode...");

-#ifdef USE_PULSEAUDIO
-            pa_threaded_mainloop_unlock(mainloop);
-            pulseaudio = true;
-#endif
+            if(ms->disable_audio == false)
+            {
+                setupsound();
+            }
+            ms->useconfig = 0;

-            error = tester(devices, numdevices);
+            int configs = getNumberOfConfigs(ms->config_str);
+            int confignum = getconfigtouse(ms->config_str, "default", configs-1);
+            int configureddevices;
+            configcheck(ms->config_str, confignum, &configureddevices);
+
+            DeviceSettings* ds = malloc(configureddevices * sizeof(DeviceSettings));
+            slogd("loading confignum %i, with %i devices.", confignum, configureddevices);
+
+            int numdevices = uiloadconfig(ms->config_str, confignum, configureddevices, ms, ds);
+            SimDevice* simdevices = malloc(numdevices * sizeof(SimDevice));
+            int initdevices = devinit(simdevices, configureddevices, ds, ms);
+            for( int i = 0; i < configureddevices; i++)
+            {
+                settingsfree(ds[i]);
+            }
+            free(ds);
+            error = tester(simdevices, numdevices);
            if (error == MONOCOQUE_ERROR_NONE)
            {
                slogi("Test exited succesfully with error code: %i", error);
@@ -251,44 +302,27 @@ int main(int argc, char** argv)
            {
                sloge("Test exited with error code: %i", error);
            }
-        }
-
-
-        for (int x = 0; x < numdevices; x++)
-        {
-            if (devices[x].initialized == true)
+            for (int x = 0; x < numdevices; x++)
            {
-                devices[x].free(&devices[x]);
+                if (simdevices[x].initialized == true)
+                {
+                    simdevices[x].free(&simdevices[x]);
+                }
+            }
+            if(ms->disable_audio == false)
+            {
+                freesound();
            }
        }
-        if(pulseaudio == true)
-        {
-            freesound();
-        }
-
-        i = 0;
-        // improve the api around the config helper
-        // i don't like that i stack allocated but hid a malloc inside
-        for( i = 0; i < configureddevices; i++)
-        {
-            settingsfree(ds[i]);
-        }
+        slog_destroy();
    }



-configcleanup:
-    config_destroy(&cfg);
-
 cleanup_final:
-
-    if(ms->tyre_diameter_config != NULL)
-    {
-        free(ms->tyre_diameter_config);
-    }
+    monocoquesettingsfree(ms);
    free(ms);
+    freeparams(p);
    free(p);
    exit(0);
 }
-
-
@@ -5,11 +5,27 @@ set(simulatorapi_source_files
  simapi/simapi/test.h
  simapi/include/acdata.h
  simapi/include/rf2data.h
+  simapi/include/pcars2data.h
+  simapi/include/dirt2data.h
+  simapi/include/scs2data.h
+  simapi/include/outgauge.h
  simapi/simmap/basicmap.h
  simapi/simmap/mapacdata.c
  simapi/simmap/mapacdata.h
  simapi/simapi/ac.h
  simapi/simapi/rf2.h
+  simapi/simapi/dirt2.h
+  simapi/simapi/pcars2.h
+  simapi/simapi/scs2.h
+  simapi/simapi/outgauge.h
+  simapi/simapi/mapping/acmapper.c
+  simapi/simapi/mapping/rf2mapper.c
+  simapi/simapi/mapping/pcars2mapper.c
+  simapi/simapi/mapping/dirt2mapper.c
+  simapi/simapi/mapping/scs2mapper.c
+  simapi/simapi/mapping/outgaugemapper.c
+  simapi/simapi/getpid.c
+  simapi/simapi/getpid.h
 )

 add_library(simulatorapi STATIC ${simulatorapi_source_files})
@@ -19,7 +19,7 @@ int main(int argc, char* argv[])
    pid = getpid();

    // get shared memory file descriptor (NOT a file)
-    fd = shm_open(TEST_MEM_FILE_LOCATION, O_RDONLY, S_IRUSR | S_IWUSR);
+    fd = shm_open(SIMAPI_MEM_FILE, O_RDONLY, S_IRUSR | S_IWUSR);
    if (fd == -1)
    {
        return 10;
@@ -21,7 +21,7 @@ int main(int argc, char* argv[])

    pid = getpid();

-    fd = shm_open(TEST_MEM_FILE_LOCATION, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+    fd = shm_open(SIMAPI_MEM_FILE, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
    if (fd == -1)
    {
        perror("open");
@@ -99,7 +99,7 @@ int main(int argc, char* argv[])
    }
    tcsetattr(0, TCSANOW, &canonicalmode);

-    fd = shm_unlink(TEST_MEM_FILE_LOCATION);
+    fd = shm_unlink(SIMAPI_MEM_FILE);
    if (fd == -1)
    {
        perror("unlink");
@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/shm.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <errno.h>
+
+void display(char* prog, char* bytes, int n);
+
+int main(void)
+{
+    const char* name = "acpmf_physics";    // file name
+
+    shm_unlink(name);
+}
+
@@ -1,81 +1,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <string.h>
 #include <libserialport.h>
-#include "../src/monocoque/simulatorapi/simapi/simapi/simdata.h"
-
-/* Helper function for error handling. */
-int check(enum sp_return result);
-
-int main()
-{
-    SimData sd;
-    sd.maxrpm = 6500;
-    sd.rpms = 0;
-    sd.altitude = 10;
-    sd.gear = 1;
-    sd.velocity = 74;
-
-    char* port_name = "/dev/ttyACM0";
-
-    /* The ports we will use. */
-    struct sp_port* port;
-
-    /* Open and configure each port. */
-    printf("Looking for port %s.\n", port_name);
-    check(sp_get_port_by_name(port_name, &port));
-
-    printf("Opening port.\n");
-    check(sp_open(port, SP_MODE_READ_WRITE));
-
-    printf("Setting port to 9600 8N1, no flow control.\n");
-    check(sp_set_baudrate(port, 9600));
-    check(sp_set_bits(port, 8));
-    check(sp_set_parity(port, SP_PARITY_NONE));
-    check(sp_set_stopbits(port, 1));
-    check(sp_set_flowcontrol(port, SP_FLOWCONTROL_NONE));
-
-    while ( sd.rpms <= sd.maxrpm )
-    {
-
-
-        unsigned int timeout = 2000;
-
-        /* On success, sp_blocking_write() and sp_blocking_read()
-         * return the number of bytes sent/received before the
-        * timeout expired. We'll store that result here. */
-        int result;
-        int size = sizeof(SimData);
-
-        /* Send data. */
-        result = check(sp_blocking_write(port, &sd, size, timeout));
-
-        /* Check whether we sent all of the data. */
-        if (result == size)
-        {
-            printf("Sent %d bytes successfully, %i rpm.\n", size, sd.rpms);
-        }
-        else
-        {
-            printf("Timed out, %d/%d bytes sent.\n", result, size);
-        }
-
-        sd.rpms += 1000;
-        if ( sd.rpms == sd.maxrpm + 1000 )
-        {
-            sd.rpms = 0;
-        }
-        if ( sd.rpms > sd.maxrpm )
-        {
-            sd.rpms = sd.maxrpm;
-        }
-
-        sleep(1);
-    }
-
-    check(sp_close(port));
-    sp_free_port(port);
-}
+#include "../src/arduino/shiftlights/shiftlights.h"

 /* Helper function for error handling. */
 int check(enum sp_return result)
@@ -104,3 +32,209 @@ int check(enum sp_return result)
            return result;
    }
 }
+
+
+int WaitForEventOnPort(struct sp_port* port, int event)
+{
+    int retval;
+    struct sp_event_set* eventSet = NULL;
+
+    retval = sp_new_event_set(&eventSet);
+    if (retval == SP_OK)
+    {
+        retval = sp_add_port_events(eventSet, port, event);
+        if (retval == SP_OK)
+        {
+            printf("set event on port\n");
+            retval = sp_wait(eventSet, 5000);
+        }
+        else
+        {
+            puts("Unable to add events to port.");
+            retval = -1;
+        }
+    }
+    else
+    {
+        puts("Unable to create new event set.");
+        retval = -1;
+    }
+    sp_free_event_set(eventSet);
+
+    return retval;
+}
+
+// the input event waiting and flushing is the right way to do this
+// most of the time i'm just "bit blasting" and the only receiving
+// happens initially to get the number of lights
+int ReadFromPort(struct sp_port* port, int* numlights)
+{
+    int count = 0;
+    int bytesWaiting;
+    char buf[256];
+    int retval = 0;
+    int i;
+
+    sp_flush(port, SP_BUF_INPUT);
+
+    while (count < 4)
+    {
+        printf("Attempting to retrieve num lights from port...\n");
+
+        size_t bufsize1 = 11;
+        size_t recv_bufsize1 = 5;
+        char recv_buf1[recv_bufsize1];
+        char bytes1[bufsize1];
+
+        for(int j = 0; j < bufsize1; j++)
+        {
+            bytes1[j] = 0x00;
+        }
+        bytes1[0] = 0xff;
+        bytes1[1] = 0xff;
+        bytes1[2] = 0xff;
+        bytes1[3] = 0xff;
+        bytes1[4] = 0xff;
+        bytes1[5] = 0xff;
+        bytes1[6] = 0x6c;
+        bytes1[7] = 0x65;
+        bytes1[8] = 0x64;
+        bytes1[9] = 0x73;
+        bytes1[10] = 0x63;
+
+        int result = 0;
+        unsigned int timeout = 6000;
+        printf("Sending message to get num lights\n");
+        WaitForEventOnPort(port, 6);
+
+        result = check(sp_blocking_write(port, &bytes1, bufsize1, timeout));
+
+        printf("Attempting to receive response\n");
+
+
+        WaitForEventOnPort(port, 5);
+        bytesWaiting = sp_input_waiting(port);
+        if (bytesWaiting > 0)
+        {
+            memset(buf, 0, sizeof(buf));
+            //printf("bytes found on port\n");
+            retval = sp_blocking_read(port, buf, sizeof(buf)-1, 10);
+            if (retval < 0)
+            {
+                printf("Error reading from serial port: %d\r\n", retval);
+                retval = -1;
+                break;
+            }
+            else
+            {
+                for(i=0; i<retval; i++)
+                {
+                    printf("%c", buf[i]);
+                    if (buf[i] == 13)
+                    {
+                        count++;
+                    }
+                }
+                int ret = atoi(buf);
+                *numlights = ret;
+                return retval;
+            }
+        }
+        else
+            if (bytesWaiting < 0)
+            {
+                printf("Error getting bytes available from serial port: %d\r\n", bytesWaiting);
+                retval = -1;
+                break;
+            }
+        printf("didn't get nothing\n");
+        //count++;
+        retval = 0;
+    }
+    return retval;
+}
+
+int main()
+{
+
+    char* port_name = "/dev/ttyACM0";
+
+    /* The ports we will use. */
+    struct sp_port* port;
+
+    /* Open and configure each port. */
+    printf("Looking for port %s.\n", port_name);
+    check(sp_get_port_by_name(port_name, &port));
+    printf("Using %s\r\n", sp_get_port_name(port));
+    printf("Opening port.\n");
+    check(sp_open(port, SP_MODE_READ | SP_MODE_WRITE));
+
+    printf("Setting port to 115200 8N1, no flow control.\n");
+    check(sp_set_baudrate(port, 115200));
+    check(sp_set_bits(port, 8));
+    check(sp_set_parity(port, SP_PARITY_NONE));
+    check(sp_set_stopbits(port, 1));
+    check(sp_set_flowcontrol(port, SP_FLOWCONTROL_NONE));
+    check(sp_set_rts(port, 1));
+    check(sp_set_dtr(port, 1));
+
+    ShiftLightsData sd;
+
+    int result = 0;
+    int numlights =  0;
+    result = ReadFromPort(port, &numlights);
+
+    int timeout = 2000;
+    size_t bufsize = (numlights * 3) + 14;
+    char bytes[bufsize];
+    for(int j = 0; j < bufsize; j++)
+    {
+        bytes[j] = 0x00;
+    }
+    bytes[0] = 0xff;
+    bytes[1] = 0xff;
+    bytes[2] = 0xff;
+    bytes[3] = 0xff;
+    bytes[4] = 0xff;
+    bytes[5] = 0xff;
+    bytes[6] = 0x73;
+    bytes[7] = 0x6c;
+    bytes[8] = 0x65;
+    bytes[9] = 0x64;
+    bytes[10] = 0x73;
+    bytes[bufsize-1] = 0xfd;
+    bytes[bufsize-2] = 0xfe;
+    bytes[bufsize-3] = 0xff;
+
+
+    for( int i = 0; i < numlights; i++)
+    {
+        bytes[(i * 3) + 11 + 1] = 0xff;
+
+        /* Send data. */
+        result = check(sp_blocking_write(port, &bytes, bufsize, timeout));
+
+        /* Check whether we sent all of the data. */
+        if (result == bufsize)
+        {
+            printf("Sent %d bytes successfully, %i lit leds.\n", bufsize, numlights);
+        }
+        else
+        {
+            printf("Timed out, %d/%d bytes sent.\n", result, bufsize);
+        }
+
+
+        sleep(2);
+    }
+    for( int i = 0; i < numlights; i++)
+    {
+        bytes[(i * 3) + 11 + 1] = 0x00;
+    }
+    result = check(sp_blocking_write(port, &bytes, bufsize, timeout));
+
+    check(sp_close(port));
+    sp_free_port(port);
+}
+
+
@@ -0,0 +1,47 @@
+# Maintainer: Paul Jones <paul@spacefreak18.xyz>
+_reponame=monocoque
+pkgname=monocoque-git
+pkgver=0.1.0r94
+pkgrel=2
+pkgdesc="Device Manager for Racing Sims"
+arch=('x86_64')
+url="https://github.com/spacefreak18/monocoque"
+license=('GPL3')
+depends=(
+        hidapi
+	libserialport
+	libxml2
+	argtable
+	libconfig
+	libpulse
+	libxdg-basedir
+	libuv
+)
+makedepends=(
+  git
+  cmake
+)
+source=(
+  git+https://github.com/spacefreak18/monocoque
+)
+sha256sums=(
+  'SKIP'
+)
+
+pkgver() {
+  cd "$srcdir/$_reponame"
+  git describe --long --tags | cut -d "-" -f 1-2 | tr "-" "r"
+}
+
+package() {
+  cd "$srcdir/$_reponame" || exit 1
+  git submodule sync --recursive
+  git submodule update --init --recursive
+  mkdir -p build
+  cd build
+  cmake -DUSE_PULSEAUDIO=yes ..
+  make
+
+  mkdir -p "${pkgdir}/usr/bin/"
+  cp "$srcdir/$_reponame"/build/$_reponame "${pkgdir}/usr/bin/$_reponame"
+}
@@ -0,0 +1,44 @@
+# Maintainer: Paul Jones <paul@spacefreak18.xyz>
+_reponame=monocoque
+pkgname=monocoque
+pkgver=0.2.0
+pkgrel=4
+pkgdesc="Device Manager for Racing Sims"
+arch=('x86_64')
+url="https://github.com/spacefreak18/monocoque"
+license=('GPL3')
+_commit=12509e9709871afcb3ae264823b4a7d3c3b71bf7
+depends=(
+        hidapi
+	libserialport
+	libxml2
+	argtable
+	libconfig
+	libpulse
+	libxdg-basedir
+	libuv
+)
+makedepends=(
+  git
+  cmake
+)
+
+source=("git+https://github.com/spacefreak18/monocoque.git#commit=$_commit")
+
+sha256sums=(
+  'SKIP'
+)
+
+package() {
+  cd "$srcdir/$_reponame" || exit 1
+  git submodule sync --recursive
+  git submodule update --init --recursive
+  mkdir -p build
+  cd build
+  cmake -Wno-dev -DUSE_PULSEAUDIO=yes ..
+  make
+
+  mkdir -p "${pkgdir}/usr/bin/"
+  cp "$srcdir/$_reponame"/build/monocoque "${pkgdir}/usr/bin/monocoque"
+  install -D -m644 "$srcdir/$_reponame"/LICENSE.rst -t "${pkgdir}/usr/share/licenses/$_reponame"
+}
@@ -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
@@ -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
@@ -0,0 +1,616 @@
+#!/usr/bin/env python3
+"""
+Monocoque Manager - Simple TUI for managing monocoque telemetry system
+"""
+
+import subprocess
+import sys
+import os
+import time
+from pathlib import Path
+
+try:
+    import curses
+except ImportError:
+    print("Error: curses module not available")
+    sys.exit(1)
+
+# Constants to avoid magic numbers
+MIN_TERMINAL_HEIGHT = 20
+MIN_TERMINAL_WIDTH = 60
+PROCESS_STOP_WAIT_TIME = 1  # seconds
+SIMD_START_DELAY = 2  # seconds
+
+
+class MonocoqueManager:
+    def __init__(self):
+        # Mirror the shell script's robust path detection
+        xdg_data = os.environ.get('XDG_DATA_HOME', os.path.join(Path.home(), ".local/share"))
+        self.install_dir = Path(os.environ.get('MONOCOQUE_INSTALL_DIR', os.path.join(xdg_data, "monocoque")))
+        
+        xdg_config = os.environ.get('XDG_CONFIG_HOME', os.path.join(Path.home(), ".config"))
+        self.config_dir = Path(xdg_config)
+        
+        self.simd_running = False
+        self.monocoque_running = False
+        self.last_cleaned_pid_files = []  # Track cleaned stale PID files
+        
+    def check_processes(self):
+        """Check if simd and monocoque are running using careful detection"""
+        try:
+            manager_pid = os.getpid()  # Our own PID to exclude
+            
+            # Method 1: Exact name matching (safest)
+            result = subprocess.run(['pgrep', '-x', 'simd'], 
+                                  capture_output=True, text=True)
+            simd_exact = bool(result.stdout.strip())
+            
+            result = subprocess.run(['pgrep', '-x', 'monocoque'], 
+                                  capture_output=True, text=True)
+            monocoque_exact = bool(result.stdout.strip())
+            
+            # Method 2: Careful process scanning
+            simd_found = False
+            monocoque_found = False
+            
+            ps_result = subprocess.run(['ps', 'axo', 'pid,comm,args'], 
+                                     capture_output=True, text=True)
+            if ps_result.returncode == 0:
+                for line in ps_result.stdout.split('\n')[1:]:  # Skip header
+                    parts = line.strip().split(None, 2)
+                    if len(parts) >= 3:
+                        pid, comm, args = parts
+                        
+                        # Skip our own process
+                        if pid == str(manager_pid):
+                            continue
+                        
+                        # Look for simd executable
+                        if (comm == 'simd' or 
+                            (comm.endswith('simd') and 'manager' not in comm) or
+                            ('/simd' in args and 'manager' not in args)):
+                            simd_found = True
+                        
+                        # Look for monocoque executable (not manager)
+                        elif ((comm == 'monocoque' or 
+                               (comm.endswith('monocoque') and 'manager' not in comm)) and
+                              'manager' not in args and
+                              'monocoque-manager' not in args and
+                              'python' not in args):
+                            monocoque_found = True
+            
+            # Set final status
+            self.simd_running = simd_exact or simd_found
+            self.monocoque_running = monocoque_exact or monocoque_found
+            
+            # Check for stale PID files and clean them up
+            self.cleanup_stale_pid_files()
+            
+        except Exception:
+            # Fallback: set both to False if detection fails
+            self.simd_running = False
+            self.monocoque_running = False
+    
+    def cleanup_stale_pid_files(self):
+        """Clean up stale PID files when processes aren't actually running"""
+        pid_files = [
+            ('/tmp/simd.pid', self.simd_running),
+            ('/tmp/monocoque.pid', self.monocoque_running),
+        ]
+        
+        cleaned_files = []
+        
+        for pid_file_path, process_running in pid_files:
+            if os.path.exists(pid_file_path) and not process_running:
+                try:
+                    # Read the PID and check if that process exists
+                    with open(pid_file_path, 'r') as f:
+                        pid_str = f.read().strip()
+                    
+                    if pid_str.isdigit():
+                        pid = int(pid_str)
+                        # Check if this PID actually exists and is the right process
+                        try:
+                            ps_result = subprocess.run(['ps', '-p', str(pid), '-o', 'comm='], 
+                                                     capture_output=True, text=True)
+                            if ps_result.returncode != 0:
+                                # Process doesn't exist, PID file is stale
+                                os.remove(pid_file_path)
+                                cleaned_files.append(os.path.basename(pid_file_path))
+                            else:
+                                # Process exists, check if it's actually simd/monocoque
+                                comm = ps_result.stdout.strip()
+                                service_name = os.path.basename(pid_file_path).replace('.pid', '')
+                                if service_name not in comm:
+                                    # Wrong process, PID file is stale
+                                    os.remove(pid_file_path)
+                                    cleaned_files.append(os.path.basename(pid_file_path))
+                        except:
+                            # Error checking process, assume stale and remove
+                            os.remove(pid_file_path)
+                            cleaned_files.append(os.path.basename(pid_file_path))
+                    else:
+                        # Invalid PID format, remove stale file
+                        os.remove(pid_file_path)
+                        cleaned_files.append(os.path.basename(pid_file_path))
+                        
+                except Exception:
+                    # Error reading/processing PID file, try to remove it
+                    try:
+                        os.remove(pid_file_path)
+                        cleaned_files.append(os.path.basename(pid_file_path))
+                    except:
+                        pass
+        
+        # Store cleaned files for potential user feedback
+        self.last_cleaned_pid_files = cleaned_files
+        return cleaned_files
+    
+    def check_installation(self):
+        """Check if monocoque is installed"""
+        simd_exists = (self.install_dir / "simapi/simd/build/simd").exists() or \
+                      subprocess.run(['which', 'simd'], capture_output=True).returncode == 0
+        monocoque_exists = (self.install_dir / "monocoque/build/monocoque").exists() or \
+                          subprocess.run(['which', 'monocoque'], capture_output=True).returncode == 0
+        
+        return simd_exists and monocoque_exists
+    
+    def draw_header(self, stdscr):
+        """Draw header"""
+        height, width = stdscr.getmaxyx()
+        title = "Monocoque Manager"
+        stdscr.attron(curses.color_pair(2) | curses.A_BOLD)
+        stdscr.addstr(0, (width - len(title)) // 2, title)
+        stdscr.attroff(curses.color_pair(2) | curses.A_BOLD)
+        stdscr.addstr(1, 0, "─" * width)
+    
+    def draw_status(self, stdscr, row):
+        """Draw status section"""
+        self.check_processes()
+        
+        stdscr.attron(curses.A_BOLD)
+        stdscr.addstr(row, 2, "Status:")
+        stdscr.attroff(curses.A_BOLD)
+        
+        # simd status
+        status_str = "● simd:      "
+        stdscr.addstr(row + 1, 4, status_str)
+        if self.simd_running:
+            stdscr.attron(curses.color_pair(1))
+            stdscr.addstr("RUNNING")
+            stdscr.attroff(curses.color_pair(1))
+        else:
+            stdscr.attron(curses.color_pair(3))
+            stdscr.addstr("STOPPED")
+            stdscr.attroff(curses.color_pair(3))
+        
+        # monocoque status
+        status_str = "● monocoque: "
+        stdscr.addstr(row + 2, 4, status_str)
+        if self.monocoque_running:
+            stdscr.attron(curses.color_pair(1))
+            stdscr.addstr("RUNNING")
+            stdscr.attroff(curses.color_pair(1))
+        else:
+            stdscr.attron(curses.color_pair(3))
+            stdscr.addstr("STOPPED")
+            stdscr.attroff(curses.color_pair(3))
+        
+        # Show notification about cleaned PID files
+        current_row = row + 3
+        if self.last_cleaned_pid_files:
+            cleaned_msg = f"● Cleaned stale PID files: {', '.join(self.last_cleaned_pid_files)}"
+            stdscr.attron(curses.color_pair(4))
+            stdscr.addstr(current_row, 4, cleaned_msg)
+            stdscr.attroff(curses.color_pair(4))
+            current_row += 1
+            # Clear the notification after showing it once
+            self.last_cleaned_pid_files = []
+        
+        return current_row
+    
+    def draw_menu(self, stdscr, row, selected):
+        """Draw menu options"""
+        height, width = stdscr.getmaxyx()
+        
+        stdscr.addstr(row, 0, "─" * width)
+        row += 1
+        
+        stdscr.attron(curses.A_BOLD)
+        stdscr.addstr(row, 2, "Actions:")
+        stdscr.attroff(curses.A_BOLD)
+        row += 1
+        
+        menu_items = [
+            ("1", "Start simd", not self.simd_running),
+            ("2", "Start monocoque", not self.monocoque_running and self.simd_running),
+            ("3", "Test configuration", True),
+            ("4", "Edit monocoque config", True),
+            ("5", "View logs", True),
+            ("6", "Restart services", self.simd_running or self.monocoque_running),
+            ("7", "Stop all", self.simd_running or self.monocoque_running),
+            ("0", "Quit", True),
+        ]
+        
+        for i, (key, label, enabled) in enumerate(menu_items):
+            if enabled:
+                if i == selected:
+                    stdscr.attron(curses.A_REVERSE)
+                stdscr.addstr(row + i, 4, f"[{key}] {label}")
+                if i == selected:
+                    stdscr.attroff(curses.A_REVERSE)
+            else:
+                stdscr.attron(curses.color_pair(4))
+                stdscr.addstr(row + i, 4, f"[{key}] {label}")
+                stdscr.attroff(curses.color_pair(4))
+        
+        return row + len(menu_items)
+    
+    def get_enabled_menu_items(self):
+        """Get list of currently enabled menu items with their indices"""
+        menu_items = [
+            ("1", "Start simd", not self.simd_running),
+            ("2", "Start monocoque", not self.monocoque_running and self.simd_running),
+            ("3", "Test configuration", True),
+            ("4", "Edit monocoque config", True),
+            ("5", "View logs", True),
+            ("6", "Restart services", self.simd_running or self.monocoque_running),
+            ("7", "Stop all", self.simd_running or self.monocoque_running),
+            ("0", "Quit", True),
+        ]
+        
+        enabled_items = []
+        for i, (key, label, enabled) in enumerate(menu_items):
+            if enabled:
+                enabled_items.append((i, key))
+        return enabled_items
+    
+    def draw_footer(self, stdscr):
+        """Draw footer"""
+        height, width = stdscr.getmaxyx()
+        footer = "↑↓/j/k: Navigate | Enter: Select | Numbers: Direct | q/ESC: Quit"
+        stdscr.addstr(height - 2, 0, "─" * width)
+        stdscr.attron(curses.color_pair(4))
+        stdscr.addstr(height - 1, (width - len(footer)) // 2, footer)
+        stdscr.attroff(curses.color_pair(4))
+    
+    def run_command(self, cmd, terminal=True):
+        """Run a command"""
+        if terminal:
+            # Try to find a terminal emulator
+            terminals = ['konsole', 'gnome-terminal', 'xfce4-terminal', 
+                        'alacritty', 'kitty', 'xterm']
+            
+            for term in terminals:
+                if subprocess.run(['which', term], capture_output=True).returncode == 0:
+                    if term == 'konsole':
+                        subprocess.Popen([term, '-e', 'bash', '-c', cmd])
+                    elif term == 'gnome-terminal':
+                        subprocess.Popen([term, '--', 'bash', '-c', cmd])
+                    elif term == 'kitty':
+                        # Kitty prefers commands as positional arguments
+                        subprocess.Popen([term, 'bash', '-c', cmd])
+                    elif term in ['xfce4-terminal', 'alacritty', 'xterm']:
+                        # Ensure the whole bash command is quoted correctly for -e
+                        subprocess.Popen([term, '-e', f"bash -c '{cmd}'"])
+                    return True
+            return False
+        else:
+            subprocess.run(cmd, shell=True)
+            return True
+    
+    def handle_action(self, action):
+        """Handle menu action"""
+        if action == '1':  # Start simd
+            cmd = "start-simd || $HOME/.local/bin/start-simd; exec bash"
+            self.run_command(cmd)
+            
+        elif action == '2':  # Start monocoque
+            cmd = "start-monocoque || $HOME/.local/bin/start-monocoque; exec bash"
+            self.run_command(cmd)
+            
+        elif action == '3':  # Test configuration
+            cmd = "test-monocoque || $HOME/.local/bin/test-monocoque; read -p 'Press Enter to close...'"
+            self.run_command(cmd)
+            
+        elif action == '4':  # Edit config
+            editor = os.environ.get('EDITOR', 'nano')
+            config_file = self.config_dir / "monocoque/monocoque.config"
+            subprocess.run([editor, str(config_file)])
+            
+        elif action == '5':  # View logs
+            xdg_cache = os.environ.get('XDG_CACHE_HOME', os.path.join(Path.home(), ".cache"))
+            log_dir = Path(xdg_cache) / "monocoque"
+            if log_dir.exists():
+                cmd = f"find {log_dir} -name '*.log' -exec ls -la {{}} + 2>/dev/null; find {log_dir} -name '*.log' -exec tail -f {{}} + 2>/dev/null; read -p 'Press Enter to close...'"
+                self.run_command(cmd)
+            else:
+                # Create a simple message if no logs exist
+                cmd = f"echo 'No log directory found at {log_dir}'; echo 'Logs will appear here when monocoque runs'; read -p 'Press Enter to close...'"
+                self.run_command(cmd)
+            
+        elif action == '6':  # Restart services
+            stopped = self.stop_all_services()
+            if stopped:
+                print(f"Stopped: {', '.join(stopped)}")
+            # Wait a moment for processes to stop
+            time.sleep(PROCESS_STOP_WAIT_TIME)
+            # Restart simd first
+            cmd = f"start-simd || $HOME/.local/bin/start-simd; sleep {SIMD_START_DELAY}; start-monocoque || $HOME/.local/bin/start-monocoque; exec bash"
+            self.run_command(cmd)
+            print("Restarting services in terminal window...")
+            
+        elif action == '7':  # Stop all
+            stopped = self.stop_all_services()
+            if stopped:
+                print(f"Stopped: {', '.join(stopped)}")
+            else:
+                print("No running services found to stop")
+    
+    def stop_all_services(self):
+        """Carefully stop simd and monocoque processes while preserving the manager"""
+        stopped_services = []
+        manager_pid = os.getpid()  # Get our own PID to exclude it
+        
+        # Method 1: Try exact name matching (safest)
+        for service in ['simd', 'monocoque']:
+            result = subprocess.run(['pkill', '-x', service], 
+                                  capture_output=True, text=True)
+            if result.returncode == 0:
+                stopped_services.append(f"{service} (exact)")
+        
+        # Method 2: Carefully search ps output and target specific processes
+        try:
+            ps_result = subprocess.run(['ps', 'axo', 'pid,ppid,comm,args'], 
+                                     capture_output=True, text=True)
+            if ps_result.returncode == 0:
+                lines = ps_result.stdout.split('\n')[1:]  # Skip header
+                for line in lines:
+                    parts = line.strip().split(None, 3)  # Split into PID, PPID, COMM, ARGS
+                    if len(parts) >= 4:
+                        pid, ppid, comm, args = parts
+                        
+                        # Skip our own process
+                        if pid == str(manager_pid):
+                            continue
+                        
+                        # Target simd: look for executables ending in 'simd' or containing '/simd'
+                        if (comm == 'simd' or 
+                            (comm.endswith('simd') and not 'manager' in comm) or
+                            ('/simd' in args and 'manager' not in args)):
+                            try:
+                                subprocess.run(['kill', '-TERM', pid], capture_output=True)
+                                stopped_services.append(f"simd (PID {pid})")
+                                time.sleep(0.1)  # Brief pause between kills
+                            except:
+                                pass
+                        
+                        # Target monocoque: be very specific to avoid manager
+                        elif ((comm == 'monocoque' or 
+                               (comm.endswith('monocoque') and not 'manager' in comm)) and
+                              'manager' not in args and
+                              'monocoque-manager' not in args and
+                              'python' not in args):  # Avoid Python scripts
+                            try:
+                                subprocess.run(['kill', '-TERM', pid], capture_output=True)
+                                stopped_services.append(f"monocoque (PID {pid})")
+                                time.sleep(0.1)  # Brief pause between kills
+                            except:
+                                pass
+        except:
+            pass
+        
+        # Wait for graceful shutdown
+        time.sleep(PROCESS_STOP_WAIT_TIME)
+        
+        # Method 3: Force kill stubborn processes (but still be careful)
+        try:
+            # Only force kill exact matches, never pattern matches
+            for service in ['simd', 'monocoque']:
+                subprocess.run(['pkill', '-9', '-x', service], 
+                              capture_output=True, text=True)
+        except:
+            pass
+        
+        return stopped_services
+    
+    def main(self, stdscr):
+        """Main TUI loop"""
+        try:
+            curses.curs_set(0)
+        except curses.error:
+            pass  # Some terminals don't support cursor visibility changes
+        
+        try:
+            stdscr.keypad(True)  # Enable keypad mode for arrow keys
+        except curses.error:
+            pass  # Fallback if keypad mode fails
+            
+        # Initialize colors if available
+        if curses.has_colors():
+            curses.start_color()
+            try:
+                curses.init_pair(1, curses.COLOR_GREEN, curses.COLOR_BLACK)
+                curses.init_pair(2, curses.COLOR_CYAN, curses.COLOR_BLACK)
+                curses.init_pair(3, curses.COLOR_RED, curses.COLOR_BLACK)
+                curses.init_pair(4, curses.COLOR_YELLOW, curses.COLOR_BLACK)
+            except curses.error:
+                pass  # Fallback for terminals with limited color support
+        
+        selected = 0
+        
+        while True:
+            stdscr.clear()
+            height, width = stdscr.getmaxyx()
+            
+            # Ensure selected index is valid for current state
+            self.check_processes()
+            enabled_items = self.get_enabled_menu_items()
+            enabled_indices = [item[0] for item in enabled_items]
+            if enabled_indices and selected not in enabled_indices:
+                selected = enabled_indices[0]
+            
+            if height < MIN_TERMINAL_HEIGHT or width < MIN_TERMINAL_WIDTH:
+                stdscr.addstr(0, 0, "Terminal too small!")
+                stdscr.addstr(1, 0, f"Minimum: {MIN_TERMINAL_WIDTH}x{MIN_TERMINAL_HEIGHT}")
+                stdscr.refresh()
+                stdscr.getch()
+                continue
+            
+            self.draw_header(stdscr)
+            row = self.draw_status(stdscr, 3)
+            row = self.draw_menu(stdscr, row + 1, selected)
+            self.draw_footer(stdscr)
+            
+            stdscr.refresh()
+            
+            key = stdscr.getch()
+            
+            # Get currently enabled menu items
+            enabled_items = self.get_enabled_menu_items()
+            enabled_indices = [item[0] for item in enabled_items]
+            
+            # Handle arrow key navigation (with multiple key codes for compatibility)
+            if key in [curses.KEY_UP, 259, ord('k'), ord('K')]:  # UP arrow or k/K
+                if enabled_indices:
+                    current_pos = enabled_indices.index(selected) if selected in enabled_indices else 0
+                    new_pos = (current_pos - 1) % len(enabled_indices)
+                    selected = enabled_indices[new_pos]
+            elif key in [curses.KEY_DOWN, 258, ord('j'), ord('J')]:  # DOWN arrow or j/J
+                if enabled_indices:
+                    current_pos = enabled_indices.index(selected) if selected in enabled_indices else 0
+                    new_pos = (current_pos + 1) % len(enabled_indices)
+                    selected = enabled_indices[new_pos]
+            elif key in [curses.KEY_ENTER, ord('\n'), ord('\r'), 10, 13]:  # Various ENTER codes
+                # Execute currently selected action
+                action_key = None
+                for idx, key_char in enabled_items:
+                    if idx == selected:
+                        action_key = key_char
+                        break
+                if action_key and action_key == '0':
+                    break
+                elif action_key:
+                    self.handle_action(action_key)
+                    # Force a refresh after action
+                    stdscr.clear()
+            elif key in [ord('q'), ord('Q'), 27]:  # q/Q or ESC
+                break
+            elif key == ord('1'):
+                self.handle_action('1')
+                stdscr.clear()  # Force refresh after action
+            elif key == ord('2'):
+                self.handle_action('2')
+                stdscr.clear()  # Force refresh after action
+            elif key == ord('3'):
+                self.handle_action('3')
+                stdscr.clear()  # Force refresh after action
+            elif key == ord('4'):
+                self.handle_action('4')
+                stdscr.clear()  # Force refresh after action
+            elif key == ord('5'):
+                self.handle_action('5')
+                stdscr.clear()  # Force refresh after action
+            elif key == ord('6'):
+                self.handle_action('6')
+                stdscr.clear()  # Force refresh after action
+            elif key == ord('7'):
+                self.handle_action('7')
+                stdscr.clear()  # Force refresh after action
+            elif key == ord('0'):
+                break
+
+
+    def text_interface(self):
+        """Fallback text-based interface when curses is not available"""
+        print("Monocoque Manager - Text Mode")
+        print("=" * 40)
+        
+        while True:
+            self.check_processes()
+            
+            print("\nStatus:")
+            print(f"  simd:      {'RUNNING' if self.simd_running else 'STOPPED'}")
+            print(f"  monocoque: {'RUNNING' if self.monocoque_running else 'STOPPED'}")
+            
+            # Show notification about cleaned PID files
+            if self.last_cleaned_pid_files:
+                print(f"  Note: Cleaned stale PID files: {', '.join(self.last_cleaned_pid_files)}")
+                # Clear the notification after showing it once
+                self.last_cleaned_pid_files = []
+            
+            print("\nActions:")
+            menu_items = [
+                ("1", "Start simd", not self.simd_running),
+                ("2", "Start monocoque", not self.monocoque_running and self.simd_running),
+                ("3", "Test configuration", True),
+                ("4", "Edit monocoque config", True),
+                ("5", "View logs", True),
+                ("6", "Restart services", self.simd_running or self.monocoque_running),
+                ("7", "Stop all", self.simd_running or self.monocoque_running),
+                ("0", "Quit", True),
+            ]
+            
+            for key, label, enabled in menu_items:
+                if enabled:
+                    print(f"  [{key}] {label}")
+                else:
+                    print(f"  [{key}] {label} (disabled)")
+            
+            try:
+                choice = input("\nEnter your choice: ").strip()
+                if choice == '0':
+                    break
+                elif choice in ['1', '2', '3', '4', '5', '6', '7']:
+                    # Check if action is enabled
+                    for key, label, enabled in menu_items:
+                        if key == choice and enabled:
+                            self.handle_action(choice)
+                            if choice in ['4']:  # Actions that don't need terminal
+                                print("Action completed.")
+                            elif choice in ['6', '7']:  # Stop/restart actions provide their own feedback
+                                pass  # Feedback already provided by handle_action
+                            else:
+                                print("Command executed. Check the terminal output.")
+                            break
+                        elif key == choice and not enabled:
+                            print("That action is currently disabled.")
+                            break
+                else:
+                    print("Invalid choice. Please try again.")
+            except (KeyboardInterrupt, EOFError):
+                print("\nExiting...")
+                break
+
+
+def main():
+    """Entry point"""
+    manager = MonocoqueManager()
+    
+    if not manager.check_installation():
+        print("Error: Monocoque does not appear to be installed")
+        print("Run the installer first: ./install.sh")
+        sys.exit(1)
+    
+    # Check if we can use curses (proper terminal environment)
+    term = os.environ.get('TERM', 'dumb')
+    if term == 'dumb' or not sys.stdout.isatty():
+        print("Note: Using text mode (terminal doesn't support full TUI)")
+        manager.text_interface()
+    else:
+        try:
+            curses.wrapper(manager.main)
+        except KeyboardInterrupt:
+            print("\nExiting...")
+        except curses.error as e:
+            print(f"Terminal error: {e}")
+            print("Falling back to text mode...")
+            manager.text_interface()
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
+
@@ -0,0 +1,128 @@
+#!/bin/bash
+# Monocoque Uninstaller
+# Removes monocoque and all related components
+
+set -e
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+INSTALL_DIR="${MONOCOQUE_INSTALL_DIR:-${XDG_DATA_HOME:-$HOME/.local/share}/monocoque}"
+CONFIG_DIR="${XDG_CONFIG_HOME:-$HOME/.config}"
+CACHE_DIR="${XDG_CACHE_HOME:-$HOME/.cache}"
+BIN_DIR="$HOME/.local/bin"
+SYSTEMD_DIR="$CONFIG_DIR/systemd/user"
+
+log_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+log_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+log_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+print_header() {
+    echo ""
+    echo "╔══════════════════════════════════════════════════════════════════╗"
+    echo "║                  Monocoque Uninstaller                           ║"
+    echo "╚══════════════════════════════════════════════════════════════════╝"
+    echo ""
+}
+
+print_header
+
+log_warn "This will remove:"
+echo "  • Monocoque installation ($INSTALL_DIR)"
+echo "  • Configuration files ($CONFIG_DIR/monocoque, $CONFIG_DIR/simd)"
+echo "  • Launcher scripts ($BIN_DIR/start-*, test-monocoque)"
+    echo "  • systemd service files ($SYSTEMD_DIR/simd.service)"
+    echo "  • Log files ($CACHE_DIR/monocoque)"
+    echo ""
+echo "This will NOT remove:"
+echo "  • System dependencies (yder, libuv, etc.)"
+echo "  • Compiled simapi library (/usr/local/lib/libsimapi.so)"
+echo ""
+
+read -p "Continue with uninstallation? [y/N]: " confirm
+
+if [[ ! $confirm =~ ^[Yy]$ ]]; then
+    log_info "Uninstallation cancelled"
+    exit 0
+fi
+
+echo ""
+log_info "Starting uninstallation..."
+
+# Stop running services
+log_info "Stopping running services..."
+pkill -x simd 2>/dev/null || true
+pkill -x monocoque 2>/dev/null || true
+systemctl --user stop simd.service 2>/dev/null || true
+systemctl --user disable simd.service 2>/dev/null || true
+
+# Remove installation directory
+if [ -d "$INSTALL_DIR" ]; then
+    log_info "Removing installation directory..."
+    rm -rf "$INSTALL_DIR"
+    log_success "Installation directory removed"
+else
+    log_info "Installation directory not found, skipping"
+fi
+
+# Remove configuration (ask first)
+if [ -d "$CONFIG_DIR/monocoque" ] || [ -d "$CONFIG_DIR/simd" ]; then
+    read -p "Remove configuration files? [y/N]: " remove_config
+    if [[ $remove_config =~ ^[Yy]$ ]]; then
+        rm -rf "$CONFIG_DIR/monocoque" 2>/dev/null || true
+        rm -rf "$CONFIG_DIR/simd" 2>/dev/null || true
+        log_success "Configuration files removed"
+    else
+        log_info "Keeping configuration files"
+    fi
+fi
+
+# Remove launcher scripts
+log_info "Removing launcher scripts..."
+rm -f "$BIN_DIR/start-simd" 2>/dev/null || true
+rm -f "$BIN_DIR/start-monocoque" 2>/dev/null || true
+rm -f "$BIN_DIR/test-monocoque" 2>/dev/null || true
+rm -f "$BIN_DIR/monocoque-manager" 2>/dev/null || true
+
+# Remove systemd services
+if [ -f "$SYSTEMD_DIR/simd.service" ]; then
+    log_info "Removing systemd service files..."
+    rm -f "$SYSTEMD_DIR/simd.service"
+    systemctl --user daemon-reload 2>/dev/null || true
+fi
+
+# Remove logs
+if [ -d "$CACHE_DIR/monocoque" ]; then
+    read -p "Remove log files? [y/N]: " remove_logs
+    if [[ $remove_logs =~ ^[Yy]$ ]]; then
+        rm -rf "$CACHE_DIR/monocoque"
+        log_success "Log files removed"
+    else
+        log_info "Keeping log files"
+    fi
+fi
+
+echo ""
+log_success "Uninstallation complete!"
+echo ""
+log_info "To remove system dependencies and simapi library:"
+echo "  • Remove packages: yder, libuv, argtable, libserialport, etc."
+echo "  • Remove library: sudo rm /usr/local/lib/libsimapi.so*"
+echo "  • Run: sudo ldconfig"
+echo ""
+
@@ -3,3 +3,9 @@ SUBSYSTEMS=="usb",ATTRS{product}=="Rev Burner",GROUP="input",TAG+="uaccess"

 SUBSYSTEM=="tty", ATTRS{idVendor}=="2341", ATTRS{idProduct}=="0043", ATTRS{serial}=="75033303335351A080F0", SYMLINK+="simdev0", GROUP="input", TAG+="uaccess"
 SUBSYSTEM=="tty", ATTRS{idVendor}=="2341", ATTRS{idProduct}=="0043", ATTRS{serial}=="242303138313514131F1", SYMLINK+="simdev1", GROUP="input", TAG+="uaccess"
+
+# Simagic P1000
+SUBSYSTEM=="hidraw", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="0525", MODE="0666"
+
+# Simagic GT NEO
+SUBSYSTEM=="hidraw", ATTRS{idVendor}=="3670", ATTRS{idProduct}=="0805", MODE="0666"
				`@@ -0,0 +1 @@`
				`Message = simdata.velocity .. ";" .. simdata.gear .. ";" .. simdata.rpm .. ";"`