clean up debug code in pulseaudio mainloop start

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

.github/workflows/ci.yaml

@@ -0,0 +1,81 @@
+name: Make Packages
+
+on:
+  push:
+    tags: [ "*" ]
+
+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/${{ matrix.os }}/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 $GITHUB_WORKSPACE/monocoque-${{ matrix.os }}.rpm
+    - name: Release the Package
+      uses: softprops/action-gh-release@v1
+      with:
+        files: monocoque-${{ matrix.os }}.rpm
+

.valgrindrc

@@ -1,3 +1,4 @@
+# small known issue with argtable2
 {
     argtable arg_parse
     Memcheck:Leak

CMakeLists.txt

@@ -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,6 +20,10 @@ 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_PACKAGE(Lua 5.3 REQUIRED)
+set(INCLUDE_DIRS ${LUA_INCLUDE_DIR})
+include_directories(${LUA_INCLUDE_DIR})
+
 #FIND_PATH(LIBUSB_INCLUDE_DIR libusb.h
 #	HINTS $ENV{LIBUSB_ROOT}
 #	PATHS ${PC_LIBUSB_INCLUDEDIR} ${PC_LIBUSB_INCLUDE_DIRS}
@@ -34,14 +38,13 @@ 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 hidapi-hidraw pulse serialport xml2 argtable2 config gameloop helper devices slog simulatorapi uv xdg-basedir)
-else()
-    message("Using portaudio backend...")
-    target_link_libraries(monocoque m hidapi-hidraw portaudio serialport xml2 argtable2 config gameloop helper devices slog simulatorapi uv xdg-basedir)
-endif()
+
+#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})
 
@@ -76,15 +79,15 @@ add_subdirectory(src/monocoque/slog)
 #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)
-#add_test(setmem setmem)
-#
-#add_executable(getmem tests/getmem.c)
-#target_include_directories(getmem PUBLIC)
-#target_link_libraries(getmem)
-#add_test(getmem getmem)
+add_executable(setmem tests/setmem.c)
+target_include_directories(setmem PUBLIC)
+target_link_libraries(setmem)
+add_test(setmem setmem)
+
+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)
@@ -96,10 +99,10 @@ add_subdirectory(src/monocoque/slog)
 #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)
-#add_test(simlighttest simlighttest)
+add_executable(simlighttest tests/simlighttest.c)
+target_include_directories(simlighttest PUBLIC)
+target_link_libraries(simlighttest serialport)
+add_test(simlighttest simlighttest)
 
 
 # used for enabling additional compiler options if supported

HOW-TO-USE.md

@@ -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

README.md

@@ -8,37 +8,56 @@ _  /  / / / /_/ /  / / / /_/ / /__ / /_/ / /_/ // /_/ //  __/
 ```
 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 60 frames per seconds.
 - Modular design for support with various titles and devices.
-- Supports bass shakers, tachometers, several wheels, 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, simwind, and simhaptic effects for motors.
+- 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.
-- Choice of Portaudio or Pulseaudio (libpulse) backend.
+- 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.
 
-## Supported Games ( see [simapi](https://github.com/spacefreak18/simapi) for more details of what is supported from each sim )
-  - Using [SimSHMBridge](https://github.com/spacefreak18/simshmbridge)
-    - Asseto Corsa
-    - Assetto Corsa Competizione
-    - Project Cars 2 (untested)
-    - Automobilista 2
-  
-  - Using [scs-sdk-plugin](https://github.com/jackz314/scs-sdk-plugin/releases)
-    - Euro Truck Simuator 2
-    - American Truck Simulator
+## Adding More Devices
+- If a device isn't already supported, feel free to assist in the reverse engineering process by submitting a pcap or even better working code in a pull request!
+https://santeri.pikarinen.com/pages/usb_hid_reverse_engineering/
 
-  - Using [rfactor 2 plugin](https://github.com/schlegp/rF2SharedMemoryMapPlugin_Wine)
-    - RFactor 2
+## Quick Install
 
-  - Using UDP
-    - Automobilista 2
-    - Project Cars 2 (untested)
+**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```
 
-## Dependencies
+**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
+- hidapi - usb hid devices (hidraw)
 - portaudio - sound devices (haptic bass shakers)
 - libpulse - sound devices (haptic bass shakers)
 - libuv base event loop
@@ -46,14 +65,14 @@ Cross Platform device manager for driving and flight simulators, for use with co
 - 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
+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
@@ -67,74 +86,17 @@ cmake ..
 make
 ```
 
-to use the pulseaudio backend use this cmake command
-```
-cmake -DUSE_PULSEAUDIO=YES ..
-```
-## Bass Shaker Sound Devices
-
-When using pulseaudio it is necesarry to provide a devid in the configuration. This command should list available sound cards with the "Name" being the "devid" needed in the monocoque config.
-```
-pactl list sinks | grep -E -i 'index:|name:' -A 4
-```
-One can generate sample sine waves at specific frequency on a specific channel on a specific sound card with this command (change -d to the Name of your desired target card and change 440 to any frequency)
-```
-ffmpeg -f lavfi -i "sine=f=440" -af "pan=7.1|c1=c0" -f wav pipe:1 | paplay --no-remap --no-remix -d alsa_output.pci-0000_00_1b.0.analog-stereo --volume=65536 -n "Monocoque" --stream-name="Haptic Test"
-```
-(BE CAREFUL!!! AS THIS SETS THE MAXIMUM STREAM VOLUME!!! the -n and --stream-name are optional but it helps you identify the stream in pavucontrol)
-The channel map from the pactl command is the order of channels. Change c1 in this above command to the desired output channel.
-
-The effects generated by monocoque should match the effects generated by this ffmpeg command. The frequency will differ slightly due to having to [fit in the buffer size](https://stackoverflow.com/questions/40078417/how-to-calculate-minimum-cycles-of-sine-wave-to-have-integer-n-cycles-in-a-buffe)
-(monocoque lowers the target frequency until it fits in the audio buffer).
-
-## 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
-- you can actually connect the motors how you wish, but you'd have to make the appropriate changes to the config and to the arduino sketch.
-
-## Getting car tyre diameter for rumbles to work
-- User needs to start monocoque and drive the new car straight at 70 kmph and then stop steering, acc or brake input 
+## 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
@@ -149,15 +111,10 @@ make  # Make sure serial connection is the same as on the host pc and it have th
     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 option to specify frame rate
- - add ability to set frame rate per effect
  - add frequency cap (low pass filter) to sound haptic effects
  - add road and kerb sound haptic effects
  - windows port

conf/basic_rpms.lua

@@ -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
+
+
+
+

conf/car_radar.lua

@@ -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
+

conf/custom.lua

@@ -0,0 +1 @@
+Message = simdata.velocity .. ";" .. simdata.gear .. ";" .. simdata.rpm .. ";"

conf/monocoque.config

@@ -1,68 +1,244 @@
-configs = ({
-    sim = 0;
-    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.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;
+            noise        = 10; // additive noise in Hz
+        },
+        {
+            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";
+        });
+    }
+);

conf/neo.lua

@@ -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

conf/rpms_and_flags.lua

@@ -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

conf/rpms_and_radar.lua

@@ -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

install.sh

@@ -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 "$@"
+

src/arduino/custom/Makefile

@@ -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

src/arduino/custom/custom.ino

@@ -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() {
+}

src/arduino/simhaptic/simhaptic.ino

@@ -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);

src/arduino/simwind/simwind.ino

@@ -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);

src/monocoque/devices/CMakeLists.txt

@@ -25,17 +25,23 @@ set(devices_source_files
   usb/cslelitev3.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
-  sound/usb_generic_shaker.h
-  sound/usb_generic_shaker.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")

src/monocoque/devices/hapticeffect.c

@@ -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;
@@ -30,11 +30,11 @@ bool hasTyreDiameter(SimData* simdata)
     return true;
 }
 
-int loadtyreconfig(SimData* simdata, char* configfile)
+int loadtyreconfig(SimData* simdata, char* configfile, bool setDiameters)
 {
     config_t cfg;
     config_init(&cfg);
-    config_setting_t* config_cars = NULL;
+    const config_setting_t* config_cars = NULL;
 
     if (!config_read_file(&cfg, configfile))
     {
@@ -53,8 +53,9 @@ int loadtyreconfig(SimData* simdata, char* configfile)
     }
     slogt("parsing diameters config file");
 
-    int cars = config_setting_length(config_cars);
+    const int cars = config_setting_length(config_cars);
 
+    bool foundCar = false;
     int i = 0;
     while (i<cars)
     {
@@ -75,15 +76,15 @@ int loadtyreconfig(SimData* simdata, char* configfile)
             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_string(config_car, "sim", &simstr);
-            if(found == 0)
-            {
-                int found = config_setting_lookup_int(config_car, "sim", &sim);
-            }
-            else
-            {
-                sim = simapi_strtogame(simstr);
-            }
+            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)
@@ -94,10 +95,15 @@ int loadtyreconfig(SimData* simdata, char* configfile)
                     if (strcicmp(car, simdata->car) == 0 && sim == simdata->simexe)
                     {
                         slogi("found saved car %s with tyre diameters %f %f %f %f", car, tyre0, tyre1, tyre2, tyre3);
-                        simdata->tyrediameter[0] = tyre0;
-                        simdata->tyrediameter[1] = tyre1;
-                        simdata->tyrediameter[2] = tyre2;
-                        simdata->tyrediameter[3] = tyre3;
+                        foundCar = true;
+                        if(setDiameters == true)
+                        {
+                            simdata->tyrediameter[0] = tyre0;
+                            simdata->tyrediameter[1] = tyre1;
+                            simdata->tyrediameter[2] = tyre2;
+                            simdata->tyrediameter[3] = tyre3;
+
+                        }
                         break;
                     }
                 }
@@ -113,7 +119,11 @@ int loadtyreconfig(SimData* simdata, char* configfile)
 
     config_destroy(&cfg);
 
-    return 0;
+    if(foundCar == true)
+    {
+        return i;
+    }
+    return -1;
 }
 
 int savetyreconfig(SimData* simdata, char* configfile)
@@ -142,8 +152,8 @@ int savetyreconfig(SimData* simdata, char* configfile)
 
     setting = config_setting_add(carobject, "car", CONFIG_TYPE_STRING);
     config_setting_set_string(setting, simdata->car);
-    setting = config_setting_add(carobject, "sim", CONFIG_TYPE_INT);
-    config_setting_set_string(setting, simapi_gametostr(simdata->simexe));
+    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);
@@ -160,7 +170,7 @@ int 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);
 
@@ -194,18 +204,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
     wheelslip[2] = 0;
     wheelslip[3] = 0;
 
-    if(simdata->car == NULL)
-    {
-        slogw("sim is not compatible with wheel and tyre effects, or car and session not loaded.");
-        return 0;
-    }
-    if(simdata->car[0] == '\0')
-    {
-        slogw("sim is not compatible with wheel and tyre effects, or car not loaded.");
-        return 0;
-    }
-
-    slogt("wheel vibration calculation with wheel config set to %i configchecked %i configfile %s car %s", useconfig, *configcheck, configfile, simdata->car);
+    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)
     {
@@ -213,31 +212,7 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
         case (EFFECT_TYRELOCK):
         case (EFFECT_ABSBRAKES):
 
-            if(useconfig == 1 && configfile != NULL)
-            {
-                // check for saved tyre diameter in config file
-                // if not saved version exists get tyre diameter and save it
-                // use config check variable to track if the config check has been performed
-                // avoid many opens of the same file
-                int error = 0;
-                if(hasTyreDiameter(simdata)==false && *configcheck == 0)
-                {
-                    slogi("attempting load of tyre diameter config");
-                    error = loadtyreconfig(simdata, configfile);
-                    *configcheck = 1;
-                }
 
-                if(hasTyreDiameter(simdata)==false)
-                {
-                    slogt("could not find tyre diameter in config file, attempting to calculate new");
-                    getTyreDiameter(simdata);
-                    if(hasTyreDiameter(simdata)==true)
-                    {
-                        slogi("saving tyre config");
-                        error = savetyreconfig(simdata, configfile);
-                    }
-                }
-            }
             if(hasTyreDiameter(simdata)==true)
             {
                 double Speedms = kmhtoms * simdata->velocity;
@@ -260,6 +235,8 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
                 slogt("velocities (x,y,z) are %f %f %f", simdata->Xvelocity, simdata->Yvelocity, simdata->Zvelocity);
             }
             break;
+        case EFFECT_SUSPENSION:
+            break;
         default:
             slogd("Unknown effect type");
     }
@@ -277,7 +254,6 @@ double slipeffect(SimData* simdata, int effecttype, int tyre, double threshold,
     {
         case (EFFECT_TYRESLIP):
 
-
             if (tyre == FRONTLEFT || tyre == FRONTS || tyre == ALLFOUR)
             {
                 if(wheelslip[0] < -threshold)
@@ -386,6 +362,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;

src/monocoque/devices/hapticeffect.h

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

src/monocoque/devices/serial/arduino.c

@@ -2,12 +2,36 @@
 #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_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 arduino_update(SerialDevice* serialdevice, void* data, size_t size)
 {
@@ -18,8 +42,389 @@ int arduino_update(SerialDevice* serialdevice, void* data, size_t size)
     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;
+}

src/monocoque/devices/serial/arduino.h

@@ -5,8 +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 arduino_customled_free(SerialDevice* serialdevice, bool lua);
 
 #endif

src/monocoque/devices/serial/arduinoledlua.c

@@ -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;
+    }
+
+}

src/monocoque/devices/serial/arduinoledlua.h

@@ -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

src/monocoque/devices/serial/moza.c

@@ -10,70 +10,71 @@
 #include "../../slog/slog.h"
 
 #define MOZA_TIMEOUT 1000
-#define MOZA_SERIAL_TEMPLATE {0x7e, 0x06, 0x41, 0x17, 0xfd, 0xde, 0x0, 0x0, 0x0, 0x0, 0x0}
+#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 char moza_checksum(unsigned char *data, unsigned short size)
 {
-    unsigned char ret = MOZA_MAGIC_VALUE;
-    for (short i = 0; i < sizeof(data)/sizeof(data[0]); i++)
+    unsigned int ret = MOZA_MAGIC_VALUE;
+    for (unsigned short i = 0; i < size; i++)
     {
         ret += data[i];
     }
 
-    return ret;
+    return ret % 0x100;
 }
 
-int moza_update(SerialDevice* serialdevice, unsigned short maxrpm, unsigned short rpm)
+int moza_update(SerialDevice* serialdevice, unsigned short rpm, unsigned short maxrpm)
 {
     unsigned char bytes[] = MOZA_SERIAL_TEMPLATE;
-    int size = sizeof(bytes)/sizeof(bytes[0]);
+    unsigned short size = MOZA_PAYLOAD_SIZE;
+    float perctflt = ((float)rpm/(float)maxrpm)*100;
+    int perct = round(perctflt);
 
-    float perct = (float)rpm/(float)maxrpm;
-
-    if (perct >= 0.8)
+    if (perct >= 10)
         bytes[9] |= BIT(0);
 
-    if (perct >= 0.83)
+    if (perct >= 20)
         bytes[9] |= BIT(1);
 
-    if (perct >= 0.86)
+    if (perct >= 30)
         bytes[9] |= BIT(2);
 
-    if (perct >= 0.89)
+    if (perct >= 40)
         bytes[9] |= BIT(3);
 
-    if (perct >= 0.91)
-        bytes[8] |= BIT(4);
+    if (perct >= 50)
+        bytes[9] |= BIT(4);
 
-    if (perct >= 0.92)
-        bytes[8] |= BIT(5);
+    if (perct >= 60)
+        bytes[9] |= BIT(5);
 
-    if (perct >= 0.93)
-        bytes[8] |= BIT(6);
+    if (perct >= 70)
+        bytes[9] |= BIT(6);
 
-    if (perct >= 0.94)
-        bytes[8] |= BIT(7);
+    if (perct >= 80)
+        bytes[9] |= BIT(7);
 
-    if (perct >= 0.96)
+    if (perct >= 90)
         bytes[8] |= BIT(0);
 
-    if (perct >= 0.96)
+    if (perct >= 92)
         bytes[8] |= BIT(1);
 
     // blinking
-    if (perct >= 0.97)
-        bytes[9] |= BIT(MOZA_BLINKING_BIT);
+    if (perct >= 94)
+        bytes[8] |= BIT(MOZA_BLINKING_BIT);
 
-    bytes[10] = moza_checksum(bytes);
+    bytes[10] = moza_checksum(bytes, size);
 
     int result = 1;
     if (serialdevice->port)
     {
-        slogd("copying %i bytes to moza device", size);
+        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);
     }

src/monocoque/devices/serial/moza.h

@@ -4,10 +4,8 @@
 #include "../serialdevice.h"
 #include "../simdevice.h"
 
-int moza_update(SerialDevice* serialdevice, unsigned short maxrpm, unsigned short rpm);
+int moza_update(SerialDevice* serialdevice, unsigned short rpm, unsigned short maxrpm);
 int moza_init(SerialDevice* serialdevice, const char* portdev);
-int moza_free(SerialDevice* serialdevice);
-int moza_serial_check(enum sp_return result);
-
+unsigned char moza_checksum(unsigned char *data, unsigned short size);
 
 #endif

src/monocoque/devices/serial/moza_new.c

@@ -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;
+}

src/monocoque/devices/serial/moza_new.h

@@ -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

src/monocoque/devices/serialadapter.c

@@ -57,10 +57,13 @@ int monocoque_serial_free(SerialDevice* serialdevice)
             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;
-            free(monocoque_serial_devices[serialdevice->id].portname);
         }
         else
         {
@@ -70,6 +73,47 @@ int monocoque_serial_free(SerialDevice* serialdevice)
     }
 }
 
+
+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);
@@ -128,6 +172,36 @@ int monocoque_serial_write_block(uint8_t serialdevicenum, void* data, size_t siz
     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;
@@ -135,7 +209,7 @@ int monocoque_serial_open(SerialDevice* serialdevice, const char* portdev)
     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 == true)
+        if(monocoque_serial_devices[i].open == true && monocoque_serial_devices[i].openfail == false)
         {
             if(msastrcicmp(monocoque_serial_devices[i].portname, portdev) == 0)
             {
@@ -173,13 +247,17 @@ int monocoque_serial_open(SerialDevice* serialdevice, const char* portdev)
         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 = true;
+            monocoque_serial_devices[i].openfail = false;
             return -1;
         }
 
         slogd("Opening port");
-        check(sp_open(sp, SP_MODE_READ_WRITE));
+        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));
@@ -188,6 +266,9 @@ int monocoque_serial_open(SerialDevice* serialdevice, const char* portdev)
         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;
@@ -198,7 +279,7 @@ int monocoque_serial_open(SerialDevice* serialdevice, const char* portdev)
         serial_device_num = i;
 
         free(port_name);
-        slogd("Successfully setup arduino serial device...");
+        slogd("Successfully setup monocoque serial device...");
     }
 
     return serial_device_num;

src/monocoque/devices/serialadapter.h

@@ -18,10 +18,13 @@ typedef struct
 }
 monocoque_serial_device;
 
-static monocoque_serial_device monocoque_serial_devices[10];
+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);
 

src/monocoque/devices/serialdevice.c

@@ -10,6 +10,7 @@
 #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"
@@ -20,7 +21,16 @@ int serial_wheel_update(SimDevice* this, SimData* simdata)
 {
     SerialDevice* serialdevice = (void *) this->derived;
 
-    moza_update(serialdevice, simdata->maxrpm, simdata->rpms);
+    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;
 }
@@ -34,6 +44,33 @@ int serialdev_update(SimDevice* this, SimData* 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;
+}
+
 int arduino_shiftlights_update(SimDevice* this, SimData* simdata)
 {
     SerialDevice* serialdevice = (void *) this->derived;
@@ -70,6 +107,8 @@ int arduino_shiftlights_update(SimDevice* this, SimData* simdata)
     return result;
 }
 
+
+
 int arduino_simwind_update(SimDevice* this, SimData* simdata)
 {
     SerialDevice* serialdevice = (void *) this->derived;
@@ -147,10 +186,18 @@ int serialdev_free(SimDevice* this)
             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;
     }
 
 
@@ -181,17 +228,38 @@ int serialdev_init(SerialDevice* serialdevice, DeviceSettings* ds)
     serialdevice->motorsposition = ds->serialdevsettings.motorsposition;
     serialdevice->baudrate = ds->serialdevsettings.baud;
 
-    switch (serialdevice->type)
+    switch (serialdevice->devicetype)
     {
-        case SERIALDEV_WHEEL:
-
+        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 );
+            error = arduino_init(serialdevice, ds->serialdevsettings.portdev);
             break;
     }
 
@@ -201,6 +269,9 @@ int serialdev_init(SerialDevice* serialdevice, DeviceSettings* ds)
 
 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 };
@@ -223,11 +294,36 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
             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;
@@ -246,16 +342,20 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
         case (SIMDEVTYPE_SERIALWHEEL):
             this->type = SERIALDEV_WHEEL;
 
-            slogi("Initializing serial wheel device.");
             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
-                this->devicetype = SERIALDEV__MOZAR5;
-                this->m.vtable = &serialwheel_vtable;
-
-                break;
+                  //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;
             }
     }
 

src/monocoque/devices/serialdevice.h

@@ -6,10 +6,14 @@
 
 typedef enum
 {
-    ARDUINODEV__SHIFTLIGHTS   = 0,
-    ARDUINODEV__SIMWIND       = 1,
-    ARDUINODEV__HAPTIC        = 2,
-    SERIALDEV__MOZAR5         = 3,
+    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;
 

src/monocoque/devices/simdevice.c

@@ -50,20 +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;
-                simdevices[j].fps = ds[j].fps;
-                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");
+                }
             }
         }
 

src/monocoque/devices/simdevice.h

@@ -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"
 
@@ -25,6 +30,8 @@ struct SimDevice
     int id;
     int fps;
     bool initialized;
+    lua_State* L;
+    char* device_specific_config_file;
     DeviceType type;
     HapticEffect hapticeffect;
 };
@@ -49,10 +56,14 @@ 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;
@@ -87,6 +98,7 @@ typedef struct
 {
     SimDevice m;
     int id;
+    hid_device* handle;
     USBType type;
     union
     {
@@ -111,12 +123,12 @@ typedef struct
     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;
 
@@ -139,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

src/monocoque/devices/sound.c

@@ -2,8 +2,6 @@
 
 #include "../slog/slog.h"
 
-#ifdef USE_PULSEAUDIO
-
 pa_threaded_mainloop* mainloop;
 pa_context* context;
 
@@ -21,10 +19,8 @@ int setupsound()
     slogi("connecting pulseaudio...");
     // Get a mainloop and its context
     mainloop = pa_threaded_mainloop_new();
-    assert(mainloop);
     mainloop_api = pa_threaded_mainloop_get_api(mainloop);
     context = pa_context_new(mainloop_api, "Monocoque");
-    assert(context);
 
     pa_context_set_state_callback(context, &context_state_cb, mainloop);
 
@@ -32,48 +28,55 @@ int setupsound()
     pa_threaded_mainloop_lock(mainloop);
 
     // Start the mainloop
+<<<<<<< Updated upstream
     assert(pa_threaded_mainloop_start(mainloop) == 0);
-    assert(pa_context_connect(context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) == 0);
+    assert(pa_context_connect(context, NULL, 0, NULL) == 0);
+=======
+    pa_threaded_mainloop_start(mainloop);
+    pa_context_connect(context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL);
+>>>>>>> Stashed changes
 
     // Wait for the context to be ready
     for(;;) {
         pa_context_state_t context_state = pa_context_get_state(context);
-        assert(PA_CONTEXT_IS_GOOD(context_state));
         if (context_state == PA_CONTEXT_READY) break;
         pa_threaded_mainloop_wait(mainloop);
     }
 
+    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()
+//{
+//
+//}

src/monocoque/devices/sound/usb_generic_shaker.c

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

src/monocoque/devices/sound/usb_generic_shaker.h

@@ -3,12 +3,12 @@
 
 #include "../simdevice.h"
 
-#ifdef USE_PULSEAUDIO
+//#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
+//#else
+//int usb_generic_shaker_init(SoundDevice* sounddevice);
+//int usb_generic_shaker_free(SoundDevice* sounddevice);
+//#endif
 
 #endif

src/monocoque/devices/sound/usb_generic_shaker_pulse.c

@@ -1,24 +1,30 @@
-#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   (44100)
-#define AMPLITUDE .5
+#define AMPLITUDE 1
 #define DURATION 1.0
 
 #ifndef M_PI
 #define M_PI  (3.14159265)
 #endif
 
+static double apply_noise(double base_freq, double noise_amount) {
+    if (noise_amount > 0.0) {
+        double r = (double) rand() / RAND_MAX * 2.0 - 1.0;
+        return base_freq + r * noise_amount;
+    } else {
+        return base_freq;
+    }
+}
+
 void gear_sound_stream(pa_stream *s, size_t length, void *userdata) {
 
     SoundData* data = (SoundData*)userdata;
@@ -27,59 +33,75 @@ void gear_sound_stream(pa_stream *s, size_t length, void *userdata) {
 
 
     for (size_t i = 0; i < num_samples; i++) {
-        static double t = 0.0;
-        double sample = 0;
-        if (data->frequency>0)
-        {
-            sample = AMPLITUDE * 32767.0 * sin(2.0 * M_PI * data->curr_frequency * data->curr_duration);
-        }
 
+        double sample = 0;
+
+        if (data->curr_frequency>0.0)
+        {
+            double t = data->phase;
+            double a = (double)data->curr_amplitude/100;
+
+            // fade-out 5ms to prevent discontinuity
+            static double fade_out_duration = 0.005;
+
+            double remaining = data->duration - data->curr_duration;
+            if (remaining < fade_out_duration) {
+                a *= remaining / fade_out_duration;
+            }
+
+            sample = a * 32767.0 * sin(2.0 * M_PI * t);
+
+            double f = apply_noise(data->curr_frequency, data->noise);
+
+            t += f / SAMPLE_RATE;
+            if (t >= 1.0) {
+                t -= floor(t);
+            }
+
+            data->phase = t;
+
+            data->curr_duration += 1.0 / SAMPLE_RATE;
+            if (data->curr_duration >= data->duration) {
+                data->curr_duration = 0.0;
+                data->curr_frequency = 0.0;
+                data->phase = 0.0;
+            }
+
+        }
 
         buffer[i] = (int16_t)sample;
 
-        data->curr_duration += 1.0 / SAMPLE_RATE;
-        if (data->curr_duration >= data->duration) {
-            data->curr_duration = 0.0;
-            data->curr_frequency = 0;
-        }
     }
     pa_stream_write(s, buffer, length, NULL, 0LL, PA_SEEK_RELATIVE);
 }
 
-double get_closest_frequency(size_t num_samples, double input_frequency) {
-
-    double samples_per_cycle = SAMPLE_RATE / input_frequency;
-
-    double adjusted_frequency = SAMPLE_RATE / (num_samples / floor(num_samples/samples_per_cycle) );
-
-    return adjusted_frequency;
-}
-
 void engine_sound_stream(pa_stream *s, size_t length, void *userdata) {
 
     SoundData* data = (SoundData*)userdata;
-    double freq = data->curr_frequency;
 
     size_t num_samples = length / sizeof(int16_t);
-    freq = get_closest_frequency( num_samples, freq );
+
     //size_t num_samples = (size_t) (DURATION * SAMPLE_RATE);
     int16_t buffer[num_samples];
 
     //double t = 0;
     for (size_t i = 0; i < num_samples; i++) {
+
         double t = data->phase;
 
-        double sample = AMPLITUDE * 32767.0 * sin( 2.0 * M_PI * freq * t );
+        double sample = ((double)data->curr_amplitude/100) * 32767.0 * sin( 2.0 * M_PI * t );
 
         buffer[i] = (int16_t)sample;
 
-        t += 1.0 / SAMPLE_RATE;
-        if (t >= SAMPLE_RATE) {
-            t = 0;
+        double f = apply_noise(data->curr_frequency, data->noise);
+
+        t += f / SAMPLE_RATE;
+        if (t >= 1.0) {
+            t -= floor(t);
         }
+
         data->phase = t;
     }
-    data->phase = round(data->phase);
 
     pa_stream_write(s, buffer, length, NULL, 0LL, PA_SEEK_RELATIVE);
 }
@@ -94,18 +116,29 @@ void stream_state_cb(pa_stream *s, void *mainloop) {
     pa_threaded_mainloop_signal(mainloop, 0);
 }
 
+
 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;
     if (sounddevice->stream)
     {
         pa_stream_disconnect(sounddevice->stream);
         pa_stream_unref(sounddevice->stream);
         // why is this wrong
-        //pa_xfree(sounddevice->stream);
+
+
     }
+
     pa_threaded_mainloop_unlock(mainloop);
+
     return err;
 }
 
@@ -158,7 +191,7 @@ int usb_generic_shaker_init(SoundDevice* sounddevice, pa_threaded_mainloop* main
     // recommended settings, i.e. server uses sensible values
     pa_buffer_attr buffer_attr;
     buffer_attr.maxlength = (uint32_t) 32767;
-    buffer_attr.tlength = (uint32_t) -1;
+    buffer_attr.tlength = (uint32_t) 2048;
     buffer_attr.prebuf = (uint32_t) -1;
     buffer_attr.minreq = (uint32_t) -1;
 
@@ -175,12 +208,15 @@ int usb_generic_shaker_init(SoundDevice* sounddevice, pa_threaded_mainloop* main
     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));
-    if (stream_state == PA_STREAM_READY) break;
+        //PA_STREAM_IS_GOOD(stream_state);
+        if (stream_state == PA_STREAM_READY) break;
         pa_threaded_mainloop_wait(mainloop);
     }
 
@@ -193,5 +229,3 @@ int usb_generic_shaker_init(SoundDevice* sounddevice, pa_threaded_mainloop* main
     pa_threaded_mainloop_unlock(mainloop);
     return 0;
 }
-
-#endif

src/monocoque/devices/sounddevice.c

@@ -4,6 +4,7 @@
 
 #include <stdio.h>
 #include <unistd.h>
+#include <math.h>
 
 #include "sound.h"
 #include "simdevice.h"
@@ -20,23 +21,14 @@ 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 %f", sounddevice->sounddata.curr_frequency);
 }
 
-// we could make a vtable for these different effects too
-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 modulate(SoundDevice* sounddevice, double raw_effect, SoundEffectModulationType modulation)
 {
@@ -44,17 +36,37 @@ double modulate(SoundDevice* sounddevice, double raw_effect, SoundEffectModulati
     switch (modulation)
     {
         case SOUND_EFFECT_MODULATION_FREQUENCY:
-            modulated_effect = (sounddevice->sounddata.frequencyMax - sounddevice->sounddata.frequency) * raw_effect;
+            modulated_effect = ((sounddevice->sounddata.frequencyMax - sounddevice->sounddata.frequency) * raw_effect) + sounddevice->sounddata.frequency;
+            sounddevice->sounddata.curr_frequency = modulated_effect;
+            sounddevice->sounddata.curr_amplitude = sounddevice->sounddata.amplitude;
+            slogt("set curr frequency to %f from raw effect %f and base frequency %i", sounddevice->sounddata.curr_frequency, raw_effect, sounddevice->sounddata.frequency);
             break;
         case SOUND_EFFECT_MODULATION_AMPLIFY:
+            modulated_effect = ((sounddevice->sounddata.amplitudeMax - sounddevice->sounddata.amplitude) * raw_effect) + sounddevice->sounddata.amplitude;
+            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:
-            modulated_effect = raw_effect;
+            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
+int sounddev_engine_update(SimDevice* this, SimData* simdata)
+{
+    SoundDevice* sounddevice = (void *) this->derived;
+
+    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;
@@ -64,13 +76,12 @@ int sounddev_tyreslip_update(SimDevice* this, SimData* simdata)
 
     if (effect > 0)
     {
-        effect = modulate(sounddevice, effect, sounddevice->modulationType);
-        sounddevice->sounddata.curr_frequency = sounddevice->sounddata.frequency;
-        sounddevice->sounddata.curr_duration = sounddevice->sounddata.duration;
+        modulate(sounddevice, effect, sounddevice->modulationType);
     }
     else
     {
-        sounddevice->sounddata.curr_frequency = 0;
+        sounddevice->sounddata.curr_frequency = 0.0;
+        sounddevice->sounddata.curr_amplitude = 0;
         sounddevice->sounddata.curr_duration = 0;
     }
 
@@ -85,12 +96,12 @@ int sounddev_tyrelock_update(SimDevice* this, SimData* simdata)
 
     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_frequency = 0.0;
+        sounddevice->sounddata.curr_amplitude = 0;
         sounddevice->sounddata.curr_duration = 0;
     }
 }
@@ -103,16 +114,37 @@ int sounddev_absbrakes_update(SimDevice* this, SimData* simdata)
 
     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_frequency = 0.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.0;
+        sounddevice->sounddata.curr_amplitude = 0;
+        sounddevice->sounddata.curr_duration = 0;
+    }
+
+}
+
 int sounddev_gearshift_update(SimDevice* this, SimData* simdata)
 {
     SoundDevice* sounddevice = (void *) this->derived;
@@ -121,51 +153,46 @@ int sounddev_gearshift_update(SimDevice* this, SimData* simdata)
 }
 
 
-#ifdef USE_PULSEAUDIO
-
 int sounddev_free(SimDevice* this)
 {
     SoundDevice* sounddevice = (void *) this->derived;
 
     usb_generic_shaker_free(sounddevice, mainloop);
-
     free(sounddevice);
 
     return 0;
 }
 
-#else
-int sounddev_free(SimDevice* this)
-{
-    SoundDevice* sounddevice = (void *) this->derived;
-
-    usb_generic_shaker_free(sounddevice);
-
-    free(sounddevice);
-
-    return 0;
-}
-#endif
-
 int sounddev_init(SoundDevice* sounddevice, const char* devname, MonocoqueTyreIdentifier tyre, SoundDeviceSettings sds)
 {
     slogi("initializing standalone sound device...");
 
 
     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);
+    slogi("noise is: %i", sds.noise);
 
 
     sounddevice->modulationType = sds.modulation;
     sounddevice->sounddata.frequency = sds.frequency;
-    sounddevice->sounddata.curr_frequency = 0;
+    sounddevice->sounddata.frequencyMax = sds.frequencyMax;
+    sounddevice->sounddata.amplitude = sds.amplitude;
+    sounddevice->sounddata.amplitudeMax = sds.amplitudeMax;
+    sounddevice->sounddata.noise = (double)sds.noise;
     sounddevice->sounddata.curr_duration = 0;
+
     sounddevice->sounddata.phase = 0;
 
+    sounddevice->sounddata.curr_amplitude = 0;
+    sounddevice->sounddata.curr_frequency = 0.0;
+
 
     const char* streamname= "Engine";
     switch (sounddevice->m.hapticeffect.effecttype) {
@@ -183,18 +210,18 @@ int sounddev_init(SoundDevice* sounddevice, const char* devname, MonocoqueTyreId
         case (EFFECT_ABSBRAKES):
             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, sds.volume, sds.pan, sds.channels, streamname);
-#else
-    usb_generic_shaker_init(sounddevice);
-#endif
+    //usb_generic_shaker_init(sounddevice);
 }
 
 static const vtable engine_sound_simdevice_vtable = { &sounddev_engine_update, &sounddev_free };
@@ -202,6 +229,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) {
 
@@ -265,6 +293,21 @@ SoundDevice* new_sound_device(DeviceSettings* ds, MonocoqueSettings* ms) {
             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 sound device %s", ds->sounddevsettings.dev);
@@ -278,4 +321,3 @@ SoundDevice* new_sound_device(DeviceSettings* ds, MonocoqueSettings* ms) {
 
     return this;
 }
-

src/monocoque/devices/sounddevice.h

@@ -1,11 +1,11 @@
 #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
@@ -19,14 +19,18 @@ SoundEffectModulationType;
 #define MAX_TABLE_SIZE   (6000)
 typedef struct
 {
-    int last_gear;
+    uint8_t last_gear;
     int volume;
     uint32_t frequency;
     uint32_t frequencyMax;
+    uint32_t amplitude;
+    uint32_t amplitudeMax;
     double duration;
-    int curr_frequency;
+    double curr_frequency;
+    uint32_t curr_amplitude;
     double curr_duration;
     double phase;
+    double noise;
 }
 SoundData;
 

src/monocoque/devices/tachdevice.c

@@ -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;
 }

src/monocoque/devices/tachdevice.h

@@ -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

src/monocoque/devices/usb/revburner.c

@@ -2,13 +2,13 @@
 
 #include <hidapi/hidapi.h>
 
-#include "tachdevice.h"
-#include "../slog/slog.h"
+#include "../simdevice.h"
+#include "../../slog/slog.h"
 
 const size_t REVBURNER_BUFSIZE = 8;
 
 
-int revburner_update(TachDevice* tachdevice, int pulses)
+int revburner_update(USBDevice* tachdevice, int pulses)
 {
 
     int res = 0;
@@ -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;
 }

src/monocoque/devices/usb/revburner.h

@@ -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

src/monocoque/devices/usb/simagicp1000.c

@@ -19,7 +19,7 @@ int senddevreport(USBGenericHapticDevice* usbhapticdevice, unsigned char* buf, s
     int res = 0;
     if (usbhapticdevice->handle)
     {
-        res = hid_write(usbhapticdevice->handle, buf, SIMAGIC_P1000_BUFSIZE);
+        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]);
     }
@@ -27,7 +27,7 @@ int senddevreport(USBGenericHapticDevice* usbhapticdevice, unsigned char* buf, s
     {
         slogd("no handle");
     }
-    return res;
+    return res != bufsize;
 }
 
 int simagicp1000_update(USBGenericHapticDevice* usbhapticdevice, int effecttype, int play)
@@ -44,34 +44,36 @@ int simagicp1000_update(USBGenericHapticDevice* usbhapticdevice, int effecttype,
 
     if (play > 0)
     {
-        bytes[0] = 0xEC;
+        bytes[0] = 241;
+        bytes[1] = 0xEC;
         // we can add config settings for these values
-        bytes[2] = 0x01;
-        bytes[3] = 0x0A;
-        bytes[4] = 0xFF;
+        bytes[3] = 0x01;
+        bytes[4] = 0x0A;
+        bytes[5] = 0xFF;
         switch (effecttype)
         {
             case (EFFECT_TYRESLIP):
-                bytes[1] = 0x02;
+                bytes[2] = 0x02;
                 senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
                 break;
             case (EFFECT_TYRELOCK):
-                bytes[1] = 0x01;
+                bytes[2] = 0x01;
                 senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
                 break;
             case (EFFECT_ABSBRAKES):
-                bytes[1] = 0x02;
+                bytes[2] = 0x02;
                 senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
-                bytes[1] = 0x01;
+                bytes[2] = 0x01;
                 senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
                 break;
         }
     }
     else
     {
-        bytes[1] = 0x01;
+        bytes[0] = 241;
+        bytes[2] = 0x01;
         senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
-        bytes[1] = 0x02;
+        bytes[2] = 0x02;
         senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
     }
 
@@ -113,13 +115,14 @@ int simagicp1000_init(USBGenericHapticDevice* usbhapticdevice)
         {
             bytes[x] = 0x00;
         }
-        bytes[0] = 0xF1;
-        bytes[1] = 0x17;
-        bytes[2] = 0x00;
+        bytes[0] = 241;
+        bytes[1] = 0xF1;
+        bytes[2] = 0x17;
         bytes[3] = 0x00;
         bytes[4] = 0x00;
-        bytes[5] = 0x01;
-        bytes[6] = 0x02;
+        bytes[5] = 0x00;
+        bytes[6] = 0x01;
+        bytes[7] = 0x02;
         res = senddevreport(usbhapticdevice, bytes, SIMAGIC_P1000_BUFSIZE);
         slogd("Initialization returned %i", res);
         if(res != 0)

src/monocoque/devices/usb/wheels/cammusc12.c

@@ -4,17 +4,21 @@
 #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;
 
-int cammusc12_update(WheelDevice* wheeldevice, int maxrpm, int rpm, int gear, int velocity)
+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;
@@ -42,10 +46,11 @@ int cammusc12_update(WheelDevice* wheeldevice, int maxrpm, int rpm, int gear, in
     // byte 4 is gear
     bytes[6] = gear-1;
 
-    slogt("writing bytes x%02xx%02xx%02xx%02xx%02x%02x%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);
-    if (wheeldevice->handle)
+
+    if (usbdevice->handle)
     {
-        res = hid_write(wheeldevice->handle, bytes, cammusc12_hidupdate_buf_size);
+        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
     {
@@ -55,17 +60,23 @@ int cammusc12_update(WheelDevice* wheeldevice, int maxrpm, int rpm, int gear, in
     return res;
 }
 
-int cammusc12_free(WheelDevice* wheeldevice)
+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(WheelDevice* wheeldevice)
+int cammusc12_init_(USBDevice* wheeldevice)
 {
     slogi("initializing cammus c12 wheel...");
 
@@ -84,3 +95,137 @@ int cammusc12_init(WheelDevice* wheeldevice)
     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;
+}

src/monocoque/devices/usb/wheels/cammusc12.h

@@ -3,8 +3,11 @@
 
 #include "../../wheeldevice.h"
 
-int cammusc12_update(WheelDevice* wheeldevice, int maxrpm, int rpm, int gear, int velocity);
-int cammusc12_init(WheelDevice* wheeldevice);
-int cammusc12_free(WheelDevice* wheeldevice);
+#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

src/monocoque/devices/usb/wheels/cammusc5.c

@@ -9,13 +9,13 @@
 const int cammusc5_hidupdate_buf_size = 14;
 const int num_avail_leds = 9;
 
-int cammusc5_update(WheelDevice* wheeldevice, int maxrpm, int rpm, int gear, int velocity)
+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;
@@ -56,9 +56,9 @@ int cammusc5_update(WheelDevice* wheeldevice, int maxrpm, int rpm, int gear, int
     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 (wheeldevice->handle)
+    if (usbdevice->handle)
     {
-        res = hid_write(wheeldevice->handle, bytes, cammusc5_hidupdate_buf_size);
+        res = hid_write(usbdevice->handle, bytes, cammusc5_hidupdate_buf_size);
     }
     else
     {
@@ -68,17 +68,17 @@ int cammusc5_update(WheelDevice* wheeldevice, int maxrpm, int rpm, int gear, int
     return res;
 }
 
-int cammusc5_free(WheelDevice* wheeldevice)
+int cammusc5_free(USBDevice* usbdevice)
 {
     int res = 0;
 
-    hid_close(wheeldevice->handle);
+    hid_close(usbdevice->handle);
     res = hid_exit();
 
     return res;
 }
 
-int cammusc5_init(WheelDevice* wheeldevice)
+int cammusc5_init(USBDevice* usbdevice)
 {
     slogi("initializing cammus c5 wheel...");
 
@@ -86,9 +86,9 @@ int cammusc5_init(WheelDevice* wheeldevice)
 
     res = hid_init();
 
-    wheeldevice->handle = hid_open(0x3416, 0x1021, NULL);
+    usbdevice->handle = hid_open(0x3416, 0x1021, NULL);
 
-    if (!wheeldevice->handle)
+    if (!usbdevice->handle)
     {
         sloge("Could not find attached Cammus C5 Wheel");
         res = hid_exit();

src/monocoque/devices/usb/wheels/cammusc5.h

@@ -1,10 +1,10 @@
 #ifndef _CAMMUSC5_H
 #define _CAMMUSC5_H
 
-#include "../../wheeldevice.h"
+#include "../../simdevice.h"
 
-int cammusc5_update(WheelDevice* wheeldevice, int maxrpm, int rpm, int gear, int velocity);
-int cammusc5_init(WheelDevice* wheeldevice);
-int cammusc5_free(WheelDevice* wheeldevice);
+int cammusc5_update(USBDevice* wheeldevice, int maxrpm, int rpm, int gear, int velocity);
+int cammusc5_init(USBDevice* wheeldevice);
+int cammusc5_free(USBDevice* wheeldevice);
 
 #endif

src/monocoque/devices/usb/wheels/gtneo.c

@@ -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;
+}

src/monocoque/devices/usb/wheels/gtneo.h

@@ -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

src/monocoque/devices/usb/wheels/logitechg29.c

@@ -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;
+}

src/monocoque/devices/usb/wheels/logitechg29.h

@@ -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

src/monocoque/devices/usbdevice.c

@@ -17,10 +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->u.wheeldevice, simdata);
+            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);
@@ -39,10 +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->u.wheeldevice);
+            wheeldev_free(usbdevice);
             break;
         case USBDEV_GENERICHAPTIC :
             usbhapticdev_free(&usbdevice->u.hapticdevice);
@@ -64,10 +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->u.wheeldevice, ds);
+            error = wheeldev_init(usbdevice, ds);
             break;
         case USBDEV_GENERICHAPTIC :
             error = usbhapticdev_init(&usbdevice->u.hapticdevice, ds);

src/monocoque/devices/usbhapticdevice.c

@@ -105,11 +105,5 @@ int usbhapticdev_init(USBGenericHapticDevice* usbhapticdevice, DeviceSettings* d
             slogw("Possibly unknown device");
     }
 
-    if(usbhapticdevice->handle == 0)
-    {
-        error = MONOCOQUE_ERROR_INVALID_DEV;
-        return error;
-    }
-
     return error;
 }

src/monocoque/devices/wheeldevice.c

@@ -2,73 +2,150 @@
 #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 "wheeldevice.h"
+
+#include "simdevice.h"
 #include "../helper/confighelper.h"
 #include "../simulatorapi/simapi/simapi/simdata.h"
 #include "../slog/slog.h"
 
-int wheeldev_update(WheelDevice* wheeldevice, SimData* simdata)
+int wheeldev_update(USBDevice* usbdevice, SimData* simdata)
 {
+    WheelDevice* wheeldevice = &usbdevice->u.wheeldevice;
     switch ( wheeldevice->type )
     {
         case WHEELDEV_UNKNOWN :
         case WHEELDEV_CAMMUSC5 :
-            cammusc5_update(wheeldevice, simdata->maxrpm, simdata->rpms, simdata->gear, simdata->velocity);
+            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 :
-            cammusc12_update(wheeldevice, simdata->maxrpm, simdata->rpms, simdata->gear, simdata->velocity);
+            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(WheelDevice* wheeldevice)
+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(wheeldevice, 0, 0, 0, 0);
-            cammusc5_free(wheeldevice);
+            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_update(wheeldevice, 0, 0, 0, 0);
-            cammusc12_free(wheeldevice);
+            cammusc12_free(usbdevice);
+            if(wheeldevice->useLua == true)
+            {
+                free(usbdevice->m.device_specific_config_file);
+            }
             break;
     }
 
     return 0;
 }
 
-int wheeldev_init(WheelDevice* wheeldevice, DeviceSettings* ds)
+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(wheeldevice);
+            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");
-            error = cammusc12_init(wheeldevice);
+
+            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(wheeldevice);
+            error = cammusc5_init(usbdevice);
             break;
     }
 
+
+
     return error;
 }

src/monocoque/devices/wheeldevice.h

@@ -1,7 +1,6 @@
 #ifndef _WHEELDEVICE_H
 #define _WHEELDEVICE_H
 
-#include <hidapi/hidapi.h>
 #include "../helper/confighelper.h"
 #include "../simulatorapi/simapi/simapi/simdata.h"
 
@@ -12,7 +11,9 @@ typedef enum
     WHEELDEV_UNKNOWN       = 0,
     WHEELDEV_CAMMUSC5      = 1,
     WHEELDEV_CAMMUSC12     = 2,
-    WHEELDEV_MOZAR5        = 3
+    WHEELDEV_MOZAR5        = 3,
+    WHEELDEV_SIMAGICGTNEO  = 4,
+    WHEELDEV_LOGITECHG29   = 5
 }
 WheelType;
 
@@ -20,13 +21,10 @@ typedef struct
 {
     int id;
     WheelType type;
-    hid_device* handle;
+    bool useLua;
     char* port;
 }
 WheelDevice;
 
-int wheeldev_update(WheelDevice* wheeldevice, SimData* simdata);
-int wheeldev_init(WheelDevice* wheeldevice, DeviceSettings* ds);
-int wheeldev_free(WheelDevice* wheeldevice);
 
 #endif

src/monocoque/gameloop/gameloop.c

@@ -11,11 +11,9 @@
 
 #include "gameloop.h"
 #include "loopdata.h"
-
-#include "../helper/parameters.h"
 #include "../helper/confighelper.h"
 #include "../devices/simdevice.h"
-#include "../devices/serialadapter.h"
+#include "../devices/hapticeffect.h"
 #include "../simulatorapi/simapi/simapi/simdata.h"
 #include "../simulatorapi/simapi/simapi/simmapper.h"
 #include "../slog/slog.h"
@@ -29,6 +27,7 @@ struct sigaction act;
 
 uv_idle_t idler;
 uv_timer_t datachecktimer;
+uv_timer_t showstatstimer;
 uv_timer_t datamaptimer;
 uv_udp_t recv_socket;
 
@@ -36,9 +35,19 @@ 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);
 
+static void close_walk_cb(uv_handle_t* handle, void* arg)
+{
+    if (!uv_is_closing(handle))
+    {
+        uv_close(handle, NULL);
+    }
+}
+#define ASSERT(expr) expr
+
 int showstats(SimData* simdata)
 {
     printf("\r");
@@ -226,6 +235,7 @@ void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
     {
         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)
         {
             slogi("looking for ui config %s pass 2", ms->config_str);
@@ -236,13 +246,13 @@ void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
             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;
@@ -250,23 +260,13 @@ void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
 
         f->simdevices = malloc(f->numdevices * sizeof(SimDevice));
         int initdevices = devinit(f->simdevices, configureddevices, ds, ms);
-        int i = 0;
-        for( i = 0; i < configureddevices; i++)
+
+        for( int i = 0; i < configureddevices; i++)
         {
             settingsfree(ds[i]);
         }
         free(ds);
 
-
-        for(int d = 0; d < 10; d++)
-        {
-            monocoque_serial_devices[d].open = false;
-            monocoque_serial_devices[d].openfail = false;
-            monocoque_serial_devices[d].busy = false;
-            monocoque_serial_devices[d].refs = 0;
-        }
-
-
         int numdevices = f->numdevices;
         SimDevice* devices = f->simdevices;
         f->device_timers = (uv_timer_t*) (malloc(uv_handle_size(UV_TIMER) * numdevices));
@@ -284,15 +284,21 @@ void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
                 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 at %i fps (%i ms ticks)", devices[x].fps, 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);
             }
         }
 
+
+        uv_timer_start(&showstatstimer, showstatscallback, 0, 100);
         doui = false;
     }
     else
     {
-        showstats(simdata);
+        //showstats(simdata);
         //SimDevice* devices = f->simdevices;
         //int numdevices = f->numdevices;
         //for (int x = 0; x < numdevices; x++)
@@ -302,35 +308,80 @@ void looprun(MonocoqueSettings* ms, loop_data* f, SimData* simdata)
         //        devices[x].update(&devices[x], simdata);
         //    }
         //}
+
+        if(f->ms->useconfig == 1 && f->ms->tyre_diameter_config != NULL)
+        {
+            if(simdata->car != NULL || simdata->car[0] != 0)
+            {
+                // check for saved tyre diameter in config file
+                // if not saved version exists get tyre diameter and save it
+                // use config check variable to track if the config check has been performed
+                // avoid many opens of the same file
+                int error = 0;
+                if(hasTyreDiameter(simdata)==false && f->ms->configcheck == 0)
+                {
+                    slogi("attempting load of tyre diameter config");
+                    error = loadtyreconfig(simdata, f->ms->tyre_diameter_config, true);
+                    f->ms->configcheck = 1;
+                }
+
+                if(hasTyreDiameter(simdata)==false)
+                {
+                    slogt("could not find tyre diameter in config file, attempting to calculate new");
+                    getTyreDiameter(simdata);
+                }
+            }
+        }
     }
 }
 
-void shmdatamapcallback(uv_timer_t* handle)
+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;
-    SimMap* simmap = f->simmap;
-    MonocoqueSettings* ms = f->ms;
-    //appstate = 2;
-    if (appstate == 2)
+    if(appstate == 2)
     {
-        simdatamap(simdata, simmap, NULL, f->map, false, NULL);
-        looprun(ms, f, simdata);
+        showstats(simdata);
     }
+}
 
-    if (f->simstate == false || simdata->simstatus <= 1 || appstate <= 1)
-    {
+void releaseloop(loop_data* f, SimData* simdata, SimMap* simmap)
+{
+        slogi("release loop");
         if(f->releasing == false)
         {
             f->releasing = true;
-            uv_timer_stop(handle);
+            uv_timer_stop(&datamaptimer);
+            uv_timer_stop(&showstatstimer);
+            if (uv_is_active((uv_handle_t*)&recv_socket))
+            {
+                uv_udp_recv_stop(&recv_socket);
+            }
+            // Close the socket handle so it can be reinitialized with a different port
+            //if (!uv_is_closing((uv_handle_t*)&recv_socket))
+            //{
+            //    uv_close((uv_handle_t*)&recv_socket, NULL);
+            //}
             slogi("releasing devices, please wait");
+            
+            //attempt tyre diameter saving
+            if(hasTyreDiameter(simdata) == true)
+            {
+                int a = loadtyreconfig(simdata, f->ms->tyre_diameter_config, false);
+                if(a < 0)
+                {
+                    slogi("saving new tyre diameter config");
+                    savetyreconfig(simdata, f->ms->tyre_diameter_config);
+                }
+            }
+
             f->uion = false;
             SimDevice* devices = f->simdevices;
             int numdevices = f->numdevices;
 
             // help things spin down
+            simdata->simstatus = 0;
             simdata->rpms = 0;
             simdata->velocity = 0;
 
@@ -355,6 +406,7 @@ void shmdatamapcallback(uv_timer_t* handle)
                     devices[x].update(&devices[x], simdata);
                 }
             }
+            sleep(1);
             for (int x = 0; x < numdevices; x++)
             {
                 if (devices[x].initialized == true)
@@ -364,14 +416,6 @@ void shmdatamapcallback(uv_timer_t* handle)
             }
             free(devices);
 
-            for(int d = 0; d < 10; d++)
-            {
-                if(monocoque_serial_devices[d].portname != NULL)
-                {
-                    free(monocoque_serial_devices[d].portname);
-                }
-            }
-
             int r = simfree(simdata, simmap, f->map);
             slogd("simfree returned %i", r);
             f->numdevices = 0;
@@ -381,7 +425,8 @@ void shmdatamapcallback(uv_timer_t* handle)
 
             if(appstate > 0)
             {
-                uv_timer_start(&datachecktimer, datacheckcallback, 3000, 1000);
+                slogi("restarting checking for data...");
+                uv_timer_start(&datachecktimer, datacheckcallback, 0, 1000);
             }
             f->releasing = false;
             if(appstate > 1)
@@ -389,6 +434,25 @@ void shmdatamapcallback(uv_timer_t* handle)
                 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);
+    }
+
+    if (f->simstate == false || simdata->simstatus <= 1 || appstate <= 1)
+    {
+        releaseloop(f, simdata, simmap);
     }
 }
 
@@ -403,6 +467,10 @@ static void on_udp_recv(uv_udp_t* handle, ssize_t nread, const uv_buf_t* rcvbuf,
     if (nread > 0) {
         slogt("udp data received");
     }
+    if (nread <= 0) {
+        free(rcvbuf->base);
+        return;
+    }
 
     char* a;
     a = rcvbuf->base;
@@ -421,50 +489,7 @@ static void on_udp_recv(uv_udp_t* handle, ssize_t nread, const uv_buf_t* rcvbuf,
 
     if (f->simstate == false || simdata->simstatus <= 1 || appstate <= 1)
     {
-        if(f->releasing == false)
-        {
-            f->releasing = true;
-            uv_udp_recv_stop(handle);
-            slogi("releasing devices, please wait");
-            f->uion = false;
-            SimDevice* devices = f->simdevices;
-            int numdevices = f->numdevices;
-
-            // help things spin down
-            simdata->rpms = 0;
-            simdata->velocity = 0;
-            for (int x = 0; x < numdevices; x++)
-            {
-                if (devices[x].initialized == true)
-                {
-                    devices[x].update(&devices[x], simdata);
-                }
-            }
-            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;
-            }
-        }
+        releaseloop(f, simdata, simmap);
     }
 
     slogt("udp free  :%lu %p\n",rcvbuf->len,rcvbuf->base);
@@ -532,6 +557,7 @@ void datacheckcallback(uv_timer_t* handle)
                 udpstart(f->ms, f, simdata, simmap);
                 uv_udp_recv_start(&recv_socket, on_alloc, on_udp_recv);
                 slogt("udp receive loop started");
+                uv_timer_stop(handle);
             }
             else
             {
@@ -539,13 +565,22 @@ void datacheckcallback(uv_timer_t* handle)
                 slogd("starting telemetry mapping at %i fps (%i ms ticks)", f->ms->fps, interval);
                 uv_timer_start(&datamaptimer, shmdatamapcallback, 2000, interval);
             }
-            uv_timer_stop(handle);
+            //uv_timer_start(&datachecktimer, datacheckcallback, 0, 3000);
+        }
+        if(appstate == 2)
+        {
+            SimInfo si = getSim(simdata, simmap, f->ms->force_udp_mode, NULL, false);
+            if(si.isSimOn == false)
+            {
+                appstate = 1;
+                releaseloop(f, simdata, simmap);
+            }
         }
     }
 
     if (appstate == 0)
     {
-        slogi("stopping checking for data");
+        slogi("stopped checking for data");
         uv_timer_stop(handle);
     }
 }
@@ -570,6 +605,10 @@ void cb(uv_poll_t* handle, int status, int events)
     if (appstate == 0)
     {
         slogi("Monocoque is exiting...");
+        uv_udp_recv_stop(&recv_socket);
+        uv_timer_stop(&datamaptimer);
+        uv_timer_stop(&showstatstimer);
+        // at this point these below should be the only active threads
         uv_timer_stop(&datachecktimer);
         uv_poll_stop(handle);
     }
@@ -604,34 +643,43 @@ int monocoque_mainloop(MonocoqueSettings* ms)
     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*) &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);
-    fprintf(stdout, "Searching for sim data... Press q to quit...\n");
-    uv_timer_start(&datachecktimer, datacheckcallback, 1000, 1000);
 
     set_simapi_log_info(simapilib_loginfo);
     set_simapi_log_debug(simapilib_logdebug);
     set_simapi_log_trace(simapilib_logtrace);
 
-
     if (0 != uv_poll_init(uv_default_loop(), poll, 0))
     {
         return 1;
     };
+    uv_timer_init(uv_default_loop(), &datachecktimer);
+    uv_timer_init(uv_default_loop(), &showstatstimer);
+    uv_timer_init(uv_default_loop(), &datamaptimer);
+    slogd("setting initial app state");
+    appstate = 1;
+
+    uv_handle_set_data((uv_handle_t*) &datachecktimer, (void*) baton);
+    uv_handle_set_data((uv_handle_t*) &datamaptimer, (void*) baton);
+    uv_handle_set_data((uv_handle_t*) &showstatstimer, (void*) baton);
+    uv_handle_set_data((uv_handle_t*) &recv_socket, (void*) baton);
+    uv_handle_set_data((uv_handle_t*) poll, (void*) baton);
+
     if (0 != uv_poll_start(poll, UV_READABLE, cb))
     {
         return 2;
     };
+    uv_timer_start(&datachecktimer, datacheckcallback, 1000, 1000);
 
-
-    uv_timer_init(uv_default_loop(), &datamaptimer);
-
+    fprintf(stdout, "Searching for sim data... Press q to quit...\n");
     uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+
+    uv_stop(uv_default_loop());
+    //uv_walk(uv_default_loop(), close_walk_cb, NULL);
+    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+    uv_loop_close(uv_default_loop());
+    uv_library_shutdown();
+    slogi("All threads stopped...");
+
     fprintf(stdout, "\n");
     fflush(stdout);
     tcsetattr(0, TCSANOW, &canonicalmode);
@@ -663,7 +711,9 @@ int tester(SimDevice* devices, int numdevices)
     simdata->car[2] = 'R';
     simdata->car[3] = '\0';
 
-    simdata->gear = MONOCOQUE_GEAR_NEUTRAL;
+    simdata->gear = SIMAPI_GEAR_NEUTRAL;
+    simdata->gearc[0] = 0x4e;
+    simdata->gearc[1] = 0;
     simdata->velocity = 16;
     simdata->rpms = 100;
     simdata->maxrpm = 8000;
@@ -676,7 +726,35 @@ int tester(SimDevice* devices, int numdevices)
     simdata->Yvelocity = 100;
     simdata->Zvelocity = 0;
 
-    sleep(3);
+    sleep(1);
+
+    fprintf(stdout, "Revving rpm from 1000 to 8000 and back\n");
+
+    for (int r = 0; r < 8000; r += 3)
+    {
+        simdata->rpms = 1000 + r;
+        for (int x = 0; x < numdevices; x++)
+        {
+            if (devices[x].initialized == true)
+            {
+                devices[x].update(&devices[x], simdata);
+            }
+        }
+        usleep(1000);
+    }
+
+    for (int r = 0; r < 8000; r += 3)
+    {
+        simdata->rpms = 9000 - r;
+        for (int x = 0; x < numdevices; x++)
+        {
+            if (devices[x].initialized == true)
+            {
+                devices[x].update(&devices[x], simdata);
+            }
+        }
+        usleep(1000);
+    }
 
     fprintf(stdout, "Setting rpms to 1000\n");
     simdata->rpms = 1000;
@@ -689,8 +767,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)
@@ -755,7 +837,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)
@@ -804,8 +887,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)
@@ -826,6 +913,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++)
@@ -838,7 +928,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)
@@ -870,6 +961,9 @@ 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++)
@@ -879,11 +973,22 @@ int tester(SimDevice* devices, int numdevices)
             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 = MONOCOQUE_GEAR_NEUTRAL;
+    simdata->gear = SIMAPI_GEAR_NEUTRAL;
+    simdata->gearc[0] = 0x4e;
     for (int x = 0; x < numdevices; x++)
     {
         if (devices[x].initialized == true)

src/monocoque/helper/confighelper.c

@@ -10,7 +10,7 @@
 #include <libxml/tree.h>
 
 #include "confighelper.h"
-
+#include "dirhelper.h"
 
 #include "../slog/slog.h"
 #include "parameters.h"
@@ -44,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;
@@ -81,32 +86,47 @@ int strtodevsubsubtype(const char* device_subsubtype, DeviceSettings* ds)
     if (strcicmp(device_subsubtype, "CammusC5") == 0)
     {
         ds->dev_subsubtype = SIMDEVSUBTYPE_CAMMUSC5;
-        bool devfound = true;
+        devfound = true;
     }
     if (strcicmp(device_subsubtype, "CammusC12") == 0)
     {
         ds->dev_subsubtype = SIMDEVSUBTYPE_CAMMUSC12;
-        bool devfound = true;
+        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;
-        bool devfound = true;
+        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;
-        bool devfound = true;
+        devfound = true;
     }
     if (strcicmp(device_subsubtype, "CSLELITEV3PEDALS") == 0)
     {
         ds->dev_subsubtype = SIMDEVSUBTYPE_CSLELITEV3PEDALS;
-        bool devfound = true;
+        devfound = true;
     }
     if (strcicmp(device_subsubtype, "SIMAGICP1000PEDALS") == 0)
     {
         ds->dev_subsubtype = SIMDEVSUBTYPE_SIMAGICP1000PEDALS;
-        bool devfound = true;
+        devfound = true;
+    }
+    if (strcicmp(device_subsubtype, "SIMAGICGTNEO") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_SIMAGICGTNEO;
+        devfound = true;
     }
 
     if(devfound == false)
@@ -129,7 +149,7 @@ int strtodevsubtype(const char* device_subtype, DeviceSettings* ds, int simdev)
                 ds->dev_subtype = SIMDEVTYPE_TACHOMETER;
                 break;
             }
-            if (strcicmp(device_subtype, "Wheel") == 0)
+            if (strcicmp(device_subtype, "Wheel") == 0 || strcicmp(device_subtype, "UsbWheel") == 0)
             {
                 ds->dev_subtype = SIMDEVTYPE_USBWHEEL;
                 break;
@@ -145,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;
@@ -233,18 +263,24 @@ int getNumberOfConfigs(const char* config_file_str)
     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");
@@ -255,6 +291,7 @@ int getconfigtouse2(const char* config_file_str, char* car, int sim)
     int j = 0;
     if ( configs == 1 )
     {
+        config_destroy(&cfg);
         return -1;
     }
     int confignum = -1;
@@ -290,6 +327,8 @@ int getconfigtouse2(const char* config_file_str, char* car, int sim)
             break;
         }
     }
+
+    config_destroy(&cfg);
     return confignum;
 }
 
@@ -300,6 +339,7 @@ int getconfigtouse1(const char* config_file_str, char* car, int sim)
     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;
@@ -312,6 +352,7 @@ int getconfigtouse1(const char* config_file_str, char* car, int sim)
     int j = 0;
     if ( configs == 1 )
     {
+        config_destroy(&cfg);
         return -1;
     }
     int confignum = -1;
@@ -358,6 +399,8 @@ int getconfigtouse1(const char* config_file_str, char* car, int sim)
             break;
         }
     }
+
+    config_destroy(&cfg);
     return confignum;
 }
 
@@ -368,8 +411,10 @@ int getconfigtouse(const char* config_file_str, char* car, int sim)
     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");
@@ -380,6 +425,7 @@ int getconfigtouse(const char* config_file_str, char* car, int sim)
     int j = 0;
     if ( configs == 1 )
     {
+        config_destroy(&cfg);
         return 0;
     }
     int confignum = 0;
@@ -426,11 +472,13 @@ int getconfigtouse(const char* config_file_str, char* car, int sim)
             break;
         }
     }
+
+    config_destroy(&cfg);
     return confignum;
 }
 
 
-int loadtachconfig(const char* config_file, DeviceSettings* ds)
+int loadtachconfig(char* config_file, DeviceSettings* ds)
 {
 
 
@@ -527,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;
@@ -557,11 +605,40 @@ 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;
 }
@@ -603,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)
     {
@@ -652,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;
@@ -664,10 +741,13 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
             slogi("reading configured sound device settings");
             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;
+            ds->sounddevsettings.noise = 0;
             if (ds->effect_type == EFFECT_GEARSHIFT)
             {
                 ds->sounddevsettings.duration = .125;
@@ -678,20 +758,26 @@ 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);
+                config_setting_lookup_int(device_settings, "noise", &ds->sounddevsettings.noise);
 
-                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);
+                    }
                 }
 
 
@@ -704,7 +790,7 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
                 }
                 else
                 {
-                    if(strcicmp(temp, "FREQUENCY"))
+                    if(strcicmp(temp, "FREQUENCY") == 0)
                     {
                         ds->sounddevsettings.modulation = SOUND_EFFECT_MODULATION_FREQUENCY;
                         if(ds->sounddevsettings.frequencyMax == 0 || ds->sounddevsettings.frequencyMax < ds->sounddevsettings.frequency)
@@ -717,7 +803,7 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
                             slogi("Effect modulation found, set to FREQUENCY");
                         }
                     }
-                    else if(strcicmp(temp, "AMPLIFY"))
+                    else if(strcicmp(temp, "AMPLIFY") == 0)
                     {
                         ds->sounddevsettings.modulation = SOUND_EFFECT_MODULATION_AMPLIFY;
                         slogi("Effect modulation found, set to AMPLIFY");
@@ -737,6 +823,12 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
         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);
 
@@ -748,20 +840,34 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
             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);
+            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;
 }
 
@@ -793,16 +899,24 @@ int uiloadconfig(const char* config_file_str, int confignum, int configureddevic
             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;
+            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);
-            config_setting_lookup_string(config_device, "config", &device_config_file);
+            found = 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);
+            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);
@@ -826,14 +940,12 @@ int uiloadconfig(const char* config_file_str, int confignum, int configureddevic
 
 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)
     {
@@ -843,6 +955,11 @@ int settingsfree(DeviceSettings ds)
         }
     }
 
+    if(ds.has_config && ds.specific_config_file != NULL)
+    {
+        free(ds.specific_config_file);
+    }
+
     return 0;
 }
 

src/monocoque/helper/confighelper.h

@@ -29,7 +29,9 @@ typedef enum
     SIMDEVTYPE_SIMWIND           = 4,
     SIMDEVTYPE_SERIALHAPTIC      = 5,
     SIMDEVTYPE_USBWHEEL          = 6,
-    SIMDEVTYPE_SERIALWHEEL       = 7
+    SIMDEVTYPE_SERIALWHEEL       = 7,
+    SIMDEVTYPE_SIMLED            = 8,
+    SIMDEVTYPE_ARDUINOCUSTOM     = 9
 }
 DeviceSubType;
 
@@ -40,7 +42,10 @@ typedef enum
     SIMDEVSUBTYPE_CAMMUSC12               = 2,
     SIMDEVSUBTYPE_MOZAR5                  = 3,
     SIMDEVSUBTYPE_CSLELITEV3PEDALS        = 4,
-    SIMDEVSUBTYPE_SIMAGICP1000PEDALS      =5
+    SIMDEVSUBTYPE_SIMAGICP1000PEDALS      = 5,
+    SIMDEVSUBTYPE_SIMAGICGTNEO            = 6,
+    SIMDEVSUBTYPE_MOZA_NEW                = 7,
+    SIMDEVSUBTYPE_LOGITECH_G29            = 8
 }
 DeviceSubSubType;
 
@@ -62,7 +67,8 @@ typedef enum
     EFFECT_GEARSHIFT   = 1,
     EFFECT_ABSBRAKES   = 2,
     EFFECT_TYRESLIP    = 3,
-    EFFECT_TYRELOCK    = 4
+    EFFECT_TYRELOCK    = 4,
+    EFFECT_SUSPENSION  = 5
 }
 VibrationEffectType;
 
@@ -133,6 +139,7 @@ typedef struct
     int verbosity_count;
     int fps;
     bool  force_udp_mode;
+    bool  disable_audio;
     char* tyre_diameter_config;
     char* config_str;
     char* log_filename_str;
@@ -153,8 +160,12 @@ TachometerSettings;
 typedef struct
 {
     char* portdev;
+
     MotorPosition motorsposition;
     int numlights;
+    int numleds;
+    int startled;
+    int endled;
     float ampfactor;
     int baud;
 }
@@ -167,11 +178,14 @@ typedef struct
     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;
+    int noise;
 }
 SoundDeviceSettings;
 
@@ -195,12 +209,13 @@ typedef struct
     VibrationEffectType effect_type;
     MonocoqueTyreIdentifier tyre;
     double threshold;
+    bool has_config;
+    char* specific_config_file;
     // union?
     TachometerSettings tachsettings;
     SerialDeviceSettings serialdevsettings;
     SoundDeviceSettings sounddevsettings;
     USBDeviceSettings usbdevsettings;
-
 }
 DeviceSettings;
 

src/monocoque/helper/dirhelper.c

@@ -48,19 +48,12 @@ 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;
@@ -269,3 +262,30 @@ bool does_file_exist(const char* file)
     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;
+}

src/monocoque/helper/dirhelper.h

@@ -12,5 +12,6 @@ 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

src/monocoque/helper/parameters.c

@@ -46,6 +46,7 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
     p->verbosity_count     = 0;
     p->fps                 = 60;
 
+    p->disable_audio       = false;
     p->udp                 = false;
 
     p->user_specified_config_file = false;
@@ -61,14 +62,15 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
 
     struct arg_rex* cmd1             = arg_rex1(NULL, NULL, "play", NULL, REG_ICASE, NULL);
     struct arg_lit* arg_udp          = arg_lit0("d", "udp", "force udp mode for sims which support it");
-    struct arg_file* arg_conf        = arg_filen(NULL, "uiconf", "<config_file>", 0, 1, NULL);
+    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_strn(NULL, "configdir", "config_dir>", 0, 1, NULL);
+    struct arg_str* arg_confdir      = arg_str1(NULL, NULL, "configdir", "<config_dir>");
     struct arg_int* arg_fps          = arg_int0("f", "fps", "fps", "main data refresh rate");
-    struct arg_lit* help             = arg_litn(NULL,"help", 0, 1, "print this help and exit");
+    struct arg_lit* help1            = arg_litn(NULL,"help", 0, 1, "print this help and exit");
     struct arg_lit* vers             = arg_litn(NULL,"version", 0, 1, "print version information and exit");
     struct arg_end* end1             = arg_end(20);
-    void* argtable1[]                = {cmd1,arg_log,arg_conf,arg_fps,arg_udp,arg_verbosity1,help,vers,end1};
+    void* argtable1[]                = {cmd1,arg_log,arg_conf,arg_fps,arg_udp,arg_audio1,arg_verbosity1,help1,vers,end1};
     int nerrors1;
 
     struct arg_rex* cmd2a            = arg_rex1(NULL, NULL, "config", NULL, REG_ICASE, NULL);
@@ -83,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");
@@ -111,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);
@@ -120,6 +121,14 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
 
     if (nerrors1==0)
     {
+       if (help1->count > 0)
+       {
+           arg_print_errors(stdout,end1,progname);
+           printf("Usage: %s ", progname);
+           arg_print_syntax(stdout,argtable1,"\n");
+           exitcode = E_SUCCESS_AND_EXIT;
+           goto cleanup;
+       }
         p->program_action = A_PLAY;
         p->verbosity_count = arg_verbosity1->count;
 
@@ -132,6 +141,10 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
         {
             p->udp = true;
         }
+        if (arg_audio1->count > 0)
+        {
+            p->disable_audio = true;
+        }
         if(arg_fps->count > 0)
         {
             p->fps = arg_fps->ival[0];
@@ -149,60 +162,75 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
         }
         exitcode = E_SUCCESS_AND_DO;
     }
-    else
-        if (nerrors2==0)
+    else if (nerrors2==0)
+    {
+        if (help2->count > 0)
         {
-            p->program_action = A_CONFIG_TACH;
-            p->max_revs = arg_max_revs->ival[0];
-            p->granularity = 1;
-            if (arg_granularity->ival[0] > 0 && arg_granularity->ival[0] < 5 && arg_granularity->ival[0] != 3)
-            {
-                p->granularity=arg_granularity->ival[0];
-            }
-            p->save_file = *arg_save->filename;
-            p->verbosity_count = arg_verbosity2->count;
-            exitcode = E_SUCCESS_AND_DO;
-        }
-        else if (nerrors3==0)
-        {
-            p->program_action = A_TEST;
-            p->verbosity_count = arg_verbosity3->count;
-            exitcode = E_SUCCESS_AND_DO;
-        }
-        else
-        {
-            if (cmd1->count > 0)
-            {
-                arg_print_errors(stdout,end1,progname);
-                printf("Usage: %s ", progname);
-                arg_print_syntax(stdout,argtable1,"\n");
-            }
-            else
-                if (cmd2a->count > 0)
-                {
-                    arg_print_errors(stdout,end2,progname);
-                    printf("Usage: %s ", progname);
-                    arg_print_syntax(stdout,argtable2,"\n");
-                }
-                else
-                {
-                    if (help->count==0 && vers->count==0)
-                    {
-                        printf("%s: missing <play|config|test> command.\n",progname);
-                        printf("Usage 1: %s ", progname);
-                        arg_print_syntax(stdout,argtable1,"\n");
-                        printf("Usage 2: %s ", progname);
-                        arg_print_syntax(stdout,argtable2,"\n");
-                        printf("Usage 3: %s ", progname);
-                        arg_print_syntax(stdout,argtable3,"\n");
-                    }
-                }
+            arg_print_errors(stdout,end2,progname);
+            printf("Usage: %s ", progname);
+            arg_print_syntax(stdout,argtable2,"\n");
             exitcode = E_SUCCESS_AND_EXIT;
             goto cleanup;
         }
+        p->program_action = A_CONFIG_TACH;
+        p->max_revs = arg_max_revs->ival[0];
+        p->granularity = 1;
+        if (arg_granularity->ival[0] > 0 && arg_granularity->ival[0] < 5 && arg_granularity->ival[0] != 3)
+        {
+            p->granularity=arg_granularity->ival[0];
+        }
+        p->save_file = *arg_save->filename;
+        p->verbosity_count = arg_verbosity2->count;
+        exitcode = E_SUCCESS_AND_DO;
+    }
+    else if (nerrors3==0)
+    {
+        if (help3->count > 0)
+        {
+            arg_print_errors(stdout,end3,progname);
+            printf("Usage: %s ", progname);
+            arg_print_syntax(stdout,argtable3,"\n");
+            exitcode = E_SUCCESS_AND_EXIT;
+            goto cleanup;
+        }
+        p->program_action = A_TEST;
+        p->verbosity_count = arg_verbosity3->count;
+        if (arg_audio2->count > 0)
+        {
+            p->disable_audio = true;
+        }
+        exitcode = E_SUCCESS_AND_DO;
+    }
+    else
+    {
+        // hit this if you typed wrong parameters
+        if (cmd1->count > 0)
+        {
+            arg_print_errors(stdout,end1,progname);
+            printf("Usage: %s ", progname);
+            arg_print_syntax(stdout,argtable1,"\n");
+            exitcode = E_SUCCESS_AND_EXIT;
+            goto cleanup;
+        }
+        if (cmd2a->count > 0)
+        {
+            arg_print_errors(stdout,end2,progname);
+            printf("Usage: %s ", progname);
+            arg_print_syntax(stdout,argtable2,"\n");
+            exitcode = E_SUCCESS_AND_EXIT;
+            goto cleanup;
+        }
+        if (cmd3->count > 0)
+        {
+            arg_print_errors(stdout,end3,progname);
+            printf("Usage: %s ", progname);
+            arg_print_syntax(stdout,argtable3,"\n");
+            exitcode = E_SUCCESS_AND_EXIT;
+            goto cleanup;
+        }
+    }
 
-    // interpret some special cases before we go through trouble of reading the config file
-    if (help->count > 0)
+    if (help0->count > 0 || (cmd3->count == 0 && cmd1->count == 0 && cmd2a->count == 0))
     {
         printf("Usage: %s\n", progname);
         printf("Usage 1: %s ", progname);
@@ -230,5 +258,4 @@ cleanup:
     arg_freetable(argtable2,sizeof(argtable2)/sizeof(argtable2[0]));
     arg_freetable(argtable3,sizeof(argtable3)/sizeof(argtable3[0]));
     return exitcode;
-
 }

src/monocoque/helper/parameters.h

@@ -17,6 +17,7 @@ typedef struct
     SimulatorAPI sim;
     bool simon;
     bool  udp;
+    bool disable_audio;
 
     char* config_filepath;
     char* config_dirpath;

src/monocoque/monocoque.c

@@ -68,6 +68,9 @@ void SetSettingsFromParameters(Parameters* p, MonocoqueSettings* ms, char* confi
     {
         ms->program_action = A_CONFIG_TACH;
     }
+
+    ms->force_udp_mode = false;
+    ms->disable_audio = p->disable_audio;
 }
 
 int main(int argc, char** argv)
@@ -80,19 +83,22 @@ int main(int argc, char** argv)
         fprintf(stderr, "You need a home directory");
         return 0;
     }
-    Parameters* p = malloc(sizeof(Parameters));
+    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;
     }
 
     xdgHandle xdg;
     if(!xdgInitHandle(&xdg))
     {
-        fprintf(stderr, "Function xdgInitHandle() failed, is $HOME unset?");
+        fprintf(stderr, "Function xdgInitHandle() failed, is $HOME unset?\n");
+        goto cleanup_final;
     }
 
     const char* config_home_str = xdgConfigHome(&xdg);
@@ -112,17 +118,21 @@ int main(int argc, char** argv)
         cachedir_str = create_user_dir(home_dir_str, ".cache", PROGRAM_NAME);
     }
 
+    fprintf(stderr, "applying settings\n");
     SetSettingsFromParameters(p, ms, configdir_str, cachedir_str);
-    freeparams(p);
-    free(p);
 
-    //char* config_file_str = ( char* ) malloc(1 + strlen(home_dir_str) + strlen("/.config/") + strlen("monocoque/monocoque.config"));
-
-    size_t diameters_file_sz = snprintf(NULL, 0, "%s/.config/monocoque/diameters.config", home_dir_str);
-    diameters_file_sz += 1;
-    char* diameters_file_str = ( char* ) malloc(diameters_file_sz);
-    snprintf(diameters_file_str, diameters_file_sz, "%s/.config/monocoque/diameters.config", home_dir_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;
@@ -144,11 +154,17 @@ int main(int argc, char** argv)
     {
         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);
+    free(diameters_file_str);
+
     ms->useconfig = 0;
     ms->configcheck = 0;
-    free(diameters_file_str);
+
 
     slogi("Testing monocoque config file: %s", ms->config_str);
     slogd("using diameters file %s %i", ms->tyre_diameter_config, ms->configcheck);
@@ -157,13 +173,17 @@ int main(int argc, char** argv)
     config_setting_t* config_devices = NULL;
     if (!config_read_file(&cfg, ms->config_str))
     {
-        fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
+        sloge("Issue with monocoque config file: %s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
+        fprintf(stderr, "Issue with monocoque config file: %s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
+        config_destroy(&cfg);
+        slog_destroy();
         goto cleanup_final;
     }
     else
     {
-        slogi("Openend monocoque configuration file");
+        slogi("Opened and validated monocoque configuration file");
     }
+    config_destroy(&cfg);
 
 
 
@@ -171,6 +191,7 @@ int main(int argc, char** argv)
     {
         int error = 0;
         SimDevice* tachdev = malloc(sizeof(SimDevice));
+        tachdev->initialized = false;
         SimData* sdata = malloc(sizeof(SimData));
         DeviceSettings* ds = malloc(sizeof(DeviceSettings));
 
@@ -183,6 +204,7 @@ int main(int argc, char** argv)
         else
         {
             int devices = 0;
+
             devices = devinit(tachdev, 1, ds, ms);
             if(devices < 1)
             {
@@ -215,18 +237,22 @@ int main(int argc, char** argv)
 
         int error = 0;
         error = MONOCOQUE_ERROR_NONE;
-        setupsound();
+        //setupsound();
         bool pulseaudio = false;
 
         if (ms->program_action == A_PLAY)
         {
             ms->useconfig = 1;
             slogi("running monocoque in gameloop mode..");
-#ifdef USE_PULSEAUDIO
-            pa_threaded_mainloop_unlock(mainloop);
+//#ifdef USE_PULSEAUDIO
+            //pa_threaded_mainloop_unlock(mainloop);
             pulseaudio = true;
-#endif
+//#endif
 
+            if(ms->disable_audio == false)
+            {
+                setupsound();
+            }
             //error = looper(devices, numdevices, p);
             error = monocoque_mainloop(ms);
             if (error == MONOCOQUE_ERROR_NONE)
@@ -237,16 +263,19 @@ 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;
 
             int configs = getNumberOfConfigs(ms->config_str);
@@ -281,20 +310,20 @@ int main(int argc, char** argv)
                     simdevices[x].free(&simdevices[x]);
                 }
             }
+            if(ms->disable_audio == false)
+            {
+                freesound();
+            }
         }
-        if(pulseaudio == true)
-        {
-            freesound();
-        }
+        slog_destroy();
     }
 
 
 
 cleanup_final:
-
     monocoquesettingsfree(ms);
     free(ms);
+    freeparams(p);
+    free(p);
     exit(0);
 }
-
-

src/monocoque/simulatorapi/CMakeLists.txt

@@ -6,14 +6,39 @@ set(simulatorapi_source_files
   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/include/f12018.h
+  simapi/include/rbrdata.h
+  simapi/include/r3e.h
+  simapi/include/wreckfest2data.h
+  simapi/include/forza.h
   simapi/simmap/basicmap.h
   simapi/simmap/mapacdata.c
   simapi/simmap/mapacdata.h
   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/wreckfest2.h
+  simapi/simapi/f1.h
+  simapi/simapi/rbr.h
+  simapi/simapi/forzadef.h
+  simapi/simapi/r3edef.h
+  simapi/simapi/mapping/acmapper.c
+  simapi/simapi/mapping/rf2mapper.c
+  simapi/simapi/mapping/r3emapper.c
+  simapi/simapi/mapping/pcars2mapper.c
+  simapi/simapi/mapping/dirt2mapper.c
+  simapi/simapi/mapping/scs2mapper.c
+  simapi/simapi/mapping/outgaugemapper.c
+  simapi/simapi/mapping/f12018mapper.c
+  simapi/simapi/mapping/rbrmapper.c
+  simapi/simapi/mapping/wreckfest2mapper.c
+  simapi/simapi/mapping/forzamapper.c
   simapi/simapi/getpid.c
   simapi/simapi/getpid.h
 )

tests/getmem.c

@@ -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;

tests/setmem.c

@@ -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");

tests/simlighttest.c

@@ -1,75 +1,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <string.h>
 #include <libserialport.h>
 #include "../src/arduino/shiftlights/shiftlights.h"
 
-/* Helper function for error handling. */
-int check(enum sp_return result);
-
-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("Opening port.\n");
-    check(sp_open(port, SP_MODE_READ_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));
-
-    ShiftLightsData sd;
-
-
-    int result;
-    unsigned int timeout = 2000;
-    size_t size = sizeof(ShiftLightsData);
-    for( sd.litleds = 0; sd.litleds < 7; sd.litleds++)
-    {
-
-
-
-
-        /* 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. */
-
-
-
-        /* 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 lit leds.\n", size, sd.litleds);
-        }
-        else
-        {
-            printf("Timed out, %d/%d bytes sent.\n", result, size);
-        }
-
-
-        sleep(2);
-    }
-    sd.litleds = 0;
-    result = check(sp_blocking_write(port, &sd, size, timeout));
-
-    check(sp_close(port));
-    sp_free_port(port);
-}
-
 /* Helper function for error handling. */
 int check(enum sp_return result)
 {
@@ -97,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);
+}
+
+

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

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

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

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

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

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

tools/distro/fedora/rpm/fedora.spec

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

tools/monocoque-manager

@@ -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()
+

tools/uninstall.sh

@@ -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 ""
+

udev/69-monocoque.rules

@@ -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"